Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core-2.6: (28 commits)
  driver core: device_rename's new_name can be const
  sysfs: Remove owner field from sysfs struct attribute
  powerpc/pci: Remove owner field from attribute initialization in PCI bridge init
  regulator: Remove owner field from attribute initialization in regulator core driver
  leds: Remove owner field from attribute initialization in bd2802 driver
  scsi: Remove owner field from attribute initialization in ARCMSR driver
  scsi: Remove owner field from attribute initialization in LPFC driver
  cgroupfs: create /sys/fs/cgroup to mount cgroupfs on
  Driver core: Add BUS_NOTIFY_BIND_DRIVER
  driver core: fix memory leak on one error path in bus_register()
  debugfs: no longer needs to depend on SYSFS
  sysfs: Fix one more signature discrepancy between sysfs implementation and docs.
  sysfs: fix discrepancies between implementation and documentation
  dcdbas: remove a redundant smi_data_buf_free in dcdbas_exit
  dmi-id: fix a memory leak in dmi_id_init error path
  sysfs: sysfs_chmod_file's attr can be const
  firmware: Update hotplug script
  Driver core: move platform device creation helpers to .init.text (if MODULE=n)
  Driver core: reduce duplicated code for platform_device creation
  Driver core: use kmemdup in platform_device_add_resources
  ...

6 files changed, 160 insertions, 222 deletions

diff --git a/drivers/base/bus.c b/drivers/base/bus.c
index 12eec3f633b1..eb1b7fa20dce 100644
--- a/drivers/base/bus.c
+++ b/drivers/base/bus.c
@@ -945,8 +945,8 @@ bus_devices_fail:
         bus_remove_file(bus, &bus_attr_uevent);
 bus_uevent_fail:
         kset_unregister(&bus->p->subsys);
-        kfree(bus->p);
 out:
+        kfree(bus->p);
         bus->p = NULL;
         return retval;
 }
diff --git a/drivers/base/core.c b/drivers/base/core.c
index f8e72724dd4b..d1b2c9adc271 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -1599,7 +1599,7 @@ EXPORT_SYMBOL_GPL(device_destroy);
  * on the same device to ensure that new_name is valid and
  * won't conflict with other devices.
  */
-int device_rename(struct device *dev, char *new_name)
+int device_rename(struct device *dev, const char *new_name)
 {
         char *old_class_name = NULL;
         char *new_class_name = NULL;
diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index 503c2620bbcc..da57ee9d63fe 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -51,6 +51,10 @@ static int driver_sysfs_add(struct device *dev)
 {
         int ret;
 
+        if (dev->bus)
+                blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
+                                             BUS_NOTIFY_BIND_DRIVER, dev);
+
         ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj,
                           kobject_name(&dev->kobj));
         if (ret == 0) {
diff --git a/drivers/base/dma-coherent.c b/drivers/base/dma-coherent.c
index d4d8ce53886a..f369e2795985 100644
--- a/drivers/base/dma-coherent.c
+++ b/drivers/base/dma-coherent.c
@@ -8,7 +8,7 @@
 
 struct dma_coherent_mem {
         void            *virt_base;
-        u32             device_base;
+        dma_addr_t      device_base;
         int             size;
         int             flags;
         unsigned long   *bitmap;
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 3f093b0dd217..c8a44f5e0584 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -87,29 +87,32 @@ static DEFINE_MUTEX(fw_lock);
 
 struct firmware_priv {
         struct completion completion;
-        struct bin_attribute attr_data;
         struct firmware *fw;
         unsigned long status;
         struct page **pages;
         int nr_pages;
         int page_array_size;
         struct timer_list timeout;
+        struct device dev;
         bool nowait;
         char fw_id[];
 };
 
-static void
-fw_load_abort(struct firmware_priv *fw_priv)
+static struct firmware_priv *to_firmware_priv(struct device *dev)
+{
+        return container_of(dev, struct firmware_priv, dev);
+}
+
+static void fw_load_abort(struct firmware_priv *fw_priv)
 {
         set_bit(FW_STATUS_ABORT, &fw_priv->status);
         wmb();
         complete(&fw_priv->completion);
 }
 
-static ssize_t
-firmware_timeout_show(struct class *class,
-                      struct class_attribute *attr,
-                      char *buf)
+static ssize_t firmware_timeout_show(struct class *class,
+                                     struct class_attribute *attr,
+                                     char *buf)
 {
         return sprintf(buf, "%d\n", loading_timeout);
 }
@@ -127,14 +130,14 @@ firmware_timeout_show(struct class *class,
  *
  *      Note: zero means 'wait forever'.
  **/
-static ssize_t
-firmware_timeout_store(struct class *class,
-                        struct class_attribute *attr,
-                        const char *buf, size_t count)
+static ssize_t firmware_timeout_store(struct class *class,
+                                      struct class_attribute *attr,
+                                      const char *buf, size_t count)
 {
         loading_timeout = simple_strtol(buf, NULL, 10);
         if (loading_timeout < 0)
                 loading_timeout = 0;
+
         return count;
 }
 
@@ -146,21 +149,20 @@ static struct class_attribute firmware_class_attrs[] = {
 
 static void fw_dev_release(struct device *dev)
 {
-        struct firmware_priv *fw_priv = dev_get_drvdata(dev);
+        struct firmware_priv *fw_priv = to_firmware_priv(dev);
         int i;
 
         for (i = 0; i < fw_priv->nr_pages; i++)
                 __free_page(fw_priv->pages[i]);
         kfree(fw_priv->pages);
         kfree(fw_priv);
-        kfree(dev);
 
         module_put(THIS_MODULE);
 }
 
 static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
-        struct firmware_priv *fw_priv = dev_get_drvdata(dev);
+        struct firmware_priv *fw_priv = to_firmware_priv(dev);
 
         if (add_uevent_var(env, "FIRMWARE=%s", fw_priv->fw_id))
                 return -ENOMEM;
@@ -182,8 +184,9 @@ static struct class firmware_class = {
 static ssize_t firmware_loading_show(struct device *dev,
                                      struct device_attribute *attr, char *buf)
 {
-        struct firmware_priv *fw_priv = dev_get_drvdata(dev);
+        struct firmware_priv *fw_priv = to_firmware_priv(dev);
         int loading = test_bit(FW_STATUS_LOADING, &fw_priv->status);
+
         return sprintf(buf, "%d\n", loading);
 }
 
@@ -219,7 +222,7 @@ static ssize_t firmware_loading_store(struct device *dev,
                                       struct device_attribute *attr,
                                       const char *buf, size_t count)
 {
-        struct firmware_priv *fw_priv = dev_get_drvdata(dev);
+        struct firmware_priv *fw_priv = to_firmware_priv(dev);
         int loading = simple_strtol(buf, NULL, 10);
         int i;
 
@@ -277,13 +280,12 @@ static ssize_t firmware_loading_store(struct device *dev,
 
 static DEVICE_ATTR(loading, 0644, firmware_loading_show, firmware_loading_store);
 
-static ssize_t
-firmware_data_read(struct file *filp, struct kobject *kobj,
-                   struct bin_attribute *bin_attr, char *buffer, loff_t offset,
-                   size_t count)
+static ssize_t firmware_data_read(struct file *filp, struct kobject *kobj,
+                                  struct bin_attribute *bin_attr,
+                                  char *buffer, loff_t offset, size_t count)
 {
         struct device *dev = to_dev(kobj);
-        struct firmware_priv *fw_priv = dev_get_drvdata(dev);
+        struct firmware_priv *fw_priv = to_firmware_priv(dev);
         struct firmware *fw;
         ssize_t ret_count;
 
@@ -322,8 +324,7 @@ out:
         return ret_count;
 }
 
-static int
-fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
+static int fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
 {
         int pages_needed = ALIGN(min_size, PAGE_SIZE) >> PAGE_SHIFT;
 
@@ -373,13 +374,12 @@ fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
  *      Data written to the 'data' attribute will be later handed to
  *      the driver as a firmware image.
  **/
-static ssize_t
-firmware_data_write(struct file* filp, struct kobject *kobj,
-                    struct bin_attribute *bin_attr, char *buffer,
-                    loff_t offset, size_t count)
+static ssize_t firmware_data_write(struct file *filp, struct kobject *kobj,
+                                   struct bin_attribute *bin_attr,
+                                   char *buffer, loff_t offset, size_t count)
 {
         struct device *dev = to_dev(kobj);
-        struct firmware_priv *fw_priv = dev_get_drvdata(dev);
+        struct firmware_priv *fw_priv = to_firmware_priv(dev);
         struct firmware *fw;
         ssize_t retval;
 
@@ -420,116 +420,103 @@ out:
         return retval;
 }
 
-static struct bin_attribute firmware_attr_data_tmpl = {
-        .attr = {.name = "data", .mode = 0644},
+static struct bin_attribute firmware_attr_data = {
+        .attr = { .name = "data", .mode = 0644 },
         .size = 0,
         .read = firmware_data_read,
         .write = firmware_data_write,
 };
 
-static void
-firmware_class_timeout(u_long data)
+static void firmware_class_timeout(u_long data)
 {
         struct firmware_priv *fw_priv = (struct firmware_priv *) data;
+
         fw_load_abort(fw_priv);
 }
 
-static int fw_register_device(struct device **dev_p, const char *fw_name,
-                              struct device *device)
+static struct firmware_priv *
+fw_create_instance(struct firmware *firmware, const char *fw_name,
+                   struct device *device, bool uevent, bool nowait)
 {
-        int retval;
-        struct firmware_priv *fw_priv =
-                kzalloc(sizeof(*fw_priv) + strlen(fw_name) + 1 , GFP_KERNEL);
-        struct device *f_dev = kzalloc(sizeof(*f_dev), GFP_KERNEL);
-
-        *dev_p = NULL;
+        struct firmware_priv *fw_priv;
+        struct device *f_dev;
+        int error;
 
-        if (!fw_priv || !f_dev) {
+        fw_priv = kzalloc(sizeof(*fw_priv) + strlen(fw_name) + 1 , GFP_KERNEL);
+        if (!fw_priv) {
                 dev_err(device, "%s: kmalloc failed\n", __func__);
-                retval = -ENOMEM;
-                goto error_kfree;
+                error = -ENOMEM;
+                goto err_out;
         }
 
+        fw_priv->fw = firmware;
+        fw_priv->nowait = nowait;
         strcpy(fw_priv->fw_id, fw_name);
         init_completion(&fw_priv->completion);
-        fw_priv->attr_data = firmware_attr_data_tmpl;
-        fw_priv->timeout.function = firmware_class_timeout;
-        fw_priv->timeout.data = (u_long) fw_priv;
-        init_timer(&fw_priv->timeout);
+        setup_timer(&fw_priv->timeout,
+                    firmware_class_timeout, (u_long) fw_priv);
 
+        f_dev = &fw_priv->dev;
+
+        device_initialize(f_dev);
         dev_set_name(f_dev, "%s", dev_name(device));
         f_dev->parent = device;
         f_dev->class = &firmware_class;
-        dev_set_drvdata(f_dev, fw_priv);
-        dev_set_uevent_suppress(f_dev, 1);
-        retval = device_register(f_dev);
-        if (retval) {
-                dev_err(device, "%s: device_register failed\n", __func__);
-                put_device(f_dev);
-                return retval;
-        }
-        *dev_p = f_dev;
-        return 0;
-
-error_kfree:
-        kfree(f_dev);
-        kfree(fw_priv);
-        return retval;
-}
 
-static int fw_setup_device(struct firmware *fw, struct device **dev_p,
-                           const char *fw_name, struct device *device,
-                           int uevent, bool nowait)
-{
-        struct device *f_dev;
-        struct firmware_priv *fw_priv;
-        int retval;
-
-        *dev_p = NULL;
-        retval = fw_register_device(&f_dev, fw_name, device);
-        if (retval)
-                goto out;
+        dev_set_uevent_suppress(f_dev, true);
 
         /* Need to pin this module until class device is destroyed */
         __module_get(THIS_MODULE);
 
-        fw_priv = dev_get_drvdata(f_dev);
-
-        fw_priv->nowait = nowait;
+        error = device_add(f_dev);
+        if (error) {
+                dev_err(device, "%s: device_register failed\n", __func__);
+                goto err_put_dev;
+        }
 
-        fw_priv->fw = fw;
-        sysfs_bin_attr_init(&fw_priv->attr_data);
-        retval = sysfs_create_bin_file(&f_dev->kobj, &fw_priv->attr_data);
-        if (retval) {
+        error = device_create_bin_file(f_dev, &firmware_attr_data);
+        if (error) {
                 dev_err(device, "%s: sysfs_create_bin_file failed\n", __func__);
-                goto error_unreg;
+                goto err_del_dev;
         }
 
-        retval = device_create_file(f_dev, &dev_attr_loading);
-        if (retval) {
+        error = device_create_file(f_dev, &dev_attr_loading);
+        if (error) {
                 dev_err(device, "%s: device_create_file failed\n", __func__);
-                goto error_unreg;
+                goto err_del_bin_attr;
         }
 
         if (uevent)
-                dev_set_uevent_suppress(f_dev, 0);
-        *dev_p = f_dev;
-        goto out;
+                dev_set_uevent_suppress(f_dev, false);
+
+        return fw_priv;
+
+err_del_bin_attr:
+        device_remove_bin_file(f_dev, &firmware_attr_data);
+err_del_dev:
+        device_del(f_dev);
+err_put_dev:
+        put_device(f_dev);
+err_out:
+        return ERR_PTR(error);
+}
+
+static void fw_destroy_instance(struct firmware_priv *fw_priv)
+{
+        struct device *f_dev = &fw_priv->dev;
 
-error_unreg:
+        device_remove_file(f_dev, &dev_attr_loading);
+        device_remove_bin_file(f_dev, &firmware_attr_data);
         device_unregister(f_dev);
-out:
-        return retval;
 }
 
-static int
-_request_firmware(const struct firmware **firmware_p, const char *name,
-                 struct device *device, int uevent, bool nowait)
+static int _request_firmware(const struct firmware **firmware_p,
+                             const char *name, struct device *device,
+                             bool uevent, bool nowait)
 {
-        struct device *f_dev;
         struct firmware_priv *fw_priv;
         struct firmware *firmware;
-        int retval;
+        int retval = 0;
 
         if (!firmware_p)
                 return -EINVAL;
@@ -550,41 +537,40 @@ _request_firmware(const struct firmware **firmware_p, const char *name,
         if (uevent)
                 dev_dbg(device, "firmware: requesting %s\n", name);
 
-        retval = fw_setup_device(firmware, &f_dev, name, device,
-                                 uevent, nowait);
-        if (retval)
-                goto error_kfree_fw;
-
-        fw_priv = dev_get_drvdata(f_dev);
+        fw_priv = fw_create_instance(firmware, name, device, uevent, nowait);
+        if (IS_ERR(fw_priv)) {
+                retval = PTR_ERR(fw_priv);
+                goto out;
+        }
 
         if (uevent) {
-                if (loading_timeout > 0) {
-                        fw_priv->timeout.expires = jiffies + loading_timeout * HZ;
-                        add_timer(&fw_priv->timeout);
-                }
+                if (loading_timeout > 0)
+                        mod_timer(&fw_priv->timeout,
+                                  round_jiffies_up(jiffies +
+                                                   loading_timeout * HZ));
+
+                kobject_uevent(&fw_priv->dev.kobj, KOBJ_ADD);
+        }
+
+        wait_for_completion(&fw_priv->completion);
 
-                kobject_uevent(&f_dev->kobj, KOBJ_ADD);
-                wait_for_completion(&fw_priv->completion);
-                set_bit(FW_STATUS_DONE, &fw_priv->status);
-                del_timer_sync(&fw_priv->timeout);
-        } else
-                wait_for_completion(&fw_priv->completion);
+        set_bit(FW_STATUS_DONE, &fw_priv->status);
+        del_timer_sync(&fw_priv->timeout);
 
         mutex_lock(&fw_lock);
-        if (!fw_priv->fw->size || test_bit(FW_STATUS_ABORT, &fw_priv->status)) {
+        if (!fw_priv->fw->size || test_bit(FW_STATUS_ABORT, &fw_priv->status))
                 retval = -ENOENT;
-                release_firmware(fw_priv->fw);
-                *firmware_p = NULL;
-        }
         fw_priv->fw = NULL;
         mutex_unlock(&fw_lock);
-        device_unregister(f_dev);
-        goto out;
 
-error_kfree_fw:
-        kfree(firmware);
-        *firmware_p = NULL;
+        fw_destroy_instance(fw_priv);
+
 out:
+        if (retval) {
+                release_firmware(firmware);
+                firmware_p = NULL;
+        }
+
         return retval;
 }
 
@@ -635,23 +621,24 @@ struct firmware_work {
         int uevent;
 };
 
-static int
-request_firmware_work_func(void *arg)
+static int request_firmware_work_func(void *arg)
 {
         struct firmware_work *fw_work = arg;
         const struct firmware *fw;
         int ret;
+
         if (!arg) {
                 WARN_ON(1);
                 return 0;
         }
-        ret = _request_firmware(&fw, fw_work->name, fw_work->device,
-                fw_work->uevent, true);
 
+        ret = _request_firmware(&fw, fw_work->name, fw_work->device,
+                                fw_work->uevent, true);
         fw_work->cont(fw, fw_work->context);
 
         module_put(fw_work->module);
         kfree(fw_work);
+
         return ret;
 }
 
@@ -679,34 +666,33 @@ request_firmware_nowait(
         void (*cont)(const struct firmware *fw, void *context))
 {
         struct task_struct *task;
-        struct firmware_work *fw_work = kmalloc(sizeof (struct firmware_work),
-                                                gfp);
+        struct firmware_work *fw_work;
 
+        fw_work = kzalloc(sizeof (struct firmware_work), gfp);
         if (!fw_work)
                 return -ENOMEM;
+
+        fw_work->module = module;
+        fw_work->name = name;
+        fw_work->device = device;
+        fw_work->context = context;
+        fw_work->cont = cont;
+        fw_work->uevent = uevent;
+
         if (!try_module_get(module)) {
                 kfree(fw_work);
                 return -EFAULT;
         }
 
-        *fw_work = (struct firmware_work) {
-                .module = module,
-                .name = name,
-                .device = device,
-                .context = context,
-                .cont = cont,
-                .uevent = uevent,
-        };
-
         task = kthread_run(request_firmware_work_func, fw_work,
                             "firmware/%s", name);
-
         if (IS_ERR(task)) {
                 fw_work->cont(NULL, fw_work->context);
                 module_put(fw_work->module);
                 kfree(fw_work);
                 return PTR_ERR(task);
         }
+
         return 0;
 }
 
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index f699fabf403b..c6c933f58102 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -192,13 +192,13 @@ int platform_device_add_resources(struct platform_device *pdev,
 {
         struct resource *r;
 
-        r = kmalloc(sizeof(struct resource) * num, GFP_KERNEL);
+        r = kmemdup(res, sizeof(struct resource) * num, GFP_KERNEL);
         if (r) {
-                memcpy(r, res, sizeof(struct resource) * num);
                 pdev->resource = r;
                 pdev->num_resources = num;
+                return 0;
         }
-        return r ? 0 : -ENOMEM;
+        return -ENOMEM;
 }
 EXPORT_SYMBOL_GPL(platform_device_add_resources);
 
@@ -345,108 +345,56 @@ void platform_device_unregister(struct platform_device *pdev)
 EXPORT_SYMBOL_GPL(platform_device_unregister);
 
 /**
- * platform_device_register_simple - add a platform-level device and its resources
- * @name: base name of the device we're adding
- * @id: instance id
- * @res: set of resources that needs to be allocated for the device
- * @num: number of resources
- *
- * This function creates a simple platform device that requires minimal
- * resource and memory management. Canned release function freeing memory
- * allocated for the device allows drivers using such devices to be
- * unloaded without waiting for the last reference to the device to be
- * dropped.
- *
- * This interface is primarily intended for use with legacy drivers which
- * probe hardware directly.  Because such drivers create sysfs device nodes
- * themselves, rather than letting system infrastructure handle such device
- * enumeration tasks, they don't fully conform to the Linux driver model.
- * In particular, when such drivers are built as modules, they can't be
- * "hotplugged".
+ * platform_device_register_resndata - add a platform-level device with
+ * resources and platform-specific data
  *
- * Returns &struct platform_device pointer on success, or ERR_PTR() on error.
- */
-struct platform_device *platform_device_register_simple(const char *name,
-                                                        int id,
-                                                        const struct resource *res,
-                                                        unsigned int num)
-{
-        struct platform_device *pdev;
-        int retval;
-
-        pdev = platform_device_alloc(name, id);
-        if (!pdev) {
-                retval = -ENOMEM;
-                goto error;
-        }
-
-        if (num) {
-                retval = platform_device_add_resources(pdev, res, num);
-                if (retval)
-                        goto error;
-        }
-
-        retval = platform_device_add(pdev);
-        if (retval)
-                goto error;
-
-        return pdev;
-
-error:
-        platform_device_put(pdev);
-        return ERR_PTR(retval);
-}
-EXPORT_SYMBOL_GPL(platform_device_register_simple);
-
-/**
- * platform_device_register_data - add a platform-level device with platform-specific data
  * @parent: parent device for the device we're adding
  * @name: base name of the device we're adding
  * @id: instance id
+ * @res: set of resources that needs to be allocated for the device
+ * @num: number of resources
  * @data: platform specific data for this platform device
  * @size: size of platform specific data
  *
- * This function creates a simple platform device that requires minimal
- * resource and memory management. Canned release function freeing memory
- * allocated for the device allows drivers using such devices to be
- * unloaded without waiting for the last reference to the device to be
- * dropped.
- *
  * Returns &struct platform_device pointer on success, or ERR_PTR() on error.
  */
-struct platform_device *platform_device_register_data(
+struct platform_device *__init_or_module platform_device_register_resndata(
                 struct device *parent,
                 const char *name, int id,
+                const struct resource *res, unsigned int num,
                 const void *data, size_t size)
 {
+        int ret = -ENOMEM;
         struct platform_device *pdev;
-        int retval;
 
         pdev = platform_device_alloc(name, id);
-        if (!pdev) {
-                retval = -ENOMEM;
-                goto error;
-        }
+        if (!pdev)
+                goto err;
 
         pdev->dev.parent = parent;
 
-        if (size) {
-                retval = platform_device_add_data(pdev, data, size);
-                if (retval)
-                        goto error;
+        if (res) {
+                ret = platform_device_add_resources(pdev, res, num);
+                if (ret)
+                        goto err;
         }
 
-        retval = platform_device_add(pdev);
-        if (retval)
-                goto error;
+        if (data) {
+                ret = platform_device_add_data(pdev, data, size);
+                if (ret)
+                        goto err;
+        }
 
-        return pdev;
+        ret = platform_device_add(pdev);
+        if (ret) {
+err:
+                platform_device_put(pdev);
+                return ERR_PTR(ret);
+        }
 
-error:
-        platform_device_put(pdev);
-        return ERR_PTR(retval);
+        return pdev;
 }
-EXPORT_SYMBOL_GPL(platform_device_register_data);
+EXPORT_SYMBOL_GPL(platform_device_register_resndata);
 
 static int platform_drv_probe(struct device *_dev)
 {