73 files changed, 5596 insertions, 2741 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 94b8d820c512..56c5ba874623 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -107,7 +107,6 @@ config ACPI_BUTTON
 config ACPI_VIDEO
         tristate "Video"
         depends on X86
-        default y
         help
           This driver implement the ACPI Extensions For Display Adapters
           for integrated graphics devices on motherboard, as specified in
@@ -133,6 +132,12 @@ config ACPI_FAN
           This driver adds support for ACPI fan devices, allowing user-mode 
           applications to perform basic fan control (on, off, status).
 
+config ACPI_DOCK
+        tristate "Dock"
+        depends on EXPERIMENTAL
+        help
+          This driver adds support for ACPI controlled docking stations
+
 config ACPI_PROCESSOR
         tristate "Processor"
         default y
@@ -207,6 +212,7 @@ config ACPI_IBM
 config ACPI_IBM_DOCK
         bool "Legacy Docking Station Support"
         depends on ACPI_IBM
+        depends on ACPI_DOCK=n
         default n
         ---help---
           Allows the ibm_acpi driver to handle docking station events.
@@ -328,7 +334,7 @@ config ACPI_CONTAINER
 config ACPI_HOTPLUG_MEMORY
         tristate "Memory Hotplug"
         depends on ACPI
-        depends on MEMORY_HOTPLUG || X86_64
+        depends on MEMORY_HOTPLUG
         default n
         help
           This driver adds supports for ACPI Memory Hotplug.  This driver
@@ -345,6 +351,17 @@ config ACPI_HOTPLUG_MEMORY
           If one selects "m," this driver can be loaded using the following
           command: 
                 $>modprobe acpi_memhotplug 
+
+config ACPI_SBS
+        tristate "Smart Battery System (EXPERIMENTAL)"
+        depends on X86 && I2C
+        depends on EXPERIMENTAL
+        help
+          This driver adds support for the Smart Battery System.
+          Depends on I2C (Device Drivers ---> I2C support)
+          A "Smart Battery" is quite old and quite rare compared
+          to today's ACPI "Control Method" battery.
+
 endif   # ACPI
 
 endmenu
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index 5984b4f6715a..bce7ca27b429 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -42,6 +42,7 @@ obj-$(CONFIG_ACPI_BATTERY)	+= battery.o
 obj-$(CONFIG_ACPI_BUTTON)       += button.o
 obj-$(CONFIG_ACPI_EC)           += ec.o
 obj-$(CONFIG_ACPI_FAN)          += fan.o
+obj-$(CONFIG_ACPI_DOCK)         += dock.o
 obj-$(CONFIG_ACPI_VIDEO)        += video.o 
 obj-$(CONFIG_ACPI_HOTKEY)       += hotkey.o
 obj-y                           += pci_root.o pci_link.o pci_irq.o pci_bind.o
@@ -57,3 +58,5 @@ obj-$(CONFIG_ACPI_IBM)		+= ibm_acpi.o
 obj-$(CONFIG_ACPI_TOSHIBA)      += toshiba_acpi.o
 obj-y                           += scan.o motherboard.o
 obj-$(CONFIG_ACPI_HOTPLUG_MEMORY)       += acpi_memhotplug.o
+obj-y                           += cm_sbs.o
+obj-$(CONFIG_ACPI_SBS)          += i2c_ec.o sbs.o
diff --git a/drivers/acpi/ac.c b/drivers/acpi/ac.c
index 7839b831df94..11abc7bf777e 100644
--- a/drivers/acpi/ac.c
+++ b/drivers/acpi/ac.c
@@ -50,6 +50,9 @@ ACPI_MODULE_NAME("acpi_ac")
 MODULE_DESCRIPTION(ACPI_AC_DRIVER_NAME);
 MODULE_LICENSE("GPL");
 
+extern struct proc_dir_entry *acpi_lock_ac_dir(void);
+extern void *acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir);
+
 static int acpi_ac_add(struct acpi_device *device);
 static int acpi_ac_remove(struct acpi_device *device, int type);
 static int acpi_ac_open_fs(struct inode *inode, struct file *file);
@@ -65,11 +68,11 @@ static struct acpi_driver acpi_ac_driver = {
 };
 
 struct acpi_ac {
-        acpi_handle handle;
+        struct acpi_device * device;
         unsigned long state;
 };
 
-static struct file_operations acpi_ac_fops = {
+static const struct file_operations acpi_ac_fops = {
         .open = acpi_ac_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -84,20 +87,18 @@ static int acpi_ac_get_state(struct acpi_ac *ac)
 {
         acpi_status status = AE_OK;
 
-        ACPI_FUNCTION_TRACE("acpi_ac_get_state");
 
         if (!ac)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
-        status = acpi_evaluate_integer(ac->handle, "_PSR", NULL, &ac->state);
+        status = acpi_evaluate_integer(ac->device->handle, "_PSR", NULL, &ac->state);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error reading AC Adapter state\n"));
+                ACPI_EXCEPTION((AE_INFO, status, "Error reading AC Adapter state"));
                 ac->state = ACPI_AC_STATUS_UNKNOWN;
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 /* --------------------------------------------------------------------------
@@ -110,14 +111,13 @@ static int acpi_ac_seq_show(struct seq_file *seq, void *offset)
 {
         struct acpi_ac *ac = (struct acpi_ac *)seq->private;
 
-        ACPI_FUNCTION_TRACE("acpi_ac_seq_show");
 
         if (!ac)
-                return_VALUE(0);
+                return 0;
 
         if (acpi_ac_get_state(ac)) {
                 seq_puts(seq, "ERROR: Unable to read AC Adapter state\n");
-                return_VALUE(0);
+                return 0;
         }
 
         seq_puts(seq, "state:                   ");
@@ -133,7 +133,7 @@ static int acpi_ac_seq_show(struct seq_file *seq, void *offset)
                 break;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_ac_open_fs(struct inode *inode, struct file *file)
@@ -145,13 +145,12 @@ static int acpi_ac_add_fs(struct acpi_device *device)
 {
         struct proc_dir_entry *entry = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_ac_add_fs");
 
         if (!acpi_device_dir(device)) {
                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
                                                      acpi_ac_dir);
                 if (!acpi_device_dir(device))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
                 acpi_device_dir(device)->owner = THIS_MODULE;
         }
 
@@ -159,21 +158,18 @@ static int acpi_ac_add_fs(struct acpi_device *device)
         entry = create_proc_entry(ACPI_AC_FILE_STATE,
                                   S_IRUGO, acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_AC_FILE_STATE));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_ac_fops;
                 entry->data = acpi_driver_data(device);
                 entry->owner = THIS_MODULE;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_ac_remove_fs(struct acpi_device *device)
 {
-        ACPI_FUNCTION_TRACE("acpi_ac_remove_fs");
 
         if (acpi_device_dir(device)) {
                 remove_proc_entry(ACPI_AC_FILE_STATE, acpi_device_dir(device));
@@ -182,7 +178,7 @@ static int acpi_ac_remove_fs(struct acpi_device *device)
                 acpi_device_dir(device) = NULL;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 /* --------------------------------------------------------------------------
@@ -194,16 +190,15 @@ static void acpi_ac_notify(acpi_handle handle, u32 event, void *data)
         struct acpi_ac *ac = (struct acpi_ac *)data;
         struct acpi_device *device = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_ac_notify");
 
         if (!ac)
-                return_VOID;
-
-        if (acpi_bus_get_device(ac->handle, &device))
-                return_VOID;
+                return;
 
+        device = ac->device;
         switch (event) {
         case ACPI_AC_NOTIFY_STATUS:
+        case ACPI_NOTIFY_BUS_CHECK:
+        case ACPI_NOTIFY_DEVICE_CHECK:
                 acpi_ac_get_state(ac);
                 acpi_bus_generate_event(device, event, (u32) ac->state);
                 break;
@@ -213,7 +208,7 @@ static void acpi_ac_notify(acpi_handle handle, u32 event, void *data)
                 break;
         }
 
-        return_VOID;
+        return;
 }
 
 static int acpi_ac_add(struct acpi_device *device)
@@ -222,17 +217,16 @@ static int acpi_ac_add(struct acpi_device *device)
         acpi_status status = AE_OK;
         struct acpi_ac *ac = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_ac_add");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         ac = kmalloc(sizeof(struct acpi_ac), GFP_KERNEL);
         if (!ac)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(ac, 0, sizeof(struct acpi_ac));
 
-        ac->handle = device->handle;
+        ac->device = device;
         strcpy(acpi_device_name(device), ACPI_AC_DEVICE_NAME);
         strcpy(acpi_device_class(device), ACPI_AC_CLASS);
         acpi_driver_data(device) = ac;
@@ -245,12 +239,10 @@ static int acpi_ac_add(struct acpi_device *device)
         if (result)
                 goto end;
 
-        status = acpi_install_notify_handler(ac->handle,
-                                             ACPI_DEVICE_NOTIFY, acpi_ac_notify,
+        status = acpi_install_notify_handler(device->handle,
+                                             ACPI_ALL_NOTIFY, acpi_ac_notify,
                                              ac);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error installing notify handler\n"));
                 result = -ENODEV;
                 goto end;
         }
@@ -265,7 +257,7 @@ static int acpi_ac_add(struct acpi_device *device)
                 kfree(ac);
         }
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_ac_remove(struct acpi_device *device, int type)
@@ -273,55 +265,50 @@ static int acpi_ac_remove(struct acpi_device *device, int type)
         acpi_status status = AE_OK;
         struct acpi_ac *ac = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_ac_remove");
 
         if (!device || !acpi_driver_data(device))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         ac = (struct acpi_ac *)acpi_driver_data(device);
 
-        status = acpi_remove_notify_handler(ac->handle,
-                                            ACPI_DEVICE_NOTIFY, acpi_ac_notify);
-        if (ACPI_FAILURE(status))
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error removing notify handler\n"));
+        status = acpi_remove_notify_handler(device->handle,
+                                            ACPI_ALL_NOTIFY, acpi_ac_notify);
 
         acpi_ac_remove_fs(device);
 
         kfree(ac);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int __init acpi_ac_init(void)
 {
-        int result = 0;
+        int result;
 
-        ACPI_FUNCTION_TRACE("acpi_ac_init");
+        if (acpi_disabled)
+                return -ENODEV;
 
-        acpi_ac_dir = proc_mkdir(ACPI_AC_CLASS, acpi_root_dir);
+        acpi_ac_dir = acpi_lock_ac_dir();
         if (!acpi_ac_dir)
-                return_VALUE(-ENODEV);
-        acpi_ac_dir->owner = THIS_MODULE;
+                return -ENODEV;
 
         result = acpi_bus_register_driver(&acpi_ac_driver);
         if (result < 0) {
-                remove_proc_entry(ACPI_AC_CLASS, acpi_root_dir);
-                return_VALUE(-ENODEV);
+                acpi_unlock_ac_dir(acpi_ac_dir);
+                return -ENODEV;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static void __exit acpi_ac_exit(void)
 {
-        ACPI_FUNCTION_TRACE("acpi_ac_exit");
 
         acpi_bus_unregister_driver(&acpi_ac_driver);
 
-        remove_proc_entry(ACPI_AC_CLASS, acpi_root_dir);
+        acpi_unlock_ac_dir(acpi_ac_dir);
 
-        return_VOID;
+        return;
 }
 
 module_init(acpi_ac_init);
diff --git a/drivers/acpi/acpi_memhotplug.c b/drivers/acpi/acpi_memhotplug.c
index e0a95ba72371..1dda370f402b 100644
--- a/drivers/acpi/acpi_memhotplug.c
+++ b/drivers/acpi/acpi_memhotplug.c
@@ -57,6 +57,7 @@ MODULE_LICENSE("GPL");
 
 static int acpi_memory_device_add(struct acpi_device *device);
 static int acpi_memory_device_remove(struct acpi_device *device, int type);
+static int acpi_memory_device_start(struct acpi_device *device);
 
 static struct acpi_driver acpi_memory_device_driver = {
         .name = ACPI_MEMORY_DEVICE_DRIVER_NAME,
@@ -65,48 +66,82 @@ static struct acpi_driver acpi_memory_device_driver = {
         .ops = {
                 .add = acpi_memory_device_add,
                 .remove = acpi_memory_device_remove,
+                .start = acpi_memory_device_start,
                 },
 };
 
-struct acpi_memory_device {
-        acpi_handle handle;
-        unsigned int state;     /* State of the memory device */
-        unsigned short caching; /* memory cache attribute */
-        unsigned short write_protect;   /* memory read/write attribute */
+struct acpi_memory_info {
+        struct list_head list;
         u64 start_addr;         /* Memory Range start physical addr */
         u64 length;             /* Memory Range length */
+        unsigned short caching; /* memory cache attribute */
+        unsigned short write_protect;   /* memory read/write attribute */
+        unsigned int enabled:1;
 };
 
+struct acpi_memory_device {
+        struct acpi_device * device;
+        unsigned int state;     /* State of the memory device */
+        struct list_head res_list;
+};
+
+static acpi_status
+acpi_memory_get_resource(struct acpi_resource *resource, void *context)
+{
+        struct acpi_memory_device *mem_device = context;
+        struct acpi_resource_address64 address64;
+        struct acpi_memory_info *info, *new;
+        acpi_status status;
+
+        status = acpi_resource_to_address64(resource, &address64);
+        if (ACPI_FAILURE(status) ||
+            (address64.resource_type != ACPI_MEMORY_RANGE))
+                return AE_OK;
+
+        list_for_each_entry(info, &mem_device->res_list, list) {
+                /* Can we combine the resource range information? */
+                if ((info->caching == address64.info.mem.caching) &&
+                    (info->write_protect == address64.info.mem.write_protect) &&
+                    (info->start_addr + info->length == address64.minimum)) {
+                        info->length += address64.address_length;
+                        return AE_OK;
+                }
+        }
+
+        new = kzalloc(sizeof(struct acpi_memory_info), GFP_KERNEL);
+        if (!new)
+                return AE_ERROR;
+
+        INIT_LIST_HEAD(&new->list);
+        new->caching = address64.info.mem.caching;
+        new->write_protect = address64.info.mem.write_protect;
+        new->start_addr = address64.minimum;
+        new->length = address64.address_length;
+        list_add_tail(&new->list, &mem_device->res_list);
+
+        return AE_OK;
+}
+
 static int
 acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
 {
         acpi_status status;
-        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
-        struct acpi_resource *resource = NULL;
-        struct acpi_resource_address64 address64;
+        struct acpi_memory_info *info, *n;
 
-        ACPI_FUNCTION_TRACE("acpi_memory_get_device_resources");
 
-        /* Get the range from the _CRS */
-        status = acpi_get_current_resources(mem_device->handle, &buffer);
-        if (ACPI_FAILURE(status))
-                return_VALUE(-EINVAL);
+        if (!list_empty(&mem_device->res_list))
+                return 0;
 
-        resource = (struct acpi_resource *)buffer.pointer;
-        status = acpi_resource_to_address64(resource, &address64);
-        if (ACPI_SUCCESS(status)) {
-                if (address64.resource_type == ACPI_MEMORY_RANGE) {
-                        /* Populate the structure */
-                        mem_device->caching = address64.info.mem.caching;
-                        mem_device->write_protect =
-                            address64.info.mem.write_protect;
-                        mem_device->start_addr = address64.minimum;
-                        mem_device->length = address64.address_length;
-                }
+        status = acpi_walk_resources(mem_device->device->handle, METHOD_NAME__CRS,
+                                     acpi_memory_get_resource, mem_device);
+        if (ACPI_FAILURE(status)) {
+                list_for_each_entry_safe(info, n, &mem_device->res_list, list)
+                        kfree(info);
+                INIT_LIST_HEAD(&mem_device->res_list);
+                return -EINVAL;
         }
 
-        acpi_os_free(buffer.pointer);
-        return_VALUE(0);
+        return 0;
 }
 
 static int
@@ -118,23 +153,21 @@ acpi_memory_get_device(acpi_handle handle,
         struct acpi_device *device = NULL;
         struct acpi_device *pdevice = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_memory_get_device");
 
         if (!acpi_bus_get_device(handle, &device) && device)
                 goto end;
 
         status = acpi_get_parent(handle, &phandle);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error in acpi_get_parent\n"));
-                return_VALUE(-EINVAL);
+                ACPI_EXCEPTION((AE_INFO, status, "Cannot find acpi parent"));
+                return -EINVAL;
         }
 
         /* Get the parent device */
         status = acpi_bus_get_device(phandle, &pdevice);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error in acpi_bus_get_device\n"));
-                return_VALUE(-EINVAL);
+                ACPI_EXCEPTION((AE_INFO, status, "Cannot get acpi bus device"));
+                return -EINVAL;
         }
 
         /*
@@ -143,30 +176,29 @@ acpi_memory_get_device(acpi_handle handle,
          */
         status = acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error in acpi_bus_add\n"));
-                return_VALUE(-EINVAL);
+                ACPI_EXCEPTION((AE_INFO, status, "Cannot add acpi bus"));
+                return -EINVAL;
         }
 
       end:
         *mem_device = acpi_driver_data(device);
         if (!(*mem_device)) {
                 printk(KERN_ERR "\n driver data not found");
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
 {
         unsigned long current_status;
 
-        ACPI_FUNCTION_TRACE("acpi_memory_check_device");
 
         /* Get device present/absent information from the _STA */
-        if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->handle, "_STA",
+        if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->device->handle, "_STA",
                                                NULL, &current_status)))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         /*
          * Check for device status. Device should be
          * present/enabled/functioning.
@@ -174,35 +206,48 @@ static int acpi_memory_check_device(struct acpi_memory_device *mem_device)
         if (!((current_status & ACPI_MEMORY_STA_PRESENT)
               && (current_status & ACPI_MEMORY_STA_ENABLED)
               && (current_status & ACPI_MEMORY_STA_FUNCTIONAL)))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
 {
-        int result;
+        int result, num_enabled = 0;
+        struct acpi_memory_info *info;
+        int node;
 
-        ACPI_FUNCTION_TRACE("acpi_memory_enable_device");
 
         /* Get the range from the _CRS */
         result = acpi_memory_get_device_resources(mem_device);
         if (result) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "\nget_device_resources failed\n"));
+                printk(KERN_ERR PREFIX "get_device_resources failed\n");
                 mem_device->state = MEMORY_INVALID_STATE;
                 return result;
         }
 
+        node = acpi_get_node(mem_device->device->handle);
         /*
          * Tell the VM there is more memory here...
          * Note: Assume that this function returns zero on success
+         * We don't have memory-hot-add rollback function,now.
+         * (i.e. memory-hot-remove function)
          */
-        result = add_memory(mem_device->start_addr, mem_device->length);
-        if (result) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "\nadd_memory failed\n"));
+        list_for_each_entry(info, &mem_device->res_list, list) {
+                if (info->enabled) { /* just sanity check...*/
+                        num_enabled++;
+                        continue;
+                }
+                result = add_memory(node, info->start_addr, info->length);
+                if (result)
+                        continue;
+                info->enabled = 1;
+                num_enabled++;
+        }
+        if (!num_enabled) {
+                printk(KERN_ERR PREFIX "add_memory failed\n");
                 mem_device->state = MEMORY_INVALID_STATE;
-                return result;
+                return -EINVAL;
         }
 
         return result;
@@ -215,57 +260,55 @@ static int acpi_memory_powerdown_device(struct acpi_memory_device *mem_device)
         union acpi_object arg;
         unsigned long current_status;
 
-        ACPI_FUNCTION_TRACE("acpi_memory_powerdown_device");
 
         /* Issue the _EJ0 command */
         arg_list.count = 1;
         arg_list.pointer = &arg;
         arg.type = ACPI_TYPE_INTEGER;
         arg.integer.value = 1;
-        status = acpi_evaluate_object(mem_device->handle,
+        status = acpi_evaluate_object(mem_device->device->handle,
                                       "_EJ0", &arg_list, NULL);
         /* Return on _EJ0 failure */
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "_EJ0 failed.\n"));
-                return_VALUE(-ENODEV);
+                ACPI_EXCEPTION((AE_INFO, status, "_EJ0 failed"));
+                return -ENODEV;
         }
 
         /* Evalute _STA to check if the device is disabled */
-        status = acpi_evaluate_integer(mem_device->handle, "_STA",
+        status = acpi_evaluate_integer(mem_device->device->handle, "_STA",
                                        NULL, &current_status);
         if (ACPI_FAILURE(status))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         /* Check for device status.  Device should be disabled */
         if (current_status & ACPI_MEMORY_STA_ENABLED)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_memory_disable_device(struct acpi_memory_device *mem_device)
 {
         int result;
-        u64 start = mem_device->start_addr;
-        u64 len = mem_device->length;
+        struct acpi_memory_info *info, *n;
 
-        ACPI_FUNCTION_TRACE("acpi_memory_disable_device");
 
         /*
          * Ask the VM to offline this memory range.
          * Note: Assume that this function returns zero on success
          */
-        result = remove_memory(start, len);
-        if (result) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Hot-Remove failed.\n"));
-                return_VALUE(result);
+        list_for_each_entry_safe(info, n, &mem_device->res_list, list) {
+                if (info->enabled) {
+                        result = remove_memory(info->start_addr, info->length);
+                        if (result)
+                                return result;
+                }
+                kfree(info);
         }
 
         /* Power-off and eject the device */
         result = acpi_memory_powerdown_device(mem_device);
         if (result) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Device Power Down failed.\n"));
                 /* Set the status of the device to invalid */
                 mem_device->state = MEMORY_INVALID_STATE;
                 return result;
@@ -280,7 +323,6 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
         struct acpi_memory_device *mem_device;
         struct acpi_device *device;
 
-        ACPI_FUNCTION_TRACE("acpi_memory_device_notify");
 
         switch (event) {
         case ACPI_NOTIFY_BUS_CHECK:
@@ -292,15 +334,14 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                           "\nReceived DEVICE CHECK notification for device\n"));
                 if (acpi_memory_get_device(handle, &mem_device)) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Error in finding driver data\n"));
-                        return_VOID;
+                        printk(KERN_ERR PREFIX "Cannot find driver data\n");
+                        return;
                 }
 
                 if (!acpi_memory_check_device(mem_device)) {
                         if (acpi_memory_enable_device(mem_device))
-                                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                                  "Error in acpi_memory_enable_device\n"));
+                                printk(KERN_ERR PREFIX
+                                            "Cannot enable memory device\n");
                 }
                 break;
         case ACPI_NOTIFY_EJECT_REQUEST:
@@ -308,14 +349,12 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
                                   "\nReceived EJECT REQUEST notification for device\n"));
 
                 if (acpi_bus_get_device(handle, &device)) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Device doesn't exist\n"));
+                        printk(KERN_ERR PREFIX "Device doesn't exist\n");
                         break;
                 }
                 mem_device = acpi_driver_data(device);
                 if (!mem_device) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Driver Data is NULL\n"));
+                        printk(KERN_ERR PREFIX "Driver Data is NULL\n");
                         break;
                 }
 
@@ -326,8 +365,8 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
                  *      with generic sysfs driver
                  */
                 if (acpi_memory_disable_device(mem_device))
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Error in acpi_memory_disable_device\n"));
+                        printk(KERN_ERR PREFIX
+                                    "Disable memory device\n");
                 /*
                  * TBD: Invoke acpi_bus_remove to cleanup data structures
                  */
@@ -338,7 +377,7 @@ static void acpi_memory_device_notify(acpi_handle handle, u32 event, void *data)
                 break;
         }
 
-        return_VOID;
+        return;
 }
 
 static int acpi_memory_device_add(struct acpi_device *device)
@@ -346,17 +385,17 @@ static int acpi_memory_device_add(struct acpi_device *device)
         int result;
         struct acpi_memory_device *mem_device = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_memory_device_add");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         mem_device = kmalloc(sizeof(struct acpi_memory_device), GFP_KERNEL);
         if (!mem_device)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(mem_device, 0, sizeof(struct acpi_memory_device));
 
-        mem_device->handle = device->handle;
+        INIT_LIST_HEAD(&mem_device->res_list);
+        mem_device->device = device;
         sprintf(acpi_device_name(device), "%s", ACPI_MEMORY_DEVICE_NAME);
         sprintf(acpi_device_class(device), "%s", ACPI_MEMORY_DEVICE_CLASS);
         acpi_driver_data(device) = mem_device;
@@ -365,7 +404,7 @@ static int acpi_memory_device_add(struct acpi_device *device)
         result = acpi_memory_get_device_resources(mem_device);
         if (result) {
                 kfree(mem_device);
-                return_VALUE(result);
+                return result;
         }
 
         /* Set the device state */
@@ -373,22 +412,38 @@ static int acpi_memory_device_add(struct acpi_device *device)
 
         printk(KERN_INFO "%s \n", acpi_device_name(device));
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_memory_device_remove(struct acpi_device *device, int type)
 {
         struct acpi_memory_device *mem_device = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_memory_device_remove");
 
         if (!device || !acpi_driver_data(device))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         mem_device = (struct acpi_memory_device *)acpi_driver_data(device);
         kfree(mem_device);
 
-        return_VALUE(0);
+        return 0;
+}
+
+static int acpi_memory_device_start (struct acpi_device *device)
+{
+        struct acpi_memory_device *mem_device;
+        int result = 0;
+
+        mem_device = acpi_driver_data(device);
+
+        if (!acpi_memory_check_device(mem_device)) {
+                /* call add_memory func */
+                result = acpi_memory_enable_device(mem_device);
+                if (result)
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                "Error in acpi_memory_enable_device\n"));
+        }
+        return result;
 }
 
 /*
@@ -401,16 +456,15 @@ static acpi_status is_memory_device(acpi_handle handle)
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         struct acpi_device_info *info;
 
-        ACPI_FUNCTION_TRACE("is_memory_device");
 
         status = acpi_get_object_info(handle, &buffer);
         if (ACPI_FAILURE(status))
-                return_ACPI_STATUS(AE_ERROR);
+                return status;
 
         info = buffer.pointer;
         if (!(info->valid & ACPI_VALID_HID)) {
-                acpi_os_free(buffer.pointer);
-                return_ACPI_STATUS(AE_ERROR);
+                kfree(buffer.pointer);
+                return AE_ERROR;
         }
 
         hardware_id = info->hardware_id.value;
@@ -418,8 +472,8 @@ static acpi_status is_memory_device(acpi_handle handle)
             (strcmp(hardware_id, ACPI_MEMORY_DEVICE_HID)))
                 status = AE_ERROR;
 
-        acpi_os_free(buffer.pointer);
-        return_ACPI_STATUS(status);
+        kfree(buffer.pointer);
+        return status;
 }
 
 static acpi_status
@@ -428,21 +482,15 @@ acpi_memory_register_notify_handler(acpi_handle handle,
 {
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("acpi_memory_register_notify_handler");
 
         status = is_memory_device(handle);
         if (ACPI_FAILURE(status))
-                return_ACPI_STATUS(AE_OK);      /* continue */
+                return AE_OK;   /* continue */
 
         status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
                                              acpi_memory_device_notify, NULL);
-        if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error installing notify handler\n"));
-                return_ACPI_STATUS(AE_OK);      /* continue */
-        }
-
-        return_ACPI_STATUS(status);
+        /* continue */
+        return AE_OK;
 }
 
 static acpi_status
@@ -451,22 +499,16 @@ acpi_memory_deregister_notify_handler(acpi_handle handle,
 {
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("acpi_memory_deregister_notify_handler");
 
         status = is_memory_device(handle);
         if (ACPI_FAILURE(status))
-                return_ACPI_STATUS(AE_OK);      /* continue */
+                return AE_OK;   /* continue */
 
         status = acpi_remove_notify_handler(handle,
                                             ACPI_SYSTEM_NOTIFY,
                                             acpi_memory_device_notify);
-        if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error removing notify handler\n"));
-                return_ACPI_STATUS(AE_OK);      /* continue */
-        }
 
-        return_ACPI_STATUS(status);
+        return AE_OK;   /* continue */
 }
 
 static int __init acpi_memory_device_init(void)
@@ -474,12 +516,11 @@ static int __init acpi_memory_device_init(void)
         int result;
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("acpi_memory_device_init");
 
         result = acpi_bus_register_driver(&acpi_memory_device_driver);
 
         if (result < 0)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
                                      ACPI_UINT32_MAX,
@@ -487,19 +528,18 @@ static int __init acpi_memory_device_init(void)
                                      NULL, NULL);
 
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "walk_namespace failed\n"));
+                ACPI_EXCEPTION((AE_INFO, status, "walk_namespace failed"));
                 acpi_bus_unregister_driver(&acpi_memory_device_driver);
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static void __exit acpi_memory_device_exit(void)
 {
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("acpi_memory_device_exit");
 
         /*
          * Adding this to un-install notification handlers for all the device
@@ -511,11 +551,11 @@ static void __exit acpi_memory_device_exit(void)
                                      NULL, NULL);
 
         if (ACPI_FAILURE(status))
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "walk_namespace failed\n"));
+                ACPI_EXCEPTION((AE_INFO, status, "walk_namespace failed"));
 
         acpi_bus_unregister_driver(&acpi_memory_device_driver);
 
-        return_VOID;
+        return;
 }
 
 module_init(acpi_memory_device_init);
diff --git a/drivers/acpi/asus_acpi.c b/drivers/acpi/asus_acpi.c
index 839f423d738d..e9ee4c52a5f6 100644
--- a/drivers/acpi/asus_acpi.c
+++ b/drivers/acpi/asus_acpi.c
@@ -2,7 +2,7 @@
  *  asus_acpi.c - Asus Laptop ACPI Extras
  *
  *
- *  Copyright (C) 2002, 2003, 2004 Julien Lerouge, Karol Kozimor
+ *  Copyright (C) 2002-2005 Julien Lerouge, 2003-2006 Karol Kozimor
  *
  *  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
@@ -26,11 +26,8 @@
  *  Pontus Fuchs   - Helper functions, cleanup
  *  Johann Wiesner - Small compile fixes
  *  John Belmonte  - ACPI code for Toshiba laptop was a good starting point.
+ *  Éric Burghard  - LED display support for W1N
  *
- *  TODO:
- *  add Fn key status
- *  Add mode selection on module loading (parameter) -> still necessary?
- *  Complete display switching -- may require dirty hacks or calling _DOS?
  */
 
 #include <linux/kernel.h>
@@ -42,12 +39,14 @@
 #include <acpi/acpi_bus.h>
 #include <asm/uaccess.h>
 
-#define ASUS_ACPI_VERSION "0.29"
+#define ASUS_ACPI_VERSION "0.30"
 
 #define PROC_ASUS       "asus"  //the directory
 #define PROC_MLED       "mled"
 #define PROC_WLED       "wled"
 #define PROC_TLED       "tled"
+#define PROC_BT         "bluetooth"
+#define PROC_LEDD       "ledd"
 #define PROC_INFO       "info"
 #define PROC_LCD        "lcd"
 #define PROC_BRN        "brn"
@@ -67,9 +66,10 @@
 /*
  * Flags for hotk status
  */
-#define MLED_ON     0x01        //is MLED ON ?
-#define WLED_ON     0x02
-#define TLED_ON     0x04
+#define MLED_ON     0x01        //mail LED
+#define WLED_ON     0x02        //wireless LED
+#define TLED_ON     0x04        //touchpad LED
+#define BT_ON       0x08        //internal Bluetooth
 
 MODULE_AUTHOR("Julien Lerouge, Karol Kozimor");
 MODULE_DESCRIPTION(ACPI_HOTK_NAME);
@@ -92,7 +92,10 @@ struct model_data {
         char *wled_status;      //node to handle wled reading_______A
         char *mt_tled;          //method to handle tled_____________R
         char *tled_status;      //node to handle tled reading_______A
-        char *mt_lcd_switch;    //method to turn LCD ON/OFF_________A
+        char *mt_ledd;          //method to handle LED display______R
+        char *mt_bt_switch;     //method to switch Bluetooth on/off_R
+        char *bt_status;        //no model currently supports this__?
+        char *mt_lcd_switch;    //method to turn LCD on/off_________A
         char *lcd_status;       //node to read LCD panel state______A
         char *brightness_up;    //method to set brightness up_______A
         char *brightness_down;  //guess what ?______________________A
@@ -111,27 +114,31 @@ struct asus_hotk {
         struct acpi_device *device;     //the device we are in
         acpi_handle handle;     //the handle of the hotk device
         char status;            //status of the hotk, for LEDs, ...
+        u32 ledd_status;        //status of the LED display
         struct model_data *methods;     //methods available on the laptop
         u8 brightness;          //brightness level
         enum {
                 A1x = 0,        //A1340D, A1300F
                 A2x,            //A2500H
+                A4G,            //A4700G
                 D1x,            //D1
                 L2D,            //L2000D
                 L3C,            //L3800C
                 L3D,            //L3400D
-                L3H,            //L3H, but also L2000E
+                L3H,            //L3H, L2000E, L5D
                 L4R,            //L4500R
                 L5x,            //L5800C 
                 L8L,            //L8400L
                 M1A,            //M1300A
                 M2E,            //M2400E, L4400L
-                M6N,            //M6800N
-                M6R,            //M6700R
+                M6N,            //M6800N, W3400N
+                M6R,            //M6700R, A3000G
                 P30,            //Samsung P30
                 S1x,            //S1300A, but also L1400B and M2400A (L84F)
                 S2x,            //S200 (J1 reported), Victor MP-XP7210
-                xxN,            //M2400N, M3700N, M5200N, S1300N, S5200N, W1OOON
+                W1N,            //W1000N
+                W5A,            //W5A
+                xxN,            //M2400N, M3700N, M5200N, M6800N, S1300N, S5200N
                 //(Centrino)
                 END_MODEL
         } model;                //Models currently supported
@@ -149,17 +156,8 @@ struct asus_hotk {
 
 static struct model_data model_conf[END_MODEL] = {
         /*
-         * Those pathnames are relative to the HOTK / ATKD device :
-         *       - mt_mled
-         *       - mt_wled
-         *       - brightness_set
-         *       - brightness_get
-         *       - display_set
-         *       - display_get
-         *
          * TODO I have seen a SWBX and AIBX method on some models, like L1400B,
          * it seems to be a kind of switch, but what for ?
-         *
          */
 
         {
@@ -184,6 +182,16 @@ static struct model_data model_conf[END_MODEL] = {
          .display_get = "\\INFB"},
 
         {
+         .name = "A4G",
+         .mt_mled = "MLED",
+/* WLED present, but not controlled by ACPI */
+         .mt_lcd_switch = xxN_PREFIX "_Q10",
+         .brightness_set = "SPLV",
+         .brightness_get = "GPLV",
+         .display_set = "SDSP",
+         .display_get = "\\ADVG"},
+
+        {
          .name = "D1x",
          .mt_mled = "MLED",
          .mt_lcd_switch = "\\Q0D",
@@ -302,7 +310,8 @@ static struct model_data model_conf[END_MODEL] = {
          .brightness_set = "SPLV",
          .brightness_get = "GPLV",
          .display_set = "SDSP",
-         .display_get = "\\_SB.PCI0.P0P1.VGA.GETD"},
+         .display_get = "\\SSTE"},
+
         {
          .name = "M6R",
          .mt_mled = "MLED",
@@ -312,7 +321,7 @@ static struct model_data model_conf[END_MODEL] = {
          .brightness_set = "SPLV",
          .brightness_get = "GPLV",
          .display_set = "SDSP",
-         .display_get = "\\SSTE"},
+         .display_get = "\\_SB.PCI0.P0P1.VGA.GETD"},
 
         {
          .name = "P30",
@@ -345,6 +354,28 @@ static struct model_data model_conf[END_MODEL] = {
          .brightness_down = S2x_PREFIX "_Q0A"},
 
         {
+         .name = "W1N",
+         .mt_mled = "MLED",
+         .mt_wled = "WLED",
+         .mt_ledd = "SLCM",
+         .mt_lcd_switch = xxN_PREFIX "_Q10",
+         .lcd_status = "\\BKLT",
+         .brightness_set = "SPLV",
+         .brightness_get = "GPLV",
+         .display_set = "SDSP",
+         .display_get = "\\ADVG"},
+
+        {
+         .name = "W5A",
+         .mt_bt_switch = "BLED",
+         .mt_wled = "WLED",
+         .mt_lcd_switch = xxN_PREFIX "_Q10",
+         .brightness_set = "SPLV",
+         .brightness_get = "GPLV",
+         .display_set = "SDSP",
+         .display_get = "\\ADVG"},
+
+        {
          .name = "xxN",
          .mt_mled = "MLED",
 /* WLED present, but not controlled by ACPI */
@@ -563,6 +594,36 @@ proc_write_mled(struct file *file, const char __user * buffer,
 }
 
 /*
+ * Proc handlers for LED display
+ */
+static int
+proc_read_ledd(char *page, char **start, off_t off, int count, int *eof,
+               void *data)
+{
+        return sprintf(page, "0x%08x\n", hotk->ledd_status);
+}
+
+static int
+proc_write_ledd(struct file *file, const char __user * buffer,
+                unsigned long count, void *data)
+{
+        int value;
+
+        count = parse_arg(buffer, count, &value);
+        if (count > 0) {
+                if (!write_acpi_int
+                    (hotk->handle, hotk->methods->mt_ledd, value, NULL))
+                        printk(KERN_WARNING
+                               "Asus ACPI: LED display write failed\n");
+                else
+                        hotk->ledd_status = (u32) value;
+        } else if (count < 0)
+                printk(KERN_WARNING "Asus ACPI: Error reading user input\n");
+
+        return count;
+}
+
+/*
  * Proc handlers for WLED
  */
 static int
@@ -581,6 +642,25 @@ proc_write_wled(struct file *file, const char __user * buffer,
 }
 
 /*
+ * Proc handlers for Bluetooth
+ */
+static int
+proc_read_bluetooth(char *page, char **start, off_t off, int count, int *eof,
+                    void *data)
+{
+        return sprintf(page, "%d\n", read_led(hotk->methods->bt_status, BT_ON));
+}
+
+static int
+proc_write_bluetooth(struct file *file, const char __user * buffer,
+                     unsigned long count, void *data)
+{
+        /* Note: mt_bt_switch controls both internal Bluetooth adapter's 
+           presence and its LED */
+        return write_led(buffer, count, hotk->methods->mt_bt_switch, BT_ON, 0);
+}
+
+/*
  * Proc handlers for TLED
  */
 static int
@@ -876,6 +956,11 @@ static int asus_hotk_add_fs(struct acpi_device *device)
                               mode, device);
         }
 
+        if (hotk->methods->mt_ledd) {
+                asus_proc_add(PROC_LEDD, &proc_write_ledd, &proc_read_ledd,
+                              mode, device);
+        }
+
         if (hotk->methods->mt_mled) {
                 asus_proc_add(PROC_MLED, &proc_write_mled, &proc_read_mled,
                               mode, device);
@@ -886,6 +971,11 @@ static int asus_hotk_add_fs(struct acpi_device *device)
                               mode, device);
         }
 
+        if (hotk->methods->mt_bt_switch) {
+                asus_proc_add(PROC_BT, &proc_write_bluetooth,
+                              &proc_read_bluetooth, mode, device);
+        }
+
         /* 
          * We need both read node and write method as LCD switch is also accessible
          * from keyboard 
@@ -919,6 +1009,10 @@ static int asus_hotk_remove_fs(struct acpi_device *device)
                         remove_proc_entry(PROC_MLED, acpi_device_dir(device));
                 if (hotk->methods->mt_tled)
                         remove_proc_entry(PROC_TLED, acpi_device_dir(device));
+                if (hotk->methods->mt_ledd)
+                        remove_proc_entry(PROC_LEDD, acpi_device_dir(device));
+                if (hotk->methods->mt_bt_switch)
+                        remove_proc_entry(PROC_BT, acpi_device_dir(device));
                 if (hotk->methods->mt_lcd_switch && hotk->methods->lcd_status)
                         remove_proc_entry(PROC_LCD, acpi_device_dir(device));
                 if ((hotk->methods->brightness_up
@@ -951,6 +1045,65 @@ static void asus_hotk_notify(acpi_handle handle, u32 event, void *data)
 }
 
 /*
+ * Match the model string to the list of supported models. Return END_MODEL if
+ * no match or model is NULL.
+ */
+static int asus_model_match(char *model)
+{
+        if (model == NULL)
+                return END_MODEL;
+
+        if (strncmp(model, "L3D", 3) == 0)
+                return L3D;
+        else if (strncmp(model, "L2E", 3) == 0 ||
+                 strncmp(model, "L3H", 3) == 0 || strncmp(model, "L5D", 3) == 0)
+                return L3H;
+        else if (strncmp(model, "L3", 2) == 0 || strncmp(model, "L2B", 3) == 0)
+                return L3C;
+        else if (strncmp(model, "L8L", 3) == 0)
+                return L8L;
+        else if (strncmp(model, "L4R", 3) == 0)
+                return L4R;
+        else if (strncmp(model, "M6N", 3) == 0 || strncmp(model, "W3N", 3) == 0)
+                return M6N;
+        else if (strncmp(model, "M6R", 3) == 0 || strncmp(model, "A3G", 3) == 0)
+                return M6R;
+        else if (strncmp(model, "M2N", 3) == 0 ||
+                 strncmp(model, "M3N", 3) == 0 ||
+                 strncmp(model, "M5N", 3) == 0 ||
+                 strncmp(model, "M6N", 3) == 0 ||
+                 strncmp(model, "S1N", 3) == 0 ||
+                 strncmp(model, "S5N", 3) == 0 || strncmp(model, "W1N", 3) == 0)
+                return xxN;
+        else if (strncmp(model, "M1", 2) == 0)
+                return M1A;
+        else if (strncmp(model, "M2", 2) == 0 || strncmp(model, "L4E", 3) == 0)
+                return M2E;
+        else if (strncmp(model, "L2", 2) == 0)
+                return L2D;
+        else if (strncmp(model, "L8", 2) == 0)
+                return S1x;
+        else if (strncmp(model, "D1", 2) == 0)
+                return D1x;
+        else if (strncmp(model, "A1", 2) == 0)
+                return A1x;
+        else if (strncmp(model, "A2", 2) == 0)
+                return A2x;
+        else if (strncmp(model, "J1", 2) == 0)
+                return S2x;
+        else if (strncmp(model, "L5", 2) == 0)
+                return L5x;
+        else if (strncmp(model, "A4G", 3) == 0)
+                return A4G;
+        else if (strncmp(model, "W1N", 3) == 0)
+                return W1N;
+        else if (strncmp(model, "W5A", 3) == 0)
+                return W5A;
+        else
+                return END_MODEL;
+}
+
+/*
  * This function is used to initialize the hotk with right values. In this
  * method, we can make all the detection we want, and modify the hotk struct
  */
@@ -960,6 +1113,7 @@ static int asus_hotk_get_info(void)
         struct acpi_buffer dsdt = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *model = NULL;
         int bsts_result;
+        char *string = NULL;
         acpi_status status;
 
         /*
@@ -989,114 +1143,73 @@ static int asus_hotk_get_info(void)
                 printk(KERN_NOTICE "  BSTS called, 0x%02x returned\n",
                        bsts_result);
 
-        /* This is unlikely with implicit return */
-        if (buffer.pointer == NULL)
-                return -EINVAL;
-
-        model = (union acpi_object *) buffer.pointer;
         /*
-         * Samsung P30 has a device with a valid _HID whose INIT does not 
-         * return anything. It used to be possible to catch this exception,
-         * but the implicit return code will now happily confuse the 
-         * driver. We assume that every ACPI_TYPE_STRING is a valid model
-         * identifier but it's still possible to get completely bogus data.
+         * Try to match the object returned by INIT to the specific model.
+         * Handle every possible object (or the lack of thereof) the DSDT 
+         * writers might throw at us. When in trouble, we pass NULL to 
+         * asus_model_match() and try something completely different.
          */
-        if (model->type == ACPI_TYPE_STRING) {
-                printk(KERN_NOTICE "  %s model detected, ", model->string.pointer);
-        } else {
-                if (asus_info &&        /* Samsung P30 */
+        if (buffer.pointer) {
+                model = (union acpi_object *)buffer.pointer;
+                switch (model->type) {
+                case ACPI_TYPE_STRING:
+                        string = model->string.pointer;
+                        break;
+                case ACPI_TYPE_BUFFER:
+                        string = model->buffer.pointer;
+                        break;
+                default:
+                        kfree(model);
+                        break;
+                }
+        }
+        hotk->model = asus_model_match(string);
+        if (hotk->model == END_MODEL) { /* match failed */
+                if (asus_info &&
                     strncmp(asus_info->oem_table_id, "ODEM", 4) == 0) {
                         hotk->model = P30;
                         printk(KERN_NOTICE
                                "  Samsung P30 detected, supported\n");
                 } else {
                         hotk->model = M2E;
-                        printk(KERN_WARNING "  no string returned by INIT\n");
-                        printk(KERN_WARNING "  trying default values, supply "
-                               "the developers with your DSDT\n");
+                        printk(KERN_NOTICE "  unsupported model %s, trying "
+                               "default values\n", string);
+                        printk(KERN_NOTICE
+                               "  send /proc/acpi/dsdt to the developers\n");
                 }
                 hotk->methods = &model_conf[hotk->model];
-                
-                acpi_os_free(model);
-
                 return AE_OK;
         }
-
-        hotk->model = END_MODEL;
-        if (strncmp(model->string.pointer, "L3D", 3) == 0)
-                hotk->model = L3D;
-        else if (strncmp(model->string.pointer, "L3H", 3) == 0 ||
-                 strncmp(model->string.pointer, "L2E", 3) == 0)
-                hotk->model = L3H;
-        else if (strncmp(model->string.pointer, "L3", 2) == 0 ||
-                 strncmp(model->string.pointer, "L2B", 3) == 0)
-                hotk->model = L3C;
-        else if (strncmp(model->string.pointer, "L8L", 3) == 0)
-                hotk->model = L8L;
-        else if (strncmp(model->string.pointer, "L4R", 3) == 0)
-                hotk->model = L4R;
-        else if (strncmp(model->string.pointer, "M6N", 3) == 0)
-                hotk->model = M6N;
-        else if (strncmp(model->string.pointer, "M6R", 3) == 0)
-                hotk->model = M6R;
-        else if (strncmp(model->string.pointer, "M2N", 3) == 0 ||
-                 strncmp(model->string.pointer, "M3N", 3) == 0 ||
-                 strncmp(model->string.pointer, "M5N", 3) == 0 ||
-                 strncmp(model->string.pointer, "M6N", 3) == 0 ||
-                 strncmp(model->string.pointer, "S1N", 3) == 0 ||
-                 strncmp(model->string.pointer, "S5N", 3) == 0 ||
-                 strncmp(model->string.pointer, "W1N", 3) == 0)
-                hotk->model = xxN;
-        else if (strncmp(model->string.pointer, "M1", 2) == 0)
-                hotk->model = M1A;
-        else if (strncmp(model->string.pointer, "M2", 2) == 0 ||
-                 strncmp(model->string.pointer, "L4E", 3) == 0)
-                hotk->model = M2E;
-        else if (strncmp(model->string.pointer, "L2", 2) == 0)
-                hotk->model = L2D;
-        else if (strncmp(model->string.pointer, "L8", 2) == 0)
-                hotk->model = S1x;
-        else if (strncmp(model->string.pointer, "D1", 2) == 0)
-                hotk->model = D1x;
-        else if (strncmp(model->string.pointer, "A1", 2) == 0)
-                hotk->model = A1x;
-        else if (strncmp(model->string.pointer, "A2", 2) == 0)
-                hotk->model = A2x;
-        else if (strncmp(model->string.pointer, "J1", 2) == 0)
-                hotk->model = S2x;
-        else if (strncmp(model->string.pointer, "L5", 2) == 0)
-                hotk->model = L5x;
-
-        if (hotk->model == END_MODEL) {
-                printk("unsupported, trying default values, supply the "
-                       "developers with your DSDT\n");
-                hotk->model = M2E;
-        } else {
-                printk("supported\n");
-        }
-
         hotk->methods = &model_conf[hotk->model];
+        printk(KERN_NOTICE "  %s model detected, supported\n", string);
 
         /* Sort of per-model blacklist */
-        if (strncmp(model->string.pointer, "L2B", 3) == 0)
+        if (strncmp(string, "L2B", 3) == 0)
                 hotk->methods->lcd_status = NULL;
         /* L2B is similar enough to L3C to use its settings, with this only 
            exception */
-        else if (strncmp(model->string.pointer, "S5N", 3) == 0 ||
-                 strncmp(model->string.pointer, "M5N", 3) == 0)
+        else if (strncmp(string, "A3G", 3) == 0)
+                hotk->methods->lcd_status = "\\BLFG";
+        /* A3G is like M6R */
+        else if (strncmp(string, "S5N", 3) == 0 ||
+                 strncmp(string, "M5N", 3) == 0 ||
+                 strncmp(string, "W3N", 3) == 0)
                 hotk->methods->mt_mled = NULL;
-        /* S5N and M5N have no MLED */
-        else if (strncmp(model->string.pointer, "M2N", 3) == 0 ||
-                 strncmp(model->string.pointer, "W1N", 3) == 0)
+        /* S5N, M5N and W3N have no MLED */
+        else if (strncmp(string, "L5D", 3) == 0)
+                hotk->methods->mt_wled = NULL;
+        /* L5D's WLED is not controlled by ACPI */
+        else if (strncmp(string, "M2N", 3) == 0 ||
+                 strncmp(string, "S1N", 3) == 0)
                 hotk->methods->mt_wled = "WLED";
-        /* M2N and W1N have a usable WLED */
+        /* M2N and S1N have a usable WLED */
         else if (asus_info) {
                 if (strncmp(asus_info->oem_table_id, "L1", 2) == 0)
                         hotk->methods->mled_status = NULL;
                 /* S1300A reports L84F, but L1400B too, account for that */
         }
 
-        acpi_os_free(model);
+        kfree(model);
 
         return AE_OK;
 }
@@ -1164,8 +1277,7 @@ static int asus_hotk_add(struct acpi_device *device)
         /* For laptops without GPLV: init the hotk->brightness value */
         if ((!hotk->methods->brightness_get)
             && (!hotk->methods->brightness_status)
-            && (hotk->methods->brightness_up
-                && hotk->methods->brightness_down)) {
+            && (hotk->methods->brightness_up && hotk->methods->brightness_down)) {
                 status =
                     acpi_evaluate_object(NULL, hotk->methods->brightness_down,
                                          NULL, NULL);
@@ -1184,6 +1296,9 @@ static int asus_hotk_add(struct acpi_device *device)
 
         asus_hotk_found = 1;
 
+        /* LED display is off by default */
+        hotk->ledd_status = 0xFFF;
+
       end:
         if (result) {
                 kfree(hotk);
@@ -1232,7 +1347,7 @@ static int __init asus_acpi_init(void)
         result = acpi_bus_register_driver(&asus_hotk_driver);
         if (result < 0) {
                 remove_proc_entry(PROC_ASUS, acpi_root_dir);
-                return -ENODEV;
+                return result;
         }
 
         /*
@@ -1256,7 +1371,7 @@ static void __exit asus_acpi_exit(void)
         acpi_bus_unregister_driver(&asus_hotk_driver);
         remove_proc_entry(PROC_ASUS, acpi_root_dir);
 
-        acpi_os_free(asus_info);
+        kfree(asus_info);
 
         return;
 }
diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index 702e857e98c5..9810e2a55d0a 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -59,6 +59,9 @@ ACPI_MODULE_NAME("acpi_battery")
 MODULE_DESCRIPTION(ACPI_BATTERY_DRIVER_NAME);
 MODULE_LICENSE("GPL");
 
+extern struct proc_dir_entry *acpi_lock_battery_dir(void);
+extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
+
 static int acpi_battery_add(struct acpi_device *device);
 static int acpi_battery_remove(struct acpi_device *device, int type);
 
@@ -108,7 +111,7 @@ struct acpi_battery_trips {
 };
 
 struct acpi_battery {
-        acpi_handle handle;
+        struct acpi_device * device;
         struct acpi_battery_flags flags;
         struct acpi_battery_trips trips;
         unsigned long alarm;
@@ -132,17 +135,16 @@ acpi_battery_get_info(struct acpi_battery *battery,
         struct acpi_buffer data = { 0, NULL };
         union acpi_object *package = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_battery_get_info");
 
         if (!battery || !bif)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /* Evalute _BIF */
 
-        status = acpi_evaluate_object(battery->handle, "_BIF", NULL, &buffer);
+        status = acpi_evaluate_object(battery->device->handle, "_BIF", NULL, &buffer);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _BIF\n"));
-                return_VALUE(-ENODEV);
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BIF"));
+                return -ENODEV;
         }
 
         package = (union acpi_object *)buffer.pointer;
@@ -151,7 +153,7 @@ acpi_battery_get_info(struct acpi_battery *battery,
 
         status = acpi_extract_package(package, &format, &data);
         if (status != AE_BUFFER_OVERFLOW) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error extracting _BIF\n"));
+                ACPI_EXCEPTION((AE_INFO, status, "Extracting _BIF"));
                 result = -ENODEV;
                 goto end;
         }
@@ -165,19 +167,19 @@ acpi_battery_get_info(struct acpi_battery *battery,
 
         status = acpi_extract_package(package, &format, &data);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error extracting _BIF\n"));
+                ACPI_EXCEPTION((AE_INFO, status, "Extracting _BIF"));
                 kfree(data.pointer);
                 result = -ENODEV;
                 goto end;
         }
 
       end:
-        acpi_os_free(buffer.pointer);
+        kfree(buffer.pointer);
 
         if (!result)
                 (*bif) = (struct acpi_battery_info *)data.pointer;
 
-        return_VALUE(result);
+        return result;
 }
 
 static int
@@ -193,17 +195,16 @@ acpi_battery_get_status(struct acpi_battery *battery,
         struct acpi_buffer data = { 0, NULL };
         union acpi_object *package = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_battery_get_status");
 
         if (!battery || !bst)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /* Evalute _BST */
 
-        status = acpi_evaluate_object(battery->handle, "_BST", NULL, &buffer);
+        status = acpi_evaluate_object(battery->device->handle, "_BST", NULL, &buffer);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _BST\n"));
-                return_VALUE(-ENODEV);
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
+                return -ENODEV;
         }
 
         package = (union acpi_object *)buffer.pointer;
@@ -212,7 +213,7 @@ acpi_battery_get_status(struct acpi_battery *battery,
 
         status = acpi_extract_package(package, &format, &data);
         if (status != AE_BUFFER_OVERFLOW) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error extracting _BST\n"));
+                ACPI_EXCEPTION((AE_INFO, status, "Extracting _BST"));
                 result = -ENODEV;
                 goto end;
         }
@@ -226,19 +227,19 @@ acpi_battery_get_status(struct acpi_battery *battery,
 
         status = acpi_extract_package(package, &format, &data);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error extracting _BST\n"));
+                ACPI_EXCEPTION((AE_INFO, status, "Extracting _BST"));
                 kfree(data.pointer);
                 result = -ENODEV;
                 goto end;
         }
 
       end:
-        acpi_os_free(buffer.pointer);
+        kfree(buffer.pointer);
 
         if (!result)
                 (*bst) = (struct acpi_battery_status *)data.pointer;
 
-        return_VALUE(result);
+        return result;
 }
 
 static int
@@ -248,25 +249,24 @@ acpi_battery_set_alarm(struct acpi_battery *battery, unsigned long alarm)
         union acpi_object arg0 = { ACPI_TYPE_INTEGER };
         struct acpi_object_list arg_list = { 1, &arg0 };
 
-        ACPI_FUNCTION_TRACE("acpi_battery_set_alarm");
 
         if (!battery)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (!battery->flags.alarm)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         arg0.integer.value = alarm;
 
-        status = acpi_evaluate_object(battery->handle, "_BTP", &arg_list, NULL);
+        status = acpi_evaluate_object(battery->device->handle, "_BTP", &arg_list, NULL);
         if (ACPI_FAILURE(status))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", (u32) alarm));
 
         battery->alarm = alarm;
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_battery_check(struct acpi_battery *battery)
@@ -277,18 +277,15 @@ static int acpi_battery_check(struct acpi_battery *battery)
         struct acpi_device *device = NULL;
         struct acpi_battery_info *bif = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_battery_check");
 
         if (!battery)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
-        result = acpi_bus_get_device(battery->handle, &device);
-        if (result)
-                return_VALUE(result);
+        device = battery->device;
 
         result = acpi_bus_get_status(device);
         if (result)
-                return_VALUE(result);
+                return result;
 
         /* Insertion? */
 
@@ -300,7 +297,7 @@ static int acpi_battery_check(struct acpi_battery *battery)
 
                 result = acpi_battery_get_info(battery, &bif);
                 if (result)
-                        return_VALUE(result);
+                        return result;
 
                 battery->flags.power_unit = bif->power_unit;
                 battery->trips.warning = bif->design_capacity_warning;
@@ -309,7 +306,7 @@ static int acpi_battery_check(struct acpi_battery *battery)
 
                 /* See if alarms are supported, and if so, set default */
 
-                status = acpi_get_handle(battery->handle, "_BTP", &handle);
+                status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
                 if (ACPI_SUCCESS(status)) {
                         battery->flags.alarm = 1;
                         acpi_battery_set_alarm(battery, battery->trips.warning);
@@ -324,7 +321,7 @@ static int acpi_battery_check(struct acpi_battery *battery)
 
         battery->flags.present = device->status.battery_present;
 
-        return_VALUE(result);
+        return result;
 }
 
 /* --------------------------------------------------------------------------
@@ -339,7 +336,6 @@ static int acpi_battery_read_info(struct seq_file *seq, void *offset)
         struct acpi_battery_info *bif = NULL;
         char *units = "?";
 
-        ACPI_FUNCTION_TRACE("acpi_battery_read_info");
 
         if (!battery)
                 goto end;
@@ -409,7 +405,7 @@ static int acpi_battery_read_info(struct seq_file *seq, void *offset)
       end:
         kfree(bif);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_battery_info_open_fs(struct inode *inode, struct file *file)
@@ -424,7 +420,6 @@ static int acpi_battery_read_state(struct seq_file *seq, void *offset)
         struct acpi_battery_status *bst = NULL;
         char *units = "?";
 
-        ACPI_FUNCTION_TRACE("acpi_battery_read_state");
 
         if (!battery)
                 goto end;
@@ -458,8 +453,6 @@ static int acpi_battery_read_state(struct seq_file *seq, void *offset)
         if ((bst->state & 0x01) && (bst->state & 0x02)) {
                 seq_printf(seq,
                            "charging state:          charging/discharging\n");
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Battery Charging and Discharging?\n"));
         } else if (bst->state & 0x01)
                 seq_printf(seq, "charging state:          discharging\n");
         else if (bst->state & 0x02)
@@ -489,7 +482,7 @@ static int acpi_battery_read_state(struct seq_file *seq, void *offset)
       end:
         kfree(bst);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
@@ -502,7 +495,6 @@ static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
         struct acpi_battery *battery = (struct acpi_battery *)seq->private;
         char *units = "?";
 
-        ACPI_FUNCTION_TRACE("acpi_battery_read_alarm");
 
         if (!battery)
                 goto end;
@@ -527,7 +519,7 @@ static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
                 seq_printf(seq, "%d %sh\n", (u32) battery->alarm, units);
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static ssize_t
@@ -540,25 +532,24 @@ acpi_battery_write_alarm(struct file *file,
         struct seq_file *m = (struct seq_file *)file->private_data;
         struct acpi_battery *battery = (struct acpi_battery *)m->private;
 
-        ACPI_FUNCTION_TRACE("acpi_battery_write_alarm");
 
         if (!battery || (count > sizeof(alarm_string) - 1))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (!battery->flags.present)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         if (copy_from_user(alarm_string, buffer, count))
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
         alarm_string[count] = '\0';
 
         result = acpi_battery_set_alarm(battery,
                                         simple_strtoul(alarm_string, NULL, 0));
         if (result)
-                return_VALUE(result);
+                return result;
 
-        return_VALUE(count);
+        return count;
 }
 
 static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file)
@@ -566,7 +557,7 @@ static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file)
         return single_open(file, acpi_battery_read_alarm, PDE(inode)->data);
 }
 
-static struct file_operations acpi_battery_info_ops = {
+static const struct file_operations acpi_battery_info_ops = {
         .open = acpi_battery_info_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -574,7 +565,7 @@ static struct file_operations acpi_battery_info_ops = {
         .owner = THIS_MODULE,
 };
 
-static struct file_operations acpi_battery_state_ops = {
+static const struct file_operations acpi_battery_state_ops = {
         .open = acpi_battery_state_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -582,7 +573,7 @@ static struct file_operations acpi_battery_state_ops = {
         .owner = THIS_MODULE,
 };
 
-static struct file_operations acpi_battery_alarm_ops = {
+static const struct file_operations acpi_battery_alarm_ops = {
         .open = acpi_battery_alarm_open_fs,
         .read = seq_read,
         .write = acpi_battery_write_alarm,
@@ -595,13 +586,12 @@ static int acpi_battery_add_fs(struct acpi_device *device)
 {
         struct proc_dir_entry *entry = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_battery_add_fs");
 
         if (!acpi_device_dir(device)) {
                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
                                                      acpi_battery_dir);
                 if (!acpi_device_dir(device))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
                 acpi_device_dir(device)->owner = THIS_MODULE;
         }
 
@@ -609,9 +599,7 @@ static int acpi_battery_add_fs(struct acpi_device *device)
         entry = create_proc_entry(ACPI_BATTERY_FILE_INFO,
                                   S_IRUGO, acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_BATTERY_FILE_INFO));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_battery_info_ops;
                 entry->data = acpi_driver_data(device);
@@ -622,9 +610,7 @@ static int acpi_battery_add_fs(struct acpi_device *device)
         entry = create_proc_entry(ACPI_BATTERY_FILE_STATUS,
                                   S_IRUGO, acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_BATTERY_FILE_STATUS));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_battery_state_ops;
                 entry->data = acpi_driver_data(device);
@@ -636,21 +622,18 @@ static int acpi_battery_add_fs(struct acpi_device *device)
                                   S_IFREG | S_IRUGO | S_IWUSR,
                                   acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_BATTERY_FILE_ALARM));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_battery_alarm_ops;
                 entry->data = acpi_driver_data(device);
                 entry->owner = THIS_MODULE;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_battery_remove_fs(struct acpi_device *device)
 {
-        ACPI_FUNCTION_TRACE("acpi_battery_remove_fs");
 
         if (acpi_device_dir(device)) {
                 remove_proc_entry(ACPI_BATTERY_FILE_ALARM,
@@ -664,7 +647,7 @@ static int acpi_battery_remove_fs(struct acpi_device *device)
                 acpi_device_dir(device) = NULL;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 /* --------------------------------------------------------------------------
@@ -676,17 +659,17 @@ static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
         struct acpi_battery *battery = (struct acpi_battery *)data;
         struct acpi_device *device = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_battery_notify");
 
         if (!battery)
-                return_VOID;
+                return;
 
-        if (acpi_bus_get_device(handle, &device))
-                return_VOID;
+        device = battery->device;
 
         switch (event) {
         case ACPI_BATTERY_NOTIFY_STATUS:
         case ACPI_BATTERY_NOTIFY_INFO:
+        case ACPI_NOTIFY_BUS_CHECK:
+        case ACPI_NOTIFY_DEVICE_CHECK:
                 acpi_battery_check(battery);
                 acpi_bus_generate_event(device, event, battery->flags.present);
                 break;
@@ -696,7 +679,7 @@ static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
                 break;
         }
 
-        return_VOID;
+        return;
 }
 
 static int acpi_battery_add(struct acpi_device *device)
@@ -705,17 +688,16 @@ static int acpi_battery_add(struct acpi_device *device)
         acpi_status status = 0;
         struct acpi_battery *battery = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_battery_add");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         battery = kmalloc(sizeof(struct acpi_battery), GFP_KERNEL);
         if (!battery)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(battery, 0, sizeof(struct acpi_battery));
 
-        battery->handle = device->handle;
+        battery->device = device;
         strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
         strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
         acpi_driver_data(device) = battery;
@@ -728,12 +710,10 @@ static int acpi_battery_add(struct acpi_device *device)
         if (result)
                 goto end;
 
-        status = acpi_install_notify_handler(battery->handle,
-                                             ACPI_DEVICE_NOTIFY,
+        status = acpi_install_notify_handler(device->handle,
+                                             ACPI_ALL_NOTIFY,
                                              acpi_battery_notify, battery);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error installing notify handler\n"));
                 result = -ENODEV;
                 goto end;
         }
@@ -748,7 +728,7 @@ static int acpi_battery_add(struct acpi_device *device)
                 kfree(battery);
         }
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_battery_remove(struct acpi_device *device, int type)
@@ -756,56 +736,51 @@ static int acpi_battery_remove(struct acpi_device *device, int type)
         acpi_status status = 0;
         struct acpi_battery *battery = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_battery_remove");
 
         if (!device || !acpi_driver_data(device))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         battery = (struct acpi_battery *)acpi_driver_data(device);
 
-        status = acpi_remove_notify_handler(battery->handle,
-                                            ACPI_DEVICE_NOTIFY,
+        status = acpi_remove_notify_handler(device->handle,
+                                            ACPI_ALL_NOTIFY,
                                             acpi_battery_notify);
-        if (ACPI_FAILURE(status))
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error removing notify handler\n"));
 
         acpi_battery_remove_fs(device);
 
         kfree(battery);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int __init acpi_battery_init(void)
 {
-        int result = 0;
+        int result;
 
-        ACPI_FUNCTION_TRACE("acpi_battery_init");
+        if (acpi_disabled)
+                return -ENODEV;
 
-        acpi_battery_dir = proc_mkdir(ACPI_BATTERY_CLASS, acpi_root_dir);
+        acpi_battery_dir = acpi_lock_battery_dir();
         if (!acpi_battery_dir)
-                return_VALUE(-ENODEV);
-        acpi_battery_dir->owner = THIS_MODULE;
+                return -ENODEV;
 
         result = acpi_bus_register_driver(&acpi_battery_driver);
         if (result < 0) {
-                remove_proc_entry(ACPI_BATTERY_CLASS, acpi_root_dir);
-                return_VALUE(-ENODEV);
+                acpi_unlock_battery_dir(acpi_battery_dir);
+                return -ENODEV;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static void __exit acpi_battery_exit(void)
 {
-        ACPI_FUNCTION_TRACE("acpi_battery_exit");
 
         acpi_bus_unregister_driver(&acpi_battery_driver);
 
-        remove_proc_entry(ACPI_BATTERY_CLASS, acpi_root_dir);
+        acpi_unlock_battery_dir(acpi_battery_dir);
 
-        return_VOID;
+        return;
 }
 
 module_init(acpi_battery_init);
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index dd3983cece92..279c4bac92e5 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -25,6 +25,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/ioport.h>
+#include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/sched.h>
 #include <linux/pm.h>
@@ -60,21 +61,20 @@ int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
 {
         acpi_status status = AE_OK;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_get_device");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /* TBD: Support fixed-feature devices */
 
         status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device);
         if (ACPI_FAILURE(status) || !*device) {
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN, "No context for object [%p]\n",
+                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
                                   handle));
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 EXPORT_SYMBOL(acpi_bus_get_device);
@@ -84,10 +84,9 @@ int acpi_bus_get_status(struct acpi_device *device)
         acpi_status status = AE_OK;
         unsigned long sta = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_get_status");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /*
          * Evaluate _STA if present.
@@ -96,7 +95,7 @@ int acpi_bus_get_status(struct acpi_device *device)
                 status =
                     acpi_evaluate_integer(device->handle, "_STA", NULL, &sta);
                 if (ACPI_FAILURE(status))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
                 STRUCT_TO_INT(device->status) = (int)sta;
         }
 
@@ -120,7 +119,7 @@ int acpi_bus_get_status(struct acpi_device *device)
                           device->pnp.bus_id,
                           (u32) STRUCT_TO_INT(device->status)));
 
-        return_VALUE(0);
+        return 0;
 }
 
 EXPORT_SYMBOL(acpi_bus_get_status);
@@ -136,11 +135,10 @@ int acpi_bus_get_power(acpi_handle handle, int *state)
         struct acpi_device *device = NULL;
         unsigned long psc = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_get_power");
 
         result = acpi_bus_get_device(handle, &device);
         if (result)
-                return_VALUE(result);
+                return result;
 
         *state = ACPI_STATE_UNKNOWN;
 
@@ -159,12 +157,12 @@ int acpi_bus_get_power(acpi_handle handle, int *state)
                         status = acpi_evaluate_integer(device->handle, "_PSC",
                                                        NULL, &psc);
                         if (ACPI_FAILURE(status))
-                                return_VALUE(-ENODEV);
+                                return -ENODEV;
                         device->power.state = (int)psc;
                 } else if (device->power.flags.power_resources) {
                         result = acpi_power_get_inferred_state(device);
                         if (result)
-                                return_VALUE(result);
+                                return result;
                 }
 
                 *state = device->power.state;
@@ -173,7 +171,7 @@ int acpi_bus_get_power(acpi_handle handle, int *state)
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n",
                           device->pnp.bus_id, device->power.state));
 
-        return_VALUE(0);
+        return 0;
 }
 
 EXPORT_SYMBOL(acpi_bus_get_power);
@@ -185,21 +183,20 @@ int acpi_bus_set_power(acpi_handle handle, int state)
         struct acpi_device *device = NULL;
         char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' };
 
-        ACPI_FUNCTION_TRACE("acpi_bus_set_power");
 
         result = acpi_bus_get_device(handle, &device);
         if (result)
-                return_VALUE(result);
+                return result;
 
         if ((state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /* Make sure this is a valid target state */
 
         if (!device->flags.power_manageable) {
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                  "Device is not power manageable\n"));
-                return_VALUE(-ENODEV);
+                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device `[%s]' is not power manageable\n",
+                                device->kobj.name));
+                return -ENODEV;
         }
         /*
          * Get device's current power state if it's unknown
@@ -211,18 +208,18 @@ int acpi_bus_set_power(acpi_handle handle, int state)
                 if (state == device->power.state) {
                         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n",
                                           state));
-                        return_VALUE(0);
+                        return 0;
                 }
         }
         if (!device->power.states[state].flags.valid) {
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Device does not support D%d\n",
-                                  state));
-                return_VALUE(-ENODEV);
+                printk(KERN_WARNING PREFIX "Device does not support D%d\n", state);
+                return -ENODEV;
         }
         if (device->parent && (state < device->parent->power.state)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                  "Cannot set device to a higher-powered state than parent\n"));
-                return_VALUE(-ENODEV);
+                printk(KERN_WARNING PREFIX
+                              "Cannot set device to a higher-powered"
+                              " state than parent\n");
+                return -ENODEV;
         }
 
         /*
@@ -264,15 +261,15 @@ int acpi_bus_set_power(acpi_handle handle, int state)
 
       end:
         if (result)
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                  "Error transitioning device [%s] to D%d\n",
-                                  device->pnp.bus_id, state));
+                printk(KERN_WARNING PREFIX
+                              "Transitioning device [%s] to D%d\n",
+                              device->pnp.bus_id, state);
         else
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                   "Device [%s] transitioned to D%d\n",
                                   device->pnp.bus_id, state));
 
-        return_VALUE(result);
+        return result;
 }
 
 EXPORT_SYMBOL(acpi_bus_set_power);
@@ -293,18 +290,17 @@ int acpi_bus_generate_event(struct acpi_device *device, u8 type, int data)
         struct acpi_bus_event *event = NULL;
         unsigned long flags = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_generate_event");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /* drop event on the floor if no one's listening */
         if (!event_is_open)
-                return_VALUE(0);
+                return 0;
 
         event = kmalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);
         if (!event)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
 
         strcpy(event->device_class, device->pnp.device_class);
         strcpy(event->bus_id, device->pnp.bus_id);
@@ -317,7 +313,7 @@ int acpi_bus_generate_event(struct acpi_device *device, u8 type, int data)
 
         wake_up_interruptible(&acpi_bus_event_queue);
 
-        return_VALUE(0);
+        return 0;
 }
 
 EXPORT_SYMBOL(acpi_bus_generate_event);
@@ -329,10 +325,9 @@ int acpi_bus_receive_event(struct acpi_bus_event *event)
 
         DECLARE_WAITQUEUE(wait, current);
 
-        ACPI_FUNCTION_TRACE("acpi_bus_receive_event");
 
         if (!event)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (list_empty(&acpi_bus_event_list)) {
 
@@ -346,7 +341,7 @@ int acpi_bus_receive_event(struct acpi_bus_event *event)
                 set_current_state(TASK_RUNNING);
 
                 if (signal_pending(current))
-                        return_VALUE(-ERESTARTSYS);
+                        return -ERESTARTSYS;
         }
 
         spin_lock_irqsave(&acpi_bus_event_lock, flags);
@@ -357,13 +352,13 @@ int acpi_bus_receive_event(struct acpi_bus_event *event)
         spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
 
         if (!entry)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         memcpy(event, entry, sizeof(struct acpi_bus_event));
 
         kfree(entry);
 
-        return_VALUE(0);
+        return 0;
 }
 
 EXPORT_SYMBOL(acpi_bus_receive_event);
@@ -378,10 +373,9 @@ acpi_bus_check_device(struct acpi_device *device, int *status_changed)
         acpi_status status = 0;
         struct acpi_device_status old_status;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_check_device");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (status_changed)
                 *status_changed = 0;
@@ -398,15 +392,15 @@ acpi_bus_check_device(struct acpi_device *device, int *status_changed)
                         if (status_changed)
                                 *status_changed = 1;
                 }
-                return_VALUE(0);
+                return 0;
         }
 
         status = acpi_bus_get_status(device);
         if (ACPI_FAILURE(status))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status))
-                return_VALUE(0);
+                return 0;
 
         if (status_changed)
                 *status_changed = 1;
@@ -422,7 +416,7 @@ acpi_bus_check_device(struct acpi_device *device, int *status_changed)
                 /* TBD: Handle device removal */
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_bus_check_scope(struct acpi_device *device)
@@ -430,25 +424,24 @@ static int acpi_bus_check_scope(struct acpi_device *device)
         int result = 0;
         int status_changed = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_check_scope");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /* Status Change? */
         result = acpi_bus_check_device(device, &status_changed);
         if (result)
-                return_VALUE(result);
+                return result;
 
         if (!status_changed)
-                return_VALUE(0);
+                return 0;
 
         /*
          * TBD: Enumerate child devices within this device's scope and
          *       run acpi_bus_check_device()'s on them.
          */
 
-        return_VALUE(0);
+        return 0;
 }
 
 /**
@@ -461,10 +454,9 @@ static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
         int result = 0;
         struct acpi_device *device = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_notify");
 
         if (acpi_bus_get_device(handle, &device))
-                return_VOID;
+                return;
 
         switch (type) {
 
@@ -539,7 +531,7 @@ static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
                 break;
         }
 
-        return_VOID;
+        return;
 }
 
 /* --------------------------------------------------------------------------
@@ -553,7 +545,6 @@ static int __init acpi_bus_init_irq(void)
         struct acpi_object_list arg_list = { 1, &arg };
         char *message = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_init_irq");
 
         /* 
          * Let the system know what interrupt model we are using by
@@ -572,7 +563,7 @@ static int __init acpi_bus_init_irq(void)
                 break;
         default:
                 printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
         printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message);
@@ -581,11 +572,11 @@ static int __init acpi_bus_init_irq(void)
 
         status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL);
         if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PIC\n"));
-                return_VALUE(-ENODEV);
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
+                return -ENODEV;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 void __init acpi_early_init(void)
@@ -593,10 +584,9 @@ void __init acpi_early_init(void)
         acpi_status status = AE_OK;
         struct acpi_buffer buffer = { sizeof(acpi_fadt), &acpi_fadt };
 
-        ACPI_FUNCTION_TRACE("acpi_early_init");
 
         if (acpi_disabled)
-                return_VOID;
+                return;
 
         printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION);
 
@@ -656,11 +646,11 @@ void __init acpi_early_init(void)
                 goto error0;
         }
 
-        return_VOID;
+        return;
 
       error0:
         disable_acpi();
-        return_VOID;
+        return;
 }
 
 static int __init acpi_bus_init(void)
@@ -669,7 +659,6 @@ static int __init acpi_bus_init(void)
         acpi_status status = AE_OK;
         extern acpi_status acpi_os_initialize1(void);
 
-        ACPI_FUNCTION_TRACE("acpi_bus_init");
 
         status = acpi_os_initialize1();
 
@@ -731,12 +720,12 @@ static int __init acpi_bus_init(void)
          */
         acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
 
-        return_VALUE(0);
+        return 0;
 
         /* Mimic structured exception handling */
       error1:
         acpi_terminate();
-        return_VALUE(-ENODEV);
+        return -ENODEV;
 }
 
 decl_subsys(acpi, NULL, NULL);
@@ -745,14 +734,16 @@ static int __init acpi_init(void)
 {
         int result = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_init");
 
         if (acpi_disabled) {
                 printk(KERN_INFO PREFIX "Interpreter disabled.\n");
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
-        firmware_register(&acpi_subsys);
+        result = firmware_register(&acpi_subsys);
+        if (result < 0)
+                printk(KERN_WARNING "%s: firmware_register error: %d\n",
+                        __FUNCTION__, result);
 
         result = acpi_bus_init();
 
@@ -770,7 +761,7 @@ static int __init acpi_init(void)
         } else
                 disable_acpi();
 
-        return_VALUE(result);
+        return result;
 }
 
 subsys_initcall(acpi_init);
diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c
index 4b6d9f0096a1..5ef885e82c78 100644
--- a/drivers/acpi/button.c
+++ b/drivers/acpi/button.c
@@ -82,20 +82,19 @@ static struct acpi_driver acpi_button_driver = {
 };
 
 struct acpi_button {
-        acpi_handle handle;
         struct acpi_device *device;     /* Fixed button kludge */
         u8 type;
         unsigned long pushed;
 };
 
-static struct file_operations acpi_button_info_fops = {
+static const struct file_operations acpi_button_info_fops = {
         .open = acpi_button_info_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
         .release = single_release,
 };
 
-static struct file_operations acpi_button_state_fops = {
+static const struct file_operations acpi_button_state_fops = {
         .open = acpi_button_state_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -112,15 +111,14 @@ static int acpi_button_info_seq_show(struct seq_file *seq, void *offset)
 {
         struct acpi_button *button = (struct acpi_button *)seq->private;
 
-        ACPI_FUNCTION_TRACE("acpi_button_info_seq_show");
 
         if (!button || !button->device)
-                return_VALUE(0);
+                return 0;
 
         seq_printf(seq, "type:                    %s\n",
                    acpi_device_name(button->device));
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_button_info_open_fs(struct inode *inode, struct file *file)
@@ -134,12 +132,11 @@ static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
         acpi_status status;
         unsigned long state;
 
-        ACPI_FUNCTION_TRACE("acpi_button_state_seq_show");
 
         if (!button || !button->device)
-                return_VALUE(0);
+                return 0;
 
-        status = acpi_evaluate_integer(button->handle, "_LID", NULL, &state);
+        status = acpi_evaluate_integer(button->device->handle, "_LID", NULL, &state);
         if (ACPI_FAILURE(status)) {
                 seq_printf(seq, "state:      unsupported\n");
         } else {
@@ -147,7 +144,7 @@ static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
                            (state ? "open" : "closed"));
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_button_state_open_fs(struct inode *inode, struct file *file)
@@ -164,10 +161,9 @@ static int acpi_button_add_fs(struct acpi_device *device)
         struct proc_dir_entry *entry = NULL;
         struct acpi_button *button = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_button_add_fs");
 
         if (!device || !acpi_driver_data(device))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         button = acpi_driver_data(device);
 
@@ -195,21 +191,19 @@ static int acpi_button_add_fs(struct acpi_device *device)
         }
 
         if (!entry)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         entry->owner = THIS_MODULE;
 
         acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), entry);
         if (!acpi_device_dir(device))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         acpi_device_dir(device)->owner = THIS_MODULE;
 
         /* 'info' [R] */
         entry = create_proc_entry(ACPI_BUTTON_FILE_INFO,
                                   S_IRUGO, acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_BUTTON_FILE_INFO));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_button_info_fops;
                 entry->data = acpi_driver_data(device);
@@ -221,9 +215,7 @@ static int acpi_button_add_fs(struct acpi_device *device)
                 entry = create_proc_entry(ACPI_BUTTON_FILE_STATE,
                                           S_IRUGO, acpi_device_dir(device));
                 if (!entry)
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Unable to create '%s' fs entry\n",
-                                          ACPI_BUTTON_FILE_INFO));
+                        return -ENODEV;
                 else {
                         entry->proc_fops = &acpi_button_state_fops;
                         entry->data = acpi_driver_data(device);
@@ -231,14 +223,13 @@ static int acpi_button_add_fs(struct acpi_device *device)
                 }
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_button_remove_fs(struct acpi_device *device)
 {
         struct acpi_button *button = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_button_remove_fs");
 
         button = acpi_driver_data(device);
         if (acpi_device_dir(device)) {
@@ -253,7 +244,7 @@ static int acpi_button_remove_fs(struct acpi_device *device)
                 acpi_device_dir(device) = NULL;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 /* --------------------------------------------------------------------------
@@ -264,10 +255,9 @@ static void acpi_button_notify(acpi_handle handle, u32 event, void *data)
 {
         struct acpi_button *button = (struct acpi_button *)data;
 
-        ACPI_FUNCTION_TRACE("acpi_button_notify");
 
         if (!button || !button->device)
-                return_VOID;
+                return;
 
         switch (event) {
         case ACPI_BUTTON_NOTIFY_STATUS:
@@ -280,21 +270,20 @@ static void acpi_button_notify(acpi_handle handle, u32 event, void *data)
                 break;
         }
 
-        return_VOID;
+        return;
 }
 
 static acpi_status acpi_button_notify_fixed(void *data)
 {
         struct acpi_button *button = (struct acpi_button *)data;
 
-        ACPI_FUNCTION_TRACE("acpi_button_notify_fixed");
 
         if (!button)
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                return AE_BAD_PARAMETER;
 
-        acpi_button_notify(button->handle, ACPI_BUTTON_NOTIFY_STATUS, button);
+        acpi_button_notify(button->device->handle, ACPI_BUTTON_NOTIFY_STATUS, button);
 
-        return_ACPI_STATUS(AE_OK);
+        return AE_OK;
 }
 
 static int acpi_button_add(struct acpi_device *device)
@@ -303,18 +292,16 @@ static int acpi_button_add(struct acpi_device *device)
         acpi_status status = AE_OK;
         struct acpi_button *button = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_button_add");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         button = kmalloc(sizeof(struct acpi_button), GFP_KERNEL);
         if (!button)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(button, 0, sizeof(struct acpi_button));
 
         button->device = device;
-        button->handle = device->handle;
         acpi_driver_data(device) = button;
 
         /*
@@ -349,8 +336,8 @@ static int acpi_button_add(struct acpi_device *device)
                 sprintf(acpi_device_class(device), "%s/%s",
                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
         } else {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unsupported hid [%s]\n",
-                                  acpi_device_hid(device)));
+                printk(KERN_ERR PREFIX "Unsupported hid [%s]\n",
+                            acpi_device_hid(device));
                 result = -ENODEV;
                 goto end;
         }
@@ -373,7 +360,7 @@ static int acpi_button_add(struct acpi_device *device)
                                                      button);
                 break;
         default:
-                status = acpi_install_notify_handler(button->handle,
+                status = acpi_install_notify_handler(device->handle,
                                                      ACPI_DEVICE_NOTIFY,
                                                      acpi_button_notify,
                                                      button);
@@ -381,8 +368,6 @@ static int acpi_button_add(struct acpi_device *device)
         }
 
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error installing notify handler\n"));
                 result = -ENODEV;
                 goto end;
         }
@@ -406,7 +391,7 @@ static int acpi_button_add(struct acpi_device *device)
                 kfree(button);
         }
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_button_remove(struct acpi_device *device, int type)
@@ -414,10 +399,9 @@ static int acpi_button_remove(struct acpi_device *device, int type)
         acpi_status status = 0;
         struct acpi_button *button = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_button_remove");
 
         if (!device || !acpi_driver_data(device))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         button = acpi_driver_data(device);
 
@@ -434,45 +418,39 @@ static int acpi_button_remove(struct acpi_device *device, int type)
                                                     acpi_button_notify_fixed);
                 break;
         default:
-                status = acpi_remove_notify_handler(button->handle,
+                status = acpi_remove_notify_handler(device->handle,
                                                     ACPI_DEVICE_NOTIFY,
                                                     acpi_button_notify);
                 break;
         }
 
-        if (ACPI_FAILURE(status))
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error removing notify handler\n"));
-
         acpi_button_remove_fs(device);
 
         kfree(button);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int __init acpi_button_init(void)
 {
         int result = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_button_init");
 
         acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
         if (!acpi_button_dir)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         acpi_button_dir->owner = THIS_MODULE;
         result = acpi_bus_register_driver(&acpi_button_driver);
         if (result < 0) {
                 remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static void __exit acpi_button_exit(void)
 {
-        ACPI_FUNCTION_TRACE("acpi_button_exit");
 
         acpi_bus_unregister_driver(&acpi_button_driver);
 
@@ -484,7 +462,7 @@ static void __exit acpi_button_exit(void)
                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, acpi_button_dir);
         remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
 
-        return_VOID;
+        return;
 }
 
 module_init(acpi_button_init);
diff --git a/drivers/acpi/cm_sbs.c b/drivers/acpi/cm_sbs.c
new file mode 100644
index 000000000000..a01ce6700bfe
--- /dev/null
+++ b/drivers/acpi/cm_sbs.c
@@ -0,0 +1,113 @@
+/*
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or (at
+ *  your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but
+ *  WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/acpi.h>
+#include <linux/types.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+#include <acpi/acmacros.h>
+#include <acpi/actypes.h>
+#include <acpi/acutils.h>
+
+ACPI_MODULE_NAME("cm_sbs")
+#define ACPI_AC_CLASS           "ac_adapter"
+#define ACPI_BATTERY_CLASS      "battery"
+#define ACPI_SBS_COMPONENT      0x00080000
+#define _COMPONENT              ACPI_SBS_COMPONENT
+static struct proc_dir_entry *acpi_ac_dir;
+static struct proc_dir_entry *acpi_battery_dir;
+
+static DEFINE_MUTEX(cm_sbs_mutex);
+
+static int lock_ac_dir_cnt;
+static int lock_battery_dir_cnt;
+
+struct proc_dir_entry *acpi_lock_ac_dir(void)
+{
+        mutex_lock(&cm_sbs_mutex);
+        if (!acpi_ac_dir)
+                acpi_ac_dir = proc_mkdir(ACPI_AC_CLASS, acpi_root_dir);
+        if (acpi_ac_dir) {
+                lock_ac_dir_cnt++;
+        } else {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "Cannot create %s\n", ACPI_AC_CLASS));
+        }
+        mutex_unlock(&cm_sbs_mutex);
+        return acpi_ac_dir;
+}
+EXPORT_SYMBOL(acpi_lock_ac_dir);
+
+void acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir_param)
+{
+        mutex_lock(&cm_sbs_mutex);
+        if (acpi_ac_dir_param)
+                lock_ac_dir_cnt--;
+        if (lock_ac_dir_cnt == 0 && acpi_ac_dir_param && acpi_ac_dir) {
+                remove_proc_entry(ACPI_AC_CLASS, acpi_root_dir);
+                acpi_ac_dir = 0;
+        }
+        mutex_unlock(&cm_sbs_mutex);
+}
+EXPORT_SYMBOL(acpi_unlock_ac_dir);
+
+struct proc_dir_entry *acpi_lock_battery_dir(void)
+{
+        mutex_lock(&cm_sbs_mutex);
+        if (!acpi_battery_dir) {
+                acpi_battery_dir =
+                    proc_mkdir(ACPI_BATTERY_CLASS, acpi_root_dir);
+        }
+        if (acpi_battery_dir) {
+                lock_battery_dir_cnt++;
+        } else {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "Cannot create %s\n", ACPI_BATTERY_CLASS));
+        }
+        mutex_unlock(&cm_sbs_mutex);
+        return acpi_battery_dir;
+}
+EXPORT_SYMBOL(acpi_lock_battery_dir);
+
+void acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir_param)
+{
+        mutex_lock(&cm_sbs_mutex);
+        if (acpi_battery_dir_param)
+                lock_battery_dir_cnt--;
+        if (lock_battery_dir_cnt == 0 && acpi_battery_dir_param
+            && acpi_battery_dir) {
+                remove_proc_entry(ACPI_BATTERY_CLASS, acpi_root_dir);
+                acpi_battery_dir = 0;
+        }
+        mutex_unlock(&cm_sbs_mutex);
+        return;
+}
+EXPORT_SYMBOL(acpi_unlock_battery_dir);
+
+static int __init acpi_cm_sbs_init(void)
+{
+        return 0;
+}
+subsys_initcall(acpi_cm_sbs_init);
diff --git a/drivers/acpi/container.c b/drivers/acpi/container.c
index b69a8cad82b7..871aa520ece7 100644
--- a/drivers/acpi/container.c
+++ b/drivers/acpi/container.c
@@ -73,17 +73,16 @@ static int is_device_present(acpi_handle handle)
         acpi_status status;
         unsigned long sta;
 
-        ACPI_FUNCTION_TRACE("is_device_present");
 
         status = acpi_get_handle(handle, "_STA", &temp);
         if (ACPI_FAILURE(status))
-                return_VALUE(1);        /* _STA not found, assmue device present */
+                return 1;       /* _STA not found, assmue device present */
 
         status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
         if (ACPI_FAILURE(status))
-                return_VALUE(0);        /* Firmware error */
+                return 0;       /* Firmware error */
 
-        return_VALUE((sta & ACPI_STA_PRESENT) == ACPI_STA_PRESENT);
+        return ((sta & ACPI_STA_PRESENT) == ACPI_STA_PRESENT);
 }
 
 /*******************************************************************/
@@ -91,16 +90,15 @@ static int acpi_container_add(struct acpi_device *device)
 {
         struct acpi_container *container;
 
-        ACPI_FUNCTION_TRACE("acpi_container_add");
 
         if (!device) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "device is NULL\n"));
-                return_VALUE(-EINVAL);
+                printk(KERN_ERR PREFIX "device is NULL\n");
+                return -EINVAL;
         }
 
         container = kmalloc(sizeof(struct acpi_container), GFP_KERNEL);
         if (!container)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
 
         memset(container, 0, sizeof(struct acpi_container));
         container->handle = device->handle;
@@ -111,7 +109,7 @@ static int acpi_container_add(struct acpi_device *device)
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device <%s> bid <%s>\n",
                           acpi_device_name(device), acpi_device_bid(device)));
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_container_remove(struct acpi_device *device, int type)
@@ -130,23 +128,22 @@ static int container_device_add(struct acpi_device **device, acpi_handle handle)
         struct acpi_device *pdev;
         int result;
 
-        ACPI_FUNCTION_TRACE("container_device_add");
 
         if (acpi_get_parent(handle, &phandle)) {
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
         if (acpi_bus_get_device(phandle, &pdev)) {
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
         if (acpi_bus_add(device, pdev, handle, ACPI_BUS_TYPE_DEVICE)) {
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
         result = acpi_bus_start(*device);
 
-        return_VALUE(result);
+        return result;
 }
 
 static void container_notify_cb(acpi_handle handle, u32 type, void *context)
@@ -156,7 +153,6 @@ static void container_notify_cb(acpi_handle handle, u32 type, void *context)
         int present;
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("container_notify_cb");
 
         present = is_device_present(handle);
 
@@ -192,7 +188,7 @@ static void container_notify_cb(acpi_handle handle, u32 type, void *context)
         default:
                 break;
         }
-        return_VOID;
+        return;
 }
 
 static acpi_status
@@ -205,11 +201,10 @@ container_walk_namespace_cb(acpi_handle handle,
         acpi_status status;
         int *action = context;
 
-        ACPI_FUNCTION_TRACE("container_walk_namespace_cb");
 
         status = acpi_get_object_info(handle, &buffer);
         if (ACPI_FAILURE(status) || !buffer.pointer) {
-                return_ACPI_STATUS(AE_OK);
+                return AE_OK;
         }
 
         info = buffer.pointer;
@@ -241,9 +236,9 @@ container_walk_namespace_cb(acpi_handle handle,
         }
 
       end:
-        acpi_os_free(buffer.pointer);
+        kfree(buffer.pointer);
 
-        return_ACPI_STATUS(AE_OK);
+        return AE_OK;
 }
 
 static int __init acpi_container_init(void)
@@ -269,7 +264,6 @@ static void __exit acpi_container_exit(void)
 {
         int action = UNINSTALL_NOTIFY_HANDLER;
 
-        ACPI_FUNCTION_TRACE("acpi_container_exit");
 
         acpi_walk_namespace(ACPI_TYPE_DEVICE,
                             ACPI_ROOT_OBJECT,
@@ -278,7 +272,7 @@ static void __exit acpi_container_exit(void)
 
         acpi_bus_unregister_driver(&acpi_container_driver);
 
-        return_VOID;
+        return;
 }
 
 module_init(acpi_container_init);
diff --git a/drivers/acpi/debug.c b/drivers/acpi/debug.c
index 263322b7d113..35c6af8a83cd 100644
--- a/drivers/acpi/debug.c
+++ b/drivers/acpi/debug.c
@@ -155,13 +155,12 @@ acpi_system_write_debug(struct file *file,
 {
         char debug_string[12] = { '\0' };
 
-        ACPI_FUNCTION_TRACE("acpi_system_write_debug");
 
         if (count > sizeof(debug_string) - 1)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (copy_from_user(debug_string, buffer, count))
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
         debug_string[count] = '\0';
 
@@ -173,10 +172,10 @@ acpi_system_write_debug(struct file *file,
                 acpi_dbg_level = simple_strtoul(debug_string, NULL, 0);
                 break;
         default:
-                return_VALUE(-EINVAL);
+                return -EINVAL;
         }
 
-        return_VALUE(count);
+        return count;
 }
 
 static int __init acpi_debug_init(void)
@@ -185,10 +184,9 @@ static int __init acpi_debug_init(void)
         int error = 0;
         char *name;
 
-        ACPI_FUNCTION_TRACE("acpi_debug_init");
 
         if (acpi_disabled)
-                return_VALUE(0);
+                return 0;
 
         /* 'debug_layer' [R/W] */
         name = ACPI_SYSTEM_FILE_DEBUG_LAYER;
@@ -213,15 +211,12 @@ static int __init acpi_debug_init(void)
                 goto Error;
 
       Done:
-        return_VALUE(error);
+        return error;
 
       Error:
-        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                          "Unable to create '%s' proc fs entry\n", name));
-
         remove_proc_entry(ACPI_SYSTEM_FILE_DEBUG_LEVEL, acpi_root_dir);
         remove_proc_entry(ACPI_SYSTEM_FILE_DEBUG_LAYER, acpi_root_dir);
-        error = -EFAULT;
+        error = -ENODEV;
         goto Done;
 }
 
diff --git a/drivers/acpi/dispatcher/dsinit.c b/drivers/acpi/dispatcher/dsinit.c
index bbdf990e9f65..1888c055d10f 100644
--- a/drivers/acpi/dispatcher/dsinit.c
+++ b/drivers/acpi/dispatcher/dsinit.c
@@ -116,46 +116,6 @@ acpi_ds_init_one_object(acpi_handle obj_handle,
 
         case ACPI_TYPE_METHOD:
 
-                /*
-                 * Set the execution data width (32 or 64) based upon the
-                 * revision number of the parent ACPI table.
-                 * TBD: This is really for possible future support of integer width
-                 * on a per-table basis. Currently, we just use a global for the width.
-                 */
-                if (info->table_desc->pointer->revision == 1) {
-                        node->flags |= ANOBJ_DATA_WIDTH_32;
-                }
-#ifdef ACPI_INIT_PARSE_METHODS
-                /*
-                 * Note 11/2005: Removed this code to parse all methods during table
-                 * load because it causes problems if there are any errors during the
-                 * parse. Also, it seems like overkill and we probably don't want to
-                 * abort a table load because of an issue with a single method.
-                 */
-
-                /*
-                 * Print a dot for each method unless we are going to print
-                 * the entire pathname
-                 */
-                if (!(acpi_dbg_level & ACPI_LV_INIT_NAMES)) {
-                        ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, "."));
-                }
-
-                /*
-                 * Always parse methods to detect errors, we will delete
-                 * the parse tree below
-                 */
-                status = acpi_ds_parse_method(obj_handle);
-                if (ACPI_FAILURE(status)) {
-                        ACPI_ERROR((AE_INFO,
-                                    "Method %p [%4.4s] - parse failure, %s",
-                                    obj_handle,
-                                    acpi_ut_get_node_name(obj_handle),
-                                    acpi_format_exception(status)));
-
-                        /* This parse failed, but we will continue parsing more methods */
-                }
-#endif
                 info->method_count++;
                 break;
 
diff --git a/drivers/acpi/dispatcher/dsmethod.c b/drivers/acpi/dispatcher/dsmethod.c
index bc9aca4e7401..cf888add3191 100644
--- a/drivers/acpi/dispatcher/dsmethod.c
+++ b/drivers/acpi/dispatcher/dsmethod.c
@@ -52,6 +52,10 @@
 #define _COMPONENT          ACPI_DISPATCHER
 ACPI_MODULE_NAME("dsmethod")
 
+/* Local prototypes */
+static acpi_status
+acpi_ds_create_method_mutex(union acpi_operand_object *method_desc);
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ds_method_error
@@ -67,6 +71,7 @@ ACPI_MODULE_NAME("dsmethod")
  *              Note: Allows the exception handler to change the status code
  *
  ******************************************************************************/
+
 acpi_status
 acpi_ds_method_error(acpi_status status, struct acpi_walk_state *walk_state)
 {
@@ -113,11 +118,51 @@ acpi_ds_method_error(acpi_status status, struct acpi_walk_state *walk_state)
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_ds_create_method_mutex
+ *
+ * PARAMETERS:  obj_desc            - The method object
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Create a mutex object for a serialized control method
+ *
+ ******************************************************************************/
+
+static acpi_status
+acpi_ds_create_method_mutex(union acpi_operand_object *method_desc)
+{
+        union acpi_operand_object *mutex_desc;
+        acpi_status status;
+
+        ACPI_FUNCTION_TRACE(ds_create_method_mutex);
+
+        /* Create the new mutex object */
+
+        mutex_desc = acpi_ut_create_internal_object(ACPI_TYPE_MUTEX);
+        if (!mutex_desc) {
+                return_ACPI_STATUS(AE_NO_MEMORY);
+        }
+
+        /* Create the actual OS Mutex */
+
+        status = acpi_os_create_mutex(&mutex_desc->mutex.os_mutex);
+        if (ACPI_FAILURE(status)) {
+                return_ACPI_STATUS(status);
+        }
+
+        mutex_desc->mutex.sync_level = method_desc->method.sync_level;
+        method_desc->method.mutex = mutex_desc;
+        return_ACPI_STATUS(AE_OK);
+}
+
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_ds_begin_method_execution
  *
  * PARAMETERS:  method_node         - Node of the method
  *              obj_desc            - The method object
- *              calling_method_node - Caller of this method (if non-null)
+ *              walk_state          - current state, NULL if not yet executing
+ *                                    a method.
  *
  * RETURN:      Status
  *
@@ -128,9 +173,9 @@ acpi_ds_method_error(acpi_status status, struct acpi_walk_state *walk_state)
  ******************************************************************************/
 
 acpi_status
-acpi_ds_begin_method_execution(struct acpi_namespace_node * method_node,
-                               union acpi_operand_object * obj_desc,
-                               struct acpi_namespace_node * calling_method_node)
+acpi_ds_begin_method_execution(struct acpi_namespace_node *method_node,
+                               union acpi_operand_object *obj_desc,
+                               struct acpi_walk_state *walk_state)
 {
         acpi_status status = AE_OK;
 
@@ -149,35 +194,80 @@ acpi_ds_begin_method_execution(struct acpi_namespace_node * method_node,
         }
 
         /*
-         * If there is a concurrency limit on this method, we need to
-         * obtain a unit from the method semaphore.
+         * If this method is serialized, we need to acquire the method mutex.
          */
-        if (obj_desc->method.semaphore) {
+        if (obj_desc->method.method_flags & AML_METHOD_SERIALIZED) {
                 /*
-                 * Allow recursive method calls, up to the reentrancy/concurrency
-                 * limit imposed by the SERIALIZED rule and the sync_level method
-                 * parameter.
-                 *
-                 * The point of this code is to avoid permanently blocking a
-                 * thread that is making recursive method calls.
+                 * Create a mutex for the method if it is defined to be Serialized
+                 * and a mutex has not already been created. We defer the mutex creation
+                 * until a method is actually executed, to minimize the object count
                  */
-                if (method_node == calling_method_node) {
-                        if (obj_desc->method.thread_count >=
-                            obj_desc->method.concurrency) {
-                                return_ACPI_STATUS(AE_AML_METHOD_LIMIT);
+                if (!obj_desc->method.mutex) {
+                        status = acpi_ds_create_method_mutex(obj_desc);
+                        if (ACPI_FAILURE(status)) {
+                                return_ACPI_STATUS(status);
                         }
                 }
 
                 /*
-                 * Get a unit from the method semaphore. This releases the
-                 * interpreter if we block (then reacquires it)
+                 * The current_sync_level (per-thread) must be less than or equal to
+                 * the sync level of the method. This mechanism provides some
+                 * deadlock prevention
+                 *
+                 * Top-level method invocation has no walk state at this point
                  */
-                status =
-                    acpi_ex_system_wait_semaphore(obj_desc->method.semaphore,
-                                                  ACPI_WAIT_FOREVER);
-                if (ACPI_FAILURE(status)) {
-                        return_ACPI_STATUS(status);
+                if (walk_state &&
+                    (walk_state->thread->current_sync_level >
+                     obj_desc->method.mutex->mutex.sync_level)) {
+                        ACPI_ERROR((AE_INFO,
+                                    "Cannot acquire Mutex for method [%4.4s], current SyncLevel is too large (%d)",
+                                    acpi_ut_get_node_name(method_node),
+                                    walk_state->thread->current_sync_level));
+
+                        return_ACPI_STATUS(AE_AML_MUTEX_ORDER);
                 }
+
+                /*
+                 * Obtain the method mutex if necessary. Do not acquire mutex for a
+                 * recursive call.
+                 */
+                if (!walk_state ||
+                    !obj_desc->method.mutex->mutex.owner_thread ||
+                    (walk_state->thread !=
+                     obj_desc->method.mutex->mutex.owner_thread)) {
+                        /*
+                         * Acquire the method mutex. This releases the interpreter if we
+                         * block (and reacquires it before it returns)
+                         */
+                        status =
+                            acpi_ex_system_wait_mutex(obj_desc->method.mutex->
+                                                      mutex.os_mutex,
+                                                      ACPI_WAIT_FOREVER);
+                        if (ACPI_FAILURE(status)) {
+                                return_ACPI_STATUS(status);
+                        }
+
+                        /* Update the mutex and walk info and save the original sync_level */
+
+                        if (walk_state) {
+                                obj_desc->method.mutex->mutex.
+                                    original_sync_level =
+                                    walk_state->thread->current_sync_level;
+
+                                obj_desc->method.mutex->mutex.owner_thread =
+                                    walk_state->thread;
+                                walk_state->thread->current_sync_level =
+                                    obj_desc->method.sync_level;
+                        } else {
+                                obj_desc->method.mutex->mutex.
+                                    original_sync_level =
+                                    obj_desc->method.mutex->mutex.sync_level;
+                        }
+                }
+
+                /* Always increase acquisition depth */
+
+                obj_desc->method.mutex->mutex.acquisition_depth++;
         }
 
         /*
@@ -200,10 +290,10 @@ acpi_ds_begin_method_execution(struct acpi_namespace_node * method_node,
         return_ACPI_STATUS(status);
 
       cleanup:
-        /* On error, must signal the method semaphore if present */
+        /* On error, must release the method mutex (if present) */
 
-        if (obj_desc->method.semaphore) {
-                (void)acpi_os_signal_semaphore(obj_desc->method.semaphore, 1);
+        if (obj_desc->method.mutex) {
+                acpi_os_release_mutex(obj_desc->method.mutex->mutex.os_mutex);
         }
         return_ACPI_STATUS(status);
 }
@@ -253,10 +343,10 @@ acpi_ds_call_control_method(struct acpi_thread_state *thread,
                 return_ACPI_STATUS(AE_NULL_OBJECT);
         }
 
-        /* Init for new method, possibly wait on concurrency semaphore */
+        /* Init for new method, possibly wait on method mutex */
 
         status = acpi_ds_begin_method_execution(method_node, obj_desc,
-                                                this_walk_state->method_node);
+                                                this_walk_state);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
         }
@@ -403,7 +493,7 @@ acpi_ds_restart_control_method(struct acpi_walk_state *walk_state,
 
         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
                           "****Restart [%4.4s] Op %p ReturnValueFromCallee %p\n",
-                          (char *)&walk_state->method_node->name,
+                          acpi_ut_get_node_name(walk_state->method_node),
                           walk_state->method_call_op, return_desc));
 
         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
@@ -478,6 +568,8 @@ acpi_ds_restart_control_method(struct acpi_walk_state *walk_state,
  *              created, delete all locals and arguments, and delete the parse
  *              tree if requested.
  *
+ * MUTEX:       Interpreter is locked
+ *
  ******************************************************************************/
 
 void
@@ -503,26 +595,22 @@ acpi_ds_terminate_control_method(union acpi_operand_object *method_desc,
         }
 
         /*
-         * Lock the parser while we terminate this method.
-         * If this is the last thread executing the method,
-         * we have additional cleanup to perform
+         * If method is serialized, release the mutex and restore the
+         * current sync level for this thread
          */
-        status = acpi_ut_acquire_mutex(ACPI_MTX_CONTROL_METHOD);
-        if (ACPI_FAILURE(status)) {
-                return_VOID;
-        }
-
-        /* Signal completion of the execution of this method if necessary */
+        if (method_desc->method.mutex) {
 
-        if (method_desc->method.semaphore) {
-                status =
-                    acpi_os_signal_semaphore(method_desc->method.semaphore, 1);
-                if (ACPI_FAILURE(status)) {
+                /* Acquisition Depth handles recursive calls */
 
-                        /* Ignore error and continue */
+                method_desc->method.mutex->mutex.acquisition_depth--;
+                if (!method_desc->method.mutex->mutex.acquisition_depth) {
+                        walk_state->thread->current_sync_level =
+                            method_desc->method.mutex->mutex.
+                            original_sync_level;
 
-                        ACPI_EXCEPTION((AE_INFO, status,
-                                        "Could not signal method semaphore"));
+                        acpi_os_release_mutex(method_desc->method.mutex->mutex.
+                                              os_mutex);
+                        method_desc->method.mutex->mutex.owner_thread = NULL;
                 }
         }
 
@@ -533,27 +621,11 @@ acpi_ds_terminate_control_method(union acpi_operand_object *method_desc,
                  */
                 method_node = walk_state->method_node;
 
-                /* Lock namespace for possible update */
-
-                status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
-                if (ACPI_FAILURE(status)) {
-                        goto exit;
-                }
-
-                /*
-                 * Delete any namespace entries created immediately underneath
-                 * the method
-                 */
-                if (method_node && method_node->child) {
-                        acpi_ns_delete_namespace_subtree(method_node);
-                }
-
                 /*
-                 * Delete any namespace entries created anywhere else within
+                 * Delete any namespace objects created anywhere within
                  * the namespace by the execution of this method
                  */
                 acpi_ns_delete_namespace_by_owner(method_desc->method.owner_id);
-                status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
         }
 
         /* Decrement the thread count on the method */
@@ -580,18 +652,16 @@ acpi_ds_terminate_control_method(union acpi_operand_object *method_desc,
                 /*
                  * Support to dynamically change a method from not_serialized to
                  * Serialized if it appears that the method is incorrectly written and
-                 * does not support multiple thread execution.  The best example of this
-                 * is if such a method creates namespace objects and blocks.  A second
+                 * does not support multiple thread execution. The best example of this
+                 * is if such a method creates namespace objects and blocks. A second
                  * thread will fail with an AE_ALREADY_EXISTS exception
                  *
                  * This code is here because we must wait until the last thread exits
                  * before creating the synchronization semaphore.
                  */
-                if ((method_desc->method.concurrency == 1) &&
-                    (!method_desc->method.semaphore)) {
-                        status = acpi_os_create_semaphore(1, 1,
-                                                          &method_desc->method.
-                                                          semaphore);
+                if ((method_desc->method.method_flags & AML_METHOD_SERIALIZED)
+                    && (!method_desc->method.mutex)) {
+                        status = acpi_ds_create_method_mutex(method_desc);
                 }
 
                 /* No more threads, we can free the owner_id */
@@ -599,144 +669,5 @@ acpi_ds_terminate_control_method(union acpi_operand_object *method_desc,
                 acpi_ut_release_owner_id(&method_desc->method.owner_id);
         }
 
-      exit:
-        (void)acpi_ut_release_mutex(ACPI_MTX_CONTROL_METHOD);
         return_VOID;
 }
-
-#ifdef ACPI_INIT_PARSE_METHODS
-        /*
-         * Note 11/2005: Removed this code to parse all methods during table
-         * load because it causes problems if there are any errors during the
-         * parse. Also, it seems like overkill and we probably don't want to
-         * abort a table load because of an issue with a single method.
-         */
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ds_parse_method
- *
- * PARAMETERS:  Node        - Method node
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Parse the AML that is associated with the method.
- *
- * MUTEX:       Assumes parser is locked
- *
- ******************************************************************************/
-
-acpi_status acpi_ds_parse_method(struct acpi_namespace_node *node)
-{
-        acpi_status status;
-        union acpi_operand_object *obj_desc;
-        union acpi_parse_object *op;
-        struct acpi_walk_state *walk_state;
-
-        ACPI_FUNCTION_TRACE_PTR(ds_parse_method, node);
-
-        /* Parameter Validation */
-
-        if (!node) {
-                return_ACPI_STATUS(AE_NULL_ENTRY);
-        }
-
-        ACPI_DEBUG_PRINT((ACPI_DB_PARSE,
-                          "**** Parsing [%4.4s] **** NamedObj=%p\n",
-                          acpi_ut_get_node_name(node), node));
-
-        /* Extract the method object from the method Node */
-
-        obj_desc = acpi_ns_get_attached_object(node);
-        if (!obj_desc) {
-                return_ACPI_STATUS(AE_NULL_OBJECT);
-        }
-
-        /* Create a mutex for the method if there is a concurrency limit */
-
-        if ((obj_desc->method.concurrency != ACPI_INFINITE_CONCURRENCY) &&
-            (!obj_desc->method.semaphore)) {
-                status = acpi_os_create_semaphore(obj_desc->method.concurrency,
-                                                  obj_desc->method.concurrency,
-                                                  &obj_desc->method.semaphore);
-                if (ACPI_FAILURE(status)) {
-                        return_ACPI_STATUS(status);
-                }
-        }
-
-        /*
-         * Allocate a new parser op to be the root of the parsed
-         * method tree
-         */
-        op = acpi_ps_alloc_op(AML_METHOD_OP);
-        if (!op) {
-                return_ACPI_STATUS(AE_NO_MEMORY);
-        }
-
-        /* Init new op with the method name and pointer back to the Node */
-
-        acpi_ps_set_name(op, node->name.integer);
-        op->common.node = node;
-
-        /*
-         * Get a new owner_id for objects created by this method. Namespace
-         * objects (such as Operation Regions) can be created during the
-         * first pass parse.
-         */
-        status = acpi_ut_allocate_owner_id(&obj_desc->method.owner_id);
-        if (ACPI_FAILURE(status)) {
-                goto cleanup;
-        }
-
-        /* Create and initialize a new walk state */
-
-        walk_state =
-            acpi_ds_create_walk_state(obj_desc->method.owner_id, NULL, NULL,
-                                      NULL);
-        if (!walk_state) {
-                status = AE_NO_MEMORY;
-                goto cleanup2;
-        }
-
-        status = acpi_ds_init_aml_walk(walk_state, op, node,
-                                       obj_desc->method.aml_start,
-                                       obj_desc->method.aml_length, NULL, 1);
-        if (ACPI_FAILURE(status)) {
-                acpi_ds_delete_walk_state(walk_state);
-                goto cleanup2;
-        }
-
-        /*
-         * Parse the method, first pass
-         *
-         * The first pass load is where newly declared named objects are added into
-         * the namespace.  Actual evaluation of the named objects (what would be
-         * called a "second pass") happens during the actual execution of the
-         * method so that operands to the named objects can take on dynamic
-         * run-time values.
-         */
-        status = acpi_ps_parse_aml(walk_state);
-        if (ACPI_FAILURE(status)) {
-                goto cleanup2;
-        }
-
-        ACPI_DEBUG_PRINT((ACPI_DB_PARSE,
-                          "**** [%4.4s] Parsed **** NamedObj=%p Op=%p\n",
-                          acpi_ut_get_node_name(node), node, op));
-
-        /*
-         * Delete the parse tree. We simply re-parse the method for every
-         * execution since there isn't much overhead (compared to keeping lots
-         * of parse trees around)
-         */
-        acpi_ns_delete_namespace_subtree(node);
-        acpi_ns_delete_namespace_by_owner(obj_desc->method.owner_id);
-
-      cleanup2:
-        acpi_ut_release_owner_id(&obj_desc->method.owner_id);
-
-      cleanup:
-        acpi_ps_delete_parse_tree(op);
-        return_ACPI_STATUS(status);
-}
-#endif
diff --git a/drivers/acpi/dispatcher/dswexec.c b/drivers/acpi/dispatcher/dswexec.c
index 3acbd9145d72..d7a616c3104e 100644
--- a/drivers/acpi/dispatcher/dswexec.c
+++ b/drivers/acpi/dispatcher/dswexec.c
@@ -313,10 +313,10 @@ acpi_ds_exec_begin_op(struct acpi_walk_state *walk_state,
         case AML_CLASS_EXECUTE:
         case AML_CLASS_CREATE:
                 /*
-                 * Most operators with arguments.
+                 * Most operators with arguments (except create_xxx_field operators)
                  * Start a new result/operand state
                  */
-                if (walk_state->opcode != AML_CREATE_FIELD_OP) {
+                if (walk_state->op_info->object_type != ACPI_TYPE_BUFFER_FIELD) {
                         status = acpi_ds_result_stack_push(walk_state);
                 }
                 break;
@@ -472,7 +472,6 @@ acpi_status acpi_ds_exec_end_op(struct acpi_walk_state *walk_state)
                             acpi_ds_result_push(walk_state->result_obj,
                                                 walk_state);
                 }
-
                 break;
 
         default:
@@ -510,6 +509,7 @@ acpi_status acpi_ds_exec_end_op(struct acpi_walk_state *walk_state)
                                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
                                                   "Method Reference in a Package, Op=%p\n",
                                                   op));
+
                                 op->common.node =
                                     (struct acpi_namespace_node *)op->asl.value.
                                     arg->asl.node->object;
@@ -670,7 +670,6 @@ acpi_status acpi_ds_exec_end_op(struct acpi_walk_state *walk_state)
 
                                 status = acpi_ds_result_stack_pop(walk_state);
                         }
-
                         break;
 
                 case AML_TYPE_UNDEFINED:
@@ -708,7 +707,6 @@ acpi_status acpi_ds_exec_end_op(struct acpi_walk_state *walk_state)
          * Check if we just completed the evaluation of a
          * conditional predicate
          */
-
         if ((ACPI_SUCCESS(status)) &&
             (walk_state->control_state) &&
             (walk_state->control_state->common.state ==
diff --git a/drivers/acpi/dispatcher/dswload.c b/drivers/acpi/dispatcher/dswload.c
index 35074399c617..e3ca7f6539c1 100644
--- a/drivers/acpi/dispatcher/dswload.c
+++ b/drivers/acpi/dispatcher/dswload.c
@@ -175,7 +175,7 @@ acpi_ds_load1_begin_op(struct acpi_walk_state * walk_state,
                 if (status == AE_NOT_FOUND) {
                         /*
                          * Table disassembly:
-                         * Target of Scope() not found.  Generate an External for it, and
+                         * Target of Scope() not found. Generate an External for it, and
                          * insert the name into the namespace.
                          */
                         acpi_dm_add_to_external_list(path, ACPI_TYPE_DEVICE, 0);
@@ -210,16 +210,15 @@ acpi_ds_load1_begin_op(struct acpi_walk_state * walk_state,
                 case ACPI_TYPE_BUFFER:
 
                         /*
-                         * These types we will allow, but we will change the type.  This
+                         * These types we will allow, but we will change the type. This
                          * enables some existing code of the form:
                          *
                          *  Name (DEB, 0)
                          *  Scope (DEB) { ... }
                          *
-                         * Note: silently change the type here.  On the second pass, we will report
+                         * Note: silently change the type here. On the second pass, we will report
                          * a warning
                          */
-
                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                           "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
                                           path,
@@ -242,7 +241,6 @@ acpi_ds_load1_begin_op(struct acpi_walk_state * walk_state,
                 break;
 
         default:
-
                 /*
                  * For all other named opcodes, we will enter the name into
                  * the namespace.
@@ -259,7 +257,6 @@ acpi_ds_load1_begin_op(struct acpi_walk_state * walk_state,
                  *       buffer_field, or Package), the name of the object is already
                  *       in the namespace.
                  */
-
                 if (walk_state->deferred_node) {
 
                         /* This name is already in the namespace, get the node */
@@ -293,8 +290,8 @@ acpi_ds_load1_begin_op(struct acpi_walk_state * walk_state,
                 }
 
                 /*
-                 * Enter the named type into the internal namespace.  We enter the name
-                 * as we go downward in the parse tree.  Any necessary subobjects that
+                 * Enter the named type into the internal namespace. We enter the name
+                 * as we go downward in the parse tree. Any necessary subobjects that
                  * involve arguments to the opcode must be created as we go back up the
                  * parse tree later.
                  */
@@ -327,12 +324,12 @@ acpi_ds_load1_begin_op(struct acpi_walk_state * walk_state,
                                                             (status);
                                                 }
                                         }
+
                                         status = AE_OK;
                                 }
                         }
 
                         if (ACPI_FAILURE(status)) {
-
                                 ACPI_ERROR_NAMESPACE(path, status);
                                 return_ACPI_STATUS(status);
                         }
@@ -434,9 +431,13 @@ acpi_status acpi_ds_load1_end_op(struct acpi_walk_state *walk_state)
                         status =
                             acpi_ex_create_region(op->named.data,
                                                   op->named.length,
-                                                  (acpi_adr_space_type)
-                                                  ((op->common.value.arg)->
-                                                   common.value.integer),
+                                                  (acpi_adr_space_type) ((op->
+                                                                          common.
+                                                                          value.
+                                                                          arg)->
+                                                                         common.
+                                                                         value.
+                                                                         integer),
                                                   walk_state);
                         if (ACPI_FAILURE(status)) {
                                 return_ACPI_STATUS(status);
@@ -474,7 +475,7 @@ acpi_status acpi_ds_load1_end_op(struct acpi_walk_state *walk_state)
                          * method_op pkg_length name_string method_flags term_list
                          *
                          * Note: We must create the method node/object pair as soon as we
-                         * see the method declaration.  This allows later pass1 parsing
+                         * see the method declaration. This allows later pass1 parsing
                          * of invocations of the method (need to know the number of
                          * arguments.)
                          */
@@ -499,6 +500,7 @@ acpi_status acpi_ds_load1_end_op(struct acpi_walk_state *walk_state)
                                                                   length,
                                                                   walk_state);
                                 }
+
                                 walk_state->operands[0] = NULL;
                                 walk_state->num_operands = 0;
 
@@ -570,7 +572,6 @@ acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
 #ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
                         if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
                             (walk_state->op_info->class == AML_CLASS_CONTROL)) {
-
                                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
                                                   "Begin/EXEC: %s (fl %8.8X)\n",
                                                   walk_state->op_info->name,
@@ -602,7 +603,7 @@ acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
                 } else {
                         /* Get name from the op */
 
-                        buffer_ptr = (char *)&op->named.name;
+                        buffer_ptr = ACPI_CAST_PTR(char, &op->named.name);
                 }
         } else {
                 /* Get the namestring from the raw AML */
@@ -629,7 +630,6 @@ acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
                 break;
 
         case AML_INT_NAMEPATH_OP:
-
                 /*
                  * The name_path is an object reference to an existing object.
                  * Don't enter the name into the namespace, but look it up
@@ -642,7 +642,6 @@ acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
                 break;
 
         case AML_SCOPE_OP:
-
                 /*
                  * The Path is an object reference to an existing object.
                  * Don't enter the name into the namespace, but look it up
@@ -664,6 +663,7 @@ acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
 #endif
                         return_ACPI_STATUS(status);
                 }
+
                 /*
                  * We must check to make sure that the target is
                  * one of the opcodes that actually opens a scope
@@ -683,13 +683,12 @@ acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
                 case ACPI_TYPE_BUFFER:
 
                         /*
-                         * These types we will allow, but we will change the type.  This
+                         * These types we will allow, but we will change the type. This
                          * enables some existing code of the form:
                          *
                          *  Name (DEB, 0)
                          *  Scope (DEB) { ... }
                          */
-
                         ACPI_WARNING((AE_INFO,
                                       "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)",
                                       buffer_ptr,
@@ -729,14 +728,14 @@ acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
                                 if (ACPI_FAILURE(status)) {
                                         return_ACPI_STATUS(status);
                                 }
-
                         }
+
                         return_ACPI_STATUS(AE_OK);
                 }
 
                 /*
-                 * Enter the named type into the internal namespace.  We enter the name
-                 * as we go downward in the parse tree.  Any necessary subobjects that
+                 * Enter the named type into the internal namespace. We enter the name
+                 * as we go downward in the parse tree. Any necessary subobjects that
                  * involve arguments to the opcode must be created as we go back up the
                  * parse tree later.
                  *
@@ -787,7 +786,6 @@ acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
          * can get it again quickly when this scope is closed
          */
         op->common.node = node;
-
         return_ACPI_STATUS(status);
 }
 
@@ -922,7 +920,6 @@ acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
 #ifndef ACPI_NO_METHOD_EXECUTION
 
         case AML_TYPE_CREATE_FIELD:
-
                 /*
                  * Create the field object, but the field buffer and index must
                  * be evaluated later during the execution phase
@@ -931,7 +928,6 @@ acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
                 break;
 
         case AML_TYPE_NAMED_FIELD:
-
                 /*
                  * If we are executing a method, initialize the field
                  */
@@ -1051,6 +1047,7 @@ acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
                          * argument is the space_id. (We must save the address of the
                          * AML of the address and length operands)
                          */
+
                         /*
                          * If we have a valid region, initialize it
                          * Namespace is NOT locked at this point.
@@ -1080,7 +1077,7 @@ acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
                          * method_op pkg_length name_string method_flags term_list
                          *
                          * Note: We must create the method node/object pair as soon as we
-                         * see the method declaration.  This allows later pass1 parsing
+                         * see the method declaration. This allows later pass1 parsing
                          * of invocations of the method (need to know the number of
                          * arguments.)
                          */
diff --git a/drivers/acpi/dock.c b/drivers/acpi/dock.c
new file mode 100644
index 000000000000..578b99b71d9c
--- /dev/null
+++ b/drivers/acpi/dock.c
@@ -0,0 +1,739 @@
+/*
+ *  dock.c - ACPI dock station driver
+ *
+ *  Copyright (C) 2006 Kristen Carlson Accardi <kristen.c.accardi@intel.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or (at
+ *  your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but
+ *  WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/notifier.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+#define ACPI_DOCK_DRIVER_NAME "ACPI Dock Station Driver"
+
+ACPI_MODULE_NAME("dock")
+MODULE_AUTHOR("Kristen Carlson Accardi");
+MODULE_DESCRIPTION(ACPI_DOCK_DRIVER_NAME);
+MODULE_LICENSE("GPL");
+
+static struct atomic_notifier_head dock_notifier_list;
+
+struct dock_station {
+        acpi_handle handle;
+        unsigned long last_dock_time;
+        u32 flags;
+        spinlock_t dd_lock;
+        spinlock_t hp_lock;
+        struct list_head dependent_devices;
+        struct list_head hotplug_devices;
+};
+
+struct dock_dependent_device {
+        struct list_head list;
+        struct list_head hotplug_list;
+        acpi_handle handle;
+        acpi_notify_handler handler;
+        void *context;
+};
+
+#define DOCK_DOCKING    0x00000001
+#define DOCK_EVENT      3
+#define UNDOCK_EVENT    2
+
+static struct dock_station *dock_station;
+
+/*****************************************************************************
+ *                         Dock Dependent device functions                   *
+ *****************************************************************************/
+/**
+ *  alloc_dock_dependent_device - allocate and init a dependent device
+ *  @handle: the acpi_handle of the dependent device
+ *
+ *  Allocate memory for a dependent device structure for a device referenced
+ *  by the acpi handle
+ */
+static struct dock_dependent_device *
+alloc_dock_dependent_device(acpi_handle handle)
+{
+        struct dock_dependent_device *dd;
+
+        dd = kzalloc(sizeof(*dd), GFP_KERNEL);
+        if (dd) {
+                dd->handle = handle;
+                INIT_LIST_HEAD(&dd->list);
+                INIT_LIST_HEAD(&dd->hotplug_list);
+        }
+        return dd;
+}
+
+/**
+ * add_dock_dependent_device - associate a device with the dock station
+ * @ds: The dock station
+ * @dd: The dependent device
+ *
+ * Add the dependent device to the dock's dependent device list.
+ */
+static void
+add_dock_dependent_device(struct dock_station *ds,
+                          struct dock_dependent_device *dd)
+{
+        spin_lock(&ds->dd_lock);
+        list_add_tail(&dd->list, &ds->dependent_devices);
+        spin_unlock(&ds->dd_lock);
+}
+
+/**
+ * dock_add_hotplug_device - associate a hotplug handler with the dock station
+ * @ds: The dock station
+ * @dd: The dependent device struct
+ *
+ * Add the dependent device to the dock's hotplug device list
+ */
+static void
+dock_add_hotplug_device(struct dock_station *ds,
+                        struct dock_dependent_device *dd)
+{
+        spin_lock(&ds->hp_lock);
+        list_add_tail(&dd->hotplug_list, &ds->hotplug_devices);
+        spin_unlock(&ds->hp_lock);
+}
+
+/**
+ * dock_del_hotplug_device - remove a hotplug handler from the dock station
+ * @ds: The dock station
+ * @dd: the dependent device struct
+ *
+ * Delete the dependent device from the dock's hotplug device list
+ */
+static void
+dock_del_hotplug_device(struct dock_station *ds,
+                        struct dock_dependent_device *dd)
+{
+        spin_lock(&ds->hp_lock);
+        list_del(&dd->hotplug_list);
+        spin_unlock(&ds->hp_lock);
+}
+
+/**
+ * find_dock_dependent_device - get a device dependent on this dock
+ * @ds: the dock station
+ * @handle: the acpi_handle of the device we want
+ *
+ * iterate over the dependent device list for this dock.  If the
+ * dependent device matches the handle, return.
+ */
+static struct dock_dependent_device *
+find_dock_dependent_device(struct dock_station *ds, acpi_handle handle)
+{
+        struct dock_dependent_device *dd;
+
+        spin_lock(&ds->dd_lock);
+        list_for_each_entry(dd, &ds->dependent_devices, list) {
+                if (handle == dd->handle) {
+                        spin_unlock(&ds->dd_lock);
+                        return dd;
+                }
+        }
+        spin_unlock(&ds->dd_lock);
+        return NULL;
+}
+
+/*****************************************************************************
+ *                         Dock functions                                    *
+ *****************************************************************************/
+/**
+ * is_dock - see if a device is a dock station
+ * @handle: acpi handle of the device
+ *
+ * If an acpi object has a _DCK method, then it is by definition a dock
+ * station, so return true.
+ */
+static int is_dock(acpi_handle handle)
+{
+        acpi_status status;
+        acpi_handle tmp;
+
+        status = acpi_get_handle(handle, "_DCK", &tmp);
+        if (ACPI_FAILURE(status))
+                return 0;
+        return 1;
+}
+
+/**
+ * is_dock_device - see if a device is on a dock station
+ * @handle: acpi handle of the device
+ *
+ * If this device is either the dock station itself,
+ * or is a device dependent on the dock station, then it
+ * is a dock device
+ */
+int is_dock_device(acpi_handle handle)
+{
+        if (!dock_station)
+                return 0;
+
+        if (is_dock(handle) || find_dock_dependent_device(dock_station, handle))
+                return 1;
+
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(is_dock_device);
+
+/**
+ * dock_present - see if the dock station is present.
+ * @ds: the dock station
+ *
+ * execute the _STA method.  note that present does not
+ * imply that we are docked.
+ */
+static int dock_present(struct dock_station *ds)
+{
+        unsigned long sta;
+        acpi_status status;
+
+        if (ds) {
+                status = acpi_evaluate_integer(ds->handle, "_STA", NULL, &sta);
+                if (ACPI_SUCCESS(status) && sta)
+                        return 1;
+        }
+        return 0;
+}
+
+
+
+/**
+ * dock_create_acpi_device - add new devices to acpi
+ * @handle - handle of the device to add
+ *
+ *  This function will create a new acpi_device for the given
+ *  handle if one does not exist already.  This should cause
+ *  acpi to scan for drivers for the given devices, and call
+ *  matching driver's add routine.
+ *
+ *  Returns a pointer to the acpi_device corresponding to the handle.
+ */
+static struct acpi_device * dock_create_acpi_device(acpi_handle handle)
+{
+        struct acpi_device *device = NULL;
+        struct acpi_device *parent_device;
+        acpi_handle parent;
+        int ret;
+
+        if (acpi_bus_get_device(handle, &device)) {
+                /*
+                 * no device created for this object,
+                 * so we should create one.
+                 */
+                acpi_get_parent(handle, &parent);
+                if (acpi_bus_get_device(parent, &parent_device))
+                        parent_device = NULL;
+
+                ret = acpi_bus_add(&device, parent_device, handle,
+                        ACPI_BUS_TYPE_DEVICE);
+                if (ret) {
+                        pr_debug("error adding bus, %x\n",
+                                -ret);
+                        return NULL;
+                }
+        }
+        return device;
+}
+
+/**
+ * dock_remove_acpi_device - remove the acpi_device struct from acpi
+ * @handle - the handle of the device to remove
+ *
+ *  Tell acpi to remove the acpi_device.  This should cause any loaded
+ *  driver to have it's remove routine called.
+ */
+static void dock_remove_acpi_device(acpi_handle handle)
+{
+        struct acpi_device *device;
+        int ret;
+
+        if (!acpi_bus_get_device(handle, &device)) {
+                ret = acpi_bus_trim(device, 1);
+                if (ret)
+                        pr_debug("error removing bus, %x\n", -ret);
+        }
+}
+
+
+/**
+ * hotplug_dock_devices - insert or remove devices on the dock station
+ * @ds: the dock station
+ * @event: either bus check or eject request
+ *
+ * Some devices on the dock station need to have drivers called
+ * to perform hotplug operations after a dock event has occurred.
+ * Traverse the list of dock devices that have registered a
+ * hotplug handler, and call the handler.
+ */
+static void hotplug_dock_devices(struct dock_station *ds, u32 event)
+{
+        struct dock_dependent_device *dd;
+
+        spin_lock(&ds->hp_lock);
+
+        /*
+         * First call driver specific hotplug functions
+         */
+        list_for_each_entry(dd, &ds->hotplug_devices, hotplug_list) {
+                if (dd->handler)
+                        dd->handler(dd->handle, event, dd->context);
+        }
+
+        /*
+         * Now make sure that an acpi_device is created for each
+         * dependent device, or removed if this is an eject request.
+         * This will cause acpi_drivers to be stopped/started if they
+         * exist
+         */
+        list_for_each_entry(dd, &ds->dependent_devices, list) {
+                if (event == ACPI_NOTIFY_EJECT_REQUEST)
+                        dock_remove_acpi_device(dd->handle);
+                else
+                        dock_create_acpi_device(dd->handle);
+        }
+        spin_unlock(&ds->hp_lock);
+}
+
+static void dock_event(struct dock_station *ds, u32 event, int num)
+{
+        /*
+         * we don't do events until someone tells me that
+         * they would like to have them.
+         */
+}
+
+/**
+ * eject_dock - respond to a dock eject request
+ * @ds: the dock station
+ *
+ * This is called after _DCK is called, to execute the dock station's
+ * _EJ0 method.
+ */
+static void eject_dock(struct dock_station *ds)
+{
+        struct acpi_object_list arg_list;
+        union acpi_object arg;
+        acpi_status status;
+        acpi_handle tmp;
+
+        /* all dock devices should have _EJ0, but check anyway */
+        status = acpi_get_handle(ds->handle, "_EJ0", &tmp);
+        if (ACPI_FAILURE(status)) {
+                pr_debug("No _EJ0 support for dock device\n");
+                return;
+        }
+
+        arg_list.count = 1;
+        arg_list.pointer = &arg;
+        arg.type = ACPI_TYPE_INTEGER;
+        arg.integer.value = 1;
+
+        if (ACPI_FAILURE(acpi_evaluate_object(ds->handle, "_EJ0",
+                                              &arg_list, NULL)))
+                pr_debug("Failed to evaluate _EJ0!\n");
+}
+
+/**
+ * handle_dock - handle a dock event
+ * @ds: the dock station
+ * @dock: to dock, or undock - that is the question
+ *
+ * Execute the _DCK method in response to an acpi event
+ */
+static void handle_dock(struct dock_station *ds, int dock)
+{
+        acpi_status status;
+        struct acpi_object_list arg_list;
+        union acpi_object arg;
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        struct acpi_buffer name_buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+
+        acpi_get_name(ds->handle, ACPI_FULL_PATHNAME, &name_buffer);
+        obj = name_buffer.pointer;
+
+        printk(KERN_INFO PREFIX "%s\n", dock ? "docking" : "undocking");
+
+        /* _DCK method has one argument */
+        arg_list.count = 1;
+        arg_list.pointer = &arg;
+        arg.type = ACPI_TYPE_INTEGER;
+        arg.integer.value = dock;
+        status = acpi_evaluate_object(ds->handle, "_DCK", &arg_list, &buffer);
+        if (ACPI_FAILURE(status))
+                pr_debug("%s: failed to execute _DCK\n", obj->string.pointer);
+        kfree(buffer.pointer);
+        kfree(name_buffer.pointer);
+}
+
+static inline void dock(struct dock_station *ds)
+{
+        handle_dock(ds, 1);
+}
+
+static inline void undock(struct dock_station *ds)
+{
+        handle_dock(ds, 0);
+}
+
+static inline void begin_dock(struct dock_station *ds)
+{
+        ds->flags |= DOCK_DOCKING;
+}
+
+static inline void complete_dock(struct dock_station *ds)
+{
+        ds->flags &= ~(DOCK_DOCKING);
+        ds->last_dock_time = jiffies;
+}
+
+/**
+ * dock_in_progress - see if we are in the middle of handling a dock event
+ * @ds: the dock station
+ *
+ * Sometimes while docking, false dock events can be sent to the driver
+ * because good connections aren't made or some other reason.  Ignore these
+ * if we are in the middle of doing something.
+ */
+static int dock_in_progress(struct dock_station *ds)
+{
+        if ((ds->flags & DOCK_DOCKING) ||
+            time_before(jiffies, (ds->last_dock_time + HZ)))
+                return 1;
+        return 0;
+}
+
+/**
+ * register_dock_notifier - add yourself to the dock notifier list
+ * @nb: the callers notifier block
+ *
+ * If a driver wishes to be notified about dock events, they can
+ * use this function to put a notifier block on the dock notifier list.
+ * this notifier call chain will be called after a dock event, but
+ * before hotplugging any new devices.
+ */
+int register_dock_notifier(struct notifier_block *nb)
+{
+        return atomic_notifier_chain_register(&dock_notifier_list, nb);
+}
+
+EXPORT_SYMBOL_GPL(register_dock_notifier);
+
+/**
+ * unregister_dock_notifier - remove yourself from the dock notifier list
+ * @nb: the callers notifier block
+ */
+void unregister_dock_notifier(struct notifier_block *nb)
+{
+        atomic_notifier_chain_unregister(&dock_notifier_list, nb);
+}
+
+EXPORT_SYMBOL_GPL(unregister_dock_notifier);
+
+/**
+ * register_hotplug_dock_device - register a hotplug function
+ * @handle: the handle of the device
+ * @handler: the acpi_notifier_handler to call after docking
+ * @context: device specific data
+ *
+ * If a driver would like to perform a hotplug operation after a dock
+ * event, they can register an acpi_notifiy_handler to be called by
+ * the dock driver after _DCK is executed.
+ */
+int
+register_hotplug_dock_device(acpi_handle handle, acpi_notify_handler handler,
+                             void *context)
+{
+        struct dock_dependent_device *dd;
+
+        if (!dock_station)
+                return -ENODEV;
+
+        /*
+         * make sure this handle is for a device dependent on the dock,
+         * this would include the dock station itself
+         */
+        dd = find_dock_dependent_device(dock_station, handle);
+        if (dd) {
+                dd->handler = handler;
+                dd->context = context;
+                dock_add_hotplug_device(dock_station, dd);
+                return 0;
+        }
+
+        return -EINVAL;
+}
+
+EXPORT_SYMBOL_GPL(register_hotplug_dock_device);
+
+/**
+ * unregister_hotplug_dock_device - remove yourself from the hotplug list
+ * @handle: the acpi handle of the device
+ */
+void unregister_hotplug_dock_device(acpi_handle handle)
+{
+        struct dock_dependent_device *dd;
+
+        if (!dock_station)
+                return;
+
+        dd = find_dock_dependent_device(dock_station, handle);
+        if (dd)
+                dock_del_hotplug_device(dock_station, dd);
+}
+
+EXPORT_SYMBOL_GPL(unregister_hotplug_dock_device);
+
+/**
+ * dock_notify - act upon an acpi dock notification
+ * @handle: the dock station handle
+ * @event: the acpi event
+ * @data: our driver data struct
+ *
+ * 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
+ * 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;
+
+        switch (event) {
+        case ACPI_NOTIFY_BUS_CHECK:
+                if (!dock_in_progress(ds) && dock_present(ds)) {
+                        begin_dock(ds);
+                        dock(ds);
+                        if (!dock_present(ds)) {
+                                printk(KERN_ERR PREFIX "Unable to dock!\n");
+                                break;
+                        }
+                        atomic_notifier_call_chain(&dock_notifier_list,
+                                                   event, NULL);
+                        hotplug_dock_devices(ds, event);
+                        complete_dock(ds);
+                        dock_event(ds, event, DOCK_EVENT);
+                }
+                break;
+        case ACPI_NOTIFY_DEVICE_CHECK:
+        /*
+         * According to acpi spec 3.0a, if a DEVICE_CHECK notification
+         * is sent and _DCK is present, it is assumed to mean an
+         * undock request.  This notify routine will only be called
+         * for objects defining _DCK, so we will fall through to eject
+         * request here.  However, we will pass an eject request through
+         * to the driver who wish to hotplug.
+         */
+        case ACPI_NOTIFY_EJECT_REQUEST:
+                if (!dock_in_progress(ds) && dock_present(ds)) {
+                        /*
+                         * 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);
+        }
+}
+
+/**
+ * find_dock_devices - find devices on the dock station
+ * @handle: the handle of the device we are examining
+ * @lvl: unused
+ * @context: the dock station private data
+ * @rv: unused
+ *
+ * This function is called by acpi_walk_namespace.  It will
+ * check to see if an object has an _EJD method.  If it does, then it
+ * will see if it is dependent on the dock station.
+ */
+static acpi_status
+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_dependent_device *dd;
+
+        status = acpi_bus_get_ejd(handle, &tmp);
+        if (ACPI_FAILURE(status))
+                return AE_OK;
+
+        if (tmp == ds->handle) {
+                dd = alloc_dock_dependent_device(handle);
+                if (dd)
+                        add_dock_dependent_device(ds, dd);
+        }
+
+        return AE_OK;
+}
+
+/**
+ * dock_add - add a new dock station
+ * @handle: the dock station handle
+ *
+ * allocated and initialize a new dock station device.  Find all devices
+ * that are on the dock station, and register for dock event notifications.
+ */
+static int dock_add(acpi_handle handle)
+{
+        int ret;
+        acpi_status status;
+        struct dock_dependent_device *dd;
+
+        /* allocate & initialize the dock_station private data */
+        dock_station = kzalloc(sizeof(*dock_station), GFP_KERNEL);
+        if (!dock_station)
+                return -ENOMEM;
+        dock_station->handle = handle;
+        dock_station->last_dock_time = jiffies - HZ;
+        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);
+        ATOMIC_INIT_NOTIFIER_HEAD(&dock_notifier_list);
+
+        /* Find dependent devices */
+        acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
+                            ACPI_UINT32_MAX, find_dock_devices, dock_station,
+                            NULL);
+
+        /* add the dock station as a device dependent on itself */
+        dd = alloc_dock_dependent_device(handle);
+        if (!dd) {
+                kfree(dock_station);
+                return -ENOMEM;
+        }
+        add_dock_dependent_device(dock_station, dd);
+
+        /* register for dock events */
+        status = acpi_install_notify_handler(dock_station->handle,
+                                             ACPI_SYSTEM_NOTIFY,
+                                             dock_notify, dock_station);
+
+        if (ACPI_FAILURE(status)) {
+                printk(KERN_ERR PREFIX "Error installing notify handler\n");
+                ret = -ENODEV;
+                goto dock_add_err;
+        }
+
+        printk(KERN_INFO PREFIX "%s \n", ACPI_DOCK_DRIVER_NAME);
+
+        return 0;
+
+dock_add_err:
+        kfree(dock_station);
+        kfree(dd);
+        return ret;
+}
+
+/**
+ * dock_remove - free up resources related to the dock station
+ */
+static int dock_remove(void)
+{
+        struct dock_dependent_device *dd, *tmp;
+        acpi_status status;
+
+        if (!dock_station)
+                return 0;
+
+        /* remove dependent devices */
+        list_for_each_entry_safe(dd, tmp, &dock_station->dependent_devices,
+                                 list)
+            kfree(dd);
+
+        /* remove dock notify handler */
+        status = acpi_remove_notify_handler(dock_station->handle,
+                                            ACPI_SYSTEM_NOTIFY,
+                                            dock_notify);
+        if (ACPI_FAILURE(status))
+                printk(KERN_ERR "Error removing notify handler\n");
+
+        /* free dock station memory */
+        kfree(dock_station);
+        return 0;
+}
+
+/**
+ * find_dock - look for a dock station
+ * @handle: acpi handle of a device
+ * @lvl: unused
+ * @context: counter of dock stations found
+ * @rv: unused
+ *
+ * This is called by acpi_walk_namespace to look for dock stations.
+ */
+static acpi_status
+find_dock(acpi_handle handle, u32 lvl, void *context, void **rv)
+{
+        int *count = (int *)context;
+        acpi_status status = AE_OK;
+
+        if (is_dock(handle)) {
+                if (dock_add(handle) >= 0) {
+                        (*count)++;
+                        status = AE_CTRL_TERMINATE;
+                }
+        }
+        return status;
+}
+
+static int __init dock_init(void)
+{
+        int num = 0;
+
+        dock_station = NULL;
+
+        /* look for a dock station */
+        acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
+                            ACPI_UINT32_MAX, find_dock, &num, NULL);
+
+        if (!num)
+                return -ENODEV;
+
+        return 0;
+}
+
+static void __exit dock_exit(void)
+{
+        dock_remove();
+}
+
+postcore_initcall(dock_init);
+module_exit(dock_exit);
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index 18b3ea9dace2..e5d796362854 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -207,16 +207,15 @@ static int acpi_ec_intr_wait(union acpi_ec *ec, unsigned int event)
 {
         int result = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_wait");
 
         ec->intr.expect_event = event;
         smp_mb();
 
         switch (event) {
         case ACPI_EC_EVENT_IBE:
-                if (~acpi_ec_read_status(ec) & event) {
+                if (~acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF) {
                         ec->intr.expect_event = 0;
-                        return_VALUE(0);
+                        return 0;
                 }
                 break;
         default:
@@ -238,16 +237,16 @@ static int acpi_ec_intr_wait(union acpi_ec *ec, unsigned int event)
         switch (event) {
         case ACPI_EC_EVENT_OBF:
                 if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_OBF)
-                        return_VALUE(0);
+                        return 0;
                 break;
 
         case ACPI_EC_EVENT_IBE:
                 if (~acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF)
-                        return_VALUE(0);
+                        return 0;
                 break;
         }
 
-        return_VALUE(-ETIME);
+        return -ETIME;
 }
 
 #ifdef ACPI_FUTURE_USAGE
@@ -260,7 +259,6 @@ int acpi_ec_enter_burst_mode(union acpi_ec *ec)
         u32 tmp = 0;
         int status = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_enter_burst_mode");
 
         status = acpi_ec_read_status(ec);
         if (status != -EINVAL && !(status & ACPI_EC_FLAG_BURST)) {
@@ -272,22 +270,21 @@ int acpi_ec_enter_burst_mode(union acpi_ec *ec)
                 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
                 acpi_hw_low_level_read(8, &tmp, &ec->common.data_addr);
                 if (tmp != 0x90) {      /* Burst ACK byte */
-                        return_VALUE(-EINVAL);
+                        return -EINVAL;
                 }
         }
 
         atomic_set(&ec->intr.leaving_burst, 0);
-        return_VALUE(0);
+        return 0;
       end:
-        printk(KERN_WARNING PREFIX "Error in acpi_ec_wait\n");
-        return_VALUE(-1);
+        ACPI_EXCEPTION ((AE_INFO, status, "EC wait, burst mode");
+        return -1;
 }
 
 int acpi_ec_leave_burst_mode(union acpi_ec *ec)
 {
         int status = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_leave_burst_mode");
 
         status = acpi_ec_read_status(ec);
         if (status != -EINVAL && (status & ACPI_EC_FLAG_BURST)){
@@ -298,10 +295,10 @@ int acpi_ec_leave_burst_mode(union acpi_ec *ec)
                 acpi_ec_wait(ec, ACPI_EC_FLAG_IBF);
         } 
         atomic_set(&ec->intr.leaving_burst, 1);
-        return_VALUE(0);
+        return 0;
 end:
-        printk(KERN_WARNING PREFIX "leave burst_mode:error\n");
-        return_VALUE(-1);
+        ACPI_EXCEPTION((AE_INFO, status, "EC leave burst mode");
+        return -1;
 }
 #endif /* ACPI_FUTURE_USAGE */
 
@@ -325,17 +322,16 @@ static int acpi_ec_poll_read(union acpi_ec *ec, u8 address, u32 * data)
         int result = 0;
         u32 glk = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_read");
 
         if (!ec || !data)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         *data = 0;
 
         if (ec->common.global_lock) {
                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
                 if (ACPI_FAILURE(status))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
         }
 
         if (down_interruptible(&ec->poll.sem)) {
@@ -365,7 +361,7 @@ end_nosem:
         if (ec->common.global_lock)
                 acpi_release_global_lock(glk);
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_ec_poll_write(union acpi_ec *ec, u8 address, u8 data)
@@ -374,15 +370,14 @@ static int acpi_ec_poll_write(union acpi_ec *ec, u8 address, u8 data)
         acpi_status status = AE_OK;
         u32 glk = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_write");
 
         if (!ec)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (ec->common.global_lock) {
                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
                 if (ACPI_FAILURE(status))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
         }
 
         if (down_interruptible(&ec->poll.sem)) {
@@ -415,7 +410,7 @@ end_nosem:
         if (ec->common.global_lock)
                 acpi_release_global_lock(glk);
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_ec_intr_read(union acpi_ec *ec, u8 address, u32 * data)
@@ -423,17 +418,16 @@ static int acpi_ec_intr_read(union acpi_ec *ec, u8 address, u32 * data)
         int status = 0;
         u32 glk;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_read");
 
         if (!ec || !data)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         *data = 0;
 
         if (ec->common.global_lock) {
                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
                 if (ACPI_FAILURE(status))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
         }
 
         WARN_ON(in_interrupt());
@@ -467,7 +461,7 @@ static int acpi_ec_intr_read(union acpi_ec *ec, u8 address, u32 * data)
         if (ec->common.global_lock)
                 acpi_release_global_lock(glk);
 
-        return_VALUE(status);
+        return status;
 }
 
 static int acpi_ec_intr_write(union acpi_ec *ec, u8 address, u8 data)
@@ -475,15 +469,14 @@ static int acpi_ec_intr_write(union acpi_ec *ec, u8 address, u8 data)
         int status = 0;
         u32 glk;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_write");
 
         if (!ec)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (ec->common.global_lock) {
                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
                 if (ACPI_FAILURE(status))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
         }
 
         WARN_ON(in_interrupt());
@@ -516,7 +509,7 @@ static int acpi_ec_intr_write(union acpi_ec *ec, u8 address, u8 data)
         if (ec->common.global_lock)
                 acpi_release_global_lock(glk);
 
-        return_VALUE(status);
+        return status;
 }
 
 /*
@@ -574,17 +567,16 @@ static int acpi_ec_poll_query(union acpi_ec *ec, u32 * data)
         acpi_status status = AE_OK;
         u32 glk = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_query");
 
         if (!ec || !data)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         *data = 0;
 
         if (ec->common.global_lock) {
                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
                 if (ACPI_FAILURE(status))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
         }
 
         /*
@@ -613,23 +605,22 @@ end_nosem:
         if (ec->common.global_lock)
                 acpi_release_global_lock(glk);
 
-        return_VALUE(result);
+        return result;
 }
 static int acpi_ec_intr_query(union acpi_ec *ec, u32 * data)
 {
         int status = 0;
         u32 glk;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_query");
 
         if (!ec || !data)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
         *data = 0;
 
         if (ec->common.global_lock) {
                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
                 if (ACPI_FAILURE(status))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
         }
 
         down(&ec->intr.sem);
@@ -662,7 +653,7 @@ static int acpi_ec_intr_query(union acpi_ec *ec, u32 * data)
         if (ec->common.global_lock)
                 acpi_release_global_lock(glk);
 
-        return_VALUE(status);
+        return status;
 }
 
 /* --------------------------------------------------------------------------
@@ -691,13 +682,12 @@ static void acpi_ec_gpe_poll_query(void *ec_cxt)
                 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
         };
 
-        ACPI_FUNCTION_TRACE("acpi_ec_gpe_query");
 
         if (!ec_cxt)
                 goto end;
 
         if (down_interruptible (&ec->poll.sem)) {
-                return_VOID;
+                return;
         }
         acpi_hw_low_level_read(8, &value, &ec->common.command_addr);
         up(&ec->poll.sem);
@@ -734,7 +724,6 @@ static void acpi_ec_gpe_intr_query(void *ec_cxt)
                 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
         };
 
-        ACPI_FUNCTION_TRACE("acpi_ec_gpe_query");
 
         if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_SCI)
                 result = acpi_ec_query(ec, &value);
@@ -793,12 +782,15 @@ static u32 acpi_ec_gpe_intr_handler(void *data)
         case ACPI_EC_EVENT_OBF:
                 if (!(value & ACPI_EC_FLAG_OBF))
                         break;
+                ec->intr.expect_event = 0;
+                wake_up(&ec->intr.wait);
+                break;
         case ACPI_EC_EVENT_IBE:
                 if ((value & ACPI_EC_FLAG_IBF))
                         break;
                 ec->intr.expect_event = 0;
                 wake_up(&ec->intr.wait);
-                return ACPI_INTERRUPT_HANDLED;
+                break;
         default:
                 break;
         }
@@ -846,15 +838,14 @@ acpi_ec_space_handler(u32 function,
         acpi_integer f_v = 0;
         int i = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_space_handler");
 
         if ((address > 0xFF) || !value || !handler_context)
-                return_VALUE(AE_BAD_PARAMETER);
+                return AE_BAD_PARAMETER;
 
         if (bit_width != 8 && acpi_strict) {
                 printk(KERN_WARNING PREFIX
                        "acpi_ec_space_handler: bit_width should be 8\n");
-                return_VALUE(AE_BAD_PARAMETER);
+                return AE_BAD_PARAMETER;
         }
 
         ec = (union acpi_ec *)handler_context;
@@ -893,16 +884,16 @@ acpi_ec_space_handler(u32 function,
       out:
         switch (result) {
         case -EINVAL:
-                return_VALUE(AE_BAD_PARAMETER);
+                return AE_BAD_PARAMETER;
                 break;
         case -ENODEV:
-                return_VALUE(AE_NOT_FOUND);
+                return AE_NOT_FOUND;
                 break;
         case -ETIME:
-                return_VALUE(AE_TIME);
+                return AE_TIME;
                 break;
         default:
-                return_VALUE(AE_OK);
+                return AE_OK;
         }
 }
 
@@ -916,7 +907,6 @@ static int acpi_ec_read_info(struct seq_file *seq, void *offset)
 {
         union acpi_ec *ec = (union acpi_ec *)seq->private;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_read_info");
 
         if (!ec)
                 goto end;
@@ -931,7 +921,7 @@ static int acpi_ec_read_info(struct seq_file *seq, void *offset)
         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_ec_info_open_fs(struct inode *inode, struct file *file)
@@ -939,7 +929,7 @@ static int acpi_ec_info_open_fs(struct inode *inode, struct file *file)
         return single_open(file, acpi_ec_read_info, PDE(inode)->data);
 }
 
-static struct file_operations acpi_ec_info_ops = {
+static const struct file_operations acpi_ec_info_ops = {
         .open = acpi_ec_info_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -951,33 +941,29 @@ static int acpi_ec_add_fs(struct acpi_device *device)
 {
         struct proc_dir_entry *entry = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_add_fs");
 
         if (!acpi_device_dir(device)) {
                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
                                                      acpi_ec_dir);
                 if (!acpi_device_dir(device))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
         }
 
         entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO,
                                   acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_EC_FILE_INFO));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_ec_info_ops;
                 entry->data = acpi_driver_data(device);
                 entry->owner = THIS_MODULE;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_ec_remove_fs(struct acpi_device *device)
 {
-        ACPI_FUNCTION_TRACE("acpi_ec_remove_fs");
 
         if (acpi_device_dir(device)) {
                 remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device));
@@ -985,7 +971,7 @@ static int acpi_ec_remove_fs(struct acpi_device *device)
                 acpi_device_dir(device) = NULL;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 /* --------------------------------------------------------------------------
@@ -998,14 +984,13 @@ static int acpi_ec_poll_add(struct acpi_device *device)
         acpi_status status = AE_OK;
         union acpi_ec *ec = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_add");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
         if (!ec)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(ec, 0, sizeof(union acpi_ec));
 
         ec->common.handle = device->handle;
@@ -1038,8 +1023,7 @@ static int acpi_ec_poll_add(struct acpi_device *device)
             acpi_evaluate_integer(ec->common.handle, "_GPE", NULL,
                                   &ec->common.gpe_bit);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error obtaining GPE bit assignment\n"));
+                ACPI_EXCEPTION((AE_INFO, status, "Obtaining GPE bit"));
                 result = -ENODEV;
                 goto end;
         }
@@ -1059,7 +1043,7 @@ static int acpi_ec_poll_add(struct acpi_device *device)
         if (result)
                 kfree(ec);
 
-        return_VALUE(result);
+        return result;
 }
 static int acpi_ec_intr_add(struct acpi_device *device)
 {
@@ -1067,14 +1051,13 @@ static int acpi_ec_intr_add(struct acpi_device *device)
         acpi_status status = AE_OK;
         union acpi_ec *ec = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_add");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
         if (!ec)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(ec, 0, sizeof(union acpi_ec));
 
         ec->common.handle = device->handle;
@@ -1110,8 +1093,7 @@ static int acpi_ec_intr_add(struct acpi_device *device)
             acpi_evaluate_integer(ec->common.handle, "_GPE", NULL,
                                   &ec->common.gpe_bit);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error obtaining GPE bit assignment\n"));
+                printk(KERN_ERR PREFIX "Obtaining GPE bit assignment\n");
                 result = -ENODEV;
                 goto end;
         }
@@ -1131,17 +1113,16 @@ static int acpi_ec_intr_add(struct acpi_device *device)
         if (result)
                 kfree(ec);
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_ec_remove(struct acpi_device *device, int type)
 {
         union acpi_ec *ec = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_remove");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         ec = acpi_driver_data(device);
 
@@ -1149,7 +1130,7 @@ static int acpi_ec_remove(struct acpi_device *device, int type)
 
         kfree(ec);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static acpi_status
@@ -1188,15 +1169,14 @@ static int acpi_ec_start(struct acpi_device *device)
         acpi_status status = AE_OK;
         union acpi_ec *ec = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_start");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         ec = acpi_driver_data(device);
 
         if (!ec)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /*
          * Get I/O port addresses. Convert to GAS format.
@@ -1205,9 +1185,8 @@ static int acpi_ec_start(struct acpi_device *device)
                                      acpi_ec_io_ports, ec);
         if (ACPI_FAILURE(status)
             || ec->common.command_addr.register_bit_width == 0) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error getting I/O port addresses"));
-                return_VALUE(-ENODEV);
+                printk(KERN_ERR PREFIX "Error getting I/O port addresses\n");
+                return -ENODEV;
         }
 
         ec->common.status_addr = ec->common.command_addr;
@@ -1224,7 +1203,7 @@ static int acpi_ec_start(struct acpi_device *device)
                                           ACPI_GPE_EDGE_TRIGGERED,
                                           &acpi_ec_gpe_handler, ec);
         if (ACPI_FAILURE(status)) {
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
         acpi_set_gpe_type(NULL, ec->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
@@ -1236,10 +1215,10 @@ static int acpi_ec_start(struct acpi_device *device)
         if (ACPI_FAILURE(status)) {
                 acpi_remove_gpe_handler(NULL, ec->common.gpe_bit,
                                         &acpi_ec_gpe_handler);
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
-        return_VALUE(AE_OK);
+        return AE_OK;
 }
 
 static int acpi_ec_stop(struct acpi_device *device, int type)
@@ -1247,10 +1226,9 @@ static int acpi_ec_stop(struct acpi_device *device, int type)
         acpi_status status = AE_OK;
         union acpi_ec *ec = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_stop");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         ec = acpi_driver_data(device);
 
@@ -1258,15 +1236,15 @@ static int acpi_ec_stop(struct acpi_device *device, int type)
                                                    ACPI_ADR_SPACE_EC,
                                                    &acpi_ec_space_handler);
         if (ACPI_FAILURE(status))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         status =
             acpi_remove_gpe_handler(NULL, ec->common.gpe_bit,
                                     &acpi_ec_gpe_handler);
         if (ACPI_FAILURE(status))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
-        return_VALUE(0);
+        return 0;
 }
 
 static acpi_status __init
@@ -1536,23 +1514,22 @@ static int __init acpi_ec_init(void)
 {
         int result = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_ec_init");
 
         if (acpi_disabled)
-                return_VALUE(0);
+                return 0;
 
         acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir);
         if (!acpi_ec_dir)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         /* Now register the driver for the EC */
         result = acpi_bus_register_driver(&acpi_ec_driver);
         if (result < 0) {
                 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
-        return_VALUE(result);
+        return result;
 }
 
 subsys_initcall(acpi_ec_init);
@@ -1561,13 +1538,12 @@ subsys_initcall(acpi_ec_init);
 #if 0
 static void __exit acpi_ec_exit(void)
 {
-        ACPI_FUNCTION_TRACE("acpi_ec_exit");
 
         acpi_bus_unregister_driver(&acpi_ec_driver);
 
         remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
 
-        return_VOID;
+        return;
 }
 #endif                          /* 0 */
 
diff --git a/drivers/acpi/event.c b/drivers/acpi/event.c
index 2dbb1b0f11d5..959a893c8d1f 100644
--- a/drivers/acpi/event.c
+++ b/drivers/acpi/event.c
@@ -48,18 +48,17 @@ acpi_system_read_event(struct file *file, char __user * buffer, size_t count,
         static int chars_remaining = 0;
         static char *ptr;
 
-        ACPI_FUNCTION_TRACE("acpi_system_read_event");
 
         if (!chars_remaining) {
                 memset(&event, 0, sizeof(struct acpi_bus_event));
 
                 if ((file->f_flags & O_NONBLOCK)
                     && (list_empty(&acpi_bus_event_list)))
-                        return_VALUE(-EAGAIN);
+                        return -EAGAIN;
 
                 result = acpi_bus_receive_event(&event);
                 if (result)
-                        return_VALUE(result);
+                        return result;
 
                 chars_remaining = sprintf(str, "%s %s %08x %08x\n",
                                           event.device_class ? event.
@@ -75,13 +74,13 @@ acpi_system_read_event(struct file *file, char __user * buffer, size_t count,
         }
 
         if (copy_to_user(buffer, ptr, count))
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
         *ppos += count;
         chars_remaining -= count;
         ptr += count;
 
-        return_VALUE(count);
+        return count;
 }
 
 static int acpi_system_close_event(struct inode *inode, struct file *file)
@@ -100,7 +99,7 @@ static unsigned int acpi_system_poll_event(struct file *file, poll_table * wait)
         return 0;
 }
 
-static struct file_operations acpi_system_event_ops = {
+static const struct file_operations acpi_system_event_ops = {
         .open = acpi_system_open_event,
         .read = acpi_system_read_event,
         .release = acpi_system_close_event,
@@ -112,22 +111,18 @@ static int __init acpi_event_init(void)
         struct proc_dir_entry *entry;
         int error = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_event_init");
 
         if (acpi_disabled)
-                return_VALUE(0);
+                return 0;
 
         /* 'event' [R] */
         entry = create_proc_entry("event", S_IRUSR, acpi_root_dir);
         if (entry)
                 entry->proc_fops = &acpi_system_event_ops;
         else {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' proc fs entry\n",
-                                  "event"));
-                error = -EFAULT;
+                error = -ENODEV;
         }
-        return_VALUE(error);
+        return error;
 }
 
 subsys_initcall(acpi_event_init);
diff --git a/drivers/acpi/events/evgpe.c b/drivers/acpi/events/evgpe.c
index f01d339407f8..c76c0583ca6a 100644
--- a/drivers/acpi/events/evgpe.c
+++ b/drivers/acpi/events/evgpe.c
@@ -382,7 +382,6 @@ u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
         u32 status_reg;
         u32 enable_reg;
         acpi_cpu_flags flags;
-        acpi_cpu_flags hw_flags;
         acpi_native_uint i;
         acpi_native_uint j;
 
@@ -394,8 +393,11 @@ u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
                 return (int_status);
         }
 
-        /* We need to hold the GPE lock now, hardware lock in the loop */
-
+        /*
+         * We need to obtain the GPE lock for both the data structs and registers
+         * Note: Not necessary to obtain the hardware lock, since the GPE registers
+         * are owned by the gpe_lock.
+         */
         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 
         /* Examine all GPE blocks attached to this interrupt level */
@@ -413,8 +415,6 @@ u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
 
                         gpe_register_info = &gpe_block->register_info[i];
 
-                        hw_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
-
                         /* Read the Status Register */
 
                         status =
@@ -423,8 +423,6 @@ u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
                                                    &gpe_register_info->
                                                    status_address);
                         if (ACPI_FAILURE(status)) {
-                                acpi_os_release_lock(acpi_gbl_hardware_lock,
-                                                     hw_flags);
                                 goto unlock_and_exit;
                         }
 
@@ -435,8 +433,6 @@ u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
                                                    &enable_reg,
                                                    &gpe_register_info->
                                                    enable_address);
-                        acpi_os_release_lock(acpi_gbl_hardware_lock, hw_flags);
-
                         if (ACPI_FAILURE(status)) {
                                 goto unlock_and_exit;
                         }
diff --git a/drivers/acpi/events/evregion.c b/drivers/acpi/events/evregion.c
index 094a17e4c86d..21caae04fe85 100644
--- a/drivers/acpi/events/evregion.c
+++ b/drivers/acpi/events/evregion.c
@@ -528,34 +528,40 @@ acpi_ev_detach_region(union acpi_operand_object *region_obj,
                                 }
                         }
 
-                        /* Call the setup handler with the deactivate notification */
+                        /*
+                         * If the region has been activated, call the setup handler
+                         * with the deactivate notification
+                         */
+                        if (region_obj->region.flags & AOPOBJ_SETUP_COMPLETE) {
+                                region_setup = handler_obj->address_space.setup;
+                                status =
+                                    region_setup(region_obj,
+                                                 ACPI_REGION_DEACTIVATE,
+                                                 handler_obj->address_space.
+                                                 context, region_context);
 
-                        region_setup = handler_obj->address_space.setup;
-                        status =
-                            region_setup(region_obj, ACPI_REGION_DEACTIVATE,
-                                         handler_obj->address_space.context,
-                                         region_context);
+                                /* Init routine may fail, Just ignore errors */
 
-                        /* Init routine may fail, Just ignore errors */
+                                if (ACPI_FAILURE(status)) {
+                                        ACPI_EXCEPTION((AE_INFO, status,
+                                                        "from region handler - deactivate, [%s]",
+                                                        acpi_ut_get_region_name
+                                                        (region_obj->region.
+                                                         space_id)));
+                                }
 
-                        if (ACPI_FAILURE(status)) {
-                                ACPI_EXCEPTION((AE_INFO, status,
-                                                "from region init, [%s]",
-                                                acpi_ut_get_region_name
-                                                (region_obj->region.space_id)));
+                                region_obj->region.flags &=
+                                    ~(AOPOBJ_SETUP_COMPLETE);
                         }
 
-                        region_obj->region.flags &= ~(AOPOBJ_SETUP_COMPLETE);
-
                         /*
                          * Remove handler reference in the region
                          *
-                         * NOTE: this doesn't mean that the region goes away
-                         * The region is just inaccessible as indicated to
-                         * the _REG method
+                         * NOTE: this doesn't mean that the region goes away, the region
+                         * is just inaccessible as indicated to the _REG method
                          *
-                         * If the region is on the handler's list
-                         * this better be the region's handler
+                         * If the region is on the handler's list, this must be the
+                         * region's handler
                          */
                         region_obj->region.handler = NULL;
                         acpi_ut_remove_reference(handler_obj);
diff --git a/drivers/acpi/events/evxface.c b/drivers/acpi/events/evxface.c
index 76c34a66e0e0..923fd2b46955 100644
--- a/drivers/acpi/events/evxface.c
+++ b/drivers/acpi/events/evxface.c
@@ -414,12 +414,13 @@ acpi_remove_notify_handler(acpi_handle device,
 
         if ((!device) ||
             (!handler) || (handler_type > ACPI_MAX_NOTIFY_HANDLER_TYPE)) {
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                status = AE_BAD_PARAMETER;
+                goto exit;
         }
 
         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
         if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
+                goto exit;
         }
 
         /* Convert and validate the device handle */
@@ -450,7 +451,7 @@ acpi_remove_notify_handler(acpi_handle device,
                 acpi_os_wait_events_complete(NULL);
                 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
                 if (ACPI_FAILURE(status)) {
-                        return_ACPI_STATUS(status);
+                        goto exit;
                 }
 
                 if (handler_type & ACPI_SYSTEM_NOTIFY) {
@@ -488,8 +489,12 @@ acpi_remove_notify_handler(acpi_handle device,
 
                 if (handler_type & ACPI_SYSTEM_NOTIFY) {
                         notify_obj = obj_desc->common_notify.system_notify;
-                        if ((!notify_obj) ||
-                            (notify_obj->notify.handler != handler)) {
+                        if (!notify_obj) {
+                                status = AE_NOT_EXIST;
+                                goto unlock_and_exit;
+                        }
+
+                        if (notify_obj->notify.handler != handler) {
                                 status = AE_BAD_PARAMETER;
                                 goto unlock_and_exit;
                         }
@@ -499,7 +504,7 @@ acpi_remove_notify_handler(acpi_handle device,
                         acpi_os_wait_events_complete(NULL);
                         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
                         if (ACPI_FAILURE(status)) {
-                                return_ACPI_STATUS(status);
+                                goto exit;
                         }
 
                         /* Remove the handler */
@@ -509,8 +514,12 @@ acpi_remove_notify_handler(acpi_handle device,
 
                 if (handler_type & ACPI_DEVICE_NOTIFY) {
                         notify_obj = obj_desc->common_notify.device_notify;
-                        if ((!notify_obj) ||
-                            (notify_obj->notify.handler != handler)) {
+                        if (!notify_obj) {
+                                status = AE_NOT_EXIST;
+                                goto unlock_and_exit;
+                        }
+
+                        if (notify_obj->notify.handler != handler) {
                                 status = AE_BAD_PARAMETER;
                                 goto unlock_and_exit;
                         }
@@ -520,7 +529,7 @@ acpi_remove_notify_handler(acpi_handle device,
                         acpi_os_wait_events_complete(NULL);
                         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
                         if (ACPI_FAILURE(status)) {
-                                return_ACPI_STATUS(status);
+                                goto exit;
                         }
 
                         /* Remove the handler */
@@ -531,6 +540,9 @@ acpi_remove_notify_handler(acpi_handle device,
 
       unlock_and_exit:
         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
+      exit:
+        if (ACPI_FAILURE(status))
+                ACPI_EXCEPTION((AE_INFO, status, "Removing notify handler"));
         return_ACPI_STATUS(status);
 }
 
@@ -568,12 +580,13 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
         /* Parameter validation */
 
         if ((!address) || (type > ACPI_GPE_XRUPT_TYPE_MASK)) {
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                status = AE_BAD_PARAMETER;
+                goto exit;
         }
 
         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
         if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
+                goto exit;
         }
 
         /* Ensure that we have a valid GPE number */
@@ -625,6 +638,10 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
 
       unlock_and_exit:
         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
+      exit:
+        if (ACPI_FAILURE(status))
+                ACPI_EXCEPTION((AE_INFO, status,
+                                "Installing notify handler failed"));
         return_ACPI_STATUS(status);
 }
 
diff --git a/drivers/acpi/events/evxfregn.c b/drivers/acpi/events/evxfregn.c
index e8b86a0baad0..83b12a9afa32 100644
--- a/drivers/acpi/events/evxfregn.c
+++ b/drivers/acpi/events/evxfregn.c
@@ -155,7 +155,11 @@ acpi_remove_address_space_handler(acpi_handle device,
         /* Convert and validate the device handle */
 
         node = acpi_ns_map_handle_to_node(device);
-        if (!node) {
+        if (!node ||
+            ((node->type != ACPI_TYPE_DEVICE) &&
+             (node->type != ACPI_TYPE_PROCESSOR) &&
+             (node->type != ACPI_TYPE_THERMAL) &&
+             (node != acpi_gbl_root_node))) {
                 status = AE_BAD_PARAMETER;
                 goto unlock_and_exit;
         }
@@ -178,6 +182,13 @@ acpi_remove_address_space_handler(acpi_handle device,
 
                 if (handler_obj->address_space.space_id == space_id) {
 
+                        /* Handler must be the same as the installed handler */
+
+                        if (handler_obj->address_space.handler != handler) {
+                                status = AE_BAD_PARAMETER;
+                                goto unlock_and_exit;
+                        }
+
                         /* Matched space_id, first dereference this in the Regions */
 
                         ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
diff --git a/drivers/acpi/executer/exconfig.c b/drivers/acpi/executer/exconfig.c
index 823352435e08..c8341fa5fe01 100644
--- a/drivers/acpi/executer/exconfig.c
+++ b/drivers/acpi/executer/exconfig.c
@@ -266,6 +266,10 @@ acpi_ex_load_table_op(struct acpi_walk_state *walk_state,
                 }
         }
 
+        ACPI_INFO((AE_INFO,
+                   "Dynamic OEM Table Load - [%4.4s] OemId [%6.6s] OemTableId [%8.8s]",
+                   table->signature, table->oem_id, table->oem_table_id));
+
         *return_desc = ddb_handle;
         return_ACPI_STATUS(status);
 }
@@ -446,6 +450,10 @@ acpi_ex_load_op(union acpi_operand_object *obj_desc,
                 return_ACPI_STATUS(status);
         }
 
+        ACPI_INFO((AE_INFO,
+                   "Dynamic SSDT Load - OemId [%6.6s] OemTableId [%8.8s]",
+                   table_ptr->oem_id, table_ptr->oem_table_id));
+
       cleanup:
         if (ACPI_FAILURE(status)) {
                 ACPI_FREE(table_ptr);
@@ -494,7 +502,6 @@ acpi_status acpi_ex_unload_table(union acpi_operand_object *ddb_handle)
          * (Offset contains the table_id)
          */
         acpi_ns_delete_namespace_by_owner(table_info->owner_id);
-        acpi_ut_release_owner_id(&table_info->owner_id);
 
         /* Delete the table itself */
 
diff --git a/drivers/acpi/executer/exconvrt.c b/drivers/acpi/executer/exconvrt.c
index b732e399b1ef..544e81a6a438 100644
--- a/drivers/acpi/executer/exconvrt.c
+++ b/drivers/acpi/executer/exconvrt.c
@@ -170,6 +170,9 @@ acpi_ex_convert_to_integer(union acpi_operand_object *obj_desc,
                 return_ACPI_STATUS(AE_NO_MEMORY);
         }
 
+        ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n",
+                          ACPI_FORMAT_UINT64(result)));
+
         /* Save the Result */
 
         return_desc->integer.value = result;
diff --git a/drivers/acpi/executer/excreate.c b/drivers/acpi/executer/excreate.c
index 106dc7219df7..34eec82c1b1e 100644
--- a/drivers/acpi/executer/excreate.c
+++ b/drivers/acpi/executer/excreate.c
@@ -177,7 +177,7 @@ acpi_status acpi_ex_create_event(struct acpi_walk_state *walk_state)
          * that the event is created in an unsignalled state
          */
         status = acpi_os_create_semaphore(ACPI_NO_UNIT_LIMIT, 0,
-                                          &obj_desc->event.semaphore);
+                                          &obj_desc->event.os_semaphore);
         if (ACPI_FAILURE(status)) {
                 goto cleanup;
         }
@@ -226,12 +226,9 @@ acpi_status acpi_ex_create_mutex(struct acpi_walk_state *walk_state)
                 goto cleanup;
         }
 
-        /*
-         * Create the actual OS semaphore.
-         * One unit max to make it a mutex, with one initial unit to allow
-         * the mutex to be acquired.
-         */
-        status = acpi_os_create_semaphore(1, 1, &obj_desc->mutex.semaphore);
+        /* Create the actual OS Mutex */
+
+        status = acpi_os_create_mutex(&obj_desc->mutex.os_mutex);
         if (ACPI_FAILURE(status)) {
                 goto cleanup;
         }
@@ -565,7 +562,7 @@ acpi_ex_create_method(u8 * aml_start,
         obj_desc->method.aml_length = aml_length;
 
         /*
-         * Disassemble the method flags.  Split off the Arg Count
+         * Disassemble the method flags. Split off the Arg Count
          * for efficiency
          */
         method_flags = (u8) operand[1]->integer.value;
@@ -576,21 +573,19 @@ acpi_ex_create_method(u8 * aml_start,
             (u8) (method_flags & AML_METHOD_ARG_COUNT);
 
         /*
-         * Get the concurrency count.  If required, a semaphore will be
+         * Get the sync_level. If method is serialized, a mutex will be
          * created for this method when it is parsed.
          */
         if (acpi_gbl_all_methods_serialized) {
-                obj_desc->method.concurrency = 1;
+                obj_desc->method.sync_level = 0;
                 obj_desc->method.method_flags |= AML_METHOD_SERIALIZED;
         } else if (method_flags & AML_METHOD_SERIALIZED) {
                 /*
-                 * ACPI 1.0: Concurrency = 1
-                 * ACPI 2.0: Concurrency = (sync_level (in method declaration) + 1)
+                 * ACPI 1.0: sync_level = 0
+                 * ACPI 2.0: sync_level = sync_level in method declaration
                  */
-                obj_desc->method.concurrency = (u8)
-                    (((method_flags & AML_METHOD_SYNCH_LEVEL) >> 4) + 1);
-        } else {
-                obj_desc->method.concurrency = ACPI_INFINITE_CONCURRENCY;
+                obj_desc->method.sync_level = (u8)
+                    ((method_flags & AML_METHOD_SYNCH_LEVEL) >> 4);
         }
 
         /* Attach the new object to the method Node */
diff --git a/drivers/acpi/executer/exdump.c b/drivers/acpi/executer/exdump.c
index 7b9718e976bf..2450943add33 100644
--- a/drivers/acpi/executer/exdump.c
+++ b/drivers/acpi/executer/exdump.c
@@ -118,14 +118,14 @@ static struct acpi_exdump_info acpi_ex_dump_device[4] = {
 
 static struct acpi_exdump_info acpi_ex_dump_event[2] = {
         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_event), NULL},
-        {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(event.semaphore), "Semaphore"}
+        {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(event.os_semaphore), "OsSemaphore"}
 };
 
 static struct acpi_exdump_info acpi_ex_dump_method[8] = {
         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_method), NULL},
         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(method.param_count), "ParamCount"},
-        {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(method.concurrency), "Concurrency"},
-        {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(method.semaphore), "Semaphore"},
+        {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(method.sync_level), "Sync Level"},
+        {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(method.mutex), "Mutex"},
         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(method.owner_id), "Owner Id"},
         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(method.thread_count), "Thread Count"},
         {ACPI_EXD_UINT32, ACPI_EXD_OFFSET(method.aml_length), "Aml Length"},
@@ -138,7 +138,7 @@ static struct acpi_exdump_info acpi_ex_dump_mutex[5] = {
         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(mutex.owner_thread), "Owner Thread"},
         {ACPI_EXD_UINT16, ACPI_EXD_OFFSET(mutex.acquisition_depth),
          "Acquire Depth"},
-        {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(mutex.semaphore), "Semaphore"}
+        {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(mutex.os_mutex), "OsMutex"}
 };
 
 static struct acpi_exdump_info acpi_ex_dump_region[7] = {
diff --git a/drivers/acpi/executer/exfldio.c b/drivers/acpi/executer/exfldio.c
index 051053f7cccb..40f0bee6faa5 100644
--- a/drivers/acpi/executer/exfldio.c
+++ b/drivers/acpi/executer/exfldio.c
@@ -727,11 +727,23 @@ acpi_ex_extract_from_field(union acpi_operand_object *obj_desc,
                         return_ACPI_STATUS(status);
                 }
 
-                /* Merge with previous datum if necessary */
-
-                merged_datum |= raw_datum <<
-                    (obj_desc->common_field.access_bit_width -
-                     obj_desc->common_field.start_field_bit_offset);
+                /*
+                 * Merge with previous datum if necessary.
+                 *
+                 * Note: Before the shift, check if the shift value will be larger than
+                 * the integer size. If so, there is no need to perform the operation.
+                 * This avoids the differences in behavior between different compilers
+                 * concerning shift values larger than the target data width.
+                 */
+                if ((obj_desc->common_field.access_bit_width -
+                     obj_desc->common_field.start_field_bit_offset) <
+                    ACPI_INTEGER_BIT_SIZE) {
+                        merged_datum |=
+                            raw_datum << (obj_desc->common_field.
+                                          access_bit_width -
+                                          obj_desc->common_field.
+                                          start_field_bit_offset);
+                }
 
                 if (i == datum_count) {
                         break;
@@ -808,13 +820,23 @@ acpi_ex_insert_into_field(union acpi_operand_object *obj_desc,
                 return_ACPI_STATUS(AE_BUFFER_OVERFLOW);
         }
 
-        /* Compute the number of datums (access width data items) */
+        /*
+         * Create the bitmasks used for bit insertion.
+         * Note: This if/else is used to bypass compiler differences with the
+         * shift operator
+         */
+        if (obj_desc->common_field.access_bit_width == ACPI_INTEGER_BIT_SIZE) {
+                width_mask = ACPI_INTEGER_MAX;
+        } else {
+                width_mask =
+                    ACPI_MASK_BITS_ABOVE(obj_desc->common_field.
+                                         access_bit_width);
+        }
 
-        width_mask =
-            ACPI_MASK_BITS_ABOVE(obj_desc->common_field.access_bit_width);
-        mask =
-            width_mask & ACPI_MASK_BITS_BELOW(obj_desc->common_field.
-                                              start_field_bit_offset);
+        mask = width_mask &
+            ACPI_MASK_BITS_BELOW(obj_desc->common_field.start_field_bit_offset);
+
+        /* Compute the number of datums (access width data items) */
 
         datum_count = ACPI_ROUND_UP_TO(obj_desc->common_field.bit_length,
                                        obj_desc->common_field.access_bit_width);
@@ -848,12 +870,29 @@ acpi_ex_insert_into_field(union acpi_operand_object *obj_desc,
                         return_ACPI_STATUS(status);
                 }
 
-                /* Start new output datum by merging with previous input datum */
-
                 field_offset += obj_desc->common_field.access_byte_width;
-                merged_datum = raw_datum >>
-                    (obj_desc->common_field.access_bit_width -
-                     obj_desc->common_field.start_field_bit_offset);
+
+                /*
+                 * Start new output datum by merging with previous input datum
+                 * if necessary.
+                 *
+                 * Note: Before the shift, check if the shift value will be larger than
+                 * the integer size. If so, there is no need to perform the operation.
+                 * This avoids the differences in behavior between different compilers
+                 * concerning shift values larger than the target data width.
+                 */
+                if ((obj_desc->common_field.access_bit_width -
+                     obj_desc->common_field.start_field_bit_offset) <
+                    ACPI_INTEGER_BIT_SIZE) {
+                        merged_datum =
+                            raw_datum >> (obj_desc->common_field.
+                                          access_bit_width -
+                                          obj_desc->common_field.
+                                          start_field_bit_offset);
+                } else {
+                        merged_datum = 0;
+                }
+
                 mask = width_mask;
 
                 if (i == datum_count) {
diff --git a/drivers/acpi/executer/exmutex.c b/drivers/acpi/executer/exmutex.c
index 93098d68cadf..3a39c2e8e104 100644
--- a/drivers/acpi/executer/exmutex.c
+++ b/drivers/acpi/executer/exmutex.c
@@ -161,12 +161,13 @@ acpi_ex_acquire_mutex(union acpi_operand_object *time_desc,
 
         /*
          * Current Sync must be less than or equal to the sync level of the
-         * mutex.  This mechanism provides some deadlock prevention
+         * mutex. This mechanism provides some deadlock prevention
          */
         if (walk_state->thread->current_sync_level > obj_desc->mutex.sync_level) {
                 ACPI_ERROR((AE_INFO,
-                            "Cannot acquire Mutex [%4.4s], incorrect SyncLevel",
-                            acpi_ut_get_node_name(obj_desc->mutex.node)));
+                            "Cannot acquire Mutex [%4.4s], current SyncLevel is too large (%d)",
+                            acpi_ut_get_node_name(obj_desc->mutex.node),
+                            walk_state->thread->current_sync_level));
                 return_ACPI_STATUS(AE_AML_MUTEX_ORDER);
         }
 
@@ -178,8 +179,7 @@ acpi_ex_acquire_mutex(union acpi_operand_object *time_desc,
 
                 if ((obj_desc->mutex.owner_thread->thread_id ==
                      walk_state->thread->thread_id) ||
-                    (obj_desc->mutex.semaphore ==
-                     acpi_gbl_global_lock_semaphore)) {
+                    (obj_desc->mutex.os_mutex == ACPI_GLOBAL_LOCK)) {
                         /*
                          * The mutex is already owned by this thread,
                          * just increment the acquisition depth
@@ -264,12 +264,12 @@ acpi_ex_release_mutex(union acpi_operand_object *obj_desc,
          */
         if ((obj_desc->mutex.owner_thread->thread_id !=
              walk_state->thread->thread_id)
-            && (obj_desc->mutex.semaphore != acpi_gbl_global_lock_semaphore)) {
+            && (obj_desc->mutex.os_mutex != ACPI_GLOBAL_LOCK)) {
                 ACPI_ERROR((AE_INFO,
                             "Thread %X cannot release Mutex [%4.4s] acquired by thread %X",
-                            walk_state->thread->thread_id,
+                            (u32) walk_state->thread->thread_id,
                             acpi_ut_get_node_name(obj_desc->mutex.node),
-                            obj_desc->mutex.owner_thread->thread_id));
+                            (u32) obj_desc->mutex.owner_thread->thread_id));
                 return_ACPI_STATUS(AE_AML_NOT_OWNER);
         }
 
diff --git a/drivers/acpi/executer/exsystem.c b/drivers/acpi/executer/exsystem.c
index 52beee3674a0..28aef3e69ecc 100644
--- a/drivers/acpi/executer/exsystem.c
+++ b/drivers/acpi/executer/exsystem.c
@@ -60,17 +60,17 @@ ACPI_MODULE_NAME("exsystem")
  *
  * DESCRIPTION: Implements a semaphore wait with a check to see if the
  *              semaphore is available immediately.  If it is not, the
- *              interpreter is released.
+ *              interpreter is released before waiting.
  *
  ******************************************************************************/
-acpi_status acpi_ex_system_wait_semaphore(acpi_handle semaphore, u16 timeout)
+acpi_status acpi_ex_system_wait_semaphore(acpi_semaphore semaphore, u16 timeout)
 {
         acpi_status status;
         acpi_status status2;
 
         ACPI_FUNCTION_TRACE(ex_system_wait_semaphore);
 
-        status = acpi_os_wait_semaphore(semaphore, 1, 0);
+        status = acpi_os_wait_semaphore(semaphore, 1, ACPI_DO_NOT_WAIT);
         if (ACPI_SUCCESS(status)) {
                 return_ACPI_STATUS(status);
         }
@@ -103,6 +103,59 @@ acpi_status acpi_ex_system_wait_semaphore(acpi_handle semaphore, u16 timeout)
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_ex_system_wait_mutex
+ *
+ * PARAMETERS:  Mutex           - Mutex to wait on
+ *              Timeout         - Max time to wait
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Implements a mutex wait with a check to see if the
+ *              mutex is available immediately.  If it is not, the
+ *              interpreter is released before waiting.
+ *
+ ******************************************************************************/
+
+acpi_status acpi_ex_system_wait_mutex(acpi_mutex mutex, u16 timeout)
+{
+        acpi_status status;
+        acpi_status status2;
+
+        ACPI_FUNCTION_TRACE(ex_system_wait_mutex);
+
+        status = acpi_os_acquire_mutex(mutex, ACPI_DO_NOT_WAIT);
+        if (ACPI_SUCCESS(status)) {
+                return_ACPI_STATUS(status);
+        }
+
+        if (status == AE_TIME) {
+
+                /* We must wait, so unlock the interpreter */
+
+                acpi_ex_exit_interpreter();
+
+                status = acpi_os_acquire_mutex(mutex, timeout);
+
+                ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
+                                  "*** Thread awake after blocking, %s\n",
+                                  acpi_format_exception(status)));
+
+                /* Reacquire the interpreter */
+
+                status2 = acpi_ex_enter_interpreter();
+                if (ACPI_FAILURE(status2)) {
+
+                        /* Report fatal error, could not acquire interpreter */
+
+                        return_ACPI_STATUS(status2);
+                }
+        }
+
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_ex_system_do_stall
  *
  * PARAMETERS:  how_long        - The amount of time to stall,
@@ -176,7 +229,7 @@ acpi_status acpi_ex_system_do_suspend(acpi_integer how_long)
  *
  * FUNCTION:    acpi_ex_system_acquire_mutex
  *
- * PARAMETERS:  time_desc       - The 'time to delay' object descriptor
+ * PARAMETERS:  time_desc       - Maximum time to wait for the mutex
  *              obj_desc        - The object descriptor for this op
  *
  * RETURN:      Status
@@ -201,14 +254,14 @@ acpi_ex_system_acquire_mutex(union acpi_operand_object * time_desc,
 
         /* Support for the _GL_ Mutex object -- go get the global lock */
 
-        if (obj_desc->mutex.semaphore == acpi_gbl_global_lock_semaphore) {
+        if (obj_desc->mutex.os_mutex == ACPI_GLOBAL_LOCK) {
                 status =
                     acpi_ev_acquire_global_lock((u16) time_desc->integer.value);
                 return_ACPI_STATUS(status);
         }
 
-        status = acpi_ex_system_wait_semaphore(obj_desc->mutex.semaphore,
-                                               (u16) time_desc->integer.value);
+        status = acpi_ex_system_wait_mutex(obj_desc->mutex.os_mutex,
+                                           (u16) time_desc->integer.value);
         return_ACPI_STATUS(status);
 }
 
@@ -239,13 +292,13 @@ acpi_status acpi_ex_system_release_mutex(union acpi_operand_object *obj_desc)
 
         /* Support for the _GL_ Mutex object -- release the global lock */
 
-        if (obj_desc->mutex.semaphore == acpi_gbl_global_lock_semaphore) {
+        if (obj_desc->mutex.os_mutex == ACPI_GLOBAL_LOCK) {
                 status = acpi_ev_release_global_lock();
                 return_ACPI_STATUS(status);
         }
 
-        status = acpi_os_signal_semaphore(obj_desc->mutex.semaphore, 1);
-        return_ACPI_STATUS(status);
+        acpi_os_release_mutex(obj_desc->mutex.os_mutex);
+        return_ACPI_STATUS(AE_OK);
 }
 
 /*******************************************************************************
@@ -268,7 +321,8 @@ acpi_status acpi_ex_system_signal_event(union acpi_operand_object *obj_desc)
         ACPI_FUNCTION_TRACE(ex_system_signal_event);
 
         if (obj_desc) {
-                status = acpi_os_signal_semaphore(obj_desc->event.semaphore, 1);
+                status =
+                    acpi_os_signal_semaphore(obj_desc->event.os_semaphore, 1);
         }
 
         return_ACPI_STATUS(status);
@@ -299,7 +353,7 @@ acpi_ex_system_wait_event(union acpi_operand_object *time_desc,
 
         if (obj_desc) {
                 status =
-                    acpi_ex_system_wait_semaphore(obj_desc->event.semaphore,
+                    acpi_ex_system_wait_semaphore(obj_desc->event.os_semaphore,
                                                   (u16) time_desc->integer.
                                                   value);
         }
@@ -322,7 +376,7 @@ acpi_ex_system_wait_event(union acpi_operand_object *time_desc,
 acpi_status acpi_ex_system_reset_event(union acpi_operand_object *obj_desc)
 {
         acpi_status status = AE_OK;
-        void *temp_semaphore;
+        acpi_semaphore temp_semaphore;
 
         ACPI_FUNCTION_ENTRY();
 
@@ -333,8 +387,8 @@ acpi_status acpi_ex_system_reset_event(union acpi_operand_object *obj_desc)
         status =
             acpi_os_create_semaphore(ACPI_NO_UNIT_LIMIT, 0, &temp_semaphore);
         if (ACPI_SUCCESS(status)) {
-                (void)acpi_os_delete_semaphore(obj_desc->event.semaphore);
-                obj_desc->event.semaphore = temp_semaphore;
+                (void)acpi_os_delete_semaphore(obj_desc->event.os_semaphore);
+                obj_desc->event.os_semaphore = temp_semaphore;
         }
 
         return (status);
diff --git a/drivers/acpi/fan.c b/drivers/acpi/fan.c
index 1cd25784b7a4..045c89477e59 100644
--- a/drivers/acpi/fan.c
+++ b/drivers/acpi/fan.c
@@ -64,7 +64,7 @@ static struct acpi_driver acpi_fan_driver = {
 };
 
 struct acpi_fan {
-        acpi_handle handle;
+        struct acpi_device * device;
 };
 
 /* --------------------------------------------------------------------------
@@ -78,16 +78,15 @@ static int acpi_fan_read_state(struct seq_file *seq, void *offset)
         struct acpi_fan *fan = seq->private;
         int state = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_fan_read_state");
 
         if (fan) {
-                if (acpi_bus_get_power(fan->handle, &state))
+                if (acpi_bus_get_power(fan->device->handle, &state))
                         seq_printf(seq, "status:                  ERROR\n");
                 else
                         seq_printf(seq, "status:                  %s\n",
                                    !state ? "on" : "off");
         }
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_fan_state_open_fs(struct inode *inode, struct file *file)
@@ -104,25 +103,24 @@ acpi_fan_write_state(struct file *file, const char __user * buffer,
         struct acpi_fan *fan = (struct acpi_fan *)m->private;
         char state_string[12] = { '\0' };
 
-        ACPI_FUNCTION_TRACE("acpi_fan_write_state");
 
         if (!fan || (count > sizeof(state_string) - 1))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (copy_from_user(state_string, buffer, count))
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
         state_string[count] = '\0';
 
-        result = acpi_bus_set_power(fan->handle,
+        result = acpi_bus_set_power(fan->device->handle,
                                     simple_strtoul(state_string, NULL, 0));
         if (result)
-                return_VALUE(result);
+                return result;
 
-        return_VALUE(count);
+        return count;
 }
 
-static struct file_operations acpi_fan_state_ops = {
+static const struct file_operations acpi_fan_state_ops = {
         .open = acpi_fan_state_open_fs,
         .read = seq_read,
         .write = acpi_fan_write_state,
@@ -135,16 +133,15 @@ static int acpi_fan_add_fs(struct acpi_device *device)
 {
         struct proc_dir_entry *entry = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_fan_add_fs");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (!acpi_device_dir(device)) {
                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
                                                      acpi_fan_dir);
                 if (!acpi_device_dir(device))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
                 acpi_device_dir(device)->owner = THIS_MODULE;
         }
 
@@ -153,21 +150,18 @@ static int acpi_fan_add_fs(struct acpi_device *device)
                                   S_IFREG | S_IRUGO | S_IWUSR,
                                   acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_FAN_FILE_STATE));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_fan_state_ops;
                 entry->data = acpi_driver_data(device);
                 entry->owner = THIS_MODULE;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_fan_remove_fs(struct acpi_device *device)
 {
-        ACPI_FUNCTION_TRACE("acpi_fan_remove_fs");
 
         if (acpi_device_dir(device)) {
                 remove_proc_entry(ACPI_FAN_FILE_STATE, acpi_device_dir(device));
@@ -175,7 +169,7 @@ static int acpi_fan_remove_fs(struct acpi_device *device)
                 acpi_device_dir(device) = NULL;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 /* --------------------------------------------------------------------------
@@ -188,25 +182,23 @@ static int acpi_fan_add(struct acpi_device *device)
         struct acpi_fan *fan = NULL;
         int state = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_fan_add");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         fan = kmalloc(sizeof(struct acpi_fan), GFP_KERNEL);
         if (!fan)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(fan, 0, sizeof(struct acpi_fan));
 
-        fan->handle = device->handle;
+        fan->device = device;
         strcpy(acpi_device_name(device), "Fan");
         strcpy(acpi_device_class(device), ACPI_FAN_CLASS);
         acpi_driver_data(device) = fan;
 
-        result = acpi_bus_get_power(fan->handle, &state);
+        result = acpi_bus_get_power(device->handle, &state);
         if (result) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error reading power state\n"));
+                printk(KERN_ERR PREFIX "Reading power state\n");
                 goto end;
         }
 
@@ -226,17 +218,16 @@ static int acpi_fan_add(struct acpi_device *device)
         if (result)
                 kfree(fan);
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_fan_remove(struct acpi_device *device, int type)
 {
         struct acpi_fan *fan = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_fan_remove");
 
         if (!device || !acpi_driver_data(device))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         fan = (struct acpi_fan *)acpi_driver_data(device);
 
@@ -244,7 +235,7 @@ static int acpi_fan_remove(struct acpi_device *device, int type)
 
         kfree(fan);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_fan_suspend(struct acpi_device *device, int state)
@@ -283,31 +274,29 @@ static int __init acpi_fan_init(void)
 {
         int result = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_fan_init");
 
         acpi_fan_dir = proc_mkdir(ACPI_FAN_CLASS, acpi_root_dir);
         if (!acpi_fan_dir)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         acpi_fan_dir->owner = THIS_MODULE;
 
         result = acpi_bus_register_driver(&acpi_fan_driver);
         if (result < 0) {
                 remove_proc_entry(ACPI_FAN_CLASS, acpi_root_dir);
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static void __exit acpi_fan_exit(void)
 {
-        ACPI_FUNCTION_TRACE("acpi_fan_exit");
 
         acpi_bus_unregister_driver(&acpi_fan_driver);
 
         remove_proc_entry(ACPI_FAN_CLASS, acpi_root_dir);
 
-        return_VOID;
+        return;
 }
 
 module_init(acpi_fan_init);
diff --git a/drivers/acpi/glue.c b/drivers/acpi/glue.c
index 8daef57b994c..10f160dc75b1 100644
--- a/drivers/acpi/glue.c
+++ b/drivers/acpi/glue.c
@@ -152,7 +152,7 @@ static int get_root_bridge_busnr(acpi_handle handle)
                 bbn = bus;
         }
       exit:
-        acpi_os_free(buffer.pointer);
+        kfree(buffer.pointer);
         return (int)bbn;
 }
 
@@ -192,7 +192,7 @@ find_pci_rootbridge(acpi_handle handle, u32 lvl, void *context, void **rv)
                 find->handle = handle;
         status = AE_OK;
       exit:
-        acpi_os_free(buffer.pointer);
+        kfree(buffer.pointer);
         return status;
 }
 
@@ -224,7 +224,7 @@ do_acpi_find_child(acpi_handle handle, u32 lvl, void *context, void **rv)
                 info = buffer.pointer;
                 if (info->address == find->address)
                         find->handle = handle;
-                acpi_os_free(buffer.pointer);
+                kfree(buffer.pointer);
         }
         return AE_OK;
 }
@@ -330,7 +330,7 @@ static int acpi_platform_notify(struct device *dev)
 
                 acpi_get_name(dev->firmware_data, ACPI_FULL_PATHNAME, &buffer);
                 DBG("Device %s -> %s\n", dev->bus_id, (char *)buffer.pointer);
-                acpi_os_free(buffer.pointer);
+                kfree(buffer.pointer);
         } else
                 DBG("Device %s -> No ACPI support\n", dev->bus_id);
 #endif
diff --git a/drivers/acpi/hardware/hwregs.c b/drivers/acpi/hardware/hwregs.c
index ae142de19507..3143f36fcec9 100644
--- a/drivers/acpi/hardware/hwregs.c
+++ b/drivers/acpi/hardware/hwregs.c
@@ -172,9 +172,9 @@ acpi_get_sleep_type_data(u8 sleep_state, u8 * sleep_type_a, u8 * sleep_type_b)
         }
 
         /*
-         * The package must have at least two elements.  NOTE (March 2005): This
+         * The package must have at least two elements. NOTE (March 2005): This
          * goes against the current ACPI spec which defines this object as a
-         * package with one encoded DWORD element.  However, existing practice
+         * package with one encoded DWORD element. However, existing practice
          * by BIOS vendors seems to be to have 2 or more elements, at least
          * one per sleep type (A/B).
          */
@@ -255,7 +255,7 @@ struct acpi_bit_register_info *acpi_hw_get_bit_register_info(u32 register_id)
  *              return_value    - Value that was read from the register
  *              Flags           - Lock the hardware or not
  *
- * RETURN:      Status and the value read from specified Register.  Value
+ * RETURN:      Status and the value read from specified Register. Value
  *              returned is normalized to bit0 (is shifted all the way right)
  *
  * DESCRIPTION: ACPI bit_register read function.
@@ -361,8 +361,8 @@ acpi_status acpi_set_register(u32 register_id, u32 value, u32 flags)
         case ACPI_REGISTER_PM1_STATUS:
 
                 /*
-                 * Status Registers are different from the rest.  Clear by
-                 * writing 1, and writing 0 has no effect.  So, the only relevant
+                 * Status Registers are different from the rest. Clear by
+                 * writing 1, and writing 0 has no effect. So, the only relevant
                  * information is the single bit we're interested in, all others should
                  * be written as 0 so they will be left unchanged.
                  */
@@ -467,14 +467,13 @@ ACPI_EXPORT_SYMBOL(acpi_set_register)
  *
  * FUNCTION:    acpi_hw_register_read
  *
- * PARAMETERS:  use_lock            - Mutex hw access
- *              register_id         - register_iD + Offset
+ * PARAMETERS:  use_lock            - Lock hardware? True/False
+ *              register_id         - ACPI Register ID
  *              return_value        - Where the register value is returned
  *
  * RETURN:      Status and the value read.
  *
- * DESCRIPTION: Acpi register read function.  Registers are read at the
- *              given offset.
+ * DESCRIPTION: Read from the specified ACPI register
  *
  ******************************************************************************/
 acpi_status
@@ -580,14 +579,26 @@ acpi_hw_register_read(u8 use_lock, u32 register_id, u32 * return_value)
  *
  * FUNCTION:    acpi_hw_register_write
  *
- * PARAMETERS:  use_lock            - Mutex hw access
- *              register_id         - register_iD + Offset
+ * PARAMETERS:  use_lock            - Lock hardware? True/False
+ *              register_id         - ACPI Register ID
  *              Value               - The value to write
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Acpi register Write function.  Registers are written at the
- *              given offset.
+ * DESCRIPTION: Write to the specified ACPI register
+ *
+ * NOTE: In accordance with the ACPI specification, this function automatically
+ * preserves the value of the following bits, meaning that these bits cannot be
+ * changed via this interface:
+ *
+ * PM1_CONTROL[0] = SCI_EN
+ * PM1_CONTROL[9]
+ * PM1_STATUS[11]
+ *
+ * ACPI References:
+ * 1) Hardware Ignored Bits: When software writes to a register with ignored
+ *      bit fields, it preserves the ignored bit fields
+ * 2) SCI_EN: OSPM always preserves this bit position
  *
  ******************************************************************************/
 
@@ -595,6 +606,7 @@ acpi_status acpi_hw_register_write(u8 use_lock, u32 register_id, u32 value)
 {
         acpi_status status;
         acpi_cpu_flags lock_flags = 0;
+        u32 read_value;
 
         ACPI_FUNCTION_TRACE(hw_register_write);
 
@@ -605,6 +617,22 @@ acpi_status acpi_hw_register_write(u8 use_lock, u32 register_id, u32 value)
         switch (register_id) {
         case ACPI_REGISTER_PM1_STATUS:  /* 16-bit access */
 
+                /* Perform a read first to preserve certain bits (per ACPI spec) */
+
+                status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
+                                               ACPI_REGISTER_PM1_STATUS,
+                                               &read_value);
+                if (ACPI_FAILURE(status)) {
+                        goto unlock_and_exit;
+                }
+
+                /* Insert the bits to be preserved */
+
+                ACPI_INSERT_BITS(value, ACPI_PM1_STATUS_PRESERVED_BITS,
+                                 read_value);
+
+                /* Now we can write the data */
+
                 status =
                     acpi_hw_low_level_write(16, value,
                                             &acpi_gbl_FADT->xpm1a_evt_blk);
@@ -635,6 +663,25 @@ acpi_status acpi_hw_register_write(u8 use_lock, u32 register_id, u32 value)
 
         case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */
 
+                /*
+                 * Perform a read first to preserve certain bits (per ACPI spec)
+                 *
+                 * Note: This includes SCI_EN, we never want to change this bit
+                 */
+                status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
+                                               ACPI_REGISTER_PM1_CONTROL,
+                                               &read_value);
+                if (ACPI_FAILURE(status)) {
+                        goto unlock_and_exit;
+                }
+
+                /* Insert the bits to be preserved */
+
+                ACPI_INSERT_BITS(value, ACPI_PM1_CONTROL_PRESERVED_BITS,
+                                 read_value);
+
+                /* Now we can write the data */
+
                 status =
                     acpi_hw_low_level_write(16, value,
                                             &acpi_gbl_FADT->xpm1a_cnt_blk);
@@ -726,7 +773,7 @@ acpi_hw_low_level_read(u32 width, u32 * value, struct acpi_generic_address *reg)
                 return (AE_OK);
         }
 
-        /* Get a local copy of the address.  Handles possible alignment issues */
+        /* Get a local copy of the address. Handles possible alignment issues */
 
         ACPI_MOVE_64_TO_64(&address, &reg->address);
         if (!address) {
@@ -798,7 +845,7 @@ acpi_hw_low_level_write(u32 width, u32 value, struct acpi_generic_address * reg)
                 return (AE_OK);
         }
 
-        /* Get a local copy of the address.  Handles possible alignment issues */
+        /* Get a local copy of the address. Handles possible alignment issues */
 
         ACPI_MOVE_64_TO_64(&address, &reg->address);
         if (!address) {
diff --git a/drivers/acpi/hotkey.c b/drivers/acpi/hotkey.c
index c25b2b92edcf..1ba2db671865 100644
--- a/drivers/acpi/hotkey.c
+++ b/drivers/acpi/hotkey.c
@@ -91,6 +91,14 @@ enum {
         HK_EVENT_ENTERRING_S5,
 };
 
+enum conf_entry_enum {
+        bus_handle = 0,
+        bus_method = 1,
+        action_handle = 2,
+        method = 3,
+        LAST_CONF_ENTRY
+};
+
 /*  procdir we use */
 static struct proc_dir_entry *hotkey_proc_dir;
 static struct proc_dir_entry *hotkey_config;
@@ -184,7 +192,7 @@ static union acpi_hotkey *get_hotkey_by_event(struct
                                               *hotkey_list, int event);
 
 /* event based config */
-static struct file_operations hotkey_config_fops = {
+static const struct file_operations hotkey_config_fops = {
         .open = hotkey_open_config,
         .read = seq_read,
         .write = hotkey_write_config,
@@ -193,7 +201,7 @@ static struct file_operations hotkey_config_fops = {
 };
 
 /* polling based config */
-static struct file_operations hotkey_poll_config_fops = {
+static const struct file_operations hotkey_poll_config_fops = {
         .open = hotkey_poll_open_config,
         .read = seq_read,
         .write = hotkey_write_config,
@@ -202,7 +210,7 @@ static struct file_operations hotkey_poll_config_fops = {
 };
 
 /* hotkey driver info */
-static struct file_operations hotkey_info_fops = {
+static const struct file_operations hotkey_info_fops = {
         .open = hotkey_info_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -210,7 +218,7 @@ static struct file_operations hotkey_info_fops = {
 };
 
 /* action */
-static struct file_operations hotkey_action_fops = {
+static const struct file_operations hotkey_action_fops = {
         .open = hotkey_action_open_fs,
         .read = seq_read,
         .write = hotkey_execute_aml_method,
@@ -219,7 +227,7 @@ static struct file_operations hotkey_action_fops = {
 };
 
 /* polling results */
-static struct file_operations hotkey_polling_fops = {
+static const struct file_operations hotkey_polling_fops = {
         .open = hotkey_polling_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -231,11 +239,10 @@ struct list_head hotkey_entries;	/* head of the list of hotkey_list */
 
 static int hotkey_info_seq_show(struct seq_file *seq, void *offset)
 {
-        ACPI_FUNCTION_TRACE("hotkey_info_seq_show");
 
         seq_printf(seq, "Hotkey generic driver ver: %s\n", HOTKEY_ACPI_VERSION);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int hotkey_info_open_fs(struct inode *inode, struct file *file)
@@ -245,19 +252,15 @@ static int hotkey_info_open_fs(struct inode *inode, struct file *file)
 
 static char *format_result(union acpi_object *object)
 {
-        char *buf = NULL;
-
-        buf = (char *)kmalloc(RESULT_STR_LEN, GFP_KERNEL);
-        if (buf)
-                memset(buf, 0, RESULT_STR_LEN);
-        else
-                goto do_fail;
+        char *buf;
 
+        buf = kzalloc(RESULT_STR_LEN, GFP_KERNEL);
+        if (!buf)
+                return NULL;
         /* Now, just support integer type */
         if (object->type == ACPI_TYPE_INTEGER)
                 sprintf(buf, "%d\n", (u32) object->integer.value);
-      do_fail:
-        return (buf);
+        return buf;
 }
 
 static int hotkey_polling_seq_show(struct seq_file *seq, void *offset)
@@ -266,7 +269,6 @@ static int hotkey_polling_seq_show(struct seq_file *seq, void *offset)
             (struct acpi_polling_hotkey *)seq->private;
         char *buf;
 
-        ACPI_FUNCTION_TRACE("hotkey_polling_seq_show");
 
         if (poll_hotkey->poll_result) {
                 buf = format_result(poll_hotkey->poll_result);
@@ -274,7 +276,7 @@ static int hotkey_polling_seq_show(struct seq_file *seq, void *offset)
                         seq_printf(seq, "%s", buf);
                 kfree(buf);
         }
-        return_VALUE(0);
+        return 0;
 }
 
 static int hotkey_polling_open_fs(struct inode *inode, struct file *file)
@@ -293,7 +295,6 @@ static int hotkey_get_internal_event(int event, struct acpi_hotkey_list *list)
         struct list_head *entries;
         int val = -1;
 
-        ACPI_FUNCTION_TRACE("hotkey_get_internal_event");
 
         list_for_each(entries, list->entries) {
                 union acpi_hotkey *key =
@@ -305,7 +306,7 @@ static int hotkey_get_internal_event(int event, struct acpi_hotkey_list *list)
                 }
         }
 
-        return_VALUE(val);
+        return val;
 }
 
 static void
@@ -314,15 +315,14 @@ acpi_hotkey_notify_handler(acpi_handle handle, u32 event, void *data)
         struct acpi_device *device = NULL;
         u32 internal_event;
 
-        ACPI_FUNCTION_TRACE("acpi_hotkey_notify_handler");
 
         if (acpi_bus_get_device(handle, &device))
-                return_VOID;
+                return;
 
         internal_event = hotkey_get_internal_event(event, &global_hotkey_list);
         acpi_bus_generate_event(device, internal_event, 0);
 
-        return_VOID;
+        return;
 }
 
 /* Need to invent automatically hotkey add method */
@@ -346,7 +346,6 @@ static int create_polling_proc(union acpi_hotkey *device)
         char proc_name[80];
         mode_t mode;
 
-        ACPI_FUNCTION_TRACE("create_polling_proc");
         mode = S_IFREG | S_IRUGO | S_IWUGO;
 
         sprintf(proc_name, "%d", device->link.hotkey_standard_num);
@@ -356,10 +355,7 @@ static int create_polling_proc(union acpi_hotkey *device)
         proc = create_proc_entry(proc_name, mode, hotkey_proc_dir);
 
         if (!proc) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Hotkey: Unable to create %s entry\n",
-                                  device->poll_hotkey.poll_method));
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         } else {
                 proc->proc_fops = &hotkey_polling_fops;
                 proc->owner = THIS_MODULE;
@@ -368,7 +364,7 @@ static int create_polling_proc(union acpi_hotkey *device)
                 proc->gid = 0;
                 device->poll_hotkey.proc = proc;
         }
-        return_VALUE(0);
+        return 0;
 }
 
 static int hotkey_add(union acpi_hotkey *device)
@@ -376,7 +372,6 @@ static int hotkey_add(union acpi_hotkey *device)
         int status = 0;
         struct acpi_device *dev = NULL;
 
-        ACPI_FUNCTION_TRACE("hotkey_add");
 
         if (device->link.hotkey_type == ACPI_HOTKEY_EVENT) {
                 acpi_bus_get_device(device->event_hotkey.bus_handle, &dev);
@@ -391,14 +386,13 @@ static int hotkey_add(union acpi_hotkey *device)
 
         list_add_tail(&device->link.entries, global_hotkey_list.entries);
 
-        return_VALUE(status);
+        return status;
 }
 
 static int hotkey_remove(union acpi_hotkey *device)
 {
         struct list_head *entries, *next;
 
-        ACPI_FUNCTION_TRACE("hotkey_remove");
 
         list_for_each_safe(entries, next, global_hotkey_list.entries) {
                 union acpi_hotkey *key =
@@ -412,14 +406,13 @@ static int hotkey_remove(union acpi_hotkey *device)
                 }
         }
         kfree(device);
-        return_VALUE(0);
+        return 0;
 }
 
 static int hotkey_update(union acpi_hotkey *key)
 {
         struct list_head *entries;
 
-        ACPI_FUNCTION_TRACE("hotkey_update");
 
         list_for_each(entries, global_hotkey_list.entries) {
                 union acpi_hotkey *tmp =
@@ -461,19 +454,18 @@ static int hotkey_update(union acpi_hotkey *key)
                                  */
                                 kfree(key);
                         }
-                        return_VALUE(0);
+                        return 0;
                         break;
                 }
         }
 
-        return_VALUE(-ENODEV);
+        return -ENODEV;
 }
 
 static void free_hotkey_device(union acpi_hotkey *key)
 {
         struct acpi_device *dev;
 
-        ACPI_FUNCTION_TRACE("free_hotkey_device");
 
         if (key->link.hotkey_type == ACPI_HOTKEY_EVENT) {
                 acpi_bus_get_device(key->event_hotkey.bus_handle, &dev);
@@ -493,119 +485,119 @@ static void free_hotkey_device(union acpi_hotkey *key)
                 free_poll_hotkey_buffer(key);
         }
         kfree(key);
-        return_VOID;
+        return;
 }
 
 static void free_hotkey_buffer(union acpi_hotkey *key)
 {
+        /* key would never be null, action method could be */
         kfree(key->event_hotkey.action_method);
 }
 
 static void free_poll_hotkey_buffer(union acpi_hotkey *key)
 {
+        /* key would never be null, others could be*/
         kfree(key->poll_hotkey.action_method);
         kfree(key->poll_hotkey.poll_method);
         kfree(key->poll_hotkey.poll_result);
 }
 static int
-init_hotkey_device(union acpi_hotkey *key, char *bus_str, char *action_str,
-                   char *method, int std_num, int external_num)
+init_hotkey_device(union acpi_hotkey *key, char **config_entry,
+                   int std_num, int external_num)
 {
         acpi_handle tmp_handle;
         acpi_status status = AE_OK;
 
-        ACPI_FUNCTION_TRACE("init_hotkey_device");
-
         if (std_num < 0 || IS_POLL(std_num) || !key)
                 goto do_fail;
 
-        if (!bus_str || !action_str || !method)
+        if (!config_entry[bus_handle] || !config_entry[action_handle]
+                        || !config_entry[method])
                 goto do_fail;
 
         key->link.hotkey_type = ACPI_HOTKEY_EVENT;
         key->link.hotkey_standard_num = std_num;
         key->event_hotkey.flag = 0;
-        key->event_hotkey.action_method = method;
+        key->event_hotkey.action_method = config_entry[method];
 
-        status =
-            acpi_get_handle(NULL, bus_str, &(key->event_hotkey.bus_handle));
+        status = acpi_get_handle(NULL, config_entry[bus_handle],
+                           &(key->event_hotkey.bus_handle));
         if (ACPI_FAILURE(status))
-                goto do_fail;
+                goto do_fail_zero;
         key->event_hotkey.external_hotkey_num = external_num;
-        status =
-            acpi_get_handle(NULL, action_str,
+        status = acpi_get_handle(NULL, config_entry[action_handle],
                             &(key->event_hotkey.action_handle));
         if (ACPI_FAILURE(status))
-                goto do_fail;
+                goto do_fail_zero;
         status = acpi_get_handle(key->event_hotkey.action_handle,
-                                 method, &tmp_handle);
+                                 config_entry[method], &tmp_handle);
         if (ACPI_FAILURE(status))
-                goto do_fail;
-        return_VALUE(AE_OK);
-      do_fail:
-        return_VALUE(-ENODEV);
+                goto do_fail_zero;
+        return AE_OK;
+do_fail_zero:
+        key->event_hotkey.action_method = NULL;
+do_fail:
+        return -ENODEV;
 }
 
 static int
-init_poll_hotkey_device(union acpi_hotkey *key,
-                        char *poll_str,
-                        char *poll_method,
-                        char *action_str, char *action_method, int std_num)
+init_poll_hotkey_device(union acpi_hotkey *key, char **config_entry,
+                        int std_num)
 {
         acpi_status status = AE_OK;
         acpi_handle tmp_handle;
 
-        ACPI_FUNCTION_TRACE("init_poll_hotkey_device");
-
         if (std_num < 0 || IS_EVENT(std_num) || !key)
                 goto do_fail;
-
-        if (!poll_str || !poll_method || !action_str || !action_method)
+        if (!config_entry[bus_handle] ||!config_entry[bus_method] ||
+                !config_entry[action_handle] || !config_entry[method])
                 goto do_fail;
 
         key->link.hotkey_type = ACPI_HOTKEY_POLLING;
         key->link.hotkey_standard_num = std_num;
         key->poll_hotkey.flag = 0;
-        key->poll_hotkey.poll_method = poll_method;
-        key->poll_hotkey.action_method = action_method;
+        key->poll_hotkey.poll_method = config_entry[bus_method];
+        key->poll_hotkey.action_method = config_entry[method];
 
-        status =
-            acpi_get_handle(NULL, poll_str, &(key->poll_hotkey.poll_handle));
+        status = acpi_get_handle(NULL, config_entry[bus_handle],
+                      &(key->poll_hotkey.poll_handle));
         if (ACPI_FAILURE(status))
-                goto do_fail;
+                goto do_fail_zero;
         status = acpi_get_handle(key->poll_hotkey.poll_handle,
-                                 poll_method, &tmp_handle);
+                                 config_entry[bus_method], &tmp_handle);
         if (ACPI_FAILURE(status))
-                goto do_fail;
+                goto do_fail_zero;
         status =
-            acpi_get_handle(NULL, action_str,
+            acpi_get_handle(NULL, config_entry[action_handle],
                             &(key->poll_hotkey.action_handle));
         if (ACPI_FAILURE(status))
-                goto do_fail;
+                goto do_fail_zero;
         status = acpi_get_handle(key->poll_hotkey.action_handle,
-                                 action_method, &tmp_handle);
+                                 config_entry[method], &tmp_handle);
         if (ACPI_FAILURE(status))
-                goto do_fail;
+                goto do_fail_zero;
         key->poll_hotkey.poll_result =
             (union acpi_object *)kmalloc(sizeof(union acpi_object), GFP_KERNEL);
         if (!key->poll_hotkey.poll_result)
-                goto do_fail;
-        return_VALUE(AE_OK);
-      do_fail:
-        return_VALUE(-ENODEV);
+                goto do_fail_zero;
+        return AE_OK;
+
+do_fail_zero:
+        key->poll_hotkey.poll_method = NULL;
+        key->poll_hotkey.action_method = NULL;
+do_fail:
+        return -ENODEV;
 }
 
 static int hotkey_open_config(struct inode *inode, struct file *file)
 {
-        ACPI_FUNCTION_TRACE("hotkey_open_config");
-        return_VALUE(single_open
+        return (single_open
                      (file, hotkey_config_seq_show, PDE(inode)->data));
 }
 
 static int hotkey_poll_open_config(struct inode *inode, struct file *file)
 {
-        ACPI_FUNCTION_TRACE("hotkey_poll_open_config");
-        return_VALUE(single_open
+        return (single_open
                      (file, hotkey_poll_config_seq_show, PDE(inode)->data));
 }
 
@@ -618,7 +610,6 @@ static int hotkey_config_seq_show(struct seq_file *seq, void *offset)
         struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name };
         struct acpi_buffer act = { ACPI_PATHNAME_MAX, action_name };
 
-        ACPI_FUNCTION_TRACE(("hotkey_config_seq_show"));
 
         list_for_each(entries, hotkey_list->entries) {
                 union acpi_hotkey *key =
@@ -636,7 +627,7 @@ static int hotkey_config_seq_show(struct seq_file *seq, void *offset)
                 }
         }
         seq_puts(seq, "\n");
-        return_VALUE(0);
+        return 0;
 }
 
 static int hotkey_poll_config_seq_show(struct seq_file *seq, void *offset)
@@ -648,7 +639,6 @@ static int hotkey_poll_config_seq_show(struct seq_file *seq, void *offset)
         struct acpi_buffer bus = { ACPI_PATHNAME_MAX, bus_name };
         struct acpi_buffer act = { ACPI_PATHNAME_MAX, action_name };
 
-        ACPI_FUNCTION_TRACE(("hotkey_config_seq_show"));
 
         list_for_each(entries, hotkey_list->entries) {
                 union acpi_hotkey *key =
@@ -666,22 +656,22 @@ static int hotkey_poll_config_seq_show(struct seq_file *seq, void *offset)
                 }
         }
         seq_puts(seq, "\n");
-        return_VALUE(0);
+        return 0;
 }
 
 static int
-get_parms(char *config_record,
-          int *cmd,
-          char **bus_handle,
-          char **bus_method,
-          char **action_handle,
-          char **method, int *internal_event_num, int *external_event_num)
+get_parms(char *config_record, int *cmd, char **config_entry,
+               int *internal_event_num, int *external_event_num)
 {
+/* the format of *config_record =
+ * "1:\d+:*" : "cmd:internal_event_num"
+ * "\d+:\w+:\w+:\w+:\w+:\d+:\d+" :
+ * "cmd:bus_handle:bus_method:action_handle:method:internal_event_num:external_event_num"
+ */
         char *tmp, *tmp1, count;
-        ACPI_FUNCTION_TRACE(("get_parms"));
+        int i;
 
         sscanf(config_record, "%d", cmd);
-
         if (*cmd == 1) {
                 if (sscanf(config_record, "%d:%d", cmd, internal_event_num) !=
                     2)
@@ -693,60 +683,28 @@ get_parms(char *config_record,
         if (!tmp)
                 goto do_fail;
         tmp++;
-        tmp1 = strchr(tmp, ':');
-        if (!tmp1)
-                goto do_fail;
-
-        count = tmp1 - tmp;
-        *bus_handle = (char *)kmalloc(count + 1, GFP_KERNEL);
-        if (!*bus_handle)
-                goto do_fail;
-        strncpy(*bus_handle, tmp, count);
-        *(*bus_handle + count) = 0;
-
-        tmp = tmp1;
-        tmp++;
-        tmp1 = strchr(tmp, ':');
-        if (!tmp1)
-                goto do_fail;
-        count = tmp1 - tmp;
-        *bus_method = (char *)kmalloc(count + 1, GFP_KERNEL);
-        if (!*bus_method)
-                goto do_fail;
-        strncpy(*bus_method, tmp, count);
-        *(*bus_method + count) = 0;
-
-        tmp = tmp1;
-        tmp++;
-        tmp1 = strchr(tmp, ':');
-        if (!tmp1)
-                goto do_fail;
-        count = tmp1 - tmp;
-        *action_handle = (char *)kmalloc(count + 1, GFP_KERNEL);
-        if (!*action_handle)
-                goto do_fail;
-        strncpy(*action_handle, tmp, count);
-        *(*action_handle + count) = 0;
-
-        tmp = tmp1;
-        tmp++;
-        tmp1 = strchr(tmp, ':');
-        if (!tmp1)
-                goto do_fail;
-        count = tmp1 - tmp;
-        *method = (char *)kmalloc(count + 1, GFP_KERNEL);
-        if (!*method)
-                goto do_fail;
-        strncpy(*method, tmp, count);
-        *(*method + count) = 0;
-
-        if (sscanf(tmp1 + 1, "%d:%d", internal_event_num, external_event_num) <=
-            0)
-                goto do_fail;
-
-        return_VALUE(6);
-      do_fail:
-        return_VALUE(-1);
+        for (i = 0; i < LAST_CONF_ENTRY; i++) {
+                tmp1 = strchr(tmp, ':');
+                if (!tmp1) {
+                        goto do_fail;
+                }
+                count = tmp1 - tmp;
+                config_entry[i] = kzalloc(count + 1, GFP_KERNEL);
+                if (!config_entry[i])
+                        goto handle_failure;
+                strncpy(config_entry[i], tmp, count);
+                tmp = tmp1 + 1;
+        }
+        if (sscanf(tmp, "%d:%d", internal_event_num, external_event_num) <= 0)
+                goto handle_failure;
+        if (!IS_OTHERS(*internal_event_num)) {
+                return 6;
+        }
+handle_failure:
+        while (i-- > 0)
+                kfree(config_entry[i]);
+do_fail:
+        return -1;
 }
 
 /*  count is length for one input record */
@@ -755,91 +713,58 @@ static ssize_t hotkey_write_config(struct file *file,
                                    size_t count, loff_t * data)
 {
         char *config_record = NULL;
-        char *bus_handle = NULL;
-        char *bus_method = NULL;
-        char *action_handle = NULL;
-        char *method = NULL;
+        char *config_entry[LAST_CONF_ENTRY];
         int cmd, internal_event_num, external_event_num;
         int ret = 0;
-        union acpi_hotkey *key = NULL;
+        union acpi_hotkey *key = kzalloc(sizeof(union acpi_hotkey), GFP_KERNEL);
 
-        ACPI_FUNCTION_TRACE(("hotkey_write_config"));
+        if (!key)
+                return -ENOMEM;
 
-        config_record = (char *)kmalloc(count + 1, GFP_KERNEL);
-        if (!config_record)
-                return_VALUE(-ENOMEM);
+        config_record = kzalloc(count + 1, GFP_KERNEL);
+        if (!config_record) {
+                kfree(key);
+                return -ENOMEM;
+        }
 
         if (copy_from_user(config_record, buffer, count)) {
                 kfree(config_record);
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data \n"));
-                return_VALUE(-EINVAL);
+                kfree(key);
+                printk(KERN_ERR PREFIX "Invalid data\n");
+                return -EINVAL;
         }
-        config_record[count] = 0;
-
-        ret = get_parms(config_record,
-                        &cmd,
-                        &bus_handle,
-                        &bus_method,
-                        &action_handle,
-                        &method, &internal_event_num, &external_event_num);
-
+        ret = get_parms(config_record, &cmd, config_entry,
+                       &internal_event_num, &external_event_num);
         kfree(config_record);
-        if (IS_OTHERS(internal_event_num))
-                goto do_fail;
         if (ret != 6) {
-              do_fail:
-                kfree(bus_handle);
-                kfree(bus_method);
-                kfree(action_handle);
-                kfree(method);
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Invalid data format ret=%d\n", ret));
-                return_VALUE(-EINVAL);
+                printk(KERN_ERR PREFIX "Invalid data format ret=%d\n", ret);
+                return -EINVAL;
         }
 
-        key = kmalloc(sizeof(union acpi_hotkey), GFP_KERNEL);
-        if (!key)
-                goto do_fail;
-        memset(key, 0, sizeof(union acpi_hotkey));
         if (cmd == 1) {
                 union acpi_hotkey *tmp = NULL;
                 tmp = get_hotkey_by_event(&global_hotkey_list,
                                           internal_event_num);
                 if (!tmp)
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid key"));
+                        printk(KERN_ERR PREFIX "Invalid key\n");
                 else
                         memcpy(key, tmp, sizeof(union acpi_hotkey));
                 goto cont_cmd;
         }
         if (IS_EVENT(internal_event_num)) {
-                kfree(bus_method);
-                ret = init_hotkey_device(key, bus_handle, action_handle, method,
-                                         internal_event_num,
-                                         external_event_num);
-        } else
-                ret = init_poll_hotkey_device(key, bus_handle, bus_method,
-                                              action_handle, method,
-                                              internal_event_num);
-        if (ret) {
-                kfree(bus_handle);
-                kfree(action_handle);
-                if (IS_EVENT(internal_event_num))
-                        free_hotkey_buffer(key);
-                else
-                        free_poll_hotkey_buffer(key);
-                kfree(key);
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid hotkey \n"));
-                return_VALUE(-EINVAL);
+                if (init_hotkey_device(key, config_entry,
+                        internal_event_num, external_event_num))
+                        goto init_hotkey_fail;
+        } else {
+                if (init_poll_hotkey_device(key, config_entry,
+                               internal_event_num))
+                        goto init_poll_hotkey_fail;
         }
-
-      cont_cmd:
-        kfree(bus_handle);
-        kfree(action_handle);
-
+cont_cmd:
         switch (cmd) {
         case 0:
-                if (get_hotkey_by_event
-                    (&global_hotkey_list, key->link.hotkey_standard_num))
+                if (get_hotkey_by_event(&global_hotkey_list,
+                                key->link.hotkey_standard_num))
                         goto fail_out;
                 else
                         hotkey_add(key);
@@ -848,6 +773,7 @@ static ssize_t hotkey_write_config(struct file *file,
                 hotkey_remove(key);
                 break;
         case 2:
+                /* key is kfree()ed if matched*/
                 if (hotkey_update(key))
                         goto fail_out;
                 break;
@@ -855,15 +781,26 @@ static ssize_t hotkey_write_config(struct file *file,
                 goto fail_out;
                 break;
         }
-        return_VALUE(count);
-      fail_out:
-        if (IS_EVENT(internal_event_num))
-                free_hotkey_buffer(key);
-        else
-                free_poll_hotkey_buffer(key);
+        return count;
+
+init_poll_hotkey_fail:          /* failed init_poll_hotkey_device */
+        kfree(config_entry[bus_method]);
+        config_entry[bus_method] = NULL;
+init_hotkey_fail:               /* failed init_hotkey_device */
+        kfree(config_entry[method]);
+fail_out:
+        kfree(config_entry[bus_handle]);
+        kfree(config_entry[action_handle]);
+        /* No double free since elements =NULL for error cases */
+        if (IS_EVENT(internal_event_num)) {
+                if (config_entry[bus_method])
+                        kfree(config_entry[bus_method]);
+                free_hotkey_buffer(key);        /* frees [method] */
+        } else
+                free_poll_hotkey_buffer(key);  /* frees [bus_method]+[method] */
         kfree(key);
-        ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "invalid key\n"));
-        return_VALUE(-EINVAL);
+        printk(KERN_ERR PREFIX "invalid key\n");
+        return -EINVAL;
 }
 
 /*
@@ -880,7 +817,6 @@ static int write_acpi_int(acpi_handle handle, const char *method, int val,
         union acpi_object in_obj;       /* the only param we use */
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("write_acpi_int");
         params.count = 1;
         params.pointer = &in_obj;
         in_obj.type = ACPI_TYPE_INTEGER;
@@ -888,7 +824,7 @@ static int write_acpi_int(acpi_handle handle, const char *method, int val,
 
         status = acpi_evaluate_object(handle, (char *)method, &params, output);
 
-        return_VALUE(status == AE_OK);
+        return (status == AE_OK);
 }
 
 static int read_acpi_int(acpi_handle handle, const char *method,
@@ -898,7 +834,6 @@ static int read_acpi_int(acpi_handle handle, const char *method,
         union acpi_object out_obj;
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("read_acpi_int");
         output.length = sizeof(out_obj);
         output.pointer = &out_obj;
 
@@ -907,8 +842,8 @@ static int read_acpi_int(acpi_handle handle, const char *method,
                 val->integer.value = out_obj.integer.value;
                 val->type = out_obj.type;
         } else
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "null val pointer"));
-        return_VALUE((status == AE_OK)
+                printk(KERN_ERR PREFIX "null val pointer\n");
+        return ((status == AE_OK)
                      && (out_obj.type == ACPI_TYPE_INTEGER));
 }
 
@@ -945,24 +880,22 @@ static ssize_t hotkey_execute_aml_method(struct file *file,
         int event, method_type, type, value;
         union acpi_hotkey *key;
 
-        ACPI_FUNCTION_TRACE("hotkey_execte_aml_method");
 
-        arg = (char *)kmalloc(count + 1, GFP_KERNEL);
+        arg = kzalloc(count + 1, GFP_KERNEL);
         if (!arg)
-                return_VALUE(-ENOMEM);
-        arg[count] = 0;
+                return -ENOMEM;
 
         if (copy_from_user(arg, buffer, count)) {
                 kfree(arg);
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 2"));
-                return_VALUE(-EINVAL);
+                printk(KERN_ERR PREFIX "Invalid argument 2\n");
+                return -EINVAL;
         }
 
         if (sscanf(arg, "%d:%d:%d:%d", &event, &method_type, &type, &value) !=
             4) {
                 kfree(arg);
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument 3"));
-                return_VALUE(-EINVAL);
+                printk(KERN_ERR PREFIX "Invalid argument 3\n");
+                return -EINVAL;
         }
         kfree(arg);
         if (type == ACPI_TYPE_INTEGER) {
@@ -987,12 +920,12 @@ static ssize_t hotkey_execute_aml_method(struct file *file,
 
                 }
         } else {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Not supported"));
-                return_VALUE(-EINVAL);
+                printk(KERN_WARNING "Not supported\n");
+                return -EINVAL;
         }
-        return_VALUE(count);
+        return count;
       do_fail:
-        return_VALUE(-EINVAL);
+        return -EINVAL;
 
 }
 
@@ -1001,7 +934,6 @@ static int __init hotkey_init(void)
         int result;
         mode_t mode = S_IFREG | S_IRUGO | S_IWUGO;
 
-        ACPI_FUNCTION_TRACE("hotkey_init");
 
         if (acpi_disabled)
                 return -ENODEV;
@@ -1013,9 +945,6 @@ static int __init hotkey_init(void)
 
         hotkey_proc_dir = proc_mkdir(HOTKEY_PROC, acpi_root_dir);
         if (!hotkey_proc_dir) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Hotkey: Unable to create %s entry\n",
-                                  HOTKEY_PROC));
                 return (-ENODEV);
         }
         hotkey_proc_dir->owner = THIS_MODULE;
@@ -1023,9 +952,6 @@ static int __init hotkey_init(void)
         hotkey_config =
             create_proc_entry(HOTKEY_EV_CONFIG, mode, hotkey_proc_dir);
         if (!hotkey_config) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Hotkey: Unable to create %s entry\n",
-                                  HOTKEY_EV_CONFIG));
                 goto do_fail1;
         } else {
                 hotkey_config->proc_fops = &hotkey_config_fops;
@@ -1038,10 +964,6 @@ static int __init hotkey_init(void)
         hotkey_poll_config =
             create_proc_entry(HOTKEY_PL_CONFIG, mode, hotkey_proc_dir);
         if (!hotkey_poll_config) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Hotkey: Unable to create %s entry\n",
-                                  HOTKEY_EV_CONFIG));
-
                 goto do_fail2;
         } else {
                 hotkey_poll_config->proc_fops = &hotkey_poll_config_fops;
@@ -1053,9 +975,6 @@ static int __init hotkey_init(void)
 
         hotkey_action = create_proc_entry(HOTKEY_ACTION, mode, hotkey_proc_dir);
         if (!hotkey_action) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Hotkey: Unable to create %s entry\n",
-                                  HOTKEY_ACTION));
                 goto do_fail3;
         } else {
                 hotkey_action->proc_fops = &hotkey_action_fops;
@@ -1066,9 +985,6 @@ static int __init hotkey_init(void)
 
         hotkey_info = create_proc_entry(HOTKEY_INFO, mode, hotkey_proc_dir);
         if (!hotkey_info) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Hotkey: Unable to create %s entry\n",
-                                  HOTKEY_INFO));
                 goto do_fail4;
         } else {
                 hotkey_info->proc_fops = &hotkey_info_fops;
@@ -1104,7 +1020,6 @@ static void __exit hotkey_exit(void)
 {
         struct list_head *entries, *next;
 
-        ACPI_FUNCTION_TRACE("hotkey_exit");
 
         list_for_each_safe(entries, next, global_hotkey_list.entries) {
                 union acpi_hotkey *key =
diff --git a/drivers/acpi/i2c_ec.c b/drivers/acpi/i2c_ec.c
new file mode 100644
index 000000000000..6342e612c203
--- /dev/null
+++ b/drivers/acpi/i2c_ec.c
@@ -0,0 +1,406 @@
+/*
+ * SMBus driver for ACPI Embedded Controller ($Revision: 1.3 $)
+ *
+ * Copyright (c) 2002, 2005 Ducrot Bruno
+ * Copyright (c) 2005 Rich Townsend (tiny hacks & tweaks)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation version 2.
+ */
+
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/sched.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/acpi.h>
+#include <linux/delay.h>
+
+#include "i2c_ec.h"
+
+#define xudelay(t)      udelay(t)
+#define xmsleep(t)      msleep(t)
+
+#define ACPI_EC_HC_COMPONENT    0x00080000
+#define ACPI_EC_HC_CLASS        "ec_hc_smbus"
+#define ACPI_EC_HC_HID          "ACPI0001"
+#define ACPI_EC_HC_DRIVER_NAME  "ACPI EC HC smbus driver"
+#define ACPI_EC_HC_DEVICE_NAME  "EC HC smbus"
+
+#define _COMPONENT              ACPI_EC_HC_COMPONENT
+
+ACPI_MODULE_NAME("acpi_smbus")
+
+static int acpi_ec_hc_add(struct acpi_device *device);
+static int acpi_ec_hc_remove(struct acpi_device *device, int type);
+
+static struct acpi_driver acpi_ec_hc_driver = {
+        .name = ACPI_EC_HC_DRIVER_NAME,
+        .class = ACPI_EC_HC_CLASS,
+        .ids = ACPI_EC_HC_HID,
+        .ops = {
+                .add = acpi_ec_hc_add,
+                .remove = acpi_ec_hc_remove,
+                },
+};
+
+/* Various bit mask for EC_SC (R) */
+#define OBF             0x01
+#define IBF             0x02
+#define CMD             0x08
+#define BURST           0x10
+#define SCI_EVT         0x20
+#define SMI_EVT         0x40
+
+/* Commands for EC_SC (W) */
+#define RD_EC           0x80
+#define WR_EC           0x81
+#define BE_EC           0x82
+#define BD_EC           0x83
+#define QR_EC           0x84
+
+/*
+ * ACPI 2.0 chapter 13 SMBus 2.0 EC register model
+ */
+
+#define ACPI_EC_SMB_PRTCL       0x00    /* protocol, PEC */
+#define ACPI_EC_SMB_STS         0x01    /* status */
+#define ACPI_EC_SMB_ADDR        0x02    /* address */
+#define ACPI_EC_SMB_CMD         0x03    /* command */
+#define ACPI_EC_SMB_DATA        0x04    /* 32 data registers */
+#define ACPI_EC_SMB_BCNT        0x24    /* number of data bytes */
+#define ACPI_EC_SMB_ALRM_A      0x25    /* alarm address */
+#define ACPI_EC_SMB_ALRM_D      0x26    /* 2 bytes alarm data */
+
+#define ACPI_EC_SMB_STS_DONE    0x80
+#define ACPI_EC_SMB_STS_ALRM    0x40
+#define ACPI_EC_SMB_STS_RES     0x20
+#define ACPI_EC_SMB_STS_STATUS  0x1f
+
+#define ACPI_EC_SMB_STATUS_OK           0x00
+#define ACPI_EC_SMB_STATUS_FAIL         0x07
+#define ACPI_EC_SMB_STATUS_DNAK         0x10
+#define ACPI_EC_SMB_STATUS_DERR         0x11
+#define ACPI_EC_SMB_STATUS_CMD_DENY     0x12
+#define ACPI_EC_SMB_STATUS_UNKNOWN      0x13
+#define ACPI_EC_SMB_STATUS_ACC_DENY     0x17
+#define ACPI_EC_SMB_STATUS_TIMEOUT      0x18
+#define ACPI_EC_SMB_STATUS_NOTSUP       0x19
+#define ACPI_EC_SMB_STATUS_BUSY         0x1A
+#define ACPI_EC_SMB_STATUS_PEC          0x1F
+
+#define ACPI_EC_SMB_PRTCL_WRITE                 0x00
+#define ACPI_EC_SMB_PRTCL_READ                  0x01
+#define ACPI_EC_SMB_PRTCL_QUICK                 0x02
+#define ACPI_EC_SMB_PRTCL_BYTE                  0x04
+#define ACPI_EC_SMB_PRTCL_BYTE_DATA             0x06
+#define ACPI_EC_SMB_PRTCL_WORD_DATA             0x08
+#define ACPI_EC_SMB_PRTCL_BLOCK_DATA            0x0a
+#define ACPI_EC_SMB_PRTCL_PROC_CALL             0x0c
+#define ACPI_EC_SMB_PRTCL_BLOCK_PROC_CALL       0x0d
+#define ACPI_EC_SMB_PRTCL_I2C_BLOCK_DATA        0x4a
+#define ACPI_EC_SMB_PRTCL_PEC                   0x80
+
+/* Length of pre/post transaction sleep (msec) */
+#define ACPI_EC_SMB_TRANSACTION_SLEEP           1
+#define ACPI_EC_SMB_ACCESS_SLEEP1               1
+#define ACPI_EC_SMB_ACCESS_SLEEP2               10
+
+static int acpi_ec_smb_read(struct acpi_ec_smbus *smbus, u8 address, u8 * data)
+{
+        u8 val;
+        int err;
+
+        err = ec_read(smbus->base + address, &val);
+        if (!err) {
+                *data = val;
+        }
+        xmsleep(ACPI_EC_SMB_TRANSACTION_SLEEP);
+        return (err);
+}
+
+static int acpi_ec_smb_write(struct acpi_ec_smbus *smbus, u8 address, u8 data)
+{
+        int err;
+
+        err = ec_write(smbus->base + address, data);
+        return (err);
+}
+
+static int
+acpi_ec_smb_access(struct i2c_adapter *adap, u16 addr, unsigned short flags,
+                   char read_write, u8 command, int size,
+                   union i2c_smbus_data *data)
+{
+        struct acpi_ec_smbus *smbus = adap->algo_data;
+        unsigned char protocol, len = 0, pec, temp[2] = { 0, 0 };
+        int i;
+
+        if (read_write == I2C_SMBUS_READ) {
+                protocol = ACPI_EC_SMB_PRTCL_READ;
+        } else {
+                protocol = ACPI_EC_SMB_PRTCL_WRITE;
+        }
+        pec = (flags & I2C_CLIENT_PEC) ? ACPI_EC_SMB_PRTCL_PEC : 0;
+
+        switch (size) {
+
+        case I2C_SMBUS_QUICK:
+                protocol |= ACPI_EC_SMB_PRTCL_QUICK;
+                read_write = I2C_SMBUS_WRITE;
+                break;
+
+        case I2C_SMBUS_BYTE:
+                if (read_write == I2C_SMBUS_WRITE) {
+                        acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA, data->byte);
+                }
+                protocol |= ACPI_EC_SMB_PRTCL_BYTE;
+                break;
+
+        case I2C_SMBUS_BYTE_DATA:
+                acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
+                if (read_write == I2C_SMBUS_WRITE) {
+                        acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA, data->byte);
+                }
+                protocol |= ACPI_EC_SMB_PRTCL_BYTE_DATA;
+                break;
+
+        case I2C_SMBUS_WORD_DATA:
+                acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
+                if (read_write == I2C_SMBUS_WRITE) {
+                        acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA, data->word);
+                        acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA + 1,
+                                          data->word >> 8);
+                }
+                protocol |= ACPI_EC_SMB_PRTCL_WORD_DATA | pec;
+                break;
+
+        case I2C_SMBUS_BLOCK_DATA:
+                acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
+                if (read_write == I2C_SMBUS_WRITE) {
+                        len = min_t(u8, data->block[0], 32);
+                        acpi_ec_smb_write(smbus, ACPI_EC_SMB_BCNT, len);
+                        for (i = 0; i < len; i++)
+                                acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA + i,
+                                                  data->block[i + 1]);
+                }
+                protocol |= ACPI_EC_SMB_PRTCL_BLOCK_DATA | pec;
+                break;
+
+        case I2C_SMBUS_I2C_BLOCK_DATA:
+                len = min_t(u8, data->block[0], 32);
+                acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
+                acpi_ec_smb_write(smbus, ACPI_EC_SMB_BCNT, len);
+                if (read_write == I2C_SMBUS_WRITE) {
+                        for (i = 0; i < len; i++) {
+                                acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA + i,
+                                                  data->block[i + 1]);
+                        }
+                }
+                protocol |= ACPI_EC_SMB_PRTCL_I2C_BLOCK_DATA;
+                break;
+
+        case I2C_SMBUS_PROC_CALL:
+                acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
+                acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA, data->word);
+                acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA + 1, data->word >> 8);
+                protocol = ACPI_EC_SMB_PRTCL_PROC_CALL | pec;
+                read_write = I2C_SMBUS_READ;
+                break;
+
+        case I2C_SMBUS_BLOCK_PROC_CALL:
+                protocol |= pec;
+                len = min_t(u8, data->block[0], 31);
+                acpi_ec_smb_write(smbus, ACPI_EC_SMB_CMD, command);
+                acpi_ec_smb_write(smbus, ACPI_EC_SMB_BCNT, len);
+                for (i = 0; i < len; i++)
+                        acpi_ec_smb_write(smbus, ACPI_EC_SMB_DATA + i,
+                                          data->block[i + 1]);
+                protocol = ACPI_EC_SMB_PRTCL_BLOCK_PROC_CALL | pec;
+                read_write = I2C_SMBUS_READ;
+                break;
+
+        default:
+                ACPI_DEBUG_PRINT((ACPI_DB_WARN, "EC SMBus adapter: "
+                                  "Unsupported transaction %d\n", size));
+                return (-1);
+        }
+
+        acpi_ec_smb_write(smbus, ACPI_EC_SMB_ADDR, addr << 1);
+        acpi_ec_smb_write(smbus, ACPI_EC_SMB_PRTCL, protocol);
+
+        acpi_ec_smb_read(smbus, ACPI_EC_SMB_STS, temp + 0);
+
+        if (~temp[0] & ACPI_EC_SMB_STS_DONE) {
+                xudelay(500);
+                acpi_ec_smb_read(smbus, ACPI_EC_SMB_STS, temp + 0);
+        }
+        if (~temp[0] & ACPI_EC_SMB_STS_DONE) {
+                xmsleep(ACPI_EC_SMB_ACCESS_SLEEP2);
+                acpi_ec_smb_read(smbus, ACPI_EC_SMB_STS, temp + 0);
+        }
+        if ((~temp[0] & ACPI_EC_SMB_STS_DONE)
+            || (temp[0] & ACPI_EC_SMB_STS_STATUS)) {
+                return (-1);
+        }
+
+        if (read_write == I2C_SMBUS_WRITE) {
+                return (0);
+        }
+
+        switch (size) {
+
+        case I2C_SMBUS_BYTE:
+        case I2C_SMBUS_BYTE_DATA:
+                acpi_ec_smb_read(smbus, ACPI_EC_SMB_DATA, &data->byte);
+                break;
+
+        case I2C_SMBUS_WORD_DATA:
+        case I2C_SMBUS_PROC_CALL:
+                acpi_ec_smb_read(smbus, ACPI_EC_SMB_DATA, temp + 0);
+                acpi_ec_smb_read(smbus, ACPI_EC_SMB_DATA + 1, temp + 1);
+                data->word = (temp[1] << 8) | temp[0];
+                break;
+
+        case I2C_SMBUS_BLOCK_DATA:
+        case I2C_SMBUS_BLOCK_PROC_CALL:
+                len = 0;
+                acpi_ec_smb_read(smbus, ACPI_EC_SMB_BCNT, &len);
+                len = min_t(u8, len, 32);
+        case I2C_SMBUS_I2C_BLOCK_DATA:
+                for (i = 0; i < len; i++)
+                        acpi_ec_smb_read(smbus, ACPI_EC_SMB_DATA + i,
+                                         data->block + i + 1);
+                data->block[0] = len;
+                break;
+        }
+
+        return (0);
+}
+
+static u32 acpi_ec_smb_func(struct i2c_adapter *adapter)
+{
+
+        return (I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
+                I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
+                I2C_FUNC_SMBUS_BLOCK_DATA |
+                I2C_FUNC_SMBUS_PROC_CALL |
+                I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
+                I2C_FUNC_SMBUS_I2C_BLOCK | I2C_FUNC_SMBUS_HWPEC_CALC);
+}
+
+static const struct i2c_algorithm acpi_ec_smbus_algorithm = {
+        .smbus_xfer = acpi_ec_smb_access,
+        .functionality = acpi_ec_smb_func,
+};
+
+static int acpi_ec_hc_add(struct acpi_device *device)
+{
+        int status;
+        unsigned long val;
+        struct acpi_ec_hc *ec_hc;
+        struct acpi_ec_smbus *smbus;
+
+        if (!device) {
+                return -EINVAL;
+        }
+
+        ec_hc = kmalloc(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);
+        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);
+        strcpy(acpi_device_class(device), ACPI_EC_HC_CLASS);
+        acpi_driver_data(device) = ec_hc;
+
+        status = acpi_evaluate_integer(ec_hc->handle, "_EC", NULL, &val);
+        if (ACPI_FAILURE(status)) {
+                ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Error obtaining _EC\n"));
+                kfree(ec_hc);
+                kfree(smbus);
+                return -EIO;
+        }
+
+        smbus->ec = acpi_driver_data(device->parent);
+        smbus->base = (val & 0xff00ull) >> 8;
+        smbus->alert = val & 0xffull;
+
+        smbus->adapter.owner = THIS_MODULE;
+        smbus->adapter.algo = &acpi_ec_smbus_algorithm;
+        smbus->adapter.algo_data = smbus;
+
+        if (i2c_add_adapter(&smbus->adapter)) {
+                ACPI_DEBUG_PRINT((ACPI_DB_WARN,
+                                  "EC SMBus adapter: Failed to register adapter\n"));
+                kfree(smbus);
+                kfree(ec_hc);
+                return -EIO;
+        }
+
+        ec_hc->smbus = smbus;
+
+        printk(KERN_INFO PREFIX "%s [%s]\n",
+               acpi_device_name(device), acpi_device_bid(device));
+
+        return AE_OK;
+}
+
+static int acpi_ec_hc_remove(struct acpi_device *device, int type)
+{
+        struct acpi_ec_hc *ec_hc;
+
+        if (!device) {
+                return -EINVAL;
+        }
+        ec_hc = acpi_driver_data(device);
+
+        i2c_del_adapter(&ec_hc->smbus->adapter);
+        kfree(ec_hc->smbus);
+        kfree(ec_hc);
+
+        return AE_OK;
+}
+
+static int __init acpi_ec_hc_init(void)
+{
+        int result;
+
+        result = acpi_bus_register_driver(&acpi_ec_hc_driver);
+        if (result < 0) {
+                return -ENODEV;
+        }
+        return 0;
+}
+
+static void __exit acpi_ec_hc_exit(void)
+{
+        acpi_bus_unregister_driver(&acpi_ec_hc_driver);
+}
+
+struct acpi_ec_hc *acpi_get_ec_hc(struct acpi_device *device)
+{
+        return ((struct acpi_ec_hc *)acpi_driver_data(device->parent));
+}
+
+EXPORT_SYMBOL(acpi_get_ec_hc);
+
+module_init(acpi_ec_hc_init);
+module_exit(acpi_ec_hc_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Ducrot Bruno");
+MODULE_DESCRIPTION("ACPI EC SMBus driver");
diff --git a/drivers/acpi/i2c_ec.h b/drivers/acpi/i2c_ec.h
new file mode 100644
index 000000000000..7c53fb732d61
--- /dev/null
+++ b/drivers/acpi/i2c_ec.h
@@ -0,0 +1,23 @@
+/*
+ * SMBus driver for ACPI Embedded Controller ($Revision: 1.2 $)
+ *
+ * Copyright (c) 2002, 2005 Ducrot Bruno
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation version 2.
+ */
+
+struct acpi_ec_smbus {
+        struct i2c_adapter adapter;
+        union acpi_ec *ec;
+        int base;
+        int alert;
+};
+
+struct acpi_ec_hc {
+        acpi_handle handle;
+        struct acpi_ec_smbus *smbus;
+};
+
+struct acpi_ec_hc *acpi_get_ec_hc(struct acpi_device *device);
diff --git a/drivers/acpi/motherboard.c b/drivers/acpi/motherboard.c
index d51d68f5dd8d..ec6b7f9ede34 100644
--- a/drivers/acpi/motherboard.c
+++ b/drivers/acpi/motherboard.c
@@ -52,13 +52,12 @@ static acpi_status acpi_reserve_io_ranges(struct acpi_resource *res, void *data)
 {
         struct resource *requested_res = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_reserve_io_ranges");
 
         if (res->type == ACPI_RESOURCE_TYPE_IO) {
                 struct acpi_resource_io *io_res = &res->data.io;
 
                 if (io_res->minimum != io_res->maximum)
-                        return_VALUE(AE_OK);
+                        return AE_OK;
                 if (IS_RESERVED_ADDR
                     (io_res->minimum, io_res->address_length)) {
                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
@@ -92,7 +91,7 @@ static acpi_status acpi_reserve_io_ranges(struct acpi_resource *res, void *data)
 
         if (requested_res)
                 requested_res->flags &= ~IORESOURCE_BUSY;
-        return_VALUE(AE_OK);
+        return AE_OK;
 }
 
 static int acpi_motherboard_add(struct acpi_device *device)
diff --git a/drivers/acpi/namespace/nsaccess.c b/drivers/acpi/namespace/nsaccess.c
index 48fadade52e2..c1c6c236df9a 100644
--- a/drivers/acpi/namespace/nsaccess.c
+++ b/drivers/acpi/namespace/nsaccess.c
@@ -196,33 +196,30 @@ acpi_status acpi_ns_root_initialize(void)
                                     (u8) (ACPI_TO_INTEGER(val) - 1);
 
                                 if (ACPI_STRCMP(init_val->name, "_GL_") == 0) {
-                                        /*
-                                         * Create a counting semaphore for the
-                                         * global lock
-                                         */
+
+                                        /* Create a counting semaphore for the global lock */
+
                                         status =
                                             acpi_os_create_semaphore
                                             (ACPI_NO_UNIT_LIMIT, 1,
-                                             &obj_desc->mutex.semaphore);
+                                             &acpi_gbl_global_lock_semaphore);
                                         if (ACPI_FAILURE(status)) {
                                                 acpi_ut_remove_reference
                                                     (obj_desc);
                                                 goto unlock_and_exit;
                                         }
 
-                                        /*
-                                         * We just created the mutex for the
-                                         * global lock, save it
-                                         */
-                                        acpi_gbl_global_lock_semaphore =
-                                            obj_desc->mutex.semaphore;
+                                        /* Mark this mutex as very special */
+
+                                        obj_desc->mutex.os_mutex =
+                                            ACPI_GLOBAL_LOCK;
                                 } else {
                                         /* Create a mutex */
 
-                                        status = acpi_os_create_semaphore(1, 1,
-                                                                          &obj_desc->
-                                                                          mutex.
-                                                                          semaphore);
+                                        status =
+                                            acpi_os_create_mutex(&obj_desc->
+                                                                 mutex.
+                                                                 os_mutex);
                                         if (ACPI_FAILURE(status)) {
                                                 acpi_ut_remove_reference
                                                     (obj_desc);
diff --git a/drivers/acpi/namespace/nsalloc.c b/drivers/acpi/namespace/nsalloc.c
index dc3f0739a46b..55b407aae266 100644
--- a/drivers/acpi/namespace/nsalloc.c
+++ b/drivers/acpi/namespace/nsalloc.c
@@ -386,14 +386,17 @@ void acpi_ns_delete_namespace_subtree(struct acpi_namespace_node *parent_node)
  *              specific ID.  Used to delete entire ACPI tables.  All
  *              reference counts are updated.
  *
+ * MUTEX:       Locks namespace during deletion walk.
+ *
  ******************************************************************************/
 
 void acpi_ns_delete_namespace_by_owner(acpi_owner_id owner_id)
 {
         struct acpi_namespace_node *child_node;
         struct acpi_namespace_node *deletion_node;
-        u32 level;
         struct acpi_namespace_node *parent_node;
+        u32 level;
+        acpi_status status;
 
         ACPI_FUNCTION_TRACE_U32(ns_delete_namespace_by_owner, owner_id);
 
@@ -401,6 +404,13 @@ void acpi_ns_delete_namespace_by_owner(acpi_owner_id owner_id)
                 return_VOID;
         }
 
+        /* Lock namespace for possible update */
+
+        status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
+        if (ACPI_FAILURE(status)) {
+                return_VOID;
+        }
+
         deletion_node = NULL;
         parent_node = acpi_gbl_root_node;
         child_node = NULL;
@@ -469,5 +479,6 @@ void acpi_ns_delete_namespace_by_owner(acpi_owner_id owner_id)
                 }
         }
 
+        (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
         return_VOID;
 }
diff --git a/drivers/acpi/namespace/nsxfeval.c b/drivers/acpi/namespace/nsxfeval.c
index 6d9bd45af30a..dca6799ac678 100644
--- a/drivers/acpi/namespace/nsxfeval.c
+++ b/drivers/acpi/namespace/nsxfeval.c
@@ -133,7 +133,7 @@ acpi_evaluate_object_typed(acpi_handle handle,
 
                 /* Caller used ACPI_ALLOCATE_BUFFER, free the return buffer */
 
-                acpi_os_free(return_buffer->pointer);
+                ACPI_FREE(return_buffer->pointer);
                 return_buffer->pointer = NULL;
         }
 
diff --git a/drivers/acpi/numa.c b/drivers/acpi/numa.c
index e2c1a16078c9..e5e448edca41 100644
--- a/drivers/acpi/numa.c
+++ b/drivers/acpi/numa.c
@@ -23,7 +23,6 @@
  *
  */
 #include <linux/module.h>
-#include <linux/config.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -254,5 +253,16 @@ int acpi_get_pxm(acpi_handle h)
         } while (ACPI_SUCCESS(status));
         return -1;
 }
-
 EXPORT_SYMBOL(acpi_get_pxm);
+
+int acpi_get_node(acpi_handle *handle)
+{
+        int pxm, node = -1;
+
+        pxm = acpi_get_pxm(handle);
+        if (pxm >= 0)
+                node = acpi_map_pxm_to_node(pxm);
+
+        return node;
+}
+EXPORT_SYMBOL(acpi_get_node);
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index 1bb558adee66..20beea778ea2 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -25,7 +25,6 @@
  *
  */
 
-#include <linux/config.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
@@ -37,7 +36,6 @@
 #include <linux/delay.h>
 #include <linux/workqueue.h>
 #include <linux/nmi.h>
-#include <linux/kthread.h>
 #include <acpi/acpi.h>
 #include <asm/io.h>
 #include <acpi/acpi_bus.h>
@@ -137,22 +135,6 @@ void acpi_os_vprintf(const char *fmt, va_list args)
 #endif
 }
 
-extern int acpi_in_resume;
-void *acpi_os_allocate(acpi_size size)
-{
-        if (acpi_in_resume)
-                return kmalloc(size, GFP_ATOMIC);
-        else
-                return kmalloc(size, GFP_KERNEL);
-}
-
-void acpi_os_free(void *ptr)
-{
-        kfree(ptr);
-}
-
-EXPORT_SYMBOL(acpi_os_free);
-
 acpi_status acpi_os_get_root_pointer(u32 flags, struct acpi_pointer *addr)
 {
         if (efi_enabled) {
@@ -280,7 +262,7 @@ acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
 
         acpi_irq_handler = handler;
         acpi_irq_context = context;
-        if (request_irq(irq, acpi_irq, SA_SHIRQ, "acpi", acpi_irq)) {
+        if (request_irq(irq, acpi_irq, IRQF_SHARED, "acpi", acpi_irq)) {
                 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
                 return AE_NOT_ACQUIRED;
         }
@@ -586,29 +568,18 @@ static void acpi_os_execute_deferred(void *context)
 {
         struct acpi_os_dpc *dpc = NULL;
 
-        ACPI_FUNCTION_TRACE("os_execute_deferred");
 
         dpc = (struct acpi_os_dpc *)context;
         if (!dpc) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid (NULL) context.\n"));
-                return_VOID;
+                printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
+                return;
         }
 
         dpc->function(dpc->context);
 
         kfree(dpc);
 
-        return_VOID;
-}
-
-static int acpi_os_execute_thread(void *context)
-{
-        struct acpi_os_dpc *dpc = (struct acpi_os_dpc *)context;
-        if (dpc) {
-                dpc->function(dpc->context);
-                kfree(dpc);
-        }
-        do_exit(0);
+        return;
 }
 
 /*******************************************************************************
@@ -632,10 +603,16 @@ acpi_status acpi_os_execute(acpi_execute_type type,
         acpi_status status = AE_OK;
         struct acpi_os_dpc *dpc;
         struct work_struct *task;
-        struct task_struct *p;
+
+        ACPI_FUNCTION_TRACE("os_queue_for_execution");
+
+        ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
+                          "Scheduling function [%p(%p)] for deferred execution.\n",
+                          function, context));
 
         if (!function)
-                return AE_BAD_PARAMETER;
+                return_ACPI_STATUS(AE_BAD_PARAMETER);
+
         /*
          * Allocate/initialize DPC structure.  Note that this memory will be
          * freed by the callee.  The kernel handles the tq_struct list  in a
@@ -646,34 +623,27 @@ acpi_status acpi_os_execute(acpi_execute_type type,
          * We can save time and code by allocating the DPC and tq_structs
          * from the same memory.
          */
-        if (type == OSL_NOTIFY_HANDLER) {
-                dpc = kmalloc(sizeof(struct acpi_os_dpc), GFP_KERNEL);
-        } else {
-                dpc = kmalloc(sizeof(struct acpi_os_dpc) +
-                                sizeof(struct work_struct), GFP_ATOMIC);
-        }
+
+        dpc =
+            kmalloc(sizeof(struct acpi_os_dpc) + sizeof(struct work_struct),
+                    GFP_ATOMIC);
         if (!dpc)
-                return AE_NO_MEMORY;
+                return_ACPI_STATUS(AE_NO_MEMORY);
+
         dpc->function = function;
         dpc->context = context;
 
-        if (type == OSL_NOTIFY_HANDLER) {
-                p = kthread_create(acpi_os_execute_thread, dpc, "kacpid_notify");
-                if (!IS_ERR(p)) {
-                        wake_up_process(p);
-                } else {
-                        status = AE_NO_MEMORY;
-                        kfree(dpc);
-                }
-        } else {
-                task = (void *)(dpc + 1);
-                INIT_WORK(task, acpi_os_execute_deferred, (void *)dpc);
-                if (!queue_work(kacpid_wq, task)) {
-                        status = AE_ERROR;
-                        kfree(dpc);
-                }
+        task = (void *)(dpc + 1);
+        INIT_WORK(task, acpi_os_execute_deferred, (void *)dpc);
+
+        if (!queue_work(kacpid_wq, task)) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "Call to queue_work() failed.\n"));
+                kfree(dpc);
+                status = AE_ERROR;
         }
-        return status;
+
+        return_ACPI_STATUS(status);
 }
 
 EXPORT_SYMBOL(acpi_os_execute);
@@ -688,35 +658,19 @@ EXPORT_SYMBOL(acpi_os_wait_events_complete);
 /*
  * Allocate the memory for a spinlock and initialize it.
  */
-acpi_status acpi_os_create_lock(acpi_handle * out_handle)
+acpi_status acpi_os_create_lock(acpi_spinlock * handle)
 {
-        spinlock_t *lock_ptr;
-
-        ACPI_FUNCTION_TRACE("os_create_lock");
-
-        lock_ptr = acpi_os_allocate(sizeof(spinlock_t));
-
-        spin_lock_init(lock_ptr);
-
-        ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating spinlock[%p].\n", lock_ptr));
+        spin_lock_init(*handle);
 
-        *out_handle = lock_ptr;
-
-        return_ACPI_STATUS(AE_OK);
+        return AE_OK;
 }
 
 /*
  * Deallocate the memory for a spinlock.
  */
-void acpi_os_delete_lock(acpi_handle handle)
+void acpi_os_delete_lock(acpi_spinlock handle)
 {
-        ACPI_FUNCTION_TRACE("os_create_lock");
-
-        ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting spinlock[%p].\n", handle));
-
-        acpi_os_free(handle);
-
-        return_VOID;
+        return;
 }
 
 acpi_status
@@ -724,11 +678,10 @@ acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
 {
         struct semaphore *sem = NULL;
 
-        ACPI_FUNCTION_TRACE("os_create_semaphore");
 
         sem = acpi_os_allocate(sizeof(struct semaphore));
         if (!sem)
-                return_ACPI_STATUS(AE_NO_MEMORY);
+                return AE_NO_MEMORY;
         memset(sem, 0, sizeof(struct semaphore));
 
         sema_init(sem, initial_units);
@@ -738,7 +691,7 @@ acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
                           *handle, initial_units));
 
-        return_ACPI_STATUS(AE_OK);
+        return AE_OK;
 }
 
 EXPORT_SYMBOL(acpi_os_create_semaphore);
@@ -754,17 +707,16 @@ acpi_status acpi_os_delete_semaphore(acpi_handle handle)
 {
         struct semaphore *sem = (struct semaphore *)handle;
 
-        ACPI_FUNCTION_TRACE("os_delete_semaphore");
 
         if (!sem)
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                return AE_BAD_PARAMETER;
 
         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
 
-        acpi_os_free(sem);
+        kfree(sem);
         sem = NULL;
 
-        return_ACPI_STATUS(AE_OK);
+        return AE_OK;
 }
 
 EXPORT_SYMBOL(acpi_os_delete_semaphore);
@@ -784,17 +736,26 @@ acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
         struct semaphore *sem = (struct semaphore *)handle;
         int ret = 0;
 
-        ACPI_FUNCTION_TRACE("os_wait_semaphore");
 
         if (!sem || (units < 1))
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                return AE_BAD_PARAMETER;
 
         if (units > 1)
-                return_ACPI_STATUS(AE_SUPPORT);
+                return AE_SUPPORT;
 
         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
                           handle, units, timeout));
 
+        /*
+         * This can be called during resume with interrupts off.
+         * Like boot-time, we should be single threaded and will
+         * always get the lock if we try -- timeout or not.
+         * If this doesn't succeed, then we will oops courtesy of
+         * might_sleep() in down().
+         */
+        if (!down_trylock(sem))
+                return AE_OK;
+
         switch (timeout) {
                 /*
                  * No Wait:
@@ -839,17 +800,17 @@ acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
         }
 
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Failed to acquire semaphore[%p|%d|%d], %s\n",
+                ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
+                                  "Failed to acquire semaphore[%p|%d|%d], %s",
                                   handle, units, timeout,
                                   acpi_format_exception(status)));
         } else {
                 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
-                                  "Acquired semaphore[%p|%d|%d]\n", handle,
+                                  "Acquired semaphore[%p|%d|%d]", handle,
                                   units, timeout));
         }
 
-        return_ACPI_STATUS(status);
+        return status;
 }
 
 EXPORT_SYMBOL(acpi_os_wait_semaphore);
@@ -861,20 +822,19 @@ acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
 {
         struct semaphore *sem = (struct semaphore *)handle;
 
-        ACPI_FUNCTION_TRACE("os_signal_semaphore");
 
         if (!sem || (units < 1))
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                return AE_BAD_PARAMETER;
 
         if (units > 1)
-                return_ACPI_STATUS(AE_SUPPORT);
+                return AE_SUPPORT;
 
         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
                           units));
 
         up(sem);
 
-        return_ACPI_STATUS(AE_OK);
+        return AE_OK;
 }
 
 EXPORT_SYMBOL(acpi_os_signal_semaphore);
@@ -1043,10 +1003,10 @@ EXPORT_SYMBOL(max_cstate);
  * handle is a pointer to the spinlock_t.
  */
 
-acpi_cpu_flags acpi_os_acquire_lock(acpi_handle handle)
+acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
 {
         acpi_cpu_flags flags;
-        spin_lock_irqsave((spinlock_t *) handle, flags);
+        spin_lock_irqsave(lockp, flags);
         return flags;
 }
 
@@ -1054,9 +1014,9 @@ acpi_cpu_flags acpi_os_acquire_lock(acpi_handle handle)
  * Release a spinlock. See above.
  */
 
-void acpi_os_release_lock(acpi_handle handle, acpi_cpu_flags flags)
+void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
 {
-        spin_unlock_irqrestore((spinlock_t *) handle, flags);
+        spin_unlock_irqrestore(lockp, flags);
 }
 
 #ifndef ACPI_USE_LOCAL_CACHE
@@ -1119,7 +1079,7 @@ acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
 
 acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
 {
-        (void)kmem_cache_destroy(cache);
+        kmem_cache_destroy(cache);
         return (AE_OK);
 }
 
@@ -1143,26 +1103,6 @@ acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
         return (AE_OK);
 }
 
-/*******************************************************************************
- *
- * FUNCTION:    acpi_os_acquire_object
- *
- * PARAMETERS:  Cache           - Handle to cache object
- *              ReturnObject    - Where the object is returned
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Return a zero-filled object.
- *
- ******************************************************************************/
-
-void *acpi_os_acquire_object(acpi_cache_t * cache)
-{
-        void *object = kmem_cache_zalloc(cache, GFP_KERNEL);
-        WARN_ON(!object);
-        return object;
-}
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_os_validate_interface
diff --git a/drivers/acpi/parser/psparse.c b/drivers/acpi/parser/psparse.c
index 7ee2f2e77525..a02aa62fe1e5 100644
--- a/drivers/acpi/parser/psparse.c
+++ b/drivers/acpi/parser/psparse.c
@@ -469,6 +469,16 @@ acpi_status acpi_ps_parse_aml(struct acpi_walk_state *walk_state)
         }
 
         walk_state->thread = thread;
+
+        /*
+         * If executing a method, the starting sync_level is this method's
+         * sync_level
+         */
+        if (walk_state->method_desc) {
+                walk_state->thread->current_sync_level =
+                    walk_state->method_desc->method.sync_level;
+        }
+
         acpi_ds_push_walk_state(walk_state, thread);
 
         /*
@@ -505,6 +515,10 @@ acpi_status acpi_ps_parse_aml(struct acpi_walk_state *walk_state)
                         status =
                             acpi_ds_call_control_method(thread, walk_state,
                                                         NULL);
+                        if (ACPI_FAILURE(status)) {
+                                status =
+                                    acpi_ds_method_error(status, walk_state);
+                        }
 
                         /*
                          * If the transfer to the new method method call worked, a new walk
@@ -525,7 +539,7 @@ acpi_status acpi_ps_parse_aml(struct acpi_walk_state *walk_state)
                         /* Check for possible multi-thread reentrancy problem */
 
                         if ((status == AE_ALREADY_EXISTS) &&
-                            (!walk_state->method_desc->method.semaphore)) {
+                            (!walk_state->method_desc->method.mutex)) {
                                 /*
                                  * Method tried to create an object twice. The probable cause is
                                  * that the method cannot handle reentrancy.
@@ -537,7 +551,7 @@ acpi_status acpi_ps_parse_aml(struct acpi_walk_state *walk_state)
                                  */
                                 walk_state->method_desc->method.method_flags |=
                                     AML_METHOD_SERIALIZED;
-                                walk_state->method_desc->method.concurrency = 1;
+                                walk_state->method_desc->method.sync_level = 0;
                         }
                 }
 
diff --git a/drivers/acpi/parser/psutils.c b/drivers/acpi/parser/psutils.c
index 182474ae8ce9..d405387b7414 100644
--- a/drivers/acpi/parser/psutils.c
+++ b/drivers/acpi/parser/psutils.c
@@ -139,12 +139,10 @@ union acpi_parse_object *acpi_ps_alloc_op(u16 opcode)
                 /* The generic op (default) is by far the most common (16 to 1) */
 
                 op = acpi_os_acquire_object(acpi_gbl_ps_node_cache);
-                memset(op, 0, sizeof(struct acpi_parse_obj_common));
         } else {
                 /* Extended parseop */
 
                 op = acpi_os_acquire_object(acpi_gbl_ps_node_ext_cache);
-                memset(op, 0, sizeof(struct acpi_parse_obj_named));
         }
 
         /* Initialize the Op */
diff --git a/drivers/acpi/pci_bind.c b/drivers/acpi/pci_bind.c
index 2a718df769b5..1e2ae6e7a7e4 100644
--- a/drivers/acpi/pci_bind.c
+++ b/drivers/acpi/pci_bind.c
@@ -47,11 +47,10 @@ struct acpi_pci_data {
 static void acpi_pci_data_handler(acpi_handle handle, u32 function,
                                   void *context)
 {
-        ACPI_FUNCTION_TRACE("acpi_pci_data_handler");
 
         /* TBD: Anything we need to do here? */
 
-        return_VOID;
+        return;
 }
 
 /**
@@ -68,25 +67,24 @@ acpi_status acpi_get_pci_id(acpi_handle handle, struct acpi_pci_id *id)
         struct acpi_device *device = NULL;
         struct acpi_pci_data *data = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_get_pci_id");
 
         if (!id)
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                return AE_BAD_PARAMETER;
 
         result = acpi_bus_get_device(handle, &device);
         if (result) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Invalid ACPI Bus context for device %s\n",
-                                  acpi_device_bid(device)));
-                return_ACPI_STATUS(AE_NOT_EXIST);
+                printk(KERN_ERR PREFIX
+                            "Invalid ACPI Bus context for device %s\n",
+                            acpi_device_bid(device));
+                return AE_NOT_EXIST;
         }
 
         status = acpi_get_data(handle, acpi_pci_data_handler, (void **)&data);
         if (ACPI_FAILURE(status) || !data) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Invalid ACPI-PCI context for device %s\n",
-                                  acpi_device_bid(device)));
-                return_ACPI_STATUS(status);
+                ACPI_EXCEPTION((AE_INFO, status,
+                                "Invalid ACPI-PCI context for device %s",
+                                acpi_device_bid(device)));
+                return status;
         }
 
         *id = data->id;
@@ -103,7 +101,7 @@ acpi_status acpi_get_pci_id(acpi_handle handle, struct acpi_pci_id *id)
                           acpi_device_bid(device), id->segment, id->bus,
                           id->device, id->function));
 
-        return_ACPI_STATUS(AE_OK);
+        return AE_OK;
 }
 
 EXPORT_SYMBOL(acpi_get_pci_id);
@@ -120,14 +118,13 @@ int acpi_pci_bind(struct acpi_device *device)
         struct pci_dev *dev;
         struct pci_bus *bus;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_bind");
 
         if (!device || !device->parent)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         pathname = kmalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
         if (!pathname)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(pathname, 0, ACPI_PATHNAME_MAX);
         buffer.length = ACPI_PATHNAME_MAX;
         buffer.pointer = pathname;
@@ -135,7 +132,7 @@ int acpi_pci_bind(struct acpi_device *device)
         data = kmalloc(sizeof(struct acpi_pci_data), GFP_KERNEL);
         if (!data) {
                 kfree(pathname);
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         }
         memset(data, 0, sizeof(struct acpi_pci_data));
 
@@ -151,9 +148,9 @@ int acpi_pci_bind(struct acpi_device *device)
         status = acpi_get_data(device->parent->handle, acpi_pci_data_handler,
                                (void **)&pdata);
         if (ACPI_FAILURE(status) || !pdata || !pdata->bus) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Invalid ACPI-PCI context for parent device %s\n",
-                                  acpi_device_bid(device->parent)));
+                ACPI_EXCEPTION((AE_INFO, status,
+                                "Invalid ACPI-PCI context for parent device %s",
+                                acpi_device_bid(device->parent)));
                 result = -ENODEV;
                 goto end;
         }
@@ -206,10 +203,10 @@ int acpi_pci_bind(struct acpi_device *device)
                 goto end;
         }
         if (!data->dev->bus) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Device %02x:%02x:%02x.%02x has invalid 'bus' field\n",
-                                  data->id.segment, data->id.bus,
-                                  data->id.device, data->id.function));
+                printk(KERN_ERR PREFIX
+                            "Device %02x:%02x:%02x.%02x has invalid 'bus' field\n",
+                            data->id.segment, data->id.bus,
+                            data->id.device, data->id.function);
                 result = -ENODEV;
                 goto end;
         }
@@ -237,9 +234,9 @@ int acpi_pci_bind(struct acpi_device *device)
          */
         status = acpi_attach_data(device->handle, acpi_pci_data_handler, data);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to attach ACPI-PCI context to device %s\n",
-                                  acpi_device_bid(device)));
+                ACPI_EXCEPTION((AE_INFO, status,
+                                "Unable to attach ACPI-PCI context to device %s",
+                                acpi_device_bid(device)));
                 result = -ENODEV;
                 goto end;
         }
@@ -269,7 +266,7 @@ int acpi_pci_bind(struct acpi_device *device)
         if (result)
                 kfree(data);
 
-        return_VALUE(result);
+        return result;
 }
 
 int acpi_pci_unbind(struct acpi_device *device)
@@ -280,14 +277,13 @@ int acpi_pci_unbind(struct acpi_device *device)
         char *pathname = NULL;
         struct acpi_buffer buffer = { 0, NULL };
 
-        ACPI_FUNCTION_TRACE("acpi_pci_unbind");
 
         if (!device || !device->parent)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         pathname = (char *)kmalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
         if (!pathname)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(pathname, 0, ACPI_PATHNAME_MAX);
 
         buffer.length = ACPI_PATHNAME_MAX;
@@ -301,18 +297,18 @@ int acpi_pci_unbind(struct acpi_device *device)
             acpi_get_data(device->handle, acpi_pci_data_handler,
                           (void **)&data);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to get data from device %s\n",
-                                  acpi_device_bid(device)));
+                ACPI_EXCEPTION((AE_INFO, status,
+                                "Unable to get data from device %s",
+                                acpi_device_bid(device)));
                 result = -ENODEV;
                 goto end;
         }
 
         status = acpi_detach_data(device->handle, acpi_pci_data_handler);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to detach data from device %s\n",
-                                  acpi_device_bid(device)));
+                ACPI_EXCEPTION((AE_INFO, status,
+                                "Unable to detach data from device %s",
+                                acpi_device_bid(device)));
                 result = -ENODEV;
                 goto end;
         }
@@ -322,7 +318,7 @@ int acpi_pci_unbind(struct acpi_device *device)
         kfree(data);
 
       end:
-        return_VALUE(result);
+        return result;
 }
 
 int
@@ -335,11 +331,10 @@ acpi_pci_bind_root(struct acpi_device *device,
         char *pathname = NULL;
         struct acpi_buffer buffer = { 0, NULL };
 
-        ACPI_FUNCTION_TRACE("acpi_pci_bind_root");
 
         pathname = (char *)kmalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
         if (!pathname)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(pathname, 0, ACPI_PATHNAME_MAX);
 
         buffer.length = ACPI_PATHNAME_MAX;
@@ -347,13 +342,13 @@ acpi_pci_bind_root(struct acpi_device *device,
 
         if (!device || !id || !bus) {
                 kfree(pathname);
-                return_VALUE(-EINVAL);
+                return -EINVAL;
         }
 
         data = kmalloc(sizeof(struct acpi_pci_data), GFP_KERNEL);
         if (!data) {
                 kfree(pathname);
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         }
         memset(data, 0, sizeof(struct acpi_pci_data));
 
@@ -369,9 +364,9 @@ acpi_pci_bind_root(struct acpi_device *device,
 
         status = acpi_attach_data(device->handle, acpi_pci_data_handler, data);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to attach ACPI-PCI context to device %s\n",
-                                  pathname));
+                ACPI_EXCEPTION((AE_INFO, status,
+                                "Unable to attach ACPI-PCI context to device %s",
+                                pathname));
                 result = -ENODEV;
                 goto end;
         }
@@ -381,5 +376,5 @@ acpi_pci_bind_root(struct acpi_device *device,
         if (result != 0)
                 kfree(data);
 
-        return_VALUE(result);
+        return result;
 }
diff --git a/drivers/acpi/pci_irq.c b/drivers/acpi/pci_irq.c
index 65aee79b3971..feda0341f5a7 100644
--- a/drivers/acpi/pci_irq.c
+++ b/drivers/acpi/pci_irq.c
@@ -24,7 +24,6 @@
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
 
-#include <linux/config.h>
 
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -55,10 +54,9 @@ static struct acpi_prt_entry *acpi_pci_irq_find_prt_entry(int segment,
         struct list_head *node = NULL;
         struct acpi_prt_entry *entry = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_irq_find_prt_entry");
 
         if (!acpi_prt.count)
-                return_PTR(NULL);
+                return NULL;
 
         /*
          * Parse through all PRT entries looking for a match on the specified
@@ -73,12 +71,12 @@ static struct acpi_prt_entry *acpi_pci_irq_find_prt_entry(int segment,
                     && (device == entry->id.device)
                     && (pin == entry->pin)) {
                         spin_unlock(&acpi_prt_lock);
-                        return_PTR(entry);
+                        return entry;
                 }
         }
 
         spin_unlock(&acpi_prt_lock);
-        return_PTR(NULL);
+        return NULL;
 }
 
 static int
@@ -87,14 +85,13 @@ acpi_pci_irq_add_entry(acpi_handle handle,
 {
         struct acpi_prt_entry *entry = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_irq_add_entry");
 
         if (!prt)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         entry = kmalloc(sizeof(struct acpi_prt_entry), GFP_KERNEL);
         if (!entry)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(entry, 0, sizeof(struct acpi_prt_entry));
 
         entry->id.segment = segment;
@@ -141,7 +138,7 @@ acpi_pci_irq_add_entry(acpi_handle handle,
         acpi_prt.count++;
         spin_unlock(&acpi_prt_lock);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static void
@@ -163,11 +160,10 @@ int acpi_pci_irq_add_prt(acpi_handle handle, int segment, int bus)
         struct acpi_pci_routing_table *entry = NULL;
         static int first_time = 1;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_irq_add_prt");
 
         pathname = (char *)kmalloc(ACPI_PATHNAME_MAX, GFP_KERNEL);
         if (!pathname)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(pathname, 0, ACPI_PATHNAME_MAX);
 
         if (first_time) {
@@ -197,24 +193,24 @@ int acpi_pci_irq_add_prt(acpi_handle handle, int segment, int bus)
         kfree(pathname);
         status = acpi_get_irq_routing_table(handle, &buffer);
         if (status != AE_BUFFER_OVERFLOW) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PRT [%s]\n",
-                                  acpi_format_exception(status)));
-                return_VALUE(-ENODEV);
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRT [%s]",
+                                acpi_format_exception(status)));
+                return -ENODEV;
         }
 
         prt = kmalloc(buffer.length, GFP_KERNEL);
         if (!prt) {
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         }
         memset(prt, 0, buffer.length);
         buffer.pointer = prt;
 
         status = acpi_get_irq_routing_table(handle, &buffer);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PRT [%s]\n",
-                                  acpi_format_exception(status)));
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRT [%s]",
+                                acpi_format_exception(status)));
                 kfree(buffer.pointer);
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
         entry = prt;
@@ -227,7 +223,7 @@ int acpi_pci_irq_add_prt(acpi_handle handle, int segment, int bus)
 
         kfree(prt);
 
-        return_VALUE(0);
+        return 0;
 }
 
 void acpi_pci_irq_del_prt(int segment, int bus)
@@ -262,16 +258,15 @@ acpi_pci_allocate_irq(struct acpi_prt_entry *entry,
 {
         int irq;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_allocate_irq");
 
         if (entry->link.handle) {
                 irq = acpi_pci_link_allocate_irq(entry->link.handle,
                                                  entry->link.index, triggering,
                                                  polarity, link);
                 if (irq < 0) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                          "Invalid IRQ link routing entry\n"));
-                        return_VALUE(-1);
+                        printk(KERN_WARNING PREFIX
+                                      "Invalid IRQ link routing entry\n");
+                        return -1;
                 }
         } else {
                 irq = entry->link.index;
@@ -280,7 +275,7 @@ acpi_pci_allocate_irq(struct acpi_prt_entry *entry,
         }
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found IRQ %d\n", irq));
-        return_VALUE(irq);
+        return irq;
 }
 
 static int
@@ -289,13 +284,12 @@ acpi_pci_free_irq(struct acpi_prt_entry *entry,
 {
         int irq;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_free_irq");
         if (entry->link.handle) {
                 irq = acpi_pci_link_free_irq(entry->link.handle);
         } else {
                 irq = entry->link.index;
         }
-        return_VALUE(irq);
+        return irq;
 }
 
 /*
@@ -315,7 +309,6 @@ acpi_pci_irq_lookup(struct pci_bus *bus,
         int bus_nr = bus->number;
         int ret;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_irq_lookup");
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                           "Searching for PRT entry for %02x:%02x:%02x[%c]\n",
@@ -324,11 +317,11 @@ acpi_pci_irq_lookup(struct pci_bus *bus,
         entry = acpi_pci_irq_find_prt_entry(segment, bus_nr, device, pin);
         if (!entry) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "PRT entry not found\n"));
-                return_VALUE(-1);
+                return -1;
         }
 
         ret = func(entry, triggering, polarity, link);
-        return_VALUE(ret);
+        return ret;
 }
 
 /*
@@ -346,10 +339,9 @@ acpi_pci_irq_derive(struct pci_dev *dev,
         int irq = -1;
         u8 bridge_pin = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_irq_derive");
 
         if (!dev)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /* 
          * Attempt to derive an IRQ for this device from a parent bridge's
@@ -366,7 +358,7 @@ acpi_pci_irq_derive(struct pci_dev *dev,
                                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                                   "No interrupt pin configured for device %s\n",
                                                   pci_name(bridge)));
-                                return_VALUE(-1);
+                                return -1;
                         }
                         /* Pin is from 0 to 3 */
                         bridge_pin--;
@@ -379,16 +371,15 @@ acpi_pci_irq_derive(struct pci_dev *dev,
         }
 
         if (irq < 0) {
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                  "Unable to derive IRQ for device %s\n",
-                                  pci_name(dev)));
-                return_VALUE(-1);
+                printk(KERN_WARNING PREFIX "Unable to derive IRQ for device %s\n",
+                              pci_name(dev));
+                return -1;
         }
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Derive IRQ %d for device %s from %s\n",
                           irq, pci_name(dev), pci_name(bridge)));
 
-        return_VALUE(irq);
+        return irq;
 }
 
 /*
@@ -406,24 +397,22 @@ int acpi_pci_irq_enable(struct pci_dev *dev)
         char *link = NULL;
         int rc;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_irq_enable");
 
         if (!dev)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         pin = dev->pin;
         if (!pin) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                   "No interrupt pin configured for device %s\n",
                                   pci_name(dev)));
-                return_VALUE(0);
+                return 0;
         }
         pin--;
 
         if (!dev->bus) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Invalid (NULL) 'bus' field\n"));
-                return_VALUE(-ENODEV);
+                printk(KERN_ERR PREFIX "Invalid (NULL) 'bus' field\n");
+                return -ENODEV;
         }
 
         /* 
@@ -455,10 +444,10 @@ int acpi_pci_irq_enable(struct pci_dev *dev)
                         printk(" - using IRQ %d\n", dev->irq);
                         acpi_register_gsi(dev->irq, ACPI_LEVEL_SENSITIVE,
                                           ACPI_ACTIVE_LOW);
-                        return_VALUE(0);
+                        return 0;
                 } else {
                         printk("\n");
-                        return_VALUE(0);
+                        return 0;
                 }
         }
 
@@ -466,7 +455,7 @@ int acpi_pci_irq_enable(struct pci_dev *dev)
         if (rc < 0) {
                 printk(KERN_WARNING PREFIX "PCI Interrupt %s[%c]: failed "
                        "to register GSI\n", pci_name(dev), ('A' + pin));
-                return_VALUE(rc);
+                return rc;
         }
         dev->irq = rc;
 
@@ -480,7 +469,7 @@ int acpi_pci_irq_enable(struct pci_dev *dev)
                (triggering == ACPI_LEVEL_SENSITIVE) ? "level" : "edge",
                (polarity == ACPI_ACTIVE_LOW) ? "low" : "high", dev->irq);
 
-        return_VALUE(0);
+        return 0;
 }
 
 EXPORT_SYMBOL(acpi_pci_irq_enable);
@@ -497,14 +486,13 @@ void acpi_pci_irq_disable(struct pci_dev *dev)
         int triggering = ACPI_LEVEL_SENSITIVE;
         int polarity = ACPI_ACTIVE_LOW;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_irq_disable");
 
         if (!dev || !dev->bus)
-                return_VOID;
+                return;
 
         pin = dev->pin;
         if (!pin)
-                return_VOID;
+                return;
         pin--;
 
         /*
@@ -522,7 +510,7 @@ void acpi_pci_irq_disable(struct pci_dev *dev)
                                           &triggering, &polarity, NULL,
                                           acpi_pci_free_irq);
         if (gsi < 0)
-                return_VOID;
+                return;
 
         /*
          * TBD: It might be worth clearing dev->irq by magic constant
@@ -534,5 +522,5 @@ void acpi_pci_irq_disable(struct pci_dev *dev)
 
         acpi_unregister_gsi(gsi);
 
-        return_VOID;
+        return;
 }
diff --git a/drivers/acpi/pci_link.c b/drivers/acpi/pci_link.c
index 228bdb626502..7f3e7e77e794 100644
--- a/drivers/acpi/pci_link.c
+++ b/drivers/acpi/pci_link.c
@@ -83,7 +83,6 @@ struct acpi_pci_link_irq {
 struct acpi_pci_link {
         struct list_head node;
         struct acpi_device *device;
-        acpi_handle handle;
         struct acpi_pci_link_irq irq;
         int refcnt;
 };
@@ -107,26 +106,23 @@ acpi_pci_link_check_possible(struct acpi_resource *resource, void *context)
         struct acpi_pci_link *link = (struct acpi_pci_link *)context;
         u32 i = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_link_check_possible");
 
         switch (resource->type) {
         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
-                return_ACPI_STATUS(AE_OK);
+                return AE_OK;
         case ACPI_RESOURCE_TYPE_IRQ:
                 {
                         struct acpi_resource_irq *p = &resource->data.irq;
                         if (!p || !p->interrupt_count) {
-                                ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                                  "Blank IRQ resource\n"));
-                                return_ACPI_STATUS(AE_OK);
+                                printk(KERN_WARNING PREFIX "Blank IRQ resource\n");
+                                return AE_OK;
                         }
                         for (i = 0;
                              (i < p->interrupt_count
                               && i < ACPI_PCI_LINK_MAX_POSSIBLE); i++) {
                                 if (!p->interrupts[i]) {
-                                        ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                                          "Invalid IRQ %d\n",
-                                                          p->interrupts[i]));
+                                        printk(KERN_WARNING PREFIX "Invalid IRQ %d\n",
+                                                      p->interrupts[i]);
                                         continue;
                                 }
                                 link->irq.possible[i] = p->interrupts[i];
@@ -142,17 +138,16 @@ acpi_pci_link_check_possible(struct acpi_resource *resource, void *context)
                         struct acpi_resource_extended_irq *p =
                             &resource->data.extended_irq;
                         if (!p || !p->interrupt_count) {
-                                ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                                  "Blank EXT IRQ resource\n"));
-                                return_ACPI_STATUS(AE_OK);
+                                printk(KERN_WARNING PREFIX
+                                              "Blank EXT IRQ resource\n");
+                                return AE_OK;
                         }
                         for (i = 0;
                              (i < p->interrupt_count
                               && i < ACPI_PCI_LINK_MAX_POSSIBLE); i++) {
                                 if (!p->interrupts[i]) {
-                                        ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                                          "Invalid IRQ %d\n",
-                                                          p->interrupts[i]));
+                                        printk(KERN_WARNING PREFIX "Invalid IRQ %d\n",
+                                                      p->interrupts[i]);
                                         continue;
                                 }
                                 link->irq.possible[i] = p->interrupts[i];
@@ -164,35 +159,33 @@ acpi_pci_link_check_possible(struct acpi_resource *resource, void *context)
                         break;
                 }
         default:
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Resource is not an IRQ entry\n"));
-                return_ACPI_STATUS(AE_OK);
+                printk(KERN_ERR PREFIX "Resource is not an IRQ entry\n");
+                return AE_OK;
         }
 
-        return_ACPI_STATUS(AE_CTRL_TERMINATE);
+        return AE_CTRL_TERMINATE;
 }
 
 static int acpi_pci_link_get_possible(struct acpi_pci_link *link)
 {
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_link_get_possible");
 
         if (!link)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
-        status = acpi_walk_resources(link->handle, METHOD_NAME__PRS,
+        status = acpi_walk_resources(link->device->handle, METHOD_NAME__PRS,
                                      acpi_pci_link_check_possible, link);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PRS\n"));
-                return_VALUE(-ENODEV);
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRS"));
+                return -ENODEV;
         }
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                           "Found %d possible IRQs\n",
                           link->irq.possible_count));
 
-        return_VALUE(0);
+        return 0;
 }
 
 static acpi_status
@@ -200,7 +193,6 @@ acpi_pci_link_check_current(struct acpi_resource *resource, void *context)
 {
         int *irq = (int *)context;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_link_check_current");
 
         switch (resource->type) {
         case ACPI_RESOURCE_TYPE_IRQ:
@@ -213,7 +205,7 @@ acpi_pci_link_check_current(struct acpi_resource *resource, void *context)
                                  */
                                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                                   "Blank IRQ resource\n"));
-                                return_ACPI_STATUS(AE_OK);
+                                return AE_OK;
                         }
                         *irq = p->interrupts[0];
                         break;
@@ -227,20 +219,20 @@ acpi_pci_link_check_current(struct acpi_resource *resource, void *context)
                                  * extended IRQ descriptors must
                                  * return at least 1 IRQ
                                  */
-                                ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                                  "Blank EXT IRQ resource\n"));
-                                return_ACPI_STATUS(AE_OK);
+                                printk(KERN_WARNING PREFIX
+                                              "Blank EXT IRQ resource\n");
+                                return AE_OK;
                         }
                         *irq = p->interrupts[0];
                         break;
                 }
                 break;
         default:
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Resource %d isn't an IRQ\n", resource->type));
+                printk(KERN_ERR PREFIX "Resource %d isn't an IRQ\n", resource->type);
         case ACPI_RESOURCE_TYPE_END_TAG:
-                return_ACPI_STATUS(AE_OK);
+                return AE_OK;
         }
-        return_ACPI_STATUS(AE_CTRL_TERMINATE);
+        return AE_CTRL_TERMINATE;
 }
 
 /*
@@ -256,10 +248,8 @@ static int acpi_pci_link_get_current(struct acpi_pci_link *link)
         acpi_status status = AE_OK;
         int irq = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_link_get_current");
-
-        if (!link || !link->handle)
-                return_VALUE(-EINVAL);
+        if (!link)
+                return -EINVAL;
 
         link->irq.active = 0;
 
@@ -268,14 +258,13 @@ static int acpi_pci_link_get_current(struct acpi_pci_link *link)
                 /* Query _STA, set link->device->status */
                 result = acpi_bus_get_status(link->device);
                 if (result) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Unable to read status\n"));
+                        printk(KERN_ERR PREFIX "Unable to read status\n");
                         goto end;
                 }
 
                 if (!link->device->status.enabled) {
                         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Link disabled\n"));
-                        return_VALUE(0);
+                        return 0;
                 }
         }
 
@@ -283,16 +272,16 @@ static int acpi_pci_link_get_current(struct acpi_pci_link *link)
          * Query and parse _CRS to get the current IRQ assignment. 
          */
 
-        status = acpi_walk_resources(link->handle, METHOD_NAME__CRS,
+        status = acpi_walk_resources(link->device->handle, METHOD_NAME__CRS,
                                      acpi_pci_link_check_current, &irq);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _CRS\n"));
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _CRS"));
                 result = -ENODEV;
                 goto end;
         }
 
         if (acpi_strict && !irq) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "_CRS returned 0\n"));
+                printk(KERN_ERR PREFIX "_CRS returned 0\n");
                 result = -ENODEV;
         }
 
@@ -301,7 +290,7 @@ static int acpi_pci_link_get_current(struct acpi_pci_link *link)
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Link at IRQ %d \n", link->irq.active));
 
       end:
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_pci_link_set(struct acpi_pci_link *link, int irq)
@@ -314,14 +303,13 @@ static int acpi_pci_link_set(struct acpi_pci_link *link, int irq)
         } *resource;
         struct acpi_buffer buffer = { 0, NULL };
 
-        ACPI_FUNCTION_TRACE("acpi_pci_link_set");
 
         if (!link || !irq)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         resource = kmalloc(sizeof(*resource) + 1, GFP_ATOMIC);
         if (!resource)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
 
         memset(resource, 0, sizeof(*resource) + 1);
         buffer.length = sizeof(*resource) + 1;
@@ -362,7 +350,7 @@ static int acpi_pci_link_set(struct acpi_pci_link *link, int irq)
                 /* ignore resource_source, it's optional */
                 break;
         default:
-                printk("ACPI BUG: resource_type %d\n", link->irq.resource_type);
+                printk(KERN_ERR PREFIX "Invalid Resource_type %d\n", link->irq.resource_type);
                 result = -EINVAL;
                 goto end;
 
@@ -370,11 +358,11 @@ static int acpi_pci_link_set(struct acpi_pci_link *link, int irq)
         resource->end.type = ACPI_RESOURCE_TYPE_END_TAG;
 
         /* Attempt to set the resource */
-        status = acpi_set_current_resources(link->handle, &buffer);
+        status = acpi_set_current_resources(link->device->handle, &buffer);
 
         /* check for total failure */
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _SRS\n"));
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _SRS"));
                 result = -ENODEV;
                 goto end;
         }
@@ -382,14 +370,14 @@ static int acpi_pci_link_set(struct acpi_pci_link *link, int irq)
         /* Query _STA, set device->status */
         result = acpi_bus_get_status(link->device);
         if (result) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unable to read status\n"));
+                printk(KERN_ERR PREFIX "Unable to read status\n");
                 goto end;
         }
         if (!link->device->status.enabled) {
                 printk(KERN_WARNING PREFIX
-                       "%s [%s] disabled and referenced, BIOS bug.\n",
-                       acpi_device_name(link->device),
-                       acpi_device_bid(link->device));
+                              "%s [%s] disabled and referenced, BIOS bug\n",
+                              acpi_device_name(link->device),
+                              acpi_device_bid(link->device));
         }
 
         /* Query _CRS, set link->irq.active */
@@ -408,9 +396,9 @@ static int acpi_pci_link_set(struct acpi_pci_link *link, int irq)
                  * assume _SRS worked and override _CRS value.
                  */
                 printk(KERN_WARNING PREFIX
-                       "%s [%s] BIOS reported IRQ %d, using IRQ %d\n",
-                       acpi_device_name(link->device),
-                       acpi_device_bid(link->device), link->irq.active, irq);
+                              "%s [%s] BIOS reported IRQ %d, using IRQ %d\n",
+                              acpi_device_name(link->device),
+                              acpi_device_bid(link->device), link->irq.active, irq);
                 link->irq.active = irq;
         }
 
@@ -418,7 +406,7 @@ static int acpi_pci_link_set(struct acpi_pci_link *link, int irq)
 
       end:
         kfree(resource);
-        return_VALUE(result);
+        return result;
 }
 
 /* --------------------------------------------------------------------------
@@ -492,7 +480,6 @@ int __init acpi_irq_penalty_init(void)
         struct acpi_pci_link *link = NULL;
         int i = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_irq_penalty_init");
 
         /*
          * Update penalties to facilitate IRQ balancing.
@@ -501,8 +488,7 @@ int __init acpi_irq_penalty_init(void)
 
                 link = list_entry(node, struct acpi_pci_link, node);
                 if (!link) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Invalid link context\n"));
+                        printk(KERN_ERR PREFIX "Invalid link context\n");
                         continue;
                 }
 
@@ -530,7 +516,7 @@ int __init acpi_irq_penalty_init(void)
         /* Add a penalty for the SCI */
         acpi_irq_penalty[acpi_fadt.sci_int] += PIRQ_PENALTY_PCI_USING;
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_irq_balance;    /* 0: static, 1: balance */
@@ -540,13 +526,12 @@ static int acpi_pci_link_allocate(struct acpi_pci_link *link)
         int irq;
         int i;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_link_allocate");
 
         if (link->irq.initialized) {
                 if (link->refcnt == 0)
                         /* This means the link is disabled but initialized */
                         acpi_pci_link_set(link, link->irq.active);
-                return_VALUE(0);
+                return 0;
         }
 
         /*
@@ -562,7 +547,7 @@ static int acpi_pci_link_allocate(struct acpi_pci_link *link)
         if (i == link->irq.possible_count) {
                 if (acpi_strict)
                         printk(KERN_WARNING PREFIX "_CRS %d not found"
-                               " in _PRS\n", link->irq.active);
+                                      " in _PRS\n", link->irq.active);
                 link->irq.active = 0;
         }
 
@@ -589,12 +574,11 @@ static int acpi_pci_link_allocate(struct acpi_pci_link *link)
 
         /* Attempt to enable the link device at this IRQ. */
         if (acpi_pci_link_set(link, irq)) {
-                printk(PREFIX
-                       "Unable to set IRQ for %s [%s] (likely buggy ACPI BIOS).\n"
-                       "Try pci=noacpi or acpi=off\n",
-                       acpi_device_name(link->device),
-                       acpi_device_bid(link->device));
-                return_VALUE(-ENODEV);
+                printk(KERN_ERR PREFIX "Unable to set IRQ for %s [%s]. "
+                            "Try pci=noacpi or acpi=off\n",
+                            acpi_device_name(link->device),
+                            acpi_device_bid(link->device));
+                return -ENODEV;
         } else {
                 acpi_irq_penalty[link->irq.active] += PIRQ_PENALTY_PCI_USING;
                 printk(PREFIX "%s [%s] enabled at IRQ %d\n",
@@ -604,7 +588,7 @@ static int acpi_pci_link_allocate(struct acpi_pci_link *link)
 
         link->irq.initialized = 1;
 
-        return_VALUE(0);
+        return 0;
 }
 
 /*
@@ -622,36 +606,35 @@ acpi_pci_link_allocate_irq(acpi_handle handle,
         struct acpi_device *device = NULL;
         struct acpi_pci_link *link = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_link_allocate_irq");
 
         result = acpi_bus_get_device(handle, &device);
         if (result) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link device\n"));
-                return_VALUE(-1);
+                printk(KERN_ERR PREFIX "Invalid link device\n");
+                return -1;
         }
 
         link = (struct acpi_pci_link *)acpi_driver_data(device);
         if (!link) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link context\n"));
-                return_VALUE(-1);
+                printk(KERN_ERR PREFIX "Invalid link context\n");
+                return -1;
         }
 
         /* TBD: Support multiple index (IRQ) entries per Link Device */
         if (index) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid index %d\n", index));
-                return_VALUE(-1);
+                printk(KERN_ERR PREFIX "Invalid index %d\n", index);
+                return -1;
         }
 
         mutex_lock(&acpi_link_lock);
         if (acpi_pci_link_allocate(link)) {
                 mutex_unlock(&acpi_link_lock);
-                return_VALUE(-1);
+                return -1;
         }
 
         if (!link->irq.active) {
                 mutex_unlock(&acpi_link_lock);
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Link active IRQ is 0!\n"));
-                return_VALUE(-1);
+                printk(KERN_ERR PREFIX "Link active IRQ is 0!\n");
+                return -1;
         }
         link->refcnt++;
         mutex_unlock(&acpi_link_lock);
@@ -665,7 +648,7 @@ acpi_pci_link_allocate_irq(acpi_handle handle,
         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                           "Link %s is referenced\n",
                           acpi_device_bid(link->device)));
-        return_VALUE(link->irq.active);
+        return (link->irq.active);
 }
 
 /*
@@ -678,25 +661,24 @@ int acpi_pci_link_free_irq(acpi_handle handle)
         struct acpi_pci_link *link = NULL;
         acpi_status result;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_link_free_irq");
 
         result = acpi_bus_get_device(handle, &device);
         if (result) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link device\n"));
-                return_VALUE(-1);
+                printk(KERN_ERR PREFIX "Invalid link device\n");
+                return -1;
         }
 
         link = (struct acpi_pci_link *)acpi_driver_data(device);
         if (!link) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid link context\n"));
-                return_VALUE(-1);
+                printk(KERN_ERR PREFIX "Invalid link context\n");
+                return -1;
         }
 
         mutex_lock(&acpi_link_lock);
         if (!link->irq.initialized) {
                 mutex_unlock(&acpi_link_lock);
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Link isn't initialized\n"));
-                return_VALUE(-1);
+                printk(KERN_ERR PREFIX "Link isn't initialized\n");
+                return -1;
         }
 #ifdef  FUTURE_USE
         /*
@@ -715,10 +697,10 @@ int acpi_pci_link_free_irq(acpi_handle handle)
                           acpi_device_bid(link->device)));
 
         if (link->refcnt == 0) {
-                acpi_ut_evaluate_object(link->handle, "_DIS", 0, NULL);
+                acpi_ut_evaluate_object(link->device->handle, "_DIS", 0, NULL);
         }
         mutex_unlock(&acpi_link_lock);
-        return_VALUE(link->irq.active);
+        return (link->irq.active);
 }
 
 /* --------------------------------------------------------------------------
@@ -732,18 +714,16 @@ static int acpi_pci_link_add(struct acpi_device *device)
         int i = 0;
         int found = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_link_add");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         link = kmalloc(sizeof(struct acpi_pci_link), GFP_KERNEL);
         if (!link)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(link, 0, sizeof(struct acpi_pci_link));
 
         link->device = device;
-        link->handle = device->handle;
         strcpy(acpi_device_name(device), ACPI_PCI_LINK_DEVICE_NAME);
         strcpy(acpi_device_class(device), ACPI_PCI_LINK_CLASS);
         acpi_driver_data(device) = link;
@@ -782,62 +762,51 @@ static int acpi_pci_link_add(struct acpi_device *device)
 
       end:
         /* disable all links -- to be activated on use */
-        acpi_ut_evaluate_object(link->handle, "_DIS", 0, NULL);
+        acpi_ut_evaluate_object(device->handle, "_DIS", 0, NULL);
         mutex_unlock(&acpi_link_lock);
 
         if (result)
                 kfree(link);
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_pci_link_resume(struct acpi_pci_link *link)
 {
-        ACPI_FUNCTION_TRACE("acpi_pci_link_resume");
 
         if (link->refcnt && link->irq.active && link->irq.initialized)
-                return_VALUE(acpi_pci_link_set(link, link->irq.active));
+                return (acpi_pci_link_set(link, link->irq.active));
         else
-                return_VALUE(0);
+                return 0;
 }
 
-/*
- * FIXME: this is a workaround to avoid nasty warning.  It will be removed
- * after every device calls pci_disable_device in .resume.
- */
-int acpi_in_resume;
 static int irqrouter_resume(struct sys_device *dev)
 {
         struct list_head *node = NULL;
         struct acpi_pci_link *link = NULL;
 
-        ACPI_FUNCTION_TRACE("irqrouter_resume");
 
         /* Make sure SCI is enabled again (Apple firmware bug?) */
         acpi_set_register(ACPI_BITREG_SCI_ENABLE, 1, ACPI_MTX_DO_NOT_LOCK);
 
-        acpi_in_resume = 1;
         list_for_each(node, &acpi_link.entries) {
                 link = list_entry(node, struct acpi_pci_link, node);
                 if (!link) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Invalid link context\n"));
+                        printk(KERN_ERR PREFIX "Invalid link context\n");
                         continue;
                 }
                 acpi_pci_link_resume(link);
         }
-        acpi_in_resume = 0;
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_pci_link_remove(struct acpi_device *device, int type)
 {
         struct acpi_pci_link *link = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_link_remove");
 
         if (!device || !acpi_driver_data(device))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         link = (struct acpi_pci_link *)acpi_driver_data(device);
 
@@ -847,7 +816,7 @@ static int acpi_pci_link_remove(struct acpi_device *device, int type)
 
         kfree(link);
 
-        return_VALUE(0);
+        return 0;
 }
 
 /*
@@ -953,34 +922,32 @@ static int __init irqrouter_init_sysfs(void)
 {
         int error;
 
-        ACPI_FUNCTION_TRACE("irqrouter_init_sysfs");
 
         if (acpi_disabled || acpi_noirq)
-                return_VALUE(0);
+                return 0;
 
         error = sysdev_class_register(&irqrouter_sysdev_class);
         if (!error)
                 error = sysdev_register(&device_irqrouter);
 
-        return_VALUE(error);
+        return error;
 }
 
 device_initcall(irqrouter_init_sysfs);
 
 static int __init acpi_pci_link_init(void)
 {
-        ACPI_FUNCTION_TRACE("acpi_pci_link_init");
 
         if (acpi_noirq)
-                return_VALUE(0);
+                return 0;
 
         acpi_link.count = 0;
         INIT_LIST_HEAD(&acpi_link.entries);
 
         if (acpi_bus_register_driver(&acpi_pci_link_driver) < 0)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
-        return_VALUE(0);
+        return 0;
 }
 
 subsys_initcall(acpi_pci_link_init);
diff --git a/drivers/acpi/pci_root.c b/drivers/acpi/pci_root.c
index 4c313eab6313..0984a1ee24ed 100644
--- a/drivers/acpi/pci_root.c
+++ b/drivers/acpi/pci_root.c
@@ -58,7 +58,7 @@ static struct acpi_driver acpi_pci_root_driver = {
 
 struct acpi_pci_root {
         struct list_head node;
-        acpi_handle handle;
+        struct acpi_device * device;
         struct acpi_pci_id id;
         struct pci_bus *bus;
 };
@@ -83,7 +83,7 @@ int acpi_pci_register_driver(struct acpi_pci_driver *driver)
         list_for_each(entry, &acpi_pci_roots) {
                 struct acpi_pci_root *root;
                 root = list_entry(entry, struct acpi_pci_root, node);
-                driver->add(root->handle);
+                driver->add(root->device->handle);
                 n++;
         }
 
@@ -110,7 +110,7 @@ void acpi_pci_unregister_driver(struct acpi_pci_driver *driver)
         list_for_each(entry, &acpi_pci_roots) {
                 struct acpi_pci_root *root;
                 root = list_entry(entry, struct acpi_pci_root, node);
-                driver->remove(root->handle);
+                driver->remove(root->device->handle);
         }
 }
 
@@ -160,18 +160,17 @@ static int acpi_pci_root_add(struct acpi_device *device)
         unsigned long value = 0;
         acpi_handle handle = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_root_add");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         root = kmalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
         if (!root)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(root, 0, sizeof(struct acpi_pci_root));
         INIT_LIST_HEAD(&root->node);
 
-        root->handle = device->handle;
+        root->device = device;
         strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME);
         strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);
         acpi_driver_data(device) = root;
@@ -186,7 +185,7 @@ static int acpi_pci_root_add(struct acpi_device *device)
          * -------
          * Obtained via _SEG, if exists, otherwise assumed to be zero (0).
          */
-        status = acpi_evaluate_integer(root->handle, METHOD_NAME__SEG, NULL,
+        status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL,
                                        &value);
         switch (status) {
         case AE_OK:
@@ -198,7 +197,7 @@ static int acpi_pci_root_add(struct acpi_device *device)
                 root->id.segment = 0;
                 break;
         default:
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _SEG\n"));
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _SEG"));
                 result = -ENODEV;
                 goto end;
         }
@@ -208,7 +207,7 @@ static int acpi_pci_root_add(struct acpi_device *device)
          * ---
          * Obtained via _BBN, if exists, otherwise assumed to be zero (0).
          */
-        status = acpi_evaluate_integer(root->handle, METHOD_NAME__BBN, NULL,
+        status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN, NULL,
                                        &value);
         switch (status) {
         case AE_OK:
@@ -219,7 +218,7 @@ static int acpi_pci_root_add(struct acpi_device *device)
                 root->id.bus = 0;
                 break;
         default:
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _BBN\n"));
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BBN"));
                 result = -ENODEV;
                 goto end;
         }
@@ -231,10 +230,11 @@ static int acpi_pci_root_add(struct acpi_device *device)
                         int bus = 0;
                         acpi_status status;
 
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Wrong _BBN value, please reboot and using option 'pci=noacpi'\n"));
+                        printk(KERN_ERR PREFIX
+                                    "Wrong _BBN value, reboot"
+                                    " and use option 'pci=noacpi'\n");
 
-                        status = try_get_root_bridge_busnr(root->handle, &bus);
+                        status = try_get_root_bridge_busnr(device->handle, &bus);
                         if (ACPI_FAILURE(status))
                                 break;
                         if (bus != root->id.bus) {
@@ -273,9 +273,9 @@ static int acpi_pci_root_add(struct acpi_device *device)
          */
         root->bus = pci_acpi_scan_root(device, root->id.segment, root->id.bus);
         if (!root->bus) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Bus %04x:%02x not present in PCI namespace\n",
-                                  root->id.segment, root->id.bus));
+                printk(KERN_ERR PREFIX
+                            "Bus %04x:%02x not present in PCI namespace\n",
+                            root->id.segment, root->id.bus);
                 result = -ENODEV;
                 goto end;
         }
@@ -294,9 +294,9 @@ static int acpi_pci_root_add(struct acpi_device *device)
          * -----------------
          * Evaluate and parse _PRT, if exists.
          */
-        status = acpi_get_handle(root->handle, METHOD_NAME__PRT, &handle);
+        status = acpi_get_handle(device->handle, METHOD_NAME__PRT, &handle);
         if (ACPI_SUCCESS(status))
-                result = acpi_pci_irq_add_prt(root->handle, root->id.segment,
+                result = acpi_pci_irq_add_prt(device->handle, root->id.segment,
                                               root->id.bus);
 
       end:
@@ -306,46 +306,43 @@ static int acpi_pci_root_add(struct acpi_device *device)
                 kfree(root);
         }
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_pci_root_start(struct acpi_device *device)
 {
         struct acpi_pci_root *root;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_root_start");
 
         list_for_each_entry(root, &acpi_pci_roots, node) {
-                if (root->handle == device->handle) {
+                if (root->device == device) {
                         pci_bus_add_devices(root->bus);
-                        return_VALUE(0);
+                        return 0;
                 }
         }
-        return_VALUE(-ENODEV);
+        return -ENODEV;
 }
 
 static int acpi_pci_root_remove(struct acpi_device *device, int type)
 {
         struct acpi_pci_root *root = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_pci_root_remove");
 
         if (!device || !acpi_driver_data(device))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         root = (struct acpi_pci_root *)acpi_driver_data(device);
 
         kfree(root);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int __init acpi_pci_root_init(void)
 {
-        ACPI_FUNCTION_TRACE("acpi_pci_root_init");
 
         if (acpi_pci_disabled)
-                return_VALUE(0);
+                return 0;
 
         /* DEBUG:
            acpi_dbg_layer = ACPI_PCI_COMPONENT;
@@ -353,9 +350,9 @@ static int __init acpi_pci_root_init(void)
          */
 
         if (acpi_bus_register_driver(&acpi_pci_root_driver) < 0)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
-        return_VALUE(0);
+        return 0;
 }
 
 subsys_initcall(acpi_pci_root_init);
diff --git a/drivers/acpi/power.c b/drivers/acpi/power.c
index 62a5595ed8bc..fec225d1b6b7 100644
--- a/drivers/acpi/power.c
+++ b/drivers/acpi/power.c
@@ -70,7 +70,7 @@ static struct acpi_driver acpi_power_driver = {
 };
 
 struct acpi_power_resource {
-        acpi_handle handle;
+        struct acpi_device * device;
         acpi_bus_id name;
         u32 system_level;
         u32 order;
@@ -80,7 +80,7 @@ struct acpi_power_resource {
 
 static struct list_head acpi_power_resource_list;
 
-static struct file_operations acpi_power_fops = {
+static const struct file_operations acpi_power_fops = {
         .open = acpi_power_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -98,23 +98,21 @@ acpi_power_get_context(acpi_handle handle,
         int result = 0;
         struct acpi_device *device = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_power_get_context");
 
         if (!resource)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         result = acpi_bus_get_device(handle, &device);
         if (result) {
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Error getting context [%p]\n",
-                                  handle));
-                return_VALUE(result);
+                printk(KERN_WARNING PREFIX "Getting context [%p]\n", handle);
+                return result;
         }
 
         *resource = (struct acpi_power_resource *)acpi_driver_data(device);
         if (!resource)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_power_get_state(struct acpi_power_resource *resource)
@@ -122,14 +120,13 @@ static int acpi_power_get_state(struct acpi_power_resource *resource)
         acpi_status status = AE_OK;
         unsigned long sta = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_power_get_state");
 
         if (!resource)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
-        status = acpi_evaluate_integer(resource->handle, "_STA", NULL, &sta);
+        status = acpi_evaluate_integer(resource->device->handle, "_STA", NULL, &sta);
         if (ACPI_FAILURE(status))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         if (sta & 0x01)
                 resource->state = ACPI_POWER_RESOURCE_STATE_ON;
@@ -139,7 +136,7 @@ static int acpi_power_get_state(struct acpi_power_resource *resource)
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n",
                           resource->name, resource->state ? "on" : "off"));
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_power_get_list_state(struct acpi_handle_list *list, int *state)
@@ -148,20 +145,19 @@ static int acpi_power_get_list_state(struct acpi_handle_list *list, int *state)
         struct acpi_power_resource *resource = NULL;
         u32 i = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_power_get_list_state");
 
         if (!list || !state)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /* The state of the list is 'on' IFF all resources are 'on'. */
 
         for (i = 0; i < list->count; i++) {
                 result = acpi_power_get_context(list->handles[i], &resource);
                 if (result)
-                        return_VALUE(result);
+                        return result;
                 result = acpi_power_get_state(resource);
                 if (result)
-                        return_VALUE(result);
+                        return result;
 
                 *state = resource->state;
 
@@ -172,7 +168,7 @@ static int acpi_power_get_list_state(struct acpi_handle_list *list, int *state)
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource list is %s\n",
                           *state ? "on" : "off"));
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_power_on(acpi_handle handle)
@@ -182,11 +178,10 @@ static int acpi_power_on(acpi_handle handle)
         struct acpi_device *device = NULL;
         struct acpi_power_resource *resource = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_power_on");
 
         result = acpi_power_get_context(handle, &resource);
         if (result)
-                return_VALUE(result);
+                return result;
 
         resource->references++;
 
@@ -194,29 +189,27 @@ static int acpi_power_on(acpi_handle handle)
             || (resource->state == ACPI_POWER_RESOURCE_STATE_ON)) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] already on\n",
                                   resource->name));
-                return_VALUE(0);
+                return 0;
         }
 
-        status = acpi_evaluate_object(resource->handle, "_ON", NULL, NULL);
+        status = acpi_evaluate_object(resource->device->handle, "_ON", NULL, NULL);
         if (ACPI_FAILURE(status))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         result = acpi_power_get_state(resource);
         if (result)
-                return_VALUE(result);
+                return result;
         if (resource->state != ACPI_POWER_RESOURCE_STATE_ON)
-                return_VALUE(-ENOEXEC);
+                return -ENOEXEC;
 
         /* Update the power resource's _device_ power state */
-        result = acpi_bus_get_device(resource->handle, &device);
-        if (result)
-                return_VALUE(result);
-        device->power.state = ACPI_STATE_D0;
+        device = resource->device;
+        resource->device->power.state = ACPI_STATE_D0;
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned on\n",
                           resource->name));
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_power_off_device(acpi_handle handle)
@@ -226,11 +219,10 @@ static int acpi_power_off_device(acpi_handle handle)
         struct acpi_device *device = NULL;
         struct acpi_power_resource *resource = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_power_off_device");
 
         result = acpi_power_get_context(handle, &resource);
         if (result)
-                return_VALUE(result);
+                return result;
 
         if (resource->references)
                 resource->references--;
@@ -239,35 +231,33 @@ static int acpi_power_off_device(acpi_handle handle)
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                   "Resource [%s] is still in use, dereferencing\n",
                                   device->pnp.bus_id));
-                return_VALUE(0);
+                return 0;
         }
 
         if (resource->state == ACPI_POWER_RESOURCE_STATE_OFF) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] already off\n",
                                   device->pnp.bus_id));
-                return_VALUE(0);
+                return 0;
         }
 
-        status = acpi_evaluate_object(resource->handle, "_OFF", NULL, NULL);
+        status = acpi_evaluate_object(resource->device->handle, "_OFF", NULL, NULL);
         if (ACPI_FAILURE(status))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         result = acpi_power_get_state(resource);
         if (result)
-                return_VALUE(result);
+                return result;
         if (resource->state != ACPI_POWER_RESOURCE_STATE_OFF)
-                return_VALUE(-ENOEXEC);
+                return -ENOEXEC;
 
         /* Update the power resource's _device_ power state */
-        result = acpi_bus_get_device(resource->handle, &device);
-        if (result)
-                return_VALUE(result);
+        device = resource->device;
         device->power.state = ACPI_STATE_D3;
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned off\n",
                           resource->name));
 
-        return_VALUE(0);
+        return 0;
 }
 
 /*
@@ -283,31 +273,29 @@ int acpi_enable_wakeup_device_power(struct acpi_device *dev)
         int i;
         int ret = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_enable_wakeup_device_power");
         if (!dev || !dev->wakeup.flags.valid)
-                return_VALUE(-1);
+                return -1;
 
         arg.integer.value = 1;
         /* Open power resource */
         for (i = 0; i < dev->wakeup.resources.count; i++) {
                 ret = acpi_power_on(dev->wakeup.resources.handles[i]);
                 if (ret) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Error transition power state\n"));
+                        printk(KERN_ERR PREFIX "Transition power state\n");
                         dev->wakeup.flags.valid = 0;
-                        return_VALUE(-1);
+                        return -1;
                 }
         }
 
         /* Execute PSW */
         status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
         if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluate _PSW\n"));
+                printk(KERN_ERR PREFIX "Evaluate _PSW\n");
                 dev->wakeup.flags.valid = 0;
                 ret = -1;
         }
 
-        return_VALUE(ret);
+        return ret;
 }
 
 /*
@@ -323,32 +311,30 @@ int acpi_disable_wakeup_device_power(struct acpi_device *dev)
         int i;
         int ret = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_disable_wakeup_device_power");
 
         if (!dev || !dev->wakeup.flags.valid)
-                return_VALUE(-1);
+                return -1;
 
         arg.integer.value = 0;
         /* Execute PSW */
         status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
         if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluate _PSW\n"));
+                printk(KERN_ERR PREFIX "Evaluate _PSW\n");
                 dev->wakeup.flags.valid = 0;
-                return_VALUE(-1);
+                return -1;
         }
 
         /* Close power resource */
         for (i = 0; i < dev->wakeup.resources.count; i++) {
                 ret = acpi_power_off_device(dev->wakeup.resources.handles[i]);
                 if (ret) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Error transition power state\n"));
+                        printk(KERN_ERR PREFIX "Transition power state\n");
                         dev->wakeup.flags.valid = 0;
-                        return_VALUE(-1);
+                        return -1;
                 }
         }
 
-        return_VALUE(ret);
+        return ret;
 }
 
 /* --------------------------------------------------------------------------
@@ -362,10 +348,9 @@ int acpi_power_get_inferred_state(struct acpi_device *device)
         int list_state = 0;
         int i = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_power_get_inferred_state");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         device->power.state = ACPI_STATE_UNKNOWN;
 
@@ -380,17 +365,17 @@ int acpi_power_get_inferred_state(struct acpi_device *device)
 
                 result = acpi_power_get_list_state(list, &list_state);
                 if (result)
-                        return_VALUE(result);
+                        return result;
 
                 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) {
                         device->power.state = i;
-                        return_VALUE(0);
+                        return 0;
                 }
         }
 
         device->power.state = ACPI_STATE_D3;
 
-        return_VALUE(0);
+        return 0;
 }
 
 int acpi_power_transition(struct acpi_device *device, int state)
@@ -400,14 +385,13 @@ int acpi_power_transition(struct acpi_device *device, int state)
         struct acpi_handle_list *tl = NULL;     /* Target Resources */
         int i = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_power_transition");
 
         if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if ((device->power.state < ACPI_STATE_D0)
             || (device->power.state > ACPI_STATE_D3))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         cl = &device->power.states[device->power.state].resources;
         tl = &device->power.states[state].resources;
@@ -444,11 +428,10 @@ int acpi_power_transition(struct acpi_device *device, int state)
         device->power.state = state;
       end:
         if (result)
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                  "Error transitioning device [%s] to D%d\n",
-                                  device->pnp.bus_id, state));
+                printk(KERN_WARNING PREFIX "Transitioning device [%s] to D%d\n",
+                              device->pnp.bus_id, state);
 
-        return_VALUE(result);
+        return result;
 }
 
 /* --------------------------------------------------------------------------
@@ -461,7 +444,6 @@ static int acpi_power_seq_show(struct seq_file *seq, void *offset)
 {
         struct acpi_power_resource *resource = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_power_seq_show");
 
         resource = (struct acpi_power_resource *)seq->private;
 
@@ -488,7 +470,7 @@ static int acpi_power_seq_show(struct seq_file *seq, void *offset)
                    resource->order, resource->references);
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_power_open_fs(struct inode *inode, struct file *file)
@@ -500,36 +482,32 @@ static int acpi_power_add_fs(struct acpi_device *device)
 {
         struct proc_dir_entry *entry = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_power_add_fs");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (!acpi_device_dir(device)) {
                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
                                                      acpi_power_dir);
                 if (!acpi_device_dir(device))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
         }
 
         /* 'status' [R] */
         entry = create_proc_entry(ACPI_POWER_FILE_STATUS,
                                   S_IRUGO, acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_POWER_FILE_STATUS));
+                return -EIO;
         else {
                 entry->proc_fops = &acpi_power_fops;
                 entry->data = acpi_driver_data(device);
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_power_remove_fs(struct acpi_device *device)
 {
-        ACPI_FUNCTION_TRACE("acpi_power_remove_fs");
 
         if (acpi_device_dir(device)) {
                 remove_proc_entry(ACPI_POWER_FILE_STATUS,
@@ -538,7 +516,7 @@ static int acpi_power_remove_fs(struct acpi_device *device)
                 acpi_device_dir(device) = NULL;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 /* --------------------------------------------------------------------------
@@ -553,24 +531,23 @@ static int acpi_power_add(struct acpi_device *device)
         union acpi_object acpi_object;
         struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object };
 
-        ACPI_FUNCTION_TRACE("acpi_power_add");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         resource = kmalloc(sizeof(struct acpi_power_resource), GFP_KERNEL);
         if (!resource)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(resource, 0, sizeof(struct acpi_power_resource));
 
-        resource->handle = device->handle;
+        resource->device = device;
         strcpy(resource->name, device->pnp.bus_id);
         strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME);
         strcpy(acpi_device_class(device), ACPI_POWER_CLASS);
         acpi_driver_data(device) = resource;
 
         /* Evalute the object to get the system level and resource order. */
-        status = acpi_evaluate_object(resource->handle, NULL, NULL, &buffer);
+        status = acpi_evaluate_object(device->handle, NULL, NULL, &buffer);
         if (ACPI_FAILURE(status)) {
                 result = -ENODEV;
                 goto end;
@@ -605,17 +582,16 @@ static int acpi_power_add(struct acpi_device *device)
         if (result)
                 kfree(resource);
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_power_remove(struct acpi_device *device, int type)
 {
         struct acpi_power_resource *resource = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_power_remove");
 
         if (!device || !acpi_driver_data(device))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         resource = (struct acpi_power_resource *)acpi_driver_data(device);
 
@@ -623,31 +599,30 @@ static int acpi_power_remove(struct acpi_device *device, int type)
 
         kfree(resource);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int __init acpi_power_init(void)
 {
         int result = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_power_init");
 
         if (acpi_disabled)
-                return_VALUE(0);
+                return 0;
 
         INIT_LIST_HEAD(&acpi_power_resource_list);
 
         acpi_power_dir = proc_mkdir(ACPI_POWER_CLASS, acpi_root_dir);
         if (!acpi_power_dir)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         result = acpi_bus_register_driver(&acpi_power_driver);
         if (result < 0) {
                 remove_proc_entry(ACPI_POWER_CLASS, acpi_root_dir);
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 subsys_initcall(acpi_power_init);
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index decaebb4cbe9..b13d64415b7a 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -102,7 +102,7 @@ static struct acpi_driver acpi_processor_driver = {
 #define INSTALL_NOTIFY_HANDLER          1
 #define UNINSTALL_NOTIFY_HANDLER        2
 
-static struct file_operations acpi_processor_info_fops = {
+static const struct file_operations acpi_processor_info_fops = {
         .open = acpi_processor_info_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -122,10 +122,9 @@ static int acpi_processor_errata_piix4(struct pci_dev *dev)
         u8 value1 = 0;
         u8 value2 = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_errata_piix4");
 
         if (!dev)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /*
          * Note that 'dev' references the PIIX4 ACPI Controller.
@@ -218,7 +217,7 @@ static int acpi_processor_errata_piix4(struct pci_dev *dev)
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                   "Type-F DMA livelock erratum (C3 disabled)\n"));
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_processor_errata(struct acpi_processor *pr)
@@ -226,10 +225,9 @@ static int acpi_processor_errata(struct acpi_processor *pr)
         int result = 0;
         struct pci_dev *dev = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_errata");
 
         if (!pr)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /*
          * PIIX4
@@ -242,7 +240,7 @@ static int acpi_processor_errata(struct acpi_processor *pr)
                 pci_dev_put(dev);
         }
 
-        return_VALUE(result);
+        return result;
 }
 
 /* --------------------------------------------------------------------------
@@ -258,10 +256,9 @@ static int acpi_processor_set_pdc(struct acpi_processor *pr)
         struct acpi_object_list *pdc_in = pr->pdc;
         acpi_status status = AE_OK;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_set_pdc");
 
         if (!pdc_in)
-                return_VALUE(status);
+                return status;
 
         status = acpi_evaluate_object(pr->handle, "_PDC", pdc_in, NULL);
 
@@ -269,7 +266,7 @@ static int acpi_processor_set_pdc(struct acpi_processor *pr)
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                     "Could not evaluate _PDC, using legacy perf. control...\n"));
 
-        return_VALUE(status);
+        return status;
 }
 
 /* --------------------------------------------------------------------------
@@ -282,7 +279,6 @@ static int acpi_processor_info_seq_show(struct seq_file *seq, void *offset)
 {
         struct acpi_processor *pr = (struct acpi_processor *)seq->private;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_info_seq_show");
 
         if (!pr)
                 goto end;
@@ -301,7 +297,7 @@ static int acpi_processor_info_seq_show(struct seq_file *seq, void *offset)
                    pr->flags.limit ? "yes" : "no");
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_processor_info_open_fs(struct inode *inode, struct file *file)
@@ -314,13 +310,12 @@ static int acpi_processor_add_fs(struct acpi_device *device)
 {
         struct proc_dir_entry *entry = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_add_fs");
 
         if (!acpi_device_dir(device)) {
                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
                                                      acpi_processor_dir);
                 if (!acpi_device_dir(device))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
         }
         acpi_device_dir(device)->owner = THIS_MODULE;
 
@@ -328,9 +323,7 @@ static int acpi_processor_add_fs(struct acpi_device *device)
         entry = create_proc_entry(ACPI_PROCESSOR_FILE_INFO,
                                   S_IRUGO, acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_PROCESSOR_FILE_INFO));
+                return -EIO;
         else {
                 entry->proc_fops = &acpi_processor_info_fops;
                 entry->data = acpi_driver_data(device);
@@ -342,9 +335,7 @@ static int acpi_processor_add_fs(struct acpi_device *device)
                                   S_IFREG | S_IRUGO | S_IWUSR,
                                   acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_PROCESSOR_FILE_THROTTLING));
+                return -EIO;
         else {
                 entry->proc_fops = &acpi_processor_throttling_fops;
                 entry->data = acpi_driver_data(device);
@@ -356,21 +347,18 @@ static int acpi_processor_add_fs(struct acpi_device *device)
                                   S_IFREG | S_IRUGO | S_IWUSR,
                                   acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_PROCESSOR_FILE_LIMIT));
+                return -EIO;
         else {
                 entry->proc_fops = &acpi_processor_limit_fops;
                 entry->data = acpi_driver_data(device);
                 entry->owner = THIS_MODULE;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_processor_remove_fs(struct acpi_device *device)
 {
-        ACPI_FUNCTION_TRACE("acpi_processor_remove_fs");
 
         if (acpi_device_dir(device)) {
                 remove_proc_entry(ACPI_PROCESSOR_FILE_INFO,
@@ -383,7 +371,7 @@ static int acpi_processor_remove_fs(struct acpi_device *device)
                 acpi_device_dir(device) = NULL;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 /* Use the acpiid in MADT to map cpus in case of SMP */
@@ -430,10 +418,9 @@ static int acpi_processor_get_info(struct acpi_processor *pr)
         int cpu_index;
         static int cpu0_initialized;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_get_info");
 
         if (!pr)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (num_online_cpus() > 1)
                 errata.smp = TRUE;
@@ -459,9 +446,8 @@ static int acpi_processor_get_info(struct acpi_processor *pr)
          */
         status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error evaluating processor object\n"));
-                return_VALUE(-ENODEV);
+                printk(KERN_ERR PREFIX "Evaluating processor object\n");
+                return -ENODEV;
         }
 
         /*
@@ -490,10 +476,10 @@ static int acpi_processor_get_info(struct acpi_processor *pr)
         if (cpu_index == -1) {
                 if (ACPI_FAILURE
                     (acpi_processor_hotadd_init(pr->handle, &pr->id))) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Error getting cpuindex for acpiid 0x%x\n",
-                                          pr->acpi_id));
-                        return_VALUE(-ENODEV);
+                        printk(KERN_ERR PREFIX
+                                    "Getting cpuindex for acpiid 0x%x\n",
+                                    pr->acpi_id);
+                        return -ENODEV;
                 }
         }
 
@@ -503,8 +489,8 @@ static int acpi_processor_get_info(struct acpi_processor *pr)
         if (!object.processor.pblk_address)
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n"));
         else if (object.processor.pblk_length != 6)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid PBLK length [%d]\n",
-                                  object.processor.pblk_length));
+                printk(KERN_ERR PREFIX "Invalid PBLK length [%d]\n",
+                            object.processor.pblk_length);
         else {
                 pr->throttling.address = object.processor.pblk_address;
                 pr->throttling.duty_offset = acpi_fadt.duty_offset;
@@ -528,7 +514,7 @@ static int acpi_processor_get_info(struct acpi_processor *pr)
         acpi_processor_get_throttling_info(pr);
         acpi_processor_get_limit_info(pr);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static void *processor_device_array[NR_CPUS];
@@ -539,14 +525,13 @@ static int acpi_processor_start(struct acpi_device *device)
         acpi_status status = AE_OK;
         struct acpi_processor *pr;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_start");
 
         pr = acpi_driver_data(device);
 
         result = acpi_processor_get_info(pr);
         if (result) {
                 /* Processor is physically not present */
-                return_VALUE(0);
+                return 0;
         }
 
         BUG_ON((pr->id >= NR_CPUS) || (pr->id < 0));
@@ -560,7 +545,7 @@ static int acpi_processor_start(struct acpi_device *device)
             processor_device_array[pr->id] != (void *)device) {
                 printk(KERN_WARNING "BIOS reported wrong ACPI id"
                         "for the processor\n");
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
         processor_device_array[pr->id] = (void *)device;
 
@@ -572,10 +557,6 @@ static int acpi_processor_start(struct acpi_device *device)
 
         status = acpi_install_notify_handler(pr->handle, ACPI_DEVICE_NOTIFY,
                                              acpi_processor_notify, pr);
-        if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error installing device notify handler\n"));
-        }
 
         /* _PDC call should be done before doing anything else (if reqd.). */
         arch_acpi_processor_init_pdc(pr);
@@ -592,7 +573,7 @@ static int acpi_processor_start(struct acpi_device *device)
 
       end:
 
-        return_VALUE(result);
+        return result;
 }
 
 static void acpi_processor_notify(acpi_handle handle, u32 event, void *data)
@@ -600,13 +581,12 @@ static void acpi_processor_notify(acpi_handle handle, u32 event, void *data)
         struct acpi_processor *pr = (struct acpi_processor *)data;
         struct acpi_device *device = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_notify");
 
         if (!pr)
-                return_VOID;
+                return;
 
         if (acpi_bus_get_device(pr->handle, &device))
-                return_VOID;
+                return;
 
         switch (event) {
         case ACPI_PROCESSOR_NOTIFY_PERFORMANCE:
@@ -624,21 +604,20 @@ static void acpi_processor_notify(acpi_handle handle, u32 event, void *data)
                 break;
         }
 
-        return_VOID;
+        return;
 }
 
 static int acpi_processor_add(struct acpi_device *device)
 {
         struct acpi_processor *pr = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_add");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         pr = kmalloc(sizeof(struct acpi_processor), GFP_KERNEL);
         if (!pr)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(pr, 0, sizeof(struct acpi_processor));
 
         pr->handle = device->handle;
@@ -646,7 +625,7 @@ static int acpi_processor_add(struct acpi_device *device)
         strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS);
         acpi_driver_data(device) = pr;
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_processor_remove(struct acpi_device *device, int type)
@@ -654,31 +633,26 @@ static int acpi_processor_remove(struct acpi_device *device, int type)
         acpi_status status = AE_OK;
         struct acpi_processor *pr = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_remove");
 
         if (!device || !acpi_driver_data(device))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         pr = (struct acpi_processor *)acpi_driver_data(device);
 
         if (pr->id >= NR_CPUS) {
                 kfree(pr);
-                return_VALUE(0);
+                return 0;
         }
 
         if (type == ACPI_BUS_REMOVAL_EJECT) {
                 if (acpi_processor_handle_eject(pr))
-                        return_VALUE(-EINVAL);
+                        return -EINVAL;
         }
 
         acpi_processor_power_exit(pr, device);
 
         status = acpi_remove_notify_handler(pr->handle, ACPI_DEVICE_NOTIFY,
                                             acpi_processor_notify);
-        if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error removing notify handler\n"));
-        }
 
         acpi_processor_remove_fs(device);
 
@@ -686,7 +660,7 @@ static int acpi_processor_remove(struct acpi_device *device, int type)
 
         kfree(pr);
 
-        return_VALUE(0);
+        return 0;
 }
 
 #ifdef CONFIG_ACPI_HOTPLUG_CPU
@@ -701,15 +675,13 @@ static int is_processor_present(acpi_handle handle)
         acpi_status status;
         unsigned long sta = 0;
 
-        ACPI_FUNCTION_TRACE("is_processor_present");
 
         status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
         if (ACPI_FAILURE(status) || !(sta & ACPI_STA_PRESENT)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Processor Device is not present\n"));
-                return_VALUE(0);
+                ACPI_EXCEPTION((AE_INFO, status, "Processor Device is not present"));
+                return 0;
         }
-        return_VALUE(1);
+        return 1;
 }
 
 static
@@ -719,30 +691,29 @@ int acpi_processor_device_add(acpi_handle handle, struct acpi_device **device)
         struct acpi_device *pdev;
         struct acpi_processor *pr;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_device_add");
 
         if (acpi_get_parent(handle, &phandle)) {
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
         if (acpi_bus_get_device(phandle, &pdev)) {
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
         if (acpi_bus_add(device, pdev, handle, ACPI_BUS_TYPE_PROCESSOR)) {
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
         acpi_bus_start(*device);
 
         pr = acpi_driver_data(*device);
         if (!pr)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         if ((pr->id >= 0) && (pr->id < NR_CPUS)) {
                 kobject_uevent(&(*device)->kobj, KOBJ_ONLINE);
         }
-        return_VALUE(0);
+        return 0;
 }
 
 static void
@@ -752,7 +723,6 @@ acpi_processor_hotplug_notify(acpi_handle handle, u32 event, void *data)
         struct acpi_device *device = NULL;
         int result;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_hotplug_notify");
 
         switch (event) {
         case ACPI_NOTIFY_BUS_CHECK:
@@ -767,15 +737,14 @@ acpi_processor_hotplug_notify(acpi_handle handle, u32 event, void *data)
                 if (acpi_bus_get_device(handle, &device)) {
                         result = acpi_processor_device_add(handle, &device);
                         if (result)
-                                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                                  "Unable to add the device\n"));
+                                printk(KERN_ERR PREFIX
+                                            "Unable to add the device\n");
                         break;
                 }
 
                 pr = acpi_driver_data(device);
                 if (!pr) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Driver data is NULL\n"));
+                        printk(KERN_ERR PREFIX "Driver data is NULL\n");
                         break;
                 }
 
@@ -788,9 +757,8 @@ acpi_processor_hotplug_notify(acpi_handle handle, u32 event, void *data)
                 if ((!result) && ((pr->id >= 0) && (pr->id < NR_CPUS))) {
                         kobject_uevent(&device->kobj, KOBJ_ONLINE);
                 } else {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Device [%s] failed to start\n",
-                                          acpi_device_bid(device)));
+                        printk(KERN_ERR PREFIX "Device [%s] failed to start\n",
+                                    acpi_device_bid(device));
                 }
                 break;
         case ACPI_NOTIFY_EJECT_REQUEST:
@@ -798,15 +766,15 @@ acpi_processor_hotplug_notify(acpi_handle handle, u32 event, void *data)
                                   "received ACPI_NOTIFY_EJECT_REQUEST\n"));
 
                 if (acpi_bus_get_device(handle, &device)) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Device don't exist, dropping EJECT\n"));
+                        printk(KERN_ERR PREFIX
+                                    "Device don't exist, dropping EJECT\n");
                         break;
                 }
                 pr = acpi_driver_data(device);
                 if (!pr) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Driver data is NULL, dropping EJECT\n"));
-                        return_VOID;
+                        printk(KERN_ERR PREFIX
+                                    "Driver data is NULL, dropping EJECT\n");
+                        return;
                 }
 
                 if ((pr->id < NR_CPUS) && (cpu_present(pr->id)))
@@ -818,7 +786,7 @@ acpi_processor_hotplug_notify(acpi_handle handle, u32 event, void *data)
                 break;
         }
 
-        return_VOID;
+        return;
 }
 
 static acpi_status
@@ -857,21 +825,20 @@ processor_walk_namespace_cb(acpi_handle handle,
 
 static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu)
 {
-        ACPI_FUNCTION_TRACE("acpi_processor_hotadd_init");
 
         if (!is_processor_present(handle)) {
-                return_VALUE(AE_ERROR);
+                return AE_ERROR;
         }
 
         if (acpi_map_lsapic(handle, p_cpu))
-                return_VALUE(AE_ERROR);
+                return AE_ERROR;
 
         if (arch_register_cpu(*p_cpu)) {
                 acpi_unmap_lsapic(*p_cpu);
-                return_VALUE(AE_ERROR);
+                return AE_ERROR;
         }
 
-        return_VALUE(AE_OK);
+        return AE_OK;
 }
 
 static int acpi_processor_handle_eject(struct acpi_processor *pr)
@@ -928,20 +895,19 @@ static int __init acpi_processor_init(void)
 {
         int result = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_init");
 
         memset(&processors, 0, sizeof(processors));
         memset(&errata, 0, sizeof(errata));
 
         acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir);
         if (!acpi_processor_dir)
-                return_VALUE(0);
+                return 0;
         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_VALUE(0);
+                return 0;
         }
 
         acpi_processor_install_hotplug_notify();
@@ -950,12 +916,11 @@ static int __init acpi_processor_init(void)
 
         acpi_processor_ppc_init();
 
-        return_VALUE(0);
+        return 0;
 }
 
 static void __exit acpi_processor_exit(void)
 {
-        ACPI_FUNCTION_TRACE("acpi_processor_exit");
 
         acpi_processor_ppc_exit();
 
@@ -967,7 +932,7 @@ static void __exit acpi_processor_exit(void)
 
         remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
 
-        return_VOID;
+        return;
 }
 
 module_init(acpi_processor_init);
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 3b97a5eae9e8..71066066d626 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -3,7 +3,7 @@
  *
  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
- *  Copyright (C) 2004       Dominik Brodowski <linux@brodo.de>
+ *  Copyright (C) 2004, 2005 Dominik Brodowski <linux@brodo.de>
  *  Copyright (C) 2004  Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
  *                      - Added processor hotplug support
  *  Copyright (C) 2005  Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
@@ -99,6 +99,9 @@ static int set_max_cstate(struct dmi_system_id *id)
 static struct dmi_system_id __cpuinitdata processor_power_dmi_table[] = {
         { set_max_cstate, "IBM ThinkPad R40e", {
           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
+          DMI_MATCH(DMI_BIOS_VERSION,"1SET70WW")}, (void *)1},
+        { set_max_cstate, "IBM ThinkPad R40e", {
+          DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
           DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW")}, (void *)1},
         { set_max_cstate, "IBM ThinkPad R40e", {
           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
@@ -206,11 +209,11 @@ acpi_processor_power_activate(struct acpi_processor *pr,
 
 static void acpi_safe_halt(void)
 {
-        clear_thread_flag(TIF_POLLING_NRFLAG);
+        current_thread_info()->status &= ~TS_POLLING;
         smp_mb__after_clear_bit();
         if (!need_resched())
                 safe_halt();
-        set_thread_flag(TIF_POLLING_NRFLAG);
+        current_thread_info()->status |= TS_POLLING;
 }
 
 static atomic_t c3_cpu_count;
@@ -261,21 +264,15 @@ static void acpi_processor_idle(void)
                 u32 bm_status = 0;
                 unsigned long diff = jiffies - pr->power.bm_check_timestamp;
 
-                if (diff > 32)
-                        diff = 32;
+                if (diff > 31)
+                        diff = 31;
 
-                while (diff) {
-                        /* if we didn't get called, assume there was busmaster activity */
-                        diff--;
-                        if (diff)
-                                pr->power.bm_activity |= 0x1;
-                        pr->power.bm_activity <<= 1;
-                }
+                pr->power.bm_activity <<= diff;
 
                 acpi_get_register(ACPI_BITREG_BUS_MASTER_STATUS,
                                   &bm_status, ACPI_MTX_DO_NOT_LOCK);
                 if (bm_status) {
-                        pr->power.bm_activity++;
+                        pr->power.bm_activity |= 0x1;
                         acpi_set_register(ACPI_BITREG_BUS_MASTER_STATUS,
                                           1, ACPI_MTX_DO_NOT_LOCK);
                 }
@@ -287,16 +284,16 @@ static void acpi_processor_idle(void)
                 else if (errata.piix4.bmisx) {
                         if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01)
                             || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01))
-                                pr->power.bm_activity++;
+                                pr->power.bm_activity |= 0x1;
                 }
 
                 pr->power.bm_check_timestamp = jiffies;
 
                 /*
-                 * Apply bus mastering demotion policy.  Automatically demote
+                 * If bus mastering is or was active this jiffy, demote
                  * to avoid a faulty transition.  Note that the processor
                  * won't enter a low-power state during this call (to this
-                 * funciton) but should upon the next.
+                 * function) but should upon the next.
                  *
                  * TBD: A better policy might be to fallback to the demotion
                  *      state (use it for this quantum only) istead of
@@ -304,7 +301,8 @@ static void acpi_processor_idle(void)
                  *      qualification.  This may, however, introduce DMA
                  *      issues (e.g. floppy DMA transfer overrun/underrun).
                  */
-                if (pr->power.bm_activity & cx->demotion.threshold.bm) {
+                if ((pr->power.bm_activity & 0x1) &&
+                    cx->demotion.threshold.bm) {
                         local_irq_enable();
                         next_state = cx->demotion.state;
                         goto end;
@@ -322,18 +320,16 @@ static void acpi_processor_idle(void)
                 cx = &pr->power.states[ACPI_STATE_C1];
 #endif
 
-        cx->usage++;
-
         /*
          * Sleep:
          * ------
          * Invoke the current Cx state to put the processor to sleep.
          */
         if (cx->type == ACPI_STATE_C2 || cx->type == ACPI_STATE_C3) {
-                clear_thread_flag(TIF_POLLING_NRFLAG);
+                current_thread_info()->status &= ~TS_POLLING;
                 smp_mb__after_clear_bit();
                 if (need_resched()) {
-                        set_thread_flag(TIF_POLLING_NRFLAG);
+                        current_thread_info()->status |= TS_POLLING;
                         local_irq_enable();
                         return;
                 }
@@ -365,13 +361,20 @@ static void acpi_processor_idle(void)
                 t1 = inl(acpi_fadt.xpm_tmr_blk.address);
                 /* Invoke C2 */
                 inb(cx->address);
-                /* Dummy op - must do something useless after P_LVL2 read */
+                /* Dummy wait op - must do something useless after P_LVL2 read
+                   because chipsets cannot guarantee that STPCLK# signal
+                   gets asserted in time to freeze execution properly. */
                 t2 = inl(acpi_fadt.xpm_tmr_blk.address);
                 /* Get end time (ticks) */
                 t2 = inl(acpi_fadt.xpm_tmr_blk.address);
+
+#ifdef CONFIG_GENERIC_TIME
+                /* TSC halts in C2, so notify users */
+                mark_tsc_unstable();
+#endif
                 /* Re-enable interrupts */
                 local_irq_enable();
-                set_thread_flag(TIF_POLLING_NRFLAG);
+                current_thread_info()->status |= TS_POLLING;
                 /* Compute time (ticks) that we were actually asleep */
                 sleep_ticks =
                     ticks_elapsed(t1, t2) - cx->latency_ticks - C2_OVERHEAD;
@@ -398,7 +401,7 @@ static void acpi_processor_idle(void)
                 t1 = inl(acpi_fadt.xpm_tmr_blk.address);
                 /* Invoke C3 */
                 inb(cx->address);
-                /* Dummy op - must do something useless after P_LVL3 read */
+                /* Dummy wait op (see above) */
                 t2 = inl(acpi_fadt.xpm_tmr_blk.address);
                 /* Get end time (ticks) */
                 t2 = inl(acpi_fadt.xpm_tmr_blk.address);
@@ -409,9 +412,13 @@ static void acpi_processor_idle(void)
                                           ACPI_MTX_DO_NOT_LOCK);
                 }
 
+#ifdef CONFIG_GENERIC_TIME
+                /* TSC halts in C3, so notify users */
+                mark_tsc_unstable();
+#endif
                 /* Re-enable interrupts */
                 local_irq_enable();
-                set_thread_flag(TIF_POLLING_NRFLAG);
+                current_thread_info()->status |= TS_POLLING;
                 /* Compute time (ticks) that we were actually asleep */
                 sleep_ticks =
                     ticks_elapsed(t1, t2) - cx->latency_ticks - C3_OVERHEAD;
@@ -421,6 +428,9 @@ static void acpi_processor_idle(void)
                 local_irq_enable();
                 return;
         }
+        cx->usage++;
+        if ((cx->type != ACPI_STATE_C1) && (sleep_ticks > 0))
+                cx->time += sleep_ticks;
 
         next_state = pr->power.state;
 
@@ -508,10 +518,9 @@ static int acpi_processor_set_power_policy(struct acpi_processor *pr)
         struct acpi_processor_cx *higher = NULL;
         struct acpi_processor_cx *cx;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_set_power_policy");
 
         if (!pr)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /*
          * This function sets the default Cx state policy (OS idle handler).
@@ -535,7 +544,7 @@ static int acpi_processor_set_power_policy(struct acpi_processor *pr)
         }
 
         if (!state_is_set)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         /* demotion */
         for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
@@ -574,18 +583,17 @@ static int acpi_processor_set_power_policy(struct acpi_processor *pr)
                 higher = cx;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
 {
-        ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_fadt");
 
         if (!pr)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (!pr->pblk)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         /* if info is obtained from pblk/fadt, type equals state */
         pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2;
@@ -597,7 +605,7 @@ static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
          * an SMP system. 
          */
         if ((num_online_cpus() > 1) && !acpi_fadt.plvl2_up)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 #endif
 
         /* determine C2 and C3 address from pblk */
@@ -613,12 +621,11 @@ static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
                           pr->power.states[ACPI_STATE_C2].address,
                           pr->power.states[ACPI_STATE_C3].address));
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_processor_get_power_info_default_c1(struct acpi_processor *pr)
 {
-        ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_default_c1");
 
         /* Zero initialize all the C-states info. */
         memset(pr->power.states, 0, sizeof(pr->power.states));
@@ -631,7 +638,7 @@ static int acpi_processor_get_power_info_default_c1(struct acpi_processor *pr)
         pr->power.states[ACPI_STATE_C0].valid = 1;
         pr->power.states[ACPI_STATE_C1].valid = 1;
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
@@ -643,10 +650,9 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *cst;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_cst");
 
         if (nocst)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         current_count = 1;
 
@@ -658,15 +664,14 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
         status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer);
         if (ACPI_FAILURE(status)) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _CST, giving up\n"));
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
         cst = (union acpi_object *)buffer.pointer;
 
         /* There must be at least 2 elements */
         if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "not enough elements in _CST\n"));
+                printk(KERN_ERR PREFIX "not enough elements in _CST\n");
                 status = -EFAULT;
                 goto end;
         }
@@ -675,8 +680,7 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
 
         /* Validate number of power states. */
         if (count < 1 || count != cst->package.count - 1) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "count given by _CST is not valid\n"));
+                printk(KERN_ERR PREFIX "count given by _CST is not valid\n");
                 status = -EFAULT;
                 goto end;
         }
@@ -764,17 +768,16 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
                 status = -EFAULT;
 
       end:
-        acpi_os_free(buffer.pointer);
+        kfree(buffer.pointer);
 
-        return_VALUE(status);
+        return status;
 }
 
 static void acpi_processor_power_verify_c2(struct acpi_processor_cx *cx)
 {
-        ACPI_FUNCTION_TRACE("acpi_processor_get_power_verify_c2");
 
         if (!cx->address)
-                return_VOID;
+                return;
 
         /*
          * C2 latency must be less than or equal to 100
@@ -783,7 +786,7 @@ static void acpi_processor_power_verify_c2(struct acpi_processor_cx *cx)
         else if (cx->latency > ACPI_PROCESSOR_MAX_C2_LATENCY) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                   "latency too large [%d]\n", cx->latency));
-                return_VOID;
+                return;
         }
 
         /*
@@ -793,7 +796,7 @@ static void acpi_processor_power_verify_c2(struct acpi_processor_cx *cx)
         cx->valid = 1;
         cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency);
 
-        return_VOID;
+        return;
 }
 
 static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
@@ -801,10 +804,9 @@ static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
 {
         static int bm_check_flag;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_get_power_verify_c3");
 
         if (!cx->address)
-                return_VOID;
+                return;
 
         /*
          * C3 latency must be less than or equal to 1000
@@ -813,7 +815,7 @@ static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
         else if (cx->latency > ACPI_PROCESSOR_MAX_C3_LATENCY) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                   "latency too large [%d]\n", cx->latency));
-                return_VOID;
+                return;
         }
 
         /*
@@ -826,7 +828,7 @@ static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
         else if (errata.piix4.fdma) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                   "C3 not supported on PIIX4 with Type-F DMA\n"));
-                return_VOID;
+                return;
         }
 
         /* All the logic here assumes flags.bm_check is same across all CPUs */
@@ -843,7 +845,7 @@ static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
                 if (!pr->flags.bm_control) {
                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                           "C3 support requires bus mastering control\n"));
-                        return_VOID;
+                        return;
                 }
         } else {
                 /*
@@ -854,7 +856,7 @@ static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                           "Cache invalidation should work properly"
                                           " for C3 to be enabled on SMP systems\n"));
-                        return_VOID;
+                        return;
                 }
                 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD,
                                   0, ACPI_MTX_DO_NOT_LOCK);
@@ -869,7 +871,7 @@ static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
         cx->valid = 1;
         cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency);
 
-        return_VOID;
+        return;
 }
 
 static int acpi_processor_power_verify(struct acpi_processor *pr)
@@ -928,7 +930,6 @@ static int acpi_processor_get_power_info(struct acpi_processor *pr)
         unsigned int i;
         int result;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_get_power_info");
 
         /* NOTE: the idle thread may not be running while calling
          * this function */
@@ -951,7 +952,7 @@ static int acpi_processor_get_power_info(struct acpi_processor *pr)
          */
         result = acpi_processor_set_power_policy(pr);
         if (result)
-                return_VALUE(result);
+                return result;
 
         /*
          * if one state of type C2 or C3 is available, mark this
@@ -965,24 +966,23 @@ static int acpi_processor_get_power_info(struct acpi_processor *pr)
                 }
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 int acpi_processor_cst_has_changed(struct acpi_processor *pr)
 {
         int result = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_cst_has_changed");
 
         if (!pr)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (nocst) {
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
         if (!pr->flags.power_setup_done)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         /* Fall back to the default idle loop */
         pm_idle = pm_idle_save;
@@ -993,7 +993,7 @@ int acpi_processor_cst_has_changed(struct acpi_processor *pr)
         if ((pr->flags.power == 1) && (pr->flags.power_setup_done))
                 pm_idle = acpi_processor_idle;
 
-        return_VALUE(result);
+        return result;
 }
 
 /* proc interface */
@@ -1003,7 +1003,6 @@ static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
         struct acpi_processor *pr = (struct acpi_processor *)seq->private;
         unsigned int i;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_power_seq_show");
 
         if (!pr)
                 goto end;
@@ -1055,13 +1054,14 @@ static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
                 else
                         seq_puts(seq, "demotion[--] ");
 
-                seq_printf(seq, "latency[%03d] usage[%08d]\n",
+                seq_printf(seq, "latency[%03d] usage[%08d] duration[%020llu]\n",
                            pr->power.states[i].latency,
-                           pr->power.states[i].usage);
+                           pr->power.states[i].usage,
+                           pr->power.states[i].time);
         }
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_processor_power_open_fs(struct inode *inode, struct file *file)
@@ -1070,7 +1070,7 @@ static int acpi_processor_power_open_fs(struct inode *inode, struct file *file)
                            PDE(inode)->data);
 }
 
-static struct file_operations acpi_processor_power_fops = {
+static const struct file_operations acpi_processor_power_fops = {
         .open = acpi_processor_power_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -1085,7 +1085,6 @@ int acpi_processor_power_init(struct acpi_processor *pr,
         struct proc_dir_entry *entry = NULL;
         unsigned int i;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_power_init");
 
         if (!first_run) {
                 dmi_check_system(processor_power_dmi_table);
@@ -1097,14 +1096,14 @@ int acpi_processor_power_init(struct acpi_processor *pr,
         }
 
         if (!pr)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (acpi_fadt.cst_cnt && !nocst) {
                 status =
                     acpi_os_write_port(acpi_fadt.smi_cmd, acpi_fadt.cst_cnt, 8);
                 if (ACPI_FAILURE(status)) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Notifying BIOS of _CST ability failed\n"));
+                        ACPI_EXCEPTION((AE_INFO, status,
+                                        "Notifying BIOS of _CST ability failed"));
                 }
         }
 
@@ -1133,9 +1132,7 @@ int acpi_processor_power_init(struct acpi_processor *pr,
         entry = create_proc_entry(ACPI_PROCESSOR_FILE_POWER,
                                   S_IRUGO, acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_PROCESSOR_FILE_POWER));
+                return -EIO;
         else {
                 entry->proc_fops = &acpi_processor_power_fops;
                 entry->data = acpi_driver_data(device);
@@ -1144,13 +1141,12 @@ int acpi_processor_power_init(struct acpi_processor *pr,
 
         pr->flags.power_setup_done = 1;
 
-        return_VALUE(0);
+        return 0;
 }
 
 int acpi_processor_power_exit(struct acpi_processor *pr,
                               struct acpi_device *device)
 {
-        ACPI_FUNCTION_TRACE("acpi_processor_power_exit");
 
         pr->flags.power_setup_done = 0;
 
@@ -1170,5 +1166,5 @@ int acpi_processor_power_exit(struct acpi_processor *pr,
                 cpu_idle_wait();
         }
 
-        return_VALUE(0);
+        return 0;
 }
diff --git a/drivers/acpi/processor_perflib.c b/drivers/acpi/processor_perflib.c
index 41aaaba74b19..7ba5e49ab302 100644
--- a/drivers/acpi/processor_perflib.c
+++ b/drivers/acpi/processor_perflib.c
@@ -108,10 +108,9 @@ static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
         acpi_status status = 0;
         unsigned long ppc = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_get_platform_limit");
 
         if (!pr)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /*
          * _PPC indicates the maximum state currently supported by the platform
@@ -123,13 +122,13 @@ static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
                 acpi_processor_ppc_status |= PPC_IN_USE;
 
         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PPC\n"));
-                return_VALUE(-ENODEV);
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PPC"));
+                return -ENODEV;
         }
 
         pr->performance_platform_limit = (int)ppc;
 
-        return_VALUE(0);
+        return 0;
 }
 
 int acpi_processor_ppc_has_changed(struct acpi_processor *pr)
@@ -168,18 +167,17 @@ static int acpi_processor_get_performance_control(struct acpi_processor *pr)
         union acpi_object *pct = NULL;
         union acpi_object obj = { 0 };
 
-        ACPI_FUNCTION_TRACE("acpi_processor_get_performance_control");
 
         status = acpi_evaluate_object(pr->handle, "_PCT", NULL, &buffer);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PCT\n"));
-                return_VALUE(-ENODEV);
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PCT"));
+                return -ENODEV;
         }
 
         pct = (union acpi_object *)buffer.pointer;
         if (!pct || (pct->type != ACPI_TYPE_PACKAGE)
             || (pct->package.count != 2)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PCT data\n"));
+                printk(KERN_ERR PREFIX "Invalid _PCT data\n");
                 result = -EFAULT;
                 goto end;
         }
@@ -193,8 +191,7 @@ static int acpi_processor_get_performance_control(struct acpi_processor *pr)
         if ((obj.type != ACPI_TYPE_BUFFER)
             || (obj.buffer.length < sizeof(struct acpi_pct_register))
             || (obj.buffer.pointer == NULL)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Invalid _PCT data (control_register)\n"));
+                printk(KERN_ERR PREFIX "Invalid _PCT data (control_register)\n");
                 result = -EFAULT;
                 goto end;
         }
@@ -210,8 +207,7 @@ static int acpi_processor_get_performance_control(struct acpi_processor *pr)
         if ((obj.type != ACPI_TYPE_BUFFER)
             || (obj.buffer.length < sizeof(struct acpi_pct_register))
             || (obj.buffer.pointer == NULL)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Invalid _PCT data (status_register)\n"));
+                printk(KERN_ERR PREFIX "Invalid _PCT data (status_register)\n");
                 result = -EFAULT;
                 goto end;
         }
@@ -220,9 +216,9 @@ static int acpi_processor_get_performance_control(struct acpi_processor *pr)
                sizeof(struct acpi_pct_register));
 
       end:
-        acpi_os_free(buffer.pointer);
+        kfree(buffer.pointer);
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_processor_get_performance_states(struct acpi_processor *pr)
@@ -235,17 +231,16 @@ static int acpi_processor_get_performance_states(struct acpi_processor *pr)
         union acpi_object *pss = NULL;
         int i;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_get_performance_states");
 
         status = acpi_evaluate_object(pr->handle, "_PSS", NULL, &buffer);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PSS\n"));
-                return_VALUE(-ENODEV);
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PSS"));
+                return -ENODEV;
         }
 
         pss = (union acpi_object *)buffer.pointer;
         if (!pss || (pss->type != ACPI_TYPE_PACKAGE)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PSS data\n"));
+                printk(KERN_ERR PREFIX "Invalid _PSS data\n");
                 result = -EFAULT;
                 goto end;
         }
@@ -274,8 +269,7 @@ static int acpi_processor_get_performance_states(struct acpi_processor *pr)
                 status = acpi_extract_package(&(pss->package.elements[i]),
                                               &format, &state);
                 if (ACPI_FAILURE(status)) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Invalid _PSS data\n"));
+                        ACPI_EXCEPTION((AE_INFO, status, "Invalid _PSS data"));
                         result = -EFAULT;
                         kfree(pr->performance->states);
                         goto end;
@@ -291,8 +285,8 @@ static int acpi_processor_get_performance_states(struct acpi_processor *pr)
                                   (u32) px->control, (u32) px->status));
 
                 if (!px->core_frequency) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Invalid _PSS data: freq is zero\n"));
+                        printk(KERN_ERR PREFIX
+                                    "Invalid _PSS data: freq is zero\n");
                         result = -EFAULT;
                         kfree(pr->performance->states);
                         goto end;
@@ -300,9 +294,9 @@ static int acpi_processor_get_performance_states(struct acpi_processor *pr)
         }
 
       end:
-        acpi_os_free(buffer.pointer);
+        kfree(buffer.pointer);
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_processor_get_performance_info(struct acpi_processor *pr)
@@ -311,31 +305,30 @@ static int acpi_processor_get_performance_info(struct acpi_processor *pr)
         acpi_status status = AE_OK;
         acpi_handle handle = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_get_performance_info");
 
         if (!pr || !pr->performance || !pr->handle)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         status = acpi_get_handle(pr->handle, "_PCT", &handle);
         if (ACPI_FAILURE(status)) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                   "ACPI-based processor performance control unavailable\n"));
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
         result = acpi_processor_get_performance_control(pr);
         if (result)
-                return_VALUE(result);
+                return result;
 
         result = acpi_processor_get_performance_states(pr);
         if (result)
-                return_VALUE(result);
+                return result;
 
         result = acpi_processor_get_platform_limit(pr);
         if (result)
-                return_VALUE(result);
+                return result;
 
-        return_VALUE(0);
+        return 0;
 }
 
 int acpi_processor_notify_smm(struct module *calling_module)
@@ -343,13 +336,12 @@ int acpi_processor_notify_smm(struct module *calling_module)
         acpi_status status;
         static int is_done = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_notify_smm");
 
         if (!(acpi_processor_ppc_status & PPC_REGISTERED))
-                return_VALUE(-EBUSY);
+                return -EBUSY;
 
         if (!try_module_get(calling_module))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /* is_done is set to negative if an error occured,
          * and to postitive if _no_ error occured, but SMM
@@ -358,10 +350,10 @@ int acpi_processor_notify_smm(struct module *calling_module)
          */
         if (is_done > 0) {
                 module_put(calling_module);
-                return_VALUE(0);
+                return 0;
         } else if (is_done < 0) {
                 module_put(calling_module);
-                return_VALUE(is_done);
+                return is_done;
         }
 
         is_done = -EIO;
@@ -370,7 +362,7 @@ int acpi_processor_notify_smm(struct module *calling_module)
         if ((!acpi_fadt.smi_cmd) || (!acpi_fadt.pstate_cnt)) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No SMI port or pstate_cnt\n"));
                 module_put(calling_module);
-                return_VALUE(0);
+                return 0;
         }
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
@@ -387,12 +379,12 @@ int acpi_processor_notify_smm(struct module *calling_module)
         status = acpi_os_write_port(acpi_fadt.smi_cmd,
                                     (u32) acpi_fadt.pstate_cnt, 8);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Failed to write pstate_cnt [0x%x] to "
-                                  "smi_cmd [0x%x]\n", acpi_fadt.pstate_cnt,
-                                  acpi_fadt.smi_cmd));
+                ACPI_EXCEPTION((AE_INFO, status,
+                                "Failed to write pstate_cnt [0x%x] to "
+                                "smi_cmd [0x%x]", acpi_fadt.pstate_cnt,
+                                acpi_fadt.smi_cmd));
                 module_put(calling_module);
-                return_VALUE(status);
+                return status;
         }
 
         /* Success. If there's no _PPC, we need to fear nothing, so
@@ -402,7 +394,7 @@ int acpi_processor_notify_smm(struct module *calling_module)
         if (!(acpi_processor_ppc_status & PPC_IN_USE))
                 module_put(calling_module);
 
-        return_VALUE(0);
+        return 0;
 }
 
 EXPORT_SYMBOL(acpi_processor_notify_smm);
@@ -423,7 +415,6 @@ static int acpi_processor_perf_seq_show(struct seq_file *seq, void *offset)
         struct acpi_processor *pr = (struct acpi_processor *)seq->private;
         int i;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_perf_seq_show");
 
         if (!pr)
                 goto end;
@@ -447,7 +438,7 @@ static int acpi_processor_perf_seq_show(struct seq_file *seq, void *offset)
                            (u32) pr->performance->states[i].transition_latency);
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_processor_perf_open_fs(struct inode *inode, struct file *file)
@@ -469,23 +460,22 @@ acpi_processor_write_performance(struct file *file,
         unsigned int new_state = 0;
         struct cpufreq_policy policy;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_write_performance");
 
         if (!pr || (count > sizeof(state_string) - 1))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         perf = pr->performance;
         if (!perf)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (copy_from_user(state_string, buffer, count))
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
         state_string[count] = '\0';
         new_state = simple_strtoul(state_string, NULL, 0);
 
         if (new_state >= perf->state_count)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         cpufreq_get_policy(&policy, pr->id);
 
@@ -495,9 +485,9 @@ acpi_processor_write_performance(struct file *file,
 
         result = cpufreq_set_policy(&policy);
         if (result)
-                return_VALUE(result);
+                return result;
 
-        return_VALUE(count);
+        return count;
 }
 
 static void acpi_cpufreq_add_file(struct acpi_processor *pr)
@@ -505,42 +495,36 @@ static void acpi_cpufreq_add_file(struct acpi_processor *pr)
         struct proc_dir_entry *entry = NULL;
         struct acpi_device *device = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_cpufreq_addfile");
 
         if (acpi_bus_get_device(pr->handle, &device))
-                return_VOID;
+                return;
 
         /* add file 'performance' [R/W] */
         entry = create_proc_entry(ACPI_PROCESSOR_FILE_PERFORMANCE,
                                   S_IFREG | S_IRUGO | S_IWUSR,
                                   acpi_device_dir(device));
-        if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_PROCESSOR_FILE_PERFORMANCE));
-        else {
+        if (entry){
                 acpi_processor_perf_fops.write = acpi_processor_write_performance;
                 entry->proc_fops = &acpi_processor_perf_fops;
                 entry->data = acpi_driver_data(device);
                 entry->owner = THIS_MODULE;
         }
-        return_VOID;
+        return;
 }
 
 static void acpi_cpufreq_remove_file(struct acpi_processor *pr)
 {
         struct acpi_device *device = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_cpufreq_addfile");
 
         if (acpi_bus_get_device(pr->handle, &device))
-                return_VOID;
+                return;
 
         /* remove file 'performance' */
         remove_proc_entry(ACPI_PROCESSOR_FILE_PERFORMANCE,
                           acpi_device_dir(device));
 
-        return_VOID;
+        return;
 }
 
 #else
@@ -608,7 +592,7 @@ static int acpi_processor_get_psd(struct acpi_processor	*pr)
         }
 
 end:
-        acpi_os_free(buffer.pointer);
+        kfree(buffer.pointer);
         return result;
 }
 
@@ -698,12 +682,12 @@ int acpi_processor_preregister_performance(
                 /* Validate the Domain info */
                 count_target = pdomain->num_processors;
                 count = 1;
-                if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ALL ||
-                    pdomain->coord_type == DOMAIN_COORD_TYPE_HW_ALL) {
+                if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ALL)
                         pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ALL;
-                } else if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ANY) {
+                else if (pdomain->coord_type == DOMAIN_COORD_TYPE_HW_ALL)
+                        pr->performance->shared_type = CPUFREQ_SHARED_TYPE_HW;
+                else if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ANY)
                         pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ANY;
-                }
 
                 for_each_possible_cpu(j) {
                         if (i == j)
@@ -784,22 +768,21 @@ acpi_processor_register_performance(struct acpi_processor_performance
 {
         struct acpi_processor *pr;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_register_performance");
 
         if (!(acpi_processor_ppc_status & PPC_REGISTERED))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         mutex_lock(&performance_mutex);
 
         pr = processors[cpu];
         if (!pr) {
                 mutex_unlock(&performance_mutex);
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
         if (pr->performance) {
                 mutex_unlock(&performance_mutex);
-                return_VALUE(-EBUSY);
+                return -EBUSY;
         }
 
         WARN_ON(!performance);
@@ -809,13 +792,13 @@ acpi_processor_register_performance(struct acpi_processor_performance
         if (acpi_processor_get_performance_info(pr)) {
                 pr->performance = NULL;
                 mutex_unlock(&performance_mutex);
-                return_VALUE(-EIO);
+                return -EIO;
         }
 
         acpi_cpufreq_add_file(pr);
 
         mutex_unlock(&performance_mutex);
-        return_VALUE(0);
+        return 0;
 }
 
 EXPORT_SYMBOL(acpi_processor_register_performance);
@@ -826,14 +809,13 @@ acpi_processor_unregister_performance(struct acpi_processor_performance
 {
         struct acpi_processor *pr;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_unregister_performance");
 
         mutex_lock(&performance_mutex);
 
         pr = processors[cpu];
         if (!pr) {
                 mutex_unlock(&performance_mutex);
-                return_VOID;
+                return;
         }
 
         if (pr->performance)
@@ -844,7 +826,7 @@ acpi_processor_unregister_performance(struct acpi_processor_performance
 
         mutex_unlock(&performance_mutex);
 
-        return_VOID;
+        return;
 }
 
 EXPORT_SYMBOL(acpi_processor_unregister_performance);
diff --git a/drivers/acpi/processor_thermal.c b/drivers/acpi/processor_thermal.c
index f99ad05cd6a2..ef5e0f6efdba 100644
--- a/drivers/acpi/processor_thermal.c
+++ b/drivers/acpi/processor_thermal.c
@@ -54,13 +54,12 @@ static int acpi_processor_apply_limit(struct acpi_processor *pr)
         u16 px = 0;
         u16 tx = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_apply_limit");
 
         if (!pr)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (!pr->flags.limit)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         if (pr->flags.throttling) {
                 if (pr->limit.user.tx > tx)
@@ -82,9 +81,9 @@ static int acpi_processor_apply_limit(struct acpi_processor *pr)
 
       end:
         if (result)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unable to set limit\n"));
+                printk(KERN_ERR PREFIX "Unable to set limit\n");
 
-        return_VALUE(result);
+        return result;
 }
 
 #ifdef CONFIG_CPU_FREQ
@@ -200,19 +199,18 @@ int acpi_processor_set_thermal_limit(acpi_handle handle, int type)
         struct acpi_device *device = NULL;
         int tx = 0, max_tx_px = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_set_thermal_limit");
 
         if ((type < ACPI_PROCESSOR_LIMIT_NONE)
             || (type > ACPI_PROCESSOR_LIMIT_DECREMENT))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         result = acpi_bus_get_device(handle, &device);
         if (result)
-                return_VALUE(result);
+                return result;
 
         pr = (struct acpi_processor *)acpi_driver_data(device);
         if (!pr)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         /* Thermal limits are always relative to the current Px/Tx state. */
         if (pr->flags.throttling)
@@ -289,30 +287,28 @@ int acpi_processor_set_thermal_limit(acpi_handle handle, int type)
 
                 result = acpi_processor_apply_limit(pr);
                 if (result)
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Unable to set thermal limit\n"));
+                        printk(KERN_ERR PREFIX "Unable to set thermal limit\n");
 
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Thermal limit now (P%d:T%d)\n",
                                   pr->limit.thermal.px, pr->limit.thermal.tx));
         } else
                 result = 0;
         if (max_tx_px)
-                return_VALUE(1);
+                return 1;
         else
-                return_VALUE(result);
+                return result;
 }
 
 int acpi_processor_get_limit_info(struct acpi_processor *pr)
 {
-        ACPI_FUNCTION_TRACE("acpi_processor_get_limit_info");
 
         if (!pr)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (pr->flags.throttling)
                 pr->flags.limit = 1;
 
-        return_VALUE(0);
+        return 0;
 }
 
 /* /proc interface */
@@ -321,7 +317,6 @@ static int acpi_processor_limit_seq_show(struct seq_file *seq, void *offset)
 {
         struct acpi_processor *pr = (struct acpi_processor *)seq->private;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_limit_seq_show");
 
         if (!pr)
                 goto end;
@@ -339,7 +334,7 @@ static int acpi_processor_limit_seq_show(struct seq_file *seq, void *offset)
                    pr->limit.thermal.px, pr->limit.thermal.tx);
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_processor_limit_open_fs(struct inode *inode, struct file *file)
@@ -359,36 +354,33 @@ static ssize_t acpi_processor_write_limit(struct file * file,
         int px = 0;
         int tx = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_write_limit");
 
         if (!pr || (count > sizeof(limit_string) - 1)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument\n"));
-                return_VALUE(-EINVAL);
+                return -EINVAL;
         }
 
         if (copy_from_user(limit_string, buffer, count)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data\n"));
-                return_VALUE(-EFAULT);
+                return -EFAULT;
         }
 
         limit_string[count] = '\0';
 
         if (sscanf(limit_string, "%d:%d", &px, &tx) != 2) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data format\n"));
-                return_VALUE(-EINVAL);
+                printk(KERN_ERR PREFIX "Invalid data format\n");
+                return -EINVAL;
         }
 
         if (pr->flags.throttling) {
                 if ((tx < 0) || (tx > (pr->throttling.state_count - 1))) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid tx\n"));
-                        return_VALUE(-EINVAL);
+                        printk(KERN_ERR PREFIX "Invalid tx\n");
+                        return -EINVAL;
                 }
                 pr->limit.user.tx = tx;
         }
 
         result = acpi_processor_apply_limit(pr);
 
-        return_VALUE(count);
+        return count;
 }
 
 struct file_operations acpi_processor_limit_fops = {
diff --git a/drivers/acpi/processor_throttling.c b/drivers/acpi/processor_throttling.c
index b966549ec000..d044ec519db0 100644
--- a/drivers/acpi/processor_throttling.c
+++ b/drivers/acpi/processor_throttling.c
@@ -55,13 +55,12 @@ static int acpi_processor_get_throttling(struct acpi_processor *pr)
         u32 duty_mask = 0;
         u32 duty_value = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_get_throttling");
 
         if (!pr)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (!pr->flags.throttling)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         pr->throttling.state = 0;
 
@@ -93,7 +92,7 @@ static int acpi_processor_get_throttling(struct acpi_processor *pr)
                           "Throttling state is T%d (%d%% throttling applied)\n",
                           state, pr->throttling.states[state].performance));
 
-        return_VALUE(0);
+        return 0;
 }
 
 int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
@@ -102,19 +101,18 @@ int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
         u32 duty_mask = 0;
         u32 duty_value = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_set_throttling");
 
         if (!pr)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if ((state < 0) || (state > (pr->throttling.state_count - 1)))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (!pr->flags.throttling)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         if (state == pr->throttling.state)
-                return_VALUE(0);
+                return 0;
 
         /*
          * Calculate the duty_value and duty_mask.
@@ -165,7 +163,7 @@ int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
                           (pr->throttling.states[state].performance ? pr->
                            throttling.states[state].performance / 10 : 0)));
 
-        return_VALUE(0);
+        return 0;
 }
 
 int acpi_processor_get_throttling_info(struct acpi_processor *pr)
@@ -174,7 +172,6 @@ int acpi_processor_get_throttling_info(struct acpi_processor *pr)
         int step = 0;
         int i = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_get_throttling_info");
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                           "pblk_address[0x%08x] duty_offset[%d] duty_width[%d]\n",
@@ -183,21 +180,21 @@ int acpi_processor_get_throttling_info(struct acpi_processor *pr)
                           pr->throttling.duty_width));
 
         if (!pr)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /* TBD: Support ACPI 2.0 objects */
 
         if (!pr->throttling.address) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling register\n"));
-                return_VALUE(0);
+                return 0;
         } else if (!pr->throttling.duty_width) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling states\n"));
-                return_VALUE(0);
+                return 0;
         }
         /* TBD: Support duty_cycle values that span bit 4. */
         else if ((pr->throttling.duty_offset + pr->throttling.duty_width) > 4) {
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN, "duty_cycle spans bit 4\n"));
-                return_VALUE(0);
+                printk(KERN_WARNING PREFIX "duty_cycle spans bit 4\n");
+                return 0;
         }
 
         /*
@@ -208,7 +205,7 @@ int acpi_processor_get_throttling_info(struct acpi_processor *pr)
         if (errata.piix4.throttle) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                   "Throttling not supported on PIIX4 A- or B-step\n"));
-                return_VALUE(0);
+                return 0;
         }
 
         pr->throttling.state_count = 1 << acpi_fadt.duty_width;
@@ -254,7 +251,7 @@ int acpi_processor_get_throttling_info(struct acpi_processor *pr)
         if (result)
                 pr->flags.throttling = 0;
 
-        return_VALUE(result);
+        return result;
 }
 
 /* proc interface */
@@ -266,7 +263,6 @@ static int acpi_processor_throttling_seq_show(struct seq_file *seq,
         int i = 0;
         int result = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_processor_throttling_seq_show");
 
         if (!pr)
                 goto end;
@@ -296,7 +292,7 @@ static int acpi_processor_throttling_seq_show(struct seq_file *seq,
                             throttling.states[i].performance / 10 : 0));
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_processor_throttling_open_fs(struct inode *inode,
@@ -315,13 +311,12 @@ static ssize_t acpi_processor_write_throttling(struct file * file,
         struct acpi_processor *pr = (struct acpi_processor *)m->private;
         char state_string[12] = { '\0' };
 
-        ACPI_FUNCTION_TRACE("acpi_processor_write_throttling");
 
         if (!pr || (count > sizeof(state_string) - 1))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (copy_from_user(state_string, buffer, count))
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
         state_string[count] = '\0';
 
@@ -329,9 +324,9 @@ static ssize_t acpi_processor_write_throttling(struct file * file,
                                                simple_strtoul(state_string,
                                                               NULL, 0));
         if (result)
-                return_VALUE(result);
+                return result;
 
-        return_VALUE(count);
+        return count;
 }
 
 struct file_operations acpi_processor_throttling_fops = {
diff --git a/drivers/acpi/sbs.c b/drivers/acpi/sbs.c
new file mode 100644
index 000000000000..62bef0b3b614
--- /dev/null
+++ b/drivers/acpi/sbs.c
@@ -0,0 +1,1769 @@
+/*
+ *  acpi_sbs.c - ACPI Smart Battery System Driver ($Revision: 1.16 $)
+ *
+ *  Copyright (c) 2005 Rich Townsend <rhdt@bartol.udel.edu>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or (at
+ *  your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but
+ *  WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/kernel.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <asm/uaccess.h>
+#include <linux/acpi.h>
+#include <linux/i2c.h>
+#include <linux/delay.h>
+
+#include "i2c_ec.h"
+
+#define DEF_CAPACITY_UNIT       3
+#define MAH_CAPACITY_UNIT       1
+#define MWH_CAPACITY_UNIT       2
+#define CAPACITY_UNIT           DEF_CAPACITY_UNIT
+
+#define REQUEST_UPDATE_MODE     1
+#define QUEUE_UPDATE_MODE       2
+
+#define DATA_TYPE_COMMON        0
+#define DATA_TYPE_INFO          1
+#define DATA_TYPE_STATE         2
+#define DATA_TYPE_ALARM         3
+#define DATA_TYPE_AC_STATE      4
+
+extern struct proc_dir_entry *acpi_lock_ac_dir(void);
+extern struct proc_dir_entry *acpi_lock_battery_dir(void);
+extern void acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir);
+extern void acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
+
+#define ACPI_SBS_COMPONENT              0x00080000
+#define ACPI_SBS_CLASS                  "sbs"
+#define ACPI_AC_CLASS                   "ac_adapter"
+#define ACPI_BATTERY_CLASS              "battery"
+#define ACPI_SBS_HID                    "ACPI0002"
+#define ACPI_SBS_DRIVER_NAME            "ACPI Smart Battery System Driver"
+#define ACPI_SBS_DEVICE_NAME            "Smart Battery System"
+#define ACPI_SBS_FILE_INFO              "info"
+#define ACPI_SBS_FILE_STATE             "state"
+#define ACPI_SBS_FILE_ALARM             "alarm"
+#define ACPI_BATTERY_DIR_NAME           "BAT%i"
+#define ACPI_AC_DIR_NAME                "AC0"
+#define ACPI_SBC_SMBUS_ADDR             0x9
+#define ACPI_SBSM_SMBUS_ADDR            0xa
+#define ACPI_SB_SMBUS_ADDR              0xb
+#define ACPI_SBS_AC_NOTIFY_STATUS       0x80
+#define ACPI_SBS_BATTERY_NOTIFY_STATUS  0x80
+#define ACPI_SBS_BATTERY_NOTIFY_INFO    0x81
+
+#define _COMPONENT                      ACPI_SBS_COMPONENT
+
+#define MAX_SBS_BAT                     4
+#define MAX_SMBUS_ERR                   1
+
+ACPI_MODULE_NAME("acpi_sbs");
+
+MODULE_AUTHOR("Rich Townsend");
+MODULE_DESCRIPTION("Smart Battery System ACPI interface driver");
+MODULE_LICENSE("GPL");
+
+static struct semaphore sbs_sem;
+
+#define UPDATE_MODE             QUEUE_UPDATE_MODE
+/* REQUEST_UPDATE_MODE  QUEUE_UPDATE_MODE */
+#define UPDATE_INFO_MODE        0
+#define UPDATE_TIME             60
+#define UPDATE_TIME2            0
+
+static int capacity_mode = CAPACITY_UNIT;
+static int update_mode = UPDATE_MODE;
+static int update_info_mode = UPDATE_INFO_MODE;
+static int update_time = UPDATE_TIME;
+static int update_time2 = UPDATE_TIME2;
+
+module_param(capacity_mode, int, CAPACITY_UNIT);
+module_param(update_mode, int, UPDATE_MODE);
+module_param(update_info_mode, int, UPDATE_INFO_MODE);
+module_param(update_time, int, UPDATE_TIME);
+module_param(update_time2, int, UPDATE_TIME2);
+
+static int acpi_sbs_add(struct acpi_device *device);
+static int acpi_sbs_remove(struct acpi_device *device, int type);
+static void acpi_battery_smbus_err_handler(struct acpi_ec_smbus *smbus);
+static void acpi_sbs_update_queue(void *data);
+
+static struct acpi_driver acpi_sbs_driver = {
+        .name = ACPI_SBS_DRIVER_NAME,
+        .class = ACPI_SBS_CLASS,
+        .ids = ACPI_SBS_HID,
+        .ops = {
+                .add = acpi_sbs_add,
+                .remove = acpi_sbs_remove,
+                },
+};
+
+struct acpi_battery_info {
+        int capacity_mode;
+        s16 full_charge_capacity;
+        s16 design_capacity;
+        s16 design_voltage;
+        int vscale;
+        int ipscale;
+        s16 serial_number;
+        char manufacturer_name[I2C_SMBUS_BLOCK_MAX + 3];
+        char device_name[I2C_SMBUS_BLOCK_MAX + 3];
+        char device_chemistry[I2C_SMBUS_BLOCK_MAX + 3];
+};
+
+struct acpi_battery_state {
+        s16 voltage;
+        s16 amperage;
+        s16 remaining_capacity;
+        s16 average_time_to_empty;
+        s16 average_time_to_full;
+        s16 battery_status;
+};
+
+struct acpi_battery_alarm {
+        s16 remaining_capacity;
+};
+
+struct acpi_battery {
+        int alive;
+        int battery_present;
+        int id;
+        int init_state;
+        struct acpi_sbs *sbs;
+        struct acpi_battery_info info;
+        struct acpi_battery_state state;
+        struct acpi_battery_alarm alarm;
+        struct proc_dir_entry *battery_entry;
+};
+
+struct acpi_sbs {
+        acpi_handle handle;
+        struct acpi_device *device;
+        struct acpi_ec_smbus *smbus;
+        int sbsm_present;
+        int sbsm_batteries_supported;
+        int ac_present;
+        struct proc_dir_entry *ac_entry;
+        struct acpi_battery battery[MAX_SBS_BAT];
+        int update_info_mode;
+        int zombie;
+        int update_time;
+        int update_time2;
+        struct timer_list update_timer;
+};
+
+static void acpi_update_delay(struct acpi_sbs *sbs);
+static int acpi_sbs_update_run(struct acpi_sbs *sbs, int data_type);
+
+/* --------------------------------------------------------------------------
+                               SMBus Communication
+   -------------------------------------------------------------------------- */
+
+static void acpi_battery_smbus_err_handler(struct acpi_ec_smbus *smbus)
+{
+        union i2c_smbus_data data;
+        int result = 0;
+        char *err_str;
+        int err_number;
+
+        data.word = 0;
+
+        result = smbus->adapter.algo->
+            smbus_xfer(&smbus->adapter,
+                       ACPI_SB_SMBUS_ADDR,
+                       0, I2C_SMBUS_READ, 0x16, I2C_SMBUS_BLOCK_DATA, &data);
+
+        err_number = (data.word & 0x000f);
+
+        switch (data.word & 0x000f) {
+        case 0x0000:
+                err_str = "unexpected bus error";
+                break;
+        case 0x0001:
+                err_str = "busy";
+                break;
+        case 0x0002:
+                err_str = "reserved command";
+                break;
+        case 0x0003:
+                err_str = "unsupported command";
+                break;
+        case 0x0004:
+                err_str = "access denied";
+                break;
+        case 0x0005:
+                err_str = "overflow/underflow";
+                break;
+        case 0x0006:
+                err_str = "bad size";
+                break;
+        case 0x0007:
+                err_str = "unknown error";
+                break;
+        default:
+                err_str = "unrecognized error";
+        }
+        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                          "%s: ret %i, err %i\n", err_str, result, err_number));
+}
+
+static int
+acpi_sbs_smbus_read_word(struct acpi_ec_smbus *smbus, int addr, int func,
+                         u16 * word,
+                         void (*err_handler) (struct acpi_ec_smbus * smbus))
+{
+        union i2c_smbus_data data;
+        int result = 0;
+        int i;
+
+        if (err_handler == NULL) {
+                err_handler = acpi_battery_smbus_err_handler;
+        }
+
+        for (i = 0; i < MAX_SMBUS_ERR; i++) {
+                result =
+                    smbus->adapter.algo->smbus_xfer(&smbus->adapter, addr, 0,
+                                                    I2C_SMBUS_READ, func,
+                                                    I2C_SMBUS_WORD_DATA, &data);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "try %i: smbus->adapter.algo->smbus_xfer() failed\n",
+                                          i));
+                        if (err_handler) {
+                                err_handler(smbus);
+                        }
+                } else {
+                        *word = data.word;
+                        break;
+                }
+        }
+
+        return result;
+}
+
+static int
+acpi_sbs_smbus_read_str(struct acpi_ec_smbus *smbus, int addr, int func,
+                        char *str,
+                        void (*err_handler) (struct acpi_ec_smbus * smbus))
+{
+        union i2c_smbus_data data;
+        int result = 0;
+        int i;
+
+        if (err_handler == NULL) {
+                err_handler = acpi_battery_smbus_err_handler;
+        }
+
+        for (i = 0; i < MAX_SMBUS_ERR; i++) {
+                result =
+                    smbus->adapter.algo->smbus_xfer(&smbus->adapter, addr, 0,
+                                                    I2C_SMBUS_READ, func,
+                                                    I2C_SMBUS_BLOCK_DATA,
+                                                    &data);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "try %i: smbus->adapter.algo->smbus_xfer() failed\n",
+                                          i));
+                        if (err_handler) {
+                                err_handler(smbus);
+                        }
+                } else {
+                        strncpy(str, (const char *)data.block + 1,
+                                data.block[0]);
+                        str[data.block[0]] = 0;
+                        break;
+                }
+        }
+
+        return result;
+}
+
+static int
+acpi_sbs_smbus_write_word(struct acpi_ec_smbus *smbus, int addr, int func,
+                          int word,
+                          void (*err_handler) (struct acpi_ec_smbus * smbus))
+{
+        union i2c_smbus_data data;
+        int result = 0;
+        int i;
+
+        if (err_handler == NULL) {
+                err_handler = acpi_battery_smbus_err_handler;
+        }
+
+        data.word = word;
+
+        for (i = 0; i < MAX_SMBUS_ERR; i++) {
+                result =
+                    smbus->adapter.algo->smbus_xfer(&smbus->adapter, addr, 0,
+                                                    I2C_SMBUS_WRITE, func,
+                                                    I2C_SMBUS_WORD_DATA, &data);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "try %i: smbus->adapter.algo"
+                                          "->smbus_xfer() failed\n", i));
+                        if (err_handler) {
+                                err_handler(smbus);
+                        }
+                } else {
+                        break;
+                }
+        }
+
+        return result;
+}
+
+/* --------------------------------------------------------------------------
+                            Smart Battery System Management
+   -------------------------------------------------------------------------- */
+
+/* Smart Battery */
+
+static int acpi_sbs_generate_event(struct acpi_device *device,
+                                   int event, int state, char *bid, char *class)
+{
+        char bid_saved[5];
+        char class_saved[20];
+        int result = 0;
+
+        strcpy(bid_saved, acpi_device_bid(device));
+        strcpy(class_saved, acpi_device_class(device));
+
+        strcpy(acpi_device_bid(device), bid);
+        strcpy(acpi_device_class(device), class);
+
+        result = acpi_bus_generate_event(device, event, state);
+
+        strcpy(acpi_device_bid(device), bid_saved);
+        strcpy(acpi_device_class(device), class_saved);
+
+        return result;
+}
+
+static int acpi_battery_get_present(struct acpi_battery *battery)
+{
+        s16 state;
+        int result = 0;
+        int is_present = 0;
+
+        result = acpi_sbs_smbus_read_word(battery->sbs->smbus,
+                                          ACPI_SBSM_SMBUS_ADDR, 0x01,
+                                          &state, NULL);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed"));
+        }
+        if (!result) {
+                is_present = (state & 0x000f) & (1 << battery->id);
+        }
+        battery->battery_present = is_present;
+
+        return result;
+}
+
+static int acpi_battery_is_present(struct acpi_battery *battery)
+{
+        return (battery->battery_present);
+}
+
+static int acpi_ac_is_present(struct acpi_sbs *sbs)
+{
+        return (sbs->ac_present);
+}
+
+static int acpi_battery_select(struct acpi_battery *battery)
+{
+        struct acpi_ec_smbus *smbus = battery->sbs->smbus;
+        int result = 0;
+        s16 state;
+        int foo;
+
+        if (battery->sbs->sbsm_present) {
+
+                /* Take special care not to knobble other nibbles of
+                 * state (aka selector_state), since
+                 * it causes charging to halt on SBSELs */
+
+                result =
+                    acpi_sbs_smbus_read_word(smbus, ACPI_SBSM_SMBUS_ADDR, 0x01,
+                                             &state, NULL);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_sbs_smbus_read_word() failed\n"));
+                        goto end;
+                }
+
+                foo = (state & 0x0fff) | (1 << (battery->id + 12));
+                result =
+                    acpi_sbs_smbus_write_word(smbus, ACPI_SBSM_SMBUS_ADDR, 0x01,
+                                              foo, NULL);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_sbs_smbus_write_word() failed\n"));
+                        goto end;
+                }
+        }
+
+      end:
+        return result;
+}
+
+static int acpi_sbsm_get_info(struct acpi_sbs *sbs)
+{
+        struct acpi_ec_smbus *smbus = sbs->smbus;
+        int result = 0;
+        s16 battery_system_info;
+
+        result = acpi_sbs_smbus_read_word(smbus, ACPI_SBSM_SMBUS_ADDR, 0x04,
+                                          &battery_system_info, NULL);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed\n"));
+                goto end;
+        }
+
+        sbs->sbsm_batteries_supported = battery_system_info & 0x000f;
+
+      end:
+
+        return result;
+}
+
+static int acpi_battery_get_info(struct acpi_battery *battery)
+{
+        struct acpi_ec_smbus *smbus = battery->sbs->smbus;
+        int result = 0;
+        s16 battery_mode;
+        s16 specification_info;
+
+        result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x03,
+                                          &battery_mode,
+                                          &acpi_battery_smbus_err_handler);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed\n"));
+                goto end;
+        }
+        battery->info.capacity_mode = (battery_mode & 0x8000) >> 15;
+
+        result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x10,
+                                          &battery->info.full_charge_capacity,
+                                          &acpi_battery_smbus_err_handler);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed\n"));
+                goto end;
+        }
+
+        result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x18,
+                                          &battery->info.design_capacity,
+                                          &acpi_battery_smbus_err_handler);
+
+        if (result) {
+                goto end;
+        }
+
+        result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x19,
+                                          &battery->info.design_voltage,
+                                          &acpi_battery_smbus_err_handler);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed\n"));
+                goto end;
+        }
+
+        result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x1a,
+                                          &specification_info,
+                                          &acpi_battery_smbus_err_handler);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed\n"));
+                goto end;
+        }
+
+        switch ((specification_info & 0x0f00) >> 8) {
+        case 1:
+                battery->info.vscale = 10;
+                break;
+        case 2:
+                battery->info.vscale = 100;
+                break;
+        case 3:
+                battery->info.vscale = 1000;
+                break;
+        default:
+                battery->info.vscale = 1;
+        }
+
+        switch ((specification_info & 0xf000) >> 12) {
+        case 1:
+                battery->info.ipscale = 10;
+                break;
+        case 2:
+                battery->info.ipscale = 100;
+                break;
+        case 3:
+                battery->info.ipscale = 1000;
+                break;
+        default:
+                battery->info.ipscale = 1;
+        }
+
+        result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x1c,
+                                          &battery->info.serial_number,
+                                          &acpi_battery_smbus_err_handler);
+        if (result) {
+                goto end;
+        }
+
+        result = acpi_sbs_smbus_read_str(smbus, ACPI_SB_SMBUS_ADDR, 0x20,
+                                         battery->info.manufacturer_name,
+                                         &acpi_battery_smbus_err_handler);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_str() failed\n"));
+                goto end;
+        }
+
+        result = acpi_sbs_smbus_read_str(smbus, ACPI_SB_SMBUS_ADDR, 0x21,
+                                         battery->info.device_name,
+                                         &acpi_battery_smbus_err_handler);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_str() failed\n"));
+                goto end;
+        }
+
+        result = acpi_sbs_smbus_read_str(smbus, ACPI_SB_SMBUS_ADDR, 0x22,
+                                         battery->info.device_chemistry,
+                                         &acpi_battery_smbus_err_handler);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_str() failed\n"));
+                goto end;
+        }
+
+      end:
+        return result;
+}
+
+static void acpi_update_delay(struct acpi_sbs *sbs)
+{
+        if (sbs->zombie) {
+                return;
+        }
+        if (sbs->update_time2 > 0) {
+                msleep(sbs->update_time2 * 1000);
+        }
+}
+
+static int acpi_battery_get_state(struct acpi_battery *battery)
+{
+        struct acpi_ec_smbus *smbus = battery->sbs->smbus;
+        int result = 0;
+
+        acpi_update_delay(battery->sbs);
+        result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x09,
+                                          &battery->state.voltage,
+                                          &acpi_battery_smbus_err_handler);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed\n"));
+                goto end;
+        }
+
+        acpi_update_delay(battery->sbs);
+        result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x0a,
+                                          &battery->state.amperage,
+                                          &acpi_battery_smbus_err_handler);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed\n"));
+                goto end;
+        }
+
+        acpi_update_delay(battery->sbs);
+        result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x0f,
+                                          &battery->state.remaining_capacity,
+                                          &acpi_battery_smbus_err_handler);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed\n"));
+                goto end;
+        }
+
+        acpi_update_delay(battery->sbs);
+        result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x12,
+                                          &battery->state.average_time_to_empty,
+                                          &acpi_battery_smbus_err_handler);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed\n"));
+                goto end;
+        }
+
+        acpi_update_delay(battery->sbs);
+        result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x13,
+                                          &battery->state.average_time_to_full,
+                                          &acpi_battery_smbus_err_handler);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed\n"));
+                goto end;
+        }
+
+        acpi_update_delay(battery->sbs);
+        result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x16,
+                                          &battery->state.battery_status,
+                                          &acpi_battery_smbus_err_handler);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed\n"));
+                goto end;
+        }
+
+        acpi_update_delay(battery->sbs);
+
+      end:
+        return result;
+}
+
+static int acpi_battery_get_alarm(struct acpi_battery *battery)
+{
+        struct acpi_ec_smbus *smbus = battery->sbs->smbus;
+        int result = 0;
+
+        result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x01,
+                                          &battery->alarm.remaining_capacity,
+                                          &acpi_battery_smbus_err_handler);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed\n"));
+                goto end;
+        }
+
+        acpi_update_delay(battery->sbs);
+
+      end:
+
+        return result;
+}
+
+static int acpi_battery_set_alarm(struct acpi_battery *battery,
+                                  unsigned long alarm)
+{
+        struct acpi_ec_smbus *smbus = battery->sbs->smbus;
+        int result = 0;
+        s16 battery_mode;
+        int foo;
+
+        result = acpi_battery_select(battery);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_battery_select() failed\n"));
+                goto end;
+        }
+
+        /* If necessary, enable the alarm */
+
+        if (alarm > 0) {
+                result =
+                    acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x03,
+                                             &battery_mode,
+                                             &acpi_battery_smbus_err_handler);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_sbs_smbus_read_word() failed\n"));
+                        goto end;
+                }
+
+                result =
+                    acpi_sbs_smbus_write_word(smbus, ACPI_SB_SMBUS_ADDR, 0x01,
+                                              battery_mode & 0xbfff,
+                                              &acpi_battery_smbus_err_handler);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_sbs_smbus_write_word() failed\n"));
+                        goto end;
+                }
+        }
+
+        foo = alarm / (battery->info.capacity_mode ? 10 : 1);
+        result = acpi_sbs_smbus_write_word(smbus, ACPI_SB_SMBUS_ADDR, 0x01,
+                                           foo,
+                                           &acpi_battery_smbus_err_handler);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_write_word() failed\n"));
+                goto end;
+        }
+
+      end:
+
+        return result;
+}
+
+static int acpi_battery_set_mode(struct acpi_battery *battery)
+{
+        int result = 0;
+        s16 battery_mode;
+
+        if (capacity_mode == DEF_CAPACITY_UNIT) {
+                goto end;
+        }
+
+        result = acpi_sbs_smbus_read_word(battery->sbs->smbus,
+                                          ACPI_SB_SMBUS_ADDR, 0x03,
+                                          &battery_mode, NULL);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed\n"));
+                goto end;
+        }
+
+        if (capacity_mode == MAH_CAPACITY_UNIT) {
+                battery_mode &= 0x7fff;
+        } else {
+                battery_mode |= 0x8000;
+        }
+        result = acpi_sbs_smbus_write_word(battery->sbs->smbus,
+                                           ACPI_SB_SMBUS_ADDR, 0x03,
+                                           battery_mode, NULL);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_write_word() failed\n"));
+                goto end;
+        }
+
+        result = acpi_sbs_smbus_read_word(battery->sbs->smbus,
+                                          ACPI_SB_SMBUS_ADDR, 0x03,
+                                          &battery_mode, NULL);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed\n"));
+                goto end;
+        }
+
+      end:
+        return result;
+}
+
+static int acpi_battery_init(struct acpi_battery *battery)
+{
+        int result = 0;
+
+        result = acpi_battery_select(battery);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_battery_init() failed\n"));
+                goto end;
+        }
+
+        result = acpi_battery_set_mode(battery);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_battery_set_mode() failed\n"));
+                goto end;
+        }
+
+        result = acpi_battery_get_info(battery);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_battery_get_info() failed\n"));
+                goto end;
+        }
+
+        result = acpi_battery_get_state(battery);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_battery_get_state() failed\n"));
+                goto end;
+        }
+
+        result = acpi_battery_get_alarm(battery);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_battery_get_alarm() failed\n"));
+                goto end;
+        }
+
+      end:
+        return result;
+}
+
+static int acpi_ac_get_present(struct acpi_sbs *sbs)
+{
+        struct acpi_ec_smbus *smbus = sbs->smbus;
+        int result = 0;
+        s16 charger_status;
+
+        result = acpi_sbs_smbus_read_word(smbus, ACPI_SBC_SMBUS_ADDR, 0x13,
+                                          &charger_status, NULL);
+
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_smbus_read_word() failed\n"));
+                goto end;
+        }
+
+        sbs->ac_present = (charger_status & 0x8000) >> 15;
+
+      end:
+
+        return result;
+}
+
+/* --------------------------------------------------------------------------
+                              FS Interface (/proc/acpi)
+   -------------------------------------------------------------------------- */
+
+/* Generic Routines */
+
+static int
+acpi_sbs_generic_add_fs(struct proc_dir_entry **dir,
+                        struct proc_dir_entry *parent_dir,
+                        char *dir_name,
+                        struct file_operations *info_fops,
+                        struct file_operations *state_fops,
+                        struct file_operations *alarm_fops, void *data)
+{
+        struct proc_dir_entry *entry = NULL;
+
+        if (!*dir) {
+                *dir = proc_mkdir(dir_name, parent_dir);
+                if (!*dir) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "proc_mkdir() failed\n"));
+                        return -ENODEV;
+                }
+                (*dir)->owner = THIS_MODULE;
+        }
+
+        /* 'info' [R] */
+        if (info_fops) {
+                entry = create_proc_entry(ACPI_SBS_FILE_INFO, S_IRUGO, *dir);
+                if (!entry) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "create_proc_entry() failed\n"));
+                } else {
+                        entry->proc_fops = info_fops;
+                        entry->data = data;
+                        entry->owner = THIS_MODULE;
+                }
+        }
+
+        /* 'state' [R] */
+        if (state_fops) {
+                entry = create_proc_entry(ACPI_SBS_FILE_STATE, S_IRUGO, *dir);
+                if (!entry) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "create_proc_entry() failed\n"));
+                } else {
+                        entry->proc_fops = state_fops;
+                        entry->data = data;
+                        entry->owner = THIS_MODULE;
+                }
+        }
+
+        /* 'alarm' [R/W] */
+        if (alarm_fops) {
+                entry = create_proc_entry(ACPI_SBS_FILE_ALARM, S_IRUGO, *dir);
+                if (!entry) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "create_proc_entry() failed\n"));
+                } else {
+                        entry->proc_fops = alarm_fops;
+                        entry->data = data;
+                        entry->owner = THIS_MODULE;
+                }
+        }
+
+        return 0;
+}
+
+static void
+acpi_sbs_generic_remove_fs(struct proc_dir_entry **dir,
+                           struct proc_dir_entry *parent_dir)
+{
+
+        if (*dir) {
+                remove_proc_entry(ACPI_SBS_FILE_INFO, *dir);
+                remove_proc_entry(ACPI_SBS_FILE_STATE, *dir);
+                remove_proc_entry(ACPI_SBS_FILE_ALARM, *dir);
+                remove_proc_entry((*dir)->name, parent_dir);
+                *dir = NULL;
+        }
+
+}
+
+/* Smart Battery Interface */
+
+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;
+        int cscale;
+        int result = 0;
+
+        if (battery->sbs->zombie) {
+                return -ENODEV;
+        }
+
+        down(&sbs_sem);
+
+        if (update_mode == REQUEST_UPDATE_MODE) {
+                result = acpi_sbs_update_run(battery->sbs, DATA_TYPE_INFO);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_sbs_update_run() failed\n"));
+                }
+        }
+
+        if (acpi_battery_is_present(battery)) {
+                seq_printf(seq, "present:                 yes\n");
+        } else {
+                seq_printf(seq, "present:                 no\n");
+                goto end;
+        }
+
+        if (battery->info.capacity_mode) {
+                cscale = battery->info.vscale * battery->info.ipscale;
+        } else {
+                cscale = battery->info.ipscale;
+        }
+        seq_printf(seq, "design capacity:         %i%s",
+                   battery->info.design_capacity * cscale,
+                   battery->info.capacity_mode ? "0 mWh\n" : " mAh\n");
+
+        seq_printf(seq, "last full capacity:      %i%s",
+                   battery->info.full_charge_capacity * cscale,
+                   battery->info.capacity_mode ? "0 mWh\n" : " mAh\n");
+
+        seq_printf(seq, "battery technology:      rechargeable\n");
+
+        seq_printf(seq, "design voltage:          %i mV\n",
+                   battery->info.design_voltage * battery->info.vscale);
+
+        seq_printf(seq, "design capacity warning: unknown\n");
+        seq_printf(seq, "design capacity low:     unknown\n");
+        seq_printf(seq, "capacity granularity 1:  unknown\n");
+        seq_printf(seq, "capacity granularity 2:  unknown\n");
+
+        seq_printf(seq, "model number:            %s\n",
+                   battery->info.device_name);
+
+        seq_printf(seq, "serial number:           %i\n",
+                   battery->info.serial_number);
+
+        seq_printf(seq, "battery type:            %s\n",
+                   battery->info.device_chemistry);
+
+        seq_printf(seq, "OEM info:                %s\n",
+                   battery->info.manufacturer_name);
+
+      end:
+
+        up(&sbs_sem);
+
+        return result;
+}
+
+static int acpi_battery_info_open_fs(struct inode *inode, struct file *file)
+{
+        return single_open(file, acpi_battery_read_info, PDE(inode)->data);
+}
+
+static int acpi_battery_read_state(struct seq_file *seq, void *offset)
+{
+        struct acpi_battery *battery = (struct acpi_battery *)seq->private;
+        int result = 0;
+        int cscale;
+        int foo;
+
+        if (battery->sbs->zombie) {
+                return -ENODEV;
+        }
+
+        down(&sbs_sem);
+
+        if (update_mode == REQUEST_UPDATE_MODE) {
+                result = acpi_sbs_update_run(battery->sbs, DATA_TYPE_STATE);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_sbs_update_run() failed\n"));
+                }
+        }
+
+        if (acpi_battery_is_present(battery)) {
+                seq_printf(seq, "present:                 yes\n");
+        } else {
+                seq_printf(seq, "present:                 no\n");
+                goto end;
+        }
+
+        if (battery->info.capacity_mode) {
+                cscale = battery->info.vscale * battery->info.ipscale;
+        } else {
+                cscale = battery->info.ipscale;
+        }
+
+        if (battery->state.battery_status & 0x0010) {
+                seq_printf(seq, "capacity state:          critical\n");
+        } else {
+                seq_printf(seq, "capacity state:          ok\n");
+        }
+        if (battery->state.amperage < 0) {
+                seq_printf(seq, "charging state:          discharging\n");
+                foo = battery->state.remaining_capacity * cscale * 60 /
+                    (battery->state.average_time_to_empty == 0 ? 1 :
+                     battery->state.average_time_to_empty);
+                seq_printf(seq, "present rate:            %i%s\n",
+                           foo, battery->info.capacity_mode ? "0 mW" : " mA");
+        } else if (battery->state.amperage > 0) {
+                seq_printf(seq, "charging state:          charging\n");
+                foo = (battery->info.full_charge_capacity -
+                       battery->state.remaining_capacity) * cscale * 60 /
+                    (battery->state.average_time_to_full == 0 ? 1 :
+                     battery->state.average_time_to_full);
+                seq_printf(seq, "present rate:            %i%s\n",
+                           foo, battery->info.capacity_mode ? "0 mW" : " mA");
+        } else {
+                seq_printf(seq, "charging state:          charged\n");
+                seq_printf(seq, "present rate:            0 %s\n",
+                           battery->info.capacity_mode ? "mW" : "mA");
+        }
+
+        seq_printf(seq, "remaining capacity:      %i%s",
+                   battery->state.remaining_capacity * cscale,
+                   battery->info.capacity_mode ? "0 mWh\n" : " mAh\n");
+
+        seq_printf(seq, "present voltage:         %i mV\n",
+                   battery->state.voltage * battery->info.vscale);
+
+      end:
+
+        up(&sbs_sem);
+
+        return result;
+}
+
+static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
+{
+        return single_open(file, acpi_battery_read_state, PDE(inode)->data);
+}
+
+static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
+{
+        struct acpi_battery *battery = (struct acpi_battery *)seq->private;
+        int result = 0;
+        int cscale;
+
+        if (battery->sbs->zombie) {
+                return -ENODEV;
+        }
+
+        down(&sbs_sem);
+
+        if (update_mode == REQUEST_UPDATE_MODE) {
+                result = acpi_sbs_update_run(battery->sbs, DATA_TYPE_ALARM);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_sbs_update_run() failed\n"));
+                }
+        }
+
+        if (!acpi_battery_is_present(battery)) {
+                seq_printf(seq, "present:                 no\n");
+                goto end;
+        }
+
+        if (battery->info.capacity_mode) {
+                cscale = battery->info.vscale * battery->info.ipscale;
+        } else {
+                cscale = battery->info.ipscale;
+        }
+
+        seq_printf(seq, "alarm:                   ");
+        if (battery->alarm.remaining_capacity) {
+                seq_printf(seq, "%i%s",
+                           battery->alarm.remaining_capacity * cscale,
+                           battery->info.capacity_mode ? "0 mWh\n" : " mAh\n");
+        } else {
+                seq_printf(seq, "disabled\n");
+        }
+
+      end:
+
+        up(&sbs_sem);
+
+        return result;
+}
+
+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 acpi_battery *battery = (struct acpi_battery *)seq->private;
+        char alarm_string[12] = { '\0' };
+        int result, old_alarm, new_alarm;
+
+        if (battery->sbs->zombie) {
+                return -ENODEV;
+        }
+
+        down(&sbs_sem);
+
+        if (!acpi_battery_is_present(battery)) {
+                result = -ENODEV;
+                goto end;
+        }
+
+        if (count > sizeof(alarm_string) - 1) {
+                result = -EINVAL;
+                goto end;
+        }
+
+        if (copy_from_user(alarm_string, buffer, count)) {
+                result = -EFAULT;
+                goto end;
+        }
+
+        alarm_string[count] = 0;
+
+        old_alarm = battery->alarm.remaining_capacity;
+        new_alarm = simple_strtoul(alarm_string, NULL, 0);
+
+        result = acpi_battery_set_alarm(battery, new_alarm);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_battery_set_alarm() failed\n"));
+                (void)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);
+                goto end;
+        }
+
+      end:
+        up(&sbs_sem);
+
+        if (result) {
+                return result;
+        } else {
+                return count;
+        }
+}
+
+static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file)
+{
+        return single_open(file, acpi_battery_read_alarm, PDE(inode)->data);
+}
+
+static struct file_operations acpi_battery_info_fops = {
+        .open = acpi_battery_info_open_fs,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static struct file_operations acpi_battery_state_fops = {
+        .open = acpi_battery_state_open_fs,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static struct file_operations acpi_battery_alarm_fops = {
+        .open = acpi_battery_alarm_open_fs,
+        .read = seq_read,
+        .write = acpi_battery_write_alarm,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+/* Legacy AC Adapter Interface */
+
+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;
+        int result;
+
+        if (sbs->zombie) {
+                return -ENODEV;
+        }
+
+        down(&sbs_sem);
+
+        if (update_mode == REQUEST_UPDATE_MODE) {
+                result = acpi_sbs_update_run(sbs, DATA_TYPE_AC_STATE);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_sbs_update_run() failed\n"));
+                }
+        }
+
+        seq_printf(seq, "state:                   %s\n",
+                   sbs->ac_present ? "on-line" : "off-line");
+
+        up(&sbs_sem);
+
+        return 0;
+}
+
+static int acpi_ac_state_open_fs(struct inode *inode, struct file *file)
+{
+        return single_open(file, acpi_ac_read_state, PDE(inode)->data);
+}
+
+static struct file_operations acpi_ac_state_fops = {
+        .open = acpi_ac_state_open_fs,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+/* --------------------------------------------------------------------------
+                                 Driver Interface
+   -------------------------------------------------------------------------- */
+
+/* Smart Battery */
+
+static int acpi_battery_add(struct acpi_sbs *sbs, int id)
+{
+        int is_present;
+        int result;
+        char dir_name[32];
+        struct acpi_battery *battery;
+
+        battery = &sbs->battery[id];
+
+        battery->alive = 0;
+
+        battery->init_state = 0;
+        battery->id = id;
+        battery->sbs = sbs;
+
+        result = acpi_battery_select(battery);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_battery_select() failed\n"));
+                goto end;
+        }
+
+        result = acpi_battery_get_present(battery);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_battery_get_present() failed\n"));
+                goto end;
+        }
+
+        is_present = acpi_battery_is_present(battery);
+
+        if (is_present) {
+                result = acpi_battery_init(battery);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_battery_init() failed\n"));
+                        goto end;
+                }
+                battery->init_state = 1;
+        }
+
+        (void)sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
+
+        result = acpi_sbs_generic_add_fs(&battery->battery_entry,
+                                         acpi_battery_dir,
+                                         dir_name,
+                                         &acpi_battery_info_fops,
+                                         &acpi_battery_state_fops,
+                                         &acpi_battery_alarm_fops, battery);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_generic_add_fs() failed\n"));
+                goto end;
+        }
+        battery->alive = 1;
+
+      end:
+        return result;
+}
+
+static void acpi_battery_remove(struct acpi_sbs *sbs, int id)
+{
+
+        if (sbs->battery[id].battery_entry) {
+                acpi_sbs_generic_remove_fs(&(sbs->battery[id].battery_entry),
+                                           acpi_battery_dir);
+        }
+}
+
+static int acpi_ac_add(struct acpi_sbs *sbs)
+{
+        int result;
+
+        result = acpi_ac_get_present(sbs);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_ac_get_present() failed\n"));
+                goto end;
+        }
+
+        result = acpi_sbs_generic_add_fs(&sbs->ac_entry,
+                                         acpi_ac_dir,
+                                         ACPI_AC_DIR_NAME,
+                                         NULL, &acpi_ac_state_fops, NULL, sbs);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_generic_add_fs() failed\n"));
+                goto end;
+        }
+
+      end:
+
+        return result;
+}
+
+static void acpi_ac_remove(struct acpi_sbs *sbs)
+{
+
+        if (sbs->ac_entry) {
+                acpi_sbs_generic_remove_fs(&sbs->ac_entry, acpi_ac_dir);
+        }
+}
+
+static void acpi_sbs_update_queue_run(unsigned long data)
+{
+        acpi_os_execute(OSL_GPE_HANDLER, acpi_sbs_update_queue, (void *)data);
+}
+
+static int acpi_sbs_update_run(struct acpi_sbs *sbs, int data_type)
+{
+        struct acpi_battery *battery;
+        int result = 0;
+        int old_ac_present;
+        int old_battery_present;
+        int new_ac_present;
+        int new_battery_present;
+        int id;
+        char dir_name[32];
+        int do_battery_init, do_ac_init;
+        s16 old_remaining_capacity;
+
+        if (sbs->zombie) {
+                goto end;
+        }
+
+        old_ac_present = acpi_ac_is_present(sbs);
+
+        result = acpi_ac_get_present(sbs);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_ac_get_present() failed\n"));
+        }
+
+        new_ac_present = acpi_ac_is_present(sbs);
+
+        do_ac_init = (old_ac_present != new_ac_present);
+
+        if (data_type == DATA_TYPE_AC_STATE) {
+                goto end;
+        }
+
+        for (id = 0; id < MAX_SBS_BAT; id++) {
+                battery = &sbs->battery[id];
+                if (battery->alive == 0) {
+                        continue;
+                }
+
+                old_remaining_capacity = battery->state.remaining_capacity;
+
+                old_battery_present = acpi_battery_is_present(battery);
+
+                result = acpi_battery_select(battery);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_battery_select() failed\n"));
+                }
+                if (sbs->zombie) {
+                        goto end;
+                }
+
+                result = acpi_battery_get_present(battery);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_battery_get_present() failed\n"));
+                }
+                if (sbs->zombie) {
+                        goto end;
+                }
+
+                new_battery_present = acpi_battery_is_present(battery);
+
+                do_battery_init = ((old_battery_present != new_battery_present)
+                                   && new_battery_present);
+
+                if (sbs->zombie) {
+                        goto end;
+                }
+                if (do_ac_init || do_battery_init ||
+                    update_info_mode || sbs->update_info_mode) {
+                        if (sbs->update_info_mode) {
+                                sbs->update_info_mode = 0;
+                        } else {
+                                sbs->update_info_mode = 1;
+                        }
+                        result = acpi_battery_init(battery);
+                        if (result) {
+                                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                                  "acpi_battery_init() "
+                                                  "failed\n"));
+                        }
+                }
+                if (data_type == DATA_TYPE_INFO) {
+                        continue;
+                }
+
+                if (sbs->zombie) {
+                        goto end;
+                }
+                if (new_battery_present) {
+                        result = acpi_battery_get_alarm(battery);
+                        if (result) {
+                                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                                  "acpi_battery_get_alarm() "
+                                                  "failed\n"));
+                        }
+                        if (data_type == DATA_TYPE_ALARM) {
+                                continue;
+                        }
+
+                        result = acpi_battery_get_state(battery);
+                        if (result) {
+                                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                                  "acpi_battery_get_state() "
+                                                  "failed\n"));
+                        }
+                }
+                if (sbs->zombie) {
+                        goto end;
+                }
+                if (data_type != DATA_TYPE_COMMON) {
+                        continue;
+                }
+
+                if (old_battery_present != new_battery_present) {
+                        (void)sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
+                        result = acpi_sbs_generate_event(sbs->device,
+                                                         ACPI_SBS_BATTERY_NOTIFY_STATUS,
+                                                         new_battery_present,
+                                                         dir_name,
+                                                         ACPI_BATTERY_CLASS);
+                        if (result) {
+                                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                                  "acpi_sbs_generate_event() "
+                                                  "failed\n"));
+                        }
+                }
+                if (old_remaining_capacity != battery->state.remaining_capacity) {
+                        (void)sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
+                        result = acpi_sbs_generate_event(sbs->device,
+                                                         ACPI_SBS_BATTERY_NOTIFY_STATUS,
+                                                         new_battery_present,
+                                                         dir_name,
+                                                         ACPI_BATTERY_CLASS);
+                        if (result) {
+                                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                                  "acpi_sbs_generate_event() failed\n"));
+                        }
+                }
+
+        }
+        if (sbs->zombie) {
+                goto end;
+        }
+        if (data_type != DATA_TYPE_COMMON) {
+                goto end;
+        }
+
+        if (old_ac_present != new_ac_present) {
+                result = acpi_sbs_generate_event(sbs->device,
+                                                 ACPI_SBS_AC_NOTIFY_STATUS,
+                                                 new_ac_present,
+                                                 ACPI_AC_DIR_NAME,
+                                                 ACPI_AC_CLASS);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_sbs_generate_event() failed\n"));
+                }
+        }
+
+      end:
+        return result;
+}
+
+static void acpi_sbs_update_queue(void *data)
+{
+        struct acpi_sbs *sbs = data;
+        unsigned long delay = -1;
+        int result;
+
+        if (sbs->zombie) {
+                goto end;
+        }
+
+        result = acpi_sbs_update_run(sbs, DATA_TYPE_COMMON);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_sbs_update_run() failed\n"));
+        }
+
+        if (sbs->zombie) {
+                goto end;
+        }
+
+        if (update_mode == REQUEST_UPDATE_MODE) {
+                goto end;
+        }
+
+        delay = jiffies + HZ * update_time;
+        sbs->update_timer.data = (unsigned long)data;
+        sbs->update_timer.function = acpi_sbs_update_queue_run;
+        sbs->update_timer.expires = delay;
+        add_timer(&sbs->update_timer);
+      end:
+        ;
+}
+
+static int acpi_sbs_add(struct acpi_device *device)
+{
+        struct acpi_sbs *sbs = NULL;
+        struct acpi_ec_hc *ec_hc = NULL;
+        int result, remove_result = 0;
+        unsigned long sbs_obj;
+        int id, cnt;
+        acpi_status status = AE_OK;
+
+        sbs = kmalloc(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) {
+                cnt++;
+                ec_hc = acpi_get_ec_hc(device);
+                if (ec_hc) {
+                        break;
+                }
+                msleep(1000);
+        }
+
+        if (!ec_hc) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_get_ec_hc() failed: "
+                                  "NO driver found for EC HC SMBus\n"));
+                result = -ENODEV;
+                goto end;
+        }
+
+        sbs->device = device;
+        sbs->smbus = ec_hc->smbus;
+
+        strcpy(acpi_device_name(device), ACPI_SBS_DEVICE_NAME);
+        strcpy(acpi_device_class(device), ACPI_SBS_CLASS);
+        acpi_driver_data(device) = sbs;
+
+        sbs->update_time = 0;
+        sbs->update_time2 = 0;
+
+        result = acpi_ac_add(sbs);
+        if (result) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "acpi_ac_add() failed\n"));
+                goto end;
+        }
+        result = acpi_evaluate_integer(device->handle, "_SBS", NULL, &sbs_obj);
+        if (ACPI_FAILURE(result)) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_evaluate_integer() failed\n"));
+                result = -EIO;
+                goto end;
+        }
+
+        if (sbs_obj > 0) {
+                result = acpi_sbsm_get_info(sbs);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_sbsm_get_info() failed\n"));
+                        goto end;
+                }
+                sbs->sbsm_present = 1;
+        }
+        if (sbs->sbsm_present == 0) {
+                result = acpi_battery_add(sbs, 0);
+                if (result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_battery_add() failed\n"));
+                        goto end;
+                }
+        } else {
+                for (id = 0; id < MAX_SBS_BAT; id++) {
+                        if ((sbs->sbsm_batteries_supported & (1 << id))) {
+                                result = acpi_battery_add(sbs, id);
+                                if (result) {
+                                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                                          "acpi_battery_add() "
+                                                          "failed\n"));
+                                        goto end;
+                                }
+                        }
+                }
+        }
+
+        sbs->handle = device->handle;
+
+        init_timer(&sbs->update_timer);
+        if (update_mode == QUEUE_UPDATE_MODE) {
+                status = acpi_os_execute(OSL_GPE_HANDLER,
+                                         acpi_sbs_update_queue, (void *)sbs);
+                if (status != AE_OK) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_os_execute() failed\n"));
+                }
+        }
+        sbs->update_time = update_time;
+        sbs->update_time2 = update_time2;
+
+        printk(KERN_INFO PREFIX "%s [%s]\n",
+               acpi_device_name(device), acpi_device_bid(device));
+
+      end:
+        if (result) {
+                remove_result = acpi_sbs_remove(device, 0);
+                if (remove_result) {
+                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                          "acpi_sbs_remove() failed\n"));
+                }
+        }
+
+        return result;
+}
+
+int acpi_sbs_remove(struct acpi_device *device, int type)
+{
+        struct acpi_sbs *sbs = (struct acpi_sbs *)acpi_driver_data(device);
+        int id;
+
+        if (!device || !sbs) {
+                return -EINVAL;
+        }
+
+        sbs->zombie = 1;
+        sbs->update_time = 0;
+        sbs->update_time2 = 0;
+        del_timer_sync(&sbs->update_timer);
+        acpi_os_wait_events_complete(NULL);
+        del_timer_sync(&sbs->update_timer);
+
+        for (id = 0; id < MAX_SBS_BAT; id++) {
+                acpi_battery_remove(sbs, id);
+        }
+
+        acpi_ac_remove(sbs);
+
+        kfree(sbs);
+
+        return 0;
+}
+
+static int __init acpi_sbs_init(void)
+{
+        int result = 0;
+
+        if (acpi_disabled)
+                return -ENODEV;
+
+        init_MUTEX(&sbs_sem);
+
+        if (capacity_mode != DEF_CAPACITY_UNIT
+            && capacity_mode != MAH_CAPACITY_UNIT
+            && capacity_mode != MWH_CAPACITY_UNIT) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "acpi_sbs_init: "
+                                  "invalid capacity_mode = %d\n",
+                                  capacity_mode));
+                return -EINVAL;
+        }
+
+        acpi_ac_dir = acpi_lock_ac_dir();
+        if (!acpi_ac_dir) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_lock_ac_dir() failed\n"));
+                return -ENODEV;
+        }
+
+        acpi_battery_dir = acpi_lock_battery_dir();
+        if (!acpi_battery_dir) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_lock_battery_dir() failed\n"));
+                return -ENODEV;
+        }
+
+        result = acpi_bus_register_driver(&acpi_sbs_driver);
+        if (result < 0) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+                                  "acpi_bus_register_driver() failed\n"));
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static void __exit acpi_sbs_exit(void)
+{
+
+        acpi_bus_unregister_driver(&acpi_sbs_driver);
+
+        acpi_unlock_ac_dir(acpi_ac_dir);
+        acpi_ac_dir = NULL;
+        acpi_unlock_battery_dir(acpi_battery_dir);
+        acpi_battery_dir = NULL;
+
+        return;
+}
+
+module_init(acpi_sbs_init);
+module_exit(acpi_sbs_exit);
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index f8316a05ede7..698a1540e303 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -4,6 +4,7 @@
 
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/kernel.h>
 #include <linux/acpi.h>
 
 #include <acpi/acpi_drivers.h>
@@ -113,6 +114,8 @@ static struct kset acpi_namespace_kset = {
 static void acpi_device_register(struct acpi_device *device,
                                  struct acpi_device *parent)
 {
+        int err;
+
         /*
          * Linkage
          * -------
@@ -138,7 +141,10 @@ static void acpi_device_register(struct acpi_device *device,
                 device->kobj.parent = &parent->kobj;
         device->kobj.ktype = &ktype_acpi_ns;
         device->kobj.kset = &acpi_namespace_kset;
-        kobject_register(&device->kobj);
+        err = kobject_register(&device->kobj);
+        if (err < 0)
+                printk(KERN_WARNING "%s: kobject_register error: %d\n",
+                        __FUNCTION__, err);
         create_sysfs_device_files(device);
 }
 
@@ -162,11 +168,10 @@ static void acpi_device_unregister(struct acpi_device *device, int type)
 
 void acpi_bus_data_handler(acpi_handle handle, u32 function, void *context)
 {
-        ACPI_FUNCTION_TRACE("acpi_bus_data_handler");
 
         /* TBD */
 
-        return_VOID;
+        return;
 }
 
 static int acpi_bus_get_power_flags(struct acpi_device *device)
@@ -175,7 +180,6 @@ static int acpi_bus_get_power_flags(struct acpi_device *device)
         acpi_handle handle = NULL;
         u32 i = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_get_power_flags");
 
         /*
          * Power Management Flags
@@ -228,7 +232,7 @@ static int acpi_bus_get_power_flags(struct acpi_device *device)
 
         device->power.state = ACPI_STATE_UNKNOWN;
 
-        return_VALUE(0);
+        return 0;
 }
 
 int acpi_match_ids(struct acpi_device *device, char *ids)
@@ -306,24 +310,22 @@ static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *package = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_get_wakeup_flags");
 
         /* _PRW */
         status = acpi_evaluate_object(device->handle, "_PRW", NULL, &buffer);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PRW\n"));
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
                 goto end;
         }
 
         package = (union acpi_object *)buffer.pointer;
         status = acpi_bus_extract_wakeup_device_power_package(device, package);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error extracting _PRW package\n"));
+                ACPI_EXCEPTION((AE_INFO, status, "Extracting _PRW package"));
                 goto end;
         }
 
-        acpi_os_free(buffer.pointer);
+        kfree(buffer.pointer);
 
         device->wakeup.flags.valid = 1;
         /* Power button, Lid switch always enable wakeup */
@@ -333,7 +335,7 @@ static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
       end:
         if (ACPI_FAILURE(status))
                 device->flags.wake_capable = 0;
-        return_VALUE(0);
+        return 0;
 }
 
 /* --------------------------------------------------------------------------
@@ -489,19 +491,18 @@ acpi_bus_driver_init(struct acpi_device *device, struct acpi_driver *driver)
 {
         int result = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_driver_init");
 
         if (!device || !driver)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (!driver->ops.add)
-                return_VALUE(-ENOSYS);
+                return -ENOSYS;
 
         result = driver->ops.add(device);
         if (result) {
                 device->driver = NULL;
                 acpi_driver_data(device) = NULL;
-                return_VALUE(result);
+                return result;
         }
 
         device->driver = driver;
@@ -513,7 +514,7 @@ acpi_bus_driver_init(struct acpi_device *device, struct acpi_driver *driver)
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                           "Driver successfully bound to device\n"));
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_start_single_object(struct acpi_device *device)
@@ -521,10 +522,9 @@ static int acpi_start_single_object(struct acpi_device *device)
         int result = 0;
         struct acpi_driver *driver;
 
-        ACPI_FUNCTION_TRACE("acpi_start_single_object");
 
         if (!(driver = device->driver))
-                return_VALUE(0);
+                return 0;
 
         if (driver->ops.start) {
                 result = driver->ops.start(device);
@@ -532,14 +532,13 @@ static int acpi_start_single_object(struct acpi_device *device)
                         driver->ops.remove(device, ACPI_BUS_REMOVAL_NORMAL);
         }
 
-        return_VALUE(result);
+        return result;
 }
 
 static void acpi_driver_attach(struct acpi_driver *drv)
 {
         struct list_head *node, *next;
 
-        ACPI_FUNCTION_TRACE("acpi_driver_attach");
 
         spin_lock(&acpi_device_lock);
         list_for_each_safe(node, next, &acpi_device_list) {
@@ -568,7 +567,6 @@ static void acpi_driver_detach(struct acpi_driver *drv)
 {
         struct list_head *node, *next;
 
-        ACPI_FUNCTION_TRACE("acpi_driver_detach");
 
         spin_lock(&acpi_device_lock);
         list_for_each_safe(node, next, &acpi_device_list) {
@@ -598,17 +596,16 @@ static void acpi_driver_detach(struct acpi_driver *drv)
  */
 int acpi_bus_register_driver(struct acpi_driver *driver)
 {
-        ACPI_FUNCTION_TRACE("acpi_bus_register_driver");
 
         if (acpi_disabled)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         spin_lock(&acpi_device_lock);
         list_add_tail(&driver->node, &acpi_bus_drivers);
         spin_unlock(&acpi_device_lock);
         acpi_driver_attach(driver);
 
-        return_VALUE(0);
+        return 0;
 }
 
 EXPORT_SYMBOL(acpi_bus_register_driver);
@@ -646,7 +643,6 @@ static int acpi_bus_find_driver(struct acpi_device *device)
         int result = 0;
         struct list_head *node, *next;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_find_driver");
 
         spin_lock(&acpi_device_lock);
         list_for_each_safe(node, next, &acpi_bus_drivers) {
@@ -666,19 +662,41 @@ static int acpi_bus_find_driver(struct acpi_device *device)
         spin_unlock(&acpi_device_lock);
 
       Done:
-        return_VALUE(result);
+        return result;
 }
 
 /* --------------------------------------------------------------------------
                                  Device Enumeration
    -------------------------------------------------------------------------- */
 
+acpi_status
+acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
+{
+        acpi_status status;
+        acpi_handle tmp;
+        struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
+        union acpi_object *obj;
+
+        status = acpi_get_handle(handle, "_EJD", &tmp);
+        if (ACPI_FAILURE(status))
+                return status;
+
+        status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
+        if (ACPI_SUCCESS(status)) {
+                obj = buffer.pointer;
+                status = acpi_get_handle(NULL, obj->string.pointer, ejd);
+                kfree(buffer.pointer);
+        }
+        return status;
+}
+EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
+
+
 static int acpi_bus_get_flags(struct acpi_device *device)
 {
         acpi_status status = AE_OK;
         acpi_handle temp = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_get_flags");
 
         /* Presence of _STA indicates 'dynamic_status' */
         status = acpi_get_handle(device->handle, "_STA", &temp);
@@ -724,7 +742,7 @@ static int acpi_bus_get_flags(struct acpi_device *device)
 
         /* TBD: Peformance management */
 
-        return_VALUE(0);
+        return 0;
 }
 
 static void acpi_device_get_busid(struct acpi_device *device,
@@ -842,7 +860,7 @@ static void acpi_device_set_id(struct acpi_device *device,
                         printk(KERN_ERR "Memory allocation error\n");
         }
 
-        acpi_os_free(buffer.pointer);
+        kfree(buffer.pointer);
 }
 
 static int acpi_device_set_context(struct acpi_device *device, int type)
@@ -918,10 +936,9 @@ static int acpi_bus_remove(struct acpi_device *dev, int rmdevice)
         int result = 0;
         struct acpi_driver *driver;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_remove");
 
         if (!dev)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         driver = dev->driver;
 
@@ -930,12 +947,12 @@ static int acpi_bus_remove(struct acpi_device *dev, int rmdevice)
                 if (driver->ops.stop) {
                         result = driver->ops.stop(dev, ACPI_BUS_REMOVAL_EJECT);
                         if (result)
-                                return_VALUE(result);
+                                return result;
                 }
 
                 result = dev->driver->ops.remove(dev, ACPI_BUS_REMOVAL_EJECT);
                 if (result) {
-                        return_VALUE(result);
+                        return result;
                 }
 
                 atomic_dec(&dev->driver->references);
@@ -944,7 +961,7 @@ static int acpi_bus_remove(struct acpi_device *dev, int rmdevice)
         }
 
         if (!rmdevice)
-                return_VALUE(0);
+                return 0;
 
         if (dev->flags.bus_address) {
                 if ((dev->parent) && (dev->parent->ops.unbind))
@@ -953,7 +970,7 @@ static int acpi_bus_remove(struct acpi_device *dev, int rmdevice)
 
         acpi_device_unregister(dev, ACPI_BUS_REMOVAL_EJECT);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int
@@ -963,15 +980,14 @@ acpi_add_single_object(struct acpi_device **child,
         int result = 0;
         struct acpi_device *device = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_add_single_object");
 
         if (!child)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         device = kmalloc(sizeof(struct acpi_device), GFP_KERNEL);
         if (!device) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Memory allocation error\n"));
-                return_VALUE(-ENOMEM);
+                printk(KERN_ERR PREFIX "Memory allocation error\n");
+                return -ENOMEM;
         }
         memset(device, 0, sizeof(struct acpi_device));
 
@@ -1096,7 +1112,7 @@ acpi_add_single_object(struct acpi_device **child,
                 kfree(device);
         }
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_bus_scan(struct acpi_device *start, struct acpi_bus_ops *ops)
@@ -1109,10 +1125,9 @@ static int acpi_bus_scan(struct acpi_device *start, struct acpi_bus_ops *ops)
         acpi_object_type type = 0;
         u32 level = 1;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_scan");
 
         if (!start)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         parent = start;
         phandle = start->handle;
@@ -1209,7 +1224,7 @@ static int acpi_bus_scan(struct acpi_device *start, struct acpi_bus_ops *ops)
                 }
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 int
@@ -1219,7 +1234,6 @@ acpi_bus_add(struct acpi_device **child,
         int result;
         struct acpi_bus_ops ops;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_add");
 
         result = acpi_add_single_object(child, parent, handle, type);
         if (!result) {
@@ -1227,7 +1241,7 @@ acpi_bus_add(struct acpi_device **child,
                 ops.acpi_op_add = 1;
                 result = acpi_bus_scan(*child, &ops);
         }
-        return_VALUE(result);
+        return result;
 }
 
 EXPORT_SYMBOL(acpi_bus_add);
@@ -1237,10 +1251,9 @@ int acpi_bus_start(struct acpi_device *device)
         int result;
         struct acpi_bus_ops ops;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_start");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         result = acpi_start_single_object(device);
         if (!result) {
@@ -1248,7 +1261,7 @@ int acpi_bus_start(struct acpi_device *device)
                 ops.acpi_op_start = 1;
                 result = acpi_bus_scan(device, &ops);
         }
-        return_VALUE(result);
+        return result;
 }
 
 EXPORT_SYMBOL(acpi_bus_start);
@@ -1314,10 +1327,9 @@ static int acpi_bus_scan_fixed(struct acpi_device *root)
         int result = 0;
         struct acpi_device *device = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_bus_scan_fixed");
 
         if (!root)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         /*
          * Enumerate all fixed-feature devices.
@@ -1338,7 +1350,7 @@ static int acpi_bus_scan_fixed(struct acpi_device *root)
                         result = acpi_start_single_object(device);
         }
 
-        return_VALUE(result);
+        return result;
 }
 
 
@@ -1427,7 +1439,7 @@ static int acpi_device_resume(struct device * dev)
 }
 
 
-struct bus_type acpi_bus_type = {
+static struct bus_type acpi_bus_type = {
         .name           = "acpi",
         .suspend        = acpi_device_suspend,
         .resume         = acpi_device_resume,
@@ -1440,12 +1452,13 @@ static int __init acpi_scan_init(void)
         int result;
         struct acpi_bus_ops ops;
 
-        ACPI_FUNCTION_TRACE("acpi_scan_init");
 
         if (acpi_disabled)
-                return_VALUE(0);
+                return 0;
 
-        kset_register(&acpi_namespace_kset);
+        result = kset_register(&acpi_namespace_kset);
+        if (result < 0)
+                printk(KERN_ERR PREFIX "kset_register error: %d\n", result);
 
         result = bus_register(&acpi_bus_type);
         if (result) {
@@ -1488,7 +1501,7 @@ static int __init acpi_scan_init(void)
                 acpi_device_unregister(acpi_root, ACPI_BUS_REMOVAL_NORMAL);
 
       Done:
-        return_VALUE(result);
+        return result;
 }
 
 subsys_initcall(acpi_scan_init);
diff --git a/drivers/acpi/sleep/proc.c b/drivers/acpi/sleep/proc.c
index 4696a85a98b9..34962578039d 100644
--- a/drivers/acpi/sleep/proc.c
+++ b/drivers/acpi/sleep/proc.c
@@ -434,7 +434,7 @@ acpi_system_wakeup_device_open_fs(struct inode *inode, struct file *file)
                            PDE(inode)->data);
 }
 
-static struct file_operations acpi_system_wakeup_device_fops = {
+static const struct file_operations acpi_system_wakeup_device_fops = {
         .open = acpi_system_wakeup_device_open_fs,
         .read = seq_read,
         .write = acpi_system_write_wakeup_device,
@@ -443,7 +443,7 @@ static struct file_operations acpi_system_wakeup_device_fops = {
 };
 
 #ifdef  CONFIG_ACPI_SLEEP_PROC_SLEEP
-static struct file_operations acpi_system_sleep_fops = {
+static const struct file_operations acpi_system_sleep_fops = {
         .open = acpi_system_sleep_open_fs,
         .read = seq_read,
         .write = acpi_system_write_sleep,
@@ -452,7 +452,7 @@ static struct file_operations acpi_system_sleep_fops = {
 };
 #endif                          /* CONFIG_ACPI_SLEEP_PROC_SLEEP */
 
-static struct file_operations acpi_system_alarm_fops = {
+static const struct file_operations acpi_system_alarm_fops = {
         .open = acpi_system_alarm_open_fs,
         .read = seq_read,
         .write = acpi_system_write_alarm,
diff --git a/drivers/acpi/system.c b/drivers/acpi/system.c
index a934ac42178d..d86dcb3c2366 100644
--- a/drivers/acpi/system.c
+++ b/drivers/acpi/system.c
@@ -47,10 +47,9 @@ extern struct fadt_descriptor acpi_fadt;
 
 static int acpi_system_read_info(struct seq_file *seq, void *offset)
 {
-        ACPI_FUNCTION_TRACE("acpi_system_read_info");
 
         seq_printf(seq, "version:                 %x\n", ACPI_CA_VERSION);
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_system_info_open_fs(struct inode *inode, struct file *file)
@@ -58,7 +57,7 @@ static int acpi_system_info_open_fs(struct inode *inode, struct file *file)
         return single_open(file, acpi_system_read_info, PDE(inode)->data);
 }
 
-static struct file_operations acpi_system_info_ops = {
+static const struct file_operations acpi_system_info_ops = {
         .open = acpi_system_info_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -68,7 +67,7 @@ static struct file_operations acpi_system_info_ops = {
 static ssize_t acpi_system_read_dsdt(struct file *, char __user *, size_t,
                                      loff_t *);
 
-static struct file_operations acpi_system_dsdt_ops = {
+static const struct file_operations acpi_system_dsdt_ops = {
         .read = acpi_system_read_dsdt,
 };
 
@@ -80,23 +79,22 @@ acpi_system_read_dsdt(struct file *file,
         struct acpi_buffer dsdt = { ACPI_ALLOCATE_BUFFER, NULL };
         ssize_t res;
 
-        ACPI_FUNCTION_TRACE("acpi_system_read_dsdt");
 
         status = acpi_get_table(ACPI_TABLE_ID_DSDT, 1, &dsdt);
         if (ACPI_FAILURE(status))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         res = simple_read_from_buffer(buffer, count, ppos,
                                       dsdt.pointer, dsdt.length);
-        acpi_os_free(dsdt.pointer);
+        kfree(dsdt.pointer);
 
-        return_VALUE(res);
+        return res;
 }
 
 static ssize_t acpi_system_read_fadt(struct file *, char __user *, size_t,
                                      loff_t *);
 
-static struct file_operations acpi_system_fadt_ops = {
+static const struct file_operations acpi_system_fadt_ops = {
         .read = acpi_system_read_fadt,
 };
 
@@ -108,17 +106,16 @@ acpi_system_read_fadt(struct file *file,
         struct acpi_buffer fadt = { ACPI_ALLOCATE_BUFFER, NULL };
         ssize_t res;
 
-        ACPI_FUNCTION_TRACE("acpi_system_read_fadt");
 
         status = acpi_get_table(ACPI_TABLE_ID_FADT, 1, &fadt);
         if (ACPI_FAILURE(status))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         res = simple_read_from_buffer(buffer, count, ppos,
                                       fadt.pointer, fadt.length);
-        acpi_os_free(fadt.pointer);
+        kfree(fadt.pointer);
 
-        return_VALUE(res);
+        return res;
 }
 
 static int __init acpi_system_init(void)
@@ -127,10 +124,9 @@ static int __init acpi_system_init(void)
         int error = 0;
         char *name;
 
-        ACPI_FUNCTION_TRACE("acpi_system_init");
 
         if (acpi_disabled)
-                return_VALUE(0);
+                return 0;
 
         /* 'info' [R] */
         name = ACPI_SYSTEM_FILE_INFO;
@@ -158,12 +154,9 @@ static int __init acpi_system_init(void)
                 goto Error;
 
       Done:
-        return_VALUE(error);
+        return error;
 
       Error:
-        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                          "Unable to create '%s' proc fs entry\n", name));
-
         remove_proc_entry(ACPI_SYSTEM_FILE_FADT, acpi_root_dir);
         remove_proc_entry(ACPI_SYSTEM_FILE_DSDT, acpi_root_dir);
         remove_proc_entry(ACPI_SYSTEM_FILE_INFO, acpi_root_dir);
diff --git a/drivers/acpi/tables.c b/drivers/acpi/tables.c
index ed5e8816d83d..bfb3bfcf9e91 100644
--- a/drivers/acpi/tables.c
+++ b/drivers/acpi/tables.c
@@ -23,7 +23,6 @@
  *
  */
 
-#include <linux/config.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
diff --git a/drivers/acpi/tables/tbget.c b/drivers/acpi/tables/tbget.c
index 99eacceff563..7856db759af0 100644
--- a/drivers/acpi/tables/tbget.c
+++ b/drivers/acpi/tables/tbget.c
@@ -320,6 +320,16 @@ acpi_tb_get_this_table(struct acpi_pointer *address,
 
         ACPI_FUNCTION_TRACE(tb_get_this_table);
 
+        /* Validate minimum length */
+
+        if (header->length < sizeof(struct acpi_table_header)) {
+                ACPI_ERROR((AE_INFO,
+                            "Table length (%X) is smaller than minimum (%X)",
+                            header->length, sizeof(struct acpi_table_header)));
+
+                return_ACPI_STATUS(AE_INVALID_TABLE_LENGTH);
+        }
+
         /*
          * Flags contains the current processor mode (Virtual or Physical
          * addressing) The pointer_type is either Logical or Physical
@@ -356,7 +366,7 @@ acpi_tb_get_this_table(struct acpi_pointer *address,
                  */
                 status = acpi_os_map_memory(address->pointer.physical,
                                             (acpi_size) header->length,
-                                            (void *)&full_table);
+                                            ACPI_CAST_PTR(void, &full_table));
                 if (ACPI_FAILURE(status)) {
                         ACPI_ERROR((AE_INFO,
                                     "Could not map memory for table [%4.4s] at %8.8X%8.8X for length %X",
diff --git a/drivers/acpi/tables/tbinstal.c b/drivers/acpi/tables/tbinstal.c
index 7ca2df75bb11..1668a232fb67 100644
--- a/drivers/acpi/tables/tbinstal.c
+++ b/drivers/acpi/tables/tbinstal.c
@@ -256,7 +256,7 @@ acpi_tb_init_table_descriptor(acpi_table_type table_type,
 
         status = acpi_ut_allocate_owner_id(&table_desc->owner_id);
         if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
+                goto error_exit1;
         }
 
         /* Install the table into the global data structure */
@@ -274,8 +274,8 @@ acpi_tb_init_table_descriptor(acpi_table_type table_type,
                  * at this location, so return an error.
                  */
                 if (list_head->next) {
-                        ACPI_FREE(table_desc);
-                        return_ACPI_STATUS(AE_ALREADY_EXISTS);
+                        status = AE_ALREADY_EXISTS;
+                        goto error_exit2;
                 }
 
                 table_desc->next = list_head->next;
@@ -335,6 +335,17 @@ acpi_tb_init_table_descriptor(acpi_table_type table_type,
         table_info->owner_id = table_desc->owner_id;
         table_info->installed_desc = table_desc;
         return_ACPI_STATUS(AE_OK);
+
+        /* Error exit with cleanup */
+
+      error_exit2:
+
+        acpi_ut_release_owner_id(&table_desc->owner_id);
+
+      error_exit1:
+
+        ACPI_FREE(table_desc);
+        return_ACPI_STATUS(status);
 }
 
 /*******************************************************************************
@@ -525,6 +536,10 @@ struct acpi_table_desc *acpi_tb_uninstall_table(struct acpi_table_desc
 
         acpi_tb_delete_single_table(table_desc);
 
+        /* Free the owner ID associated with this table */
+
+        acpi_ut_release_owner_id(&table_desc->owner_id);
+
         /* Free the table descriptor */
 
         next_desc = table_desc->next;
diff --git a/drivers/acpi/tables/tbrsdt.c b/drivers/acpi/tables/tbrsdt.c
index abcb08c2592a..0ad3dbb9ebca 100644
--- a/drivers/acpi/tables/tbrsdt.c
+++ b/drivers/acpi/tables/tbrsdt.c
@@ -183,6 +183,17 @@ acpi_status acpi_tb_validate_rsdt(struct acpi_table_header *table_ptr)
 
         ACPI_FUNCTION_ENTRY();
 
+        /* Validate minimum length */
+
+        if (table_ptr->length < sizeof(struct acpi_table_header)) {
+                ACPI_ERROR((AE_INFO,
+                            "RSDT/XSDT length (%X) is smaller than minimum (%X)",
+                            table_ptr->length,
+                            sizeof(struct acpi_table_header)));
+
+                return (AE_INVALID_TABLE_LENGTH);
+        }
+
         /* Search for appropriate signature, RSDT or XSDT */
 
         if (acpi_gbl_root_table_type == ACPI_TABLE_TYPE_RSDT) {
@@ -210,7 +221,7 @@ acpi_status acpi_tb_validate_rsdt(struct acpi_table_header *table_ptr)
                         ACPI_ERROR((AE_INFO, "Looking for XSDT"));
                 }
 
-                ACPI_DUMP_BUFFER((char *)table_ptr, 48);
+                ACPI_DUMP_BUFFER(ACPI_CAST_PTR(char, table_ptr), 48);
                 return (AE_BAD_SIGNATURE);
         }
 
@@ -258,7 +269,7 @@ acpi_status acpi_tb_get_table_rsdt(void)
 
         status = acpi_tb_validate_rsdt(table_info.pointer);
         if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
+                goto error_cleanup;
         }
 
         /* Get the number of tables defined in the RSDT or XSDT */
@@ -270,14 +281,14 @@ acpi_status acpi_tb_get_table_rsdt(void)
 
         status = acpi_tb_convert_to_xsdt(&table_info);
         if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
+                goto error_cleanup;
         }
 
         /* Save the table pointers and allocation info */
 
         status = acpi_tb_init_table_descriptor(ACPI_TABLE_ID_XSDT, &table_info);
         if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
+                goto error_cleanup;
         }
 
         acpi_gbl_XSDT =
@@ -285,4 +296,12 @@ acpi_status acpi_tb_get_table_rsdt(void)
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "XSDT located at %p\n", acpi_gbl_XSDT));
         return_ACPI_STATUS(status);
+
+      error_cleanup:
+
+        /* Free table allocated by acpi_tb_get_table */
+
+        acpi_tb_delete_single_table(&table_info);
+
+        return_ACPI_STATUS(status);
 }
diff --git a/drivers/acpi/tables/tbxface.c b/drivers/acpi/tables/tbxface.c
index 4e91f2984815..7767987be15a 100644
--- a/drivers/acpi/tables/tbxface.c
+++ b/drivers/acpi/tables/tbxface.c
@@ -134,8 +134,8 @@ ACPI_EXPORT_SYMBOL(acpi_load_tables)
  * RETURN:      Status
  *
  * DESCRIPTION: This function is called to load a table from the caller's
- *              buffer.  The buffer must contain an entire ACPI Table including
- *              a valid header.  The header fields will be verified, and if it
+ *              buffer. The buffer must contain an entire ACPI Table including
+ *              a valid header. The header fields will be verified, and if it
  *              is determined that the table is invalid, the call will fail.
  *
  ******************************************************************************/
@@ -245,15 +245,18 @@ acpi_status acpi_unload_table(acpi_table_type table_type)
         /* Find all tables of the requested type */
 
         table_desc = acpi_gbl_table_lists[table_type].next;
+        if (!table_desc) {
+                return_ACPI_STATUS(AE_NOT_EXIST);
+        }
+
         while (table_desc) {
                 /*
-                 * Delete all namespace entries owned by this table.  Note that these
-                 * entries can appear anywhere in the namespace by virtue of the AML
-                 * "Scope" operator.  Thus, we need to track ownership by an ID, not
+                 * 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);
-                acpi_ut_release_owner_id(&table_desc->owner_id);
                 table_desc = table_desc->next;
         }
 
@@ -275,12 +278,12 @@ ACPI_EXPORT_SYMBOL(acpi_unload_table)
  *                                see acpi_gbl_acpi_table_flag
  *              out_table_header - pointer to the struct acpi_table_header if successful
  *
- * DESCRIPTION: This function is called to get an ACPI table header.  The caller
+ * DESCRIPTION: This function is called to get an ACPI table header. The caller
  *              supplies an pointer to a data area sufficient to contain an ACPI
  *              struct acpi_table_header structure.
  *
  *              The header contains a length field that can be used to determine
- *              the size of the buffer needed to contain the entire table.  This
+ *              the size of the buffer needed to contain the entire table. This
  *              function is not valid for the RSD PTR table since it does not
  *              have a standard header and is fixed length.
  *
@@ -322,7 +325,8 @@ acpi_get_table_header(acpi_table_type table_type,
 
         /* Copy the header to the caller's buffer */
 
-        ACPI_MEMCPY((void *)out_table_header, (void *)tbl_ptr,
+        ACPI_MEMCPY(ACPI_CAST_PTR(void, out_table_header),
+                    ACPI_CAST_PTR(void, tbl_ptr),
                     sizeof(struct acpi_table_header));
 
         return_ACPI_STATUS(status);
@@ -344,10 +348,10 @@ ACPI_EXPORT_SYMBOL(acpi_get_table_header)
  *
  * RETURN:      Status
  *
- * DESCRIPTION: This function is called to get an ACPI table.  The caller
+ * DESCRIPTION: This function is called to get an ACPI table. The caller
  *              supplies an out_buffer large enough to contain the entire ACPI
- *              table.  The caller should call the acpi_get_table_header function
- *              first to determine the buffer size needed.  Upon completion
+ *              table. The caller should call the acpi_get_table_header function
+ *              first to determine the buffer size needed. Upon completion
  *              the out_buffer->Length field will indicate the number of bytes
  *              copied into the out_buffer->buf_ptr buffer. This table will be
  *              a complete table including the header.
@@ -417,7 +421,9 @@ acpi_get_table(acpi_table_type table_type,
 
         /* Copy the table to the buffer */
 
-        ACPI_MEMCPY((void *)ret_buffer->pointer, (void *)tbl_ptr, table_length);
+        ACPI_MEMCPY(ACPI_CAST_PTR(void, ret_buffer->pointer),
+                    ACPI_CAST_PTR(void, tbl_ptr), table_length);
+
         return_ACPI_STATUS(AE_OK);
 }
 
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index e7fe3a14fdaf..5753d06b7860 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -162,7 +162,7 @@ struct acpi_thermal_flags {
 };
 
 struct acpi_thermal {
-        acpi_handle handle;
+        struct acpi_device * device;
         acpi_bus_id name;
         unsigned long temperature;
         unsigned long last_temperature;
@@ -176,21 +176,21 @@ struct acpi_thermal {
         struct timer_list timer;
 };
 
-static struct file_operations acpi_thermal_state_fops = {
+static const struct file_operations acpi_thermal_state_fops = {
         .open = acpi_thermal_state_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
         .release = single_release,
 };
 
-static struct file_operations acpi_thermal_temp_fops = {
+static const struct file_operations acpi_thermal_temp_fops = {
         .open = acpi_thermal_temp_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
         .release = single_release,
 };
 
-static struct file_operations acpi_thermal_trip_fops = {
+static const struct file_operations acpi_thermal_trip_fops = {
         .open = acpi_thermal_trip_open_fs,
         .read = seq_read,
         .write = acpi_thermal_write_trip_points,
@@ -198,7 +198,7 @@ static struct file_operations acpi_thermal_trip_fops = {
         .release = single_release,
 };
 
-static struct file_operations acpi_thermal_cooling_fops = {
+static const struct file_operations acpi_thermal_cooling_fops = {
         .open = acpi_thermal_cooling_open_fs,
         .read = seq_read,
         .write = acpi_thermal_write_cooling_mode,
@@ -206,7 +206,7 @@ static struct file_operations acpi_thermal_cooling_fops = {
         .release = single_release,
 };
 
-static struct file_operations acpi_thermal_polling_fops = {
+static const struct file_operations acpi_thermal_polling_fops = {
         .open = acpi_thermal_polling_open_fs,
         .read = seq_read,
         .write = acpi_thermal_write_polling,
@@ -222,51 +222,48 @@ static int acpi_thermal_get_temperature(struct acpi_thermal *tz)
 {
         acpi_status status = AE_OK;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_get_temperature");
 
         if (!tz)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         tz->last_temperature = tz->temperature;
 
         status =
-            acpi_evaluate_integer(tz->handle, "_TMP", NULL, &tz->temperature);
+            acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tz->temperature);
         if (ACPI_FAILURE(status))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n",
                           tz->temperature));
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
 {
         acpi_status status = AE_OK;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_get_polling_frequency");
 
         if (!tz)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         status =
-            acpi_evaluate_integer(tz->handle, "_TZP", NULL,
+            acpi_evaluate_integer(tz->device->handle, "_TZP", NULL,
                                   &tz->polling_frequency);
         if (ACPI_FAILURE(status))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n",
                           tz->polling_frequency));
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_set_polling(struct acpi_thermal *tz, int seconds)
 {
-        ACPI_FUNCTION_TRACE("acpi_thermal_set_polling");
 
         if (!tz)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         tz->polling_frequency = seconds * 10;   /* Convert value to deci-seconds */
 
@@ -274,7 +271,7 @@ static int acpi_thermal_set_polling(struct acpi_thermal *tz, int seconds)
                           "Polling frequency set to %lu seconds\n",
                           tz->polling_frequency));
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
@@ -284,29 +281,28 @@ static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
         struct acpi_object_list arg_list = { 1, &arg0 };
         acpi_handle handle = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_set_cooling_mode");
 
         if (!tz)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
-        status = acpi_get_handle(tz->handle, "_SCP", &handle);
+        status = acpi_get_handle(tz->device->handle, "_SCP", &handle);
         if (ACPI_FAILURE(status)) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n"));
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
         arg0.integer.value = mode;
 
         status = acpi_evaluate_object(handle, NULL, &arg_list, NULL);
         if (ACPI_FAILURE(status))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         tz->cooling_mode = mode;
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Cooling mode [%s]\n",
                           mode ? "passive" : "active"));
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
@@ -314,19 +310,18 @@ static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
         acpi_status status = AE_OK;
         int i = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_get_trip_points");
 
         if (!tz)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /* Critical Shutdown (required) */
 
-        status = acpi_evaluate_integer(tz->handle, "_CRT", NULL,
+        status = acpi_evaluate_integer(tz->device->handle, "_CRT", NULL,
                                        &tz->trips.critical.temperature);
         if (ACPI_FAILURE(status)) {
                 tz->trips.critical.flags.valid = 0;
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "No critical threshold\n"));
-                return_VALUE(-ENODEV);
+                ACPI_EXCEPTION((AE_INFO, status, "No critical threshold"));
+                return -ENODEV;
         } else {
                 tz->trips.critical.flags.valid = 1;
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
@@ -337,7 +332,7 @@ static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
         /* Critical Sleep (optional) */
 
         status =
-            acpi_evaluate_integer(tz->handle, "_HOT", NULL,
+            acpi_evaluate_integer(tz->device->handle, "_HOT", NULL,
                                   &tz->trips.hot.temperature);
         if (ACPI_FAILURE(status)) {
                 tz->trips.hot.flags.valid = 0;
@@ -351,7 +346,7 @@ static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
         /* Passive: Processors (optional) */
 
         status =
-            acpi_evaluate_integer(tz->handle, "_PSV", NULL,
+            acpi_evaluate_integer(tz->device->handle, "_PSV", NULL,
                                   &tz->trips.passive.temperature);
         if (ACPI_FAILURE(status)) {
                 tz->trips.passive.flags.valid = 0;
@@ -360,32 +355,31 @@ static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
                 tz->trips.passive.flags.valid = 1;
 
                 status =
-                    acpi_evaluate_integer(tz->handle, "_TC1", NULL,
+                    acpi_evaluate_integer(tz->device->handle, "_TC1", NULL,
                                           &tz->trips.passive.tc1);
                 if (ACPI_FAILURE(status))
                         tz->trips.passive.flags.valid = 0;
 
                 status =
-                    acpi_evaluate_integer(tz->handle, "_TC2", NULL,
+                    acpi_evaluate_integer(tz->device->handle, "_TC2", NULL,
                                           &tz->trips.passive.tc2);
                 if (ACPI_FAILURE(status))
                         tz->trips.passive.flags.valid = 0;
 
                 status =
-                    acpi_evaluate_integer(tz->handle, "_TSP", NULL,
+                    acpi_evaluate_integer(tz->device->handle, "_TSP", NULL,
                                           &tz->trips.passive.tsp);
                 if (ACPI_FAILURE(status))
                         tz->trips.passive.flags.valid = 0;
 
                 status =
-                    acpi_evaluate_reference(tz->handle, "_PSL", NULL,
+                    acpi_evaluate_reference(tz->device->handle, "_PSL", NULL,
                                             &tz->trips.passive.devices);
                 if (ACPI_FAILURE(status))
                         tz->trips.passive.flags.valid = 0;
 
                 if (!tz->trips.passive.flags.valid)
-                        ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                          "Invalid passive threshold\n"));
+                        printk(KERN_WARNING PREFIX "Invalid passive threshold\n");
                 else
                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                           "Found passive threshold [%lu]\n",
@@ -399,14 +393,14 @@ static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
                 char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
 
                 status =
-                    acpi_evaluate_integer(tz->handle, name, NULL,
+                    acpi_evaluate_integer(tz->device->handle, name, NULL,
                                           &tz->trips.active[i].temperature);
                 if (ACPI_FAILURE(status))
                         break;
 
                 name[2] = 'L';
                 status =
-                    acpi_evaluate_reference(tz->handle, name, NULL,
+                    acpi_evaluate_reference(tz->device->handle, name, NULL,
                                             &tz->trips.active[i].devices);
                 if (ACPI_SUCCESS(status)) {
                         tz->trips.active[i].flags.valid = 1;
@@ -414,29 +408,27 @@ static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
                                           "Found active threshold [%d]:[%lu]\n",
                                           i, tz->trips.active[i].temperature));
                 } else
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Invalid active threshold [%d]\n",
-                                          i));
+                        ACPI_EXCEPTION((AE_INFO, status,
+                                        "Invalid active threshold [%d]", i));
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_get_devices(struct acpi_thermal *tz)
 {
         acpi_status status = AE_OK;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_get_devices");
 
         if (!tz)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         status =
-            acpi_evaluate_reference(tz->handle, "_TZD", NULL, &tz->devices);
+            acpi_evaluate_reference(tz->device->handle, "_TZD", NULL, &tz->devices);
         if (ACPI_FAILURE(status))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_call_usermode(char *path)
@@ -444,10 +436,9 @@ static int acpi_thermal_call_usermode(char *path)
         char *argv[2] = { NULL, NULL };
         char *envp[3] = { NULL, NULL, NULL };
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_call_usermode");
 
         if (!path)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         argv[0] = path;
 
@@ -457,66 +448,48 @@ static int acpi_thermal_call_usermode(char *path)
 
         call_usermodehelper(argv[0], argv, envp, 0);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_critical(struct acpi_thermal *tz)
 {
-        int result = 0;
-        struct acpi_device *device = NULL;
-
-        ACPI_FUNCTION_TRACE("acpi_thermal_critical");
-
         if (!tz || !tz->trips.critical.flags.valid)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (tz->temperature >= tz->trips.critical.temperature) {
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Critical trip point\n"));
+                printk(KERN_WARNING PREFIX "Critical trip point\n");
                 tz->trips.critical.flags.enabled = 1;
         } else if (tz->trips.critical.flags.enabled)
                 tz->trips.critical.flags.enabled = 0;
 
-        result = acpi_bus_get_device(tz->handle, &device);
-        if (result)
-                return_VALUE(result);
-
         printk(KERN_EMERG
                "Critical temperature reached (%ld C), shutting down.\n",
                KELVIN_TO_CELSIUS(tz->temperature));
-        acpi_bus_generate_event(device, ACPI_THERMAL_NOTIFY_CRITICAL,
+        acpi_bus_generate_event(tz->device, ACPI_THERMAL_NOTIFY_CRITICAL,
                                 tz->trips.critical.flags.enabled);
 
         acpi_thermal_call_usermode(ACPI_THERMAL_PATH_POWEROFF);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_hot(struct acpi_thermal *tz)
 {
-        int result = 0;
-        struct acpi_device *device = NULL;
-
-        ACPI_FUNCTION_TRACE("acpi_thermal_hot");
-
         if (!tz || !tz->trips.hot.flags.valid)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (tz->temperature >= tz->trips.hot.temperature) {
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Hot trip point\n"));
+                printk(KERN_WARNING PREFIX "Hot trip point\n");
                 tz->trips.hot.flags.enabled = 1;
         } else if (tz->trips.hot.flags.enabled)
                 tz->trips.hot.flags.enabled = 0;
 
-        result = acpi_bus_get_device(tz->handle, &device);
-        if (result)
-                return_VALUE(result);
-
-        acpi_bus_generate_event(device, ACPI_THERMAL_NOTIFY_HOT,
+        acpi_bus_generate_event(tz->device, ACPI_THERMAL_NOTIFY_HOT,
                                 tz->trips.hot.flags.enabled);
 
         /* TBD: Call user-mode "sleep(S4)" function */
 
-        return_VALUE(0);
+        return 0;
 }
 
 static void acpi_thermal_passive(struct acpi_thermal *tz)
@@ -526,7 +499,6 @@ static void acpi_thermal_passive(struct acpi_thermal *tz)
         int trend = 0;
         int i = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_passive");
 
         if (!tz || !tz->trips.passive.flags.valid)
                 return;
@@ -615,7 +587,6 @@ static void acpi_thermal_active(struct acpi_thermal *tz)
         int j = 0;
         unsigned long maxtemp = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_active");
 
         if (!tz)
                 return;
@@ -642,10 +613,10 @@ static void acpi_thermal_active(struct acpi_thermal *tz)
                                                        handles[j],
                                                        ACPI_STATE_D0);
                                 if (result) {
-                                        ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                                          "Unable to turn cooling device [%p] 'on'\n",
-                                                          active->devices.
-                                                          handles[j]));
+                                        printk(KERN_WARNING PREFIX
+                                                      "Unable to turn cooling device [%p] 'on'\n",
+                                                      active->devices.
+                                                      handles[j]);
                                         continue;
                                 }
                                 active->flags.enabled = 1;
@@ -667,9 +638,9 @@ static void acpi_thermal_active(struct acpi_thermal *tz)
                         result = acpi_bus_set_power(active->devices.handles[j],
                                                     ACPI_STATE_D3);
                         if (result) {
-                                ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                                  "Unable to turn cooling device [%p] 'off'\n",
-                                                  active->devices.handles[j]));
+                                printk(KERN_WARNING PREFIX
+                                              "Unable to turn cooling device [%p] 'off'\n",
+                                              active->devices.handles[j]);
                                 continue;
                         }
                         active->flags.enabled = 0;
@@ -697,18 +668,17 @@ static void acpi_thermal_check(void *data)
         int i = 0;
         struct acpi_thermal_state state;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_check");
 
         if (!tz) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid (NULL) context.\n"));
-                return_VOID;
+                printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
+                return;
         }
 
         state = tz->state;
 
         result = acpi_thermal_get_temperature(tz);
         if (result)
-                return_VOID;
+                return;
 
         memset(&tz->state, 0, sizeof(tz->state));
 
@@ -797,7 +767,7 @@ static void acpi_thermal_check(void *data)
                 }
         }
 
-        return_VOID;
+        return;
 }
 
 /* --------------------------------------------------------------------------
@@ -810,7 +780,6 @@ static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
 {
         struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_state_seq_show");
 
         if (!tz)
                 goto end;
@@ -833,7 +802,7 @@ static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
         }
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file)
@@ -846,7 +815,6 @@ 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;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_temp_seq_show");
 
         if (!tz)
                 goto end;
@@ -859,7 +827,7 @@ static int acpi_thermal_temp_seq_show(struct seq_file *seq, void *offset)
                    KELVIN_TO_CELSIUS(tz->temperature));
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file)
@@ -873,7 +841,6 @@ static int acpi_thermal_trip_seq_show(struct seq_file *seq, void *offset)
         int i = 0;
         int j = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_trip_seq_show");
 
         if (!tz)
                 goto end;
@@ -913,7 +880,7 @@ static int acpi_thermal_trip_seq_show(struct seq_file *seq, void *offset)
         }
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file)
@@ -934,28 +901,25 @@ acpi_thermal_write_trip_points(struct file *file,
         int *active;
         int i = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_write_trip_points");
 
         limit_string = kmalloc(ACPI_THERMAL_MAX_LIMIT_STR_LEN, GFP_KERNEL);
         if (!limit_string)
-                return_VALUE(-ENOMEM);
+                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);
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         }
 
         if (!tz || (count > ACPI_THERMAL_MAX_LIMIT_STR_LEN - 1)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument\n"));
                 count = -EINVAL;
                 goto end;
         }
 
         if (copy_from_user(limit_string, buffer, count)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data\n"));
                 count = -EFAULT;
                 goto end;
         }
@@ -968,7 +932,6 @@ acpi_thermal_write_trip_points(struct file *file,
                      &active[5], &active[6], &active[7], &active[8],
                      &active[9]);
         if (!(num >= 5 && num < (ACPI_THERMAL_MAX_ACTIVE + 3))) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data format\n"));
                 count = -EINVAL;
                 goto end;
         }
@@ -985,14 +948,13 @@ acpi_thermal_write_trip_points(struct file *file,
       end:
         kfree(active);
         kfree(limit_string);
-        return_VALUE(count);
+        return count;
 }
 
 static int acpi_thermal_cooling_seq_show(struct seq_file *seq, void *offset)
 {
         struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_cooling_seq_show");
 
         if (!tz)
                 goto end;
@@ -1008,7 +970,7 @@ static int acpi_thermal_cooling_seq_show(struct seq_file *seq, void *offset)
                            tz->cooling_mode ? "passive" : "active");
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file)
@@ -1027,16 +989,15 @@ acpi_thermal_write_cooling_mode(struct file *file,
         int result = 0;
         char mode_string[12] = { '\0' };
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_write_cooling_mode");
 
         if (!tz || (count > sizeof(mode_string) - 1))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (!tz->flags.cooling_mode)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         if (copy_from_user(mode_string, buffer, count))
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
         mode_string[count] = '\0';
 
@@ -1044,18 +1005,17 @@ acpi_thermal_write_cooling_mode(struct file *file,
                                                simple_strtoul(mode_string, NULL,
                                                               0));
         if (result)
-                return_VALUE(result);
+                return result;
 
         acpi_thermal_check(tz);
 
-        return_VALUE(count);
+        return count;
 }
 
 static int acpi_thermal_polling_seq_show(struct seq_file *seq, void *offset)
 {
         struct acpi_thermal *tz = (struct acpi_thermal *)seq->private;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_polling_seq_show");
 
         if (!tz)
                 goto end;
@@ -1069,7 +1029,7 @@ static int acpi_thermal_polling_seq_show(struct seq_file *seq, void *offset)
                    (tz->polling_frequency / 10));
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file)
@@ -1089,13 +1049,12 @@ acpi_thermal_write_polling(struct file *file,
         char polling_string[12] = { '\0' };
         int seconds = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_write_polling");
 
         if (!tz || (count > sizeof(polling_string) - 1))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (copy_from_user(polling_string, buffer, count))
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
         polling_string[count] = '\0';
 
@@ -1103,24 +1062,23 @@ acpi_thermal_write_polling(struct file *file,
 
         result = acpi_thermal_set_polling(tz, seconds);
         if (result)
-                return_VALUE(result);
+                return result;
 
         acpi_thermal_check(tz);
 
-        return_VALUE(count);
+        return count;
 }
 
 static int acpi_thermal_add_fs(struct acpi_device *device)
 {
         struct proc_dir_entry *entry = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_add_fs");
 
         if (!acpi_device_dir(device)) {
                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
                                                      acpi_thermal_dir);
                 if (!acpi_device_dir(device))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
                 acpi_device_dir(device)->owner = THIS_MODULE;
         }
 
@@ -1128,9 +1086,7 @@ static int acpi_thermal_add_fs(struct acpi_device *device)
         entry = create_proc_entry(ACPI_THERMAL_FILE_STATE,
                                   S_IRUGO, acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_THERMAL_FILE_STATE));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_thermal_state_fops;
                 entry->data = acpi_driver_data(device);
@@ -1141,9 +1097,7 @@ static int acpi_thermal_add_fs(struct acpi_device *device)
         entry = create_proc_entry(ACPI_THERMAL_FILE_TEMPERATURE,
                                   S_IRUGO, acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_THERMAL_FILE_TEMPERATURE));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_thermal_temp_fops;
                 entry->data = acpi_driver_data(device);
@@ -1155,9 +1109,7 @@ static int acpi_thermal_add_fs(struct acpi_device *device)
                                   S_IFREG | S_IRUGO | S_IWUSR,
                                   acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_THERMAL_FILE_TRIP_POINTS));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_thermal_trip_fops;
                 entry->data = acpi_driver_data(device);
@@ -1169,9 +1121,7 @@ static int acpi_thermal_add_fs(struct acpi_device *device)
                                   S_IFREG | S_IRUGO | S_IWUSR,
                                   acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_THERMAL_FILE_COOLING_MODE));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_thermal_cooling_fops;
                 entry->data = acpi_driver_data(device);
@@ -1183,21 +1133,18 @@ static int acpi_thermal_add_fs(struct acpi_device *device)
                                   S_IFREG | S_IRUGO | S_IWUSR,
                                   acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create '%s' fs entry\n",
-                                  ACPI_THERMAL_FILE_POLLING_FREQ));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_thermal_polling_fops;
                 entry->data = acpi_driver_data(device);
                 entry->owner = THIS_MODULE;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_remove_fs(struct acpi_device *device)
 {
-        ACPI_FUNCTION_TRACE("acpi_thermal_remove_fs");
 
         if (acpi_device_dir(device)) {
                 remove_proc_entry(ACPI_THERMAL_FILE_POLLING_FREQ,
@@ -1214,7 +1161,7 @@ static int acpi_thermal_remove_fs(struct acpi_device *device)
                 acpi_device_dir(device) = NULL;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 /* --------------------------------------------------------------------------
@@ -1226,13 +1173,11 @@ static void acpi_thermal_notify(acpi_handle handle, u32 event, void *data)
         struct acpi_thermal *tz = (struct acpi_thermal *)data;
         struct acpi_device *device = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_notify");
 
         if (!tz)
-                return_VOID;
+                return;
 
-        if (acpi_bus_get_device(tz->handle, &device))
-                return_VOID;
+        device = tz->device;
 
         switch (event) {
         case ACPI_THERMAL_NOTIFY_TEMPERATURE:
@@ -1254,27 +1199,26 @@ static void acpi_thermal_notify(acpi_handle handle, u32 event, void *data)
                 break;
         }
 
-        return_VOID;
+        return;
 }
 
 static int acpi_thermal_get_info(struct acpi_thermal *tz)
 {
         int result = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_get_info");
 
         if (!tz)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /* Get temperature [_TMP] (required) */
         result = acpi_thermal_get_temperature(tz);
         if (result)
-                return_VALUE(result);
+                return result;
 
         /* Get trip points [_CRT, _PSV, etc.] (required) */
         result = acpi_thermal_get_trip_points(tz);
         if (result)
-                return_VALUE(result);
+                return result;
 
         /* Set the cooling mode [_SCP] to active cooling (default) */
         result = acpi_thermal_set_cooling_mode(tz, ACPI_THERMAL_MODE_ACTIVE);
@@ -1314,7 +1258,7 @@ static int acpi_thermal_get_info(struct acpi_thermal *tz)
         if (!result)
                 tz->flags.devices = 1;
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_add(struct acpi_device *device)
@@ -1323,17 +1267,16 @@ static int acpi_thermal_add(struct acpi_device *device)
         acpi_status status = AE_OK;
         struct acpi_thermal *tz = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_add");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         tz = kmalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
         if (!tz)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(tz, 0, sizeof(struct acpi_thermal));
 
-        tz->handle = device->handle;
+        tz->device = device;
         strcpy(tz->name, device->pnp.bus_id);
         strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
         strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
@@ -1351,12 +1294,10 @@ static int acpi_thermal_add(struct acpi_device *device)
 
         acpi_thermal_check(tz);
 
-        status = acpi_install_notify_handler(tz->handle,
+        status = acpi_install_notify_handler(device->handle,
                                              ACPI_DEVICE_NOTIFY,
                                              acpi_thermal_notify, tz);
         if (ACPI_FAILURE(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error installing notify handler\n"));
                 result = -ENODEV;
                 goto end;
         }
@@ -1371,7 +1312,7 @@ static int acpi_thermal_add(struct acpi_device *device)
                 kfree(tz);
         }
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_thermal_remove(struct acpi_device *device, int type)
@@ -1379,10 +1320,9 @@ static int acpi_thermal_remove(struct acpi_device *device, int type)
         acpi_status status = AE_OK;
         struct acpi_thermal *tz = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_remove");
 
         if (!device || !acpi_driver_data(device))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         tz = (struct acpi_thermal *)acpi_driver_data(device);
 
@@ -1395,12 +1335,9 @@ static int acpi_thermal_remove(struct acpi_device *device, int type)
         /* deferred task may reinsert timer */
         del_timer_sync(&(tz->timer));
 
-        status = acpi_remove_notify_handler(tz->handle,
+        status = acpi_remove_notify_handler(device->handle,
                                             ACPI_DEVICE_NOTIFY,
                                             acpi_thermal_notify);
-        if (ACPI_FAILURE(status))
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error removing notify handler\n"));
 
         /* Terminate policy */
         if (tz->trips.passive.flags.valid && tz->trips.passive.flags.enabled) {
@@ -1416,19 +1353,34 @@ static int acpi_thermal_remove(struct acpi_device *device, int type)
         acpi_thermal_remove_fs(device);
 
         kfree(tz);
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_thermal_resume(struct acpi_device *device, int state)
 {
         struct acpi_thermal *tz = NULL;
+        int i;
 
         if (!device || !acpi_driver_data(device))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         tz = (struct acpi_thermal *)acpi_driver_data(device);
 
-        acpi_thermal_check(tz);
+        acpi_thermal_get_temperature(tz);
+
+        for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
+                if (tz->trips.active[i].flags.valid) {
+                        tz->temperature = tz->trips.active[i].temperature;
+                        tz->trips.active[i].flags.enabled = 0;
+
+                        acpi_thermal_active(tz);
+
+                        tz->state.active |= tz->trips.active[i].flags.enabled;
+                        tz->state.active_index = i;
+                }
+        }
+
+        acpi_thermal_check(tz);
 
         return AE_OK;
 }
@@ -1437,31 +1389,29 @@ static int __init acpi_thermal_init(void)
 {
         int result = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_thermal_init");
 
         acpi_thermal_dir = proc_mkdir(ACPI_THERMAL_CLASS, acpi_root_dir);
         if (!acpi_thermal_dir)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         acpi_thermal_dir->owner = THIS_MODULE;
 
         result = acpi_bus_register_driver(&acpi_thermal_driver);
         if (result < 0) {
                 remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static void __exit acpi_thermal_exit(void)
 {
-        ACPI_FUNCTION_TRACE("acpi_thermal_exit");
 
         acpi_bus_unregister_driver(&acpi_thermal_driver);
 
         remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
 
-        return_VOID;
+        return;
 }
 
 module_init(acpi_thermal_init);
diff --git a/drivers/acpi/utilities/utalloc.c b/drivers/acpi/utilities/utalloc.c
index 7940fc1bd69e..f6cbc0b1bfd0 100644
--- a/drivers/acpi/utilities/utalloc.c
+++ b/drivers/acpi/utilities/utalloc.c
@@ -166,10 +166,10 @@ acpi_status acpi_ut_delete_caches(void)
 
         /* Free memory lists */
 
-        acpi_os_free(acpi_gbl_global_list);
+        ACPI_FREE(acpi_gbl_global_list);
         acpi_gbl_global_list = NULL;
 
-        acpi_os_free(acpi_gbl_ns_node_list);
+        ACPI_FREE(acpi_gbl_ns_node_list);
         acpi_gbl_ns_node_list = NULL;
 #endif
 
@@ -285,6 +285,7 @@ acpi_ut_initialize_buffer(struct acpi_buffer * buffer,
         return (status);
 }
 
+#ifdef NOT_USED_BY_LINUX
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ut_allocate
@@ -360,3 +361,4 @@ void *acpi_ut_allocate_zeroed(acpi_size size,
 
         return (allocation);
 }
+#endif
diff --git a/drivers/acpi/utilities/utcache.c b/drivers/acpi/utilities/utcache.c
index 56270a30718a..1a1f8109159c 100644
--- a/drivers/acpi/utilities/utcache.c
+++ b/drivers/acpi/utilities/utcache.c
@@ -162,7 +162,7 @@ acpi_status acpi_os_delete_cache(struct acpi_memory_list * cache)
 
         /* Now we can delete the cache object */
 
-        acpi_os_free(cache);
+        ACPI_FREE(cache);
         return (AE_OK);
 }
 
diff --git a/drivers/acpi/utilities/utdebug.c b/drivers/acpi/utilities/utdebug.c
index 5ec1cfcc611d..bb1eaf9aa653 100644
--- a/drivers/acpi/utilities/utdebug.c
+++ b/drivers/acpi/utilities/utdebug.c
@@ -47,7 +47,7 @@
 ACPI_MODULE_NAME("utdebug")
 
 #ifdef ACPI_DEBUG_OUTPUT
-static u32 acpi_gbl_prev_thread_id = 0xFFFFFFFF;
+static acpi_thread_id acpi_gbl_prev_thread_id;
 static char *acpi_gbl_fn_entry_str = "----Entry";
 static char *acpi_gbl_fn_exit_str = "----Exit-";
 
@@ -181,7 +181,7 @@ acpi_ut_debug_print(u32 requested_debug_level,
                 if (ACPI_LV_THREADS & acpi_dbg_level) {
                         acpi_os_printf
                             ("\n**** Context Switch from TID %X to TID %X ****\n\n",
-                             acpi_gbl_prev_thread_id, thread_id);
+                             (u32) acpi_gbl_prev_thread_id, (u32) thread_id);
                 }
 
                 acpi_gbl_prev_thread_id = thread_id;
diff --git a/drivers/acpi/utilities/utdelete.c b/drivers/acpi/utilities/utdelete.c
index 67b9f325c6fa..9d3f1149ba21 100644
--- a/drivers/acpi/utilities/utdelete.c
+++ b/drivers/acpi/utilities/utdelete.c
@@ -155,21 +155,30 @@ static void acpi_ut_delete_internal_obj(union acpi_operand_object *object)
         case ACPI_TYPE_MUTEX:
 
                 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
-                                  "***** Mutex %p, Semaphore %p\n",
-                                  object, object->mutex.semaphore));
+                                  "***** Mutex %p, OS Mutex %p\n",
+                                  object, object->mutex.os_mutex));
 
-                acpi_ex_unlink_mutex(object);
-                (void)acpi_os_delete_semaphore(object->mutex.semaphore);
+                if (object->mutex.os_mutex != ACPI_GLOBAL_LOCK) {
+                        acpi_ex_unlink_mutex(object);
+                        acpi_os_delete_mutex(object->mutex.os_mutex);
+                } else {
+                        /* Global Lock "mutex" is actually a counting semaphore */
+
+                        (void)
+                            acpi_os_delete_semaphore
+                            (acpi_gbl_global_lock_semaphore);
+                        acpi_gbl_global_lock_semaphore = NULL;
+                }
                 break;
 
         case ACPI_TYPE_EVENT:
 
                 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
-                                  "***** Event %p, Semaphore %p\n",
-                                  object, object->event.semaphore));
+                                  "***** Event %p, OS Semaphore %p\n",
+                                  object, object->event.os_semaphore));
 
-                (void)acpi_os_delete_semaphore(object->event.semaphore);
-                object->event.semaphore = NULL;
+                (void)acpi_os_delete_semaphore(object->event.os_semaphore);
+                object->event.os_semaphore = NULL;
                 break;
 
         case ACPI_TYPE_METHOD:
@@ -177,12 +186,13 @@ static void acpi_ut_delete_internal_obj(union acpi_operand_object *object)
                 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
                                   "***** Method %p\n", object));
 
-                /* Delete the method semaphore if it exists */
+                /* Delete the method mutex if it exists */
 
-                if (object->method.semaphore) {
-                        (void)acpi_os_delete_semaphore(object->method.
-                                                       semaphore);
-                        object->method.semaphore = NULL;
+                if (object->method.mutex) {
+                        acpi_os_delete_mutex(object->method.mutex->mutex.
+                                             os_mutex);
+                        acpi_ut_delete_object_desc(object->method.mutex);
+                        object->method.mutex = NULL;
                 }
                 break;
 
@@ -437,11 +447,16 @@ acpi_ut_update_object_reference(union acpi_operand_object *object, u16 action)
                  */
                 switch (ACPI_GET_OBJECT_TYPE(object)) {
                 case ACPI_TYPE_DEVICE:
+                case ACPI_TYPE_PROCESSOR:
+                case ACPI_TYPE_POWER:
+                case ACPI_TYPE_THERMAL:
+
+                        /* Update the notify objects for these types (if present) */
 
-                        acpi_ut_update_ref_count(object->device.system_notify,
-                                                 action);
-                        acpi_ut_update_ref_count(object->device.device_notify,
-                                                 action);
+                        acpi_ut_update_ref_count(object->common_notify.
+                                                 system_notify, action);
+                        acpi_ut_update_ref_count(object->common_notify.
+                                                 device_notify, action);
                         break;
 
                 case ACPI_TYPE_PACKAGE:
diff --git a/drivers/acpi/utilities/utglobal.c b/drivers/acpi/utilities/utglobal.c
index e5999c65c0b8..014030af8b50 100644
--- a/drivers/acpi/utilities/utglobal.c
+++ b/drivers/acpi/utilities/utglobal.c
@@ -794,6 +794,7 @@ void acpi_ut_init_globals(void)
 
         /* Global Lock support */
 
+        acpi_gbl_global_lock_semaphore = NULL;
         acpi_gbl_global_lock_acquired = FALSE;
         acpi_gbl_global_lock_thread_count = 0;
         acpi_gbl_global_lock_handle = 0;
diff --git a/drivers/acpi/utilities/utmisc.c b/drivers/acpi/utilities/utmisc.c
index 5c75d35ad1cd..6d8a8211be90 100644
--- a/drivers/acpi/utilities/utmisc.c
+++ b/drivers/acpi/utilities/utmisc.c
@@ -41,6 +41,8 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
+#include <linux/module.h>
+
 #include <acpi/acpi.h>
 #include <acpi/acnamesp.h>
 
@@ -63,7 +65,7 @@ ACPI_MODULE_NAME("utmisc")
 u8 acpi_ut_is_aml_table(struct acpi_table_header *table)
 {
 
-        /* Ignore tables that contain AML */
+        /* These are the only tables that contain executable AML */
 
         if (ACPI_COMPARE_NAME(table->signature, DSDT_SIG) ||
             ACPI_COMPARE_NAME(table->signature, PSDT_SIG) ||
@@ -417,10 +419,15 @@ void acpi_ut_set_integer_width(u8 revision)
 {
 
         if (revision <= 1) {
+
+                /* 32-bit case */
+
                 acpi_gbl_integer_bit_width = 32;
                 acpi_gbl_integer_nybble_width = 8;
                 acpi_gbl_integer_byte_width = 4;
         } else {
+                /* 64-bit case (ACPI 2.0+) */
+
                 acpi_gbl_integer_bit_width = 64;
                 acpi_gbl_integer_nybble_width = 16;
                 acpi_gbl_integer_byte_width = 8;
@@ -500,6 +507,7 @@ acpi_ut_display_init_pathname(u8 type,
  * FUNCTION:    acpi_ut_valid_acpi_char
  *
  * PARAMETERS:  Char            - The character to be examined
+ *              Position        - Byte position (0-3)
  *
  * RETURN:      TRUE if the character is valid, FALSE otherwise
  *
@@ -607,7 +615,9 @@ acpi_name acpi_ut_repair_name(acpi_name name)
  *
  * RETURN:      Status and Converted value
  *
- * DESCRIPTION: Convert a string into an unsigned value.
+ * DESCRIPTION: Convert a string into an unsigned value. Performs either a
+ *              32-bit or 64-bit conversion, depending on the current mode
+ *              of the interpreter.
  *              NOTE: Does not support Octal strings, not needed.
  *
  ******************************************************************************/
@@ -625,7 +635,7 @@ acpi_ut_strtoul64(char *string, u32 base, acpi_integer * ret_integer)
         u8 sign_of0x = 0;
         u8 term = 0;
 
-        ACPI_FUNCTION_TRACE(ut_stroul64);
+        ACPI_FUNCTION_TRACE_STR(ut_stroul64, string);
 
         switch (base) {
         case ACPI_ANY_BASE:
@@ -673,11 +683,13 @@ acpi_ut_strtoul64(char *string, u32 base, acpi_integer * ret_integer)
                 }
         }
 
+        /*
+         * Perform a 32-bit or 64-bit conversion, depending upon the current
+         * execution mode of the interpreter
+         */
         dividend = (mode32) ? ACPI_UINT32_MAX : ACPI_UINT64_MAX;
 
-        /* At least one character in the string here */
-
-        /* Main loop: convert the string to a 64-bit integer */
+        /* Main loop: convert the string to a 32- or 64-bit integer */
 
         while (*string) {
                 if (ACPI_IS_DIGIT(*string)) {
@@ -752,6 +764,9 @@ acpi_ut_strtoul64(char *string, u32 base, acpi_integer * ret_integer)
 
       all_done:
 
+        ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n",
+                          ACPI_FORMAT_UINT64(return_value)));
+
         *ret_integer = return_value;
         return_ACPI_STATUS(AE_OK);
 
@@ -962,6 +977,7 @@ acpi_ut_exception(char *module_name,
         acpi_os_vprintf(format, args);
         acpi_os_printf(" [%X]\n", ACPI_CA_VERSION);
 }
+EXPORT_SYMBOL(acpi_ut_exception);
 
 void ACPI_INTERNAL_VAR_XFACE
 acpi_ut_warning(char *module_name, u32 line_number, char *format, ...)
diff --git a/drivers/acpi/utilities/utmutex.c b/drivers/acpi/utilities/utmutex.c
index 25eb34369afa..c39062a047cd 100644
--- a/drivers/acpi/utilities/utmutex.c
+++ b/drivers/acpi/utilities/utmutex.c
@@ -82,12 +82,9 @@ acpi_status acpi_ut_mutex_initialize(void)
 
         /* Create the spinlocks for use at interrupt level */
 
-        status = acpi_os_create_lock(&acpi_gbl_gpe_lock);
-        if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
-        }
+        spin_lock_init(acpi_gbl_gpe_lock);
+        spin_lock_init(acpi_gbl_hardware_lock);
 
-        status = acpi_os_create_lock(&acpi_gbl_hardware_lock);
         return_ACPI_STATUS(status);
 }
 
@@ -146,9 +143,8 @@ static acpi_status acpi_ut_create_mutex(acpi_mutex_handle mutex_id)
         }
 
         if (!acpi_gbl_mutex_info[mutex_id].mutex) {
-                status = acpi_os_create_semaphore(1, 1,
-                                                  &acpi_gbl_mutex_info
-                                                  [mutex_id].mutex);
+                status =
+                    acpi_os_create_mutex(&acpi_gbl_mutex_info[mutex_id].mutex);
                 acpi_gbl_mutex_info[mutex_id].thread_id =
                     ACPI_MUTEX_NOT_ACQUIRED;
                 acpi_gbl_mutex_info[mutex_id].use_count = 0;
@@ -171,7 +167,6 @@ static acpi_status acpi_ut_create_mutex(acpi_mutex_handle mutex_id)
 
 static acpi_status acpi_ut_delete_mutex(acpi_mutex_handle mutex_id)
 {
-        acpi_status status;
 
         ACPI_FUNCTION_TRACE_U32(ut_delete_mutex, mutex_id);
 
@@ -179,12 +174,12 @@ static acpi_status acpi_ut_delete_mutex(acpi_mutex_handle mutex_id)
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
         }
 
-        status = acpi_os_delete_semaphore(acpi_gbl_mutex_info[mutex_id].mutex);
+        acpi_os_delete_mutex(acpi_gbl_mutex_info[mutex_id].mutex);
 
         acpi_gbl_mutex_info[mutex_id].mutex = NULL;
         acpi_gbl_mutex_info[mutex_id].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
 
-        return_ACPI_STATUS(status);
+        return_ACPI_STATUS(AE_OK);
 }
 
 /*******************************************************************************
@@ -249,14 +244,14 @@ acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id)
 
         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
                           "Thread %X attempting to acquire Mutex [%s]\n",
-                          this_thread_id, acpi_ut_get_mutex_name(mutex_id)));
+                          (u32) this_thread_id, acpi_ut_get_mutex_name(mutex_id)));
 
-        status = acpi_os_wait_semaphore(acpi_gbl_mutex_info[mutex_id].mutex,
-                                        1, ACPI_WAIT_FOREVER);
+        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",
-                                  this_thread_id,
+                                  (u32) this_thread_id,
                                   acpi_ut_get_mutex_name(mutex_id)));
 
                 acpi_gbl_mutex_info[mutex_id].use_count++;
@@ -264,7 +259,7 @@ acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id)
         } else {
                 ACPI_EXCEPTION((AE_INFO, status,
                                 "Thread %X could not acquire Mutex [%X]",
-                                this_thread_id, mutex_id));
+                                (u32) this_thread_id, mutex_id));
         }
 
         return (status);
@@ -284,14 +279,13 @@ acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id)
 
 acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id)
 {
-        acpi_status status;
         acpi_thread_id this_thread_id;
 
         ACPI_FUNCTION_NAME(ut_release_mutex);
 
         this_thread_id = acpi_os_get_thread_id();
         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
-                          "Thread %X releasing Mutex [%s]\n", this_thread_id,
+                          "Thread %X releasing Mutex [%s]\n", (u32) this_thread_id,
                           acpi_ut_get_mutex_name(mutex_id)));
 
         if (mutex_id > ACPI_MAX_MUTEX) {
@@ -340,19 +334,6 @@ acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id)
 
         acpi_gbl_mutex_info[mutex_id].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
 
-        status =
-            acpi_os_signal_semaphore(acpi_gbl_mutex_info[mutex_id].mutex, 1);
-
-        if (ACPI_FAILURE(status)) {
-                ACPI_EXCEPTION((AE_INFO, status,
-                                "Thread %X could not release Mutex [%X]",
-                                this_thread_id, mutex_id));
-        } else {
-                ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
-                                  "Thread %X released Mutex [%s]\n",
-                                  this_thread_id,
-                                  acpi_ut_get_mutex_name(mutex_id)));
-        }
-
-        return (status);
+        acpi_os_release_mutex(acpi_gbl_mutex_info[mutex_id].mutex);
+        return (AE_OK);
 }
diff --git a/drivers/acpi/utilities/utstate.c b/drivers/acpi/utilities/utstate.c
index 0f5c5bb5deff..eaa13d05c859 100644
--- a/drivers/acpi/utilities/utstate.c
+++ b/drivers/acpi/utilities/utstate.c
@@ -199,6 +199,13 @@ struct acpi_thread_state *acpi_ut_create_thread_state(void)
         state->common.descriptor_type = ACPI_DESC_TYPE_STATE_THREAD;
         state->thread.thread_id = acpi_os_get_thread_id();
 
+        /* Check for invalid thread ID - zero is very bad, it will break things */
+
+        if (!state->thread.thread_id) {
+                ACPI_ERROR((AE_INFO, "Invalid zero ID from AcpiOsGetThreadId"));
+                state->thread.thread_id = (acpi_thread_id) 1;
+        }
+
         return_PTR((struct acpi_thread_state *)state);
 }
 
diff --git a/drivers/acpi/utils.c b/drivers/acpi/utils.c
index 6b516852ac12..d0d84c43a9d4 100644
--- a/drivers/acpi/utils.c
+++ b/drivers/acpi/utils.c
@@ -58,31 +58,29 @@ acpi_extract_package(union acpi_object *package,
         u8 *head = NULL;
         u8 *tail = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_extract_package");
 
         if (!package || (package->type != ACPI_TYPE_PACKAGE)
             || (package->package.count < 1)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                  "Invalid 'package' argument\n"));
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                printk(KERN_WARNING PREFIX "Invalid package argument\n");
+                return AE_BAD_PARAMETER;
         }
 
         if (!format || !format->pointer || (format->length < 1)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid 'format' argument\n"));
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                printk(KERN_WARNING PREFIX "Invalid format argument\n");
+                return AE_BAD_PARAMETER;
         }
 
         if (!buffer) {
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid 'buffer' argument\n"));
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                printk(KERN_WARNING PREFIX "Invalid buffer argument\n");
+                return AE_BAD_PARAMETER;
         }
 
         format_count = (format->length / sizeof(char)) - 1;
         if (format_count > package->package.count) {
-                ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                  "Format specifies more objects [%d] than exist in package [%d].",
-                                  format_count, package->package.count));
-                return_ACPI_STATUS(AE_BAD_DATA);
+                printk(KERN_WARNING PREFIX "Format specifies more objects [%d]"
+                              " than exist in package [%d].\n",
+                              format_count, package->package.count);
+                return AE_BAD_DATA;
         }
 
         format_string = (char *)format->pointer;
@@ -95,7 +93,7 @@ acpi_extract_package(union acpi_object *package,
                 union acpi_object *element = &(package->package.elements[i]);
 
                 if (!element) {
-                        return_ACPI_STATUS(AE_BAD_DATA);
+                        return AE_BAD_DATA;
                 }
 
                 switch (element->type) {
@@ -113,10 +111,11 @@ acpi_extract_package(union acpi_object *package,
                                 tail_offset += sizeof(char *);
                                 break;
                         default:
-                                ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                                  "Invalid package element [%d]: got number, expecing [%c].\n",
-                                                  i, format_string[i]));
-                                return_ACPI_STATUS(AE_BAD_DATA);
+                                printk(KERN_WARNING PREFIX "Invalid package element"
+                                              " [%d]: got number, expecing"
+                                              " [%c]\n",
+                                              i, format_string[i]);
+                                return AE_BAD_DATA;
                                 break;
                         }
                         break;
@@ -138,10 +137,11 @@ acpi_extract_package(union acpi_object *package,
                                 tail_offset += sizeof(u8 *);
                                 break;
                         default:
-                                ACPI_DEBUG_PRINT((ACPI_DB_WARN,
-                                                  "Invalid package element [%d] got string/buffer, expecing [%c].\n",
-                                                  i, format_string[i]));
-                                return_ACPI_STATUS(AE_BAD_DATA);
+                                printk(KERN_WARNING PREFIX "Invalid package element"
+                                              " [%d] got string/buffer,"
+                                              " expecing [%c]\n",
+                                              i, format_string[i]);
+                                return AE_BAD_DATA;
                                 break;
                         }
                         break;
@@ -152,7 +152,7 @@ acpi_extract_package(union acpi_object *package,
                                           "Found unsupported element at index=%d\n",
                                           i));
                         /* TBD: handle nested packages... */
-                        return_ACPI_STATUS(AE_SUPPORT);
+                        return AE_SUPPORT;
                         break;
                 }
         }
@@ -162,9 +162,9 @@ acpi_extract_package(union acpi_object *package,
          */
         if (buffer->length < size_required) {
                 buffer->length = size_required;
-                return_ACPI_STATUS(AE_BUFFER_OVERFLOW);
+                return AE_BUFFER_OVERFLOW;
         } else if (buffer->length != size_required || !buffer->pointer) {
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                return AE_BAD_PARAMETER;
         }
 
         head = buffer->pointer;
@@ -179,7 +179,7 @@ acpi_extract_package(union acpi_object *package,
                 union acpi_object *element = &(package->package.elements[i]);
 
                 if (!element) {
-                        return_ACPI_STATUS(AE_BAD_DATA);
+                        return AE_BAD_DATA;
                 }
 
                 switch (element->type) {
@@ -244,7 +244,7 @@ acpi_extract_package(union acpi_object *package,
                 }
         }
 
-        return_ACPI_STATUS(AE_OK);
+        return AE_OK;
 }
 
 EXPORT_SYMBOL(acpi_extract_package);
@@ -258,14 +258,13 @@ acpi_evaluate_integer(acpi_handle handle,
         union acpi_object *element;
         struct acpi_buffer buffer = { 0, NULL };
 
-        ACPI_FUNCTION_TRACE("acpi_evaluate_integer");
 
         if (!data)
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                return AE_BAD_PARAMETER;
 
-        element = kmalloc(sizeof(union acpi_object), GFP_KERNEL);
+        element = kmalloc(sizeof(union acpi_object), irqs_disabled() ? GFP_ATOMIC: GFP_KERNEL);
         if (!element)
-                return_ACPI_STATUS(AE_NO_MEMORY);
+                return AE_NO_MEMORY;
 
         memset(element, 0, sizeof(union acpi_object));
         buffer.length = sizeof(union acpi_object);
@@ -274,13 +273,13 @@ acpi_evaluate_integer(acpi_handle handle,
         if (ACPI_FAILURE(status)) {
                 acpi_util_eval_error(handle, pathname, status);
                 kfree(element);
-                return_ACPI_STATUS(status);
+                return status;
         }
 
         if (element->type != ACPI_TYPE_INTEGER) {
                 acpi_util_eval_error(handle, pathname, AE_BAD_DATA);
                 kfree(element);
-                return_ACPI_STATUS(AE_BAD_DATA);
+                return AE_BAD_DATA;
         }
 
         *data = element->integer.value;
@@ -288,7 +287,7 @@ acpi_evaluate_integer(acpi_handle handle,
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%lu]\n", *data));
 
-        return_ACPI_STATUS(AE_OK);
+        return AE_OK;
 }
 
 EXPORT_SYMBOL(acpi_evaluate_integer);
@@ -303,15 +302,14 @@ acpi_evaluate_string(acpi_handle handle,
         acpi_object *element = NULL;
         acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 
-        ACPI_FUNCTION_TRACE("acpi_evaluate_string");
 
         if (!data)
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                return AE_BAD_PARAMETER;
 
         status = acpi_evaluate_object(handle, pathname, arguments, &buffer);
         if (ACPI_FAILURE(status)) {
                 acpi_util_eval_error(handle, pathname, status);
-                return_ACPI_STATUS(status);
+                return status;
         }
 
         element = (acpi_object *) buffer.pointer;
@@ -320,13 +318,13 @@ acpi_evaluate_string(acpi_handle handle,
             || (element->type != ACPI_TYPE_BUFFER)
             || !element->string.length) {
                 acpi_util_eval_error(handle, pathname, AE_BAD_DATA);
-                return_ACPI_STATUS(AE_BAD_DATA);
+                return AE_BAD_DATA;
         }
 
         *data = kmalloc(element->string.length + 1, GFP_KERNEL);
         if (!data) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Memory allocation error\n"));
-                return_VALUE(-ENOMEM);
+                printk(KERN_ERR PREFIX "Memory allocation\n");
+                return -ENOMEM;
         }
         memset(*data, 0, element->string.length + 1);
 
@@ -334,9 +332,9 @@ acpi_evaluate_string(acpi_handle handle,
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%s]\n", *data));
 
-        acpi_os_free(buffer.pointer);
+        kfree(buffer.pointer);
 
-        return_ACPI_STATUS(AE_OK);
+        return AE_OK;
 }
 #endif
 
@@ -352,10 +350,9 @@ acpi_evaluate_reference(acpi_handle handle,
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         u32 i = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_evaluate_reference");
 
         if (!list) {
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                return AE_BAD_PARAMETER;
         }
 
         /* Evaluate object. */
@@ -367,32 +364,29 @@ acpi_evaluate_reference(acpi_handle handle,
         package = (union acpi_object *)buffer.pointer;
 
         if ((buffer.length == 0) || !package) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "No return object (len %X ptr %p)\n",
-                                  (unsigned)buffer.length, package));
+                printk(KERN_ERR PREFIX "No return object (len %X ptr %p)\n",
+                            (unsigned)buffer.length, package);
                 status = AE_BAD_DATA;
                 acpi_util_eval_error(handle, pathname, status);
                 goto end;
         }
         if (package->type != ACPI_TYPE_PACKAGE) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Expecting a [Package], found type %X\n",
-                                  package->type));
+                printk(KERN_ERR PREFIX "Expecting a [Package], found type %X\n",
+                            package->type);
                 status = AE_BAD_DATA;
                 acpi_util_eval_error(handle, pathname, status);
                 goto end;
         }
         if (!package->package.count) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "[Package] has zero elements (%p)\n",
-                                  package));
+                printk(KERN_ERR PREFIX "[Package] has zero elements (%p)\n",
+                            package);
                 status = AE_BAD_DATA;
                 acpi_util_eval_error(handle, pathname, status);
                 goto end;
         }
 
         if (package->package.count > ACPI_MAX_HANDLES) {
-                return_ACPI_STATUS(AE_NO_MEMORY);
+                return AE_NO_MEMORY;
         }
         list->count = package->package.count;
 
@@ -404,9 +398,9 @@ acpi_evaluate_reference(acpi_handle handle,
 
                 if (element->type != ACPI_TYPE_ANY) {
                         status = AE_BAD_DATA;
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Expecting a [Reference] package element, found type %X\n",
-                                          element->type));
+                        printk(KERN_ERR PREFIX
+                                    "Expecting a [Reference] package element, found type %X\n",
+                                    element->type);
                         acpi_util_eval_error(handle, pathname, status);
                         break;
                 }
@@ -424,9 +418,9 @@ acpi_evaluate_reference(acpi_handle handle,
                 //kfree(list->handles);
         }
 
-        acpi_os_free(buffer.pointer);
+        kfree(buffer.pointer);
 
-        return_ACPI_STATUS(status);
+        return status;
 }
 
 EXPORT_SYMBOL(acpi_evaluate_reference);
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index e7e9a693953a..56666a982476 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -117,7 +117,7 @@ struct acpi_video_enumerated_device {
 };
 
 struct acpi_video_bus {
-        acpi_handle handle;
+        struct acpi_device *device;
         u8 dos_setting;
         struct acpi_video_enumerated_device *attached_array;
         u8 attached_count;
@@ -155,7 +155,6 @@ struct acpi_video_device_brightness {
 };
 
 struct acpi_video_device {
-        acpi_handle handle;
         unsigned long device_id;
         struct acpi_video_device_flags flags;
         struct acpi_video_device_cap cap;
@@ -272,10 +271,10 @@ static int
 acpi_video_device_query(struct acpi_video_device *device, unsigned long *state)
 {
         int status;
-        ACPI_FUNCTION_TRACE("acpi_video_device_query");
-        status = acpi_evaluate_integer(device->handle, "_DGS", NULL, state);
 
-        return_VALUE(status);
+        status = acpi_evaluate_integer(device->dev->handle, "_DGS", NULL, state);
+
+        return status;
 }
 
 static int
@@ -284,11 +283,9 @@ acpi_video_device_get_state(struct acpi_video_device *device,
 {
         int status;
 
-        ACPI_FUNCTION_TRACE("acpi_video_device_get_state");
-
-        status = acpi_evaluate_integer(device->handle, "_DCS", NULL, state);
+        status = acpi_evaluate_integer(device->dev->handle, "_DCS", NULL, state);
 
-        return_VALUE(status);
+        return status;
 }
 
 static int
@@ -299,12 +296,11 @@ acpi_video_device_set_state(struct acpi_video_device *device, int state)
         struct acpi_object_list args = { 1, &arg0 };
         unsigned long ret;
 
-        ACPI_FUNCTION_TRACE("acpi_video_device_set_state");
 
         arg0.integer.value = state;
-        status = acpi_evaluate_integer(device->handle, "_DSS", &args, &ret);
+        status = acpi_evaluate_integer(device->dev->handle, "_DSS", &args, &ret);
 
-        return_VALUE(status);
+        return status;
 }
 
 static int
@@ -315,28 +311,27 @@ acpi_video_device_lcd_query_levels(struct acpi_video_device *device,
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *obj;
 
-        ACPI_FUNCTION_TRACE("acpi_video_device_lcd_query_levels");
 
         *levels = NULL;
 
-        status = acpi_evaluate_object(device->handle, "_BCL", NULL, &buffer);
+        status = acpi_evaluate_object(device->dev->handle, "_BCL", NULL, &buffer);
         if (!ACPI_SUCCESS(status))
-                return_VALUE(status);
+                return status;
         obj = (union acpi_object *)buffer.pointer;
         if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _BCL data\n"));
+                printk(KERN_ERR PREFIX "Invalid _BCL data\n");
                 status = -EFAULT;
                 goto err;
         }
 
         *levels = obj;
 
-        return_VALUE(0);
+        return 0;
 
       err:
         kfree(buffer.pointer);
 
-        return_VALUE(status);
+        return status;
 }
 
 static int
@@ -346,13 +341,12 @@ acpi_video_device_lcd_set_level(struct acpi_video_device *device, int level)
         union acpi_object arg0 = { ACPI_TYPE_INTEGER };
         struct acpi_object_list args = { 1, &arg0 };
 
-        ACPI_FUNCTION_TRACE("acpi_video_device_lcd_set_level");
 
         arg0.integer.value = level;
-        status = acpi_evaluate_object(device->handle, "_BCM", &args, NULL);
+        status = acpi_evaluate_object(device->dev->handle, "_BCM", &args, NULL);
 
         printk(KERN_DEBUG "set_level status: %x\n", status);
-        return_VALUE(status);
+        return status;
 }
 
 static int
@@ -360,11 +354,10 @@ acpi_video_device_lcd_get_level_current(struct acpi_video_device *device,
                                         unsigned long *level)
 {
         int status;
-        ACPI_FUNCTION_TRACE("acpi_video_device_lcd_get_level_current");
 
-        status = acpi_evaluate_integer(device->handle, "_BQC", NULL, level);
+        status = acpi_evaluate_integer(device->dev->handle, "_BQC", NULL, level);
 
-        return_VALUE(status);
+        return status;
 }
 
 static int
@@ -377,34 +370,33 @@ acpi_video_device_EDID(struct acpi_video_device *device,
         union acpi_object arg0 = { ACPI_TYPE_INTEGER };
         struct acpi_object_list args = { 1, &arg0 };
 
-        ACPI_FUNCTION_TRACE("acpi_video_device_get_EDID");
 
         *edid = NULL;
 
         if (!device)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         if (length == 128)
                 arg0.integer.value = 1;
         else if (length == 256)
                 arg0.integer.value = 2;
         else
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
-        status = acpi_evaluate_object(device->handle, "_DDC", &args, &buffer);
+        status = acpi_evaluate_object(device->dev->handle, "_DDC", &args, &buffer);
         if (ACPI_FAILURE(status))
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         obj = (union acpi_object *)buffer.pointer;
 
         if (obj && obj->type == ACPI_TYPE_BUFFER)
                 *edid = obj;
         else {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _DDC data\n"));
+                printk(KERN_ERR PREFIX "Invalid _DDC data\n");
                 status = -EFAULT;
                 kfree(obj);
         }
 
-        return_VALUE(status);
+        return status;
 }
 
 /* bus */
@@ -417,15 +409,14 @@ acpi_video_bus_set_POST(struct acpi_video_bus *video, unsigned long option)
         union acpi_object arg0 = { ACPI_TYPE_INTEGER };
         struct acpi_object_list args = { 1, &arg0 };
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_set_POST");
 
         arg0.integer.value = option;
 
-        status = acpi_evaluate_integer(video->handle, "_SPD", &args, &tmp);
+        status = acpi_evaluate_integer(video->device->handle, "_SPD", &args, &tmp);
         if (ACPI_SUCCESS(status))
                 status = tmp ? (-EINVAL) : (AE_OK);
 
-        return_VALUE(status);
+        return status;
 }
 
 static int
@@ -433,11 +424,9 @@ acpi_video_bus_get_POST(struct acpi_video_bus *video, unsigned long *id)
 {
         int status;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_get_POST");
-
-        status = acpi_evaluate_integer(video->handle, "_GPD", NULL, id);
+        status = acpi_evaluate_integer(video->device->handle, "_GPD", NULL, id);
 
-        return_VALUE(status);
+        return status;
 }
 
 static int
@@ -445,12 +434,11 @@ acpi_video_bus_POST_options(struct acpi_video_bus *video,
                             unsigned long *options)
 {
         int status;
-        ACPI_FUNCTION_TRACE("acpi_video_bus_POST_options");
 
-        status = acpi_evaluate_integer(video->handle, "_VPO", NULL, options);
+        status = acpi_evaluate_integer(video->device->handle, "_VPO", NULL, options);
         *options &= 3;
 
-        return_VALUE(status);
+        return status;
 }
 
 /*
@@ -481,7 +469,6 @@ acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
         union acpi_object arg0 = { ACPI_TYPE_INTEGER };
         struct acpi_object_list args = { 1, &arg0 };
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_DOS");
 
         if (bios_flag < 0 || bios_flag > 3 || lcd_flag < 0 || lcd_flag > 1) {
                 status = -1;
@@ -489,10 +476,10 @@ acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
         }
         arg0.integer.value = (lcd_flag << 2) | bios_flag;
         video->dos_setting = arg0.integer.value;
-        acpi_evaluate_object(video->handle, "_DOS", &args, NULL);
+        acpi_evaluate_object(video->device->handle, "_DOS", &args, NULL);
 
       Failed:
-        return_VALUE(status);
+        return status;
 }
 
 /*
@@ -514,29 +501,28 @@ static void acpi_video_device_find_cap(struct acpi_video_device *device)
         union acpi_object *obj = NULL;
         struct acpi_video_device_brightness *br = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_video_device_find_cap");
 
         memset(&device->cap, 0, 4);
 
-        if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_ADR", &h_dummy1))) {
+        if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_ADR", &h_dummy1))) {
                 device->cap._ADR = 1;
         }
-        if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_BCL", &h_dummy1))) {
+        if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCL", &h_dummy1))) {
                 device->cap._BCL = 1;
         }
-        if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_BCM", &h_dummy1))) {
+        if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_BCM", &h_dummy1))) {
                 device->cap._BCM = 1;
         }
-        if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_DDC", &h_dummy1))) {
+        if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DDC", &h_dummy1))) {
                 device->cap._DDC = 1;
         }
-        if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_DCS", &h_dummy1))) {
+        if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DCS", &h_dummy1))) {
                 device->cap._DCS = 1;
         }
-        if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_DGS", &h_dummy1))) {
+        if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DGS", &h_dummy1))) {
                 device->cap._DGS = 1;
         }
-        if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_DSS", &h_dummy1))) {
+        if (ACPI_SUCCESS(acpi_get_handle(device->dev->handle, "_DSS", &h_dummy1))) {
                 device->cap._DSS = 1;
         }
 
@@ -560,8 +546,7 @@ static void acpi_video_device_find_cap(struct acpi_video_device *device)
                                 o = (union acpi_object *)&obj->package.
                                     elements[i];
                                 if (o->type != ACPI_TYPE_INTEGER) {
-                                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                                          "Invalid data\n"));
+                                        printk(KERN_ERR PREFIX "Invalid data\n");
                                         continue;
                                 }
                                 br->levels[count] = (u32) o->integer.value;
@@ -583,7 +568,7 @@ static void acpi_video_device_find_cap(struct acpi_video_device *device)
 
         kfree(obj);
 
-        return_VOID;
+        return;
 }
 
 /*
@@ -601,22 +586,22 @@ static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
         acpi_handle h_dummy1;
 
         memset(&video->cap, 0, 4);
-        if (ACPI_SUCCESS(acpi_get_handle(video->handle, "_DOS", &h_dummy1))) {
+        if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOS", &h_dummy1))) {
                 video->cap._DOS = 1;
         }
-        if (ACPI_SUCCESS(acpi_get_handle(video->handle, "_DOD", &h_dummy1))) {
+        if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_DOD", &h_dummy1))) {
                 video->cap._DOD = 1;
         }
-        if (ACPI_SUCCESS(acpi_get_handle(video->handle, "_ROM", &h_dummy1))) {
+        if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_ROM", &h_dummy1))) {
                 video->cap._ROM = 1;
         }
-        if (ACPI_SUCCESS(acpi_get_handle(video->handle, "_GPD", &h_dummy1))) {
+        if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_GPD", &h_dummy1))) {
                 video->cap._GPD = 1;
         }
-        if (ACPI_SUCCESS(acpi_get_handle(video->handle, "_SPD", &h_dummy1))) {
+        if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_SPD", &h_dummy1))) {
                 video->cap._SPD = 1;
         }
-        if (ACPI_SUCCESS(acpi_get_handle(video->handle, "_VPO", &h_dummy1))) {
+        if (ACPI_SUCCESS(acpi_get_handle(video->device->handle, "_VPO", &h_dummy1))) {
                 video->cap._VPO = 1;
         }
 }
@@ -630,10 +615,9 @@ static int acpi_video_bus_check(struct acpi_video_bus *video)
 {
         acpi_status status = -ENOENT;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_check");
 
         if (!video)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /* Since there is no HID, CID and so on for VGA driver, we have
          * to check well known required nodes.
@@ -657,7 +641,7 @@ static int acpi_video_bus_check(struct acpi_video_bus *video)
                 status = 0;
         }
 
-        return_VALUE(status);
+        return status;
 }
 
 /* --------------------------------------------------------------------------
@@ -673,7 +657,6 @@ static int acpi_video_device_info_seq_show(struct seq_file *seq, void *offset)
         struct acpi_video_device *dev =
             (struct acpi_video_device *)seq->private;
 
-        ACPI_FUNCTION_TRACE("acpi_video_device_info_seq_show");
 
         if (!dev)
                 goto end;
@@ -692,7 +675,7 @@ static int acpi_video_device_info_seq_show(struct seq_file *seq, void *offset)
         seq_printf(seq, "known by bios: %s\n", dev->flags.bios ? "yes" : "no");
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int
@@ -709,7 +692,6 @@ static int acpi_video_device_state_seq_show(struct seq_file *seq, void *offset)
             (struct acpi_video_device *)seq->private;
         unsigned long state;
 
-        ACPI_FUNCTION_TRACE("acpi_video_device_state_seq_show");
 
         if (!dev)
                 goto end;
@@ -729,7 +711,7 @@ static int acpi_video_device_state_seq_show(struct seq_file *seq, void *offset)
                 seq_printf(seq, "<not supported>\n");
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int
@@ -750,13 +732,12 @@ acpi_video_device_write_state(struct file *file,
         char str[12] = { 0 };
         u32 state = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_video_device_write_state");
 
         if (!dev || count + 1 > sizeof str)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (copy_from_user(str, buffer, count))
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
         str[count] = 0;
         state = simple_strtoul(str, NULL, 0);
@@ -765,9 +746,9 @@ acpi_video_device_write_state(struct file *file,
         status = acpi_video_device_set_state(dev, state);
 
         if (status)
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
-        return_VALUE(count);
+        return count;
 }
 
 static int
@@ -777,11 +758,10 @@ acpi_video_device_brightness_seq_show(struct seq_file *seq, void *offset)
             (struct acpi_video_device *)seq->private;
         int i;
 
-        ACPI_FUNCTION_TRACE("acpi_video_device_brightness_seq_show");
 
         if (!dev || !dev->brightness) {
                 seq_printf(seq, "<not supported>\n");
-                return_VALUE(0);
+                return 0;
         }
 
         seq_printf(seq, "levels: ");
@@ -789,7 +769,7 @@ acpi_video_device_brightness_seq_show(struct seq_file *seq, void *offset)
                 seq_printf(seq, " %d", dev->brightness->levels[i]);
         seq_printf(seq, "\ncurrent: %d\n", dev->brightness->curr);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int
@@ -810,19 +790,18 @@ acpi_video_device_write_brightness(struct file *file,
         unsigned int level = 0;
         int i;
 
-        ACPI_FUNCTION_TRACE("acpi_video_device_write_brightness");
 
         if (!dev || !dev->brightness || count + 1 > sizeof str)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (copy_from_user(str, buffer, count))
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
         str[count] = 0;
         level = simple_strtoul(str, NULL, 0);
 
         if (level > 100)
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
         /* validate though the list of available levels */
         for (i = 0; i < dev->brightness->count; i++)
@@ -833,7 +812,7 @@ acpi_video_device_write_brightness(struct file *file,
                         break;
                 }
 
-        return_VALUE(count);
+        return count;
 }
 
 static int acpi_video_device_EDID_seq_show(struct seq_file *seq, void *offset)
@@ -844,7 +823,6 @@ static int acpi_video_device_EDID_seq_show(struct seq_file *seq, void *offset)
         int i;
         union acpi_object *edid = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_video_device_EDID_seq_show");
 
         if (!dev)
                 goto out;
@@ -869,7 +847,7 @@ static int acpi_video_device_EDID_seq_show(struct seq_file *seq, void *offset)
         else
                 kfree(edid);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int
@@ -884,28 +862,26 @@ static int acpi_video_device_add_fs(struct acpi_device *device)
         struct proc_dir_entry *entry = NULL;
         struct acpi_video_device *vid_dev;
 
-        ACPI_FUNCTION_TRACE("acpi_video_device_add_fs");
 
         if (!device)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         vid_dev = (struct acpi_video_device *)acpi_driver_data(device);
         if (!vid_dev)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         if (!acpi_device_dir(device)) {
                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
                                                      vid_dev->video->dir);
                 if (!acpi_device_dir(device))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
                 acpi_device_dir(device)->owner = THIS_MODULE;
         }
 
         /* 'info' [R] */
         entry = create_proc_entry("info", S_IRUGO, acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create 'info' fs entry\n"));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_video_device_info_fops;
                 entry->data = acpi_driver_data(device);
@@ -917,8 +893,7 @@ static int acpi_video_device_add_fs(struct acpi_device *device)
             create_proc_entry("state", S_IFREG | S_IRUGO | S_IWUSR,
                               acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create 'state' fs entry\n"));
+                return -ENODEV;
         else {
                 acpi_video_device_state_fops.write = acpi_video_device_write_state;
                 entry->proc_fops = &acpi_video_device_state_fops;
@@ -931,8 +906,7 @@ static int acpi_video_device_add_fs(struct acpi_device *device)
             create_proc_entry("brightness", S_IFREG | S_IRUGO | S_IWUSR,
                               acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create 'brightness' fs entry\n"));
+                return -ENODEV;
         else {
                 acpi_video_device_brightness_fops.write = acpi_video_device_write_brightness;
                 entry->proc_fops = &acpi_video_device_brightness_fops;
@@ -943,25 +917,23 @@ static int acpi_video_device_add_fs(struct acpi_device *device)
         /* 'EDID' [R] */
         entry = create_proc_entry("EDID", S_IRUGO, acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create 'brightness' fs entry\n"));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_video_device_EDID_fops;
                 entry->data = acpi_driver_data(device);
                 entry->owner = THIS_MODULE;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_video_device_remove_fs(struct acpi_device *device)
 {
         struct acpi_video_device *vid_dev;
-        ACPI_FUNCTION_TRACE("acpi_video_device_remove_fs");
 
         vid_dev = (struct acpi_video_device *)acpi_driver_data(device);
         if (!vid_dev || !vid_dev->video || !vid_dev->video->dir)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
 
         if (acpi_device_dir(device)) {
                 remove_proc_entry("info", acpi_device_dir(device));
@@ -972,7 +944,7 @@ static int acpi_video_device_remove_fs(struct acpi_device *device)
                 acpi_device_dir(device) = NULL;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 /* video bus */
@@ -980,7 +952,6 @@ 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;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_info_seq_show");
 
         if (!video)
                 goto end;
@@ -993,7 +964,7 @@ static int acpi_video_bus_info_seq_show(struct seq_file *seq, void *offset)
                    video->flags.post ? "yes" : "no");
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_video_bus_info_open_fs(struct inode *inode, struct file *file)
@@ -1006,7 +977,6 @@ 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;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_ROM_seq_show");
 
         if (!video)
                 goto end;
@@ -1015,7 +985,7 @@ static int acpi_video_bus_ROM_seq_show(struct seq_file *seq, void *offset)
         seq_printf(seq, "<TODO>\n");
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_video_bus_ROM_open_fs(struct inode *inode, struct file *file)
@@ -1029,7 +999,6 @@ static int acpi_video_bus_POST_info_seq_show(struct seq_file *seq, void *offset)
         unsigned long options;
         int status;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_POST_info_seq_show");
 
         if (!video)
                 goto end;
@@ -1052,7 +1021,7 @@ static int acpi_video_bus_POST_info_seq_show(struct seq_file *seq, void *offset)
         } else
                 seq_printf(seq, "<not supported>\n");
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 static int
@@ -1068,7 +1037,6 @@ static int acpi_video_bus_POST_seq_show(struct seq_file *seq, void *offset)
         int status;
         unsigned long id;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_POST_seq_show");
 
         if (!video)
                 goto end;
@@ -1081,18 +1049,17 @@ static int acpi_video_bus_POST_seq_show(struct seq_file *seq, void *offset)
         seq_printf(seq, "device posted is <%s>\n", device_decode[id & 3]);
 
       end:
-        return_VALUE(0);
+        return 0;
 }
 
 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;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_DOS_seq_show");
 
         seq_printf(seq, "DOS setting: <%d>\n", video->dos_setting);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_video_bus_POST_open_fs(struct inode *inode, struct file *file)
@@ -1117,22 +1084,21 @@ acpi_video_bus_write_POST(struct file *file,
         char str[12] = { 0 };
         unsigned long opt, options;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_write_POST");
 
         if (!video || count + 1 > sizeof str)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         status = acpi_video_bus_POST_options(video, &options);
         if (!ACPI_SUCCESS(status))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (copy_from_user(str, buffer, count))
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
         str[count] = 0;
         opt = strtoul(str, NULL, 0);
         if (opt > 3)
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
         /* just in case an OEM 'forget' the motherboard... */
         options |= 1;
@@ -1140,11 +1106,11 @@ acpi_video_bus_write_POST(struct file *file,
         if (options & (1ul << opt)) {
                 status = acpi_video_bus_set_POST(video, opt);
                 if (!ACPI_SUCCESS(status))
-                        return_VALUE(-EFAULT);
+                        return -EFAULT;
 
         }
 
-        return_VALUE(count);
+        return count;
 }
 
 static ssize_t
@@ -1158,25 +1124,24 @@ acpi_video_bus_write_DOS(struct file *file,
         char str[12] = { 0 };
         unsigned long opt;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_write_DOS");
 
         if (!video || count + 1 > sizeof str)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         if (copy_from_user(str, buffer, count))
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
         str[count] = 0;
         opt = strtoul(str, NULL, 0);
         if (opt > 7)
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
         status = acpi_video_bus_DOS(video, opt & 0x3, (opt & 0x4) >> 2);
 
         if (!ACPI_SUCCESS(status))
-                return_VALUE(-EFAULT);
+                return -EFAULT;
 
-        return_VALUE(count);
+        return count;
 }
 
 static int acpi_video_bus_add_fs(struct acpi_device *device)
@@ -1184,7 +1149,6 @@ static int acpi_video_bus_add_fs(struct acpi_device *device)
         struct proc_dir_entry *entry = NULL;
         struct acpi_video_bus *video;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_add_fs");
 
         video = (struct acpi_video_bus *)acpi_driver_data(device);
 
@@ -1192,7 +1156,7 @@ static int acpi_video_bus_add_fs(struct acpi_device *device)
                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
                                                      acpi_video_dir);
                 if (!acpi_device_dir(device))
-                        return_VALUE(-ENODEV);
+                        return -ENODEV;
                 video->dir = acpi_device_dir(device);
                 acpi_device_dir(device)->owner = THIS_MODULE;
         }
@@ -1200,8 +1164,7 @@ static int acpi_video_bus_add_fs(struct acpi_device *device)
         /* 'info' [R] */
         entry = create_proc_entry("info", S_IRUGO, acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create 'info' fs entry\n"));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_video_bus_info_fops;
                 entry->data = acpi_driver_data(device);
@@ -1211,8 +1174,7 @@ static int acpi_video_bus_add_fs(struct acpi_device *device)
         /* 'ROM' [R] */
         entry = create_proc_entry("ROM", S_IRUGO, acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create 'ROM' fs entry\n"));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_video_bus_ROM_fops;
                 entry->data = acpi_driver_data(device);
@@ -1223,8 +1185,7 @@ static int acpi_video_bus_add_fs(struct acpi_device *device)
         entry =
             create_proc_entry("POST_info", S_IRUGO, acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create 'POST_info' fs entry\n"));
+                return -ENODEV;
         else {
                 entry->proc_fops = &acpi_video_bus_POST_info_fops;
                 entry->data = acpi_driver_data(device);
@@ -1236,8 +1197,7 @@ static int acpi_video_bus_add_fs(struct acpi_device *device)
             create_proc_entry("POST", S_IFREG | S_IRUGO | S_IRUSR,
                               acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create 'POST' fs entry\n"));
+                return -ENODEV;
         else {
                 acpi_video_bus_POST_fops.write = acpi_video_bus_write_POST;
                 entry->proc_fops = &acpi_video_bus_POST_fops;
@@ -1250,8 +1210,7 @@ static int acpi_video_bus_add_fs(struct acpi_device *device)
             create_proc_entry("DOS", S_IFREG | S_IRUGO | S_IRUSR,
                               acpi_device_dir(device));
         if (!entry)
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Unable to create 'DOS' fs entry\n"));
+                return -ENODEV;
         else {
                 acpi_video_bus_DOS_fops.write = acpi_video_bus_write_DOS;
                 entry->proc_fops = &acpi_video_bus_DOS_fops;
@@ -1259,14 +1218,13 @@ static int acpi_video_bus_add_fs(struct acpi_device *device)
                 entry->owner = THIS_MODULE;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_video_bus_remove_fs(struct acpi_device *device)
 {
         struct acpi_video_bus *video;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_remove_fs");
 
         video = (struct acpi_video_bus *)acpi_driver_data(device);
 
@@ -1280,7 +1238,7 @@ static int acpi_video_bus_remove_fs(struct acpi_device *device)
                 acpi_device_dir(device) = NULL;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 /* --------------------------------------------------------------------------
@@ -1297,10 +1255,9 @@ acpi_video_bus_get_one_device(struct acpi_device *device,
         int status;
         struct acpi_video_device *data;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_get_one_device");
 
         if (!device || !video)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         status =
             acpi_evaluate_integer(device->handle, "_ADR", NULL, &device_id);
@@ -1308,11 +1265,10 @@ acpi_video_bus_get_one_device(struct acpi_device *device,
 
                 data = kmalloc(sizeof(struct acpi_video_device), GFP_KERNEL);
                 if (!data)
-                        return_VALUE(-ENOMEM);
+                        return -ENOMEM;
 
                 memset(data, 0, sizeof(struct acpi_video_device));
 
-                data->handle = device->handle;
                 strcpy(acpi_device_name(device), ACPI_VIDEO_DEVICE_NAME);
                 strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
                 acpi_driver_data(device) = data;
@@ -1339,7 +1295,7 @@ acpi_video_bus_get_one_device(struct acpi_device *device,
                 acpi_video_device_bind(video, data);
                 acpi_video_device_find_cap(data);
 
-                status = acpi_install_notify_handler(data->handle,
+                status = acpi_install_notify_handler(device->handle,
                                                      ACPI_DEVICE_NOTIFY,
                                                      acpi_video_device_notify,
                                                      data);
@@ -1359,10 +1315,10 @@ acpi_video_bus_get_one_device(struct acpi_device *device,
 
                 acpi_video_device_add_fs(device);
 
-                return_VALUE(0);
+                return 0;
         }
 
-        return_VALUE(-ENOENT);
+        return -ENOENT;
 }
 
 /*
@@ -1405,7 +1361,6 @@ acpi_video_device_bind(struct acpi_video_bus *video,
                        struct acpi_video_device *device)
 {
         int i;
-        ACPI_FUNCTION_TRACE("acpi_video_device_bind");
 
 #define IDS_VAL(i) video->attached_array[i].value.int_val
 #define IDS_BIND(i) video->attached_array[i].bind_info
@@ -1442,17 +1397,15 @@ static int acpi_video_device_enumerate(struct acpi_video_bus *video)
         union acpi_object *dod = NULL;
         union acpi_object *obj;
 
-        ACPI_FUNCTION_TRACE("acpi_video_device_enumerate");
-
-        status = acpi_evaluate_object(video->handle, "_DOD", NULL, &buffer);
+        status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer);
         if (!ACPI_SUCCESS(status)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _DOD\n"));
-                return_VALUE(status);
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD"));
+                return status;
         }
 
         dod = (union acpi_object *)buffer.pointer;
         if (!dod || (dod->type != ACPI_TYPE_PACKAGE)) {
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _DOD data\n"));
+                ACPI_EXCEPTION((AE_INFO, status, "Invalid _DOD data"));
                 status = -EFAULT;
                 goto out;
         }
@@ -1476,8 +1429,7 @@ static int acpi_video_device_enumerate(struct acpi_video_bus *video)
                 obj = (union acpi_object *)&dod->package.elements[i];
 
                 if (obj->type != ACPI_TYPE_INTEGER) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Invalid _DOD data\n"));
+                        printk(KERN_ERR PREFIX "Invalid _DOD data\n");
                         active_device_list[i].value.int_val =
                             ACPI_VIDEO_HEAD_INVALID;
                 }
@@ -1494,8 +1446,8 @@ static int acpi_video_device_enumerate(struct acpi_video_bus *video)
         video->attached_array = active_device_list;
         video->attached_count = count;
       out:
-        acpi_os_free(buffer.pointer);
-        return_VALUE(status);
+        kfree(buffer.pointer);
+        return status;
 }
 
 /*
@@ -1520,7 +1472,6 @@ static int acpi_video_switch_output(struct acpi_video_bus *video, int event)
         unsigned long state;
         int status = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_video_switch_output");
 
         list_for_each_safe(node, next, &video->video_device_list) {
                 dev = container_of(node, struct acpi_video_device, entry);
@@ -1551,7 +1502,7 @@ static int acpi_video_switch_output(struct acpi_video_bus *video, int event)
                 break;
         }
 
-        return_VALUE(status);
+        return status;
 }
 
 static int
@@ -1578,7 +1529,6 @@ acpi_video_bus_get_devices(struct acpi_video_bus *video,
         int status = 0;
         struct list_head *node, *next;
 
-        ACPI_FUNCTION_TRACE("acpi_video_get_devices");
 
         acpi_video_device_enumerate(video);
 
@@ -1591,13 +1541,12 @@ acpi_video_bus_get_devices(struct acpi_video_bus *video,
 
                 status = acpi_video_bus_get_one_device(dev, video);
                 if (ACPI_FAILURE(status)) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                          "Cant attach device\n"));
+                        ACPI_EXCEPTION((AE_INFO, status, "Cant attach device"));
                         continue;
                 }
 
         }
-        return_VALUE(status);
+        return status;
 }
 
 static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
@@ -1605,10 +1554,9 @@ static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
         acpi_status status;
         struct acpi_video_bus *video;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_put_one_device");
 
         if (!device || !device->video)
-                return_VALUE(-ENOENT);
+                return -ENOENT;
 
         video = device->video;
 
@@ -1617,14 +1565,11 @@ static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
         up(&video->sem);
         acpi_video_device_remove_fs(device->dev);
 
-        status = acpi_remove_notify_handler(device->handle,
+        status = acpi_remove_notify_handler(device->dev->handle,
                                             ACPI_DEVICE_NOTIFY,
                                             acpi_video_device_notify);
-        if (ACPI_FAILURE(status))
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error removing notify handler\n"));
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
@@ -1632,7 +1577,6 @@ static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
         int status;
         struct list_head *node, *next;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_put_devices");
 
         list_for_each_safe(node, next, &video->video_device_list) {
                 struct acpi_video_device *data =
@@ -1651,7 +1595,7 @@ static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
                 kfree(data);
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 /* acpi_video interface */
@@ -1671,14 +1615,12 @@ 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_device *device = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_notify");
         printk("video bus notify\n");
 
         if (!video)
-                return_VOID;
+                return;
 
-        if (acpi_bus_get_device(handle, &device))
-                return_VOID;
+        device = video->device;
 
         switch (event) {
         case ACPI_VIDEO_NOTIFY_SWITCH:  /* User request that a switch occur,
@@ -1707,7 +1649,7 @@ static void acpi_video_bus_notify(acpi_handle handle, u32 event, void *data)
                 break;
         }
 
-        return_VOID;
+        return;
 }
 
 static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
@@ -1716,14 +1658,12 @@ static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
             (struct acpi_video_device *)data;
         struct acpi_device *device = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_video_device_notify");
 
         printk("video device notify\n");
         if (!video_device)
-                return_VOID;
+                return;
 
-        if (acpi_bus_get_device(handle, &device))
-                return_VOID;
+        device = video_device->dev;
 
         switch (event) {
         case ACPI_VIDEO_NOTIFY_SWITCH:  /* change in status (cycle output device) */
@@ -1743,7 +1683,7 @@ static void acpi_video_device_notify(acpi_handle handle, u32 event, void *data)
                                   "Unsupported event [0x%x]\n", event));
                 break;
         }
-        return_VOID;
+        return;
 }
 
 static int acpi_video_bus_add(struct acpi_device *device)
@@ -1752,17 +1692,16 @@ static int acpi_video_bus_add(struct acpi_device *device)
         acpi_status status = 0;
         struct acpi_video_bus *video = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_add");
 
         if (!device)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         video = kmalloc(sizeof(struct acpi_video_bus), GFP_KERNEL);
         if (!video)
-                return_VALUE(-ENOMEM);
+                return -ENOMEM;
         memset(video, 0, sizeof(struct acpi_video_bus));
 
-        video->handle = device->handle;
+        video->device = device;
         strcpy(acpi_device_name(device), ACPI_VIDEO_BUS_NAME);
         strcpy(acpi_device_class(device), ACPI_VIDEO_CLASS);
         acpi_driver_data(device) = video;
@@ -1782,7 +1721,7 @@ static int acpi_video_bus_add(struct acpi_device *device)
         acpi_video_bus_get_devices(video, device);
         acpi_video_bus_start_devices(video);
 
-        status = acpi_install_notify_handler(video->handle,
+        status = acpi_install_notify_handler(device->handle,
                                              ACPI_DEVICE_NOTIFY,
                                              acpi_video_bus_notify, video);
         if (ACPI_FAILURE(status)) {
@@ -1806,7 +1745,7 @@ static int acpi_video_bus_add(struct acpi_device *device)
         if (result)
                 kfree(video);
 
-        return_VALUE(result);
+        return result;
 }
 
 static int acpi_video_bus_remove(struct acpi_device *device, int type)
@@ -1814,21 +1753,17 @@ static int acpi_video_bus_remove(struct acpi_device *device, int type)
         acpi_status status = 0;
         struct acpi_video_bus *video = NULL;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_remove");
 
         if (!device || !acpi_driver_data(device))
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         video = (struct acpi_video_bus *)acpi_driver_data(device);
 
         acpi_video_bus_stop_devices(video);
 
-        status = acpi_remove_notify_handler(video->handle,
+        status = acpi_remove_notify_handler(video->device->handle,
                                             ACPI_DEVICE_NOTIFY,
                                             acpi_video_bus_notify);
-        if (ACPI_FAILURE(status))
-                ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
-                                  "Error removing notify handler\n"));
 
         acpi_video_bus_put_devices(video);
         acpi_video_bus_remove_fs(device);
@@ -1836,7 +1771,7 @@ static int acpi_video_bus_remove(struct acpi_device *device, int type)
         kfree(video->attached_array);
         kfree(video);
 
-        return_VALUE(0);
+        return 0;
 }
 
 static int
@@ -1846,10 +1781,9 @@ acpi_video_bus_match(struct acpi_device *device, struct acpi_driver *driver)
         acpi_handle h_dummy2;
         acpi_handle h_dummy3;
 
-        ACPI_FUNCTION_TRACE("acpi_video_bus_match");
 
         if (!device || !driver)
-                return_VALUE(-EINVAL);
+                return -EINVAL;
 
         /* Since there is no HID, CID for ACPI Video drivers, we have
          * to check well known required nodes for each feature we support.
@@ -1858,26 +1792,25 @@ acpi_video_bus_match(struct acpi_device *device, struct acpi_driver *driver)
         /* Does this device able to support video switching ? */
         if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_DOD", &h_dummy1)) &&
             ACPI_SUCCESS(acpi_get_handle(device->handle, "_DOS", &h_dummy2)))
-                return_VALUE(0);
+                return 0;
 
         /* Does this device able to retrieve a video ROM ? */
         if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_ROM", &h_dummy1)))
-                return_VALUE(0);
+                return 0;
 
         /* Does this device able to configure which video head to be POSTed ? */
         if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_VPO", &h_dummy1)) &&
             ACPI_SUCCESS(acpi_get_handle(device->handle, "_GPD", &h_dummy2)) &&
             ACPI_SUCCESS(acpi_get_handle(device->handle, "_SPD", &h_dummy3)))
-                return_VALUE(0);
+                return 0;
 
-        return_VALUE(-ENODEV);
+        return -ENODEV;
 }
 
 static int __init acpi_video_init(void)
 {
         int result = 0;
 
-        ACPI_FUNCTION_TRACE("acpi_video_init");
 
         /*
            acpi_dbg_level = 0xFFFFFFFF;
@@ -1886,27 +1819,26 @@ static int __init acpi_video_init(void)
 
         acpi_video_dir = proc_mkdir(ACPI_VIDEO_CLASS, acpi_root_dir);
         if (!acpi_video_dir)
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         acpi_video_dir->owner = THIS_MODULE;
 
         result = acpi_bus_register_driver(&acpi_video_bus);
         if (result < 0) {
                 remove_proc_entry(ACPI_VIDEO_CLASS, acpi_root_dir);
-                return_VALUE(-ENODEV);
+                return -ENODEV;
         }
 
-        return_VALUE(0);
+        return 0;
 }
 
 static void __exit acpi_video_exit(void)
 {
-        ACPI_FUNCTION_TRACE("acpi_video_exit");
 
         acpi_bus_unregister_driver(&acpi_video_bus);
 
         remove_proc_entry(ACPI_VIDEO_CLASS, acpi_root_dir);
 
-        return_VOID;
+        return;
 }
 
 module_init(acpi_video_init);