4 files changed, 99 insertions, 75 deletions

diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index 026e40755cdd..07c3c276ad34 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -64,7 +64,7 @@ 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);
-static int acpi_battery_resume(struct acpi_device *device, int status);
+static int acpi_battery_resume(struct acpi_device *device);
 
 static struct acpi_driver acpi_battery_driver = {
         .name = ACPI_BATTERY_DRIVER_NAME,
@@ -756,7 +756,7 @@ static int acpi_battery_remove(struct acpi_device *device, int type)
 }
 
 /* this is needed to learn about changes made in suspended state */
-static int acpi_battery_resume(struct acpi_device *device, int state)
+static int acpi_battery_resume(struct acpi_device *device)
 {
         struct acpi_battery *battery;
 
diff --git a/drivers/acpi/fan.c b/drivers/acpi/fan.c
index 045c89477e59..b24942041b3f 100644
--- a/drivers/acpi/fan.c
+++ b/drivers/acpi/fan.c
@@ -48,8 +48,8 @@ MODULE_LICENSE("GPL");
 
 static int acpi_fan_add(struct acpi_device *device);
 static int acpi_fan_remove(struct acpi_device *device, int type);
-static int acpi_fan_suspend(struct acpi_device *device, int state);
-static int acpi_fan_resume(struct acpi_device *device, int state);
+static int acpi_fan_suspend(struct acpi_device *device, pm_message_t state);
+static int acpi_fan_resume(struct acpi_device *device);
 
 static struct acpi_driver acpi_fan_driver = {
         .name = ACPI_FAN_DRIVER_NAME,
@@ -238,7 +238,7 @@ static int acpi_fan_remove(struct acpi_device *device, int type)
         return 0;
 }
 
-static int acpi_fan_suspend(struct acpi_device *device, int state)
+static int acpi_fan_suspend(struct acpi_device *device, pm_message_t state)
 {
         if (!device)
                 return -EINVAL;
@@ -248,7 +248,7 @@ static int acpi_fan_suspend(struct acpi_device *device, int state)
         return AE_OK;
 }
 
-static int acpi_fan_resume(struct acpi_device *device, int state)
+static int acpi_fan_resume(struct acpi_device *device)
 {
         int result = 0;
         int power_state = 0;
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index 5b42948ea97f..464746257d8e 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -222,100 +222,124 @@ acpi_eject_store(struct acpi_device *device, const char *buf, size_t count)
 /* --------------------------------------------------------------------------
                         ACPI Bus operations
    -------------------------------------------------------------------------- */
-static int root_suspend(struct acpi_device * acpi_dev, pm_message_t state)
+static int acpi_device_suspend(struct device *dev, pm_message_t state)
 {
-        struct acpi_device * dev, * next;
-        int result;
+        struct acpi_device *acpi_dev = to_acpi_device(dev);
+        struct acpi_driver *acpi_drv = acpi_dev->driver;
 
-        spin_lock(&acpi_device_lock);
-        list_for_each_entry_safe_reverse(dev, next, &acpi_device_list, g_list) {
-                if (dev->driver && dev->driver->ops.suspend) {
-                        spin_unlock(&acpi_device_lock);
-                        result = dev->driver->ops.suspend(dev, 0);
-                        if (result) {
-                                printk(KERN_ERR PREFIX "[%s - %s] Suspend failed: %d\n",
-                                       acpi_device_name(dev),
-                                       acpi_device_bid(dev), result);
-                        }
-                        spin_lock(&acpi_device_lock);
-                }
-        }
-        spin_unlock(&acpi_device_lock);
+        if (acpi_drv && acpi_drv->ops.suspend)
+                return acpi_drv->ops.suspend(acpi_dev, state);
         return 0;
 }
 
-static int acpi_device_suspend(struct device * dev, pm_message_t state)
+static int acpi_device_resume(struct device *dev)
 {
-        struct acpi_device * acpi_dev = to_acpi_device(dev);
+        struct acpi_device *acpi_dev = to_acpi_device(dev);
+        struct acpi_driver *acpi_drv = acpi_dev->driver;
 
-        /*
-         * For now, we should only register 1 generic device -
-         * the ACPI root device - and from there, we walk the
-         * tree of ACPI devices to suspend each one using the
-         * ACPI driver methods.
-         */
-        if (acpi_dev->handle == ACPI_ROOT_OBJECT)
-                root_suspend(acpi_dev, state);
+        if (acpi_drv && acpi_drv->ops.resume)
+                return acpi_drv->ops.resume(acpi_dev);
         return 0;
 }
 
-static int root_resume(struct acpi_device * acpi_dev)
+static int acpi_bus_match(struct device *dev, struct device_driver *drv)
 {
-        struct acpi_device * dev, * next;
-        int result;
+        struct acpi_device *acpi_dev = to_acpi_device(dev);
+        struct acpi_driver *acpi_drv = to_acpi_driver(drv);
 
-        spin_lock(&acpi_device_lock);
-        list_for_each_entry_safe(dev, next, &acpi_device_list, g_list) {
-                if (dev->driver && dev->driver->ops.resume) {
-                        spin_unlock(&acpi_device_lock);
-                        result = dev->driver->ops.resume(dev, 0);
-                        if (result) {
-                                printk(KERN_ERR PREFIX "[%s - %s] resume failed: %d\n",
-                                       acpi_device_name(dev),
-                                       acpi_device_bid(dev), result);
-                        }
-                        spin_lock(&acpi_device_lock);
+        if (acpi_drv->ops.match)
+                return !acpi_drv->ops.match(acpi_dev, acpi_drv);
+        return !acpi_match_ids(acpi_dev, acpi_drv->ids);
+}
+
+static int acpi_device_uevent(struct device *dev, char **envp, int num_envp,
+        char *buffer, int buffer_size)
+{
+        struct acpi_device *acpi_dev = to_acpi_device(dev);
+        int i = 0, length = 0, ret = 0;
+
+        if (acpi_dev->flags.hardware_id)
+                ret = add_uevent_var(envp, num_envp, &i,
+                        buffer, buffer_size, &length,
+                        "HWID=%s", acpi_dev->pnp.hardware_id);
+        if (ret)
+                return -ENOMEM;
+        if (acpi_dev->flags.compatible_ids) {
+                int j;
+                struct acpi_compatible_id_list *cid_list;
+
+                cid_list = acpi_dev->pnp.cid_list;
+
+                for (j = 0; j < cid_list->count; j++) {
+                        ret = add_uevent_var(envp, num_envp, &i, buffer,
+                                buffer_size, &length, "COMPTID=%s",
+                                cid_list->id[j].value);
+                        if (ret)
+                                return -ENOMEM;
                 }
         }
-        spin_unlock(&acpi_device_lock);
+
+        envp[i] = NULL;
         return 0;
 }
 
-static int acpi_device_resume(struct device * dev)
+static int acpi_bus_driver_init(struct acpi_device *, struct acpi_driver *);
+static int acpi_start_single_object(struct acpi_device *);
+static int acpi_device_probe(struct device * dev)
 {
-        struct acpi_device * acpi_dev = to_acpi_device(dev);
+        struct acpi_device *acpi_dev = to_acpi_device(dev);
+        struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
+        int ret;
+
+        ret = acpi_bus_driver_init(acpi_dev, acpi_drv);
+        if (!ret) {
+                acpi_start_single_object(acpi_dev);
+                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+                        "Found driver [%s] for device [%s]\n",
+                        acpi_drv->name, acpi_dev->pnp.bus_id));
+                get_device(dev);
+        }
+        return ret;
+}
 
-        /*
-         * For now, we should only register 1 generic device -
-         * the ACPI root device - and from there, we walk the
-         * tree of ACPI devices to resume each one using the
-         * ACPI driver methods.
-         */
-        if (acpi_dev->handle == ACPI_ROOT_OBJECT)
-                root_resume(acpi_dev);
+static int acpi_device_remove(struct device * dev)
+{
+        struct acpi_device *acpi_dev = to_acpi_device(dev);
+        struct acpi_driver *acpi_drv = acpi_dev->driver;
+
+        if (acpi_drv) {
+                if (acpi_drv->ops.stop)
+                        acpi_drv->ops.stop(acpi_dev, ACPI_BUS_REMOVAL_NORMAL);
+                if (acpi_drv->ops.remove)
+                        acpi_drv->ops.remove(acpi_dev, ACPI_BUS_REMOVAL_NORMAL);
+        }
+        acpi_dev->driver = NULL;
+        acpi_driver_data(dev) = NULL;
+
+        put_device(dev);
         return 0;
 }
 
-/**
- * acpi_bus_match - match device IDs to driver's supported IDs
- * @device: the device that we are trying to match to a driver
- * @driver: driver whose device id table is being checked
- *
- * Checks the device's hardware (_HID) or compatible (_CID) ids to see if it
- * matches the specified driver's criteria.
- */
-static int
-acpi_bus_match(struct acpi_device *device, struct acpi_driver *driver)
+static void acpi_device_shutdown(struct device *dev)
 {
-        if (driver && driver->ops.match)
-                return driver->ops.match(device, driver);
-        return acpi_match_ids(device, driver->ids);
+        struct acpi_device *acpi_dev = to_acpi_device(dev);
+        struct acpi_driver *acpi_drv = acpi_dev->driver;
+
+        if (acpi_drv && acpi_drv->ops.shutdown)
+                acpi_drv->ops.shutdown(acpi_dev);
+
+        return ;
 }
 
 static struct bus_type acpi_bus_type = {
         .name           = "acpi",
         .suspend        = acpi_device_suspend,
         .resume         = acpi_device_resume,
+        .shutdown       = acpi_device_shutdown,
+        .match          = acpi_bus_match,
+        .probe          = acpi_device_probe,
+        .remove         = acpi_device_remove,
+        .uevent         = acpi_device_uevent,
 };
 
 static void acpi_device_register(struct acpi_device *device,
@@ -449,7 +473,7 @@ static void acpi_driver_attach(struct acpi_driver *drv)
                         continue;
                 spin_unlock(&acpi_device_lock);
 
-                if (!acpi_bus_match(dev, drv)) {
+                if (!acpi_bus_match(&(dev->dev), &(drv->drv))) {
                         if (!acpi_bus_driver_init(dev, drv)) {
                                 acpi_start_single_object(dev);
                                 atomic_inc(&drv->references);
@@ -551,7 +575,7 @@ static int acpi_bus_find_driver(struct acpi_device *device)
 
                 atomic_inc(&driver->references);
                 spin_unlock(&acpi_device_lock);
-                if (!acpi_bus_match(device, driver)) {
+                if (!acpi_bus_match(&(device->dev), &(driver->drv))) {
                         result = acpi_bus_driver_init(device, driver);
                         if (!result)
                                 goto Done;
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index 5753d06b7860..3650654f878e 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -82,7 +82,7 @@ MODULE_PARM_DESC(tzp, "Thermal zone polling frequency, in 1/10 seconds.\n");
 
 static int acpi_thermal_add(struct acpi_device *device);
 static int acpi_thermal_remove(struct acpi_device *device, int type);
-static int acpi_thermal_resume(struct acpi_device *device, int state);
+static int acpi_thermal_resume(struct acpi_device *device);
 static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file);
 static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file);
 static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file);
@@ -1356,7 +1356,7 @@ static int acpi_thermal_remove(struct acpi_device *device, int type)
         return 0;
 }
 
-static int acpi_thermal_resume(struct acpi_device *device, int state)
+static int acpi_thermal_resume(struct acpi_device *device)
 {
         struct acpi_thermal *tz = NULL;
         int i;