101 files changed, 1746 insertions, 399 deletions

diff --git a/drivers/acpi/fan.c b/drivers/acpi/fan.c
index 55c17afbe669..2655bc1b4eeb 100644
--- a/drivers/acpi/fan.c
+++ b/drivers/acpi/fan.c
@@ -263,22 +263,22 @@ static int acpi_fan_add(struct acpi_device *device)
                 goto end;
         }
 
-        printk(KERN_INFO PREFIX
-                "%s is registered as cooling_device%d\n",
-                device->dev.bus_id, cdev->id);
+        dev_info(&device->dev, "registered as cooling_device%d\n", cdev->id);
 
         acpi_driver_data(device) = cdev;
         result = sysfs_create_link(&device->dev.kobj,
                                    &cdev->device.kobj,
                                    "thermal_cooling");
         if (result)
-                printk(KERN_ERR PREFIX "Create sysfs link\n");
+                dev_err(&device->dev, "Failed to create sysfs link "
+                        "'thermal_cooling'\n");
 
         result = sysfs_create_link(&cdev->device.kobj,
                                    &device->dev.kobj,
                                    "device");
         if (result)
-                printk(KERN_ERR PREFIX "Create sysfs link\n");
+                dev_err(&device->dev, "Failed to create sysfs link "
+                        "'device'\n");
 
         result = acpi_fan_add_fs(device);
         if (result)
diff --git a/drivers/acpi/glue.c b/drivers/acpi/glue.c
index 2f173e83f8a7..084109507c9f 100644
--- a/drivers/acpi/glue.c
+++ b/drivers/acpi/glue.c
@@ -146,8 +146,7 @@ static int acpi_bind_one(struct device *dev, acpi_handle handle)
         acpi_status status;
 
         if (dev->archdata.acpi_handle) {
-                printk(KERN_WARNING PREFIX
-                       "Drivers changed 'acpi_handle' for %s\n", dev->bus_id);
+                dev_warn(dev, "Drivers changed 'acpi_handle'\n");
                 return -EINVAL;
         }
         get_device(dev);
@@ -195,8 +194,7 @@ static int acpi_unbind_one(struct device *dev)
                 /* acpi_bind_one increase refcnt by one */
                 put_device(dev);
         } else {
-                printk(KERN_ERR PREFIX
-                       "Oops, 'acpi_handle' corrupt for %s\n", dev->bus_id);
+                dev_err(dev, "Oops, 'acpi_handle' corrupt\n");
         }
         return 0;
 }
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index ec0f2d581ece..e36422a7122c 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -714,9 +714,8 @@ static int __cpuinit acpi_processor_start(struct acpi_device *device)
                 goto end;
         }
 
-        printk(KERN_INFO PREFIX
-                "%s is registered as cooling_device%d\n",
-                device->dev.bus_id, pr->cdev->id);
+        dev_info(&device->dev, "registered as cooling_device%d\n",
+                 pr->cdev->id);
 
         result = sysfs_create_link(&device->dev.kobj,
                                    &pr->cdev->device.kobj,
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index f3132aa47a69..f6f52c1a2aba 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -471,7 +471,7 @@ static int acpi_device_register(struct acpi_device *device,
         device->dev.release = &acpi_device_release;
         result = device_add(&device->dev);
         if(result) {
-                printk(KERN_ERR PREFIX "Error adding device %s", device->dev.bus_id);
+                dev_err(&device->dev, "Error adding device\n");
                 goto end;
         }
 
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index 84c795fb9b1e..30a341337933 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -1179,8 +1179,8 @@ static int acpi_thermal_register_thermal_zone(struct acpi_thermal *tz)
 
         tz->tz_enabled = 1;
 
-        printk(KERN_INFO PREFIX "%s is registered as thermal_zone%d\n",
-                        tz->device->dev.bus_id, tz->thermal_zone->id);
+        dev_info(&tz->device->dev, "registered as thermal_zone%d\n",
+                 tz->thermal_zone->id);
         return 0;
 }
 
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index 64c889331f3b..37b9e16710d6 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -762,9 +762,8 @@ static void acpi_video_device_find_cap(struct acpi_video_device *device)
                 if (IS_ERR(device->cdev))
                         return;
 
-                printk(KERN_INFO PREFIX
-                        "%s is registered as cooling_device%d\n",
-                        device->dev->dev.bus_id, device->cdev->id);
+                dev_info(&device->dev->dev, "registered as cooling_device%d\n",
+                         device->cdev->id);
                 result = sysfs_create_link(&device->dev->dev.kobj,
                                 &device->cdev->device.kobj,
                                 "thermal_cooling");
diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index d47482fa1d21..6318f6b57360 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -27,8 +27,9 @@ config PREVENT_FIRMWARE_BUILD
           If unsure say Y here.
 
 config FW_LOADER
-        tristate "Userspace firmware loading support"
+        tristate "Userspace firmware loading support" if EMBEDDED
         depends on HOTPLUG
+        default y
         ---help---
           This option is provided for the case where no in-kernel-tree modules
           require userspace firmware loading support, but a module built outside
diff --git a/drivers/base/base.h b/drivers/base/base.h
index 2c9ae43e2219..31dc0cd84afa 100644
--- a/drivers/base/base.h
+++ b/drivers/base/base.h
@@ -36,6 +36,33 @@ struct driver_private {
 };
 #define to_driver(obj) container_of(obj, struct driver_private, kobj)
 
+
+/**
+ * struct class_private - structure to hold the private to the driver core portions of the class structure.
+ *
+ * @class_subsys - the struct kset that defines this class.  This is the main kobject
+ * @class_devices - list of devices associated with this class
+ * @class_interfaces - list of class_interfaces associated with this class
+ * @class_dirs - "glue" directory for virtual devices associated with this class
+ * @class_mutex - mutex to protect the children, devices, and interfaces lists.
+ * @class - pointer back to the struct class that this structure is associated
+ * with.
+ *
+ * This structure is the one that is the actual kobject allowing struct
+ * class to be statically allocated safely.  Nothing outside of the driver
+ * core should ever touch these fields.
+ */
+struct class_private {
+        struct kset class_subsys;
+        struct list_head class_devices;
+        struct list_head class_interfaces;
+        struct kset class_dirs;
+        struct mutex class_mutex;
+        struct class *class;
+};
+#define to_class(obj)   \
+        container_of(obj, struct class_private, class_subsys.kobj)
+
 /* initialisation functions */
 extern int devices_init(void);
 extern int buses_init(void);
diff --git a/drivers/base/class.c b/drivers/base/class.c
index e085af0ff94f..839d27cecb36 100644
--- a/drivers/base/class.c
+++ b/drivers/base/class.c
@@ -18,20 +18,20 @@
 #include <linux/err.h>
 #include <linux/slab.h>
 #include <linux/genhd.h>
+#include <linux/mutex.h>
 #include "base.h"
 
 #define to_class_attr(_attr) container_of(_attr, struct class_attribute, attr)
-#define to_class(obj) container_of(obj, struct class, subsys.kobj)
 
 static ssize_t class_attr_show(struct kobject *kobj, struct attribute *attr,
                                char *buf)
 {
         struct class_attribute *class_attr = to_class_attr(attr);
-        struct class *dc = to_class(kobj);
+        struct class_private *cp = to_class(kobj);
         ssize_t ret = -EIO;
 
         if (class_attr->show)
-                ret = class_attr->show(dc, buf);
+                ret = class_attr->show(cp->class, buf);
         return ret;
 }
 
@@ -39,17 +39,18 @@ static ssize_t class_attr_store(struct kobject *kobj, struct attribute *attr,
                                 const char *buf, size_t count)
 {
         struct class_attribute *class_attr = to_class_attr(attr);
-        struct class *dc = to_class(kobj);
+        struct class_private *cp = to_class(kobj);
         ssize_t ret = -EIO;
 
         if (class_attr->store)
-                ret = class_attr->store(dc, buf, count);
+                ret = class_attr->store(cp->class, buf, count);
         return ret;
 }
 
 static void class_release(struct kobject *kobj)
 {
-        struct class *class = to_class(kobj);
+        struct class_private *cp = to_class(kobj);
+        struct class *class = cp->class;
 
         pr_debug("class '%s': release.\n", class->name);
 
@@ -70,7 +71,7 @@ static struct kobj_type class_ktype = {
         .release        = class_release,
 };
 
-/* Hotplug events for classes go to the class_obj subsys */
+/* Hotplug events for classes go to the class class_subsys */
 static struct kset *class_kset;
 
 
@@ -78,7 +79,8 @@ int class_create_file(struct class *cls, const struct class_attribute *attr)
 {
         int error;
         if (cls)
-                error = sysfs_create_file(&cls->subsys.kobj, &attr->attr);
+                error = sysfs_create_file(&cls->p->class_subsys.kobj,
+                                          &attr->attr);
         else
                 error = -EINVAL;
         return error;
@@ -87,21 +89,20 @@ int class_create_file(struct class *cls, const struct class_attribute *attr)
 void class_remove_file(struct class *cls, const struct class_attribute *attr)
 {
         if (cls)
-                sysfs_remove_file(&cls->subsys.kobj, &attr->attr);
+                sysfs_remove_file(&cls->p->class_subsys.kobj, &attr->attr);
 }
 
 static struct class *class_get(struct class *cls)
 {
         if (cls)
-                return container_of(kset_get(&cls->subsys),
-                                    struct class, subsys);
-        return NULL;
+                kset_get(&cls->p->class_subsys);
+        return cls;
 }
 
 static void class_put(struct class *cls)
 {
         if (cls)
-                kset_put(&cls->subsys);
+                kset_put(&cls->p->class_subsys);
 }
 
 static int add_class_attrs(struct class *cls)
@@ -134,42 +135,57 @@ static void remove_class_attrs(struct class *cls)
         }
 }
 
-int class_register(struct class *cls)
+int __class_register(struct class *cls, struct lock_class_key *key)
 {
+        struct class_private *cp;
         int error;
 
         pr_debug("device class '%s': registering\n", cls->name);
 
-        INIT_LIST_HEAD(&cls->devices);
-        INIT_LIST_HEAD(&cls->interfaces);
-        kset_init(&cls->class_dirs);
-        init_MUTEX(&cls->sem);
-        error = kobject_set_name(&cls->subsys.kobj, "%s", cls->name);
-        if (error)
+        cp = kzalloc(sizeof(*cp), GFP_KERNEL);
+        if (!cp)
+                return -ENOMEM;
+        INIT_LIST_HEAD(&cp->class_devices);
+        INIT_LIST_HEAD(&cp->class_interfaces);
+        kset_init(&cp->class_dirs);
+        __mutex_init(&cp->class_mutex, "struct class mutex", key);
+        error = kobject_set_name(&cp->class_subsys.kobj, "%s", cls->name);
+        if (error) {
+                kfree(cp);
                 return error;
+        }
+
+        /* set the default /sys/dev directory for devices of this class */
+        if (!cls->dev_kobj)
+                cls->dev_kobj = sysfs_dev_char_kobj;
 
 #if defined(CONFIG_SYSFS_DEPRECATED) && defined(CONFIG_BLOCK)
         /* let the block class directory show up in the root of sysfs */
         if (cls != &block_class)
-                cls->subsys.kobj.kset = class_kset;
+                cp->class_subsys.kobj.kset = class_kset;
 #else
-        cls->subsys.kobj.kset = class_kset;
+        cp->class_subsys.kobj.kset = class_kset;
 #endif
-        cls->subsys.kobj.ktype = &class_ktype;
+        cp->class_subsys.kobj.ktype = &class_ktype;
+        cp->class = cls;
+        cls->p = cp;
 
-        error = kset_register(&cls->subsys);
-        if (!error) {
-                error = add_class_attrs(class_get(cls));
-                class_put(cls);
+        error = kset_register(&cp->class_subsys);
+        if (error) {
+                kfree(cp);
+                return error;
         }
+        error = add_class_attrs(class_get(cls));
+        class_put(cls);
         return error;
 }
+EXPORT_SYMBOL_GPL(__class_register);
 
 void class_unregister(struct class *cls)
 {
         pr_debug("device class '%s': unregistering\n", cls->name);
         remove_class_attrs(cls);
-        kset_unregister(&cls->subsys);
+        kset_unregister(&cls->p->class_subsys);
 }
 
 static void class_create_release(struct class *cls)
@@ -189,7 +205,8 @@ static void class_create_release(struct class *cls)
  * Note, the pointer created here is to be destroyed when finished by
  * making a call to class_destroy().
  */
-struct class *class_create(struct module *owner, const char *name)
+struct class *__class_create(struct module *owner, const char *name,
+                             struct lock_class_key *key)
 {
         struct class *cls;
         int retval;
@@ -204,7 +221,7 @@ struct class *class_create(struct module *owner, const char *name)
         cls->owner = owner;
         cls->class_release = class_create_release;
 
-        retval = class_register(cls);
+        retval = __class_register(cls, key);
         if (retval)
                 goto error;
 
@@ -214,6 +231,7 @@ error:
         kfree(cls);
         return ERR_PTR(retval);
 }
+EXPORT_SYMBOL_GPL(__class_create);
 
 /**
  * class_destroy - destroys a struct class structure
@@ -252,39 +270,44 @@ char *make_class_name(const char *name, struct kobject *kobj)
 /**
  * class_for_each_device - device iterator
  * @class: the class we're iterating
+ * @start: the device to start with in the list, if any.
  * @data: data for the callback
  * @fn: function to be called for each device
  *
  * Iterate over @class's list of devices, and call @fn for each,
- * passing it @data.
+ * passing it @data.  If @start is set, the list iteration will start
+ * there, otherwise if it is NULL, the iteration starts at the
+ * beginning of the list.
  *
  * We check the return of @fn each time. If it returns anything
  * other than 0, we break out and return that value.
  *
- * Note, we hold class->sem in this function, so it can not be
+ * Note, we hold class->class_mutex in this function, so it can not be
  * re-acquired in @fn, otherwise it will self-deadlocking. For
  * example, calls to add or remove class members would be verboten.
  */
-int class_for_each_device(struct class *class, void *data,
-                           int (*fn)(struct device *, void *))
+int class_for_each_device(struct class *class, struct device *start,
+                          void *data, int (*fn)(struct device *, void *))
 {
         struct device *dev;
         int error = 0;
 
         if (!class)
                 return -EINVAL;
-        down(&class->sem);
-        list_for_each_entry(dev, &class->devices, node) {
+        mutex_lock(&class->p->class_mutex);
+        list_for_each_entry(dev, &class->p->class_devices, node) {
+                if (start) {
+                        if (start == dev)
+                                start = NULL;
+                        continue;
+                }
                 dev = get_device(dev);
-                if (dev) {
-                        error = fn(dev, data);
-                        put_device(dev);
-                } else
-                        error = -ENODEV;
+                error = fn(dev, data);
+                put_device(dev);
                 if (error)
                         break;
         }
-        up(&class->sem);
+        mutex_unlock(&class->p->class_mutex);
 
         return error;
 }
@@ -293,6 +316,7 @@ EXPORT_SYMBOL_GPL(class_for_each_device);
 /**
  * class_find_device - device iterator for locating a particular device
  * @class: the class we're iterating
+ * @start: Device to begin with
  * @data: data for the match function
  * @match: function to check device
  *
@@ -306,12 +330,13 @@ EXPORT_SYMBOL_GPL(class_for_each_device);
  *
  * Note, you will need to drop the reference with put_device() after use.
  *
- * We hold class->sem in this function, so it can not be
+ * We hold class->class_mutex in this function, so it can not be
  * re-acquired in @match, otherwise it will self-deadlocking. For
  * example, calls to add or remove class members would be verboten.
  */
-struct device *class_find_device(struct class *class, void *data,
-                                   int (*match)(struct device *, void *))
+struct device *class_find_device(struct class *class, struct device *start,
+                                 void *data,
+                                 int (*match)(struct device *, void *))
 {
         struct device *dev;
         int found = 0;
@@ -319,19 +344,21 @@ struct device *class_find_device(struct class *class, void *data,
         if (!class)
                 return NULL;
 
-        down(&class->sem);
-        list_for_each_entry(dev, &class->devices, node) {
+        mutex_lock(&class->p->class_mutex);
+        list_for_each_entry(dev, &class->p->class_devices, node) {
+                if (start) {
+                        if (start == dev)
+                                start = NULL;
+                        continue;
+                }
                 dev = get_device(dev);
-                if (dev) {
-                        if (match(dev, data)) {
-                                found = 1;
-                                break;
-                        } else
-                                put_device(dev);
-                } else
+                if (match(dev, data)) {
+                        found = 1;
                         break;
+                } else
+                        put_device(dev);
         }
-        up(&class->sem);
+        mutex_unlock(&class->p->class_mutex);
 
         return found ? dev : NULL;
 }
@@ -349,13 +376,13 @@ int class_interface_register(struct class_interface *class_intf)
         if (!parent)
                 return -EINVAL;
 
-        down(&parent->sem);
-        list_add_tail(&class_intf->node, &parent->interfaces);
+        mutex_lock(&parent->p->class_mutex);
+        list_add_tail(&class_intf->node, &parent->p->class_interfaces);
         if (class_intf->add_dev) {
-                list_for_each_entry(dev, &parent->devices, node)
+                list_for_each_entry(dev, &parent->p->class_devices, node)
                         class_intf->add_dev(dev, class_intf);
         }
-        up(&parent->sem);
+        mutex_unlock(&parent->p->class_mutex);
 
         return 0;
 }
@@ -368,13 +395,13 @@ void class_interface_unregister(struct class_interface *class_intf)
         if (!parent)
                 return;
 
-        down(&parent->sem);
+        mutex_lock(&parent->p->class_mutex);
         list_del_init(&class_intf->node);
         if (class_intf->remove_dev) {
-                list_for_each_entry(dev, &parent->devices, node)
+                list_for_each_entry(dev, &parent->p->class_devices, node)
                         class_intf->remove_dev(dev, class_intf);
         }
-        up(&parent->sem);
+        mutex_unlock(&parent->p->class_mutex);
 
         class_put(parent);
 }
@@ -389,9 +416,7 @@ int __init classes_init(void)
 
 EXPORT_SYMBOL_GPL(class_create_file);
 EXPORT_SYMBOL_GPL(class_remove_file);
-EXPORT_SYMBOL_GPL(class_register);
 EXPORT_SYMBOL_GPL(class_unregister);
-EXPORT_SYMBOL_GPL(class_create);
 EXPORT_SYMBOL_GPL(class_destroy);
 
 EXPORT_SYMBOL_GPL(class_interface_register);
diff --git a/drivers/base/core.c b/drivers/base/core.c
index ee0a51a3a41d..7d5c63c81a59 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -21,12 +21,16 @@
 #include <linux/genhd.h>
 #include <linux/kallsyms.h>
 #include <linux/semaphore.h>
+#include <linux/mutex.h>
 
 #include "base.h"
 #include "power/power.h"
 
 int (*platform_notify)(struct device *dev) = NULL;
 int (*platform_notify_remove)(struct device *dev) = NULL;
+static struct kobject *dev_kobj;
+struct kobject *sysfs_dev_char_kobj;
+struct kobject *sysfs_dev_block_kobj;
 
 #ifdef CONFIG_BLOCK
 static inline int device_is_not_partition(struct device *dev)
@@ -548,7 +552,7 @@ static struct kobject *get_device_parent(struct device *dev,
 {
         /* class devices without a parent live in /sys/class/<classname>/ */
         if (dev->class && (!parent || parent->class != dev->class))
-                return &dev->class->subsys.kobj;
+                return &dev->class->p->class_subsys.kobj;
         /* all other devices keep their parent */
         else if (parent)
                 return &parent->kobj;
@@ -594,13 +598,13 @@ static struct kobject *get_device_parent(struct device *dev,
                         parent_kobj = &parent->kobj;
 
                 /* find our class-directory at the parent and reference it */
-                spin_lock(&dev->class->class_dirs.list_lock);
-                list_for_each_entry(k, &dev->class->class_dirs.list, entry)
+                spin_lock(&dev->class->p->class_dirs.list_lock);
+                list_for_each_entry(k, &dev->class->p->class_dirs.list, entry)
                         if (k->parent == parent_kobj) {
                                 kobj = kobject_get(k);
                                 break;
                         }
-                spin_unlock(&dev->class->class_dirs.list_lock);
+                spin_unlock(&dev->class->p->class_dirs.list_lock);
                 if (kobj)
                         return kobj;
 
@@ -608,7 +612,7 @@ static struct kobject *get_device_parent(struct device *dev,
                 k = kobject_create();
                 if (!k)
                         return NULL;
-                k->kset = &dev->class->class_dirs;
+                k->kset = &dev->class->p->class_dirs;
                 retval = kobject_add(k, parent_kobj, "%s", dev->class->name);
                 if (retval < 0) {
                         kobject_put(k);
@@ -627,7 +631,7 @@ static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
 {
         /* see if we live in a "glue" directory */
         if (!glue_dir || !dev->class ||
-            glue_dir->kset != &dev->class->class_dirs)
+            glue_dir->kset != &dev->class->p->class_dirs)
                 return;
 
         kobject_put(glue_dir);
@@ -654,17 +658,18 @@ static int device_add_class_symlinks(struct device *dev)
         if (!dev->class)
                 return 0;
 
-        error = sysfs_create_link(&dev->kobj, &dev->class->subsys.kobj,
+        error = sysfs_create_link(&dev->kobj,
+                                  &dev->class->p->class_subsys.kobj,
                                   "subsystem");
         if (error)
                 goto out;
 
 #ifdef CONFIG_SYSFS_DEPRECATED
         /* stacked class devices need a symlink in the class directory */
-        if (dev->kobj.parent != &dev->class->subsys.kobj &&
+        if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
             device_is_not_partition(dev)) {
-                error = sysfs_create_link(&dev->class->subsys.kobj, &dev->kobj,
-                                          dev->bus_id);
+                error = sysfs_create_link(&dev->class->p->class_subsys.kobj,
+                                          &dev->kobj, dev->bus_id);
                 if (error)
                         goto out_subsys;
         }
@@ -701,13 +706,14 @@ out_device:
         if (dev->parent && device_is_not_partition(dev))
                 sysfs_remove_link(&dev->kobj, "device");
 out_busid:
-        if (dev->kobj.parent != &dev->class->subsys.kobj &&
+        if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
             device_is_not_partition(dev))
-                sysfs_remove_link(&dev->class->subsys.kobj, dev->bus_id);
+                sysfs_remove_link(&dev->class->p->class_subsys.kobj,
+                                  dev->bus_id);
 #else
         /* link in the class directory pointing to the device */
-        error = sysfs_create_link(&dev->class->subsys.kobj, &dev->kobj,
-                                  dev->bus_id);
+        error = sysfs_create_link(&dev->class->p->class_subsys.kobj,
+                                  &dev->kobj, dev->bus_id);
         if (error)
                 goto out_subsys;
 
@@ -720,7 +726,7 @@ out_busid:
         return 0;
 
 out_busid:
-        sysfs_remove_link(&dev->class->subsys.kobj, dev->bus_id);
+        sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev->bus_id);
 #endif
 
 out_subsys:
@@ -746,14 +752,15 @@ static void device_remove_class_symlinks(struct device *dev)
                 sysfs_remove_link(&dev->kobj, "device");
         }
 
-        if (dev->kobj.parent != &dev->class->subsys.kobj &&
+        if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
             device_is_not_partition(dev))
-                sysfs_remove_link(&dev->class->subsys.kobj, dev->bus_id);
+                sysfs_remove_link(&dev->class->p->class_subsys.kobj,
+                                  dev->bus_id);
 #else
         if (dev->parent && device_is_not_partition(dev))
                 sysfs_remove_link(&dev->kobj, "device");
 
-        sysfs_remove_link(&dev->class->subsys.kobj, dev->bus_id);
+        sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev->bus_id);
 #endif
 
         sysfs_remove_link(&dev->kobj, "subsystem");
@@ -776,6 +783,54 @@ int dev_set_name(struct device *dev, const char *fmt, ...)
 EXPORT_SYMBOL_GPL(dev_set_name);
 
 /**
+ * device_to_dev_kobj - select a /sys/dev/ directory for the device
+ * @dev: device
+ *
+ * By default we select char/ for new entries.  Setting class->dev_obj
+ * to NULL prevents an entry from being created.  class->dev_kobj must
+ * be set (or cleared) before any devices are registered to the class
+ * otherwise device_create_sys_dev_entry() and
+ * device_remove_sys_dev_entry() will disagree about the the presence
+ * of the link.
+ */
+static struct kobject *device_to_dev_kobj(struct device *dev)
+{
+        struct kobject *kobj;
+
+        if (dev->class)
+                kobj = dev->class->dev_kobj;
+        else
+                kobj = sysfs_dev_char_kobj;
+
+        return kobj;
+}
+
+static int device_create_sys_dev_entry(struct device *dev)
+{
+        struct kobject *kobj = device_to_dev_kobj(dev);
+        int error = 0;
+        char devt_str[15];
+
+        if (kobj) {
+                format_dev_t(devt_str, dev->devt);
+                error = sysfs_create_link(kobj, &dev->kobj, devt_str);
+        }
+
+        return error;
+}
+
+static void device_remove_sys_dev_entry(struct device *dev)
+{
+        struct kobject *kobj = device_to_dev_kobj(dev);
+        char devt_str[15];
+
+        if (kobj) {
+                format_dev_t(devt_str, dev->devt);
+                sysfs_remove_link(kobj, devt_str);
+        }
+}
+
+/**
  * device_add - add device to device hierarchy.
  * @dev: device.
  *
@@ -829,6 +884,10 @@ int device_add(struct device *dev)
                 error = device_create_file(dev, &devt_attr);
                 if (error)
                         goto ueventattrError;
+
+                error = device_create_sys_dev_entry(dev);
+                if (error)
+                        goto devtattrError;
         }
 
         error = device_add_class_symlinks(dev);
@@ -849,15 +908,16 @@ int device_add(struct device *dev)
                 klist_add_tail(&dev->knode_parent, &parent->klist_children);
 
         if (dev->class) {
-                down(&dev->class->sem);
+                mutex_lock(&dev->class->p->class_mutex);
                 /* tie the class to the device */
-                list_add_tail(&dev->node, &dev->class->devices);
+                list_add_tail(&dev->node, &dev->class->p->class_devices);
 
                 /* notify any interfaces that the device is here */
-                list_for_each_entry(class_intf, &dev->class->interfaces, node)
+                list_for_each_entry(class_intf,
+                                    &dev->class->p->class_interfaces, node)
                         if (class_intf->add_dev)
                                 class_intf->add_dev(dev, class_intf);
-                up(&dev->class->sem);
+                mutex_unlock(&dev->class->p->class_mutex);
         }
  Done:
         put_device(dev);
@@ -873,6 +933,9 @@ int device_add(struct device *dev)
         device_remove_class_symlinks(dev);
  SymlinkError:
         if (MAJOR(dev->devt))
+                device_remove_sys_dev_entry(dev);
+ devtattrError:
+        if (MAJOR(dev->devt))
                 device_remove_file(dev, &devt_attr);
  ueventattrError:
         device_remove_file(dev, &uevent_attr);
@@ -948,19 +1011,22 @@ void device_del(struct device *dev)
         device_pm_remove(dev);
         if (parent)
                 klist_del(&dev->knode_parent);
-        if (MAJOR(dev->devt))
+        if (MAJOR(dev->devt)) {
+                device_remove_sys_dev_entry(dev);
                 device_remove_file(dev, &devt_attr);
+        }
         if (dev->class) {
                 device_remove_class_symlinks(dev);
 
-                down(&dev->class->sem);
+                mutex_lock(&dev->class->p->class_mutex);
                 /* notify any interfaces that the device is now gone */
-                list_for_each_entry(class_intf, &dev->class->interfaces, node)
+                list_for_each_entry(class_intf,
+                                    &dev->class->p->class_interfaces, node)
                         if (class_intf->remove_dev)
                                 class_intf->remove_dev(dev, class_intf);
                 /* remove the device from the class list */
                 list_del_init(&dev->node);
-                up(&dev->class->sem);
+                mutex_unlock(&dev->class->p->class_mutex);
         }
         device_remove_file(dev, &uevent_attr);
         device_remove_attrs(dev);
@@ -1074,7 +1140,25 @@ int __init devices_init(void)
         devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
         if (!devices_kset)
                 return -ENOMEM;
+        dev_kobj = kobject_create_and_add("dev", NULL);
+        if (!dev_kobj)
+                goto dev_kobj_err;
+        sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
+        if (!sysfs_dev_block_kobj)
+                goto block_kobj_err;
+        sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
+        if (!sysfs_dev_char_kobj)
+                goto char_kobj_err;
+
         return 0;
+
+ char_kobj_err:
+        kobject_put(sysfs_dev_block_kobj);
+ block_kobj_err:
+        kobject_put(dev_kobj);
+ dev_kobj_err:
+        kset_unregister(devices_kset);
+        return -ENOMEM;
 }
 
 EXPORT_SYMBOL_GPL(device_for_each_child);
@@ -1158,48 +1242,11 @@ error:
 EXPORT_SYMBOL_GPL(device_create_vargs);
 
 /**
- * device_create_drvdata - creates a device and registers it with sysfs
- * @class: pointer to the struct class that this device should be registered to
- * @parent: pointer to the parent struct device of this new device, if any
- * @devt: the dev_t for the char device to be added
- * @drvdata: the data to be added to the device for callbacks
- * @fmt: string for the device's name
- *
- * This function can be used by char device classes.  A struct device
- * will be created in sysfs, registered to the specified class.
- *
- * A "dev" file will be created, showing the dev_t for the device, if
- * the dev_t is not 0,0.
- * If a pointer to a parent struct device is passed in, the newly created
- * struct device will be a child of that device in sysfs.
- * The pointer to the struct device will be returned from the call.
- * Any further sysfs files that might be required can be created using this
- * pointer.
- *
- * Note: the struct class passed to this function must have previously
- * been created with a call to class_create().
- */
-struct device *device_create_drvdata(struct class *class,
-                                     struct device *parent,
-                                     dev_t devt,
-                                     void *drvdata,
-                                     const char *fmt, ...)
-{
-        va_list vargs;
-        struct device *dev;
-
-        va_start(vargs, fmt);
-        dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
-        va_end(vargs);
-        return dev;
-}
-EXPORT_SYMBOL_GPL(device_create_drvdata);
-
-/**
  * device_create - creates a device and registers it with sysfs
  * @class: pointer to the struct class that this device should be registered to
  * @parent: pointer to the parent struct device of this new device, if any
  * @devt: the dev_t for the char device to be added
+ * @drvdata: the data to be added to the device for callbacks
  * @fmt: string for the device's name
  *
  * This function can be used by char device classes.  A struct device
@@ -1217,13 +1264,13 @@ EXPORT_SYMBOL_GPL(device_create_drvdata);
  * been created with a call to class_create().
  */
 struct device *device_create(struct class *class, struct device *parent,
-                             dev_t devt, const char *fmt, ...)
+                             dev_t devt, void *drvdata, const char *fmt, ...)
 {
         va_list vargs;
         struct device *dev;
 
         va_start(vargs, fmt);
-        dev = device_create_vargs(class, parent, devt, NULL, fmt, vargs);
+        dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
         va_end(vargs);
         return dev;
 }
@@ -1248,7 +1295,7 @@ void device_destroy(struct class *class, dev_t devt)
 {
         struct device *dev;
 
-        dev = class_find_device(class, &devt, __match_devt);
+        dev = class_find_device(class, NULL, &devt, __match_devt);
         if (dev) {
                 put_device(dev);
                 device_unregister(dev);
@@ -1298,8 +1345,9 @@ int device_rename(struct device *dev, char *new_name)
         if (old_class_name) {
                 new_class_name = make_class_name(dev->class->name, &dev->kobj);
                 if (new_class_name) {
-                        error = sysfs_create_link(&dev->parent->kobj,
-                                                  &dev->kobj, new_class_name);
+                        error = sysfs_create_link_nowarn(&dev->parent->kobj,
+                                                         &dev->kobj,
+                                                         new_class_name);
                         if (error)
                                 goto out;
                         sysfs_remove_link(&dev->parent->kobj, old_class_name);
@@ -1307,11 +1355,12 @@ int device_rename(struct device *dev, char *new_name)
         }
 #else
         if (dev->class) {
-                error = sysfs_create_link(&dev->class->subsys.kobj, &dev->kobj,
-                                          dev->bus_id);
+                error = sysfs_create_link_nowarn(&dev->class->p->class_subsys.kobj,
+                                                 &dev->kobj, dev->bus_id);
                 if (error)
                         goto out;
-                sysfs_remove_link(&dev->class->subsys.kobj, old_device_name);
+                sysfs_remove_link(&dev->class->p->class_subsys.kobj,
+                                  old_device_name);
         }
 #endif
 
@@ -1447,4 +1496,7 @@ void device_shutdown(void)
                         dev->driver->shutdown(dev);
                 }
         }
+        kobject_put(sysfs_dev_char_kobj);
+        kobject_put(sysfs_dev_block_kobj);
+        kobject_put(dev_kobj);
 }
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index e38dfed41d80..20537d507909 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -21,15 +21,16 @@ EXPORT_SYMBOL(cpu_sysdev_class);
 static DEFINE_PER_CPU(struct sys_device *, cpu_sys_devices);
 
 #ifdef CONFIG_HOTPLUG_CPU
-static ssize_t show_online(struct sys_device *dev, char *buf)
+static ssize_t show_online(struct sys_device *dev, struct sysdev_attribute *attr,
+                           char *buf)
 {
         struct cpu *cpu = container_of(dev, struct cpu, sysdev);
 
         return sprintf(buf, "%u\n", !!cpu_online(cpu->sysdev.id));
 }
 
-static ssize_t __ref store_online(struct sys_device *dev, const char *buf,
-                            size_t count)
+static ssize_t __ref store_online(struct sys_device *dev, struct sysdev_attribute *attr,
+                                 const char *buf, size_t count)
 {
         struct cpu *cpu = container_of(dev, struct cpu, sysdev);
         ssize_t ret;
@@ -80,7 +81,8 @@ static inline void register_cpu_control(struct cpu *cpu)
 #ifdef CONFIG_KEXEC
 #include <linux/kexec.h>
 
-static ssize_t show_crash_notes(struct sys_device *dev, char *buf)
+static ssize_t show_crash_notes(struct sys_device *dev, struct sysdev_attribute *attr,
+                                char *buf)
 {
         struct cpu *cpu = container_of(dev, struct cpu, sysdev);
         ssize_t rc;
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index 937e8258981d..4d4e0e7b6e92 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -92,7 +92,8 @@ unregister_memory(struct memory_block *memory, struct mem_section *section)
  * uses.
  */
 
-static ssize_t show_mem_phys_index(struct sys_device *dev, char *buf)
+static ssize_t show_mem_phys_index(struct sys_device *dev,
+                        struct sysdev_attribute *attr, char *buf)
 {
         struct memory_block *mem =
                 container_of(dev, struct memory_block, sysdev);
@@ -102,7 +103,8 @@ static ssize_t show_mem_phys_index(struct sys_device *dev, char *buf)
 /*
  * online, offline, going offline, etc.
  */
-static ssize_t show_mem_state(struct sys_device *dev, char *buf)
+static ssize_t show_mem_state(struct sys_device *dev,
+                        struct sysdev_attribute *attr, char *buf)
 {
         struct memory_block *mem =
                 container_of(dev, struct memory_block, sysdev);
@@ -217,7 +219,8 @@ out:
 }
 
 static ssize_t
-store_mem_state(struct sys_device *dev, const char *buf, size_t count)
+store_mem_state(struct sys_device *dev,
+                struct sysdev_attribute *attr, const char *buf, size_t count)
 {
         struct memory_block *mem;
         unsigned int phys_section_nr;
@@ -248,7 +251,8 @@ out:
  * s.t. if I offline all of these sections I can then
  * remove the physical device?
  */
-static ssize_t show_phys_device(struct sys_device *dev, char *buf)
+static ssize_t show_phys_device(struct sys_device *dev,
+                                struct sysdev_attribute *attr, char *buf)
 {
         struct memory_block *mem =
                 container_of(dev, struct memory_block, sysdev);
diff --git a/drivers/base/node.c b/drivers/base/node.c
index 0f867a083338..5116b78c6325 100644
--- a/drivers/base/node.c
+++ b/drivers/base/node.c
@@ -36,11 +36,13 @@ static ssize_t node_read_cpumap(struct sys_device *dev, int type, char *buf)
         return len;
 }
 
-static inline ssize_t node_read_cpumask(struct sys_device *dev, char *buf)
+static inline ssize_t node_read_cpumask(struct sys_device *dev,
+                                struct sysdev_attribute *attr, char *buf)
 {
         return node_read_cpumap(dev, 0, buf);
 }
-static inline ssize_t node_read_cpulist(struct sys_device *dev, char *buf)
+static inline ssize_t node_read_cpulist(struct sys_device *dev,
+                                struct sysdev_attribute *attr, char *buf)
 {
         return node_read_cpumap(dev, 1, buf);
 }
@@ -49,7 +51,8 @@ static SYSDEV_ATTR(cpumap,  S_IRUGO, node_read_cpumask, NULL);
 static SYSDEV_ATTR(cpulist, S_IRUGO, node_read_cpulist, NULL);
 
 #define K(x) ((x) << (PAGE_SHIFT - 10))
-static ssize_t node_read_meminfo(struct sys_device * dev, char * buf)
+static ssize_t node_read_meminfo(struct sys_device * dev,
+                        struct sysdev_attribute *attr, char * buf)
 {
         int n;
         int nid = dev->id;
@@ -112,7 +115,8 @@ static ssize_t node_read_meminfo(struct sys_device * dev, char * buf)
 #undef K
 static SYSDEV_ATTR(meminfo, S_IRUGO, node_read_meminfo, NULL);
 
-static ssize_t node_read_numastat(struct sys_device * dev, char * buf)
+static ssize_t node_read_numastat(struct sys_device * dev,
+                                struct sysdev_attribute *attr, char * buf)
 {
         return sprintf(buf,
                        "numa_hit %lu\n"
@@ -130,7 +134,8 @@ static ssize_t node_read_numastat(struct sys_device * dev, char * buf)
 }
 static SYSDEV_ATTR(numastat, S_IRUGO, node_read_numastat, NULL);
 
-static ssize_t node_read_distance(struct sys_device * dev, char * buf)
+static ssize_t node_read_distance(struct sys_device * dev,
+                        struct sysdev_attribute *attr, char * buf)
 {
         int nid = dev->id;
         int len = 0;
diff --git a/drivers/base/power/trace.c b/drivers/base/power/trace.c
index 9b1b20b59e0a..2aa6e8fc4def 100644
--- a/drivers/base/power/trace.c
+++ b/drivers/base/power/trace.c
@@ -194,7 +194,7 @@ static int show_dev_hash(unsigned int value)
                 struct device * dev = to_device(entry);
                 unsigned int hash = hash_string(DEVSEED, dev->bus_id, DEVHASH);
                 if (hash == value) {
-                        printk("  hash matches device %s\n", dev->bus_id);
+                        dev_info(dev, "hash matches\n");
                         match++;
                 }
                 entry = entry->prev;
diff --git a/drivers/base/sys.c b/drivers/base/sys.c
index 358bb0be3c08..40fc14f03540 100644
--- a/drivers/base/sys.c
+++ b/drivers/base/sys.c
@@ -36,7 +36,7 @@ sysdev_show(struct kobject * kobj, struct attribute * attr, char * buffer)
         struct sysdev_attribute * sysdev_attr = to_sysdev_attr(attr);
 
         if (sysdev_attr->show)
-                return sysdev_attr->show(sysdev, buffer);
+                return sysdev_attr->show(sysdev, sysdev_attr, buffer);
         return -EIO;
 }
 
@@ -49,7 +49,7 @@ sysdev_store(struct kobject * kobj, struct attribute * attr,
         struct sysdev_attribute * sysdev_attr = to_sysdev_attr(attr);
 
         if (sysdev_attr->store)
-                return sysdev_attr->store(sysdev, buffer, count);
+                return sysdev_attr->store(sysdev, sysdev_attr, buffer, count);
         return -EIO;
 }
 
@@ -130,8 +130,8 @@ static struct kset *system_kset;
 
 int sysdev_class_register(struct sysdev_class * cls)
 {
-        pr_debug("Registering sysdev class '%s'\n",
-                 kobject_name(&cls->kset.kobj));
+        pr_debug("Registering sysdev class '%s'\n", cls->name);
+
         INIT_LIST_HEAD(&cls->drivers);
         memset(&cls->kset.kobj, 0x00, sizeof(struct kobject));
         cls->kset.kobj.parent = &system_kset->kobj;
@@ -241,7 +241,8 @@ int sysdev_register(struct sys_device * sysdev)
         if (!cls)
                 return -EINVAL;
 
-        pr_debug("Registering sys device '%s'\n", kobject_name(&sysdev->kobj));
+        pr_debug("Registering sys device of class '%s'\n",
+                 kobject_name(&cls->kset.kobj));
 
         /* initialize the kobject to 0, in case it had previously been used */
         memset(&sysdev->kobj, 0x00, sizeof(struct kobject));
@@ -257,6 +258,9 @@ int sysdev_register(struct sys_device * sysdev)
         if (!error) {
                 struct sysdev_driver * drv;
 
+                pr_debug("Registering sys device '%s'\n",
+                         kobject_name(&sysdev->kobj));
+
                 mutex_lock(&sysdev_drivers_lock);
                 /* Generic notification is implicit, because it's that
                  * code that should have called us.
@@ -269,6 +273,7 @@ int sysdev_register(struct sys_device * sysdev)
                 }
                 mutex_unlock(&sysdev_drivers_lock);
         }
+
         kobject_uevent(&sysdev->kobj, KOBJ_ADD);
         return error;
 }
@@ -474,3 +479,52 @@ int __init system_bus_init(void)
 
 EXPORT_SYMBOL_GPL(sysdev_register);
 EXPORT_SYMBOL_GPL(sysdev_unregister);
+
+#define to_ext_attr(x) container_of(x, struct sysdev_ext_attribute, attr)
+
+ssize_t sysdev_store_ulong(struct sys_device *sysdev,
+                           struct sysdev_attribute *attr,
+                           const char *buf, size_t size)
+{
+        struct sysdev_ext_attribute *ea = to_ext_attr(attr);
+        char *end;
+        unsigned long new = simple_strtoul(buf, &end, 0);
+        if (end == buf)
+                return -EINVAL;
+        *(unsigned long *)(ea->var) = new;
+        return end - buf;
+}
+EXPORT_SYMBOL_GPL(sysdev_store_ulong);
+
+ssize_t sysdev_show_ulong(struct sys_device *sysdev,
+                          struct sysdev_attribute *attr,
+                          char *buf)
+{
+        struct sysdev_ext_attribute *ea = to_ext_attr(attr);
+        return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));
+}
+EXPORT_SYMBOL_GPL(sysdev_show_ulong);
+
+ssize_t sysdev_store_int(struct sys_device *sysdev,
+                           struct sysdev_attribute *attr,
+                           const char *buf, size_t size)
+{
+        struct sysdev_ext_attribute *ea = to_ext_attr(attr);
+        char *end;
+        long new = simple_strtol(buf, &end, 0);
+        if (end == buf || new > INT_MAX || new < INT_MIN)
+                return -EINVAL;
+        *(int *)(ea->var) = new;
+        return end - buf;
+}
+EXPORT_SYMBOL_GPL(sysdev_store_int);
+
+ssize_t sysdev_show_int(struct sys_device *sysdev,
+                          struct sysdev_attribute *attr,
+                          char *buf)
+{
+        struct sysdev_ext_attribute *ea = to_ext_attr(attr);
+        return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));
+}
+EXPORT_SYMBOL_GPL(sysdev_show_int);
+
diff --git a/drivers/base/topology.c b/drivers/base/topology.c
index 3f6d9b0a6abe..199cd97e32e6 100644
--- a/drivers/base/topology.c
+++ b/drivers/base/topology.c
@@ -34,7 +34,8 @@
 static SYSDEV_ATTR(_name, 0444, show_##_name, NULL)
 
 #define define_id_show_func(name)                               \
-static ssize_t show_##name(struct sys_device *dev, char *buf)   \
+static ssize_t show_##name(struct sys_device *dev,              \
+                struct sysdev_attribute *attr, char *buf)       \
 {                                                               \
         unsigned int cpu = dev->id;                             \
         return sprintf(buf, "%d\n", topology_##name(cpu));      \
@@ -59,14 +60,17 @@ static ssize_t show_cpumap(int type, cpumask_t *mask, char *buf)
 
 #ifdef arch_provides_topology_pointers
 #define define_siblings_show_map(name)                                  \
-static ssize_t show_##name(struct sys_device *dev, char *buf)   \
+static ssize_t show_##name(struct sys_device *dev,                      \
+                           struct sysdev_attribute *attr, char *buf)    \
 {                                                                       \
         unsigned int cpu = dev->id;                                     \
         return show_cpumap(0, &(topology_##name(cpu)), buf);            \
 }
 
 #define define_siblings_show_list(name)                                 \
-static ssize_t show_##name##_list(struct sys_device *dev, char *buf) \
+static ssize_t show_##name##_list(struct sys_device *dev,               \
+                                  struct sysdev_attribute *attr,        \
+                                  char *buf)                            \
 {                                                                       \
         unsigned int cpu = dev->id;                                     \
         return show_cpumap(1, &(topology_##name(cpu)), buf);            \
@@ -74,7 +78,8 @@ static ssize_t show_##name##_list(struct sys_device *dev, char *buf) \
 
 #else
 #define define_siblings_show_map(name)                                  \
-static ssize_t show_##name(struct sys_device *dev, char *buf)   \
+static ssize_t show_##name(struct sys_device *dev,                      \
+                           struct sysdev_attribute *attr, char *buf)    \
 {                                                                       \
         unsigned int cpu = dev->id;                                     \
         cpumask_t mask = topology_##name(cpu);                          \
@@ -82,7 +87,9 @@ static ssize_t show_##name(struct sys_device *dev, char *buf)	\
 }
 
 #define define_siblings_show_list(name)                                 \
-static ssize_t show_##name##_list(struct sys_device *dev, char *buf) \
+static ssize_t show_##name##_list(struct sys_device *dev,               \
+                                  struct sysdev_attribute *attr,        \
+                                  char *buf)                            \
 {                                                                       \
         unsigned int cpu = dev->id;                                     \
         cpumask_t mask = topology_##name(cpu);                          \
diff --git a/drivers/block/aoe/aoechr.c b/drivers/block/aoe/aoechr.c
index d1de68a31920..c04440cd6a32 100644
--- a/drivers/block/aoe/aoechr.c
+++ b/drivers/block/aoe/aoechr.c
@@ -277,8 +277,9 @@ aoechr_init(void)
                 return PTR_ERR(aoe_class);
         }
         for (i = 0; i < ARRAY_SIZE(chardevs); ++i)
-                device_create(aoe_class, NULL,
-                              MKDEV(AOE_MAJOR, chardevs[i].minor), chardevs[i].name);
+                device_create_drvdata(aoe_class, NULL,
+                                      MKDEV(AOE_MAJOR, chardevs[i].minor),
+                                      NULL, chardevs[i].name);
 
         return 0;
 }
diff --git a/drivers/block/paride/pg.c b/drivers/block/paride/pg.c
index 9d92636350e5..d731ca42f802 100644
--- a/drivers/block/paride/pg.c
+++ b/drivers/block/paride/pg.c
@@ -686,8 +686,9 @@ static int __init pg_init(void)
         for (unit = 0; unit < PG_UNITS; unit++) {
                 struct pg *dev = &devices[unit];
                 if (dev->present)
-                        device_create(pg_class, NULL, MKDEV(major, unit),
-                                      "pg%u", unit);
+                        device_create_drvdata(pg_class, NULL,
+                                              MKDEV(major, unit), NULL,
+                                              "pg%u", unit);
         }
         err = 0;
         goto out;
diff --git a/drivers/block/paride/pt.c b/drivers/block/paride/pt.c
index 5c74c3574a5a..673b8b2fd337 100644
--- a/drivers/block/paride/pt.c
+++ b/drivers/block/paride/pt.c
@@ -979,10 +979,12 @@ static int __init pt_init(void)
 
         for (unit = 0; unit < PT_UNITS; unit++)
                 if (pt[unit].present) {
-                        device_create(pt_class, NULL, MKDEV(major, unit),
-                                      "pt%d", unit);
-                        device_create(pt_class, NULL, MKDEV(major, unit + 128),
-                                      "pt%dn", unit);
+                        device_create_drvdata(pt_class, NULL,
+                                              MKDEV(major, unit), NULL,
+                                              "pt%d", unit);
+                        device_create_drvdata(pt_class, NULL,
+                                              MKDEV(major, unit + 128), NULL,
+                                              "pt%dn", unit);
                 }
         goto out;
 
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 45bee918c46a..158eed4d5161 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -303,7 +303,9 @@ static struct kobj_type kobj_pkt_type_wqueue = {
 static void pkt_sysfs_dev_new(struct pktcdvd_device *pd)
 {
         if (class_pktcdvd) {
-                pd->dev = device_create(class_pktcdvd, NULL, pd->pkt_dev, "%s", pd->name);
+                pd->dev = device_create_drvdata(class_pktcdvd, NULL,
+                                                pd->pkt_dev, NULL,
+                                                "%s", pd->name);
                 if (IS_ERR(pd->dev))
                         pd->dev = NULL;
         }
diff --git a/drivers/char/dsp56k.c b/drivers/char/dsp56k.c
index b9a30c30e2b8..33c466a4888f 100644
--- a/drivers/char/dsp56k.c
+++ b/drivers/char/dsp56k.c
@@ -500,7 +500,8 @@ static int __init dsp56k_init_driver(void)
                 err = PTR_ERR(dsp56k_class);
                 goto out_chrdev;
         }
-        device_create(dsp56k_class, NULL, MKDEV(DSP56K_MAJOR, 0), "dsp56k");
+        device_create_drvdata(dsp56k_class, NULL, MKDEV(DSP56K_MAJOR, 0),
+                              NULL, "dsp56k");
 
         printk(banner);
         goto out;
diff --git a/drivers/char/ip2/ip2main.c b/drivers/char/ip2/ip2main.c
index 5dc74404058f..9cb48fcd316c 100644
--- a/drivers/char/ip2/ip2main.c
+++ b/drivers/char/ip2/ip2main.c
@@ -718,12 +718,12 @@ ip2_loadmain(int *iop, int *irqp)
                         }
 
                         if ( NULL != ( pB = i2BoardPtrTable[i] ) ) {
-                                device_create(ip2_class, NULL,
-                                                MKDEV(IP2_IPL_MAJOR, 4 * i),
-                                                "ipl%d", i);
-                                device_create(ip2_class, NULL,
-                                                MKDEV(IP2_IPL_MAJOR, 4 * i + 1),
-                                                "stat%d", i);
+                                device_create_drvdata(ip2_class, NULL,
+                                                      MKDEV(IP2_IPL_MAJOR, 4 * i),
+                                                      NULL, "ipl%d", i);
+                                device_create_drvdata(ip2_class, NULL,
+                                                      MKDEV(IP2_IPL_MAJOR, 4 * i + 1),
+                                                      NULL, "stat%d", i);
 
                             for ( box = 0; box < ABS_MAX_BOXES; ++box )
                             {
diff --git a/drivers/char/ipmi/ipmi_devintf.c b/drivers/char/ipmi/ipmi_devintf.c
index c11a40483459..64e1c169e826 100644
--- a/drivers/char/ipmi/ipmi_devintf.c
+++ b/drivers/char/ipmi/ipmi_devintf.c
@@ -871,7 +871,7 @@ static void ipmi_new_smi(int if_num, struct device *device)
         entry->dev = dev;
 
         mutex_lock(&reg_list_mutex);
-        device_create(ipmi_class, device, dev, "ipmi%d", if_num);
+        device_create_drvdata(ipmi_class, device, dev, NULL, "ipmi%d", if_num);
         list_add(&entry->link, &reg_list);
         mutex_unlock(&reg_list_mutex);
 }
diff --git a/drivers/char/istallion.c b/drivers/char/istallion.c
index f9ebcd41d8e5..843a2afaf204 100644
--- a/drivers/char/istallion.c
+++ b/drivers/char/istallion.c
@@ -4599,8 +4599,9 @@ static int __init istallion_module_init(void)
 
         istallion_class = class_create(THIS_MODULE, "staliomem");
         for (i = 0; i < 4; i++)
-                device_create(istallion_class, NULL, MKDEV(STL_SIOMEMMAJOR, i),
-                              "staliomem%d", i);
+                device_create_drvdata(istallion_class, NULL,
+                                      MKDEV(STL_SIOMEMMAJOR, i),
+                                      NULL, "staliomem%d", i);
 
         return 0;
 err_deinit:
diff --git a/drivers/char/lp.c b/drivers/char/lp.c
index 71abb4c33aa2..3f2719b9f77b 100644
--- a/drivers/char/lp.c
+++ b/drivers/char/lp.c
@@ -813,7 +813,8 @@ static int lp_register(int nr, struct parport *port)
         if (reset)
                 lp_reset(nr);
 
-        device_create(lp_class, port->dev, MKDEV(LP_MAJOR, nr), "lp%d", nr);
+        device_create_drvdata(lp_class, port->dev, MKDEV(LP_MAJOR, nr), NULL,
+                              "lp%d", nr);
 
         printk(KERN_INFO "lp%d: using %s (%s).\n", nr, port->name, 
                (port->irq == PARPORT_IRQ_NONE)?"polling":"interrupt-driven");
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index b6772d657547..c2dba82eb5f7 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -989,9 +989,9 @@ static int __init chr_dev_init(void)
 
         mem_class = class_create(THIS_MODULE, "mem");
         for (i = 0; i < ARRAY_SIZE(devlist); i++)
-                device_create(mem_class, NULL,
-                              MKDEV(MEM_MAJOR, devlist[i].minor),
-                              devlist[i].name);
+                device_create_drvdata(mem_class, NULL,
+                                      MKDEV(MEM_MAJOR, devlist[i].minor),
+                                      NULL, devlist[i].name);
 
         return 0;
 }
diff --git a/drivers/char/misc.c b/drivers/char/misc.c
index 6e1563c3d30a..999aa779c08a 100644
--- a/drivers/char/misc.c
+++ b/drivers/char/misc.c
@@ -217,8 +217,8 @@ int misc_register(struct miscdevice * misc)
                 misc_minors[misc->minor >> 3] |= 1 << (misc->minor & 7);
         dev = MKDEV(MISC_MAJOR, misc->minor);
 
-        misc->this_device = device_create(misc_class, misc->parent, dev,
-                                          "%s", misc->name);
+        misc->this_device = device_create_drvdata(misc_class, misc->parent,
+                                                  dev, NULL, "%s", misc->name);
         if (IS_ERR(misc->this_device)) {
                 err = PTR_ERR(misc->this_device);
                 goto out;
diff --git a/drivers/char/pcmcia/cm4000_cs.c b/drivers/char/pcmcia/cm4000_cs.c
index e4a4fbd37d7a..f070ae7bd91a 100644
--- a/drivers/char/pcmcia/cm4000_cs.c
+++ b/drivers/char/pcmcia/cm4000_cs.c
@@ -1896,7 +1896,7 @@ static int cm4000_probe(struct pcmcia_device *link)
                 return ret;
         }
 
-        device_create(cmm_class, NULL, MKDEV(major, i), "cmm%d", i);
+        device_create_drvdata(cmm_class, NULL, MKDEV(major, i), NULL, "cmm%d", i);
 
         return 0;
 }
diff --git a/drivers/char/pcmcia/cm4040_cs.c b/drivers/char/pcmcia/cm4040_cs.c
index 6181f8a9b0bd..0b5934bef7a4 100644
--- a/drivers/char/pcmcia/cm4040_cs.c
+++ b/drivers/char/pcmcia/cm4040_cs.c
@@ -653,7 +653,8 @@ static int reader_probe(struct pcmcia_device *link)
                 return ret;
         }
 
-        device_create(cmx_class, NULL, MKDEV(major, i), "cmx%d", i);
+        device_create_drvdata(cmx_class, NULL, MKDEV(major, i), NULL,
+                              "cmx%d", i);
 
         return 0;
 }
diff --git a/drivers/char/ppdev.c b/drivers/char/ppdev.c
index f6e6acadd9a0..7af7a7e6b9c2 100644
--- a/drivers/char/ppdev.c
+++ b/drivers/char/ppdev.c
@@ -752,8 +752,9 @@ static const struct file_operations pp_fops = {
 
 static void pp_attach(struct parport *port)
 {
-        device_create(ppdev_class, port->dev, MKDEV(PP_MAJOR, port->number),
-                        "parport%d", port->number);
+        device_create_drvdata(ppdev_class, port->dev,
+                              MKDEV(PP_MAJOR, port->number),
+                              NULL, "parport%d", port->number);
 }
 
 static void pp_detach(struct parport *port)
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index 505fcbe884a4..47b8cf281d4a 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -131,8 +131,8 @@ raw_ioctl(struct inode *inode, struct file *filp,
 static void bind_device(struct raw_config_request *rq)
 {
         device_destroy(raw_class, MKDEV(RAW_MAJOR, rq->raw_minor));
-        device_create(raw_class, NULL, MKDEV(RAW_MAJOR, rq->raw_minor),
-                      "raw%d", rq->raw_minor);
+        device_create_drvdata(raw_class, NULL, MKDEV(RAW_MAJOR, rq->raw_minor),
+                              NULL, "raw%d", rq->raw_minor);
 }
 
 /*
@@ -283,7 +283,8 @@ static int __init raw_init(void)
                 ret = PTR_ERR(raw_class);
                 goto error_region;
         }
-        device_create(raw_class, NULL, MKDEV(RAW_MAJOR, 0), "rawctl");
+        device_create_drvdata(raw_class, NULL, MKDEV(RAW_MAJOR, 0), NULL,
+                              "rawctl");
 
         return 0;
 
diff --git a/drivers/char/snsc.c b/drivers/char/snsc.c
index 0b799ac1b049..3ce60df14c0a 100644
--- a/drivers/char/snsc.c
+++ b/drivers/char/snsc.c
@@ -444,7 +444,8 @@ scdrv_init(void)
                                 continue;
                         }
 
-                        device_create(snsc_class, NULL, dev, "%s", devname);
+                        device_create_drvdata(snsc_class, NULL, dev, NULL,
+                                              "%s", devname);
 
                         ia64_sn_irtr_intr_enable(scd->scd_nasid,
                                                  0 /*ignored */ ,
diff --git a/drivers/char/stallion.c b/drivers/char/stallion.c
index de5a725c3cc0..b976248e1072 100644
--- a/drivers/char/stallion.c
+++ b/drivers/char/stallion.c
@@ -4755,8 +4755,8 @@ static int __init stallion_module_init(void)
         if (IS_ERR(stallion_class))
                 printk("STALLION: failed to create class\n");
         for (i = 0; i < 4; i++)
-                device_create(stallion_class, NULL, MKDEV(STL_SIOMEMMAJOR, i),
-                              "staliomem%d", i);
+                device_create_drvdata(stallion_class, NULL, MKDEV(STL_SIOMEMMAJOR, i),
+                                      NULL, "staliomem%d", i);
 
         return 0;
 err_unrtty:
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index d94cd8410c53..15e597d03002 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -3412,7 +3412,7 @@ struct device *tty_register_device(struct tty_driver *driver, unsigned index,
         else
                 tty_line_name(driver, index, name);
 
-        return device_create(tty_class, device, dev, name);
+        return device_create_drvdata(tty_class, device, dev, NULL, name);
 }
 
 /**
@@ -3690,20 +3690,22 @@ static int __init tty_init(void)
         if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
                 panic("Couldn't register /dev/tty driver\n");
-        device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), "tty");
+        device_create_drvdata(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL,
+                              "tty");
 
         cdev_init(&console_cdev, &console_fops);
         if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
                 panic("Couldn't register /dev/console driver\n");
-        device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), "console");
+        device_create_drvdata(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
+                              "console");
 
 #ifdef CONFIG_UNIX98_PTYS
         cdev_init(&ptmx_cdev, &ptmx_fops);
         if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
                 panic("Couldn't register /dev/ptmx driver\n");
-        device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), "ptmx");
+        device_create_drvdata(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
 #endif
 
 #ifdef CONFIG_VT
@@ -3711,7 +3713,7 @@ static int __init tty_init(void)
         if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
             register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
                 panic("Couldn't register /dev/tty0 driver\n");
-        device_create(tty_class, NULL, MKDEV(TTY_MAJOR, 0), "tty0");
+        device_create_drvdata(tty_class, NULL, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
 
         vty_init();
 #endif
diff --git a/drivers/char/vc_screen.c b/drivers/char/vc_screen.c
index eebfad2777d2..c2ae52dd53d1 100644
--- a/drivers/char/vc_screen.c
+++ b/drivers/char/vc_screen.c
@@ -481,10 +481,10 @@ static struct class *vc_class;
 
 void vcs_make_sysfs(struct tty_struct *tty)
 {
-        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 1),
-                        "vcs%u", tty->index + 1);
-        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 129),
-                        "vcsa%u", tty->index + 1);
+        device_create_drvdata(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 1),
+                              NULL, "vcs%u", tty->index + 1);
+        device_create_drvdata(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 129),
+                              NULL, "vcsa%u", tty->index + 1);
 }
 
 void vcs_remove_sysfs(struct tty_struct *tty)
@@ -499,7 +499,7 @@ int __init vcs_init(void)
                 panic("unable to get major %d for vcs device", VCS_MAJOR);
         vc_class = class_create(THIS_MODULE, "vc");
 
-        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, 0), "vcs");
-        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, 128), "vcsa");
+        device_create_drvdata(vc_class, NULL, MKDEV(VCS_MAJOR, 0), NULL, "vcs");
+        device_create_drvdata(vc_class, NULL, MKDEV(VCS_MAJOR, 128), NULL, "vcsa");
         return 0;
 }
diff --git a/drivers/char/viotape.c b/drivers/char/viotape.c
index e5da98d8f9cd..7a70a40ad639 100644
--- a/drivers/char/viotape.c
+++ b/drivers/char/viotape.c
@@ -886,10 +886,10 @@ static int viotape_probe(struct vio_dev *vdev, const struct vio_device_id *id)
         state[i].cur_part = 0;
         for (j = 0; j < MAX_PARTITIONS; ++j)
                 state[i].part_stat_rwi[j] = VIOT_IDLE;
-        device_create(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i),
-                        "iseries!vt%d", i);
-        device_create(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i | 0x80),
-                        "iseries!nvt%d", i);
+        device_create_drvdata(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i),
+                              NULL, "iseries!vt%d", i);
+        device_create_drvdata(tape_class, NULL, MKDEV(VIOTAPE_MAJOR, i | 0x80),
+                              NULL, "iseries!nvt%d", i);
         printk(VIOTAPE_KERN_INFO "tape iseries/vt%d is iSeries "
                         "resource %10.10s type %4.4s, model %3.3s\n",
                         i, viotape_unitinfo[i].rsrcname,
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index 935f1c207a1f..e32a076d5f1f 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -3425,9 +3425,10 @@ int register_con_driver(const struct consw *csw, int first, int last)
         if (retval)
                 goto err;
 
-        con_driver->dev = device_create(vtconsole_class, NULL,
-                                        MKDEV(0, con_driver->node),
-                                        "vtcon%i", con_driver->node);
+        con_driver->dev = device_create_drvdata(vtconsole_class, NULL,
+                                                MKDEV(0, con_driver->node),
+                                                NULL, "vtcon%i",
+                                                con_driver->node);
 
         if (IS_ERR(con_driver->dev)) {
                 printk(KERN_WARNING "Unable to create device for %s; "
@@ -3535,9 +3536,10 @@ static int __init vtconsole_class_init(void)
                 struct con_driver *con = &registered_con_driver[i];
 
                 if (con->con && !con->dev) {
-                        con->dev = device_create(vtconsole_class, NULL,
-                                                 MKDEV(0, con->node),
-                                                 "vtcon%i", con->node);
+                        con->dev = device_create_drvdata(vtconsole_class, NULL,
+                                                         MKDEV(0, con->node),
+                                                         NULL, "vtcon%i",
+                                                         con->node);
 
                         if (IS_ERR(con->dev)) {
                                 printk(KERN_WARNING "Unable to create "
diff --git a/drivers/char/xilinx_hwicap/xilinx_hwicap.c b/drivers/char/xilinx_hwicap/xilinx_hwicap.c
index 1e1b81e57cdc..51966ccf4ea3 100644
--- a/drivers/char/xilinx_hwicap/xilinx_hwicap.c
+++ b/drivers/char/xilinx_hwicap/xilinx_hwicap.c
@@ -658,8 +658,9 @@ static int __devinit hwicap_setup(struct device *dev, int id,
                 dev_err(dev, "cdev_add() failed\n");
                 goto failed3;
         }
-        /*  devfs_mk_cdev(devt, S_IFCHR|S_IRUGO|S_IWUGO, DRIVER_NAME); */
-        device_create(icap_class, dev, devt, "%s%d", DRIVER_NAME, id);
+
+        device_create_drvdata(icap_class, dev, devt, NULL,
+                              "%s%d", DRIVER_NAME, id);
         return 0;               /* success */
 
  failed3:
diff --git a/drivers/cpuidle/sysfs.c b/drivers/cpuidle/sysfs.c
index e949618b9be0..31a0e0b455b6 100644
--- a/drivers/cpuidle/sysfs.c
+++ b/drivers/cpuidle/sysfs.c
@@ -21,7 +21,8 @@ static int __init cpuidle_sysfs_setup(char *unused)
 }
 __setup("cpuidle_sysfs_switch", cpuidle_sysfs_setup);
 
-static ssize_t show_available_governors(struct sys_device *dev, char *buf)
+static ssize_t show_available_governors(struct sys_device *dev,
+                struct sysdev_attribute *attr, char *buf)
 {
         ssize_t i = 0;
         struct cpuidle_governor *tmp;
@@ -39,7 +40,8 @@ out:
         return i;
 }
 
-static ssize_t show_current_driver(struct sys_device *dev, char *buf)
+static ssize_t show_current_driver(struct sys_device *dev,
+                struct sysdev_attribute *attr, char *buf)
 {
         ssize_t ret;
 
@@ -53,7 +55,8 @@ static ssize_t show_current_driver(struct sys_device *dev, char *buf)
         return ret;
 }
 
-static ssize_t show_current_governor(struct sys_device *dev, char *buf)
+static ssize_t show_current_governor(struct sys_device *dev,
+                        struct sysdev_attribute *attr, char *buf)
 {
         ssize_t ret;
 
@@ -68,6 +71,7 @@ static ssize_t show_current_governor(struct sys_device *dev, char *buf)
 }
 
 static ssize_t store_current_governor(struct sys_device *dev,
+        struct sysdev_attribute *attr,
         const char *buf, size_t count)
 {
         char gov_name[CPUIDLE_NAME_LEN];
diff --git a/drivers/dca/dca-sysfs.c b/drivers/dca/dca-sysfs.c
index 011328faa5f2..9a70377bfb34 100644
--- a/drivers/dca/dca-sysfs.c
+++ b/drivers/dca/dca-sysfs.c
@@ -14,8 +14,9 @@ int dca_sysfs_add_req(struct dca_provider *dca, struct device *dev, int slot)
 {
         struct device *cd;
 
-        cd = device_create(dca_class, dca->cd, MKDEV(0, slot + 1),
-                           "requester%d", slot);
+        cd = device_create_drvdata(dca_class, dca->cd,
+                                   MKDEV(0, slot + 1), NULL,
+                                   "requester%d", slot);
         if (IS_ERR(cd))
                 return PTR_ERR(cd);
         return 0;
@@ -46,7 +47,8 @@ idr_try_again:
                 return err;
         }
 
-        cd = device_create(dca_class, dev, MKDEV(0, 0), "dca%d", dca->id);
+        cd = device_create_drvdata(dca_class, dev, MKDEV(0, 0), NULL,
+                                   "dca%d", dca->id);
         if (IS_ERR(cd)) {
                 spin_lock(&dca_idr_lock);
                 idr_remove(&dca_idr, dca->id);
diff --git a/drivers/eisa/Makefile b/drivers/eisa/Makefile
index 70abf93fe6b0..5369ce957c6d 100644
--- a/drivers/eisa/Makefile
+++ b/drivers/eisa/Makefile
@@ -9,7 +9,7 @@ obj-${CONFIG_EISA_VIRTUAL_ROOT} += virtual_root.o
 
 
 # Ugly hack to get DEVICE_NAME_SIZE value...
-DEVICE_NAME_SIZE =$(shell awk '$$1=="\#define" && $$2=="DEVICE_NAME_SIZE" {print $$3-1}' $(srctree)/include/linux/device.h)
+DEVICE_NAME_SIZE = 50
 
 $(obj)/eisa-bus.o: $(obj)/devlist.h
 
diff --git a/drivers/eisa/eisa-bus.c b/drivers/eisa/eisa-bus.c
index 65dcf0432653..c950bf8606d9 100644
--- a/drivers/eisa/eisa-bus.c
+++ b/drivers/eisa/eisa-bus.c
@@ -22,7 +22,7 @@
 
 struct eisa_device_info {
         struct eisa_device_id id;
-        char name[DEVICE_NAME_SIZE];
+        char name[50];
 };
 
 #ifdef CONFIG_EISA_NAMES
@@ -63,7 +63,7 @@ static void __init eisa_name_device (struct eisa_device *edev)
                 if (!strcmp (edev->id.sig, eisa_table[i].id.sig)) {
                         strlcpy (edev->pretty_name,
                                  eisa_table[i].name,
-                                 DEVICE_NAME_SIZE);
+                                 sizeof(edev->pretty_name));
                         return;
                 }
         }
diff --git a/drivers/hid/hidraw.c b/drivers/hid/hidraw.c
index 2fde6c63f47d..0c6b4d4e7e27 100644
--- a/drivers/hid/hidraw.c
+++ b/drivers/hid/hidraw.c
@@ -322,8 +322,9 @@ int hidraw_connect(struct hid_device *hid)
                 goto out;
         }
 
-        dev->dev = device_create(hidraw_class, NULL, MKDEV(hidraw_major, minor),
-                                "%s%d", "hidraw", minor);
+        dev->dev = device_create_drvdata(hidraw_class, NULL,
+                                         MKDEV(hidraw_major, minor), NULL,
+                                         "%s%d", "hidraw", minor);
 
         if (IS_ERR(dev->dev)) {
                 spin_lock(&minors_lock);
diff --git a/drivers/hwmon/hwmon.c b/drivers/hwmon/hwmon.c
index 3db28450a3b3..7321a88a5112 100644
--- a/drivers/hwmon/hwmon.c
+++ b/drivers/hwmon/hwmon.c
@@ -55,7 +55,8 @@ again:
                 return ERR_PTR(err);
 
         id = id & MAX_ID_MASK;
-        hwdev = device_create(hwmon_class, dev, MKDEV(0,0), HWMON_ID_FORMAT, id);
+        hwdev = device_create_drvdata(hwmon_class, dev, MKDEV(0, 0), NULL,
+                                      HWMON_ID_FORMAT, id);
 
         if (IS_ERR(hwdev)) {
                 spin_lock(&idr_lock);
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 7608df83d6d1..7bf38c418086 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -722,7 +722,8 @@ int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
 
         INIT_LIST_HEAD(&driver->clients);
         /* Walk the adapters that are already present */
-        class_for_each_device(&i2c_adapter_class, driver, __attach_adapter);
+        class_for_each_device(&i2c_adapter_class, NULL, driver,
+                              __attach_adapter);
 
         mutex_unlock(&core_lock);
         return 0;
@@ -782,7 +783,8 @@ void i2c_del_driver(struct i2c_driver *driver)
 {
         mutex_lock(&core_lock);
 
-        class_for_each_device(&i2c_adapter_class, driver, __detach_adapter);
+        class_for_each_device(&i2c_adapter_class, NULL, driver,
+                              __detach_adapter);
 
         driver_unregister(&driver->driver);
         pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
diff --git a/drivers/i2c/i2c-dev.c b/drivers/i2c/i2c-dev.c
index 86727fa8858f..9d55c6383b23 100644
--- a/drivers/i2c/i2c-dev.c
+++ b/drivers/i2c/i2c-dev.c
@@ -521,9 +521,9 @@ static int i2cdev_attach_adapter(struct i2c_adapter *adap)
                 return PTR_ERR(i2c_dev);
 
         /* register this i2c device with the driver core */
-        i2c_dev->dev = device_create(i2c_dev_class, &adap->dev,
-                                     MKDEV(I2C_MAJOR, adap->nr),
-                                     "i2c-%d", adap->nr);
+        i2c_dev->dev = device_create_drvdata(i2c_dev_class, &adap->dev,
+                                             MKDEV(I2C_MAJOR, adap->nr),
+                                             NULL, "i2c-%d", adap->nr);
         if (IS_ERR(i2c_dev->dev)) {
                 res = PTR_ERR(i2c_dev->dev);
                 goto error;
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index b711ab96e287..353dd11b9283 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -2697,10 +2697,12 @@ static int ide_tape_probe(ide_drive_t *drive)
 
         idetape_setup(drive, tape, minor);
 
-        device_create(idetape_sysfs_class, &drive->gendev,
-                      MKDEV(IDETAPE_MAJOR, minor), "%s", tape->name);
-        device_create(idetape_sysfs_class, &drive->gendev,
-                        MKDEV(IDETAPE_MAJOR, minor + 128), "n%s", tape->name);
+        device_create_drvdata(idetape_sysfs_class, &drive->gendev,
+                              MKDEV(IDETAPE_MAJOR, minor), NULL,
+                              "%s", tape->name);
+        device_create_drvdata(idetape_sysfs_class, &drive->gendev,
+                              MKDEV(IDETAPE_MAJOR, minor + 128), NULL,
+                              "n%s", tape->name);
 
         g->fops = &idetape_block_ops;
         ide_register_region(g);
diff --git a/drivers/ieee1394/dv1394.c b/drivers/ieee1394/dv1394.c
index 9d19aec5820a..b6eb2cf25914 100644
--- a/drivers/ieee1394/dv1394.c
+++ b/drivers/ieee1394/dv1394.c
@@ -2296,9 +2296,10 @@ static void dv1394_add_host(struct hpsb_host *host)
 
         ohci = (struct ti_ohci *)host->hostdata;
 
-        device_create(hpsb_protocol_class, NULL, MKDEV(
-                IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_DV1394 * 16 + (id<<2)),
-                "dv1394-%d", id);
+        device_create_drvdata(hpsb_protocol_class, NULL,
+                              MKDEV(IEEE1394_MAJOR,
+                                    IEEE1394_MINOR_BLOCK_DV1394 * 16 + (id<<2)), NULL,
+                              "dv1394-%d", id);
 
         dv1394_init(ohci, DV1394_NTSC, MODE_RECEIVE);
         dv1394_init(ohci, DV1394_NTSC, MODE_TRANSMIT);
diff --git a/drivers/ieee1394/nodemgr.c b/drivers/ieee1394/nodemgr.c
index 05710c7c1220..994a21e5a0aa 100644
--- a/drivers/ieee1394/nodemgr.c
+++ b/drivers/ieee1394/nodemgr.c
@@ -754,7 +754,8 @@ static void nodemgr_remove_uds(struct node_entry *ne)
          */
         mutex_lock(&nodemgr_serialize_remove_uds);
         for (;;) {
-                dev = class_find_device(&nodemgr_ud_class, ne, __match_ne);
+                dev = class_find_device(&nodemgr_ud_class, NULL, ne,
+                                        __match_ne);
                 if (!dev)
                         break;
                 ud = container_of(dev, struct unit_directory, unit_dev);
@@ -901,7 +902,8 @@ static struct node_entry *find_entry_by_guid(u64 guid)
         struct device *dev;
         struct node_entry *ne;
 
-        dev = class_find_device(&nodemgr_ne_class, &guid, __match_ne_guid);
+        dev = class_find_device(&nodemgr_ne_class, NULL, &guid,
+                                __match_ne_guid);
         if (!dev)
                 return NULL;
         ne = container_of(dev, struct node_entry, node_dev);
@@ -940,7 +942,8 @@ static struct node_entry *find_entry_by_nodeid(struct hpsb_host *host,
         param.host = host;
         param.nodeid = nodeid;
 
-        dev = class_find_device(&nodemgr_ne_class, &param, __match_ne_nodeid);
+        dev = class_find_device(&nodemgr_ne_class, NULL, &param,
+                                __match_ne_nodeid);
         if (!dev)
                 return NULL;
         ne = container_of(dev, struct node_entry, node_dev);
@@ -1453,7 +1456,8 @@ static void nodemgr_suspend_ne(struct node_entry *ne)
         ne->in_limbo = 1;
         WARN_ON(device_create_file(&ne->device, &dev_attr_ne_in_limbo));
 
-        class_for_each_device(&nodemgr_ud_class, ne, __nodemgr_driver_suspend);
+        class_for_each_device(&nodemgr_ud_class, NULL, ne,
+                              __nodemgr_driver_suspend);
 }
 
 
@@ -1462,7 +1466,8 @@ static void nodemgr_resume_ne(struct node_entry *ne)
         ne->in_limbo = 0;
         device_remove_file(&ne->device, &dev_attr_ne_in_limbo);
 
-        class_for_each_device(&nodemgr_ud_class, ne, __nodemgr_driver_resume);
+        class_for_each_device(&nodemgr_ud_class, NULL, ne,
+                              __nodemgr_driver_resume);
         HPSB_DEBUG("Node resumed: ID:BUS[" NODE_BUS_FMT "]  GUID[%016Lx]",
                    NODE_BUS_ARGS(ne->host, ne->nodeid), (unsigned long long)ne->guid);
 }
@@ -1498,7 +1503,8 @@ static int __nodemgr_update_pdrv(struct device *dev, void *data)
 
 static void nodemgr_update_pdrv(struct node_entry *ne)
 {
-        class_for_each_device(&nodemgr_ud_class, ne, __nodemgr_update_pdrv);
+        class_for_each_device(&nodemgr_ud_class, NULL, ne,
+                              __nodemgr_update_pdrv);
 }
 
 
@@ -1591,7 +1597,8 @@ static void nodemgr_node_probe(struct host_info *hi, int generation)
          * while probes are time-consuming. (Well, those probes need some
          * improvement...) */
 
-        class_for_each_device(&nodemgr_ne_class, &param, __nodemgr_node_probe);
+        class_for_each_device(&nodemgr_ne_class, NULL, &param,
+                              __nodemgr_node_probe);
 
         /* If we had a bus reset while we were scanning the bus, it is
          * possible that we did not probe all nodes.  In that case, we
@@ -1826,7 +1833,7 @@ int nodemgr_for_each_host(void *data, int (*cb)(struct hpsb_host *, void *))
 
         hip.cb = cb;
         hip.data = data;
-        error = class_for_each_device(&hpsb_host_class, &hip,
+        error = class_for_each_device(&hpsb_host_class, NULL, &hip,
                                       __nodemgr_for_each_host);
 
         return error;
diff --git a/drivers/ieee1394/raw1394.c b/drivers/ieee1394/raw1394.c
index 96f2847b0405..6fa9e4a21840 100644
--- a/drivers/ieee1394/raw1394.c
+++ b/drivers/ieee1394/raw1394.c
@@ -3010,10 +3010,10 @@ static int __init init_raw1394(void)
         hpsb_register_highlevel(&raw1394_highlevel);
 
         if (IS_ERR
-            (device_create(
+            (device_create_drvdata(
               hpsb_protocol_class, NULL,
               MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16),
-              RAW1394_DEVICE_NAME))) {
+              NULL, RAW1394_DEVICE_NAME))) {
                 ret = -EFAULT;
                 goto out_unreg;
         }
diff --git a/drivers/ieee1394/video1394.c b/drivers/ieee1394/video1394.c
index 069b9f6bf16d..25db6e67fa4e 100644
--- a/drivers/ieee1394/video1394.c
+++ b/drivers/ieee1394/video1394.c
@@ -1341,9 +1341,9 @@ static void video1394_add_host (struct hpsb_host *host)
         hpsb_set_hostinfo_key(&video1394_highlevel, host, ohci->host->id);
 
         minor = IEEE1394_MINOR_BLOCK_VIDEO1394 * 16 + ohci->host->id;
-        device_create(hpsb_protocol_class, NULL,
-                      MKDEV(IEEE1394_MAJOR, minor),
-                      "%s-%d", VIDEO1394_DRIVER_NAME, ohci->host->id);
+        device_create_drvdata(hpsb_protocol_class, NULL,
+                              MKDEV(IEEE1394_MAJOR, minor), NULL,
+                              "%s-%d", VIDEO1394_DRIVER_NAME, ohci->host->id);
 }
 
 
diff --git a/drivers/infiniband/core/cm.c b/drivers/infiniband/core/cm.c
index 55738eead3bf..922d35f4fc08 100644
--- a/drivers/infiniband/core/cm.c
+++ b/drivers/infiniband/core/cm.c
@@ -44,6 +44,7 @@
 #include <linux/spinlock.h>
 #include <linux/sysfs.h>
 #include <linux/workqueue.h>
+#include <linux/kdev_t.h>
 
 #include <rdma/ib_cache.h>
 #include <rdma/ib_cm.h>
@@ -162,8 +163,8 @@ struct cm_port {
 
 struct cm_device {
         struct list_head list;
-        struct ib_device *device;
-        struct kobject dev_obj;
+        struct ib_device *ib_device;
+        struct device *device;
         u8 ack_delay;
         struct cm_port *port[0];
 };
@@ -339,7 +340,7 @@ static void cm_init_av_for_response(struct cm_port *port, struct ib_wc *wc,
 {
         av->port = port;
         av->pkey_index = wc->pkey_index;
-        ib_init_ah_from_wc(port->cm_dev->device, port->port_num, wc,
+        ib_init_ah_from_wc(port->cm_dev->ib_device, port->port_num, wc,
                            grh, &av->ah_attr);
 }
 
@@ -353,7 +354,7 @@ static int cm_init_av_by_path(struct ib_sa_path_rec *path, struct cm_av *av)
 
         read_lock_irqsave(&cm.device_lock, flags);
         list_for_each_entry(cm_dev, &cm.device_list, list) {
-                if (!ib_find_cached_gid(cm_dev->device, &path->sgid,
+                if (!ib_find_cached_gid(cm_dev->ib_device, &path->sgid,
                                         &p, NULL)) {
                         port = cm_dev->port[p-1];
                         break;
@@ -364,13 +365,13 @@ static int cm_init_av_by_path(struct ib_sa_path_rec *path, struct cm_av *av)
         if (!port)
                 return -EINVAL;
 
-        ret = ib_find_cached_pkey(cm_dev->device, port->port_num,
+        ret = ib_find_cached_pkey(cm_dev->ib_device, port->port_num,
                                   be16_to_cpu(path->pkey), &av->pkey_index);
         if (ret)
                 return ret;
 
         av->port = port;
-        ib_init_ah_from_path(cm_dev->device, port->port_num, path,
+        ib_init_ah_from_path(cm_dev->ib_device, port->port_num, path,
                              &av->ah_attr);
         av->timeout = path->packet_life_time + 1;
         return 0;
@@ -1515,7 +1516,7 @@ static int cm_req_handler(struct cm_work *work)
 
         req_msg = (struct cm_req_msg *)work->mad_recv_wc->recv_buf.mad;
 
-        cm_id = ib_create_cm_id(work->port->cm_dev->device, NULL, NULL);
+        cm_id = ib_create_cm_id(work->port->cm_dev->ib_device, NULL, NULL);
         if (IS_ERR(cm_id))
                 return PTR_ERR(cm_id);
 
@@ -1550,7 +1551,7 @@ static int cm_req_handler(struct cm_work *work)
         cm_format_paths_from_req(req_msg, &work->path[0], &work->path[1]);
         ret = cm_init_av_by_path(&work->path[0], &cm_id_priv->av);
         if (ret) {
-                ib_get_cached_gid(work->port->cm_dev->device,
+                ib_get_cached_gid(work->port->cm_dev->ib_device,
                                   work->port->port_num, 0, &work->path[0].sgid);
                 ib_send_cm_rej(cm_id, IB_CM_REJ_INVALID_GID,
                                &work->path[0].sgid, sizeof work->path[0].sgid,
@@ -2950,7 +2951,7 @@ static int cm_sidr_req_handler(struct cm_work *work)
         struct cm_sidr_req_msg *sidr_req_msg;
         struct ib_wc *wc;
 
-        cm_id = ib_create_cm_id(work->port->cm_dev->device, NULL, NULL);
+        cm_id = ib_create_cm_id(work->port->cm_dev->ib_device, NULL, NULL);
         if (IS_ERR(cm_id))
                 return PTR_ERR(cm_id);
         cm_id_priv = container_of(cm_id, struct cm_id_private, id);
@@ -3578,7 +3579,7 @@ static void cm_get_ack_delay(struct cm_device *cm_dev)
 {
         struct ib_device_attr attr;
 
-        if (ib_query_device(cm_dev->device, &attr))
+        if (ib_query_device(cm_dev->ib_device, &attr))
                 cm_dev->ack_delay = 0; /* acks will rely on packet life time */
         else
                 cm_dev->ack_delay = attr.local_ca_ack_delay;
@@ -3618,18 +3619,6 @@ static struct kobj_type cm_port_obj_type = {
         .release = cm_release_port_obj
 };
 
-static void cm_release_dev_obj(struct kobject *obj)
-{
-        struct cm_device *cm_dev;
-
-        cm_dev = container_of(obj, struct cm_device, dev_obj);
-        kfree(cm_dev);
-}
-
-static struct kobj_type cm_dev_obj_type = {
-        .release = cm_release_dev_obj
-};
-
 struct class cm_class = {
         .name    = "infiniband_cm",
 };
@@ -3640,7 +3629,7 @@ static int cm_create_port_fs(struct cm_port *port)
         int i, ret;
 
         ret = kobject_init_and_add(&port->port_obj, &cm_port_obj_type,
-                                   &port->cm_dev->dev_obj,
+                                   &port->cm_dev->device->kobj,
                                    "%d", port->port_num);
         if (ret) {
                 kfree(port);
@@ -3676,7 +3665,7 @@ static void cm_remove_port_fs(struct cm_port *port)
         kobject_put(&port->port_obj);
 }
 
-static void cm_add_one(struct ib_device *device)
+static void cm_add_one(struct ib_device *ib_device)
 {
         struct cm_device *cm_dev;
         struct cm_port *port;
@@ -3691,26 +3680,27 @@ static void cm_add_one(struct ib_device *device)
         int ret;
         u8 i;
 
-        if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
+        if (rdma_node_get_transport(ib_device->node_type) != RDMA_TRANSPORT_IB)
                 return;
 
         cm_dev = kzalloc(sizeof(*cm_dev) + sizeof(*port) *
-                         device->phys_port_cnt, GFP_KERNEL);
+                         ib_device->phys_port_cnt, GFP_KERNEL);
         if (!cm_dev)
                 return;
 
-        cm_dev->device = device;
+        cm_dev->ib_device = ib_device;
         cm_get_ack_delay(cm_dev);
 
-        ret = kobject_init_and_add(&cm_dev->dev_obj, &cm_dev_obj_type,
-                                   &cm_class.subsys.kobj, "%s", device->name);
-        if (ret) {
+        cm_dev->device = device_create_drvdata(&cm_class, &ib_device->dev,
+                                               MKDEV(0, 0), NULL,
+                                               "%s", ib_device->name);
+        if (!cm_dev->device) {
                 kfree(cm_dev);
                 return;
         }
 
         set_bit(IB_MGMT_METHOD_SEND, reg_req.method_mask);
-        for (i = 1; i <= device->phys_port_cnt; i++) {
+        for (i = 1; i <= ib_device->phys_port_cnt; i++) {
                 port = kzalloc(sizeof *port, GFP_KERNEL);
                 if (!port)
                         goto error1;
@@ -3723,7 +3713,7 @@ static void cm_add_one(struct ib_device *device)
                 if (ret)
                         goto error1;
 
-                port->mad_agent = ib_register_mad_agent(device, i,
+                port->mad_agent = ib_register_mad_agent(ib_device, i,
                                                         IB_QPT_GSI,
                                                         &reg_req,
                                                         0,
@@ -3733,11 +3723,11 @@ static void cm_add_one(struct ib_device *device)
                 if (IS_ERR(port->mad_agent))
                         goto error2;
 
-                ret = ib_modify_port(device, i, 0, &port_modify);
+                ret = ib_modify_port(ib_device, i, 0, &port_modify);
                 if (ret)
                         goto error3;
         }
-        ib_set_client_data(device, &cm_client, cm_dev);
+        ib_set_client_data(ib_device, &cm_client, cm_dev);
 
         write_lock_irqsave(&cm.device_lock, flags);
         list_add_tail(&cm_dev->list, &cm.device_list);
@@ -3753,14 +3743,14 @@ error1:
         port_modify.clr_port_cap_mask = IB_PORT_CM_SUP;
         while (--i) {
                 port = cm_dev->port[i-1];
-                ib_modify_port(device, port->port_num, 0, &port_modify);
+                ib_modify_port(ib_device, port->port_num, 0, &port_modify);
                 ib_unregister_mad_agent(port->mad_agent);
                 cm_remove_port_fs(port);
         }
-        kobject_put(&cm_dev->dev_obj);
+        device_unregister(cm_dev->device);
 }
 
-static void cm_remove_one(struct ib_device *device)
+static void cm_remove_one(struct ib_device *ib_device)
 {
         struct cm_device *cm_dev;
         struct cm_port *port;
@@ -3770,7 +3760,7 @@ static void cm_remove_one(struct ib_device *device)
         unsigned long flags;
         int i;
 
-        cm_dev = ib_get_client_data(device, &cm_client);
+        cm_dev = ib_get_client_data(ib_device, &cm_client);
         if (!cm_dev)
                 return;
 
@@ -3778,14 +3768,14 @@ static void cm_remove_one(struct ib_device *device)
         list_del(&cm_dev->list);
         write_unlock_irqrestore(&cm.device_lock, flags);
 
-        for (i = 1; i <= device->phys_port_cnt; i++) {
+        for (i = 1; i <= ib_device->phys_port_cnt; i++) {
                 port = cm_dev->port[i-1];
-                ib_modify_port(device, port->port_num, 0, &port_modify);
+                ib_modify_port(ib_device, port->port_num, 0, &port_modify);
                 ib_unregister_mad_agent(port->mad_agent);
                 flush_workqueue(cm.wq);
                 cm_remove_port_fs(port);
         }
-        kobject_put(&cm_dev->dev_obj);
+        device_unregister(cm_dev->device);
 }
 
 static int __init ib_cm_init(void)
diff --git a/drivers/infiniband/hw/ipath/ipath_file_ops.c b/drivers/infiniband/hw/ipath/ipath_file_ops.c
index 35f301c88b57..56c0eda3c077 100644
--- a/drivers/infiniband/hw/ipath/ipath_file_ops.c
+++ b/drivers/infiniband/hw/ipath/ipath_file_ops.c
@@ -2455,7 +2455,7 @@ static int init_cdev(int minor, char *name, const struct file_operations *fops,
                 goto err_cdev;
         }
 
-        device = device_create(ipath_class, NULL, dev, name);
+        device = device_create_drvdata(ipath_class, NULL, dev, NULL, name);
 
         if (IS_ERR(device)) {
                 ret = PTR_ERR(device);
diff --git a/drivers/isdn/capi/capi.c b/drivers/isdn/capi/capi.c
index 19e005e81fef..871b0cbca5e4 100644
--- a/drivers/isdn/capi/capi.c
+++ b/drivers/isdn/capi/capi.c
@@ -1553,7 +1553,8 @@ static int __init capi_init(void)
                 return PTR_ERR(capi_class);
         }
 
-        device_create(capi_class, NULL, MKDEV(capi_major, 0), "capi");
+        device_create_drvdata(capi_class, NULL, MKDEV(capi_major, 0), NULL,
+                              "capi");
 
 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
         if (capinc_tty_init() < 0) {
diff --git a/drivers/macintosh/adb.c b/drivers/macintosh/adb.c
index e5d446804d32..cae52485208a 100644
--- a/drivers/macintosh/adb.c
+++ b/drivers/macintosh/adb.c
@@ -862,7 +862,8 @@ adbdev_init(void)
         adb_dev_class = class_create(THIS_MODULE, "adb");
         if (IS_ERR(adb_dev_class))
                 return;
-        device_create(adb_dev_class, NULL, MKDEV(ADB_MAJOR, 0), "adb");
+        device_create_drvdata(adb_dev_class, NULL, MKDEV(ADB_MAJOR, 0), NULL,
+                              "adb");
 
         platform_device_register(&adb_pfdev);
         platform_driver_probe(&adb_pfdrv, adb_dummy_probe);
diff --git a/drivers/mca/mca-bus.c b/drivers/mca/mca-bus.c
index 67b8e9453b19..ef2dbfe74714 100644
--- a/drivers/mca/mca-bus.c
+++ b/drivers/mca/mca-bus.c
@@ -40,7 +40,7 @@ static struct mca_bus *mca_root_busses[MAX_MCA_BUSSES];
 
 struct mca_device_info {
         short pos_id;           /* the 2 byte pos id for this card */
-        char name[DEVICE_NAME_SIZE];
+        char name[50];
 };
 
 static int mca_bus_match (struct device *dev, struct device_driver *drv)
diff --git a/drivers/media/dvb/dvb-core/dvbdev.c b/drivers/media/dvb/dvb-core/dvbdev.c
index e208a60c048a..e7132770a3bf 100644
--- a/drivers/media/dvb/dvb-core/dvbdev.c
+++ b/drivers/media/dvb/dvb-core/dvbdev.c
@@ -233,9 +233,9 @@ int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
 
         mutex_unlock(&dvbdev_register_lock);
 
-        clsdev = device_create(dvb_class, adap->device,
+        clsdev = device_create_drvdata(dvb_class, adap->device,
                                MKDEV(DVB_MAJOR, nums2minor(adap->num, type, id)),
-                               "dvb%d.%s%d", adap->num, dnames[type], id);
+                               NULL, "dvb%d.%s%d", adap->num, dnames[type], id);
         if (IS_ERR(clsdev)) {
                 printk(KERN_ERR "%s: failed to create device dvb%d.%s%d (%ld)\n",
                        __func__, adap->num, dnames[type], id, PTR_ERR(clsdev));
diff --git a/drivers/memstick/host/jmb38x_ms.c b/drivers/memstick/host/jmb38x_ms.c
index a054668eda16..4e3bfbcdf155 100644
--- a/drivers/memstick/host/jmb38x_ms.c
+++ b/drivers/memstick/host/jmb38x_ms.c
@@ -51,7 +51,7 @@ struct jmb38x_ms_host {
         void __iomem            *addr;
         spinlock_t              lock;
         int                     id;
-        char                    host_id[DEVICE_ID_SIZE];
+        char                    host_id[32];
         int                     irq;
         unsigned int            block_pos;
         unsigned long           timeout_jiffies;
@@ -781,7 +781,7 @@ static struct memstick_host *jmb38x_ms_alloc_host(struct jmb38x_ms *jm, int cnt)
 
         spin_lock_init(&host->lock);
         host->id = cnt;
-        snprintf(host->host_id, DEVICE_ID_SIZE, DRIVER_NAME ":slot%d",
+        snprintf(host->host_id, sizeof(host->host_id), DRIVER_NAME ":slot%d",
                  host->id);
         host->irq = jm->pdev->irq;
         host->timeout_jiffies = msecs_to_jiffies(1000);
diff --git a/drivers/message/fusion/mptbase.c b/drivers/message/fusion/mptbase.c
index 75e599b85b64..34402c47027e 100644
--- a/drivers/message/fusion/mptbase.c
+++ b/drivers/message/fusion/mptbase.c
@@ -1670,7 +1670,8 @@ mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id)
         INIT_DELAYED_WORK(&ioc->fault_reset_work, mpt_fault_reset_work);
         spin_lock_init(&ioc->fault_reset_work_lock);
 
-        snprintf(ioc->reset_work_q_name, KOBJ_NAME_LEN, "mpt_poll_%d", ioc->id);
+        snprintf(ioc->reset_work_q_name, sizeof(ioc->reset_work_q_name),
+                 "mpt_poll_%d", ioc->id);
         ioc->reset_work_q =
                 create_singlethread_workqueue(ioc->reset_work_q_name);
         if (!ioc->reset_work_q) {
diff --git a/drivers/message/fusion/mptbase.h b/drivers/message/fusion/mptbase.h
index 6adab648dbb9..dff048cfa101 100644
--- a/drivers/message/fusion/mptbase.h
+++ b/drivers/message/fusion/mptbase.h
@@ -707,12 +707,12 @@ typedef struct _MPT_ADAPTER
         u8                       fc_link_speed[2];
         spinlock_t               fc_rescan_work_lock;
         struct work_struct       fc_rescan_work;
-        char                     fc_rescan_work_q_name[KOBJ_NAME_LEN];
+        char                     fc_rescan_work_q_name[20];
         struct workqueue_struct *fc_rescan_work_q;
         struct scsi_cmnd        **ScsiLookup;
         spinlock_t                scsi_lookup_lock;
 
-        char                     reset_work_q_name[KOBJ_NAME_LEN];
+        char                     reset_work_q_name[20];
         struct workqueue_struct *reset_work_q;
         struct delayed_work      fault_reset_work;
         spinlock_t               fault_reset_work_lock;
diff --git a/drivers/message/fusion/mptfc.c b/drivers/message/fusion/mptfc.c
index fc31ca6829d8..b36cae9ec6db 100644
--- a/drivers/message/fusion/mptfc.c
+++ b/drivers/message/fusion/mptfc.c
@@ -1326,8 +1326,8 @@ mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 
         /* initialize workqueue */
 
-        snprintf(ioc->fc_rescan_work_q_name, KOBJ_NAME_LEN, "mptfc_wq_%d",
-                sh->host_no);
+        snprintf(ioc->fc_rescan_work_q_name, sizeof(ioc->fc_rescan_work_q_name),
+                 "mptfc_wq_%d", sh->host_no);
         ioc->fc_rescan_work_q =
                 create_singlethread_workqueue(ioc->fc_rescan_work_q_name);
         if (!ioc->fc_rescan_work_q)
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 1921b8dbb242..ce67d973d349 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -420,4 +420,17 @@ config SGI_XP
           this feature will allow for direct communication between SSIs
           based on a network adapter and DMA messaging.
 
+config HP_ILO
+        tristate "Channel interface driver for HP iLO/iLO2 processor"
+        default n
+        help
+          The channel interface driver allows applications to communicate
+          with iLO/iLO2 management processors present on HP ProLiant
+          servers.  Upon loading, the driver creates /dev/hpilo/dXccbN files,
+          which can be used to gather data from the management processor,
+          via read and write system calls.
+
+          To compile this driver as a module, choose M here: the
+          module will be called hpilo.
+
 endif # MISC_DEVICES
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index a6dac6a2e7e5..688fe76135e0 100644
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -27,3 +27,4 @@ obj-$(CONFIG_INTEL_MENLOW)	+= intel_menlow.o
 obj-$(CONFIG_ENCLOSURE_SERVICES) += enclosure.o
 obj-$(CONFIG_KGDB_TESTS)        += kgdbts.o
 obj-$(CONFIG_SGI_XP)            += sgi-xp/
+obj-$(CONFIG_HP_ILO)            += hpilo.o
diff --git a/drivers/misc/hpilo.c b/drivers/misc/hpilo.c
new file mode 100644
index 000000000000..05e298289238
--- /dev/null
+++ b/drivers/misc/hpilo.c
@@ -0,0 +1,768 @@
+/*
+ * Driver for HP iLO/iLO2 management processor.
+ *
+ * Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
+ *      David Altobelli <david.altobelli@hp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/pci.h>
+#include <linux/ioport.h>
+#include <linux/device.h>
+#include <linux/file.h>
+#include <linux/cdev.h>
+#include <linux/spinlock.h>
+#include <linux/delay.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
+#include "hpilo.h"
+
+static struct class *ilo_class;
+static unsigned int ilo_major;
+static char ilo_hwdev[MAX_ILO_DEV];
+
+static inline int get_entry_id(int entry)
+{
+        return (entry & ENTRY_MASK_DESCRIPTOR) >> ENTRY_BITPOS_DESCRIPTOR;
+}
+
+static inline int get_entry_len(int entry)
+{
+        return ((entry & ENTRY_MASK_QWORDS) >> ENTRY_BITPOS_QWORDS) << 3;
+}
+
+static inline int mk_entry(int id, int len)
+{
+        int qlen = len & 7 ? (len >> 3) + 1 : len >> 3;
+        return id << ENTRY_BITPOS_DESCRIPTOR | qlen << ENTRY_BITPOS_QWORDS;
+}
+
+static inline int desc_mem_sz(int nr_entry)
+{
+        return nr_entry << L2_QENTRY_SZ;
+}
+
+/*
+ * FIFO queues, shared with hardware.
+ *
+ * If a queue has empty slots, an entry is added to the queue tail,
+ * and that entry is marked as occupied.
+ * Entries can be dequeued from the head of the list, when the device
+ * has marked the entry as consumed.
+ *
+ * Returns true on successful queue/dequeue, false on failure.
+ */
+static int fifo_enqueue(struct ilo_hwinfo *hw, char *fifobar, int entry)
+{
+        struct fifo *fifo_q = FIFOBARTOHANDLE(fifobar);
+        int ret = 0;
+
+        spin_lock(&hw->fifo_lock);
+        if (!(fifo_q->fifobar[(fifo_q->tail + 1) & fifo_q->imask]
+              & ENTRY_MASK_O)) {
+                fifo_q->fifobar[fifo_q->tail & fifo_q->imask] |=
+                                (entry & ENTRY_MASK_NOSTATE) | fifo_q->merge;
+                fifo_q->tail += 1;
+                ret = 1;
+        }
+        spin_unlock(&hw->fifo_lock);
+
+        return ret;
+}
+
+static int fifo_dequeue(struct ilo_hwinfo *hw, char *fifobar, int *entry)
+{
+        struct fifo *fifo_q = FIFOBARTOHANDLE(fifobar);
+        int ret = 0;
+        u64 c;
+
+        spin_lock(&hw->fifo_lock);
+        c = fifo_q->fifobar[fifo_q->head & fifo_q->imask];
+        if (c & ENTRY_MASK_C) {
+                if (entry)
+                        *entry = c & ENTRY_MASK_NOSTATE;
+
+                fifo_q->fifobar[fifo_q->head & fifo_q->imask] =
+                                                        (c | ENTRY_MASK) + 1;
+                fifo_q->head += 1;
+                ret = 1;
+        }
+        spin_unlock(&hw->fifo_lock);
+
+        return ret;
+}
+
+static int ilo_pkt_enqueue(struct ilo_hwinfo *hw, struct ccb *ccb,
+                           int dir, int id, int len)
+{
+        char *fifobar;
+        int entry;
+
+        if (dir == SENDQ)
+                fifobar = ccb->ccb_u1.send_fifobar;
+        else
+                fifobar = ccb->ccb_u3.recv_fifobar;
+
+        entry = mk_entry(id, len);
+        return fifo_enqueue(hw, fifobar, entry);
+}
+
+static int ilo_pkt_dequeue(struct ilo_hwinfo *hw, struct ccb *ccb,
+                           int dir, int *id, int *len, void **pkt)
+{
+        char *fifobar, *desc;
+        int entry = 0, pkt_id = 0;
+        int ret;
+
+        if (dir == SENDQ) {
+                fifobar = ccb->ccb_u1.send_fifobar;
+                desc = ccb->ccb_u2.send_desc;
+        } else {
+                fifobar = ccb->ccb_u3.recv_fifobar;
+                desc = ccb->ccb_u4.recv_desc;
+        }
+
+        ret = fifo_dequeue(hw, fifobar, &entry);
+        if (ret) {
+                pkt_id = get_entry_id(entry);
+                if (id)
+                        *id = pkt_id;
+                if (len)
+                        *len = get_entry_len(entry);
+                if (pkt)
+                        *pkt = (void *)(desc + desc_mem_sz(pkt_id));
+        }
+
+        return ret;
+}
+
+static inline void doorbell_set(struct ccb *ccb)
+{
+        iowrite8(1, ccb->ccb_u5.db_base);
+}
+
+static inline void doorbell_clr(struct ccb *ccb)
+{
+        iowrite8(2, ccb->ccb_u5.db_base);
+}
+static inline int ctrl_set(int l2sz, int idxmask, int desclim)
+{
+        int active = 0, go = 1;
+        return l2sz << CTRL_BITPOS_L2SZ |
+               idxmask << CTRL_BITPOS_FIFOINDEXMASK |
+               desclim << CTRL_BITPOS_DESCLIMIT |
+               active << CTRL_BITPOS_A |
+               go << CTRL_BITPOS_G;
+}
+static void ctrl_setup(struct ccb *ccb, int nr_desc, int l2desc_sz)
+{
+        /* for simplicity, use the same parameters for send and recv ctrls */
+        ccb->send_ctrl = ctrl_set(l2desc_sz, nr_desc-1, nr_desc-1);
+        ccb->recv_ctrl = ctrl_set(l2desc_sz, nr_desc-1, nr_desc-1);
+}
+
+static inline int fifo_sz(int nr_entry)
+{
+        /* size of a fifo is determined by the number of entries it contains */
+        return (nr_entry * sizeof(u64)) + FIFOHANDLESIZE;
+}
+
+static void fifo_setup(void *base_addr, int nr_entry)
+{
+        struct fifo *fifo_q = base_addr;
+        int i;
+
+        /* set up an empty fifo */
+        fifo_q->head = 0;
+        fifo_q->tail = 0;
+        fifo_q->reset = 0;
+        fifo_q->nrents = nr_entry;
+        fifo_q->imask = nr_entry - 1;
+        fifo_q->merge = ENTRY_MASK_O;
+
+        for (i = 0; i < nr_entry; i++)
+                fifo_q->fifobar[i] = 0;
+}
+
+static void ilo_ccb_close(struct pci_dev *pdev, struct ccb_data *data)
+{
+        struct ccb *driver_ccb;
+        struct ccb __iomem *device_ccb;
+        int retries;
+
+        driver_ccb = &data->driver_ccb;
+        device_ccb = data->mapped_ccb;
+
+        /* complicated dance to tell the hw we are stopping */
+        doorbell_clr(driver_ccb);
+        iowrite32(ioread32(&device_ccb->send_ctrl) & ~(1 << CTRL_BITPOS_G),
+                  &device_ccb->send_ctrl);
+        iowrite32(ioread32(&device_ccb->recv_ctrl) & ~(1 << CTRL_BITPOS_G),
+                  &device_ccb->recv_ctrl);
+
+        /* give iLO some time to process stop request */
+        for (retries = 1000; retries > 0; retries--) {
+                doorbell_set(driver_ccb);
+                udelay(1);
+                if (!(ioread32(&device_ccb->send_ctrl) & (1 << CTRL_BITPOS_A))
+                    &&
+                    !(ioread32(&device_ccb->recv_ctrl) & (1 << CTRL_BITPOS_A)))
+                        break;
+        }
+        if (retries == 0)
+                dev_err(&pdev->dev, "Closing, but controller still active\n");
+
+        /* clear the hw ccb */
+        memset_io(device_ccb, 0, sizeof(struct ccb));
+
+        /* free resources used to back send/recv queues */
+        pci_free_consistent(pdev, data->dma_size, data->dma_va, data->dma_pa);
+}
+
+static int ilo_ccb_open(struct ilo_hwinfo *hw, struct ccb_data *data, int slot)
+{
+        char *dma_va, *dma_pa;
+        int pkt_id, pkt_sz, i, error;
+        struct ccb *driver_ccb, *ilo_ccb;
+        struct pci_dev *pdev;
+
+        driver_ccb = &data->driver_ccb;
+        ilo_ccb = &data->ilo_ccb;
+        pdev = hw->ilo_dev;
+
+        data->dma_size = 2 * fifo_sz(NR_QENTRY) +
+                         2 * desc_mem_sz(NR_QENTRY) +
+                         ILO_START_ALIGN + ILO_CACHE_SZ;
+
+        error = -ENOMEM;
+        data->dma_va = pci_alloc_consistent(pdev, data->dma_size,
+                                            &data->dma_pa);
+        if (!data->dma_va)
+                goto out;
+
+        dma_va = (char *)data->dma_va;
+        dma_pa = (char *)data->dma_pa;
+
+        memset(dma_va, 0, data->dma_size);
+
+        dma_va = (char *)roundup((unsigned long)dma_va, ILO_START_ALIGN);
+        dma_pa = (char *)roundup((unsigned long)dma_pa, ILO_START_ALIGN);
+
+        /*
+         * Create two ccb's, one with virt addrs, one with phys addrs.
+         * Copy the phys addr ccb to device shared mem.
+         */
+        ctrl_setup(driver_ccb, NR_QENTRY, L2_QENTRY_SZ);
+        ctrl_setup(ilo_ccb, NR_QENTRY, L2_QENTRY_SZ);
+
+        fifo_setup(dma_va, NR_QENTRY);
+        driver_ccb->ccb_u1.send_fifobar = dma_va + FIFOHANDLESIZE;
+        ilo_ccb->ccb_u1.send_fifobar = dma_pa + FIFOHANDLESIZE;
+        dma_va += fifo_sz(NR_QENTRY);
+        dma_pa += fifo_sz(NR_QENTRY);
+
+        dma_va = (char *)roundup((unsigned long)dma_va, ILO_CACHE_SZ);
+        dma_pa = (char *)roundup((unsigned long)dma_pa, ILO_CACHE_SZ);
+
+        fifo_setup(dma_va, NR_QENTRY);
+        driver_ccb->ccb_u3.recv_fifobar = dma_va + FIFOHANDLESIZE;
+        ilo_ccb->ccb_u3.recv_fifobar = dma_pa + FIFOHANDLESIZE;
+        dma_va += fifo_sz(NR_QENTRY);
+        dma_pa += fifo_sz(NR_QENTRY);
+
+        driver_ccb->ccb_u2.send_desc = dma_va;
+        ilo_ccb->ccb_u2.send_desc = dma_pa;
+        dma_pa += desc_mem_sz(NR_QENTRY);
+        dma_va += desc_mem_sz(NR_QENTRY);
+
+        driver_ccb->ccb_u4.recv_desc = dma_va;
+        ilo_ccb->ccb_u4.recv_desc = dma_pa;
+
+        driver_ccb->channel = slot;
+        ilo_ccb->channel = slot;
+
+        driver_ccb->ccb_u5.db_base = hw->db_vaddr + (slot << L2_DB_SIZE);
+        ilo_ccb->ccb_u5.db_base = NULL; /* hw ccb's doorbell is not used */
+
+        /* copy the ccb with physical addrs to device memory */
+        data->mapped_ccb = (struct ccb __iomem *)
+                                (hw->ram_vaddr + (slot * ILOHW_CCB_SZ));
+        memcpy_toio(data->mapped_ccb, ilo_ccb, sizeof(struct ccb));
+
+        /* put packets on the send and receive queues */
+        pkt_sz = 0;
+        for (pkt_id = 0; pkt_id < NR_QENTRY; pkt_id++) {
+                ilo_pkt_enqueue(hw, driver_ccb, SENDQ, pkt_id, pkt_sz);
+                doorbell_set(driver_ccb);
+        }
+
+        pkt_sz = desc_mem_sz(1);
+        for (pkt_id = 0; pkt_id < NR_QENTRY; pkt_id++)
+                ilo_pkt_enqueue(hw, driver_ccb, RECVQ, pkt_id, pkt_sz);
+
+        doorbell_clr(driver_ccb);
+
+        /* make sure iLO is really handling requests */
+        for (i = 1000; i > 0; i--) {
+                if (ilo_pkt_dequeue(hw, driver_ccb, SENDQ, &pkt_id, NULL, NULL))
+                        break;
+                udelay(1);
+        }
+
+        if (i) {
+                ilo_pkt_enqueue(hw, driver_ccb, SENDQ, pkt_id, 0);
+                doorbell_set(driver_ccb);
+        } else {
+                dev_err(&pdev->dev, "Open could not dequeue a packet\n");
+                error = -EBUSY;
+                goto free;
+        }
+
+        return 0;
+free:
+        pci_free_consistent(pdev, data->dma_size, data->dma_va, data->dma_pa);
+out:
+        return error;
+}
+
+static inline int is_channel_reset(struct ccb *ccb)
+{
+        /* check for this particular channel needing a reset */
+        return FIFOBARTOHANDLE(ccb->ccb_u1.send_fifobar)->reset;
+}
+
+static inline void set_channel_reset(struct ccb *ccb)
+{
+        /* set a flag indicating this channel needs a reset */
+        FIFOBARTOHANDLE(ccb->ccb_u1.send_fifobar)->reset = 1;
+}
+
+static inline int is_device_reset(struct ilo_hwinfo *hw)
+{
+        /* check for global reset condition */
+        return ioread32(&hw->mmio_vaddr[DB_OUT]) & (1 << DB_RESET);
+}
+
+static inline void clear_device(struct ilo_hwinfo *hw)
+{
+        /* clear the device (reset bits, pending channel entries) */
+        iowrite32(-1, &hw->mmio_vaddr[DB_OUT]);
+}
+
+static void ilo_locked_reset(struct ilo_hwinfo *hw)
+{
+        int slot;
+
+        /*
+         * Mapped memory is zeroed on ilo reset, so set a per ccb flag
+         * to indicate that this ccb needs to be closed and reopened.
+         */
+        for (slot = 0; slot < MAX_CCB; slot++) {
+                if (!hw->ccb_alloc[slot])
+                        continue;
+                set_channel_reset(&hw->ccb_alloc[slot]->driver_ccb);
+        }
+
+        clear_device(hw);
+}
+
+static void ilo_reset(struct ilo_hwinfo *hw)
+{
+        spin_lock(&hw->alloc_lock);
+
+        /* reset might have been handled after lock was taken */
+        if (is_device_reset(hw))
+                ilo_locked_reset(hw);
+
+        spin_unlock(&hw->alloc_lock);
+}
+
+static ssize_t ilo_read(struct file *fp, char __user *buf,
+                        size_t len, loff_t *off)
+{
+        int err, found, cnt, pkt_id, pkt_len;
+        struct ccb_data *data;
+        struct ccb *driver_ccb;
+        struct ilo_hwinfo *hw;
+        void *pkt;
+
+        data = fp->private_data;
+        driver_ccb = &data->driver_ccb;
+        hw = data->ilo_hw;
+
+        if (is_device_reset(hw) || is_channel_reset(driver_ccb)) {
+                /*
+                 * If the device has been reset, applications
+                 * need to close and reopen all ccbs.
+                 */
+                ilo_reset(hw);
+                return -ENODEV;
+        }
+
+        /*
+         * This function is to be called when data is expected
+         * in the channel, and will return an error if no packet is found
+         * during the loop below.  The sleep/retry logic is to allow
+         * applications to call read() immediately post write(),
+         * and give iLO some time to process the sent packet.
+         */
+        cnt = 20;
+        do {
+                /* look for a received packet */
+                found = ilo_pkt_dequeue(hw, driver_ccb, RECVQ, &pkt_id,
+                                        &pkt_len, &pkt);
+                if (found)
+                        break;
+                cnt--;
+                msleep(100);
+        } while (!found && cnt);
+
+        if (!found)
+                return -EAGAIN;
+
+        /* only copy the length of the received packet */
+        if (pkt_len < len)
+                len = pkt_len;
+
+        err = copy_to_user(buf, pkt, len);
+
+        /* return the received packet to the queue */
+        ilo_pkt_enqueue(hw, driver_ccb, RECVQ, pkt_id, desc_mem_sz(1));
+
+        return err ? -EFAULT : len;
+}
+
+static ssize_t ilo_write(struct file *fp, const char __user *buf,
+                         size_t len, loff_t *off)
+{
+        int err, pkt_id, pkt_len;
+        struct ccb_data *data;
+        struct ccb *driver_ccb;
+        struct ilo_hwinfo *hw;
+        void *pkt;
+
+        data = fp->private_data;
+        driver_ccb = &data->driver_ccb;
+        hw = data->ilo_hw;
+
+        if (is_device_reset(hw) || is_channel_reset(driver_ccb)) {
+                /*
+                 * If the device has been reset, applications
+                 * need to close and reopen all ccbs.
+                 */
+                ilo_reset(hw);
+                return -ENODEV;
+        }
+
+        /* get a packet to send the user command */
+        if (!ilo_pkt_dequeue(hw, driver_ccb, SENDQ, &pkt_id, &pkt_len, &pkt))
+                return -EBUSY;
+
+        /* limit the length to the length of the packet */
+        if (pkt_len < len)
+                len = pkt_len;
+
+        /* on failure, set the len to 0 to return empty packet to the device */
+        err = copy_from_user(pkt, buf, len);
+        if (err)
+                len = 0;
+
+        /* send the packet */
+        ilo_pkt_enqueue(hw, driver_ccb, SENDQ, pkt_id, len);
+        doorbell_set(driver_ccb);
+
+        return err ? -EFAULT : len;
+}
+
+static int ilo_close(struct inode *ip, struct file *fp)
+{
+        int slot;
+        struct ccb_data *data;
+        struct ilo_hwinfo *hw;
+
+        slot = iminor(ip) % MAX_CCB;
+        hw = container_of(ip->i_cdev, struct ilo_hwinfo, cdev);
+
+        spin_lock(&hw->alloc_lock);
+
+        if (is_device_reset(hw))
+                ilo_locked_reset(hw);
+
+        if (hw->ccb_alloc[slot]->ccb_cnt == 1) {
+
+                data = fp->private_data;
+
+                ilo_ccb_close(hw->ilo_dev, data);
+
+                kfree(data);
+                hw->ccb_alloc[slot] = NULL;
+        } else
+                hw->ccb_alloc[slot]->ccb_cnt--;
+
+        spin_unlock(&hw->alloc_lock);
+
+        return 0;
+}
+
+static int ilo_open(struct inode *ip, struct file *fp)
+{
+        int slot, error;
+        struct ccb_data *data;
+        struct ilo_hwinfo *hw;
+
+        slot = iminor(ip) % MAX_CCB;
+        hw = container_of(ip->i_cdev, struct ilo_hwinfo, cdev);
+
+        /* new ccb allocation */
+        data = kzalloc(sizeof(*data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        spin_lock(&hw->alloc_lock);
+
+        if (is_device_reset(hw))
+                ilo_locked_reset(hw);
+
+        /* each fd private_data holds sw/hw view of ccb */
+        if (hw->ccb_alloc[slot] == NULL) {
+                /* create a channel control block for this minor */
+                error = ilo_ccb_open(hw, data, slot);
+                if (!error) {
+                        hw->ccb_alloc[slot] = data;
+                        hw->ccb_alloc[slot]->ccb_cnt = 1;
+                        hw->ccb_alloc[slot]->ccb_excl = fp->f_flags & O_EXCL;
+                        hw->ccb_alloc[slot]->ilo_hw = hw;
+                } else
+                        kfree(data);
+        } else {
+                kfree(data);
+                if (fp->f_flags & O_EXCL || hw->ccb_alloc[slot]->ccb_excl) {
+                        /*
+                         * The channel exists, and either this open
+                         * or a previous open of this channel wants
+                         * exclusive access.
+                         */
+                        error = -EBUSY;
+                } else {
+                        hw->ccb_alloc[slot]->ccb_cnt++;
+                        error = 0;
+                }
+        }
+        spin_unlock(&hw->alloc_lock);
+
+        if (!error)
+                fp->private_data = hw->ccb_alloc[slot];
+
+        return error;
+}
+
+static const struct file_operations ilo_fops = {
+        .owner          = THIS_MODULE,
+        .read           = ilo_read,
+        .write          = ilo_write,
+        .open           = ilo_open,
+        .release        = ilo_close,
+};
+
+static void ilo_unmap_device(struct pci_dev *pdev, struct ilo_hwinfo *hw)
+{
+        pci_iounmap(pdev, hw->db_vaddr);
+        pci_iounmap(pdev, hw->ram_vaddr);
+        pci_iounmap(pdev, hw->mmio_vaddr);
+}
+
+static int __devinit ilo_map_device(struct pci_dev *pdev, struct ilo_hwinfo *hw)
+{
+        int error = -ENOMEM;
+
+        /* map the memory mapped i/o registers */
+        hw->mmio_vaddr = pci_iomap(pdev, 1, 0);
+        if (hw->mmio_vaddr == NULL) {
+                dev_err(&pdev->dev, "Error mapping mmio\n");
+                goto out;
+        }
+
+        /* map the adapter shared memory region */
+        hw->ram_vaddr = pci_iomap(pdev, 2, MAX_CCB * ILOHW_CCB_SZ);
+        if (hw->ram_vaddr == NULL) {
+                dev_err(&pdev->dev, "Error mapping shared mem\n");
+                goto mmio_free;
+        }
+
+        /* map the doorbell aperture */
+        hw->db_vaddr = pci_iomap(pdev, 3, MAX_CCB * ONE_DB_SIZE);
+        if (hw->db_vaddr == NULL) {
+                dev_err(&pdev->dev, "Error mapping doorbell\n");
+                goto ram_free;
+        }
+
+        return 0;
+ram_free:
+        pci_iounmap(pdev, hw->ram_vaddr);
+mmio_free:
+        pci_iounmap(pdev, hw->mmio_vaddr);
+out:
+        return error;
+}
+
+static void ilo_remove(struct pci_dev *pdev)
+{
+        int i, minor;
+        struct ilo_hwinfo *ilo_hw = pci_get_drvdata(pdev);
+
+        clear_device(ilo_hw);
+
+        minor = MINOR(ilo_hw->cdev.dev);
+        for (i = minor; i < minor + MAX_CCB; i++)
+                device_destroy(ilo_class, MKDEV(ilo_major, i));
+
+        cdev_del(&ilo_hw->cdev);
+        ilo_unmap_device(pdev, ilo_hw);
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+        kfree(ilo_hw);
+        ilo_hwdev[(minor / MAX_CCB)] = 0;
+}
+
+static int __devinit ilo_probe(struct pci_dev *pdev,
+                               const struct pci_device_id *ent)
+{
+        int devnum, minor, start, error;
+        struct ilo_hwinfo *ilo_hw;
+
+        /* find a free range for device files */
+        for (devnum = 0; devnum < MAX_ILO_DEV; devnum++) {
+                if (ilo_hwdev[devnum] == 0) {
+                        ilo_hwdev[devnum] = 1;
+                        break;
+                }
+        }
+
+        if (devnum == MAX_ILO_DEV) {
+                dev_err(&pdev->dev, "Error finding free device\n");
+                return -ENODEV;
+        }
+
+        /* track global allocations for this device */
+        error = -ENOMEM;
+        ilo_hw = kzalloc(sizeof(*ilo_hw), GFP_KERNEL);
+        if (!ilo_hw)
+                goto out;
+
+        ilo_hw->ilo_dev = pdev;
+        spin_lock_init(&ilo_hw->alloc_lock);
+        spin_lock_init(&ilo_hw->fifo_lock);
+
+        error = pci_enable_device(pdev);
+        if (error)
+                goto free;
+
+        pci_set_master(pdev);
+
+        error = pci_request_regions(pdev, ILO_NAME);
+        if (error)
+                goto disable;
+
+        error = ilo_map_device(pdev, ilo_hw);
+        if (error)
+                goto free_regions;
+
+        pci_set_drvdata(pdev, ilo_hw);
+        clear_device(ilo_hw);
+
+        cdev_init(&ilo_hw->cdev, &ilo_fops);
+        ilo_hw->cdev.owner = THIS_MODULE;
+        start = devnum * MAX_CCB;
+        error = cdev_add(&ilo_hw->cdev, MKDEV(ilo_major, start), MAX_CCB);
+        if (error) {
+                dev_err(&pdev->dev, "Could not add cdev\n");
+                goto unmap;
+        }
+
+        for (minor = 0 ; minor < MAX_CCB; minor++) {
+                struct device *dev;
+                dev = device_create(ilo_class, &pdev->dev,
+                                    MKDEV(ilo_major, minor), NULL,
+                                    "hpilo!d%dccb%d", devnum, minor);
+                if (IS_ERR(dev))
+                        dev_err(&pdev->dev, "Could not create files\n");
+        }
+
+        return 0;
+unmap:
+        ilo_unmap_device(pdev, ilo_hw);
+free_regions:
+        pci_release_regions(pdev);
+disable:
+        pci_disable_device(pdev);
+free:
+        kfree(ilo_hw);
+out:
+        ilo_hwdev[devnum] = 0;
+        return error;
+}
+
+static struct pci_device_id ilo_devices[] = {
+        { PCI_DEVICE(PCI_VENDOR_ID_COMPAQ, 0xB204) },
+        { }
+};
+MODULE_DEVICE_TABLE(pci, ilo_devices);
+
+static struct pci_driver ilo_driver = {
+        .name     = ILO_NAME,
+        .id_table = ilo_devices,
+        .probe    = ilo_probe,
+        .remove   = __devexit_p(ilo_remove),
+};
+
+static int __init ilo_init(void)
+{
+        int error;
+        dev_t dev;
+
+        ilo_class = class_create(THIS_MODULE, "iLO");
+        if (IS_ERR(ilo_class)) {
+                error = PTR_ERR(ilo_class);
+                goto out;
+        }
+
+        error = alloc_chrdev_region(&dev, 0, MAX_OPEN, ILO_NAME);
+        if (error)
+                goto class_destroy;
+
+        ilo_major = MAJOR(dev);
+
+        error = pci_register_driver(&ilo_driver);
+        if (error)
+                goto chr_remove;
+
+        return 0;
+chr_remove:
+        unregister_chrdev_region(dev, MAX_OPEN);
+class_destroy:
+        class_destroy(ilo_class);
+out:
+        return error;
+}
+
+static void __exit ilo_exit(void)
+{
+        pci_unregister_driver(&ilo_driver);
+        unregister_chrdev_region(MKDEV(ilo_major, 0), MAX_OPEN);
+        class_destroy(ilo_class);
+}
+
+MODULE_VERSION("0.05");
+MODULE_ALIAS(ILO_NAME);
+MODULE_DESCRIPTION(ILO_NAME);
+MODULE_AUTHOR("David Altobelli <david.altobelli@hp.com>");
+MODULE_LICENSE("GPL v2");
+
+module_init(ilo_init);
+module_exit(ilo_exit);
diff --git a/drivers/misc/hpilo.h b/drivers/misc/hpilo.h
new file mode 100644
index 000000000000..a281207696c1
--- /dev/null
+++ b/drivers/misc/hpilo.h
@@ -0,0 +1,189 @@
+/*
+ * linux/drivers/char/hpilo.h
+ *
+ * Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
+ *      David Altobelli <david.altobelli@hp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef __HPILO_H
+#define __HPILO_H
+
+#define ILO_NAME "hpilo"
+
+/* max number of open channel control blocks per device, hw limited to 32 */
+#define MAX_CCB         8
+/* max number of supported devices */
+#define MAX_ILO_DEV     1
+/* max number of files */
+#define MAX_OPEN        (MAX_CCB * MAX_ILO_DEV)
+
+/*
+ * Per device, used to track global memory allocations.
+ */
+struct ilo_hwinfo {
+        /* mmio registers on device */
+        char __iomem *mmio_vaddr;
+
+        /* doorbell registers on device */
+        char __iomem *db_vaddr;
+
+        /* shared memory on device used for channel control blocks */
+        char __iomem *ram_vaddr;
+
+        /* files corresponding to this device */
+        struct ccb_data *ccb_alloc[MAX_CCB];
+
+        struct pci_dev *ilo_dev;
+
+        spinlock_t alloc_lock;
+        spinlock_t fifo_lock;
+
+        struct cdev cdev;
+};
+
+/* offset from mmio_vaddr */
+#define DB_OUT          0xD4
+/* DB_OUT reset bit */
+#define DB_RESET        26
+
+/*
+ * Channel control block. Used to manage hardware queues.
+ * The format must match hw's version.  The hw ccb is 128 bytes,
+ * but the context area shouldn't be touched by the driver.
+ */
+#define ILOSW_CCB_SZ    64
+#define ILOHW_CCB_SZ    128
+struct ccb {
+        union {
+                char *send_fifobar;
+                u64 padding1;
+        } ccb_u1;
+        union {
+                char *send_desc;
+                u64 padding2;
+        } ccb_u2;
+        u64 send_ctrl;
+
+        union {
+                char *recv_fifobar;
+                u64 padding3;
+        } ccb_u3;
+        union {
+                char *recv_desc;
+                u64 padding4;
+        } ccb_u4;
+        u64 recv_ctrl;
+
+        union {
+                char __iomem *db_base;
+                u64 padding5;
+        } ccb_u5;
+
+        u64 channel;
+
+        /* unused context area (64 bytes) */
+};
+
+/* ccb queue parameters */
+#define SENDQ           1
+#define RECVQ           2
+#define NR_QENTRY       4
+#define L2_QENTRY_SZ    12
+
+/* ccb ctrl bitfields */
+#define CTRL_BITPOS_L2SZ             0
+#define CTRL_BITPOS_FIFOINDEXMASK    4
+#define CTRL_BITPOS_DESCLIMIT        18
+#define CTRL_BITPOS_A                30
+#define CTRL_BITPOS_G                31
+
+/* ccb doorbell macros */
+#define L2_DB_SIZE              14
+#define ONE_DB_SIZE             (1 << L2_DB_SIZE)
+
+/*
+ * Per fd structure used to track the ccb allocated to that dev file.
+ */
+struct ccb_data {
+        /* software version of ccb, using virtual addrs */
+        struct ccb  driver_ccb;
+
+        /* hardware version of ccb, using physical addrs */
+        struct ccb  ilo_ccb;
+
+        /* hardware ccb is written to this shared mapped device memory */
+        struct ccb __iomem *mapped_ccb;
+
+        /* dma'able memory used for send/recv queues */
+        void       *dma_va;
+        dma_addr_t  dma_pa;
+        size_t      dma_size;
+
+        /* pointer to hardware device info */
+        struct ilo_hwinfo *ilo_hw;
+
+        /* usage count, to allow for shared ccb's */
+        int         ccb_cnt;
+
+        /* open wanted exclusive access to this ccb */
+        int         ccb_excl;
+};
+
+/*
+ * FIFO queue structure, shared with hw.
+ */
+#define ILO_START_ALIGN 4096
+#define ILO_CACHE_SZ     128
+struct fifo {
+    u64 nrents; /* user requested number of fifo entries */
+    u64 imask;  /* mask to extract valid fifo index */
+    u64 merge;  /*  O/C bits to merge in during enqueue operation */
+    u64 reset;  /* set to non-zero when the target device resets */
+    u8  pad_0[ILO_CACHE_SZ - (sizeof(u64) * 4)];
+
+    u64 head;
+    u8  pad_1[ILO_CACHE_SZ - (sizeof(u64))];
+
+    u64 tail;
+    u8  pad_2[ILO_CACHE_SZ - (sizeof(u64))];
+
+    u64 fifobar[1];
+};
+
+/* convert between struct fifo, and the fifobar, which is saved in the ccb */
+#define FIFOHANDLESIZE (sizeof(struct fifo) - sizeof(u64))
+#define FIFOBARTOHANDLE(_fifo) \
+        ((struct fifo *)(((char *)(_fifo)) - FIFOHANDLESIZE))
+
+/* the number of qwords to consume from the entry descriptor */
+#define ENTRY_BITPOS_QWORDS      0
+/* descriptor index number (within a specified queue) */
+#define ENTRY_BITPOS_DESCRIPTOR  10
+/* state bit, fifo entry consumed by consumer */
+#define ENTRY_BITPOS_C           22
+/* state bit, fifo entry is occupied */
+#define ENTRY_BITPOS_O           23
+
+#define ENTRY_BITS_QWORDS        10
+#define ENTRY_BITS_DESCRIPTOR    12
+#define ENTRY_BITS_C             1
+#define ENTRY_BITS_O             1
+#define ENTRY_BITS_TOTAL        \
+        (ENTRY_BITS_C + ENTRY_BITS_O + \
+         ENTRY_BITS_QWORDS + ENTRY_BITS_DESCRIPTOR)
+
+/* extract various entry fields */
+#define ENTRY_MASK ((1 << ENTRY_BITS_TOTAL) - 1)
+#define ENTRY_MASK_C (((1 << ENTRY_BITS_C) - 1) << ENTRY_BITPOS_C)
+#define ENTRY_MASK_O (((1 << ENTRY_BITS_O) - 1) << ENTRY_BITPOS_O)
+#define ENTRY_MASK_QWORDS \
+        (((1 << ENTRY_BITS_QWORDS) - 1) << ENTRY_BITPOS_QWORDS)
+#define ENTRY_MASK_DESCRIPTOR \
+        (((1 << ENTRY_BITS_DESCRIPTOR) - 1) << ENTRY_BITPOS_DESCRIPTOR)
+
+#define ENTRY_MASK_NOSTATE (ENTRY_MASK >> (ENTRY_BITS_C + ENTRY_BITS_O))
+
+#endif /* __HPILO_H */
diff --git a/drivers/misc/phantom.c b/drivers/misc/phantom.c
index 186162470090..4ce3bdc2f959 100644
--- a/drivers/misc/phantom.c
+++ b/drivers/misc/phantom.c
@@ -399,8 +399,9 @@ static int __devinit phantom_probe(struct pci_dev *pdev,
                 goto err_irq;
         }
 
-        if (IS_ERR(device_create(phantom_class, &pdev->dev, MKDEV(phantom_major,
-                        minor), "phantom%u", minor)))
+        if (IS_ERR(device_create_drvdata(phantom_class, &pdev->dev,
+                                         MKDEV(phantom_major, minor),
+                                         NULL, "phantom%u", minor)))
                 dev_err(&pdev->dev, "can't create device\n");
 
         pci_set_drvdata(pdev, pht);
diff --git a/drivers/mtd/devices/block2mtd.c b/drivers/mtd/devices/block2mtd.c
index 519d942e7940..7b72a1b36115 100644
--- a/drivers/mtd/devices/block2mtd.c
+++ b/drivers/mtd/devices/block2mtd.c
@@ -241,6 +241,7 @@ static struct block2mtd_dev *add_device(char *devname, int erase_size)
 {
         struct block_device *bdev;
         struct block2mtd_dev *dev;
+        char *name;
 
         if (!devname)
                 return NULL;
@@ -279,12 +280,13 @@ static struct block2mtd_dev *add_device(char *devname, int erase_size)
 
         /* Setup the MTD structure */
         /* make the name contain the block device in */
-        dev->mtd.name = kmalloc(sizeof("block2mtd: ") + strlen(devname),
+        name = kmalloc(sizeof("block2mtd: ") + strlen(devname) + 1,
                         GFP_KERNEL);
-        if (!dev->mtd.name)
+        if (!name)
                 goto devinit_err;
 
-        sprintf(dev->mtd.name, "block2mtd: %s", devname);
+        sprintf(name, "block2mtd: %s", devname);
+        dev->mtd.name = name;
 
         dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK;
         dev->mtd.erasesize = erase_size;
diff --git a/drivers/mtd/mtdchar.c b/drivers/mtd/mtdchar.c
index 129d429cd2da..aef9f4b687c9 100644
--- a/drivers/mtd/mtdchar.c
+++ b/drivers/mtd/mtdchar.c
@@ -28,10 +28,13 @@ static void mtd_notify_add(struct mtd_info* mtd)
         if (!mtd)
                 return;
 
-        device_create(mtd_class, NULL, MKDEV(MTD_CHAR_MAJOR, mtd->index*2), "mtd%d", mtd->index);
+        device_create_drvdata(mtd_class, NULL,
+                              MKDEV(MTD_CHAR_MAJOR, mtd->index*2),
+                              NULL, "mtd%d", mtd->index);
 
-        device_create(mtd_class, NULL,
-                      MKDEV(MTD_CHAR_MAJOR, mtd->index*2+1), "mtd%dro", mtd->index);
+        device_create_drvdata(mtd_class, NULL,
+                              MKDEV(MTD_CHAR_MAJOR, mtd->index*2+1),
+                              NULL, "mtd%dro", mtd->index);
 }
 
 static void mtd_notify_remove(struct mtd_info* mtd)
diff --git a/drivers/net/3c59x.c b/drivers/net/3c59x.c
index aabad8ce7458..8db4e6b89482 100644
--- a/drivers/net/3c59x.c
+++ b/drivers/net/3c59x.c
@@ -1010,7 +1010,7 @@ static int __devinit vortex_probe1(struct device *gendev,
         static int printed_version;
         int retval, print_info;
         struct vortex_chip_info * const vci = &vortex_info_tbl[chip_idx];
-        char *print_name = "3c59x";
+        const char *print_name = "3c59x";
         struct pci_dev *pdev = NULL;
         struct eisa_device *edev = NULL;
         DECLARE_MAC_BUF(mac);
diff --git a/drivers/net/arm/at91_ether.c b/drivers/net/arm/at91_ether.c
index 1e39e78f1778..71f7cec30911 100644
--- a/drivers/net/arm/at91_ether.c
+++ b/drivers/net/arm/at91_ether.c
@@ -677,7 +677,7 @@ static void at91ether_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo
 {
         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
-        strlcpy(info->bus_info, dev->dev.parent->bus_id, sizeof(info->bus_info));
+        strlcpy(info->bus_info, dev_name(dev->dev.parent), sizeof(info->bus_info));
 }
 
 static const struct ethtool_ops at91ether_ethtool_ops = {
diff --git a/drivers/net/arm/ep93xx_eth.c b/drivers/net/arm/ep93xx_eth.c
index ecd8fc6146e9..7a14980f3472 100644
--- a/drivers/net/arm/ep93xx_eth.c
+++ b/drivers/net/arm/ep93xx_eth.c
@@ -848,7 +848,7 @@ static int ep93xx_eth_probe(struct platform_device *pdev)
 
         ep->res = request_mem_region(pdev->resource[0].start,
                         pdev->resource[0].end - pdev->resource[0].start + 1,
-                        pdev->dev.bus_id);
+                        dev_name(&pdev->dev));
         if (ep->res == NULL) {
                 dev_err(&pdev->dev, "Could not reserve memory region\n");
                 err = -ENOMEM;
diff --git a/drivers/net/arm/etherh.c b/drivers/net/arm/etherh.c
index e9d15eccad08..5c5f1e470d3c 100644
--- a/drivers/net/arm/etherh.c
+++ b/drivers/net/arm/etherh.c
@@ -535,7 +535,7 @@ static int __init etherh_addr(char *addr, struct expansion_card *ec)
         
         if (!ecard_readchunk(&cd, ec, 0xf5, 0)) {
                 printk(KERN_ERR "%s: unable to read podule description string\n",
-                       ec->dev.bus_id);
+                       dev_name(&ec->dev));
                 goto no_addr;
         }
 
@@ -554,7 +554,7 @@ static int __init etherh_addr(char *addr, struct expansion_card *ec)
         }
 
         printk(KERN_ERR "%s: unable to parse MAC address: %s\n",
-               ec->dev.bus_id, cd.d.string);
+               dev_name(&ec->dev), cd.d.string);
 
  no_addr:
         return -ENODEV;
@@ -585,7 +585,7 @@ static void etherh_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *i
 {
         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
-        strlcpy(info->bus_info, dev->dev.parent->bus_id,
+        strlcpy(info->bus_info, dev_name(dev->dev.parent),
                 sizeof(info->bus_info));
 }
 
diff --git a/drivers/net/ppp_generic.c b/drivers/net/ppp_generic.c
index 6b1d7a8edf15..739b3ab7bccc 100644
--- a/drivers/net/ppp_generic.c
+++ b/drivers/net/ppp_generic.c
@@ -866,7 +866,8 @@ static int __init ppp_init(void)
                         err = PTR_ERR(ppp_class);
                         goto out_chrdev;
                 }
-                device_create(ppp_class, NULL, MKDEV(PPP_MAJOR, 0), "ppp");
+                device_create_drvdata(ppp_class, NULL, MKDEV(PPP_MAJOR, 0),
+                                      NULL, "ppp");
         }
 
 out:
diff --git a/drivers/net/wan/cosa.c b/drivers/net/wan/cosa.c
index 5827324e9d9f..f7d3349dc3ec 100644
--- a/drivers/net/wan/cosa.c
+++ b/drivers/net/wan/cosa.c
@@ -397,9 +397,9 @@ static int __init cosa_init(void)
                 err = PTR_ERR(cosa_class);
                 goto out_chrdev;
         }
-        for (i=0; i<nr_cards; i++) {
-                device_create(cosa_class, NULL, MKDEV(cosa_major, i), "cosa%d", i);
-        }
+        for (i = 0; i < nr_cards; i++)
+                device_create_drvdata(cosa_class, NULL, MKDEV(cosa_major, i),
+                                      NULL, "cosa%d", i);
         err = 0;
         goto out;
         
diff --git a/drivers/pci/hotplug/acpiphp.h b/drivers/pci/hotplug/acpiphp.h
index eecf7cbf4139..5a58b075dd8d 100644
--- a/drivers/pci/hotplug/acpiphp.h
+++ b/drivers/pci/hotplug/acpiphp.h
@@ -36,7 +36,7 @@
 #define _ACPIPHP_H
 
 #include <linux/acpi.h>
-#include <linux/kobject.h>      /* for KOBJ_NAME_LEN */
+#include <linux/kobject.h>
 #include <linux/mutex.h>
 #include <linux/pci_hotplug.h>
 
@@ -51,7 +51,7 @@
 #define warn(format, arg...) printk(KERN_WARNING "%s: " format, MY_NAME , ## arg)
 
 /* name size which is used for entries in pcihpfs */
-#define SLOT_NAME_SIZE  KOBJ_NAME_LEN           /* {_SUN} */
+#define SLOT_NAME_SIZE  20              /* {_SUN} */
 
 struct acpiphp_bridge;
 struct acpiphp_slot;
diff --git a/drivers/power/apm_power.c b/drivers/power/apm_power.c
index a4892275659d..936bae560fa1 100644
--- a/drivers/power/apm_power.c
+++ b/drivers/power/apm_power.c
@@ -78,7 +78,7 @@ static void find_main_battery(void)
         main_battery = NULL;
         bp.main = main_battery;
 
-        error = class_for_each_device(power_supply_class, &bp,
+        error = class_for_each_device(power_supply_class, NULL, &bp,
                                       __find_main_battery);
         if (error) {
                 main_battery = bp.main;
diff --git a/drivers/power/power_supply_core.c b/drivers/power/power_supply_core.c
index af1633eb3b70..cb1ccb472921 100644
--- a/drivers/power/power_supply_core.c
+++ b/drivers/power/power_supply_core.c
@@ -41,7 +41,7 @@ static void power_supply_changed_work(struct work_struct *work)
 
         dev_dbg(psy->dev, "%s\n", __func__);
 
-        class_for_each_device(power_supply_class, psy,
+        class_for_each_device(power_supply_class, NULL, psy,
                               __power_supply_changed_work);
 
         power_supply_update_leds(psy);
@@ -79,7 +79,7 @@ int power_supply_am_i_supplied(struct power_supply *psy)
 {
         int error;
 
-        error = class_for_each_device(power_supply_class, psy,
+        error = class_for_each_device(power_supply_class, NULL, psy,
                                       __power_supply_am_i_supplied);
 
         dev_dbg(psy->dev, "%s %d\n", __func__, error);
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 58b7336640ff..d397fa5f3a91 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -345,7 +345,7 @@ struct rtc_device *rtc_class_open(char *name)
         struct device *dev;
         struct rtc_device *rtc = NULL;
 
-        dev = class_find_device(rtc_class, name, __rtc_match);
+        dev = class_find_device(rtc_class, NULL, name, __rtc_match);
         if (dev)
                 rtc = to_rtc_device(dev);
 
diff --git a/drivers/s390/char/raw3270.c b/drivers/s390/char/raw3270.c
index 81a96e019080..c3dee900a5c8 100644
--- a/drivers/s390/char/raw3270.c
+++ b/drivers/s390/char/raw3270.c
@@ -1168,17 +1168,19 @@ static int raw3270_create_attributes(struct raw3270 *rp)
         if (rc)
                 goto out;
 
-        rp->clttydev = device_create(class3270, &rp->cdev->dev,
-                                     MKDEV(IBM_TTY3270_MAJOR, rp->minor),
-                                     "tty%s", rp->cdev->dev.bus_id);
+        rp->clttydev = device_create_drvdata(class3270, &rp->cdev->dev,
+                                             MKDEV(IBM_TTY3270_MAJOR, rp->minor),
+                                             NULL,
+                                             "tty%s", rp->cdev->dev.bus_id);
         if (IS_ERR(rp->clttydev)) {
                 rc = PTR_ERR(rp->clttydev);
                 goto out_ttydev;
         }
 
-        rp->cltubdev = device_create(class3270, &rp->cdev->dev,
-                                     MKDEV(IBM_FS3270_MAJOR, rp->minor),
-                                     "tub%s", rp->cdev->dev.bus_id);
+        rp->cltubdev = device_create_drvdata(class3270, &rp->cdev->dev,
+                                             MKDEV(IBM_FS3270_MAJOR, rp->minor),
+                                             NULL,
+                                             "tub%s", rp->cdev->dev.bus_id);
         if (!IS_ERR(rp->cltubdev))
                 goto out;
 
diff --git a/drivers/s390/char/tape_class.c b/drivers/s390/char/tape_class.c
index 6dfdb7c17981..12c2a5aaf31b 100644
--- a/drivers/s390/char/tape_class.c
+++ b/drivers/s390/char/tape_class.c
@@ -69,10 +69,9 @@ struct tape_class_device *register_tape_dev(
         if (rc)
                 goto fail_with_cdev;
 
-        tcd->class_device = device_create(tape_class, device,
-                                          tcd->char_device->dev,
-                                          "%s", tcd->device_name
-                        );
+        tcd->class_device = device_create_drvdata(tape_class, device,
+                                                  tcd->char_device->dev,
+                                                  NULL, "%s", tcd->device_name);
         rc = IS_ERR(tcd->class_device) ? PTR_ERR(tcd->class_device) : 0;
         if (rc)
                 goto fail_with_cdev;
diff --git a/drivers/s390/char/vmur.c b/drivers/s390/char/vmur.c
index b0ac44b27127..c1f352b84868 100644
--- a/drivers/s390/char/vmur.c
+++ b/drivers/s390/char/vmur.c
@@ -896,8 +896,9 @@ static int ur_set_online(struct ccw_device *cdev)
                 goto fail_free_cdev;
         }
 
-        urd->device = device_create(vmur_class, NULL, urd->char_device->dev,
-                                        "%s", node_id);
+        urd->device = device_create_drvdata(vmur_class, NULL,
+                                            urd->char_device->dev, NULL,
+                                            "%s", node_id);
         if (IS_ERR(urd->device)) {
                 rc = PTR_ERR(urd->device);
                 TRACE("ur_set_online: device_create rc=%d\n", rc);
diff --git a/drivers/sbus/sbus.c b/drivers/sbus/sbus.c
index c37d7c2587ff..73a86d09bba8 100644
--- a/drivers/sbus/sbus.c
+++ b/drivers/sbus/sbus.c
@@ -78,7 +78,7 @@ static void __init fill_sbus_device(struct device_node *dp, struct sbus_dev *sde
         else
                 sdev->ofdev.dev.parent = &sdev->bus->ofdev.dev;
         sdev->ofdev.dev.bus = &sbus_bus_type;
-        sprintf(sdev->ofdev.dev.bus_id, "sbus[%08x]", dp->node);
+        dev_set_name(&sdev->ofdev.dev, "sbus[%08x]", dp->node);
 
         if (of_device_register(&sdev->ofdev) != 0)
                 printk(KERN_DEBUG "sbus: device registration error for %s!\n",
@@ -257,11 +257,11 @@ static void __init build_one_sbus(struct device_node *dp, int num_sbus)
         sbus->ofdev.node = dp;
         sbus->ofdev.dev.parent = NULL;
         sbus->ofdev.dev.bus = &sbus_bus_type;
-        sprintf(sbus->ofdev.dev.bus_id, "sbus%d", num_sbus);
+        dev_set_name(&sbus->ofdev.dev, "sbus%d", num_sbus);
 
         if (of_device_register(&sbus->ofdev) != 0)
                 printk(KERN_DEBUG "sbus: device registration error for %s!\n",
-                       sbus->ofdev.dev.bus_id);
+                       dev_name(&sbus->ofdev.dev));
 
         dev_dp = dp->child;
         while (dev_dp) {
diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index 2bc30e32b67a..1fe0901e8119 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -271,8 +271,8 @@ rebuild_sys_tab:
                 pHba->initialized = TRUE;
                 pHba->state &= ~DPTI_STATE_RESET;
                 if (adpt_sysfs_class) {
-                        struct device *dev = device_create(adpt_sysfs_class,
-                                NULL, MKDEV(DPTI_I2O_MAJOR, pHba->unit),
+                        struct device *dev = device_create_drvdata(adpt_sysfs_class,
+                                NULL, MKDEV(DPTI_I2O_MAJOR, pHba->unit), NULL,
                                 "dpti%d", pHba->unit);
                         if (IS_ERR(dev)) {
                                 printk(KERN_WARNING"dpti%d: unable to "
diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
index 35cd892dce04..fed0b02ebc1d 100644
--- a/drivers/scsi/hosts.c
+++ b/drivers/scsi/hosts.c
@@ -232,8 +232,8 @@ int scsi_add_host(struct Scsi_Host *shost, struct device *dev)
         }
 
         if (shost->transportt->create_work_queue) {
-                snprintf(shost->work_q_name, KOBJ_NAME_LEN, "scsi_wq_%d",
-                        shost->host_no);
+                snprintf(shost->work_q_name, sizeof(shost->work_q_name),
+                         "scsi_wq_%d", shost->host_no);
                 shost->work_q = create_singlethread_workqueue(
                                         shost->work_q_name);
                 if (!shost->work_q) {
@@ -466,7 +466,8 @@ struct Scsi_Host *scsi_host_lookup(unsigned short hostnum)
         struct device *cdev;
         struct Scsi_Host *shost = ERR_PTR(-ENXIO);
 
-        cdev = class_find_device(&shost_class, &hostnum, __scsi_host_match);
+        cdev = class_find_device(&shost_class, NULL, &hostnum,
+                                 __scsi_host_match);
         if (cdev) {
                 shost = scsi_host_get(class_to_shost(cdev));
                 put_device(cdev);
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index 5fd64e70029d..a272b9a2c869 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -417,15 +417,16 @@ static int fc_host_setup(struct transport_container *tc, struct device *dev,
         fc_host->next_vport_number = 0;
         fc_host->npiv_vports_inuse = 0;
 
-        snprintf(fc_host->work_q_name, KOBJ_NAME_LEN, "fc_wq_%d",
-                shost->host_no);
+        snprintf(fc_host->work_q_name, sizeof(fc_host->work_q_name),
+                 "fc_wq_%d", shost->host_no);
         fc_host->work_q = create_singlethread_workqueue(
                                         fc_host->work_q_name);
         if (!fc_host->work_q)
                 return -ENOMEM;
 
-        snprintf(fc_host->devloss_work_q_name, KOBJ_NAME_LEN, "fc_dl_%d",
-                shost->host_no);
+        snprintf(fc_host->devloss_work_q_name,
+                 sizeof(fc_host->devloss_work_q_name),
+                 "fc_dl_%d", shost->host_no);
         fc_host->devloss_work_q = create_singlethread_workqueue(
                                         fc_host->devloss_work_q_name);
         if (!fc_host->devloss_work_q) {
diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
index 3af7cbcc5c5d..043c3921164f 100644
--- a/drivers/scsi/scsi_transport_iscsi.c
+++ b/drivers/scsi/scsi_transport_iscsi.c
@@ -170,7 +170,7 @@ iscsi_create_endpoint(int dd_size)
         int err;
 
         for (id = 1; id < ISCSI_MAX_EPID; id++) {
-                dev = class_find_device(&iscsi_endpoint_class, &id,
+                dev = class_find_device(&iscsi_endpoint_class, NULL, &id,
                                         iscsi_match_epid);
                 if (!dev)
                         break;
@@ -222,7 +222,7 @@ struct iscsi_endpoint *iscsi_lookup_endpoint(u64 handle)
         struct iscsi_endpoint *ep;
         struct device *dev;
 
-        dev = class_find_device(&iscsi_endpoint_class, &handle,
+        dev = class_find_device(&iscsi_endpoint_class, NULL, &handle,
                                 iscsi_match_epid);
         if (!dev)
                 return NULL;
@@ -247,8 +247,8 @@ static int iscsi_setup_host(struct transport_container *tc, struct device *dev,
         atomic_set(&ihost->nr_scans, 0);
         mutex_init(&ihost->mutex);
 
-        snprintf(ihost->scan_workq_name, KOBJ_NAME_LEN, "iscsi_scan_%d",
-                shost->host_no);
+        snprintf(ihost->scan_workq_name, sizeof(ihost->scan_workq_name),
+                 "iscsi_scan_%d", shost->host_no);
         ihost->scan_workq = create_singlethread_workqueue(
                                                 ihost->scan_workq_name);
         if (!ihost->scan_workq)
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 1ad12afc6ba0..1771b2456bfa 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -502,7 +502,7 @@ struct spi_master *spi_busnum_to_master(u16 bus_num)
         struct device           *dev;
         struct spi_master       *master = NULL;
 
-        dev = class_find_device(&spi_master_class, &bus_num,
+        dev = class_find_device(&spi_master_class, NULL, &bus_num,
                                 __spi_master_match);
         if (dev)
                 master = container_of(dev, struct spi_master, dev);
diff --git a/drivers/spi/spidev.c b/drivers/spi/spidev.c
index ddbe1a5e970e..2833fd772a24 100644
--- a/drivers/spi/spidev.c
+++ b/drivers/spi/spidev.c
@@ -576,7 +576,8 @@ static int spidev_probe(struct spi_device *spi)
                 struct device *dev;
 
                 spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
-                dev = device_create(spidev_class, &spi->dev, spidev->devt,
+                dev = device_create_drvdata(spidev_class, &spi->dev,
+                                spidev->devt, spidev,
                                 "spidev%d.%d",
                                 spi->master->bus_num, spi->chip_select);
                 status = IS_ERR(dev) ? PTR_ERR(dev) : 0;
@@ -586,7 +587,6 @@ static int spidev_probe(struct spi_device *spi)
         }
         if (status == 0) {
                 set_bit(minor, minors);
-                spi_set_drvdata(spi, spidev);
                 list_add(&spidev->device_entry, &device_list);
         }
         mutex_unlock(&device_list_lock);
diff --git a/drivers/uio/Kconfig b/drivers/uio/Kconfig
index a4aaab9c7ddc..2e9079df26b3 100644
--- a/drivers/uio/Kconfig
+++ b/drivers/uio/Kconfig
@@ -15,7 +15,7 @@ if UIO
 
 config UIO_CIF
         tristate "generic Hilscher CIF Card driver"
-        depends on UIO && PCI
+        depends on PCI
         default n
         help
           Driver for Hilscher CIF DeviceNet and Profibus cards.  This
@@ -26,9 +26,15 @@ config UIO_CIF
           To compile this driver as a module, choose M here: the module
           will be called uio_cif.
 
+config UIO_PDRV
+        tristate "Userspace I/O platform driver"
+        help
+          Generic platform driver for Userspace I/O devices.
+
+          If you don't know what to do here, say N.
+
 config UIO_SMX
         tristate "SMX cryptengine UIO interface"
-        depends on UIO
         default n
         help
           Userspace IO interface to the Cryptography engine found on the
diff --git a/drivers/uio/Makefile b/drivers/uio/Makefile
index 18c45662431e..e00ce0def1a0 100644
--- a/drivers/uio/Makefile
+++ b/drivers/uio/Makefile
@@ -1,3 +1,4 @@
 obj-$(CONFIG_UIO)       += uio.o
 obj-$(CONFIG_UIO_CIF)   += uio_cif.o
+obj-$(CONFIG_UIO_PDRV)  += uio_pdrv.o
 obj-$(CONFIG_UIO_SMX)   += uio_smx.o
diff --git a/drivers/uio/uio.c b/drivers/uio/uio.c
index 5a7ca2e6094d..3a6934bf7131 100644
--- a/drivers/uio/uio.c
+++ b/drivers/uio/uio.c
@@ -427,6 +427,31 @@ static ssize_t uio_read(struct file *filep, char __user *buf,
         return retval;
 }
 
+static ssize_t uio_write(struct file *filep, const char __user *buf,
+                        size_t count, loff_t *ppos)
+{
+        struct uio_listener *listener = filep->private_data;
+        struct uio_device *idev = listener->dev;
+        ssize_t retval;
+        s32 irq_on;
+
+        if (idev->info->irq == UIO_IRQ_NONE)
+                return -EIO;
+
+        if (count != sizeof(s32))
+                return -EINVAL;
+
+        if (!idev->info->irqcontrol)
+                return -ENOSYS;
+
+        if (copy_from_user(&irq_on, buf, count))
+                return -EFAULT;
+
+        retval = idev->info->irqcontrol(idev->info, irq_on);
+
+        return retval ? retval : sizeof(s32);
+}
+
 static int uio_find_mem_index(struct vm_area_struct *vma)
 {
         int mi;
@@ -546,6 +571,7 @@ static const struct file_operations uio_fops = {
         .open           = uio_open,
         .release        = uio_release,
         .read           = uio_read,
+        .write          = uio_write,
         .mmap           = uio_mmap,
         .poll           = uio_poll,
         .fasync         = uio_fasync,
diff --git a/drivers/uio/uio_pdrv.c b/drivers/uio/uio_pdrv.c
new file mode 100644
index 000000000000..5d0d2e85d982
--- /dev/null
+++ b/drivers/uio/uio_pdrv.c
@@ -0,0 +1,118 @@
+/*
+ * drivers/uio/uio_pdrv.c
+ *
+ * Copyright (C) 2008 by Digi International Inc.
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ */
+#include <linux/platform_device.h>
+#include <linux/uio_driver.h>
+#include <linux/stringify.h>
+
+#define DRIVER_NAME "uio"
+
+struct uio_platdata {
+        struct uio_info *uioinfo;
+};
+
+static int uio_pdrv_probe(struct platform_device *pdev)
+{
+        struct uio_info *uioinfo = pdev->dev.platform_data;
+        struct uio_platdata *pdata;
+        struct uio_mem *uiomem;
+        int ret = -ENODEV;
+        int i;
+
+        if (!uioinfo || !uioinfo->name || !uioinfo->version) {
+                dev_dbg(&pdev->dev, "%s: err_uioinfo\n", __func__);
+                goto err_uioinfo;
+        }
+
+        pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+        if (!pdata) {
+                ret = -ENOMEM;
+                dev_dbg(&pdev->dev, "%s: err_alloc_pdata\n", __func__);
+                goto err_alloc_pdata;
+        }
+
+        pdata->uioinfo = uioinfo;
+
+        uiomem = &uioinfo->mem[0];
+
+        for (i = 0; i < pdev->num_resources; ++i) {
+                struct resource *r = &pdev->resource[i];
+
+                if (r->flags != IORESOURCE_MEM)
+                        continue;
+
+                if (uiomem >= &uioinfo->mem[MAX_UIO_MAPS]) {
+                        dev_warn(&pdev->dev, "device has more than "
+                                        __stringify(MAX_UIO_MAPS)
+                                        " I/O memory resources.\n");
+                        break;
+                }
+
+                uiomem->memtype = UIO_MEM_PHYS;
+                uiomem->addr = r->start;
+                uiomem->size = r->end - r->start + 1;
+                ++uiomem;
+        }
+
+        while (uiomem < &uioinfo->mem[MAX_UIO_MAPS]) {
+                uiomem->size = 0;
+                ++uiomem;
+        }
+
+        pdata->uioinfo->priv = pdata;
+
+        ret = uio_register_device(&pdev->dev, pdata->uioinfo);
+
+        if (ret) {
+                kfree(pdata);
+err_alloc_pdata:
+err_uioinfo:
+                return ret;
+        }
+
+        platform_set_drvdata(pdev, pdata);
+
+        return 0;
+}
+
+static int uio_pdrv_remove(struct platform_device *pdev)
+{
+        struct uio_platdata *pdata = platform_get_drvdata(pdev);
+
+        uio_unregister_device(pdata->uioinfo);
+
+        return 0;
+}
+
+static struct platform_driver uio_pdrv = {
+        .probe = uio_pdrv_probe,
+        .remove = uio_pdrv_remove,
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init uio_pdrv_init(void)
+{
+        return platform_driver_register(&uio_pdrv);
+}
+
+static void __exit uio_pdrv_exit(void)
+{
+        platform_driver_unregister(&uio_pdrv);
+}
+module_init(uio_pdrv_init);
+module_exit(uio_pdrv_exit);
+
+MODULE_AUTHOR("Uwe Kleine-Koenig");
+MODULE_DESCRIPTION("Userspace I/O platform driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:" DRIVER_NAME);
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 54a350ccd033..20290c5b1562 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -1729,9 +1729,9 @@ static int usb_classdev_add(struct usb_device *dev)
 {
         struct device *cldev;
 
-        cldev = device_create(usb_classdev_class, &dev->dev, dev->dev.devt,
-                              "usbdev%d.%d", dev->bus->busnum,
-                              dev->devnum);
+        cldev = device_create_drvdata(usb_classdev_class, &dev->dev,
+                                      dev->dev.devt, NULL, "usbdev%d.%d",
+                                      dev->bus->busnum, dev->devnum);
         if (IS_ERR(cldev))
                 return PTR_ERR(cldev);
         dev->usb_classdev = cldev;
@@ -1792,6 +1792,11 @@ int __init usb_devio_init(void)
                 usb_classdev_class = NULL;
                 goto out;
         }
+        /* devices of this class shadow the major:minor of their parent
+         * device, so clear ->dev_kobj to prevent adding duplicate entries
+         * to /sys/dev
+         */
+        usb_classdev_class->dev_kobj = NULL;
 
         usb_register_notify(&usbdev_nb);
 #endif
diff --git a/drivers/usb/core/file.c b/drivers/usb/core/file.c
index 913fb8667899..6b1b229e38cd 100644
--- a/drivers/usb/core/file.c
+++ b/drivers/usb/core/file.c
@@ -196,8 +196,9 @@ int usb_register_dev(struct usb_interface *intf,
                 ++temp;
         else
                 temp = name;
-        intf->usb_dev = device_create(usb_class->class, &intf->dev,
-                                      MKDEV(USB_MAJOR, minor), "%s", temp);
+        intf->usb_dev = device_create_drvdata(usb_class->class, &intf->dev,
+                                              MKDEV(USB_MAJOR, minor), NULL,
+                                              "%s", temp);
         if (IS_ERR(intf->usb_dev)) {
                 down_write(&minor_rwsem);
                 usb_minors[intf->minor] = NULL;
diff --git a/drivers/usb/gadget/printer.c b/drivers/usb/gadget/printer.c
index 9caaec3ae9a3..49cd9e145a9b 100644
--- a/drivers/usb/gadget/printer.c
+++ b/drivers/usb/gadget/printer.c
@@ -1360,8 +1360,8 @@ printer_bind(struct usb_gadget *gadget)
 
 
         /* Setup the sysfs files for the printer gadget. */
-        dev->pdev = device_create(usb_gadget_class, NULL, g_printer_devno,
-                        "g_printer");
+        dev->pdev = device_create_drvdata(usb_gadget_class, NULL,
+                                          g_printer_devno, NULL, "g_printer");
         if (IS_ERR(dev->pdev)) {
                 ERROR(dev, "Failed to create device: g_printer\n");
                 goto fail;
diff --git a/drivers/usb/mon/mon_bin.c b/drivers/usb/mon/mon_bin.c
index 293a46247c3b..6566fc0a3228 100644
--- a/drivers/usb/mon/mon_bin.c
+++ b/drivers/usb/mon/mon_bin.c
@@ -1162,8 +1162,9 @@ int mon_bin_add(struct mon_bus *mbus, const struct usb_bus *ubus)
         if (minor >= MON_BIN_MAX_MINOR)
                 return 0;
 
-        dev = device_create(mon_bin_class, ubus? ubus->controller: NULL,
-                        MKDEV(MAJOR(mon_bin_dev0), minor), "usbmon%d", minor);
+        dev = device_create_drvdata(mon_bin_class, ubus? ubus->controller: NULL,
+                                    MKDEV(MAJOR(mon_bin_dev0), minor), NULL,
+                                    "usbmon%d", minor);
         if (IS_ERR(dev))
                 return 0;
 
diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c
index 24ee96c4e9e9..07b6addbb3c1 100644
--- a/drivers/video/aty/aty128fb.c
+++ b/drivers/video/aty/aty128fb.c
@@ -1872,7 +1872,7 @@ static int __devinit aty128_init(struct pci_dev *pdev, const struct pci_device_i
         struct fb_info *info = pci_get_drvdata(pdev);
         struct aty128fb_par *par = info->par;
         struct fb_var_screeninfo var;
-        char video_card[DEVICE_NAME_SIZE];
+        char video_card[50];
         u8 chip_rev;
         u32 dac;
 
diff --git a/drivers/video/aty/radeonfb.h b/drivers/video/aty/radeonfb.h
index c347e38cd0b0..ccbfffd12805 100644
--- a/drivers/video/aty/radeonfb.h
+++ b/drivers/video/aty/radeonfb.h
@@ -289,7 +289,7 @@ struct radeonfb_info {
         struct radeon_regs      state;
         struct radeon_regs      init_state;
 
-        char                    name[DEVICE_NAME_SIZE];
+        char                    name[50];
 
         unsigned long           mmio_base_phys;
         unsigned long           fb_base_phys;
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index 97aff8db10bf..4be3b46c069b 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -3586,7 +3586,8 @@ static int __init fb_console_init(void)
 
         acquire_console_sem();
         fb_register_client(&fbcon_event_notifier);
-        fbcon_device = device_create(fb_class, NULL, MKDEV(0, 0), "fbcon");
+        fbcon_device = device_create_drvdata(fb_class, NULL, MKDEV(0, 0),
+                                             NULL, "fbcon");
 
         if (IS_ERR(fbcon_device)) {
                 printk(KERN_WARNING "Unable to create device "
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index 33ebdb198daf..1cd5071e5362 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -1439,8 +1439,9 @@ register_framebuffer(struct fb_info *fb_info)
                         break;
         fb_info->node = i;
 
-        fb_info->dev = device_create(fb_class, fb_info->device,
-                                     MKDEV(FB_MAJOR, i), "fb%d", i);
+        fb_info->dev = device_create_drvdata(fb_class, fb_info->device,
+                                             MKDEV(FB_MAJOR, i), NULL,
+                                             "fb%d", i);
         if (IS_ERR(fb_info->dev)) {
                 /* Not fatal */
                 printk(KERN_WARNING "Unable to create device for framebuffer %d; errno = %ld\n", i, PTR_ERR(fb_info->dev));
diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c
index 591bc29b55f5..d4427cb86979 100644
--- a/drivers/xen/balloon.c
+++ b/drivers/xen/balloon.c
@@ -610,6 +610,7 @@ static ssize_t show_target_kb(struct sys_device *dev, char *buf)
 }
 
 static ssize_t store_target_kb(struct sys_device *dev,
+                               struct sysdev_attribute *attr,
                                const char *buf,
                                size_t count)
 {