Pull trivial into test branch
[sfrench/cifs-2.6.git] / drivers / acpi / scan.c
index 2e0fc8c3b58b88612bccdde575714a546e9b9798..64f26db10c8efd765fcde8e8d0eb821b3a06efc2 100644 (file)
@@ -21,470 +21,408 @@ extern struct acpi_device *acpi_root;
 #define ACPI_BUS_DEVICE_NAME           "System Bus"
 
 static LIST_HEAD(acpi_device_list);
+static LIST_HEAD(acpi_bus_id_list);
 DEFINE_SPINLOCK(acpi_device_lock);
 LIST_HEAD(acpi_wakeup_device_list);
 
-
-static void acpi_device_release(struct kobject *kobj)
+struct acpi_device_bus_id{
+       char bus_id[15];
+       unsigned int instance_no;
+       struct list_head node;
+};
+static int acpi_eject_operation(acpi_handle handle, int lockable)
 {
-       struct acpi_device *dev = container_of(kobj, struct acpi_device, kobj);
-       kfree(dev->pnp.cid_list);
-       kfree(dev);
-}
+       struct acpi_object_list arg_list;
+       union acpi_object arg;
+       acpi_status status = AE_OK;
 
-struct acpi_device_attribute {
-       struct attribute attr;
-        ssize_t(*show) (struct acpi_device *, char *);
-        ssize_t(*store) (struct acpi_device *, const char *, size_t);
-};
+       /*
+        * TBD: evaluate _PS3?
+        */
 
-typedef void acpi_device_sysfs_files(struct kobject *,
-                                    const struct attribute *);
+       if (lockable) {
+               arg_list.count = 1;
+               arg_list.pointer = &arg;
+               arg.type = ACPI_TYPE_INTEGER;
+               arg.integer.value = 0;
+               acpi_evaluate_object(handle, "_LCK", &arg_list, NULL);
+       }
 
-static void setup_sys_fs_device_files(struct acpi_device *dev,
-                                     acpi_device_sysfs_files * func);
+       arg_list.count = 1;
+       arg_list.pointer = &arg;
+       arg.type = ACPI_TYPE_INTEGER;
+       arg.integer.value = 1;
 
-#define create_sysfs_device_files(dev) \
-       setup_sys_fs_device_files(dev, (acpi_device_sysfs_files *)&sysfs_create_file)
-#define remove_sysfs_device_files(dev) \
-       setup_sys_fs_device_files(dev, (acpi_device_sysfs_files *)&sysfs_remove_file)
+       /*
+        * TBD: _EJD support.
+        */
 
-#define to_acpi_device(n) container_of(n, struct acpi_device, kobj)
-#define to_handle_attr(n) container_of(n, struct acpi_device_attribute, attr);
+       status = acpi_evaluate_object(handle, "_EJ0", &arg_list, NULL);
+       if (ACPI_FAILURE(status)) {
+               return (-ENODEV);
+       }
 
-static ssize_t acpi_device_attr_show(struct kobject *kobj,
-                                    struct attribute *attr, char *buf)
-{
-       struct acpi_device *device = to_acpi_device(kobj);
-       struct acpi_device_attribute *attribute = to_handle_attr(attr);
-       return attribute->show ? attribute->show(device, buf) : -EIO;
-}
-static ssize_t acpi_device_attr_store(struct kobject *kobj,
-                                     struct attribute *attr, const char *buf,
-                                     size_t len)
-{
-       struct acpi_device *device = to_acpi_device(kobj);
-       struct acpi_device_attribute *attribute = to_handle_attr(attr);
-       return attribute->store ? attribute->store(device, buf, len) : -EIO;
+       return (0);
 }
 
-static struct sysfs_ops acpi_device_sysfs_ops = {
-       .show = acpi_device_attr_show,
-       .store = acpi_device_attr_store,
-};
-
-static struct kobj_type ktype_acpi_ns = {
-       .sysfs_ops = &acpi_device_sysfs_ops,
-       .release = acpi_device_release,
-};
-
-static int namespace_uevent(struct kset *kset, struct kobject *kobj,
-                            char **envp, int num_envp, char *buffer,
-                            int buffer_size)
+static ssize_t
+acpi_eject_store(struct device *d, struct device_attribute *attr,
+               const char *buf, size_t count)
 {
-       struct acpi_device *dev = to_acpi_device(kobj);
-       int i = 0;
-       int len = 0;
-
-       if (!dev->driver)
-               return 0;
-
-       if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
-                          "PHYSDEVDRIVER=%s", dev->driver->name))
-               return -ENOMEM;
+       int result;
+       int ret = count;
+       int islockable;
+       acpi_status status;
+       acpi_handle handle;
+       acpi_object_type type = 0;
+       struct acpi_device *acpi_device = to_acpi_device(d);
 
-       envp[i] = NULL;
+       if ((!count) || (buf[0] != '1')) {
+               return -EINVAL;
+       }
+#ifndef FORCE_EJECT
+       if (acpi_device->driver == NULL) {
+               ret = -ENODEV;
+               goto err;
+       }
+#endif
+       status = acpi_get_type(acpi_device->handle, &type);
+       if (ACPI_FAILURE(status) || (!acpi_device->flags.ejectable)) {
+               ret = -ENODEV;
+               goto err;
+       }
 
-       return 0;
-}
+       islockable = acpi_device->flags.lockable;
+       handle = acpi_device->handle;
 
-static struct kset_uevent_ops namespace_uevent_ops = {
-       .uevent = &namespace_uevent,
-};
+       result = acpi_bus_trim(acpi_device, 1);
 
-static struct kset acpi_namespace_kset = {
-       .kobj = {
-                .name = "namespace",
-                },
-       .subsys = &acpi_subsys,
-       .ktype = &ktype_acpi_ns,
-       .uevent_ops = &namespace_uevent_ops,
-};
+       if (!result)
+               result = acpi_eject_operation(handle, islockable);
 
-static void acpi_device_register(struct acpi_device *device,
-                                struct acpi_device *parent)
-{
-       int err;
+       if (result) {
+               ret = -EBUSY;
+       }
+      err:
+       return ret;
+}
 
-       /*
-        * Linkage
-        * -------
-        * Link this device to its parent and siblings.
-        */
-       INIT_LIST_HEAD(&device->children);
-       INIT_LIST_HEAD(&device->node);
-       INIT_LIST_HEAD(&device->g_list);
-       INIT_LIST_HEAD(&device->wakeup_list);
+static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
 
-       spin_lock(&acpi_device_lock);
-       if (device->parent) {
-               list_add_tail(&device->node, &device->parent->children);
-               list_add_tail(&device->g_list, &device->parent->g_list);
-       } else
-               list_add_tail(&device->g_list, &acpi_device_list);
-       if (device->wakeup.flags.valid)
-               list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
-       spin_unlock(&acpi_device_lock);
+static ssize_t
+acpi_device_hid_show(struct device *dev, struct device_attribute *attr, char *buf) {
+       struct acpi_device *acpi_dev = to_acpi_device(dev);
 
-       strlcpy(device->kobj.name, device->pnp.bus_id, KOBJ_NAME_LEN);
-       if (parent)
-               device->kobj.parent = &parent->kobj;
-       device->kobj.ktype = &ktype_acpi_ns;
-       device->kobj.kset = &acpi_namespace_kset;
-       err = kobject_register(&device->kobj);
-       if (err < 0)
-               printk(KERN_WARNING "%s: kobject_register error: %d\n",
-                       __FUNCTION__, err);
-       create_sysfs_device_files(device);
+       return sprintf(buf, "%s\n", acpi_dev->pnp.hardware_id);
 }
+static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
 
-static void acpi_device_unregister(struct acpi_device *device, int type)
-{
-       spin_lock(&acpi_device_lock);
-       if (device->parent) {
-               list_del(&device->node);
-               list_del(&device->g_list);
-       } else
-               list_del(&device->g_list);
-
-       list_del(&device->wakeup_list);
+static ssize_t
+acpi_device_path_show(struct device *dev, struct device_attribute *attr, char *buf) {
+       struct acpi_device *acpi_dev = to_acpi_device(dev);
+       struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
+       int result;
 
-       spin_unlock(&acpi_device_lock);
+       result = acpi_get_name(acpi_dev->handle, ACPI_FULL_PATHNAME, &path);
+       if(result)
+               goto end;
 
-       acpi_detach_data(device->handle, acpi_bus_data_handler);
-       remove_sysfs_device_files(device);
-       kobject_unregister(&device->kobj);
+       result = sprintf(buf, "%s\n", (char*)path.pointer);
+       kfree(path.pointer);
+  end:
+       return result;
 }
+static DEVICE_ATTR(path, 0444, acpi_device_path_show, NULL);
 
-void acpi_bus_data_handler(acpi_handle handle, u32 function, void *context)
+static int acpi_device_setup_files(struct acpi_device *dev)
 {
+       acpi_status status;
+       acpi_handle temp;
+       int result = 0;
 
-       /* TBD */
+       /*
+        * Devices gotten from FADT don't have a "path" attribute
+        */
+       if(dev->handle) {
+               result = device_create_file(&dev->dev, &dev_attr_path);
+               if(result)
+                       goto end;
+       }
 
-       return;
+       if(dev->flags.hardware_id) {
+               result = device_create_file(&dev->dev, &dev_attr_hid);
+               if(result)
+                       goto end;
+       }
+
+        /*
+         * If device has _EJ0, 'eject' file is created that is used to trigger
+         * hot-removal function from userland.
+         */
+       status = acpi_get_handle(dev->handle, "_EJ0", &temp);
+       if (ACPI_SUCCESS(status))
+               result = device_create_file(&dev->dev, &dev_attr_eject);
+  end:
+       return result;
 }
 
-static int acpi_bus_get_power_flags(struct acpi_device *device)
+static void acpi_device_remove_files(struct acpi_device *dev)
 {
-       acpi_status status = 0;
-       acpi_handle handle = NULL;
-       u32 i = 0;
-
+       acpi_status status;
+       acpi_handle temp;
 
        /*
-        * Power Management Flags
+        * If device has _EJ0, 'eject' file is created that is used to trigger
+        * hot-removal function from userland.
         */
-       status = acpi_get_handle(device->handle, "_PSC", &handle);
-       if (ACPI_SUCCESS(status))
-               device->power.flags.explicit_get = 1;
-       status = acpi_get_handle(device->handle, "_IRC", &handle);
+       status = acpi_get_handle(dev->handle, "_EJ0", &temp);
        if (ACPI_SUCCESS(status))
-               device->power.flags.inrush_current = 1;
-
-       /*
-        * Enumerate supported power management states
-        */
-       for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3; i++) {
-               struct acpi_device_power_state *ps = &device->power.states[i];
-               char object_name[5] = { '_', 'P', 'R', '0' + i, '\0' };
-
-               /* Evaluate "_PRx" to se if power resources are referenced */
-               acpi_evaluate_reference(device->handle, object_name, NULL,
-                                       &ps->resources);
-               if (ps->resources.count) {
-                       device->power.flags.power_resources = 1;
-                       ps->flags.valid = 1;
-               }
-
-               /* Evaluate "_PSx" to see if we can do explicit sets */
-               object_name[2] = 'S';
-               status = acpi_get_handle(device->handle, object_name, &handle);
-               if (ACPI_SUCCESS(status)) {
-                       ps->flags.explicit_set = 1;
-                       ps->flags.valid = 1;
-               }
-
-               /* State is valid if we have some power control */
-               if (ps->resources.count || ps->flags.explicit_set)
-                       ps->flags.valid = 1;
-
-               ps->power = -1; /* Unknown - driver assigned */
-               ps->latency = -1;       /* Unknown - driver assigned */
-       }
+               device_remove_file(&dev->dev, &dev_attr_eject);
 
-       /* Set defaults for D0 and D3 states (always valid) */
-       device->power.states[ACPI_STATE_D0].flags.valid = 1;
-       device->power.states[ACPI_STATE_D0].power = 100;
-       device->power.states[ACPI_STATE_D3].flags.valid = 1;
-       device->power.states[ACPI_STATE_D3].power = 0;
+       if(dev->flags.hardware_id)
+               device_remove_file(&dev->dev, &dev_attr_hid);
+       if(dev->handle)
+               device_remove_file(&dev->dev, &dev_attr_path);
+}
+/* --------------------------------------------------------------------------
+                       ACPI Bus operations
+   -------------------------------------------------------------------------- */
+static void acpi_device_release(struct device *dev)
+{
+       struct acpi_device *acpi_dev = to_acpi_device(dev);
 
-       /* TBD: System wake support and resource requirements. */
+       kfree(acpi_dev->pnp.cid_list);
+       kfree(acpi_dev);
+}
 
-       device->power.state = ACPI_STATE_UNKNOWN;
+static int acpi_device_suspend(struct device *dev, pm_message_t state)
+{
+       struct acpi_device *acpi_dev = to_acpi_device(dev);
+       struct acpi_driver *acpi_drv = acpi_dev->driver;
 
+       if (acpi_drv && acpi_drv->ops.suspend)
+               return acpi_drv->ops.suspend(acpi_dev, state);
        return 0;
 }
 
-int acpi_match_ids(struct acpi_device *device, char *ids)
+static int acpi_device_resume(struct device *dev)
 {
-       if (device->flags.hardware_id)
-               if (strstr(ids, device->pnp.hardware_id))
-                       return 0;
+       struct acpi_device *acpi_dev = to_acpi_device(dev);
+       struct acpi_driver *acpi_drv = acpi_dev->driver;
 
-       if (device->flags.compatible_ids) {
-               struct acpi_compatible_id_list *cid_list = device->pnp.cid_list;
-               int i;
-
-               /* compare multiple _CID entries against driver ids */
-               for (i = 0; i < cid_list->count; i++) {
-                       if (strstr(ids, cid_list->id[i].value))
-                               return 0;
-               }
-       }
-       return -ENOENT;
+       if (acpi_drv && acpi_drv->ops.resume)
+               return acpi_drv->ops.resume(acpi_dev);
+       return 0;
 }
 
-static acpi_status
-acpi_bus_extract_wakeup_device_power_package(struct acpi_device *device,
-                                            union acpi_object *package)
+static int acpi_bus_match(struct device *dev, struct device_driver *drv)
 {
-       int i = 0;
-       union acpi_object *element = NULL;
-
-       if (!device || !package || (package->package.count < 2))
-               return AE_BAD_PARAMETER;
-
-       element = &(package->package.elements[0]);
-       if (!element)
-               return AE_BAD_PARAMETER;
-       if (element->type == ACPI_TYPE_PACKAGE) {
-               if ((element->package.count < 2) ||
-                   (element->package.elements[0].type !=
-                    ACPI_TYPE_LOCAL_REFERENCE)
-                   || (element->package.elements[1].type != ACPI_TYPE_INTEGER))
-                       return AE_BAD_DATA;
-               device->wakeup.gpe_device =
-                   element->package.elements[0].reference.handle;
-               device->wakeup.gpe_number =
-                   (u32) element->package.elements[1].integer.value;
-       } else if (element->type == ACPI_TYPE_INTEGER) {
-               device->wakeup.gpe_number = element->integer.value;
-       } else
-               return AE_BAD_DATA;
-
-       element = &(package->package.elements[1]);
-       if (element->type != ACPI_TYPE_INTEGER) {
-               return AE_BAD_DATA;
-       }
-       device->wakeup.sleep_state = element->integer.value;
-
-       if ((package->package.count - 2) > ACPI_MAX_HANDLES) {
-               return AE_NO_MEMORY;
-       }
-       device->wakeup.resources.count = package->package.count - 2;
-       for (i = 0; i < device->wakeup.resources.count; i++) {
-               element = &(package->package.elements[i + 2]);
-               if (element->type != ACPI_TYPE_ANY) {
-                       return AE_BAD_DATA;
-               }
-
-               device->wakeup.resources.handles[i] = element->reference.handle;
-       }
+       struct acpi_device *acpi_dev = to_acpi_device(dev);
+       struct acpi_driver *acpi_drv = to_acpi_driver(drv);
 
-       return AE_OK;
+       return !acpi_match_ids(acpi_dev, acpi_drv->ids);
 }
 
-static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
+static int acpi_device_uevent(struct device *dev, char **envp, int num_envp,
+       char *buffer, int buffer_size)
 {
-       acpi_status status = 0;
-       struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
-       union acpi_object *package = NULL;
-
-
-       /* _PRW */
-       status = acpi_evaluate_object(device->handle, "_PRW", NULL, &buffer);
-       if (ACPI_FAILURE(status)) {
-               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_EXCEPTION((AE_INFO, status, "Extracting _PRW package"));
-               goto end;
+       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;
+               }
        }
 
-       kfree(buffer.pointer);
-
-       device->wakeup.flags.valid = 1;
-       /* Power button, Lid switch always enable wakeup */
-       if (!acpi_match_ids(device, "PNP0C0D,PNP0C0C,PNP0C0E"))
-               device->wakeup.flags.run_wake = 1;
-
-      end:
-       if (ACPI_FAILURE(status))
-               device->flags.wake_capable = 0;
+       envp[i] = NULL;
        return 0;
 }
 
-/* --------------------------------------------------------------------------
-               ACPI sysfs device file support
-   -------------------------------------------------------------------------- */
-static ssize_t acpi_eject_store(struct acpi_device *device,
-                               const char *buf, size_t count);
-
-#define ACPI_DEVICE_ATTR(_name,_mode,_show,_store) \
-static struct acpi_device_attribute acpi_device_attr_##_name = \
-               __ATTR(_name, _mode, _show, _store)
-
-ACPI_DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
-
-/**
- * setup_sys_fs_device_files - sets up the device files under device namespace
- * @dev:       acpi_device object
- * @func:      function pointer to create or destroy the device file
- */
-static void
-setup_sys_fs_device_files(struct acpi_device *dev,
-                         acpi_device_sysfs_files * func)
+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)
 {
-       acpi_status status;
-       acpi_handle temp = NULL;
-
-       /*
-        * If device has _EJ0, 'eject' file is created that is used to trigger
-        * hot-removal function from userland.
-        */
-       status = acpi_get_handle(dev->handle, "_EJ0", &temp);
-       if (ACPI_SUCCESS(status))
-               (*(func)) (&dev->kobj, &acpi_device_attr_eject.attr);
+       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) {
+               if (acpi_dev->bus_ops.acpi_op_start)
+                       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;
 }
-
-static int acpi_eject_operation(acpi_handle handle, int lockable)
-{
-       struct acpi_object_list arg_list;
-       union acpi_object arg;
-       acpi_status status = AE_OK;
-
-       /*
-        * TBD: evaluate _PS3?
-        */
-
-       if (lockable) {
-               arg_list.count = 1;
-               arg_list.pointer = &arg;
-               arg.type = ACPI_TYPE_INTEGER;
-               arg.integer.value = 0;
-               acpi_evaluate_object(handle, "_LCK", &arg_list, NULL);
+
+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_dev->removal_type);
+               if (acpi_drv->ops.remove)
+                       acpi_drv->ops.remove(acpi_dev, acpi_dev->removal_type);
        }
+       acpi_dev->driver = NULL;
+       acpi_driver_data(dev) = NULL;
 
-       arg_list.count = 1;
-       arg_list.pointer = &arg;
-       arg.type = ACPI_TYPE_INTEGER;
-       arg.integer.value = 1;
+       put_device(dev);
+       return 0;
+}
 
-       /*
-        * TBD: _EJD support.
-        */
+static void acpi_device_shutdown(struct device *dev)
+{
+       struct acpi_device *acpi_dev = to_acpi_device(dev);
+       struct acpi_driver *acpi_drv = acpi_dev->driver;
 
-       status = acpi_evaluate_object(handle, "_EJ0", &arg_list, NULL);
-       if (ACPI_FAILURE(status)) {
-               return (-ENODEV);
-       }
+       if (acpi_drv && acpi_drv->ops.shutdown)
+               acpi_drv->ops.shutdown(acpi_dev);
 
-       return (0);
+       return ;
 }
 
-static ssize_t
-acpi_eject_store(struct acpi_device *device, const char *buf, size_t count)
+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 int acpi_device_register(struct acpi_device *device,
+                                struct acpi_device *parent)
 {
        int result;
-       int ret = count;
-       int islockable;
-       acpi_status status;
-       acpi_handle handle;
-       acpi_object_type type = 0;
+       struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
+       int found = 0;
+       /*
+        * Linkage
+        * -------
+        * Link this device to its parent and siblings.
+        */
+       INIT_LIST_HEAD(&device->children);
+       INIT_LIST_HEAD(&device->node);
+       INIT_LIST_HEAD(&device->g_list);
+       INIT_LIST_HEAD(&device->wakeup_list);
 
-       if ((!count) || (buf[0] != '1')) {
-               return -EINVAL;
+       new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
+       if (!new_bus_id) {
+               printk(KERN_ERR PREFIX "Memory allocation error\n");
+               return -ENOMEM;
        }
-#ifndef FORCE_EJECT
-       if (device->driver == NULL) {
-               ret = -ENODEV;
-               goto err;
+
+       spin_lock(&acpi_device_lock);
+       /*
+        * Find suitable bus_id and instance number in acpi_bus_id_list
+        * If failed, create one and link it into acpi_bus_id_list
+        */
+       list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
+               if(!strcmp(acpi_device_bus_id->bus_id, device->flags.hardware_id? device->pnp.hardware_id : "device")) {
+                       acpi_device_bus_id->instance_no ++;
+                       found = 1;
+                       kfree(new_bus_id);
+                       break;
+               }
        }
-#endif
-       status = acpi_get_type(device->handle, &type);
-       if (ACPI_FAILURE(status) || (!device->flags.ejectable)) {
-               ret = -ENODEV;
-               goto err;
+       if(!found) {
+               acpi_device_bus_id = new_bus_id;
+               strcpy(acpi_device_bus_id->bus_id, device->flags.hardware_id ? device->pnp.hardware_id : "device");
+               acpi_device_bus_id->instance_no = 0;
+               list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
        }
+       sprintf(device->dev.bus_id, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);
 
-       islockable = device->flags.lockable;
-       handle = device->handle;
-
-       result = acpi_bus_trim(device, 1);
-
-       if (!result)
-               result = acpi_eject_operation(handle, islockable);
+       if (device->parent) {
+               list_add_tail(&device->node, &device->parent->children);
+               list_add_tail(&device->g_list, &device->parent->g_list);
+       } else
+               list_add_tail(&device->g_list, &acpi_device_list);
+       if (device->wakeup.flags.valid)
+               list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
+       spin_unlock(&acpi_device_lock);
 
-       if (result) {
-               ret = -EBUSY;
+       if (device->parent)
+               device->dev.parent = &parent->dev;
+       device->dev.bus = &acpi_bus_type;
+       device_initialize(&device->dev);
+       device->dev.release = &acpi_device_release;
+       result = device_add(&device->dev);
+       if(result) {
+               printk("Error adding device %s", device->dev.bus_id);
+               goto end;
        }
-      err:
-       return ret;
-}
 
-/* --------------------------------------------------------------------------
-                              Performance Management
-   -------------------------------------------------------------------------- */
+       result = acpi_device_setup_files(device);
+       if(result)
+               ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error creating sysfs interface for device %s\n", device->dev.bus_id));
 
-static int acpi_bus_get_perf_flags(struct acpi_device *device)
-{
-       device->performance.state = ACPI_STATE_UNKNOWN;
+       device->removal_type = ACPI_BUS_REMOVAL_NORMAL;
        return 0;
+  end:
+       spin_lock(&acpi_device_lock);
+       if (device->parent) {
+               list_del(&device->node);
+               list_del(&device->g_list);
+       } else
+               list_del(&device->g_list);
+       list_del(&device->wakeup_list);
+       spin_unlock(&acpi_device_lock);
+       return result;
 }
 
-/* --------------------------------------------------------------------------
-                                 Driver Management
-   -------------------------------------------------------------------------- */
+static void acpi_device_unregister(struct acpi_device *device, int type)
+{
+       spin_lock(&acpi_device_lock);
+       if (device->parent) {
+               list_del(&device->node);
+               list_del(&device->g_list);
+       } else
+               list_del(&device->g_list);
 
-static LIST_HEAD(acpi_bus_drivers);
+       list_del(&device->wakeup_list);
+       spin_unlock(&acpi_device_lock);
 
-/**
- * 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)
-{
-       if (driver && driver->ops.match)
-               return driver->ops.match(device, driver);
-       return acpi_match_ids(device, driver->ids);
+       acpi_detach_data(device->handle, acpi_bus_data_handler);
+
+       acpi_device_remove_files(device);
+       device_unregister(&device->dev);
 }
 
+/* --------------------------------------------------------------------------
+                                 Driver Management
+   -------------------------------------------------------------------------- */
 /**
  * acpi_bus_driver_init - add a device to a driver
  * @device: the device to add and initialize
  * @driver: driver for the device
  *
  * Used to initialize a device via its device driver.  Called whenever a 
- * driver is bound to a device.  Invokes the driver's add() and start() ops.
+ * driver is bound to a device.  Invokes the driver's add() ops.
  */
 static int
 acpi_bus_driver_init(struct acpi_device *device, struct acpi_driver *driver)
@@ -535,162 +473,246 @@ static int acpi_start_single_object(struct acpi_device *device)
        return result;
 }
 
-static void acpi_driver_attach(struct acpi_driver *drv)
+/**
+ * acpi_bus_register_driver - register a driver with the ACPI bus
+ * @driver: driver being registered
+ *
+ * Registers a driver with the ACPI bus.  Searches the namespace for all
+ * devices that match the driver's criteria and binds.  Returns zero for
+ * success or a negative error status for failure.
+ */
+int acpi_bus_register_driver(struct acpi_driver *driver)
 {
-       struct list_head *node, *next;
+       int ret;
 
+       if (acpi_disabled)
+               return -ENODEV;
+       driver->drv.name = driver->name;
+       driver->drv.bus = &acpi_bus_type;
+       driver->drv.owner = driver->owner;
 
-       spin_lock(&acpi_device_lock);
-       list_for_each_safe(node, next, &acpi_device_list) {
-               struct acpi_device *dev =
-                   container_of(node, struct acpi_device, g_list);
+       ret = driver_register(&driver->drv);
+       return ret;
+}
 
-               if (dev->driver || !dev->status.present)
-                       continue;
-               spin_unlock(&acpi_device_lock);
-
-               if (!acpi_bus_match(dev, drv)) {
-                       if (!acpi_bus_driver_init(dev, drv)) {
-                               acpi_start_single_object(dev);
-                               atomic_inc(&drv->references);
-                               ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                                 "Found driver [%s] for device [%s]\n",
-                                                 drv->name, dev->pnp.bus_id));
-                       }
+EXPORT_SYMBOL(acpi_bus_register_driver);
+
+/**
+ * acpi_bus_unregister_driver - unregisters a driver with the APIC bus
+ * @driver: driver to unregister
+ *
+ * Unregisters a driver with the ACPI bus.  Searches the namespace for all
+ * devices that match the driver's criteria and unbinds.
+ */
+void acpi_bus_unregister_driver(struct acpi_driver *driver)
+{
+       driver_unregister(&driver->drv);
+}
+
+EXPORT_SYMBOL(acpi_bus_unregister_driver);
+
+/* --------------------------------------------------------------------------
+                                 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);
+
+void acpi_bus_data_handler(acpi_handle handle, u32 function, void *context)
+{
+
+       /* TBD */
+
+       return;
+}
+
+int acpi_match_ids(struct acpi_device *device, char *ids)
+{
+       if (device->flags.hardware_id)
+               if (strstr(ids, device->pnp.hardware_id))
+                       return 0;
+
+       if (device->flags.compatible_ids) {
+               struct acpi_compatible_id_list *cid_list = device->pnp.cid_list;
+               int i;
+
+               /* compare multiple _CID entries against driver ids */
+               for (i = 0; i < cid_list->count; i++) {
+                       if (strstr(ids, cid_list->id[i].value))
+                               return 0;
                }
-               spin_lock(&acpi_device_lock);
        }
-       spin_unlock(&acpi_device_lock);
+       return -ENOENT;
+}
+
+static int acpi_bus_get_perf_flags(struct acpi_device *device)
+{
+       device->performance.state = ACPI_STATE_UNKNOWN;
+       return 0;
 }
 
-static void acpi_driver_detach(struct acpi_driver *drv)
+static acpi_status
+acpi_bus_extract_wakeup_device_power_package(struct acpi_device *device,
+                                            union acpi_object *package)
 {
-       struct list_head *node, *next;
+       int i = 0;
+       union acpi_object *element = NULL;
 
+       if (!device || !package || (package->package.count < 2))
+               return AE_BAD_PARAMETER;
 
-       spin_lock(&acpi_device_lock);
-       list_for_each_safe(node, next, &acpi_device_list) {
-               struct acpi_device *dev =
-                   container_of(node, struct acpi_device, g_list);
-
-               if (dev->driver == drv) {
-                       spin_unlock(&acpi_device_lock);
-                       if (drv->ops.remove)
-                               drv->ops.remove(dev, ACPI_BUS_REMOVAL_NORMAL);
-                       spin_lock(&acpi_device_lock);
-                       dev->driver = NULL;
-                       dev->driver_data = NULL;
-                       atomic_dec(&drv->references);
+       element = &(package->package.elements[0]);
+       if (!element)
+               return AE_BAD_PARAMETER;
+       if (element->type == ACPI_TYPE_PACKAGE) {
+               if ((element->package.count < 2) ||
+                   (element->package.elements[0].type !=
+                    ACPI_TYPE_LOCAL_REFERENCE)
+                   || (element->package.elements[1].type != ACPI_TYPE_INTEGER))
+                       return AE_BAD_DATA;
+               device->wakeup.gpe_device =
+                   element->package.elements[0].reference.handle;
+               device->wakeup.gpe_number =
+                   (u32) element->package.elements[1].integer.value;
+       } else if (element->type == ACPI_TYPE_INTEGER) {
+               device->wakeup.gpe_number = element->integer.value;
+       } else
+               return AE_BAD_DATA;
+
+       element = &(package->package.elements[1]);
+       if (element->type != ACPI_TYPE_INTEGER) {
+               return AE_BAD_DATA;
+       }
+       device->wakeup.sleep_state = element->integer.value;
+
+       if ((package->package.count - 2) > ACPI_MAX_HANDLES) {
+               return AE_NO_MEMORY;
+       }
+       device->wakeup.resources.count = package->package.count - 2;
+       for (i = 0; i < device->wakeup.resources.count; i++) {
+               element = &(package->package.elements[i + 2]);
+               if (element->type != ACPI_TYPE_ANY) {
+                       return AE_BAD_DATA;
                }
+
+               device->wakeup.resources.handles[i] = element->reference.handle;
+       }
+
+       return AE_OK;
+}
+
+static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
+{
+       acpi_status status = 0;
+       struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+       union acpi_object *package = NULL;
+
+
+       /* _PRW */
+       status = acpi_evaluate_object(device->handle, "_PRW", NULL, &buffer);
+       if (ACPI_FAILURE(status)) {
+               ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
+               goto end;
        }
-       spin_unlock(&acpi_device_lock);
-}
 
-/**
- * acpi_bus_register_driver - register a driver with the ACPI bus
- * @driver: driver being registered
- *
- * Registers a driver with the ACPI bus.  Searches the namespace for all
- * devices that match the driver's criteria and binds.  Returns zero for
- * success or a negative error status for failure.
- */
-int acpi_bus_register_driver(struct acpi_driver *driver)
-{
+       package = (union acpi_object *)buffer.pointer;
+       status = acpi_bus_extract_wakeup_device_power_package(device, package);
+       if (ACPI_FAILURE(status)) {
+               ACPI_EXCEPTION((AE_INFO, status, "Extracting _PRW package"));
+               goto end;
+       }
 
-       if (acpi_disabled)
-               return -ENODEV;
+       kfree(buffer.pointer);
 
-       spin_lock(&acpi_device_lock);
-       list_add_tail(&driver->node, &acpi_bus_drivers);
-       spin_unlock(&acpi_device_lock);
-       acpi_driver_attach(driver);
+       device->wakeup.flags.valid = 1;
+       /* Power button, Lid switch always enable wakeup */
+       if (!acpi_match_ids(device, "PNP0C0D,PNP0C0C,PNP0C0E"))
+               device->wakeup.flags.run_wake = 1;
 
+      end:
+       if (ACPI_FAILURE(status))
+               device->flags.wake_capable = 0;
        return 0;
 }
 
-EXPORT_SYMBOL(acpi_bus_register_driver);
-
-/**
- * acpi_bus_unregister_driver - unregisters a driver with the APIC bus
- * @driver: driver to unregister
- *
- * Unregisters a driver with the ACPI bus.  Searches the namespace for all
- * devices that match the driver's criteria and unbinds.
- */
-void acpi_bus_unregister_driver(struct acpi_driver *driver)
+static int acpi_bus_get_power_flags(struct acpi_device *device)
 {
-       acpi_driver_detach(driver);
+       acpi_status status = 0;
+       acpi_handle handle = NULL;
+       u32 i = 0;
 
-       if (!atomic_read(&driver->references)) {
-               spin_lock(&acpi_device_lock);
-               list_del_init(&driver->node);
-               spin_unlock(&acpi_device_lock);
-       }
-       return;
-}
 
-EXPORT_SYMBOL(acpi_bus_unregister_driver);
+       /*
+        * Power Management Flags
+        */
+       status = acpi_get_handle(device->handle, "_PSC", &handle);
+       if (ACPI_SUCCESS(status))
+               device->power.flags.explicit_get = 1;
+       status = acpi_get_handle(device->handle, "_IRC", &handle);
+       if (ACPI_SUCCESS(status))
+               device->power.flags.inrush_current = 1;
 
-/**
- * acpi_bus_find_driver - check if there is a driver installed for the device
- * @device: device that we are trying to find a supporting driver for
- *
- * Parses the list of registered drivers looking for a driver applicable for
- * the specified device.
- */
-static int acpi_bus_find_driver(struct acpi_device *device)
-{
-       int result = 0;
-       struct list_head *node, *next;
+       /*
+        * Enumerate supported power management states
+        */
+       for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3; i++) {
+               struct acpi_device_power_state *ps = &device->power.states[i];
+               char object_name[5] = { '_', 'P', 'R', '0' + i, '\0' };
 
+               /* Evaluate "_PRx" to se if power resources are referenced */
+               acpi_evaluate_reference(device->handle, object_name, NULL,
+                                       &ps->resources);
+               if (ps->resources.count) {
+                       device->power.flags.power_resources = 1;
+                       ps->flags.valid = 1;
+               }
 
-       spin_lock(&acpi_device_lock);
-       list_for_each_safe(node, next, &acpi_bus_drivers) {
-               struct acpi_driver *driver =
-                   container_of(node, struct acpi_driver, node);
-
-               atomic_inc(&driver->references);
-               spin_unlock(&acpi_device_lock);
-               if (!acpi_bus_match(device, driver)) {
-                       result = acpi_bus_driver_init(device, driver);
-                       if (!result)
-                               goto Done;
+               /* Evaluate "_PSx" to see if we can do explicit sets */
+               object_name[2] = 'S';
+               status = acpi_get_handle(device->handle, object_name, &handle);
+               if (ACPI_SUCCESS(status)) {
+                       ps->flags.explicit_set = 1;
+                       ps->flags.valid = 1;
                }
-               atomic_dec(&driver->references);
-               spin_lock(&acpi_device_lock);
-       }
-       spin_unlock(&acpi_device_lock);
 
-      Done:
-       return result;
-}
+               /* State is valid if we have some power control */
+               if (ps->resources.count || ps->flags.explicit_set)
+                       ps->flags.valid = 1;
 
-/* --------------------------------------------------------------------------
-                                 Device Enumeration
-   -------------------------------------------------------------------------- */
+               ps->power = -1; /* Unknown - driver assigned */
+               ps->latency = -1;       /* Unknown - driver assigned */
+       }
 
-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;
+       /* Set defaults for D0 and D3 states (always valid) */
+       device->power.states[ACPI_STATE_D0].flags.valid = 1;
+       device->power.states[ACPI_STATE_D0].power = 100;
+       device->power.states[ACPI_STATE_D3].flags.valid = 1;
+       device->power.states[ACPI_STATE_D3].power = 0;
 
-       status = acpi_get_handle(handle, "_EJD", &tmp);
-       if (ACPI_FAILURE(status))
-               return status;
+       /* TBD: System wake support and resource requirements. */
 
-       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);
+       device->power.state = ACPI_STATE_UNKNOWN;
 
+       return 0;
+}
 
 static int acpi_bus_get_flags(struct acpi_device *device)
 {
@@ -782,6 +804,75 @@ static void acpi_device_get_busid(struct acpi_device *device,
        }
 }
 
+static int
+acpi_video_bus_match(struct acpi_device *device)
+{
+       acpi_handle h_dummy1;
+       acpi_handle h_dummy2;
+       acpi_handle h_dummy3;
+
+
+       if (!device)
+               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.
+        */
+
+       /* 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 0;
+
+       /* Does this device able to retrieve a video ROM ? */
+       if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_ROM", &h_dummy1)))
+               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 0;
+
+       return -ENODEV;
+}
+
+/*
+ * acpi_bay_match - see if a device is an ejectable driver bay
+ *
+ * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
+ * then we can safely call it an ejectable drive bay
+ */
+static int acpi_bay_match(struct acpi_device *device){
+       acpi_status status;
+       acpi_handle handle;
+       acpi_handle tmp;
+       acpi_handle phandle;
+
+       handle = device->handle;
+
+       status = acpi_get_handle(handle, "_EJ0", &tmp);
+       if (ACPI_FAILURE(status))
+               return -ENODEV;
+
+       if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) ||
+               (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) ||
+               (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) ||
+               (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp))))
+               return 0;
+
+       if (acpi_get_parent(handle, &phandle))
+               return -ENODEV;
+
+        if ((ACPI_SUCCESS(acpi_get_handle(phandle, "_GTF", &tmp))) ||
+                (ACPI_SUCCESS(acpi_get_handle(phandle, "_GTM", &tmp))) ||
+                (ACPI_SUCCESS(acpi_get_handle(phandle, "_STM", &tmp))) ||
+                (ACPI_SUCCESS(acpi_get_handle(phandle, "_SDD", &tmp))))
+                return 0;
+
+       return -ENODEV;
+}
+
 static void acpi_device_set_id(struct acpi_device *device,
                               struct acpi_device *parent, acpi_handle handle,
                               int type)
@@ -812,6 +903,16 @@ static void acpi_device_set_id(struct acpi_device *device,
                        device->pnp.bus_address = info->address;
                        device->flags.bus_address = 1;
                }
+
+               if(!(info->valid & (ACPI_VALID_HID | ACPI_VALID_CID))){
+                       status = acpi_video_bus_match(device);
+                       if(ACPI_SUCCESS(status))
+                               hid = ACPI_VIDEO_HID;
+
+                       status = acpi_bay_match(device);
+                       if (ACPI_SUCCESS(status))
+                               hid = ACPI_BAY_HID;
+               }
                break;
        case ACPI_BUS_TYPE_POWER:
                hid = ACPI_POWER_HID;
@@ -890,41 +991,22 @@ static int acpi_device_set_context(struct acpi_device *device, int type)
 
 static int acpi_bus_remove(struct acpi_device *dev, int rmdevice)
 {
-       int result = 0;
-       struct acpi_driver *driver;
-
-
        if (!dev)
                return -EINVAL;
 
-       driver = dev->driver;
-
-       if ((driver) && (driver->ops.remove)) {
-
-               if (driver->ops.stop) {
-                       result = driver->ops.stop(dev, ACPI_BUS_REMOVAL_EJECT);
-                       if (result)
-                               return result;
-               }
-
-               result = dev->driver->ops.remove(dev, ACPI_BUS_REMOVAL_EJECT);
-               if (result) {
-                       return result;
-               }
-
-               atomic_dec(&dev->driver->references);
-               dev->driver = NULL;
-               acpi_driver_data(dev) = NULL;
-       }
+       dev->removal_type = ACPI_BUS_REMOVAL_EJECT;
+       device_release_driver(&dev->dev);
 
        if (!rmdevice)
                return 0;
 
+       /*
+        * unbind _ADR-Based Devices when hot removal
+        */
        if (dev->flags.bus_address) {
                if ((dev->parent) && (dev->parent->ops.unbind))
                        dev->parent->ops.unbind(dev);
        }
-
        acpi_device_unregister(dev, ACPI_BUS_REMOVAL_EJECT);
 
        return 0;
@@ -932,7 +1014,8 @@ static int acpi_bus_remove(struct acpi_device *dev, int rmdevice)
 
 static int
 acpi_add_single_object(struct acpi_device **child,
-                      struct acpi_device *parent, acpi_handle handle, int type)
+                      struct acpi_device *parent, acpi_handle handle, int type,
+                       struct acpi_bus_ops *ops)
 {
        int result = 0;
        struct acpi_device *device = NULL;
@@ -949,6 +1032,8 @@ acpi_add_single_object(struct acpi_device **child,
 
        device->handle = handle;
        device->parent = parent;
+       device->bus_ops = *ops; /* workround for not call .start */
+
 
        acpi_device_get_busid(device, handle, type);
 
@@ -1033,31 +1118,16 @@ acpi_add_single_object(struct acpi_device **child,
        if ((result = acpi_device_set_context(device, type)))
                goto end;
 
-       acpi_device_register(device, parent);
+       result = acpi_device_register(device, parent);
 
        /*
-        * Bind _ADR-Based Devices
-        * -----------------------
-        * If there's a a bus address (_ADR) then we utilize the parent's 
-        * 'bind' function (if exists) to bind the ACPI- and natively-
-        * enumerated device representations.
+        * Bind _ADR-Based Devices when hot add
         */
        if (device->flags.bus_address) {
                if (device->parent && device->parent->ops.bind)
                        device->parent->ops.bind(device);
        }
 
-       /*
-        * Locate & Attach Driver
-        * ----------------------
-        * If there's a hardware id (_HID) or compatible ids (_CID) we check
-        * to see if there's a driver installed for this kind of device.  Note
-        * that drivers can install before or after a device is enumerated.
-        *
-        * TBD: Assumes LDM provides driver hot-plug capability.
-        */
-       acpi_bus_find_driver(device);
-
       end:
        if (!result)
                *child = device;
@@ -1143,14 +1213,14 @@ static int acpi_bus_scan(struct acpi_device *start, struct acpi_bus_ops *ops)
 
                if (ops->acpi_op_add)
                        status = acpi_add_single_object(&child, parent,
-                                                       chandle, type);
+                               chandle, type, ops);
                else
                        status = acpi_bus_get_device(chandle, &child);
 
                if (ACPI_FAILURE(status))
                        continue;
 
-               if (ops->acpi_op_start) {
+               if (ops->acpi_op_start && !(ops->acpi_op_add)) {
                        status = acpi_start_single_object(child);
                        if (ACPI_FAILURE(status))
                                continue;
@@ -1188,13 +1258,13 @@ acpi_bus_add(struct acpi_device **child,
        int result;
        struct acpi_bus_ops ops;
 
+       memset(&ops, 0, sizeof(ops));
+       ops.acpi_op_add = 1;
 
-       result = acpi_add_single_object(child, parent, handle, type);
-       if (!result) {
-               memset(&ops, 0, sizeof(ops));
-               ops.acpi_op_add = 1;
+       result = acpi_add_single_object(child, parent, handle, type, &ops);
+       if (!result)
                result = acpi_bus_scan(*child, &ops);
-       }
+
        return result;
 }
 
@@ -1280,127 +1350,35 @@ static int acpi_bus_scan_fixed(struct acpi_device *root)
 {
        int result = 0;
        struct acpi_device *device = NULL;
-
+       struct acpi_bus_ops ops;
 
        if (!root)
                return -ENODEV;
 
+       memset(&ops, 0, sizeof(ops));
+       ops.acpi_op_add = 1;
+       ops.acpi_op_start = 1;
+
        /*
         * Enumerate all fixed-feature devices.
         */
-       if (acpi_fadt.pwr_button == 0) {
+       if ((acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON) == 0) {
                result = acpi_add_single_object(&device, acpi_root,
                                                NULL,
-                                               ACPI_BUS_TYPE_POWER_BUTTON);
-               if (!result)
-                       result = acpi_start_single_object(device);
+                                               ACPI_BUS_TYPE_POWER_BUTTON,
+                                               &ops);
        }
 
-       if (acpi_fadt.sleep_button == 0) {
+       if ((acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON) == 0) {
                result = acpi_add_single_object(&device, acpi_root,
                                                NULL,
-                                               ACPI_BUS_TYPE_SLEEP_BUTTON);
-               if (!result)
-                       result = acpi_start_single_object(device);
+                                               ACPI_BUS_TYPE_SLEEP_BUTTON,
+                                               &ops);
        }
 
        return result;
 }
 
-
-static inline struct acpi_device * to_acpi_dev(struct device * dev)
-{
-       return container_of(dev, struct acpi_device, dev);
-}
-
-
-static int root_suspend(struct acpi_device * acpi_dev, pm_message_t state)
-{
-       struct acpi_device * dev, * next;
-       int result;
-
-       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);
-       return 0;
-}
-
-
-static int acpi_device_suspend(struct device * dev, pm_message_t state)
-{
-       struct acpi_device * acpi_dev = to_acpi_dev(dev);
-
-       /*
-        * 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);
-       return 0;
-}
-
-
-
-static int root_resume(struct acpi_device * acpi_dev)
-{
-       struct acpi_device * dev, * next;
-       int result;
-
-       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);
-               }
-       }
-       spin_unlock(&acpi_device_lock);
-       return 0;
-}
-
-
-static int acpi_device_resume(struct device * dev)
-{
-       struct acpi_device * acpi_dev = to_acpi_dev(dev);
-
-       /*
-        * 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);
-       return 0;
-}
-
-
-static struct bus_type acpi_bus_type = {
-       .name           = "acpi",
-       .suspend        = acpi_device_suspend,
-       .resume         = acpi_device_resume,
-};
-
-
-
 static int __init acpi_scan_init(void)
 {
        int result;
@@ -1410,9 +1388,9 @@ static int __init acpi_scan_init(void)
        if (acpi_disabled)
                return 0;
 
-       result = kset_register(&acpi_namespace_kset);
-       if (result < 0)
-               printk(KERN_ERR PREFIX "kset_register error: %d\n", result);
+       memset(&ops, 0, sizeof(ops));
+       ops.acpi_op_add = 1;
+       ops.acpi_op_start = 1;
 
        result = bus_register(&acpi_bus_type);
        if (result) {
@@ -1424,32 +1402,16 @@ static int __init acpi_scan_init(void)
         * Create the root device in the bus's device tree
         */
        result = acpi_add_single_object(&acpi_root, NULL, ACPI_ROOT_OBJECT,
-                                       ACPI_BUS_TYPE_SYSTEM);
+                                       ACPI_BUS_TYPE_SYSTEM, &ops);
        if (result)
                goto Done;
 
-       result = acpi_start_single_object(acpi_root);
-       if (result)
-               goto Done;
-
-       acpi_root->dev.bus = &acpi_bus_type;
-       snprintf(acpi_root->dev.bus_id, BUS_ID_SIZE, "%s", acpi_bus_type.name);
-       result = device_register(&acpi_root->dev);
-       if (result) {
-               /* We don't want to quit even if we failed to add suspend/resume */
-               printk(KERN_ERR PREFIX "Could not register device\n");
-       }
-
        /*
         * Enumerate devices in the ACPI namespace.
         */
        result = acpi_bus_scan_fixed(acpi_root);
-       if (!result) {
-               memset(&ops, 0, sizeof(ops));
-               ops.acpi_op_add = 1;
-               ops.acpi_op_start = 1;
+       if (!result)
                result = acpi_bus_scan(acpi_root, &ops);
-       }
 
        if (result)
                acpi_device_unregister(acpi_root, ACPI_BUS_REMOVAL_NORMAL);