Merge branch 'acpi-scan' into acpi-lpss

The following commits depend on the 'acpi-scan' material.

1 files changed, 116 insertions, 204 deletions

diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index c88be6c37c30..7d164a966b0d 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -116,24 +116,18 @@ static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL);
 void acpi_bus_hot_remove_device(void *context)
 {
         struct acpi_eject_event *ej_event = (struct acpi_eject_event *) context;
-        struct acpi_device *device;
-        acpi_handle handle = ej_event->handle;
+        struct acpi_device *device = ej_event->device;
+        acpi_handle handle = device->handle;
         acpi_handle temp;
         struct acpi_object_list arg_list;
         union acpi_object arg;
         acpi_status status = AE_OK;
         u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE; /* default */
 
-        if (acpi_bus_get_device(handle, &device))
-                goto err_out;
-
-        if (!device)
-                goto err_out;
-
         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                 "Hot-removing device %s...\n", dev_name(&device->dev)));
 
-        if (acpi_bus_trim(device, 1)) {
+        if (acpi_bus_trim(device)) {
                 printk(KERN_ERR PREFIX
                                 "Removing device failed\n");
                 goto err_out;
@@ -215,7 +209,7 @@ acpi_eject_store(struct device *d, struct device_attribute *attr,
                 goto err;
         }
 
-        ej_event->handle = acpi_device->handle;
+        ej_event->device = acpi_device;
         if (acpi_device->flags.eject_pending) {
                 /* event originated from ACPI eject notification */
                 ej_event->event = ACPI_NOTIFY_EJECT_REQUEST;
@@ -223,7 +217,7 @@ acpi_eject_store(struct device *d, struct device_attribute *attr,
         } else {
                 /* event originated from user */
                 ej_event->event = ACPI_OST_EC_OSPM_EJECT;
-                (void) acpi_evaluate_hotplug_ost(ej_event->handle,
+                (void) acpi_evaluate_hotplug_ost(acpi_device->handle,
                         ej_event->event, ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
         }
 
@@ -494,7 +488,8 @@ static int acpi_bus_match(struct device *dev, struct device_driver *drv)
         struct acpi_device *acpi_dev = to_acpi_device(dev);
         struct acpi_driver *acpi_drv = to_acpi_driver(drv);
 
-        return !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
+        return acpi_dev->flags.match_driver
+                && !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
 }
 
 static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
@@ -570,7 +565,6 @@ static void acpi_device_remove_notify_handler(struct acpi_device *device)
 }
 
 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);
@@ -579,9 +573,6 @@ static int acpi_device_probe(struct device * dev)
 
         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);
-
                 if (acpi_drv->ops.notify) {
                         ret = acpi_device_install_notify_handler(acpi_dev);
                         if (ret) {
@@ -704,7 +695,7 @@ end:
         return result;
 }
 
-static void acpi_device_unregister(struct acpi_device *device, int type)
+static void acpi_device_unregister(struct acpi_device *device)
 {
         mutex_lock(&acpi_device_lock);
         if (device->parent)
@@ -760,24 +751,6 @@ acpi_bus_driver_init(struct acpi_device *device, struct acpi_driver *driver)
         return 0;
 }
 
-static int acpi_start_single_object(struct acpi_device *device)
-{
-        int result = 0;
-        struct acpi_driver *driver;
-
-
-        if (!(driver = device->driver))
-                return 0;
-
-        if (driver->ops.start) {
-                result = driver->ops.start(device);
-                if (result && driver->ops.remove)
-                        driver->ops.remove(device, ACPI_BUS_REMOVAL_NORMAL);
-        }
-
-        return result;
-}
-
 /**
  * acpi_bus_register_driver - register a driver with the ACPI bus
  * @driver: driver being registered
@@ -1395,33 +1368,9 @@ static int acpi_device_set_context(struct acpi_device *device)
         return -ENODEV;
 }
 
-static int acpi_bus_remove(struct acpi_device *dev, int rmdevice)
-{
-        if (!dev)
-                return -EINVAL;
-
-        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;
-}
-
 static int acpi_add_single_object(struct acpi_device **child,
                                   acpi_handle handle, int type,
-                                  unsigned long long sta,
-                                  struct acpi_bus_ops *ops)
+                                  unsigned long long sta, bool match_driver)
 {
         int result;
         struct acpi_device *device;
@@ -1437,7 +1386,6 @@ static int acpi_add_single_object(struct acpi_device **child,
         device->device_type = type;
         device->handle = handle;
         device->parent = acpi_bus_get_parent(handle);
-        device->bus_ops = *ops; /* workround for not call .start */
         STRUCT_TO_INT(device->status) = sta;
 
         acpi_device_get_busid(device);
@@ -1488,16 +1436,9 @@ static int acpi_add_single_object(struct acpi_device **child,
         if ((result = acpi_device_set_context(device)))
                 goto end;
 
+        device->flags.match_driver = match_driver;
         result = acpi_device_register(device);
 
-        /*
-         * Bind _ADR-Based Devices when hot add
-         */
-        if (device->flags.bus_address) {
-                if (device->parent && device->parent->ops.bind)
-                        device->parent->ops.bind(device);
-        }
-
 end:
         if (!result) {
                 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
@@ -1519,16 +1460,12 @@ end:
 
 static void acpi_bus_add_power_resource(acpi_handle handle)
 {
-        struct acpi_bus_ops ops = {
-                .acpi_op_add = 1,
-                .acpi_op_start = 1,
-        };
         struct acpi_device *device = NULL;
 
         acpi_bus_get_device(handle, &device);
         if (!device)
                 acpi_add_single_object(&device, handle, ACPI_BUS_TYPE_POWER,
-                                        ACPI_STA_DEFAULT, &ops);
+                                        ACPI_STA_DEFAULT, true);
 }
 
 static int acpi_bus_type_and_status(acpi_handle handle, int *type,
@@ -1570,16 +1507,19 @@ static int acpi_bus_type_and_status(acpi_handle handle, int *type,
         return 0;
 }
 
-static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl,
-                                      void *context, void **return_value)
+static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
+                                      void *not_used, void **return_value)
 {
-        struct acpi_bus_ops *ops = context;
+        struct acpi_device *device = NULL;
         int type;
         unsigned long long sta;
-        struct acpi_device *device;
         acpi_status status;
         int result;
 
+        acpi_bus_get_device(handle, &device);
+        if (device)
+                goto out;
+
         result = acpi_bus_type_and_status(handle, &type, &sta);
         if (result)
                 return AE_OK;
@@ -1596,150 +1536,130 @@ static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl,
                 return AE_CTRL_DEPTH;
         }
 
-        /*
-         * We may already have an acpi_device from a previous enumeration.  If
-         * so, we needn't add it again, but we may still have to start it.
-         */
-        device = NULL;
-        acpi_bus_get_device(handle, &device);
-        if (ops->acpi_op_add && !device) {
-                acpi_add_single_object(&device, handle, type, sta, ops);
-                /* Is the device a known good platform device? */
-                if (device
-                    && !acpi_match_device_ids(device, acpi_platform_device_ids))
-                        acpi_create_platform_device(device);
-        }
-
+        acpi_add_single_object(&device, handle, type, sta,
+                               type == ACPI_BUS_TYPE_POWER);
         if (!device)
                 return AE_CTRL_DEPTH;
 
-        if (ops->acpi_op_start && !(ops->acpi_op_add)) {
-                status = acpi_start_single_object(device);
-                if (ACPI_FAILURE(status))
-                        return AE_CTRL_DEPTH;
-        }
+        device->flags.match_driver = true;
 
+ out:
         if (!*return_value)
                 *return_value = device;
+
         return AE_OK;
 }
 
-static int acpi_bus_scan(acpi_handle handle, struct acpi_bus_ops *ops,
-                         struct acpi_device **child)
+static acpi_status acpi_bus_device_attach(acpi_handle handle, u32 lvl_not_used,
+                                          void *not_used, void **ret_not_used)
+{
+        acpi_status status = AE_OK;
+        struct acpi_device *device;
+        unsigned long long sta_not_used;
+        int type_not_used;
+
+        /*
+         * Ignore errors ignored by acpi_bus_check_add() to avoid terminating
+         * namespace walks prematurely.
+         */
+        if (acpi_bus_type_and_status(handle, &type_not_used, &sta_not_used))
+                return AE_OK;
+
+        if (acpi_bus_get_device(handle, &device))
+                return AE_CTRL_DEPTH;
+
+        if (!acpi_match_device_ids(device, acpi_platform_device_ids)) {
+                /* This is a known good platform device. */
+                acpi_create_platform_device(device);
+        } else if (device_attach(&device->dev) < 0) {
+                status = AE_CTRL_DEPTH;
+        }
+        return status;
+}
+
+static int acpi_bus_scan(acpi_handle handle)
 {
-        acpi_status status;
         void *device = NULL;
 
-        status = acpi_bus_check_add(handle, 0, ops, &device);
-        if (ACPI_SUCCESS(status))
+        if (ACPI_SUCCESS(acpi_bus_check_add(handle, 0, NULL, &device)))
                 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
-                                    acpi_bus_check_add, NULL, ops, &device);
+                                    acpi_bus_check_add, NULL, NULL, &device);
 
-        if (child)
-                *child = device;
-
-        if (device)
-                return 0;
-        else
+        if (!device)
                 return -ENODEV;
+
+        if (ACPI_SUCCESS(acpi_bus_device_attach(handle, 0, NULL, NULL)))
+                acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
+                                    acpi_bus_device_attach, NULL, NULL, NULL);
+
+        return 0;
 }
 
-/*
- * acpi_bus_add and acpi_bus_start
+/**
+ * acpi_bus_add - Add ACPI device node objects in a given namespace scope.
+ * @handle: Root of the namespace scope to scan.
  *
- * scan a given ACPI tree and (probably recently hot-plugged)
- * create and add or starts found devices.
+ * Scan a given ACPI tree (probably recently hot-plugged) and create and add
+ * found devices.
  *
- * If no devices were found -ENODEV is returned which does not
- * mean that this is a real error, there just have been no suitable
- * ACPI objects in the table trunk from which the kernel could create
- * a device and add/start an appropriate driver.
+ * If no devices were found, -ENODEV is returned, but it does not mean that
+ * there has been a real error.  There just have been no suitable ACPI objects
+ * in the table trunk from which the kernel could create a device and add an
+ * appropriate driver.
  */
-
-int
-acpi_bus_add(struct acpi_device **child,
-             struct acpi_device *parent, acpi_handle handle, int type)
+int acpi_bus_add(acpi_handle handle)
 {
-        struct acpi_bus_ops ops;
+        int err;
 
-        memset(&ops, 0, sizeof(ops));
-        ops.acpi_op_add = 1;
+        err = acpi_bus_scan(handle);
+        if (err)
+                return err;
 
-        return acpi_bus_scan(handle, &ops, child);
+        acpi_update_all_gpes();
+        return 0;
 }
 EXPORT_SYMBOL(acpi_bus_add);
 
-int acpi_bus_start(struct acpi_device *device)
+static acpi_status acpi_bus_device_detach(acpi_handle handle, u32 lvl_not_used,
+                                          void *not_used, void **ret_not_used)
 {
-        struct acpi_bus_ops ops;
-        int result;
-
-        if (!device)
-                return -EINVAL;
-
-        memset(&ops, 0, sizeof(ops));
-        ops.acpi_op_start = 1;
-
-        result = acpi_bus_scan(device->handle, &ops, NULL);
-
-        acpi_update_all_gpes();
+        struct acpi_device *device = NULL;
 
-        return result;
+        if (!acpi_bus_get_device(handle, &device)) {
+                device->removal_type = ACPI_BUS_REMOVAL_EJECT;
+                device_release_driver(&device->dev);
+        }
+        return AE_OK;
 }
-EXPORT_SYMBOL(acpi_bus_start);
 
-int acpi_bus_trim(struct acpi_device *start, int rmdevice)
+static acpi_status acpi_bus_remove(acpi_handle handle, u32 lvl_not_used,
+                                   void *not_used, void **ret_not_used)
 {
-        acpi_status status;
-        struct acpi_device *parent, *child;
-        acpi_handle phandle, chandle;
-        acpi_object_type type;
-        u32 level = 1;
-        int err = 0;
-
-        parent = start;
-        phandle = start->handle;
-        child = chandle = NULL;
-
-        while ((level > 0) && parent && (!err)) {
-                status = acpi_get_next_object(ACPI_TYPE_ANY, phandle,
-                                              chandle, &chandle);
+        struct acpi_device *device = NULL;
 
-                /*
-                 * If this scope is exhausted then move our way back up.
-                 */
-                if (ACPI_FAILURE(status)) {
-                        level--;
-                        chandle = phandle;
-                        acpi_get_parent(phandle, &phandle);
-                        child = parent;
-                        parent = parent->parent;
-
-                        if (level == 0)
-                                err = acpi_bus_remove(child, rmdevice);
-                        else
-                                err = acpi_bus_remove(child, 1);
+        if (!acpi_bus_get_device(handle, &device))
+                acpi_device_unregister(device);
 
-                        continue;
-                }
+        return AE_OK;
+}
 
-                status = acpi_get_type(chandle, &type);
-                if (ACPI_FAILURE(status)) {
-                        continue;
-                }
-                /*
-                 * If there is a device corresponding to chandle then
-                 * parse it (depth-first).
-                 */
-                if (acpi_bus_get_device(chandle, &child) == 0) {
-                        level++;
-                        phandle = chandle;
-                        chandle = NULL;
-                        parent = child;
-                }
-                continue;
-        }
-        return err;
+int acpi_bus_trim(struct acpi_device *start)
+{
+        /*
+         * Execute acpi_bus_device_detach() as a post-order callback to detach
+         * all ACPI drivers from the device nodes being removed.
+         */
+        acpi_walk_namespace(ACPI_TYPE_ANY, start->handle, ACPI_UINT32_MAX, NULL,
+                            acpi_bus_device_detach, NULL, NULL);
+        acpi_bus_device_detach(start->handle, 0, NULL, NULL);
+        /*
+         * Execute acpi_bus_remove() as a post-order callback to remove device
+         * nodes in the given namespace scope.
+         */
+        acpi_walk_namespace(ACPI_TYPE_ANY, start->handle, ACPI_UINT32_MAX, NULL,
+                            acpi_bus_remove, NULL, NULL);
+        acpi_bus_remove(start->handle, 0, NULL, NULL);
+        return 0;
 }
 EXPORT_SYMBOL_GPL(acpi_bus_trim);
 
@@ -1747,11 +1667,6 @@ static int acpi_bus_scan_fixed(void)
 {
         int result = 0;
         struct acpi_device *device = NULL;
-        struct acpi_bus_ops ops;
-
-        memset(&ops, 0, sizeof(ops));
-        ops.acpi_op_add = 1;
-        ops.acpi_op_start = 1;
 
         /*
          * Enumerate all fixed-feature devices.
@@ -1759,16 +1674,14 @@ static int acpi_bus_scan_fixed(void)
         if ((acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON) == 0) {
                 result = acpi_add_single_object(&device, NULL,
                                                 ACPI_BUS_TYPE_POWER_BUTTON,
-                                                ACPI_STA_DEFAULT,
-                                                &ops);
+                                                ACPI_STA_DEFAULT, true);
                 device_init_wakeup(&device->dev, true);
         }
 
         if ((acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON) == 0) {
                 result = acpi_add_single_object(&device, NULL,
                                                 ACPI_BUS_TYPE_SLEEP_BUTTON,
-                                                ACPI_STA_DEFAULT,
-                                                &ops);
+                                                ACPI_STA_DEFAULT, true);
         }
 
         return result;
@@ -1777,11 +1690,6 @@ static int acpi_bus_scan_fixed(void)
 int __init acpi_scan_init(void)
 {
         int result;
-        struct acpi_bus_ops ops;
-
-        memset(&ops, 0, sizeof(ops));
-        ops.acpi_op_add = 1;
-        ops.acpi_op_start = 1;
 
         result = bus_register(&acpi_bus_type);
         if (result) {
@@ -1790,17 +1698,21 @@ int __init acpi_scan_init(void)
         }
 
         acpi_power_init();
+        acpi_pci_root_init();
 
         /*
          * Enumerate devices in the ACPI namespace.
          */
-        result = acpi_bus_scan(ACPI_ROOT_OBJECT, &ops, &acpi_root);
+        result = acpi_bus_scan(ACPI_ROOT_OBJECT);
+        if (result)
+                return result;
 
+        result = acpi_bus_get_device(ACPI_ROOT_OBJECT, &acpi_root);
         if (!result)
                 result = acpi_bus_scan_fixed();
 
         if (result)
-                acpi_device_unregister(acpi_root, ACPI_BUS_REMOVAL_NORMAL);
+                acpi_device_unregister(acpi_root);
         else
                 acpi_update_all_gpes();