113 files changed, 1052 insertions, 530 deletions

diff --git a/drivers/acpi/dock.c b/drivers/acpi/dock.c
index 35094f230b1e..7af7db1ba8c4 100644
--- a/drivers/acpi/dock.c
+++ b/drivers/acpi/dock.c
@@ -977,7 +977,7 @@ static int dock_add(acpi_handle handle)
                 sizeof(struct dock_station *));
 
         /* we want the dock device to send uevents */
-        dock_device->dev.uevent_suppress = 0;
+        dev_set_uevent_suppress(&dock_device->dev, 0);
 
         if (is_dock(handle))
                 dock_station->flags |= DOCK_IS_DOCK;
diff --git a/drivers/amba/bus.c b/drivers/amba/bus.c
index 00c46e0b40e4..3d763fdf99b7 100644
--- a/drivers/amba/bus.c
+++ b/drivers/amba/bus.c
@@ -210,7 +210,7 @@ int amba_device_register(struct amba_device *dev, struct resource *parent)
         dev->dev.release = amba_device_release;
         dev->dev.bus = &amba_bustype;
         dev->dev.dma_mask = &dev->dma_mask;
-        dev->res.name = dev->dev.bus_id;
+        dev->res.name = dev_name(&dev->dev);
 
         if (!dev->dev.coherent_dma_mask && dev->dma_mask)
                 dev_warn(&dev->dev, "coherent dma mask is unset\n");
@@ -294,7 +294,7 @@ static int amba_find_match(struct device *dev, void *data)
         if (d->parent)
                 r &= d->parent == dev->parent;
         if (d->busid)
-                r &= strcmp(dev->bus_id, d->busid) == 0;
+                r &= strcmp(dev_name(dev), d->busid) == 0;
 
         if (r) {
                 get_device(dev);
diff --git a/drivers/base/base.h b/drivers/base/base.h
index 9f50f1b545dc..ddc97496db4a 100644
--- a/drivers/base/base.h
+++ b/drivers/base/base.h
@@ -63,6 +63,32 @@ struct class_private {
 #define to_class(obj)   \
         container_of(obj, struct class_private, class_subsys.kobj)
 
+/**
+ * struct device_private - structure to hold the private to the driver core portions of the device structure.
+ *
+ * @klist_children - klist containing all children of this device
+ * @knode_parent - node in sibling list
+ * @knode_driver - node in driver list
+ * @knode_bus - node in bus list
+ * @device - pointer back to the struct class that this structure is
+ * associated with.
+ *
+ * Nothing outside of the driver core should ever touch these fields.
+ */
+struct device_private {
+        struct klist klist_children;
+        struct klist_node knode_parent;
+        struct klist_node knode_driver;
+        struct klist_node knode_bus;
+        struct device *device;
+};
+#define to_device_private_parent(obj)   \
+        container_of(obj, struct device_private, knode_parent)
+#define to_device_private_driver(obj)   \
+        container_of(obj, struct device_private, knode_driver)
+#define to_device_private_bus(obj)      \
+        container_of(obj, struct device_private, knode_bus)
+
 /* initialisation functions */
 extern int devices_init(void);
 extern int buses_init(void);
@@ -86,6 +112,11 @@ extern void bus_remove_driver(struct device_driver *drv);
 
 extern void driver_detach(struct device_driver *drv);
 extern int driver_probe_device(struct device_driver *drv, struct device *dev);
+static inline int driver_match_device(struct device_driver *drv,
+                                      struct device *dev)
+{
+        return drv->bus->match && drv->bus->match(dev, drv);
+}
 
 extern void sysdev_shutdown(void);
 
diff --git a/drivers/base/bus.c b/drivers/base/bus.c
index 83f32b891fa9..dc030f1f00f1 100644
--- a/drivers/base/bus.c
+++ b/drivers/base/bus.c
@@ -198,7 +198,7 @@ static ssize_t driver_bind(struct device_driver *drv,
         int err = -ENODEV;
 
         dev = bus_find_device_by_name(bus, NULL, buf);
-        if (dev && dev->driver == NULL) {
+        if (dev && dev->driver == NULL && driver_match_device(drv, dev)) {
                 if (dev->parent)        /* Needed for USB */
                         down(&dev->parent->sem);
                 down(&dev->sem);
@@ -253,7 +253,14 @@ static ssize_t store_drivers_probe(struct bus_type *bus,
 static struct device *next_device(struct klist_iter *i)
 {
         struct klist_node *n = klist_next(i);
-        return n ? container_of(n, struct device, knode_bus) : NULL;
+        struct device *dev = NULL;
+        struct device_private *dev_prv;
+
+        if (n) {
+                dev_prv = to_device_private_bus(n);
+                dev = dev_prv->device;
+        }
+        return dev;
 }
 
 /**
@@ -286,7 +293,7 @@ int bus_for_each_dev(struct bus_type *bus, struct device *start,
                 return -EINVAL;
 
         klist_iter_init_node(&bus->p->klist_devices, &i,
-                             (start ? &start->knode_bus : NULL));
+                             (start ? &start->p->knode_bus : NULL));
         while ((dev = next_device(&i)) && !error)
                 error = fn(dev, data);
         klist_iter_exit(&i);
@@ -320,7 +327,7 @@ struct device *bus_find_device(struct bus_type *bus,
                 return NULL;
 
         klist_iter_init_node(&bus->p->klist_devices, &i,
-                             (start ? &start->knode_bus : NULL));
+                             (start ? &start->p->knode_bus : NULL));
         while ((dev = next_device(&i)))
                 if (match(dev, data) && get_device(dev))
                         break;
@@ -507,7 +514,8 @@ void bus_attach_device(struct device *dev)
                         ret = device_attach(dev);
                 WARN_ON(ret < 0);
                 if (ret >= 0)
-                        klist_add_tail(&dev->knode_bus, &bus->p->klist_devices);
+                        klist_add_tail(&dev->p->knode_bus,
+                                       &bus->p->klist_devices);
         }
 }
 
@@ -528,8 +536,8 @@ void bus_remove_device(struct device *dev)
                 sysfs_remove_link(&dev->bus->p->devices_kset->kobj,
                                   dev_name(dev));
                 device_remove_attrs(dev->bus, dev);
-                if (klist_node_attached(&dev->knode_bus))
-                        klist_del(&dev->knode_bus);
+                if (klist_node_attached(&dev->p->knode_bus))
+                        klist_del(&dev->p->knode_bus);
 
                 pr_debug("bus: '%s': remove device %s\n",
                          dev->bus->name, dev_name(dev));
@@ -831,14 +839,16 @@ static void bus_remove_attrs(struct bus_type *bus)
 
 static void klist_devices_get(struct klist_node *n)
 {
-        struct device *dev = container_of(n, struct device, knode_bus);
+        struct device_private *dev_prv = to_device_private_bus(n);
+        struct device *dev = dev_prv->device;
 
         get_device(dev);
 }
 
 static void klist_devices_put(struct klist_node *n)
 {
-        struct device *dev = container_of(n, struct device, knode_bus);
+        struct device_private *dev_prv = to_device_private_bus(n);
+        struct device *dev = dev_prv->device;
 
         put_device(dev);
 }
@@ -932,6 +942,7 @@ bus_uevent_fail:
         kset_unregister(&bus->p->subsys);
         kfree(bus->p);
 out:
+        bus->p = NULL;
         return retval;
 }
 EXPORT_SYMBOL_GPL(bus_register);
@@ -953,6 +964,7 @@ void bus_unregister(struct bus_type *bus)
         bus_remove_file(bus, &bus_attr_uevent);
         kset_unregister(&bus->p->subsys);
         kfree(bus->p);
+        bus->p = NULL;
 }
 EXPORT_SYMBOL_GPL(bus_unregister);
 
@@ -993,18 +1005,20 @@ static void device_insertion_sort_klist(struct device *a, struct list_head *list
 {
         struct list_head *pos;
         struct klist_node *n;
+        struct device_private *dev_prv;
         struct device *b;
 
         list_for_each(pos, list) {
                 n = container_of(pos, struct klist_node, n_node);
-                b = container_of(n, struct device, knode_bus);
+                dev_prv = to_device_private_bus(n);
+                b = dev_prv->device;
                 if (compare(a, b) <= 0) {
-                        list_move_tail(&a->knode_bus.n_node,
-                                       &b->knode_bus.n_node);
+                        list_move_tail(&a->p->knode_bus.n_node,
+                                       &b->p->knode_bus.n_node);
                         return;
                 }
         }
-        list_move_tail(&a->knode_bus.n_node, list);
+        list_move_tail(&a->p->knode_bus.n_node, list);
 }
 
 void bus_sort_breadthfirst(struct bus_type *bus,
@@ -1014,6 +1028,7 @@ void bus_sort_breadthfirst(struct bus_type *bus,
         LIST_HEAD(sorted_devices);
         struct list_head *pos, *tmp;
         struct klist_node *n;
+        struct device_private *dev_prv;
         struct device *dev;
         struct klist *device_klist;
 
@@ -1022,7 +1037,8 @@ void bus_sort_breadthfirst(struct bus_type *bus,
         spin_lock(&device_klist->k_lock);
         list_for_each_safe(pos, tmp, &device_klist->k_list) {
                 n = container_of(pos, struct klist_node, n_node);
-                dev = container_of(n, struct device, knode_bus);
+                dev_prv = to_device_private_bus(n);
+                dev = dev_prv->device;
                 device_insertion_sort_klist(dev, &sorted_devices, compare);
         }
         list_splice(&sorted_devices, &device_klist->k_list);
diff --git a/drivers/base/core.c b/drivers/base/core.c
index f3eae630e589..e73c92d13a23 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -109,6 +109,7 @@ static struct sysfs_ops dev_sysfs_ops = {
 static void device_release(struct kobject *kobj)
 {
         struct device *dev = to_dev(kobj);
+        struct device_private *p = dev->p;
 
         if (dev->release)
                 dev->release(dev);
@@ -120,6 +121,7 @@ static void device_release(struct kobject *kobj)
                 WARN(1, KERN_ERR "Device '%s' does not have a release() "
                         "function, it is broken and must be fixed.\n",
                         dev_name(dev));
+        kfree(p);
 }
 
 static struct kobj_type device_ktype = {
@@ -134,8 +136,6 @@ static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
 
         if (ktype == &device_ktype) {
                 struct device *dev = to_dev(kobj);
-                if (dev->uevent_suppress)
-                        return 0;
                 if (dev->bus)
                         return 1;
                 if (dev->class)
@@ -507,14 +507,16 @@ EXPORT_SYMBOL_GPL(device_schedule_callback_owner);
 
 static void klist_children_get(struct klist_node *n)
 {
-        struct device *dev = container_of(n, struct device, knode_parent);
+        struct device_private *p = to_device_private_parent(n);
+        struct device *dev = p->device;
 
         get_device(dev);
 }
 
 static void klist_children_put(struct klist_node *n)
 {
-        struct device *dev = container_of(n, struct device, knode_parent);
+        struct device_private *p = to_device_private_parent(n);
+        struct device *dev = p->device;
 
         put_device(dev);
 }
@@ -538,8 +540,6 @@ void device_initialize(struct device *dev)
 {
         dev->kobj.kset = devices_kset;
         kobject_init(&dev->kobj, &device_ktype);
-        klist_init(&dev->klist_children, klist_children_get,
-                   klist_children_put);
         INIT_LIST_HEAD(&dev->dma_pools);
         init_MUTEX(&dev->sem);
         spin_lock_init(&dev->devres_lock);
@@ -777,17 +777,12 @@ static void device_remove_class_symlinks(struct device *dev)
 int dev_set_name(struct device *dev, const char *fmt, ...)
 {
         va_list vargs;
-        char *s;
+        int err;
 
         va_start(vargs, fmt);
-        vsnprintf(dev->bus_id, sizeof(dev->bus_id), fmt, vargs);
+        err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
         va_end(vargs);
-
-        /* ewww... some of these buggers have / in the name... */
-        while ((s = strchr(dev->bus_id, '/')))
-                *s = '!';
-
-        return 0;
+        return err;
 }
 EXPORT_SYMBOL_GPL(dev_set_name);
 
@@ -864,12 +859,26 @@ int device_add(struct device *dev)
         if (!dev)
                 goto done;
 
-        /* Temporarily support init_name if it is set.
-         * It will override bus_id for now */
-        if (dev->init_name)
-                dev_set_name(dev, "%s", dev->init_name);
+        dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
+        if (!dev->p) {
+                error = -ENOMEM;
+                goto done;
+        }
+        dev->p->device = dev;
+        klist_init(&dev->p->klist_children, klist_children_get,
+                   klist_children_put);
+
+        /*
+         * for statically allocated devices, which should all be converted
+         * some day, we need to initialize the name. We prevent reading back
+         * the name, and force the use of dev_name()
+         */
+        if (dev->init_name) {
+                dev_set_name(dev, dev->init_name);
+                dev->init_name = NULL;
+        }
 
-        if (!strlen(dev->bus_id))
+        if (!dev_name(dev))
                 goto done;
 
         pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
@@ -928,7 +937,8 @@ int device_add(struct device *dev)
         kobject_uevent(&dev->kobj, KOBJ_ADD);
         bus_attach_device(dev);
         if (parent)
-                klist_add_tail(&dev->knode_parent, &parent->klist_children);
+                klist_add_tail(&dev->p->knode_parent,
+                               &parent->p->klist_children);
 
         if (dev->class) {
                 mutex_lock(&dev->class->p->class_mutex);
@@ -1042,7 +1052,7 @@ void device_del(struct device *dev)
         device_pm_remove(dev);
         dpm_sysfs_remove(dev);
         if (parent)
-                klist_del(&dev->knode_parent);
+                klist_del(&dev->p->knode_parent);
         if (MAJOR(dev->devt)) {
                 device_remove_sys_dev_entry(dev);
                 device_remove_file(dev, &devt_attr);
@@ -1103,7 +1113,14 @@ void device_unregister(struct device *dev)
 static struct device *next_device(struct klist_iter *i)
 {
         struct klist_node *n = klist_next(i);
-        return n ? container_of(n, struct device, knode_parent) : NULL;
+        struct device *dev = NULL;
+        struct device_private *p;
+
+        if (n) {
+                p = to_device_private_parent(n);
+                dev = p->device;
+        }
+        return dev;
 }
 
 /**
@@ -1125,7 +1142,7 @@ int device_for_each_child(struct device *parent, void *data,
         struct device *child;
         int error = 0;
 
-        klist_iter_init(&parent->klist_children, &i);
+        klist_iter_init(&parent->p->klist_children, &i);
         while ((child = next_device(&i)) && !error)
                 error = fn(child, data);
         klist_iter_exit(&i);
@@ -1156,7 +1173,7 @@ struct device *device_find_child(struct device *parent, void *data,
         if (!parent)
                 return NULL;
 
-        klist_iter_init(&parent->klist_children, &i);
+        klist_iter_init(&parent->p->klist_children, &i);
         while ((child = next_device(&i)))
                 if (match(child, data) && get_device(child))
                         break;
@@ -1348,7 +1365,10 @@ struct device *device_create_vargs(struct class *class, struct device *parent,
         dev->release = device_create_release;
         dev_set_drvdata(dev, drvdata);
 
-        vsnprintf(dev->bus_id, BUS_ID_SIZE, fmt, args);
+        retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
+        if (retval)
+                goto error;
+
         retval = device_register(dev);
         if (retval)
                 goto error;
@@ -1452,19 +1472,15 @@ int device_rename(struct device *dev, char *new_name)
                 old_class_name = make_class_name(dev->class->name, &dev->kobj);
 #endif
 
-        old_device_name = kmalloc(BUS_ID_SIZE, GFP_KERNEL);
+        old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
         if (!old_device_name) {
                 error = -ENOMEM;
                 goto out;
         }
-        strlcpy(old_device_name, dev->bus_id, BUS_ID_SIZE);
-        strlcpy(dev->bus_id, new_name, BUS_ID_SIZE);
 
         error = kobject_rename(&dev->kobj, new_name);
-        if (error) {
-                strlcpy(dev->bus_id, old_device_name, BUS_ID_SIZE);
+        if (error)
                 goto out;
-        }
 
 #ifdef CONFIG_SYSFS_DEPRECATED
         if (old_class_name) {
@@ -1545,8 +1561,10 @@ out:
  * device_move - moves a device to a new parent
  * @dev: the pointer to the struct device to be moved
  * @new_parent: the new parent of the device (can by NULL)
+ * @dpm_order: how to reorder the dpm_list
  */
-int device_move(struct device *dev, struct device *new_parent)
+int device_move(struct device *dev, struct device *new_parent,
+                enum dpm_order dpm_order)
 {
         int error;
         struct device *old_parent;
@@ -1556,6 +1574,7 @@ int device_move(struct device *dev, struct device *new_parent)
         if (!dev)
                 return -EINVAL;
 
+        device_pm_lock();
         new_parent = get_device(new_parent);
         new_parent_kobj = get_device_parent(dev, new_parent);
 
@@ -1570,9 +1589,10 @@ int device_move(struct device *dev, struct device *new_parent)
         old_parent = dev->parent;
         dev->parent = new_parent;
         if (old_parent)
-                klist_remove(&dev->knode_parent);
+                klist_remove(&dev->p->knode_parent);
         if (new_parent) {
-                klist_add_tail(&dev->knode_parent, &new_parent->klist_children);
+                klist_add_tail(&dev->p->knode_parent,
+                               &new_parent->p->klist_children);
                 set_dev_node(dev, dev_to_node(new_parent));
         }
 
@@ -1584,11 +1604,11 @@ int device_move(struct device *dev, struct device *new_parent)
                 device_move_class_links(dev, new_parent, old_parent);
                 if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
                         if (new_parent)
-                                klist_remove(&dev->knode_parent);
+                                klist_remove(&dev->p->knode_parent);
                         dev->parent = old_parent;
                         if (old_parent) {
-                                klist_add_tail(&dev->knode_parent,
-                                               &old_parent->klist_children);
+                                klist_add_tail(&dev->p->knode_parent,
+                                               &old_parent->p->klist_children);
                                 set_dev_node(dev, dev_to_node(old_parent));
                         }
                 }
@@ -1596,9 +1616,23 @@ int device_move(struct device *dev, struct device *new_parent)
                 put_device(new_parent);
                 goto out;
         }
+        switch (dpm_order) {
+        case DPM_ORDER_NONE:
+                break;
+        case DPM_ORDER_DEV_AFTER_PARENT:
+                device_pm_move_after(dev, new_parent);
+                break;
+        case DPM_ORDER_PARENT_BEFORE_DEV:
+                device_pm_move_before(new_parent, dev);
+                break;
+        case DPM_ORDER_DEV_LAST:
+                device_pm_move_last(dev);
+                break;
+        }
 out_put:
         put_device(old_parent);
 out:
+        device_pm_unlock();
         put_device(dev);
         return error;
 }
diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index 135231239103..f17c3266a0e0 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -30,7 +30,7 @@
 
 static void driver_bound(struct device *dev)
 {
-        if (klist_node_attached(&dev->knode_driver)) {
+        if (klist_node_attached(&dev->p->knode_driver)) {
                 printk(KERN_WARNING "%s: device %s already bound\n",
                         __func__, kobject_name(&dev->kobj));
                 return;
@@ -43,7 +43,7 @@ static void driver_bound(struct device *dev)
                 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
                                              BUS_NOTIFY_BOUND_DRIVER, dev);
 
-        klist_add_tail(&dev->knode_driver, &dev->driver->p->klist_devices);
+        klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);
 }
 
 static int driver_sysfs_add(struct device *dev)
@@ -172,16 +172,12 @@ int driver_probe_done(void)
 /**
  * wait_for_device_probe
  * Wait for device probing to be completed.
- *
- * Note: this function polls at 100 msec intervals.
  */
-int wait_for_device_probe(void)
+void wait_for_device_probe(void)
 {
         /* wait for the known devices to complete their probing */
-        while (driver_probe_done() != 0)
-                msleep(100);
+        wait_event(probe_waitqueue, atomic_read(&probe_count) == 0);
         async_synchronize_full();
-        return 0;
 }
 
 /**
@@ -189,14 +185,8 @@ int wait_for_device_probe(void)
  * @drv: driver to bind a device to
  * @dev: device to try to bind to the driver
  *
- * First, we call the bus's match function, if one present, which should
- * compare the device IDs the driver supports with the device IDs of the
- * device. Note we don't do this ourselves because we don't know the
- * format of the ID structures, nor what is to be considered a match and
- * what is not.
- *
- * This function returns 1 if a match is found, -ENODEV if the device is
- * not registered, and 0 otherwise.
+ * This function returns -ENODEV if the device is not registered,
+ * 1 if the device is bound sucessfully and 0 otherwise.
  *
  * This function must be called with @dev->sem held.  When called for a
  * USB interface, @dev->parent->sem must be held as well.
@@ -207,21 +197,22 @@ int driver_probe_device(struct device_driver *drv, struct device *dev)
 
         if (!device_is_registered(dev))
                 return -ENODEV;
-        if (drv->bus->match && !drv->bus->match(dev, drv))
-                goto done;
 
         pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
                  drv->bus->name, __func__, dev_name(dev), drv->name);
 
         ret = really_probe(dev, drv);
 
-done:
         return ret;
 }
 
 static int __device_attach(struct device_driver *drv, void *data)
 {
         struct device *dev = data;
+
+        if (!driver_match_device(drv, dev))
+                return 0;
+
         return driver_probe_device(drv, dev);
 }
 
@@ -274,7 +265,7 @@ static int __driver_attach(struct device *dev, void *data)
          * is an error.
          */
 
-        if (drv->bus->match && !drv->bus->match(dev, drv))
+        if (!driver_match_device(drv, dev))
                 return 0;
 
         if (dev->parent)        /* Needed for USB */
@@ -327,7 +318,7 @@ static void __device_release_driver(struct device *dev)
                         drv->remove(dev);
                 devres_release_all(dev);
                 dev->driver = NULL;
-                klist_remove(&dev->knode_driver);
+                klist_remove(&dev->p->knode_driver);
         }
 }
 
@@ -357,6 +348,7 @@ EXPORT_SYMBOL_GPL(device_release_driver);
  */
 void driver_detach(struct device_driver *drv)
 {
+        struct device_private *dev_prv;
         struct device *dev;
 
         for (;;) {
@@ -365,8 +357,10 @@ void driver_detach(struct device_driver *drv)
                         spin_unlock(&drv->p->klist_devices.k_lock);
                         break;
                 }
-                dev = list_entry(drv->p->klist_devices.k_list.prev,
-                                struct device, knode_driver.n_node);
+                dev_prv = list_entry(drv->p->klist_devices.k_list.prev,
+                                     struct device_private,
+                                     knode_driver.n_node);
+                dev = dev_prv->device;
                 get_device(dev);
                 spin_unlock(&drv->p->klist_devices.k_lock);
 
diff --git a/drivers/base/driver.c b/drivers/base/driver.c
index 1e2bda780e48..c51f11bb29ae 100644
--- a/drivers/base/driver.c
+++ b/drivers/base/driver.c
@@ -19,7 +19,14 @@
 static struct device *next_device(struct klist_iter *i)
 {
         struct klist_node *n = klist_next(i);
-        return n ? container_of(n, struct device, knode_driver) : NULL;
+        struct device *dev = NULL;
+        struct device_private *dev_prv;
+
+        if (n) {
+                dev_prv = to_device_private_driver(n);
+                dev = dev_prv->device;
+        }
+        return dev;
 }
 
 /**
@@ -42,7 +49,7 @@ int driver_for_each_device(struct device_driver *drv, struct device *start,
                 return -EINVAL;
 
         klist_iter_init_node(&drv->p->klist_devices, &i,
-                             start ? &start->knode_driver : NULL);
+                             start ? &start->p->knode_driver : NULL);
         while ((dev = next_device(&i)) && !error)
                 error = fn(dev, data);
         klist_iter_exit(&i);
@@ -76,7 +83,7 @@ struct device *driver_find_device(struct device_driver *drv,
                 return NULL;
 
         klist_iter_init_node(&drv->p->klist_devices, &i,
-                             (start ? &start->knode_driver : NULL));
+                             (start ? &start->p->knode_driver : NULL));
         while ((dev = next_device(&i)))
                 if (match(dev, data) && get_device(dev))
                         break;
@@ -216,6 +223,8 @@ int driver_register(struct device_driver *drv)
         int ret;
         struct device_driver *other;
 
+        BUG_ON(!drv->bus->p);
+
         if ((drv->bus->probe && drv->probe) ||
             (drv->bus->remove && drv->remove) ||
             (drv->bus->shutdown && drv->shutdown))
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 44699d9dd85c..d3a59c688fe4 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -319,7 +319,7 @@ static int fw_register_device(struct device **dev_p, const char *fw_name,
         f_dev->parent = device;
         f_dev->class = &firmware_class;
         dev_set_drvdata(f_dev, fw_priv);
-        f_dev->uevent_suppress = 1;
+        dev_set_uevent_suppress(f_dev, 1);
         retval = device_register(f_dev);
         if (retval) {
                 dev_err(device, "%s: device_register failed\n", __func__);
@@ -366,7 +366,7 @@ static int fw_setup_device(struct firmware *fw, struct device **dev_p,
         }
 
         if (uevent)
-                f_dev->uevent_suppress = 0;
+                dev_set_uevent_suppress(f_dev, 0);
         *dev_p = f_dev;
         goto out;
 
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 349a1013603f..d2198f64ad4e 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -217,6 +217,7 @@ int platform_device_add_data(struct platform_device *pdev, const void *data,
         if (d) {
                 memcpy(d, data, size);
                 pdev->dev.platform_data = d;
+                pdev->platform_data = d;
         }
         return d ? 0 : -ENOMEM;
 }
@@ -246,6 +247,21 @@ int platform_device_add(struct platform_device *pdev)
         else
                 dev_set_name(&pdev->dev, pdev->name);
 
+        /* We will remove platform_data field from struct device
+        * if all platform devices pass its platform specific data
+        * from platform_device. The conversion is going to be a
+        * long time, so we allow the two cases coexist to make
+        * this kind of fix more easily*/
+        if (pdev->platform_data && pdev->dev.platform_data) {
+                printk(KERN_ERR
+                               "%s: use which platform_data?\n",
+                               dev_name(&pdev->dev));
+        } else if (pdev->platform_data) {
+                pdev->dev.platform_data = pdev->platform_data;
+        } else if (pdev->dev.platform_data) {
+                pdev->platform_data = pdev->dev.platform_data;
+        }
+
         for (i = 0; i < pdev->num_resources; i++) {
                 struct resource *p, *r = &pdev->resource[i];
 
@@ -584,10 +600,25 @@ static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
         struct platform_device  *pdev = to_platform_device(dev);
 
-        add_uevent_var(env, "MODALIAS=platform:%s", pdev->name);
+        add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX,
+                (pdev->id_entry) ? pdev->id_entry->name : pdev->name);
         return 0;
 }
 
+static const struct platform_device_id *platform_match_id(
+                        struct platform_device_id *id,
+                        struct platform_device *pdev)
+{
+        while (id->name[0]) {
+                if (strcmp(pdev->name, id->name) == 0) {
+                        pdev->id_entry = id;
+                        return id;
+                }
+                id++;
+        }
+        return NULL;
+}
+
 /**
  * platform_match - bind platform device to platform driver.
  * @dev: device.
@@ -603,9 +634,14 @@ static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
  */
 static int platform_match(struct device *dev, struct device_driver *drv)
 {
-        struct platform_device *pdev;
+        struct platform_device *pdev = to_platform_device(dev);
+        struct platform_driver *pdrv = to_platform_driver(drv);
 
-        pdev = container_of(dev, struct platform_device, dev);
+        /* match against the id table first */
+        if (pdrv->id_table)
+                return platform_match_id(pdrv->id_table, pdev) != NULL;
+
+        /* fall-back to driver name match */
         return (strcmp(pdev->name, drv->name) == 0);
 }
 
@@ -623,26 +659,24 @@ static int platform_legacy_suspend(struct device *dev, pm_message_t mesg)
 
 static int platform_legacy_suspend_late(struct device *dev, pm_message_t mesg)
 {
-        struct platform_driver *drv = to_platform_driver(dev->driver);
-        struct platform_device *pdev;
+        struct platform_driver *pdrv = to_platform_driver(dev->driver);
+        struct platform_device *pdev = to_platform_device(dev);
         int ret = 0;
 
-        pdev = container_of(dev, struct platform_device, dev);
-        if (dev->driver && drv->suspend_late)
-                ret = drv->suspend_late(pdev, mesg);
+        if (dev->driver && pdrv->suspend_late)
+                ret = pdrv->suspend_late(pdev, mesg);
 
         return ret;
 }
 
 static int platform_legacy_resume_early(struct device *dev)
 {
-        struct platform_driver *drv = to_platform_driver(dev->driver);
-        struct platform_device *pdev;
+        struct platform_driver *pdrv = to_platform_driver(dev->driver);
+        struct platform_device *pdev = to_platform_device(dev);
         int ret = 0;
 
-        pdev = container_of(dev, struct platform_device, dev);
-        if (dev->driver && drv->resume_early)
-                ret = drv->resume_early(pdev);
+        if (dev->driver && pdrv->resume_early)
+                ret = pdrv->resume_early(pdev);
 
         return ret;
 }
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 2d14f4ae6c01..e255341682c8 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -107,6 +107,50 @@ void device_pm_remove(struct device *dev)
 }
 
 /**
+ *      device_pm_move_before - move device in dpm_list
+ *      @deva:  Device to move in dpm_list
+ *      @devb:  Device @deva should come before
+ */
+void device_pm_move_before(struct device *deva, struct device *devb)
+{
+        pr_debug("PM: Moving %s:%s before %s:%s\n",
+                 deva->bus ? deva->bus->name : "No Bus",
+                 kobject_name(&deva->kobj),
+                 devb->bus ? devb->bus->name : "No Bus",
+                 kobject_name(&devb->kobj));
+        /* Delete deva from dpm_list and reinsert before devb. */
+        list_move_tail(&deva->power.entry, &devb->power.entry);
+}
+
+/**
+ *      device_pm_move_after - move device in dpm_list
+ *      @deva:  Device to move in dpm_list
+ *      @devb:  Device @deva should come after
+ */
+void device_pm_move_after(struct device *deva, struct device *devb)
+{
+        pr_debug("PM: Moving %s:%s after %s:%s\n",
+                 deva->bus ? deva->bus->name : "No Bus",
+                 kobject_name(&deva->kobj),
+                 devb->bus ? devb->bus->name : "No Bus",
+                 kobject_name(&devb->kobj));
+        /* Delete deva from dpm_list and reinsert after devb. */
+        list_move(&deva->power.entry, &devb->power.entry);
+}
+
+/**
+ *      device_pm_move_last - move device to end of dpm_list
+ *      @dev:   Device to move in dpm_list
+ */
+void device_pm_move_last(struct device *dev)
+{
+        pr_debug("PM: Moving %s:%s to end of list\n",
+                 dev->bus ? dev->bus->name : "No Bus",
+                 kobject_name(&dev->kobj));
+        list_move_tail(&dev->power.entry, &dpm_list);
+}
+
+/**
  *      pm_op - execute the PM operation appropiate for given PM event
  *      @dev:   Device.
  *      @ops:   PM operations to choose from.
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index 41f51fae042f..c7cb4fc3735c 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -18,11 +18,19 @@ static inline struct device *to_device(struct list_head *entry)
 
 extern void device_pm_add(struct device *);
 extern void device_pm_remove(struct device *);
+extern void device_pm_move_before(struct device *, struct device *);
+extern void device_pm_move_after(struct device *, struct device *);
+extern void device_pm_move_last(struct device *);
 
 #else /* CONFIG_PM_SLEEP */
 
 static inline void device_pm_add(struct device *dev) {}
 static inline void device_pm_remove(struct device *dev) {}
+static inline void device_pm_move_before(struct device *deva,
+                                         struct device *devb) {}
+static inline void device_pm_move_after(struct device *deva,
+                                        struct device *devb) {}
+static inline void device_pm_move_last(struct device *dev) {}
 
 #endif
 
diff --git a/drivers/base/sys.c b/drivers/base/sys.c
index b428c8c4bc64..cbd36cf59a0f 100644
--- a/drivers/base/sys.c
+++ b/drivers/base/sys.c
@@ -30,10 +30,10 @@
 
 
 static ssize_t
-sysdev_show(struct kobject * kobj, struct attribute * attr, char * buffer)
+sysdev_show(struct kobject *kobj, struct attribute *attr, char *buffer)
 {
-        struct sys_device * sysdev = to_sysdev(kobj);
-        struct sysdev_attribute * sysdev_attr = to_sysdev_attr(attr);
+        struct sys_device *sysdev = to_sysdev(kobj);
+        struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);
 
         if (sysdev_attr->show)
                 return sysdev_attr->show(sysdev, sysdev_attr, buffer);
@@ -42,11 +42,11 @@ sysdev_show(struct kobject * kobj, struct attribute * attr, char * buffer)
 
 
 static ssize_t
-sysdev_store(struct kobject * kobj, struct attribute * attr,
-             const char * buffer, size_t count)
+sysdev_store(struct kobject *kobj, struct attribute *attr,
+             const char *buffer, size_t count)
 {
-        struct sys_device * sysdev = to_sysdev(kobj);
-        struct sysdev_attribute * sysdev_attr = to_sysdev_attr(attr);
+        struct sys_device *sysdev = to_sysdev(kobj);
+        struct sysdev_attribute *sysdev_attr = to_sysdev_attr(attr);
 
         if (sysdev_attr->store)
                 return sysdev_attr->store(sysdev, sysdev_attr, buffer, count);
@@ -63,13 +63,13 @@ static struct kobj_type ktype_sysdev = {
 };
 
 
-int sysdev_create_file(struct sys_device * s, struct sysdev_attribute * a)
+int sysdev_create_file(struct sys_device *s, struct sysdev_attribute *a)
 {
         return sysfs_create_file(&s->kobj, &a->attr);
 }
 
 
-void sysdev_remove_file(struct sys_device * s, struct sysdev_attribute * a)
+void sysdev_remove_file(struct sys_device *s, struct sysdev_attribute *a)
 {
         sysfs_remove_file(&s->kobj, &a->attr);
 }
@@ -84,7 +84,7 @@ EXPORT_SYMBOL_GPL(sysdev_remove_file);
 static ssize_t sysdev_class_show(struct kobject *kobj, struct attribute *attr,
                                  char *buffer)
 {
-        struct sysdev_class * class = to_sysdev_class(kobj);
+        struct sysdev_class *class = to_sysdev_class(kobj);
         struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);
 
         if (class_attr->show)
@@ -95,8 +95,8 @@ static ssize_t sysdev_class_show(struct kobject *kobj, struct attribute *attr,
 static ssize_t sysdev_class_store(struct kobject *kobj, struct attribute *attr,
                                   const char *buffer, size_t count)
 {
-        struct sysdev_class * class = to_sysdev_class(kobj);
-        struct sysdev_class_attribute * class_attr = to_sysdev_class_attr(attr);
+        struct sysdev_class *class = to_sysdev_class(kobj);
+        struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);
 
         if (class_attr->store)
                 return class_attr->store(class, buffer, count);
@@ -128,7 +128,7 @@ EXPORT_SYMBOL_GPL(sysdev_class_remove_file);
 
 static struct kset *system_kset;
 
-int sysdev_class_register(struct sysdev_class * cls)
+int sysdev_class_register(struct sysdev_class *cls)
 {
         pr_debug("Registering sysdev class '%s'\n", cls->name);
 
@@ -141,7 +141,7 @@ int sysdev_class_register(struct sysdev_class * cls)
         return kset_register(&cls->kset);
 }
 
-void sysdev_class_unregister(struct sysdev_class * cls)
+void sysdev_class_unregister(struct sysdev_class *cls)
 {
         pr_debug("Unregistering sysdev class '%s'\n",
                  kobject_name(&cls->kset.kobj));
@@ -203,8 +203,8 @@ int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
  *      @cls:   Class driver belongs to.
  *      @drv:   Driver.
  */
-void sysdev_driver_unregister(struct sysdev_class * cls,
-                              struct sysdev_driver * drv)
+void sysdev_driver_unregister(struct sysdev_class *cls,
+                              struct sysdev_driver *drv)
 {
         mutex_lock(&sysdev_drivers_lock);
         list_del_init(&drv->entry);
@@ -229,10 +229,10 @@ EXPORT_SYMBOL_GPL(sysdev_driver_unregister);
  *      @sysdev:        device in question
  *
  */
-int sysdev_register(struct sys_device * sysdev)
+int sysdev_register(struct sys_device *sysdev)
 {
         int error;
-        struct sysdev_class * cls = sysdev->cls;
+        struct sysdev_class *cls = sysdev->cls;
 
         if (!cls)
                 return -EINVAL;
@@ -252,7 +252,7 @@ int sysdev_register(struct sys_device * sysdev)
                                      sysdev->id);
 
         if (!error) {
-                struct sysdev_driver * drv;
+                struct sysdev_driver *drv;
 
                 pr_debug("Registering sys device '%s'\n",
                          kobject_name(&sysdev->kobj));
@@ -274,9 +274,9 @@ int sysdev_register(struct sys_device * sysdev)
         return error;
 }
 
-void sysdev_unregister(struct sys_device * sysdev)
+void sysdev_unregister(struct sys_device *sysdev)
 {
-        struct sysdev_driver * drv;
+        struct sysdev_driver *drv;
 
         mutex_lock(&sysdev_drivers_lock);
         list_for_each_entry(drv, &sysdev->cls->drivers, entry) {
@@ -305,19 +305,19 @@ void sysdev_unregister(struct sys_device * sysdev)
  */
 void sysdev_shutdown(void)
 {
-        struct sysdev_class * cls;
+        struct sysdev_class *cls;
 
         pr_debug("Shutting Down System Devices\n");
 
         mutex_lock(&sysdev_drivers_lock);
         list_for_each_entry_reverse(cls, &system_kset->list, kset.kobj.entry) {
-                struct sys_device * sysdev;
+                struct sys_device *sysdev;
 
                 pr_debug("Shutting down type '%s':\n",
                          kobject_name(&cls->kset.kobj));
 
                 list_for_each_entry(sysdev, &cls->kset.list, kobj.entry) {
-                        struct sysdev_driver * drv;
+                        struct sysdev_driver *drv;
                         pr_debug(" %s\n", kobject_name(&sysdev->kobj));
 
                         /* Call auxillary drivers first */
@@ -364,7 +364,7 @@ static void __sysdev_resume(struct sys_device *dev)
  */
 int sysdev_suspend(pm_message_t state)
 {
-        struct sysdev_class * cls;
+        struct sysdev_class *cls;
         struct sys_device *sysdev, *err_dev;
         struct sysdev_driver *drv, *err_drv;
         int ret;
@@ -442,12 +442,12 @@ EXPORT_SYMBOL_GPL(sysdev_suspend);
  */
 int sysdev_resume(void)
 {
-        struct sysdev_class * cls;
+        struct sysdev_class *cls;
 
         pr_debug("Resuming System Devices\n");
 
         list_for_each_entry(cls, &system_kset->list, kset.kobj.entry) {
-                struct sys_device * sysdev;
+                struct sys_device *sysdev;
 
                 pr_debug("Resuming type '%s':\n",
                          kobject_name(&cls->kset.kobj));
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 83d8ed39433d..c2c95e614506 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -4135,10 +4135,9 @@ static int have_no_fdc = -ENODEV;
 static ssize_t floppy_cmos_show(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
-        struct platform_device *p;
+        struct platform_device *p = to_platform_device(dev);
         int drive;
 
-        p = container_of(dev, struct platform_device,dev);
         drive = p->id;
         return sprintf(buf, "%X\n", UDP->cmos);
 }
diff --git a/drivers/char/tpm/tpm_atmel.c b/drivers/char/tpm/tpm_atmel.c
index d0e7926eb486..c64a1bc65349 100644
--- a/drivers/char/tpm/tpm_atmel.c
+++ b/drivers/char/tpm/tpm_atmel.c
@@ -168,12 +168,22 @@ static void atml_plat_remove(void)
         }
 }
 
-static struct device_driver atml_drv = {
-        .name = "tpm_atmel",
-        .bus = &platform_bus_type,
-        .owner = THIS_MODULE,
-        .suspend = tpm_pm_suspend,
-        .resume = tpm_pm_resume,
+static int tpm_atml_suspend(struct platform_device *dev, pm_message_t msg)
+{
+        return tpm_pm_suspend(&dev->dev, msg);
+}
+
+static int tpm_atml_resume(struct platform_device *dev)
+{
+        return tpm_pm_resume(&dev->dev);
+}
+static struct platform_driver atml_drv = {
+        .driver = {
+                .name = "tpm_atmel",
+                .owner          = THIS_MODULE,
+        },
+        .suspend = tpm_atml_suspend,
+        .resume = tpm_atml_resume,
 };
 
 static int __init init_atmel(void)
@@ -184,7 +194,7 @@ static int __init init_atmel(void)
         unsigned long base;
         struct  tpm_chip *chip;
 
-        rc = driver_register(&atml_drv);
+        rc = platform_driver_register(&atml_drv);
         if (rc)
                 return rc;
 
@@ -223,13 +233,13 @@ err_rel_reg:
                 atmel_release_region(base,
                                      region_size);
 err_unreg_drv:
-        driver_unregister(&atml_drv);
+        platform_driver_unregister(&atml_drv);
         return rc;
 }
 
 static void __exit cleanup_atmel(void)
 {
-        driver_unregister(&atml_drv);
+        platform_driver_unregister(&atml_drv);
         atml_plat_remove();
 }
 
diff --git a/drivers/char/tpm/tpm_tis.c b/drivers/char/tpm/tpm_tis.c
index 717af7ad1bdf..aec1931608aa 100644
--- a/drivers/char/tpm/tpm_tis.c
+++ b/drivers/char/tpm/tpm_tis.c
@@ -654,12 +654,22 @@ module_param_string(hid, tpm_pnp_tbl[TIS_HID_USR_IDX].id,
                     sizeof(tpm_pnp_tbl[TIS_HID_USR_IDX].id), 0444);
 MODULE_PARM_DESC(hid, "Set additional specific HID for this driver to probe");
 
-static struct device_driver tis_drv = {
-        .name = "tpm_tis",
-        .bus = &platform_bus_type,
-        .owner = THIS_MODULE,
-        .suspend = tpm_pm_suspend,
-        .resume = tpm_pm_resume,
+static int tpm_tis_suspend(struct platform_device *dev, pm_message_t msg)
+{
+        return tpm_pm_suspend(&dev->dev, msg);
+}
+
+static int tpm_tis_resume(struct platform_device *dev)
+{
+        return tpm_pm_resume(&dev->dev);
+}
+static struct platform_driver tis_drv = {
+        .driver = {
+                .name = "tpm_tis",
+                .owner          = THIS_MODULE,
+        },
+        .suspend = tpm_tis_suspend,
+        .resume = tpm_tis_resume,
 };
 
 static struct platform_device *pdev;
@@ -672,14 +682,14 @@ static int __init init_tis(void)
         int rc;
 
         if (force) {
-                rc = driver_register(&tis_drv);
+                rc = platform_driver_register(&tis_drv);
                 if (rc < 0)
                         return rc;
                 if (IS_ERR(pdev=platform_device_register_simple("tpm_tis", -1, NULL, 0)))
                         return PTR_ERR(pdev);
                 if((rc=tpm_tis_init(&pdev->dev, TIS_MEM_BASE, TIS_MEM_LEN, 0)) != 0) {
                         platform_device_unregister(pdev);
-                        driver_unregister(&tis_drv);
+                        platform_driver_unregister(&tis_drv);
                 }
                 return rc;
         }
@@ -711,7 +721,7 @@ static void __exit cleanup_tis(void)
 
         if (force) {
                 platform_device_unregister(pdev);
-                driver_unregister(&tis_drv);
+                platform_driver_unregister(&tis_drv);
         } else
                 pnp_unregister_driver(&tis_pnp_driver);
 }
diff --git a/drivers/char/vc_screen.c b/drivers/char/vc_screen.c
index 4f3b3f95fc42..d94d25c12aa8 100644
--- a/drivers/char/vc_screen.c
+++ b/drivers/char/vc_screen.c
@@ -479,18 +479,18 @@ static const struct file_operations vcs_fops = {
 
 static struct class *vc_class;
 
-void vcs_make_sysfs(struct tty_struct *tty)
+void vcs_make_sysfs(int index)
 {
-        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 1), NULL,
-                      "vcs%u", tty->index + 1);
-        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, tty->index + 129), NULL,
-                      "vcsa%u", tty->index + 1);
+        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, index + 1), NULL,
+                      "vcs%u", index + 1);
+        device_create(vc_class, NULL, MKDEV(VCS_MAJOR, index + 129), NULL,
+                      "vcsa%u", index + 1);
 }
 
-void vcs_remove_sysfs(struct tty_struct *tty)
+void vcs_remove_sysfs(int index)
 {
-        device_destroy(vc_class, MKDEV(VCS_MAJOR, tty->index + 1));
-        device_destroy(vc_class, MKDEV(VCS_MAJOR, tty->index + 129));
+        device_destroy(vc_class, MKDEV(VCS_MAJOR, index + 1));
+        device_destroy(vc_class, MKDEV(VCS_MAJOR, index + 129));
 }
 
 int __init vcs_init(void)
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index 7900bd63b36d..2c1d133819b5 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -778,6 +778,7 @@ int vc_allocate(unsigned int currcons)	/* return 0 on success */
             }
             vc->vc_kmalloced = 1;
             vc_init(vc, vc->vc_rows, vc->vc_cols, 1);
+            vcs_make_sysfs(currcons);
             atomic_notifier_call_chain(&vt_notifier_list, VT_ALLOCATE, &param);
         }
         return 0;
@@ -987,7 +988,9 @@ void vc_deallocate(unsigned int currcons)
         if (vc_cons_allocated(currcons)) {
                 struct vc_data *vc = vc_cons[currcons].d;
                 struct vt_notifier_param param = { .vc = vc };
+
                 atomic_notifier_call_chain(&vt_notifier_list, VT_DEALLOCATE, &param);
+                vcs_remove_sysfs(currcons);
                 vc->vc_sw->con_deinit(vc);
                 put_pid(vc->vt_pid);
                 module_put(vc->vc_sw->owner);
@@ -2775,7 +2778,6 @@ static int con_open(struct tty_struct *tty, struct file *filp)
                                 tty->termios->c_iflag |= IUTF8;
                         else
                                 tty->termios->c_iflag &= ~IUTF8;
-                        vcs_make_sysfs(tty);
                         release_console_sem();
                         return ret;
                 }
@@ -2795,7 +2797,6 @@ static void con_shutdown(struct tty_struct *tty)
         BUG_ON(vc == NULL);
         acquire_console_sem();
         vc->vc_tty = NULL;
-        vcs_remove_sysfs(tty);
         release_console_sem();
         tty_shutdown(tty);
 }
diff --git a/drivers/dio/dio.c b/drivers/dio/dio.c
index 10c3c498358c..55dd88d82d6d 100644
--- a/drivers/dio/dio.c
+++ b/drivers/dio/dio.c
@@ -182,7 +182,7 @@ static int __init dio_init(void)
 
         /* Initialize the DIO bus */ 
         INIT_LIST_HEAD(&dio_bus.devices);
-        strcpy(dio_bus.dev.bus_id, "dio");
+        dev_set_name(&dio_bus.dev, "dio");
         error = device_register(&dio_bus.dev);
         if (error) {
                 pr_err("DIO: Error registering dio_bus\n");
@@ -237,7 +237,7 @@ static int __init dio_init(void)
                 dev->scode = scode;
                 dev->resource.start = pa;
                 dev->resource.end = pa + DIO_SIZE(scode, va);
-                sprintf(dev->dev.bus_id,"%02x", scode);
+                dev_set_name(&dev->dev, "%02x", scode);
 
                 /* read the ID byte(s) and encode if necessary. */
                 prid = DIO_ID(va);
diff --git a/drivers/dma/dw_dmac.c b/drivers/dma/dw_dmac.c
index a97c07eef7ec..20ad3d26bec2 100644
--- a/drivers/dma/dw_dmac.c
+++ b/drivers/dma/dw_dmac.c
@@ -1011,7 +1011,7 @@ static int __init dw_probe(struct platform_device *pdev)
         dma_writel(dw, CFG, DW_CFG_DMA_EN);
 
         printk(KERN_INFO "%s: DesignWare DMA Controller, %d channels\n",
-                        pdev->dev.bus_id, dw->dma.chancnt);
+                        dev_name(&pdev->dev), dw->dma.chancnt);
 
         dma_async_device_register(&dw->dma);
 
diff --git a/drivers/edac/cell_edac.c b/drivers/edac/cell_edac.c
index 24f3ca851523..cb0f639f049d 100644
--- a/drivers/edac/cell_edac.c
+++ b/drivers/edac/cell_edac.c
@@ -198,7 +198,7 @@ static int __devinit cell_edac_probe(struct platform_device *pdev)
         mci->edac_cap = EDAC_FLAG_EC | EDAC_FLAG_SECDED;
         mci->mod_name = "cell_edac";
         mci->ctl_name = "MIC";
-        mci->dev_name = pdev->dev.bus_id;
+        mci->dev_name = dev_name(&pdev->dev);
         mci->edac_check = cell_edac_check;
         cell_edac_init_csrows(mci);
 
diff --git a/drivers/edac/mpc85xx_edac.c b/drivers/edac/mpc85xx_edac.c
index 853ef37ec006..4637a4a757df 100644
--- a/drivers/edac/mpc85xx_edac.c
+++ b/drivers/edac/mpc85xx_edac.c
@@ -218,7 +218,7 @@ static int __devinit mpc85xx_pci_err_probe(struct of_device *op,
         pci->dev = &op->dev;
         pci->mod_name = EDAC_MOD_STR;
         pci->ctl_name = pdata->name;
-        pci->dev_name = op->dev.bus_id;
+        pci->dev_name = dev_name(&op->dev);
 
         if (edac_op_state == EDAC_OPSTATE_POLL)
                 pci->edac_check = mpc85xx_pci_check;
diff --git a/drivers/edac/mv64x60_edac.c b/drivers/edac/mv64x60_edac.c
index 083ce8d0c63d..5131aaae8e03 100644
--- a/drivers/edac/mv64x60_edac.c
+++ b/drivers/edac/mv64x60_edac.c
@@ -121,7 +121,7 @@ static int __devinit mv64x60_pci_err_probe(struct platform_device *pdev)
         pdata->irq = NO_IRQ;
         platform_set_drvdata(pdev, pci);
         pci->dev = &pdev->dev;
-        pci->dev_name = pdev->dev.bus_id;
+        pci->dev_name = dev_name(&pdev->dev);
         pci->mod_name = EDAC_MOD_STR;
         pci->ctl_name = pdata->name;
 
@@ -294,7 +294,7 @@ static int __devinit mv64x60_sram_err_probe(struct platform_device *pdev)
         pdata->irq = NO_IRQ;
         edac_dev->dev = &pdev->dev;
         platform_set_drvdata(pdev, edac_dev);
-        edac_dev->dev_name = pdev->dev.bus_id;
+        edac_dev->dev_name = dev_name(&pdev->dev);
 
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!r) {
@@ -462,7 +462,7 @@ static int __devinit mv64x60_cpu_err_probe(struct platform_device *pdev)
         pdata->irq = NO_IRQ;
         edac_dev->dev = &pdev->dev;
         platform_set_drvdata(pdev, edac_dev);
-        edac_dev->dev_name = pdev->dev.bus_id;
+        edac_dev->dev_name = dev_name(&pdev->dev);
 
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!r) {
@@ -713,7 +713,7 @@ static int __devinit mv64x60_mc_err_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, mci);
         pdata->name = "mv64x60_mc_err";
         pdata->irq = NO_IRQ;
-        mci->dev_name = pdev->dev.bus_id;
+        mci->dev_name = dev_name(&pdev->dev);
         pdata->edac_idx = edac_mc_idx++;
 
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
diff --git a/drivers/eisa/eisa-bus.c b/drivers/eisa/eisa-bus.c
index c950bf8606d9..66958b3f10b4 100644
--- a/drivers/eisa/eisa-bus.c
+++ b/drivers/eisa/eisa-bus.c
@@ -200,7 +200,7 @@ static int __init eisa_init_device (struct eisa_root_device *root,
         edev->dev.bus = &eisa_bus_type;
         edev->dev.dma_mask = &edev->dma_mask;
         edev->dev.coherent_dma_mask = edev->dma_mask;
-        sprintf (edev->dev.bus_id, "%02X:%02X", root->bus_nr, slot);
+        dev_set_name(&edev->dev, "%02X:%02X", root->bus_nr, slot);
 
         for (i = 0; i < EISA_MAX_RESOURCES; i++) {
 #ifdef CONFIG_EISA_NAMES
@@ -301,7 +301,7 @@ static int __init eisa_probe (struct eisa_root_device *root)
         struct eisa_device *edev;
 
         printk (KERN_INFO "EISA: Probing bus %d at %s\n",
-                root->bus_nr, root->dev->bus_id);
+                root->bus_nr, dev_name(root->dev));
 
         /* First try to get hold of slot 0. If there is no device
          * here, simply fail, unless root->force_probe is set. */
diff --git a/drivers/gpio/bt8xxgpio.c b/drivers/gpio/bt8xxgpio.c
index 7a1168249dd5..984b587f0f96 100644
--- a/drivers/gpio/bt8xxgpio.c
+++ b/drivers/gpio/bt8xxgpio.c
@@ -160,7 +160,7 @@ static void bt8xxgpio_gpio_setup(struct bt8xxgpio *bg)
 {
         struct gpio_chip *c = &bg->gpio;
 
-        c->label = bg->pdev->dev.bus_id;
+        c->label = dev_name(&bg->pdev->dev);
         c->owner = THIS_MODULE;
         c->direction_input = bt8xxgpio_gpio_direction_input;
         c->get = bt8xxgpio_gpio_get;
diff --git a/drivers/gpu/drm/drm_sysfs.c b/drivers/gpu/drm/drm_sysfs.c
index 5aa6780652aa..186d08159d48 100644
--- a/drivers/gpu/drm/drm_sysfs.c
+++ b/drivers/gpu/drm/drm_sysfs.c
@@ -359,8 +359,8 @@ int drm_sysfs_connector_add(struct drm_connector *connector)
         DRM_DEBUG("adding \"%s\" to sysfs\n",
                   drm_get_connector_name(connector));
 
-        snprintf(connector->kdev.bus_id, BUS_ID_SIZE, "card%d-%s",
-                 dev->primary->index, drm_get_connector_name(connector));
+        dev_set_name(&connector->kdev, "card%d-%s",
+                     dev->primary->index, drm_get_connector_name(connector));
         ret = device_register(&connector->kdev);
 
         if (ret) {
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index e7d984866de0..fbb9030b68a5 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -841,7 +841,7 @@ int i2c_attach_client(struct i2c_client *client)
 
         if (client->driver && !is_newstyle_driver(client->driver)) {
                 client->dev.release = i2c_client_release;
-                client->dev.uevent_suppress = 1;
+                dev_set_uevent_suppress(&client->dev, 1);
         } else
                 client->dev.release = i2c_client_dev_release;
 
diff --git a/drivers/ide/au1xxx-ide.c b/drivers/ide/au1xxx-ide.c
index 79a2dfed8eb7..154ec2cf734f 100644
--- a/drivers/ide/au1xxx-ide.c
+++ b/drivers/ide/au1xxx-ide.c
@@ -536,9 +536,8 @@ static const struct ide_port_info au1xxx_port_info = {
 #endif
 };
 
-static int au_ide_probe(struct device *dev)
+static int au_ide_probe(struct platform_device *dev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
         _auide_hwif *ahwif = &auide_hwif;
         struct resource *res;
         struct ide_host *host;
@@ -552,23 +551,23 @@ static int au_ide_probe(struct device *dev)
 #endif
 
         memset(&auide_hwif, 0, sizeof(_auide_hwif));
-        ahwif->irq = platform_get_irq(pdev, 0);
+        ahwif->irq = platform_get_irq(dev, 0);
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        res = platform_get_resource(dev, IORESOURCE_MEM, 0);
 
         if (res == NULL) {
-                pr_debug("%s %d: no base address\n", DRV_NAME, pdev->id);
+                pr_debug("%s %d: no base address\n", DRV_NAME, dev->id);
                 ret = -ENODEV;
                 goto out;
         }
         if (ahwif->irq < 0) {
-                pr_debug("%s %d: no IRQ\n", DRV_NAME, pdev->id);
+                pr_debug("%s %d: no IRQ\n", DRV_NAME, dev->id);
                 ret = -ENODEV;
                 goto out;
         }
 
         if (!request_mem_region(res->start, res->end - res->start + 1,
-                                pdev->name)) {
+                                dev->name)) {
                 pr_debug("%s: request_mem_region failed\n", DRV_NAME);
                 ret =  -EBUSY;
                 goto out;
@@ -583,7 +582,7 @@ static int au_ide_probe(struct device *dev)
         memset(&hw, 0, sizeof(hw));
         auide_setup_ports(&hw, ahwif);
         hw.irq = ahwif->irq;
-        hw.dev = dev;
+        hw.dev = &dev->dev;
         hw.chipset = ide_au1xxx;
 
         ret = ide_host_add(&au1xxx_port_info, hws, &host);
@@ -592,7 +591,7 @@ static int au_ide_probe(struct device *dev)
 
         auide_hwif.hwif = host->ports[0];
 
-        dev_set_drvdata(dev, host);
+        platform_set_drvdata(dev, host);
 
         printk(KERN_INFO "Au1xxx IDE(builtin) configured for %s\n", mode );
 
@@ -600,38 +599,39 @@ static int au_ide_probe(struct device *dev)
         return ret;
 }
 
-static int au_ide_remove(struct device *dev)
+static int au_ide_remove(struct platform_device *dev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
         struct resource *res;
-        struct ide_host *host = dev_get_drvdata(dev);
+        struct ide_host *host = platform_get_drvdata(dev);
         _auide_hwif *ahwif = &auide_hwif;
 
         ide_host_remove(host);
 
         iounmap((void *)ahwif->regbase);
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        res = platform_get_resource(dev, IORESOURCE_MEM, 0);
         release_mem_region(res->start, res->end - res->start + 1);
 
         return 0;
 }
 
-static struct device_driver au1200_ide_driver = {
-        .name           = "au1200-ide",
-        .bus            = &platform_bus_type,
+static struct platform_driver au1200_ide_driver = {
+        .driver = {
+                .name           = "au1200-ide",
+                .owner          = THIS_MODULE,
+        },
         .probe          = au_ide_probe,
         .remove         = au_ide_remove,
 };
 
 static int __init au_ide_init(void)
 {
-        return driver_register(&au1200_ide_driver);
+        return platform_driver_register(&au1200_ide_driver);
 }
 
 static void __exit au_ide_exit(void)
 {
-        driver_unregister(&au1200_ide_driver);
+        platform_driver_unregister(&au1200_ide_driver);
 }
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/isdn/gigaset/ser-gigaset.c b/drivers/isdn/gigaset/ser-gigaset.c
index ac245e7e96a5..3071a52467ed 100644
--- a/drivers/isdn/gigaset/ser-gigaset.c
+++ b/drivers/isdn/gigaset/ser-gigaset.c
@@ -389,8 +389,7 @@ static void gigaset_freecshw(struct cardstate *cs)
 
 static void gigaset_device_release(struct device *dev)
 {
-        struct platform_device *pdev =
-                container_of(dev, struct platform_device, dev);
+        struct platform_device *pdev = to_platform_device(dev);
 
         /* adapted from platform_device_release() in drivers/base/platform.c */
         //FIXME is this actually necessary?
diff --git a/drivers/mca/mca-bus.c b/drivers/mca/mca-bus.c
index ef2dbfe74714..ada5ebbaa255 100644
--- a/drivers/mca/mca-bus.c
+++ b/drivers/mca/mca-bus.c
@@ -110,7 +110,7 @@ int __init mca_register_device(int bus, struct mca_device *mca_dev)
 
         mca_dev->dev.parent = &mca_bus->dev;
         mca_dev->dev.bus = &mca_bus_type;
-        sprintf (mca_dev->dev.bus_id, "%02d:%02X", bus, mca_dev->slot);
+        dev_set_name(&mca_dev->dev, "%02d:%02X", bus, mca_dev->slot);
         mca_dev->dma_mask = mca_bus->default_dma_mask;
         mca_dev->dev.dma_mask = &mca_dev->dma_mask;
         mca_dev->dev.coherent_dma_mask = mca_dev->dma_mask;
@@ -151,7 +151,7 @@ struct mca_bus * __devinit mca_attach_bus(int bus)
         if (!mca_bus)
                 return NULL;
 
-        sprintf(mca_bus->dev.bus_id,"mca%d",bus);
+        dev_set_name(&mca_bus->dev, "mca%d", bus);
         sprintf(mca_bus->name,"Host %s MCA Bridge", bus ? "Secondary" : "Primary");
         if (device_register(&mca_bus->dev)) {
                 kfree(mca_bus);
diff --git a/drivers/media/radio/radio-tea5764.c b/drivers/media/radio/radio-tea5764.c
index 4d35308fc1ff..393623818ade 100644
--- a/drivers/media/radio/radio-tea5764.c
+++ b/drivers/media/radio/radio-tea5764.c
@@ -298,7 +298,8 @@ static int vidioc_querycap(struct file *file, void  *priv,
 
         strlcpy(v->driver, dev->dev.driver->name, sizeof(v->driver));
         strlcpy(v->card, dev->name, sizeof(v->card));
-        snprintf(v->bus_info, sizeof(v->bus_info), "I2C:%s", dev->dev.bus_id);
+        snprintf(v->bus_info, sizeof(v->bus_info),
+                 "I2C:%s", dev_name(&dev->dev));
         v->version = RADIO_VERSION;
         v->capabilities = V4L2_CAP_TUNER | V4L2_CAP_RADIO;
         return 0;
diff --git a/drivers/media/video/v4l2-device.c b/drivers/media/video/v4l2-device.c
index cf9d4c7f571a..8a4b74f3129f 100644
--- a/drivers/media/video/v4l2-device.c
+++ b/drivers/media/video/v4l2-device.c
@@ -34,7 +34,7 @@ int v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev)
         spin_lock_init(&v4l2_dev->lock);
         v4l2_dev->dev = dev;
         snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s %s",
-                        dev->driver->name, dev->bus_id);
+                        dev->driver->name, dev_name(dev));
         dev_set_drvdata(dev, v4l2_dev);
         return 0;
 }
diff --git a/drivers/mfd/mcp-core.c b/drivers/mfd/mcp-core.c
index 6063dc2b52e8..57271cb3b316 100644
--- a/drivers/mfd/mcp-core.c
+++ b/drivers/mfd/mcp-core.c
@@ -214,7 +214,7 @@ EXPORT_SYMBOL(mcp_host_alloc);
 
 int mcp_host_register(struct mcp *mcp)
 {
-        strcpy(mcp->attached_device.bus_id, "mcp0");
+        dev_set_name(&mcp->attached_device, "mcp0");
         return device_register(&mcp->attached_device);
 }
 EXPORT_SYMBOL(mcp_host_register);
diff --git a/drivers/mfd/ucb1x00-core.c b/drivers/mfd/ucb1x00-core.c
index 6860c924f364..fea9085fe52c 100644
--- a/drivers/mfd/ucb1x00-core.c
+++ b/drivers/mfd/ucb1x00-core.c
@@ -492,7 +492,7 @@ static int ucb1x00_probe(struct mcp *mcp)
 
         ucb->dev.class = &ucb1x00_class;
         ucb->dev.parent = &mcp->attached_device;
-        strlcpy(ucb->dev.bus_id, "ucb1x00", sizeof(ucb->dev.bus_id));
+        dev_set_name(&ucb->dev, "ucb1x00");
 
         spin_lock_init(&ucb->lock);
         spin_lock_init(&ucb->io_lock);
diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index 2b1196e6142c..e94e92001e7c 100644
--- a/drivers/mmc/host/atmel-mci.c
+++ b/drivers/mmc/host/atmel-mci.c
@@ -1603,7 +1603,7 @@ static int __init atmci_probe(struct platform_device *pdev)
 
         tasklet_init(&host->tasklet, atmci_tasklet_func, (unsigned long)host);
 
-        ret = request_irq(irq, atmci_interrupt, 0, pdev->dev.bus_id, host);
+        ret = request_irq(irq, atmci_interrupt, 0, dev_name(&pdev->dev), host);
         if (ret)
                 goto err_request_irq;
 
diff --git a/drivers/mmc/host/of_mmc_spi.c b/drivers/mmc/host/of_mmc_spi.c
index fb2921f8099d..0c44d560bf1a 100644
--- a/drivers/mmc/host/of_mmc_spi.c
+++ b/drivers/mmc/host/of_mmc_spi.c
@@ -103,7 +103,7 @@ struct mmc_spi_platform_data *mmc_spi_get_pdata(struct spi_device *spi)
                 if (!gpio_is_valid(oms->gpios[i]))
                         continue;
 
-                ret = gpio_request(oms->gpios[i], dev->bus_id);
+                ret = gpio_request(oms->gpios[i], dev_name(dev));
                 if (ret < 0) {
                         oms->gpios[i] = -EINVAL;
                         continue;
diff --git a/drivers/mtd/maps/pxa2xx-flash.c b/drivers/mtd/maps/pxa2xx-flash.c
index 771139c5bf87..e9026cb1c5b2 100644
--- a/drivers/mtd/maps/pxa2xx-flash.c
+++ b/drivers/mtd/maps/pxa2xx-flash.c
@@ -41,9 +41,8 @@ struct pxa2xx_flash_info {
 static const char *probes[] = { "RedBoot", "cmdlinepart", NULL };
 
 
-static int __init pxa2xx_flash_probe(struct device *dev)
+static int __init pxa2xx_flash_probe(struct platform_device *pdev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
         struct flash_platform_data *flash = pdev->dev.platform_data;
         struct pxa2xx_flash_info *info;
         struct mtd_partition *parts;
@@ -114,15 +113,15 @@ static int __init pxa2xx_flash_probe(struct device *dev)
                 add_mtd_device(info->mtd);
         }
 
-        dev_set_drvdata(dev, info);
+        platform_set_drvdata(pdev, info);
         return 0;
 }
 
-static int __exit pxa2xx_flash_remove(struct device *dev)
+static int __exit pxa2xx_flash_remove(struct platform_device *dev)
 {
-        struct pxa2xx_flash_info *info = dev_get_drvdata(dev);
+        struct pxa2xx_flash_info *info = platform_get_drvdata(dev);
 
-        dev_set_drvdata(dev, NULL);
+        platform_set_drvdata(dev, NULL);
 
 #ifdef CONFIG_MTD_PARTITIONS
         if (info->nr_parts)
@@ -141,9 +140,9 @@ static int __exit pxa2xx_flash_remove(struct device *dev)
 }
 
 #ifdef CONFIG_PM
-static int pxa2xx_flash_suspend(struct device *dev, pm_message_t state)
+static int pxa2xx_flash_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct pxa2xx_flash_info *info = dev_get_drvdata(dev);
+        struct pxa2xx_flash_info *info = platform_get_drvdata(dev);
         int ret = 0;
 
         if (info->mtd && info->mtd->suspend)
@@ -151,17 +150,17 @@ static int pxa2xx_flash_suspend(struct device *dev, pm_message_t state)
         return ret;
 }
 
-static int pxa2xx_flash_resume(struct device *dev)
+static int pxa2xx_flash_resume(struct platform_device *dev)
 {
-        struct pxa2xx_flash_info *info = dev_get_drvdata(dev);
+        struct pxa2xx_flash_info *info = platform_get_drvdata(dev);
 
         if (info->mtd && info->mtd->resume)
                 info->mtd->resume(info->mtd);
         return 0;
 }
-static void pxa2xx_flash_shutdown(struct device *dev)
+static void pxa2xx_flash_shutdown(struct platform_device *dev)
 {
-        struct pxa2xx_flash_info *info = dev_get_drvdata(dev);
+        struct pxa2xx_flash_info *info = platform_get_drvdata(dev);
 
         if (info && info->mtd->suspend(info->mtd) == 0)
                 info->mtd->resume(info->mtd);
@@ -172,11 +171,13 @@ static void pxa2xx_flash_shutdown(struct device *dev)
 #define pxa2xx_flash_shutdown NULL
 #endif
 
-static struct device_driver pxa2xx_flash_driver = {
-        .name           = "pxa2xx-flash",
-        .bus            = &platform_bus_type,
+static struct platform_driver pxa2xx_flash_driver = {
+        .driver = {
+                .name           = "pxa2xx-flash",
+                .owner          = THIS_MODULE,
+        },
         .probe          = pxa2xx_flash_probe,
-        .remove         = __exit_p(pxa2xx_flash_remove),
+        .remove         = __devexit_p(pxa2xx_flash_remove),
         .suspend        = pxa2xx_flash_suspend,
         .resume         = pxa2xx_flash_resume,
         .shutdown       = pxa2xx_flash_shutdown,
@@ -184,12 +185,12 @@ static struct device_driver pxa2xx_flash_driver = {
 
 static int __init init_pxa2xx_flash(void)
 {
-        return driver_register(&pxa2xx_flash_driver);
+        return platform_driver_register(&pxa2xx_flash_driver);
 }
 
 static void __exit cleanup_pxa2xx_flash(void)
 {
-        driver_unregister(&pxa2xx_flash_driver);
+        platform_driver_unregister(&pxa2xx_flash_driver);
 }
 
 module_init(init_pxa2xx_flash);
diff --git a/drivers/mtd/nand/excite_nandflash.c b/drivers/mtd/nand/excite_nandflash.c
index ced14b5294d5..72446fb48d4b 100644
--- a/drivers/mtd/nand/excite_nandflash.c
+++ b/drivers/mtd/nand/excite_nandflash.c
@@ -128,11 +128,11 @@ static int excite_nand_devready(struct mtd_info *mtd)
  * The binding to the mtd and all allocated
  * resources are released.
  */
-static int __exit excite_nand_remove(struct device *dev)
+static int __exit excite_nand_remove(struct platform_device *dev)
 {
-        struct excite_nand_drvdata * const this = dev_get_drvdata(dev);
+        struct excite_nand_drvdata * const this = platform_get_drvdata(dev);
 
-        dev_set_drvdata(dev, NULL);
+        platform_set_drvdata(dev, NULL);
 
         if (unlikely(!this)) {
                 printk(KERN_ERR "%s: called %s without private data!!",
@@ -159,9 +159,8 @@ static int __exit excite_nand_remove(struct device *dev)
  * it can allocate all necessary resources then calls the
  * nand layer to look for devices.
 */
-static int __init excite_nand_probe(struct device *dev)
+static int __init excite_nand_probe(struct platform_device *pdev)
 {
-        struct platform_device * const pdev = to_platform_device(dev);
         struct excite_nand_drvdata *drvdata;    /* private driver data */
         struct nand_chip *board_chip;   /* private flash chip data */
         struct mtd_info *board_mtd;     /* mtd info for this board */
@@ -175,7 +174,7 @@ static int __init excite_nand_probe(struct device *dev)
         }
 
         /* bind private data into driver */
-        dev_set_drvdata(dev, drvdata);
+        platform_set_drvdata(pdev, drvdata);
 
         /* allocate and map the resource */
         drvdata->regs =
@@ -219,23 +218,25 @@ static int __init excite_nand_probe(struct device *dev)
         return 0;
 }
 
-static struct device_driver excite_nand_driver = {
-        .name = "excite_nand",
-        .bus = &platform_bus_type,
+static struct platform_driver excite_nand_driver = {
+        .driver = {
+                .name = "excite_nand",
+                .owner          = THIS_MODULE,
+        },
         .probe = excite_nand_probe,
-        .remove = __exit_p(excite_nand_remove)
+        .remove = __devexit_p(excite_nand_remove)
 };
 
 static int __init excite_nand_init(void)
 {
         pr_info("Basler eXcite nand flash driver Version "
                 EXCITE_NANDFLASH_VERSION "\n");
-        return driver_register(&excite_nand_driver);
+        return platform_driver_register(&excite_nand_driver);
 }
 
 static void __exit excite_nand_exit(void)
 {
-        driver_unregister(&excite_nand_driver);
+        platform_driver_unregister(&excite_nand_driver);
 }
 
 module_init(excite_nand_init);
diff --git a/drivers/mtd/nand/ndfc.c b/drivers/mtd/nand/ndfc.c
index 582cf80f555a..89bf85af642c 100644
--- a/drivers/mtd/nand/ndfc.c
+++ b/drivers/mtd/nand/ndfc.c
@@ -187,7 +187,7 @@ static int ndfc_chip_init(struct ndfc_controller *ndfc,
                 return -ENODEV;
 
         ndfc->mtd.name = kasprintf(GFP_KERNEL, "%s.%s",
-                                   ndfc->ofdev->dev.bus_id, flash_np->name);
+                        dev_name(&ndfc->ofdev->dev), flash_np->name);
         if (!ndfc->mtd.name) {
                 ret = -ENOMEM;
                 goto err;
diff --git a/drivers/mtd/onenand/generic.c b/drivers/mtd/onenand/generic.c
index 5b69e7773c6c..3a496c33fb52 100644
--- a/drivers/mtd/onenand/generic.c
+++ b/drivers/mtd/onenand/generic.c
@@ -36,10 +36,9 @@ struct onenand_info {
         struct onenand_chip     onenand;
 };
 
-static int __devinit generic_onenand_probe(struct device *dev)
+static int __devinit generic_onenand_probe(struct platform_device *pdev)
 {
         struct onenand_info *info;
-        struct platform_device *pdev = to_platform_device(dev);
         struct flash_platform_data *pdata = pdev->dev.platform_data;
         struct resource *res = pdev->resource;
         unsigned long size = res->end - res->start + 1;
@@ -49,7 +48,7 @@ static int __devinit generic_onenand_probe(struct device *dev)
         if (!info)
                 return -ENOMEM;
 
-        if (!request_mem_region(res->start, size, dev->driver->name)) {
+        if (!request_mem_region(res->start, size, pdev->dev.driver->name)) {
                 err = -EBUSY;
                 goto out_free_info;
         }
@@ -82,7 +81,7 @@ static int __devinit generic_onenand_probe(struct device *dev)
 #endif
                 err = add_mtd_device(&info->mtd);
 
-        dev_set_drvdata(&pdev->dev, info);
+        platform_set_drvdata(pdev, info);
 
         return 0;
 
@@ -96,14 +95,13 @@ out_free_info:
         return err;
 }
 
-static int __devexit generic_onenand_remove(struct device *dev)
+static int __devexit generic_onenand_remove(struct platform_device *pdev)
 {
-        struct platform_device *pdev = to_platform_device(dev);
-        struct onenand_info *info = dev_get_drvdata(&pdev->dev);
+        struct onenand_info *info = platform_get_drvdata(pdev);
         struct resource *res = pdev->resource;
         unsigned long size = res->end - res->start + 1;
 
-        dev_set_drvdata(&pdev->dev, NULL);
+        platform_set_drvdata(pdev, NULL);
 
         if (info) {
                 if (info->parts)
@@ -120,9 +118,11 @@ static int __devexit generic_onenand_remove(struct device *dev)
         return 0;
 }
 
-static struct device_driver generic_onenand_driver = {
-        .name           = DRIVER_NAME,
-        .bus            = &platform_bus_type,
+static struct platform_driver generic_onenand_driver = {
+        .driver = {
+                .name           = DRIVER_NAME,
+                .owner          = THIS_MODULE,
+        },
         .probe          = generic_onenand_probe,
         .remove         = __devexit_p(generic_onenand_remove),
 };
@@ -131,12 +131,12 @@ MODULE_ALIAS(DRIVER_NAME);
 
 static int __init generic_onenand_init(void)
 {
-        return driver_register(&generic_onenand_driver);
+        return platform_driver_register(&generic_onenand_driver);
 }
 
 static void __exit generic_onenand_exit(void)
 {
-        driver_unregister(&generic_onenand_driver);
+        platform_driver_unregister(&generic_onenand_driver);
 }
 
 module_init(generic_onenand_init);
diff --git a/drivers/net/arm/ks8695net.c b/drivers/net/arm/ks8695net.c
index f3a127434897..35cd264abae7 100644
--- a/drivers/net/arm/ks8695net.c
+++ b/drivers/net/arm/ks8695net.c
@@ -1059,7 +1059,7 @@ ks8695_get_drvinfo(struct net_device *ndev, struct ethtool_drvinfo *info)
 {
         strlcpy(info->driver, MODULENAME, sizeof(info->driver));
         strlcpy(info->version, MODULEVERSION, sizeof(info->version));
-        strlcpy(info->bus_info, ndev->dev.parent->bus_id,
+        strlcpy(info->bus_info, dev_name(ndev->dev.parent),
                 sizeof(info->bus_info));
 }
 
diff --git a/drivers/net/au1000_eth.c b/drivers/net/au1000_eth.c
index 9c875bb3f76c..79aec32c6add 100644
--- a/drivers/net/au1000_eth.c
+++ b/drivers/net/au1000_eth.c
@@ -355,8 +355,8 @@ static int mii_probe (struct net_device *dev)
         /* now we are supposed to have a proper phydev, to attach to... */
         BUG_ON(phydev->attached_dev);
 
-        phydev = phy_connect(dev, phydev->dev.bus_id, &au1000_adjust_link, 0,
-                        PHY_INTERFACE_MODE_MII);
+        phydev = phy_connect(dev, dev_name(&phydev->dev), &au1000_adjust_link,
+                        0, PHY_INTERFACE_MODE_MII);
 
         if (IS_ERR(phydev)) {
                 printk(KERN_ERR "%s: Could not attach to PHY\n", dev->name);
@@ -381,8 +381,8 @@ static int mii_probe (struct net_device *dev)
         aup->phy_dev = phydev;
 
         printk(KERN_INFO "%s: attached PHY driver [%s] "
-               "(mii_bus:phy_addr=%s, irq=%d)\n",
-               dev->name, phydev->drv->name, phydev->dev.bus_id, phydev->irq);
+               "(mii_bus:phy_addr=%s, irq=%d)\n", dev->name,
+               phydev->drv->name, dev_name(&phydev->dev), phydev->irq);
 
         return 0;
 }
diff --git a/drivers/net/bfin_mac.c b/drivers/net/bfin_mac.c
index 78e31aa861e0..9afe8092dfc4 100644
--- a/drivers/net/bfin_mac.c
+++ b/drivers/net/bfin_mac.c
@@ -415,11 +415,11 @@ static int mii_probe(struct net_device *dev)
         }
 
 #if defined(CONFIG_BFIN_MAC_RMII)
-        phydev = phy_connect(dev, phydev->dev.bus_id, &bfin_mac_adjust_link, 0,
-                        PHY_INTERFACE_MODE_RMII);
+        phydev = phy_connect(dev, dev_name(&phydev->dev), &bfin_mac_adjust_link,
+                        0, PHY_INTERFACE_MODE_RMII);
 #else
-        phydev = phy_connect(dev, phydev->dev.bus_id, &bfin_mac_adjust_link, 0,
-                        PHY_INTERFACE_MODE_MII);
+        phydev = phy_connect(dev, dev_name(&phydev->dev), &bfin_mac_adjust_link,
+                        0, PHY_INTERFACE_MODE_MII);
 #endif
 
         if (IS_ERR(phydev)) {
@@ -447,7 +447,7 @@ static int mii_probe(struct net_device *dev)
         printk(KERN_INFO "%s: attached PHY driver [%s] "
                "(mii_bus:phy_addr=%s, irq=%d, mdc_clk=%dHz(mdc_div=%d)"
                "@sclk=%dMHz)\n",
-               DRV_NAME, phydev->drv->name, phydev->dev.bus_id, phydev->irq,
+               DRV_NAME, phydev->drv->name, dev_name(&phydev->dev), phydev->irq,
                MDC_CLK, mdc_div, sclk/1000000);
 
         return 0;
@@ -488,7 +488,7 @@ static void bfin_mac_ethtool_getdrvinfo(struct net_device *dev,
         strcpy(info->driver, DRV_NAME);
         strcpy(info->version, DRV_VERSION);
         strcpy(info->fw_version, "N/A");
-        strcpy(info->bus_info, dev->dev.bus_id);
+        strcpy(info->bus_info, dev_name(&dev->dev));
 }
 
 static struct ethtool_ops bfin_mac_ethtool_ops = {
diff --git a/drivers/net/bmac.c b/drivers/net/bmac.c
index 8a546a33d581..1ab58375d061 100644
--- a/drivers/net/bmac.c
+++ b/drivers/net/bmac.c
@@ -1240,7 +1240,7 @@ static void bmac_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *inf
 {
         struct bmac_data *bp = netdev_priv(dev);
         strcpy(info->driver, "bmac");
-        strcpy(info->bus_info, bp->mdev->ofdev.dev.bus_id);
+        strcpy(info->bus_info, dev_name(&bp->mdev->ofdev.dev));
 }
 
 static const struct ethtool_ops bmac_ethtool_ops = {
diff --git a/drivers/net/cpmac.c b/drivers/net/cpmac.c
index f66548751c38..79741c5f9fe7 100644
--- a/drivers/net/cpmac.c
+++ b/drivers/net/cpmac.c
@@ -1161,7 +1161,7 @@ static int __devinit cpmac_probe(struct platform_device *pdev)
         priv->msg_enable = netif_msg_init(debug_level, 0xff);
         memcpy(dev->dev_addr, pdata->dev_addr, sizeof(dev->dev_addr));
 
-        priv->phy = phy_connect(dev, cpmac_mii->phy_map[phy_id]->dev.bus_id,
+        priv->phy = phy_connect(dev, dev_name(&cpmac_mii->phy_map[phy_id]->dev),
                                 &cpmac_adjust_link, 0, PHY_INTERFACE_MODE_MII);
         if (IS_ERR(priv->phy)) {
                 if (netif_msg_drv(priv))
diff --git a/drivers/net/declance.c b/drivers/net/declance.c
index 7ce3053530f9..861c867fca87 100644
--- a/drivers/net/declance.c
+++ b/drivers/net/declance.c
@@ -1027,7 +1027,7 @@ static int __init dec_lance_probe(struct device *bdev, const int type)
                 printk(version);
 
         if (bdev)
-                snprintf(name, sizeof(name), "%s", bdev->bus_id);
+                snprintf(name, sizeof(name), "%s", dev_name(bdev));
         else {
                 i = 0;
                 dev = root_lance_dev;
@@ -1105,10 +1105,10 @@ static int __init dec_lance_probe(struct device *bdev, const int type)
 
                 start = to_tc_dev(bdev)->resource.start;
                 len = to_tc_dev(bdev)->resource.end - start + 1;
-                if (!request_mem_region(start, len, bdev->bus_id)) {
+                if (!request_mem_region(start, len, dev_name(bdev))) {
                         printk(KERN_ERR
                                "%s: Unable to reserve MMIO resource\n",
-                               bdev->bus_id);
+                               dev_name(bdev));
                         ret = -EBUSY;
                         goto err_out_dev;
                 }
diff --git a/drivers/net/depca.c b/drivers/net/depca.c
index e4cef491dc73..55625dbbae5a 100644
--- a/drivers/net/depca.c
+++ b/drivers/net/depca.c
@@ -606,8 +606,8 @@ static int __init depca_hw_init (struct net_device *dev, struct device *device)
         if (!mem_start || lp->adapter < DEPCA || lp->adapter >=unknown)
                 return -ENXIO;
 
-        printk ("%s: %s at 0x%04lx",
-                device->bus_id, depca_signature[lp->adapter], ioaddr);
+        printk("%s: %s at 0x%04lx",
+               dev_name(device), depca_signature[lp->adapter], ioaddr);
 
         switch (lp->depca_bus) {
 #ifdef CONFIG_MCA
@@ -669,7 +669,7 @@ static int __init depca_hw_init (struct net_device *dev, struct device *device)
 
         spin_lock_init(&lp->lock);
         sprintf(lp->adapter_name, "%s (%s)",
-                depca_signature[lp->adapter], device->bus_id);
+                depca_signature[lp->adapter], dev_name(device));
         status = -EBUSY;
 
         /* Initialisation Block */
diff --git a/drivers/net/ehea/ehea_main.c b/drivers/net/ehea/ehea_main.c
index dfe92264e825..8e7c16535ad7 100644
--- a/drivers/net/ehea/ehea_main.c
+++ b/drivers/net/ehea/ehea_main.c
@@ -3040,7 +3040,7 @@ static struct device *ehea_register_port(struct ehea_port *port,
         port->ofdev.dev.parent = &port->adapter->ofdev->dev;
         port->ofdev.dev.bus = &ibmebus_bus_type;
 
-        sprintf(port->ofdev.dev.bus_id, "port%d", port_name_cnt++);
+        dev_set_name(&port->ofdev.dev, "port%d", port_name_cnt++);
         port->ofdev.dev.release = logical_port_release;
 
         ret = of_device_register(&port->ofdev);
diff --git a/drivers/net/jazzsonic.c b/drivers/net/jazzsonic.c
index 334ff9e12cdd..14248cfc3dfd 100644
--- a/drivers/net/jazzsonic.c
+++ b/drivers/net/jazzsonic.c
@@ -131,7 +131,8 @@ static int __init sonic_probe1(struct net_device *dev)
         if (sonic_debug  &&  version_printed++ == 0)
                 printk(version);
 
-        printk(KERN_INFO "%s: Sonic ethernet found at 0x%08lx, ", lp->device->bus_id, dev->base_addr);
+        printk(KERN_INFO "%s: Sonic ethernet found at 0x%08lx, ",
+               dev_name(lp->device), dev->base_addr);
 
         /*
          * Put the sonic into software reset, then
@@ -156,7 +157,8 @@ static int __init sonic_probe1(struct net_device *dev)
         if ((lp->descriptors = dma_alloc_coherent(lp->device,
                                 SIZEOF_SONIC_DESC * SONIC_BUS_SCALE(lp->dma_bitmode),
                                 &lp->descriptors_laddr, GFP_KERNEL)) == NULL) {
-                printk(KERN_ERR "%s: couldn't alloc DMA memory for descriptors.\n", lp->device->bus_id);
+                printk(KERN_ERR "%s: couldn't alloc DMA memory for descriptors.\n",
+                       dev_name(lp->device));
                 goto out;
         }
 
diff --git a/drivers/net/macb.c b/drivers/net/macb.c
index f6c4936e2fa8..f4086542c358 100644
--- a/drivers/net/macb.c
+++ b/drivers/net/macb.c
@@ -211,10 +211,10 @@ static int macb_mii_probe(struct net_device *dev)
 
         /* attach the mac to the phy */
         if (pdata && pdata->is_rmii) {
-                phydev = phy_connect(dev, phydev->dev.bus_id,
+                phydev = phy_connect(dev, dev_name(&phydev->dev),
                         &macb_handle_link_change, 0, PHY_INTERFACE_MODE_RMII);
         } else {
-                phydev = phy_connect(dev, phydev->dev.bus_id,
+                phydev = phy_connect(dev, dev_name(&phydev->dev),
                         &macb_handle_link_change, 0, PHY_INTERFACE_MODE_MII);
         }
 
@@ -1077,7 +1077,7 @@ static void macb_get_drvinfo(struct net_device *dev,
 
         strcpy(info->driver, bp->pdev->dev.driver->name);
         strcpy(info->version, "$Revision: 1.14 $");
-        strcpy(info->bus_info, bp->pdev->dev.bus_id);
+        strcpy(info->bus_info, dev_name(&bp->pdev->dev));
 }
 
 static struct ethtool_ops macb_ethtool_ops = {
@@ -1234,8 +1234,8 @@ static int __init macb_probe(struct platform_device *pdev)
 
         phydev = bp->phy_dev;
         printk(KERN_INFO "%s: attached PHY driver [%s] "
-                "(mii_bus:phy_addr=%s, irq=%d)\n",
-                dev->name, phydev->drv->name, phydev->dev.bus_id, phydev->irq);
+                "(mii_bus:phy_addr=%s, irq=%d)\n", dev->name,
+                phydev->drv->name, dev_name(&phydev->dev), phydev->irq);
 
         return 0;
 
diff --git a/drivers/net/macsonic.c b/drivers/net/macsonic.c
index 205bb05c25d6..527166e35d56 100644
--- a/drivers/net/macsonic.c
+++ b/drivers/net/macsonic.c
@@ -176,7 +176,8 @@ static int __init macsonic_init(struct net_device *dev)
         if ((lp->descriptors = dma_alloc_coherent(lp->device,
                     SIZEOF_SONIC_DESC * SONIC_BUS_SCALE(lp->dma_bitmode),
                     &lp->descriptors_laddr, GFP_KERNEL)) == NULL) {
-                printk(KERN_ERR "%s: couldn't alloc DMA memory for descriptors.\n", lp->device->bus_id);
+                printk(KERN_ERR "%s: couldn't alloc DMA memory for descriptors.\n",
+                       dev_name(lp->device));
                 return -ENOMEM;
         }
 
@@ -337,7 +338,7 @@ static int __init mac_onboard_sonic_probe(struct net_device *dev)
                 sonic_version_printed = 1;
         }
         printk(KERN_INFO "%s: onboard / comm-slot SONIC at 0x%08lx\n",
-               lp->device->bus_id, dev->base_addr);
+               dev_name(lp->device), dev->base_addr);
 
         /* The PowerBook's SONIC is 16 bit always. */
         if (macintosh_config->ident == MAC_MODEL_PB520) {
@@ -370,10 +371,10 @@ static int __init mac_onboard_sonic_probe(struct net_device *dev)
         }
         printk(KERN_INFO
                "%s: revision 0x%04x, using %d bit DMA and register offset %d\n",
-               lp->device->bus_id, sr, lp->dma_bitmode?32:16, lp->reg_offset);
+               dev_name(lp->device), sr, lp->dma_bitmode?32:16, lp->reg_offset);
 
 #if 0 /* This is sometimes useful to find out how MacOS configured the card. */
-        printk(KERN_INFO "%s: DCR: 0x%04x, DCR2: 0x%04x\n", lp->device->bus_id,
+        printk(KERN_INFO "%s: DCR: 0x%04x, DCR2: 0x%04x\n", dev_name(lp->device),
                SONIC_READ(SONIC_DCR) & 0xffff, SONIC_READ(SONIC_DCR2) & 0xffff);
 #endif
 
@@ -525,12 +526,12 @@ static int __init mac_nubus_sonic_probe(struct net_device *dev)
                 sonic_version_printed = 1;
         }
         printk(KERN_INFO "%s: %s in slot %X\n",
-               lp->device->bus_id, ndev->board->name, ndev->board->slot);
+               dev_name(lp->device), ndev->board->name, ndev->board->slot);
         printk(KERN_INFO "%s: revision 0x%04x, using %d bit DMA and register offset %d\n",
-               lp->device->bus_id, SONIC_READ(SONIC_SR), dma_bitmode?32:16, reg_offset);
+               dev_name(lp->device), SONIC_READ(SONIC_SR), dma_bitmode?32:16, reg_offset);
 
 #if 0 /* This is sometimes useful to find out how MacOS configured the card. */
-        printk(KERN_INFO "%s: DCR: 0x%04x, DCR2: 0x%04x\n", lp->device->bus_id,
+        printk(KERN_INFO "%s: DCR: 0x%04x, DCR2: 0x%04x\n", dev_name(lp->device),
                SONIC_READ(SONIC_DCR) & 0xffff, SONIC_READ(SONIC_DCR2) & 0xffff);
 #endif
 
diff --git a/drivers/net/mipsnet.c b/drivers/net/mipsnet.c
index 4e7a5faf0351..664835b822fb 100644
--- a/drivers/net/mipsnet.c
+++ b/drivers/net/mipsnet.c
@@ -237,7 +237,7 @@ static void mipsnet_set_mclist(struct net_device *dev)
 {
 }
 
-static int __init mipsnet_probe(struct device *dev)
+static int __init mipsnet_probe(struct platform_device *dev)
 {
         struct net_device *netdev;
         int err;
@@ -248,7 +248,7 @@ static int __init mipsnet_probe(struct device *dev)
                 goto out;
         }
 
-        dev_set_drvdata(dev, netdev);
+        platform_set_drvdata(dev, netdev);
 
         netdev->open                    = mipsnet_open;
         netdev->stop                    = mipsnet_close;
@@ -293,23 +293,25 @@ out:
         return err;
 }
 
-static int __devexit mipsnet_device_remove(struct device *device)
+static int __devexit mipsnet_device_remove(struct platform_device *device)
 {
-        struct net_device *dev = dev_get_drvdata(device);
+        struct net_device *dev = platform_get_drvdata(device);
 
         unregister_netdev(dev);
         release_region(dev->base_addr, sizeof(struct mipsnet_regs));
         free_netdev(dev);
-        dev_set_drvdata(device, NULL);
+        platform_set_drvdata(device, NULL);
 
         return 0;
 }
 
-static struct device_driver mipsnet_driver = {
-        .name   = mipsnet_string,
-        .bus    = &platform_bus_type,
-        .probe  = mipsnet_probe,
-        .remove = __devexit_p(mipsnet_device_remove),
+static struct platform_driver mipsnet_driver = {
+        .driver = {
+                .name           = mipsnet_string,
+                .owner          = THIS_MODULE,
+        },
+        .probe          = mipsnet_probe,
+        .remove         = __devexit_p(mipsnet_device_remove),
 };
 
 static int __init mipsnet_init_module(void)
@@ -319,7 +321,7 @@ static int __init mipsnet_init_module(void)
         printk(KERN_INFO "MIPSNet Ethernet driver. Version: %s. "
                "(c)2005 MIPS Technologies, Inc.\n", MIPSNET_VERSION);
 
-        err = driver_register(&mipsnet_driver);
+        err = platform_driver_register(&mipsnet_driver);
         if (err)
                 printk(KERN_ERR "Driver registration failed\n");
 
@@ -328,7 +330,7 @@ static int __init mipsnet_init_module(void)
 
 static void __exit mipsnet_exit_module(void)
 {
-        driver_unregister(&mipsnet_driver);
+        platform_driver_unregister(&mipsnet_driver);
 }
 
 module_init(mipsnet_init_module);
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index b0bc3bc18e9c..fe4e158c893d 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -2588,7 +2588,7 @@ static void phy_init(struct mv643xx_eth_private *mp, int speed, int duplex)
 
         phy_reset(mp);
 
-        phy_attach(mp->dev, phy->dev.bus_id, 0, PHY_INTERFACE_MODE_GMII);
+        phy_attach(mp->dev, dev_name(&phy->dev), 0, PHY_INTERFACE_MODE_GMII);
 
         if (speed == 0) {
                 phy->autoneg = AUTONEG_ENABLE;
diff --git a/drivers/net/sb1250-mac.c b/drivers/net/sb1250-mac.c
index 31e38fae017f..845431c186ac 100644
--- a/drivers/net/sb1250-mac.c
+++ b/drivers/net/sb1250-mac.c
@@ -2478,7 +2478,7 @@ static int sbmac_mii_probe(struct net_device *dev)
                 return -ENXIO;
         }
 
-        phy_dev = phy_connect(dev, phy_dev->dev.bus_id, &sbmac_mii_poll, 0,
+        phy_dev = phy_connect(dev, dev_name(&phy_dev->dev), &sbmac_mii_poll, 0,
                               PHY_INTERFACE_MODE_GMII);
         if (IS_ERR(phy_dev)) {
                 printk(KERN_ERR "%s: could not attach to PHY\n", dev->name);
@@ -2500,7 +2500,7 @@ static int sbmac_mii_probe(struct net_device *dev)
 
         pr_info("%s: attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
                 dev->name, phy_dev->drv->name,
-                phy_dev->dev.bus_id, phy_dev->irq);
+                dev_name(&phy_dev->dev), phy_dev->irq);
 
         sc->phy_dev = phy_dev;
 
@@ -2697,7 +2697,7 @@ static int __init sbmac_probe(struct platform_device *pldev)
         sbm_base = ioremap_nocache(res->start, res->end - res->start + 1);
         if (!sbm_base) {
                 printk(KERN_ERR "%s: unable to map device registers\n",
-                       pldev->dev.bus_id);
+                       dev_name(&pldev->dev));
                 err = -ENOMEM;
                 goto out_out;
         }
@@ -2708,7 +2708,7 @@ static int __init sbmac_probe(struct platform_device *pldev)
          * If we find a zero, skip this MAC.
          */
         sbmac_orig_hwaddr = __raw_readq(sbm_base + R_MAC_ETHERNET_ADDR);
-        pr_debug("%s: %sconfiguring MAC at 0x%08Lx\n", pldev->dev.bus_id,
+        pr_debug("%s: %sconfiguring MAC at 0x%08Lx\n", dev_name(&pldev->dev),
                  sbmac_orig_hwaddr ? "" : "not ", (long long)res->start);
         if (sbmac_orig_hwaddr == 0) {
                 err = 0;
@@ -2721,7 +2721,7 @@ static int __init sbmac_probe(struct platform_device *pldev)
         dev = alloc_etherdev(sizeof(struct sbmac_softc));
         if (!dev) {
                 printk(KERN_ERR "%s: unable to allocate etherdev\n",
-                       pldev->dev.bus_id);
+                       dev_name(&pldev->dev));
                 err = -ENOMEM;
                 goto out_unmap;
         }
diff --git a/drivers/net/smc911x.c b/drivers/net/smc911x.c
index 223cde0d43be..293610334a77 100644
--- a/drivers/net/smc911x.c
+++ b/drivers/net/smc911x.c
@@ -1545,7 +1545,7 @@ smc911x_ethtool_getdrvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
         strncpy(info->driver, CARDNAME, sizeof(info->driver));
         strncpy(info->version, version, sizeof(info->version));
-        strncpy(info->bus_info, dev->dev.parent->bus_id, sizeof(info->bus_info));
+        strncpy(info->bus_info, dev_name(dev->dev.parent), sizeof(info->bus_info));
 }
 
 static int smc911x_ethtool_nwayreset(struct net_device *dev)
diff --git a/drivers/net/smc91x.c b/drivers/net/smc91x.c
index b215a8d85e62..0b6da9501444 100644
--- a/drivers/net/smc91x.c
+++ b/drivers/net/smc91x.c
@@ -1614,7 +1614,7 @@ smc_ethtool_getdrvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
         strncpy(info->driver, CARDNAME, sizeof(info->driver));
         strncpy(info->version, version, sizeof(info->version));
-        strncpy(info->bus_info, dev->dev.parent->bus_id, sizeof(info->bus_info));
+        strncpy(info->bus_info, dev_name(dev->dev.parent), sizeof(info->bus_info));
 }
 
 static int smc_ethtool_nwayreset(struct net_device *dev)
diff --git a/drivers/net/smsc911x.c b/drivers/net/smsc911x.c
index d1590ac55e4b..ab18ee0f60f3 100644
--- a/drivers/net/smsc911x.c
+++ b/drivers/net/smsc911x.c
@@ -769,7 +769,7 @@ static int smsc911x_mii_probe(struct net_device *dev)
                 return -ENODEV;
         }
 
-        phydev = phy_connect(dev, phydev->dev.bus_id,
+        phydev = phy_connect(dev, dev_name(&phydev->dev),
                 &smsc911x_phy_adjust_link, 0, pdata->config.phy_interface);
 
         if (IS_ERR(phydev)) {
@@ -778,7 +778,8 @@ static int smsc911x_mii_probe(struct net_device *dev)
         }
 
         pr_info("%s: attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
-                dev->name, phydev->drv->name, phydev->dev.bus_id, phydev->irq);
+                dev->name, phydev->drv->name,
+                dev_name(&phydev->dev), phydev->irq);
 
         /* mask with MAC supported features */
         phydev->supported &= (PHY_BASIC_FEATURES | SUPPORTED_Pause |
@@ -1549,7 +1550,7 @@ static void smsc911x_ethtool_getdrvinfo(struct net_device *dev,
 {
         strlcpy(info->driver, SMSC_CHIPNAME, sizeof(info->driver));
         strlcpy(info->version, SMSC_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/smsc9420.c b/drivers/net/smsc9420.c
index 4e15ae068b3f..72f1348eb809 100644
--- a/drivers/net/smsc9420.c
+++ b/drivers/net/smsc9420.c
@@ -1160,7 +1160,7 @@ static int smsc9420_mii_probe(struct net_device *dev)
         smsc_info(PROBE, "PHY addr %d, phy_id 0x%08X", phydev->addr,
                 phydev->phy_id);
 
-        phydev = phy_connect(dev, phydev->dev.bus_id,
+        phydev = phy_connect(dev, dev_name(&phydev->dev),
                 &smsc9420_phy_adjust_link, 0, PHY_INTERFACE_MODE_MII);
 
         if (IS_ERR(phydev)) {
@@ -1169,7 +1169,7 @@ static int smsc9420_mii_probe(struct net_device *dev)
         }
 
         pr_info("%s: attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
-                dev->name, phydev->drv->name, phydev->dev.bus_id, phydev->irq);
+                dev->name, phydev->drv->name, dev_name(&phydev->dev), phydev->irq);
 
         /* mask with MAC supported features */
         phydev->supported &= (PHY_BASIC_FEATURES | SUPPORTED_Pause |
diff --git a/drivers/net/tc35815.c b/drivers/net/tc35815.c
index bcd0e60cbda9..e1f8eb96a45c 100644
--- a/drivers/net/tc35815.c
+++ b/drivers/net/tc35815.c
@@ -725,7 +725,7 @@ static int tc_mii_probe(struct net_device *dev)
         }
 
         /* attach the mac to the phy */
-        phydev = phy_connect(dev, phydev->dev.bus_id,
+        phydev = phy_connect(dev, dev_name(&phydev->dev),
                              &tc_handle_link_change, 0,
                              lp->chiptype == TC35815_TX4939 ?
                              PHY_INTERFACE_MODE_RMII : PHY_INTERFACE_MODE_MII);
@@ -735,7 +735,7 @@ static int tc_mii_probe(struct net_device *dev)
         }
         printk(KERN_INFO "%s: attached PHY driver [%s] "
                 "(mii_bus:phy_addr=%s, id=%x)\n",
-                dev->name, phydev->drv->name, phydev->dev.bus_id,
+                dev->name, phydev->drv->name, dev_name(&phydev->dev),
                 phydev->phy_id);
 
         /* mask with MAC supported features */
diff --git a/drivers/net/wimax/i2400m/driver.c b/drivers/net/wimax/i2400m/driver.c
index e80a0b65a754..d58b971faa64 100644
--- a/drivers/net/wimax/i2400m/driver.c
+++ b/drivers/net/wimax/i2400m/driver.c
@@ -613,7 +613,7 @@ int i2400m_setup(struct i2400m *i2400m, enum i2400m_bri bm_flags)
         d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
 
         snprintf(wimax_dev->name, sizeof(wimax_dev->name),
-                 "i2400m-%s:%s", dev->bus->name, dev->bus_id);
+                 "i2400m-%s:%s", dev->bus->name, dev_name(dev));
 
         i2400m->bm_cmd_buf = kzalloc(I2400M_BM_CMD_BUF_SIZE, GFP_KERNEL);
         if (i2400m->bm_cmd_buf == NULL) {
diff --git a/drivers/net/wimax/i2400m/usb-notif.c b/drivers/net/wimax/i2400m/usb-notif.c
index 9702c22b2497..0528879f6d39 100644
--- a/drivers/net/wimax/i2400m/usb-notif.c
+++ b/drivers/net/wimax/i2400m/usb-notif.c
@@ -102,7 +102,7 @@ int i2400mu_notification_grok(struct i2400mu *i2400mu, const void *buf,
                 dev_err(dev, "HW BUG? Unknown/unexpected data in notification "
                         "message (%zu bytes)\n", buf_len);
                 snprintf(prefix, sizeof(prefix), "%s %s: ",
-                         dev_driver_string(dev) , dev->bus_id);
+                         dev_driver_string(dev) , dev_name(dev));
                 if (buf_len > 64) {
                         print_hex_dump(KERN_ERR, prefix, DUMP_PREFIX_OFFSET,
                                        8, 4, buf, 64, 0);
diff --git a/drivers/net/xtsonic.c b/drivers/net/xtsonic.c
index 03a3f34e9039..a12a7211c982 100644
--- a/drivers/net/xtsonic.c
+++ b/drivers/net/xtsonic.c
@@ -183,7 +183,7 @@ static int __init sonic_probe1(struct net_device *dev)
 
         if (lp->descriptors == NULL) {
                 printk(KERN_ERR "%s: couldn't alloc DMA memory for "
-                                " descriptors.\n", lp->device->bus_id);
+                                " descriptors.\n", dev_name(lp->device));
                 goto out;
         }
 
diff --git a/drivers/pci/hotplug/cpqphp_sysfs.c b/drivers/pci/hotplug/cpqphp_sysfs.c
index a13abf55d784..8450f4a6568a 100644
--- a/drivers/pci/hotplug/cpqphp_sysfs.c
+++ b/drivers/pci/hotplug/cpqphp_sysfs.c
@@ -225,7 +225,8 @@ void cpqhp_shutdown_debugfs(void)
 
 void cpqhp_create_debugfs_files(struct controller *ctrl)
 {
-        ctrl->dentry = debugfs_create_file(ctrl->pci_dev->dev.bus_id, S_IRUGO, root, ctrl, &debug_ops);
+        ctrl->dentry = debugfs_create_file(dev_name(&ctrl->pci_dev->dev),
+                                           S_IRUGO, root, ctrl, &debug_ops);
 }
 
 void cpqhp_remove_debugfs_files(struct controller *ctrl)
diff --git a/drivers/pcmcia/au1000_generic.c b/drivers/pcmcia/au1000_generic.c
index fc1de46fd20a..90013341cd5f 100644
--- a/drivers/pcmcia/au1000_generic.c
+++ b/drivers/pcmcia/au1000_generic.c
@@ -468,13 +468,13 @@ out:
         return ret;
 }
 
-int au1x00_drv_pcmcia_remove(struct device *dev)
+int au1x00_drv_pcmcia_remove(struct platform_device *dev)
 {
-        struct skt_dev_info *sinfo = dev_get_drvdata(dev);
+        struct skt_dev_info *sinfo = platform_get_drvdata(dev);
         int i;
 
         mutex_lock(&pcmcia_sockets_lock);
-        dev_set_drvdata(dev, NULL);
+        platform_set_drvdata(dev, NULL);
 
         for (i = 0; i < sinfo->nskt; i++) {
                 struct au1000_pcmcia_socket *skt = PCMCIA_SOCKET(i);
@@ -498,13 +498,13 @@ int au1x00_drv_pcmcia_remove(struct device *dev)
  * PCMCIA "Driver" API
  */
 
-static int au1x00_drv_pcmcia_probe(struct device *dev)
+static int au1x00_drv_pcmcia_probe(struct platform_device *dev)
 {
         int i, ret = -ENODEV;
 
         mutex_lock(&pcmcia_sockets_lock);
         for (i=0; i < ARRAY_SIZE(au1x00_pcmcia_hw_init); i++) {
-                ret = au1x00_pcmcia_hw_init[i](dev);
+                ret = au1x00_pcmcia_hw_init[i](&dev->dev);
                 if (ret == 0)
                         break;
         }
@@ -512,14 +512,26 @@ static int au1x00_drv_pcmcia_probe(struct device *dev)
         return ret;
 }
 
+static int au1x00_drv_pcmcia_suspend(struct platform_device *dev,
+                                     pm_message_t state)
+{
+        return pcmcia_socket_dev_suspend(&dev->dev, state);
+}
+
+static int au1x00_drv_pcmcia_resume(struct platform_device *dev)
+{
+        return pcmcia_socket_dev_resume(&dev->dev);
+}
 
-static struct device_driver au1x00_pcmcia_driver = {
+static struct platform_driver au1x00_pcmcia_driver = {
+        .driver = {
+                .name           = "au1x00-pcmcia",
+                .owner          = THIS_MODULE,
+        },
         .probe          = au1x00_drv_pcmcia_probe,
         .remove         = au1x00_drv_pcmcia_remove,
-        .name           = "au1x00-pcmcia",
-        .bus            = &platform_bus_type,
-        .suspend        = pcmcia_socket_dev_suspend,
-        .resume         = pcmcia_socket_dev_resume,
+        .suspend        = au1x00_drv_pcmcia_suspend,
+        .resume         = au1x00_drv_pcmcia_resume,
 };
 
 
@@ -533,8 +545,7 @@ static struct device_driver au1x00_pcmcia_driver = {
 static int __init au1x00_pcmcia_init(void)
 {
         int error = 0;
-        if ((error = driver_register(&au1x00_pcmcia_driver)))
-                return error;
+        error = platform_driver_register(&au1x00_pcmcia_driver);
         return error;
 }
 
@@ -544,7 +555,7 @@ static int __init au1x00_pcmcia_init(void)
  */
 static void __exit au1x00_pcmcia_exit(void)
 {
-        driver_unregister(&au1x00_pcmcia_driver);
+        platform_driver_unregister(&au1x00_pcmcia_driver);
 }
 
 module_init(au1x00_pcmcia_init);
diff --git a/drivers/pcmcia/i82365.c b/drivers/pcmcia/i82365.c
index 71653ab84890..40d4953e4b12 100644
--- a/drivers/pcmcia/i82365.c
+++ b/drivers/pcmcia/i82365.c
@@ -1238,6 +1238,16 @@ static int pcic_init(struct pcmcia_socket *s)
         return 0;
 }
 
+static int i82365_drv_pcmcia_suspend(struct platform_device *dev,
+                                     pm_message_t state)
+{
+        return pcmcia_socket_dev_suspend(&dev->dev, state);
+}
+
+static int i82365_drv_pcmcia_resume(struct platform_device *dev)
+{
+        return pcmcia_socket_dev_resume(&dev->dev);
+}
 static struct pccard_operations pcic_operations = {
         .init                   = pcic_init,
         .get_status             = pcic_get_status,
@@ -1248,11 +1258,13 @@ static struct pccard_operations pcic_operations = {
 
 /*====================================================================*/
 
-static struct device_driver i82365_driver = {
-        .name = "i82365",
-        .bus = &platform_bus_type,
-        .suspend = pcmcia_socket_dev_suspend,
-        .resume = pcmcia_socket_dev_resume,
+static struct platform_driver i82365_driver = {
+        .driver = {
+                .name = "i82365",
+                .owner          = THIS_MODULE,
+        },
+        .suspend        = i82365_drv_pcmcia_suspend,
+        .resume         = i82365_drv_pcmcia_resume,
 };
 
 static struct platform_device *i82365_device;
@@ -1261,7 +1273,7 @@ static int __init init_i82365(void)
 {
     int i, ret;
 
-    ret = driver_register(&i82365_driver);
+    ret = platform_driver_register(&i82365_driver);
     if (ret)
         goto err_out;
 
@@ -1337,7 +1349,7 @@ err_dev_unregister:
         pnp_disable_dev(i82365_pnpdev);
 #endif
 err_driver_unregister:
-    driver_unregister(&i82365_driver);
+    platform_driver_unregister(&i82365_driver);
 err_out:
     return ret;
 } /* init_i82365 */
@@ -1365,7 +1377,7 @@ static void __exit exit_i82365(void)
     if (i82365_pnpdev)
                 pnp_disable_dev(i82365_pnpdev);
 #endif
-    driver_unregister(&i82365_driver);
+    platform_driver_unregister(&i82365_driver);
 } /* exit_i82365 */
 
 module_init(init_i82365);
diff --git a/drivers/pcmcia/m32r_cfc.c b/drivers/pcmcia/m32r_cfc.c
index 2ab4f22c21de..62b4ecc97c46 100644
--- a/drivers/pcmcia/m32r_cfc.c
+++ b/drivers/pcmcia/m32r_cfc.c
@@ -696,13 +696,25 @@ static struct pccard_operations pcc_operations = {
         .set_mem_map            = pcc_set_mem_map,
 };
 
+static int cfc_drv_pcmcia_suspend(struct platform_device *dev,
+                                     pm_message_t state)
+{
+        return pcmcia_socket_dev_suspend(&dev->dev, state);
+}
+
+static int cfc_drv_pcmcia_resume(struct platform_device *dev)
+{
+        return pcmcia_socket_dev_resume(&dev->dev);
+}
 /*====================================================================*/
 
-static struct device_driver pcc_driver = {
-        .name = "cfc",
-        .bus = &platform_bus_type,
-        .suspend = pcmcia_socket_dev_suspend,
-        .resume = pcmcia_socket_dev_resume,
+static struct platform_driver pcc_driver = {
+        .driver = {
+                .name           = "cfc",
+                .owner          = THIS_MODULE,
+        },
+        .suspend        = cfc_drv_pcmcia_suspend,
+        .resume         = cfc_drv_pcmcia_resume,
 };
 
 static struct platform_device pcc_device = {
@@ -716,13 +728,13 @@ static int __init init_m32r_pcc(void)
 {
         int i, ret;
 
-        ret = driver_register(&pcc_driver);
+        ret = platform_driver_register(&pcc_driver);
         if (ret)
                 return ret;
 
         ret = platform_device_register(&pcc_device);
         if (ret){
-                driver_unregister(&pcc_driver);
+                platform_driver_unregister(&pcc_driver);
                 return ret;
         }
 
@@ -754,7 +766,7 @@ static int __init init_m32r_pcc(void)
         if (pcc_sockets == 0) {
                 printk("socket is not found.\n");
                 platform_device_unregister(&pcc_device);
-                driver_unregister(&pcc_driver);
+                platform_driver_unregister(&pcc_driver);
                 return -ENODEV;
         }
 
@@ -802,7 +814,7 @@ static void __exit exit_m32r_pcc(void)
         if (poll_interval != 0)
                 del_timer_sync(&poll_timer);
 
-        driver_unregister(&pcc_driver);
+        platform_driver_unregister(&pcc_driver);
 } /* exit_m32r_pcc */
 
 module_init(init_m32r_pcc);
diff --git a/drivers/pcmcia/m32r_pcc.c b/drivers/pcmcia/m32r_pcc.c
index 2f108c23dbd9..12034b41d196 100644
--- a/drivers/pcmcia/m32r_pcc.c
+++ b/drivers/pcmcia/m32r_pcc.c
@@ -672,13 +672,25 @@ static struct pccard_operations pcc_operations = {
         .set_mem_map            = pcc_set_mem_map,
 };
 
+static int pcc_drv_pcmcia_suspend(struct platform_device *dev,
+                                     pm_message_t state)
+{
+        return pcmcia_socket_dev_suspend(&dev->dev, state);
+}
+
+static int pcc_drv_pcmcia_resume(struct platform_device *dev)
+{
+        return pcmcia_socket_dev_resume(&dev->dev);
+}
 /*====================================================================*/
 
-static struct device_driver pcc_driver = {
-        .name = "pcc",
-        .bus = &platform_bus_type,
-        .suspend = pcmcia_socket_dev_suspend,
-        .resume = pcmcia_socket_dev_resume,
+static struct platform_driver pcc_driver = {
+        .driver = {
+                .name           = "pcc",
+                .owner          = THIS_MODULE,
+        },
+        .suspend        = pcc_drv_pcmcia_suspend,
+        .resume         = pcc_drv_pcmcia_resume,
 };
 
 static struct platform_device pcc_device = {
@@ -692,13 +704,13 @@ static int __init init_m32r_pcc(void)
 {
         int i, ret;
 
-        ret = driver_register(&pcc_driver);
+        ret = platform_driver_register(&pcc_driver);
         if (ret)
                 return ret;
 
         ret = platform_device_register(&pcc_device);
         if (ret){
-                driver_unregister(&pcc_driver);
+                platform_driver_unregister(&pcc_driver);
                 return ret;
         }
 
@@ -715,7 +727,7 @@ static int __init init_m32r_pcc(void)
         if (pcc_sockets == 0) {
                 printk("socket is not found.\n");
                 platform_device_unregister(&pcc_device);
-                driver_unregister(&pcc_driver);
+                platform_driver_unregister(&pcc_driver);
                 return -ENODEV;
         }
 
@@ -763,7 +775,7 @@ static void __exit exit_m32r_pcc(void)
         if (poll_interval != 0)
                 del_timer_sync(&poll_timer);
 
-        driver_unregister(&pcc_driver);
+        platform_driver_unregister(&pcc_driver);
 } /* exit_m32r_pcc */
 
 module_init(init_m32r_pcc);
diff --git a/drivers/pcmcia/rsrc_mgr.c b/drivers/pcmcia/rsrc_mgr.c
index c0e2afc79e3e..e592e0e0d7ed 100644
--- a/drivers/pcmcia/rsrc_mgr.c
+++ b/drivers/pcmcia/rsrc_mgr.c
@@ -153,7 +153,7 @@ static struct resource *iodyn_find_io_region(unsigned long base, int num,
                 unsigned long align, struct pcmcia_socket *s)
 {
         struct resource *res = make_resource(0, num, IORESOURCE_IO,
-                                             s->dev.bus_id);
+                                             dev_name(&s->dev));
         struct pcmcia_align_data data;
         unsigned long min = base;
         int ret;
diff --git a/drivers/pcmcia/sa1100_generic.c b/drivers/pcmcia/sa1100_generic.c
index c5b2a44b4c37..d8da5ac844e9 100644
--- a/drivers/pcmcia/sa1100_generic.c
+++ b/drivers/pcmcia/sa1100_generic.c
@@ -65,7 +65,7 @@ static int (*sa11x0_pcmcia_hw_init[])(struct device *dev) = {
 #endif
 };
 
-static int sa11x0_drv_pcmcia_probe(struct device *dev)
+static int sa11x0_drv_pcmcia_probe(struct platform_device *dev)
 {
         int i, ret = -ENODEV;
 
@@ -73,7 +73,7 @@ static int sa11x0_drv_pcmcia_probe(struct device *dev)
          * Initialise any "on-board" PCMCIA sockets.
          */
         for (i = 0; i < ARRAY_SIZE(sa11x0_pcmcia_hw_init); i++) {
-                ret = sa11x0_pcmcia_hw_init[i](dev);
+                ret = sa11x0_pcmcia_hw_init[i](&dev->dev);
                 if (ret == 0)
                         break;
         }
@@ -81,13 +81,31 @@ static int sa11x0_drv_pcmcia_probe(struct device *dev)
         return ret;
 }
 
-static struct device_driver sa11x0_pcmcia_driver = {
+static int sa11x0_drv_pcmcia_remove(struct platform_device *dev)
+{
+        return soc_common_drv_pcmcia_remove(&dev->dev);
+}
+
+static int sa11x0_drv_pcmcia_suspend(struct platform_device *dev,
+                                     pm_message_t state)
+{
+        return pcmcia_socket_dev_suspend(&dev->dev, state);
+}
+
+static int sa11x0_drv_pcmcia_resume(struct platform_device *dev)
+{
+        return pcmcia_socket_dev_resume(&dev->dev);
+}
+
+static struct platform_driver sa11x0_pcmcia_driver = {
+        .driver = {
+                .name           = "sa11x0-pcmcia",
+                .owner          = THIS_MODULE,
+        },
         .probe          = sa11x0_drv_pcmcia_probe,
-        .remove         = soc_common_drv_pcmcia_remove,
-        .name           = "sa11x0-pcmcia",
-        .bus            = &platform_bus_type,
-        .suspend        = pcmcia_socket_dev_suspend,
-        .resume         = pcmcia_socket_dev_resume,
+        .remove         = sa11x0_drv_pcmcia_remove,
+        .suspend        = sa11x0_drv_pcmcia_suspend,
+        .resume         = sa11x0_drv_pcmcia_resume,
 };
 
 /* sa11x0_pcmcia_init()
@@ -100,7 +118,7 @@ static struct device_driver sa11x0_pcmcia_driver = {
  */
 static int __init sa11x0_pcmcia_init(void)
 {
-        return driver_register(&sa11x0_pcmcia_driver);
+        return platform_driver_register(&sa11x0_pcmcia_driver);
 }
 
 /* sa11x0_pcmcia_exit()
@@ -110,7 +128,7 @@ static int __init sa11x0_pcmcia_init(void)
  */
 static void __exit sa11x0_pcmcia_exit(void)
 {
-        driver_unregister(&sa11x0_pcmcia_driver);
+        platform_driver_unregister(&sa11x0_pcmcia_driver);
 }
 
 MODULE_AUTHOR("John Dorsey <john+@cs.cmu.edu>");
diff --git a/drivers/pcmcia/tcic.c b/drivers/pcmcia/tcic.c
index 2a613e920fd4..9ad97ea836e8 100644
--- a/drivers/pcmcia/tcic.c
+++ b/drivers/pcmcia/tcic.c
@@ -363,13 +363,25 @@ static int __init get_tcic_id(void)
     return id;
 }
 
+static int tcic_drv_pcmcia_suspend(struct platform_device *dev,
+                                     pm_message_t state)
+{
+        return pcmcia_socket_dev_suspend(&dev->dev, state);
+}
+
+static int tcic_drv_pcmcia_resume(struct platform_device *dev)
+{
+        return pcmcia_socket_dev_resume(&dev->dev);
+}
 /*====================================================================*/
 
-static struct device_driver tcic_driver = {
-        .name = "tcic-pcmcia",
-        .bus = &platform_bus_type,
-        .suspend = pcmcia_socket_dev_suspend,
-        .resume = pcmcia_socket_dev_resume,
+static struct platform_driver tcic_driver = {
+        .driver = {
+                .name = "tcic-pcmcia",
+                .owner          = THIS_MODULE,
+        },
+        .suspend        = tcic_drv_pcmcia_suspend,
+        .resume         = tcic_drv_pcmcia_resume,
 };
 
 static struct platform_device tcic_device = {
@@ -383,7 +395,7 @@ static int __init init_tcic(void)
     int i, sock, ret = 0;
     u_int mask, scan;
 
-    if (driver_register(&tcic_driver))
+    if (platform_driver_register(&tcic_driver))
         return -1;
     
     printk(KERN_INFO "Databook TCIC-2 PCMCIA probe: ");
@@ -391,7 +403,7 @@ static int __init init_tcic(void)
 
     if (!request_region(tcic_base, 16, "tcic-2")) {
         printk("could not allocate ports,\n ");
-        driver_unregister(&tcic_driver);
+        platform_driver_unregister(&tcic_driver);
         return -ENODEV;
     }
     else {
@@ -414,7 +426,7 @@ static int __init init_tcic(void)
     if (sock == 0) {
         printk("not found.\n");
         release_region(tcic_base, 16);
-        driver_unregister(&tcic_driver);
+        platform_driver_unregister(&tcic_driver);
         return -ENODEV;
     }
 
@@ -542,7 +554,7 @@ static void __exit exit_tcic(void)
     }
 
     platform_device_unregister(&tcic_device);
-    driver_unregister(&tcic_driver);
+    platform_driver_unregister(&tcic_driver);
 } /* exit_tcic */
 
 /*====================================================================*/
diff --git a/drivers/pcmcia/vrc4171_card.c b/drivers/pcmcia/vrc4171_card.c
index b2c412419059..659421d0ca46 100644
--- a/drivers/pcmcia/vrc4171_card.c
+++ b/drivers/pcmcia/vrc4171_card.c
@@ -704,24 +704,37 @@ static int __devinit vrc4171_card_setup(char *options)
 
 __setup("vrc4171_card=", vrc4171_card_setup);
 
-static struct device_driver vrc4171_card_driver = {
-        .name           = vrc4171_card_name,
-        .bus            = &platform_bus_type,
-        .suspend        = pcmcia_socket_dev_suspend,
-        .resume         = pcmcia_socket_dev_resume,
+static int vrc4171_card_suspend(struct platform_device *dev,
+                                     pm_message_t state)
+{
+        return pcmcia_socket_dev_suspend(&dev->dev, state);
+}
+
+static int vrc4171_card_resume(struct platform_device *dev)
+{
+        return pcmcia_socket_dev_resume(&dev->dev);
+}
+
+static struct platform_driver vrc4171_card_driver = {
+        .driver = {
+                .name           = vrc4171_card_name,
+                .owner          = THIS_MODULE,
+        },
+        .suspend        = vrc4171_card_suspend,
+        .resume         = vrc4171_card_resume,
 };
 
 static int __devinit vrc4171_card_init(void)
 {
         int retval;
 
-        retval = driver_register(&vrc4171_card_driver);
+        retval = platform_driver_register(&vrc4171_card_driver);
         if (retval < 0)
                 return retval;
 
         retval = platform_device_register(&vrc4171_card_device);
         if (retval < 0) {
-                driver_unregister(&vrc4171_card_driver);
+                platform_driver_unregister(&vrc4171_card_driver);
                 return retval;
         }
 
@@ -735,11 +748,12 @@ static int __devinit vrc4171_card_init(void)
         if (retval < 0) {
                 vrc4171_remove_sockets();
                 platform_device_unregister(&vrc4171_card_device);
-                driver_unregister(&vrc4171_card_driver);
+                platform_driver_unregister(&vrc4171_card_driver);
                 return retval;
         }
 
-        printk(KERN_INFO "%s, connected to IRQ %d\n", vrc4171_card_driver.name, vrc4171_irq);
+        printk(KERN_INFO "%s, connected to IRQ %d\n",
+                vrc4171_card_driver.driver.name, vrc4171_irq);
 
         return 0;
 }
@@ -749,7 +763,7 @@ static void __devexit vrc4171_card_exit(void)
         free_irq(vrc4171_irq, vrc4171_sockets);
         vrc4171_remove_sockets();
         platform_device_unregister(&vrc4171_card_device);
-        driver_unregister(&vrc4171_card_driver);
+        platform_driver_unregister(&vrc4171_card_driver);
 }
 
 module_init(vrc4171_card_init);
diff --git a/drivers/rapidio/rio-driver.c b/drivers/rapidio/rio-driver.c
index addb87cf44d9..3222fa3c808c 100644
--- a/drivers/rapidio/rio-driver.c
+++ b/drivers/rapidio/rio-driver.c
@@ -193,7 +193,7 @@ static int rio_match_bus(struct device *dev, struct device_driver *drv)
 }
 
 static struct device rio_bus = {
-        .bus_id = "rapidio",
+        .init_name = "rapidio",
 };
 
 struct bus_type rio_bus_type = {
diff --git a/drivers/rtc/rtc-at91sam9.c b/drivers/rtc/rtc-at91sam9.c
index d5e4e637ddec..86c61f143515 100644
--- a/drivers/rtc/rtc-at91sam9.c
+++ b/drivers/rtc/rtc-at91sam9.c
@@ -351,7 +351,7 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
         /* register irq handler after we know what name we'll use */
         ret = request_irq(AT91_ID_SYS, at91_rtc_interrupt,
                                 IRQF_DISABLED | IRQF_SHARED,
-                                rtc->rtcdev->dev.bus_id, rtc);
+                                dev_name(&rtc->rtcdev->dev), rtc);
         if (ret) {
                 dev_dbg(&pdev->dev, "can't share IRQ %d?\n", AT91_ID_SYS);
                 rtc_device_unregister(rtc->rtcdev);
@@ -366,7 +366,7 @@ static int __init at91_rtc_probe(struct platform_device *pdev)
 
         if (gpbr_readl(rtc) == 0)
                 dev_warn(&pdev->dev, "%s: SET TIME!\n",
-                                rtc->rtcdev->dev.bus_id);
+                                dev_name(&rtc->rtcdev->dev));
 
         return 0;
 
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index 2cbeb0794f14..bd1ce8e2bc18 100644
--- a/drivers/rtc/rtc-omap.c
+++ b/drivers/rtc/rtc-omap.c
@@ -377,13 +377,13 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
 
         /* handle periodic and alarm irqs */
         if (request_irq(omap_rtc_timer, rtc_irq, IRQF_DISABLED,
-                        rtc->dev.bus_id, rtc)) {
+                        dev_name(&rtc->dev), rtc)) {
                 pr_debug("%s: RTC timer interrupt IRQ%d already claimed\n",
                         pdev->name, omap_rtc_timer);
                 goto fail0;
         }
         if (request_irq(omap_rtc_alarm, rtc_irq, IRQF_DISABLED,
-                        rtc->dev.bus_id, rtc)) {
+                        dev_name(&rtc->dev), rtc)) {
                 pr_debug("%s: RTC alarm interrupt IRQ%d already claimed\n",
                         pdev->name, omap_rtc_alarm);
                 goto fail1;
diff --git a/drivers/rtc/rtc-twl4030.c b/drivers/rtc/rtc-twl4030.c
index ad35f76c46b7..a6341e4f9a0f 100644
--- a/drivers/rtc/rtc-twl4030.c
+++ b/drivers/rtc/rtc-twl4030.c
@@ -426,7 +426,7 @@ static int __devinit twl4030_rtc_probe(struct platform_device *pdev)
 
         ret = request_irq(irq, twl4030_rtc_interrupt,
                                 IRQF_TRIGGER_RISING,
-                                rtc->dev.bus_id, rtc);
+                                dev_name(&rtc->dev), rtc);
         if (ret < 0) {
                 dev_err(&pdev->dev, "IRQ is not free.\n");
                 goto out1;
diff --git a/drivers/s390/cio/ccwgroup.c b/drivers/s390/cio/ccwgroup.c
index 918e6fce2573..b91c1719b075 100644
--- a/drivers/s390/cio/ccwgroup.c
+++ b/drivers/s390/cio/ccwgroup.c
@@ -104,8 +104,9 @@ ccwgroup_ungroup_store(struct device *dev, struct device_attribute *attr, const
         rc = device_schedule_callback(dev, ccwgroup_ungroup_callback);
 out:
         if (rc) {
-                /* Release onoff "lock" when ungrouping failed. */
-                atomic_set(&gdev->onoff, 0);
+                if (rc != -EAGAIN)
+                        /* Release onoff "lock" when ungrouping failed. */
+                        atomic_set(&gdev->onoff, 0);
                 return rc;
         }
         return count;
diff --git a/drivers/s390/cio/chsc_sch.c b/drivers/s390/cio/chsc_sch.c
index 0a2f2edafc03..93eca1731b81 100644
--- a/drivers/s390/cio/chsc_sch.c
+++ b/drivers/s390/cio/chsc_sch.c
@@ -84,8 +84,8 @@ static int chsc_subchannel_probe(struct subchannel *sch)
                 kfree(private);
         } else {
                 sch->private = private;
-                if (sch->dev.uevent_suppress) {
-                        sch->dev.uevent_suppress = 0;
+                if (dev_get_uevent_suppress(&sch->dev)) {
+                        dev_set_uevent_suppress(&sch->dev, 0);
                         kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
                 }
         }
diff --git a/drivers/s390/cio/css.c b/drivers/s390/cio/css.c
index 8019288bc6de..427d11d88069 100644
--- a/drivers/s390/cio/css.c
+++ b/drivers/s390/cio/css.c
@@ -272,7 +272,7 @@ static int css_register_subchannel(struct subchannel *sch)
          * the subchannel driver can decide itself when it wants to inform
          * userspace of its existence.
          */
-        sch->dev.uevent_suppress = 1;
+        dev_set_uevent_suppress(&sch->dev, 1);
         css_update_ssd_info(sch);
         /* make it known to the system */
         ret = css_sch_device_register(sch);
@@ -287,7 +287,7 @@ static int css_register_subchannel(struct subchannel *sch)
                  * a fitting driver module may be loaded based on the
                  * modalias.
                  */
-                sch->dev.uevent_suppress = 0;
+                dev_set_uevent_suppress(&sch->dev, 0);
                 kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
         }
         return ret;
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index 23d5752349b5..e28f8ae53453 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -799,7 +799,7 @@ static void sch_attach_disconnected_device(struct subchannel *sch,
                 return;
         other_sch = to_subchannel(cdev->dev.parent);
         /* Note: device_move() changes cdev->dev.parent */
-        ret = device_move(&cdev->dev, &sch->dev);
+        ret = device_move(&cdev->dev, &sch->dev, DPM_ORDER_PARENT_BEFORE_DEV);
         if (ret) {
                 CIO_MSG_EVENT(0, "Moving disconnected device 0.%x.%04x failed "
                               "(ret=%d)!\n", cdev->private->dev_id.ssid,
@@ -830,7 +830,7 @@ static void sch_attach_orphaned_device(struct subchannel *sch,
          * Try to move the ccw device to its new subchannel.
          * Note: device_move() changes cdev->dev.parent
          */
-        ret = device_move(&cdev->dev, &sch->dev);
+        ret = device_move(&cdev->dev, &sch->dev, DPM_ORDER_PARENT_BEFORE_DEV);
         if (ret) {
                 CIO_MSG_EVENT(0, "Moving device 0.%x.%04x from orphanage "
                               "failed (ret=%d)!\n",
@@ -897,7 +897,8 @@ void ccw_device_move_to_orphanage(struct work_struct *work)
          * ccw device can take its place on the subchannel.
          * Note: device_move() changes cdev->dev.parent
          */
-        ret = device_move(&cdev->dev, &css->pseudo_subchannel->dev);
+        ret = device_move(&cdev->dev, &css->pseudo_subchannel->dev,
+                DPM_ORDER_NONE);
         if (ret) {
                 CIO_MSG_EVENT(0, "Moving device 0.%x.%04x to orphanage failed "
                               "(ret=%d)!\n", cdev->private->dev_id.ssid,
@@ -981,7 +982,7 @@ io_subchannel_register(struct work_struct *work)
          * Now we know this subchannel will stay, we can throw
          * our delayed uevent.
          */
-        sch->dev.uevent_suppress = 0;
+        dev_set_uevent_suppress(&sch->dev, 0);
         kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
         /* make it known to the system */
         ret = ccw_device_register(cdev);
@@ -1129,7 +1130,7 @@ static void ccw_device_move_to_sch(struct work_struct *work)
          * Try to move the ccw device to its new subchannel.
          * Note: device_move() changes cdev->dev.parent
          */
-        rc = device_move(&cdev->dev, &sch->dev);
+        rc = device_move(&cdev->dev, &sch->dev, DPM_ORDER_PARENT_BEFORE_DEV);
         mutex_unlock(&sch->reg_mutex);
         if (rc) {
                 CIO_MSG_EVENT(0, "Moving device 0.%x.%04x to subchannel "
@@ -1243,7 +1244,7 @@ static int io_subchannel_probe(struct subchannel *sch)
                  * the ccw_device and exit. This happens for all early
                  * devices, e.g. the console.
                  */
-                sch->dev.uevent_suppress = 0;
+                dev_set_uevent_suppress(&sch->dev, 0);
                 kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
                 cdev->dev.groups = ccwdev_attr_groups;
                 device_initialize(&cdev->dev);
diff --git a/drivers/s390/net/qeth_l3_main.c b/drivers/s390/net/qeth_l3_main.c
index 3d04920b9bb9..0dcc036d34aa 100644
--- a/drivers/s390/net/qeth_l3_main.c
+++ b/drivers/s390/net/qeth_l3_main.c
@@ -1038,7 +1038,7 @@ static int qeth_l3_setadapter_parms(struct qeth_card *card)
         rc = qeth_query_setadapterparms(card);
         if (rc) {
                 QETH_DBF_MESSAGE(2, "%s couldn't set adapter parameters: "
-                        "0x%x\n", card->gdev->dev.bus_id, rc);
+                        "0x%x\n", dev_name(&card->gdev->dev), rc);
                 return rc;
         }
         if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
diff --git a/drivers/scsi/a4000t.c b/drivers/scsi/a4000t.c
index d4bda2017746..61af3d91ac8a 100644
--- a/drivers/scsi/a4000t.c
+++ b/drivers/scsi/a4000t.c
@@ -35,7 +35,7 @@ static struct platform_device *a4000t_scsi_device;
 
 #define A4000T_SCSI_ADDR 0xdd0040
 
-static int __devinit a4000t_probe(struct device *dev)
+static int __devinit a4000t_probe(struct platform_device *dev)
 {
         struct Scsi_Host *host;
         struct NCR_700_Host_Parameters *hostdata;
@@ -61,7 +61,8 @@ static int __devinit a4000t_probe(struct device *dev)
         hostdata->dcntl_extra = EA_710;
 
         /* and register the chip */
-        host = NCR_700_detect(&a4000t_scsi_driver_template, hostdata, dev);
+        host = NCR_700_detect(&a4000t_scsi_driver_template, hostdata,
+                              &dev->dev);
         if (!host) {
                 printk(KERN_ERR "a4000t-scsi: No host detected; "
                                 "board configuration problem?\n");
@@ -78,7 +79,7 @@ static int __devinit a4000t_probe(struct device *dev)
                 goto out_put_host;
         }
 
-        dev_set_drvdata(dev, host);
+        platform_set_drvdata(dev, host);
         scsi_scan_host(host);
 
         return 0;
@@ -93,9 +94,9 @@ static int __devinit a4000t_probe(struct device *dev)
         return -ENODEV;
 }
 
-static __devexit int a4000t_device_remove(struct device *dev)
+static __devexit int a4000t_device_remove(struct platform_device *dev)
 {
-        struct Scsi_Host *host = dev_get_drvdata(dev);
+        struct Scsi_Host *host = platform_get_drvdata(dev);
         struct NCR_700_Host_Parameters *hostdata = shost_priv(host);
 
         scsi_remove_host(host);
@@ -108,25 +109,27 @@ static __devexit int a4000t_device_remove(struct device *dev)
         return 0;
 }
 
-static struct device_driver a4000t_scsi_driver = {
-        .name   = "a4000t-scsi",
-        .bus    = &platform_bus_type,
-        .probe  = a4000t_probe,
-        .remove = __devexit_p(a4000t_device_remove),
+static struct platform_driver a4000t_scsi_driver = {
+        .driver = {
+                .name           = "a4000t-scsi",
+                .owner          = THIS_MODULE,
+        },
+        .probe          = a4000t_probe,
+        .remove         = __devexit_p(a4000t_device_remove),
 };
 
 static int __init a4000t_scsi_init(void)
 {
         int err;
 
-        err = driver_register(&a4000t_scsi_driver);
+        err = platform_driver_register(&a4000t_scsi_driver);
         if (err)
                 return err;
 
         a4000t_scsi_device = platform_device_register_simple("a4000t-scsi",
                         -1, NULL, 0);
         if (IS_ERR(a4000t_scsi_device)) {
-                driver_unregister(&a4000t_scsi_driver);
+                platform_driver_register(&a4000t_scsi_driver);
                 return PTR_ERR(a4000t_scsi_device);
         }
 
@@ -136,7 +139,7 @@ static int __init a4000t_scsi_init(void)
 static void __exit a4000t_scsi_exit(void)
 {
         platform_device_unregister(a4000t_scsi_device);
-        driver_unregister(&a4000t_scsi_driver);
+        platform_driver_unregister(&a4000t_scsi_driver);
 }
 
 module_init(a4000t_scsi_init);
diff --git a/drivers/scsi/bvme6000_scsi.c b/drivers/scsi/bvme6000_scsi.c
index d858f3d41274..5799cb5cba6b 100644
--- a/drivers/scsi/bvme6000_scsi.c
+++ b/drivers/scsi/bvme6000_scsi.c
@@ -34,7 +34,7 @@ static struct scsi_host_template bvme6000_scsi_driver_template = {
 static struct platform_device *bvme6000_scsi_device;
 
 static __devinit int
-bvme6000_probe(struct device *dev)
+bvme6000_probe(struct platform_device *dev)
 {
         struct Scsi_Host *host;
         struct NCR_700_Host_Parameters *hostdata;
@@ -58,7 +58,8 @@ bvme6000_probe(struct device *dev)
         hostdata->ctest7_extra = CTEST7_TT1;
 
         /* and register the chip */
-        host = NCR_700_detect(&bvme6000_scsi_driver_template, hostdata, dev);
+        host = NCR_700_detect(&bvme6000_scsi_driver_template, hostdata,
+                              &dev->dev);
         if (!host) {
                 printk(KERN_ERR "bvme6000-scsi: No host detected; "
                                 "board configuration problem?\n");
@@ -73,7 +74,7 @@ bvme6000_probe(struct device *dev)
                 goto out_put_host;
         }
 
-        dev_set_drvdata(dev, host);
+        platform_set_drvdata(dev, host);
         scsi_scan_host(host);
 
         return 0;
@@ -87,9 +88,9 @@ bvme6000_probe(struct device *dev)
 }
 
 static __devexit int
-bvme6000_device_remove(struct device *dev)
+bvme6000_device_remove(struct platform_device *dev)
 {
-        struct Scsi_Host *host = dev_get_drvdata(dev);
+        struct Scsi_Host *host = platform_get_drvdata(dev);
         struct NCR_700_Host_Parameters *hostdata = shost_priv(host);
 
         scsi_remove_host(host);
@@ -100,25 +101,27 @@ bvme6000_device_remove(struct device *dev)
         return 0;
 }
 
-static struct device_driver bvme6000_scsi_driver = {
-        .name   = "bvme6000-scsi",
-        .bus    = &platform_bus_type,
-        .probe  = bvme6000_probe,
-        .remove = __devexit_p(bvme6000_device_remove),
+static struct platform_driver bvme6000_scsi_driver = {
+        .driver = {
+                .name           = "bvme6000-scsi",
+                .owner          = THIS_MODULE,
+        },
+        .probe          = bvme6000_probe,
+        .remove         = __devexit_p(bvme6000_device_remove),
 };
 
 static int __init bvme6000_scsi_init(void)
 {
         int err;
 
-        err = driver_register(&bvme6000_scsi_driver);
+        err = platform_driver_register(&bvme6000_scsi_driver);
         if (err)
                 return err;
 
         bvme6000_scsi_device = platform_device_register_simple("bvme6000-scsi",
                                                                -1, NULL, 0);
         if (IS_ERR(bvme6000_scsi_device)) {
-                driver_unregister(&bvme6000_scsi_driver);
+                platform_driver_unregister(&bvme6000_scsi_driver);
                 return PTR_ERR(bvme6000_scsi_device);
         }
 
@@ -128,7 +131,7 @@ static int __init bvme6000_scsi_init(void)
 static void __exit bvme6000_scsi_exit(void)
 {
         platform_device_unregister(bvme6000_scsi_device);
-        driver_unregister(&bvme6000_scsi_driver);
+        platform_driver_unregister(&bvme6000_scsi_driver);
 }
 
 module_init(bvme6000_scsi_init);
diff --git a/drivers/scsi/mvme16x_scsi.c b/drivers/scsi/mvme16x_scsi.c
index b264b499d982..b5fbfd6ce870 100644
--- a/drivers/scsi/mvme16x_scsi.c
+++ b/drivers/scsi/mvme16x_scsi.c
@@ -34,7 +34,7 @@ static struct scsi_host_template mvme16x_scsi_driver_template = {
 static struct platform_device *mvme16x_scsi_device;
 
 static __devinit int
-mvme16x_probe(struct device *dev)
+mvme16x_probe(struct platform_device *dev)
 {
         struct Scsi_Host * host = NULL;
         struct NCR_700_Host_Parameters *hostdata;
@@ -64,7 +64,8 @@ mvme16x_probe(struct device *dev)
         hostdata->ctest7_extra = CTEST7_TT1;
 
         /* and register the chip */
-        host = NCR_700_detect(&mvme16x_scsi_driver_template, hostdata, dev);
+        host = NCR_700_detect(&mvme16x_scsi_driver_template, hostdata,
+                              &dev->dev);
         if (!host) {
                 printk(KERN_ERR "mvme16x-scsi: No host detected; "
                                 "board configuration problem?\n");
@@ -88,7 +89,7 @@ mvme16x_probe(struct device *dev)
                 out_be32(0xfff4202c, v);
         }
 
-        dev_set_drvdata(dev, host);
+        platform_set_drvdata(dev, host);
         scsi_scan_host(host);
 
         return 0;
@@ -102,9 +103,9 @@ mvme16x_probe(struct device *dev)
 }
 
 static __devexit int
-mvme16x_device_remove(struct device *dev)
+mvme16x_device_remove(struct platform_device *dev)
 {
-        struct Scsi_Host *host = dev_get_drvdata(dev);
+        struct Scsi_Host *host = platform_get_drvdata(dev);
         struct NCR_700_Host_Parameters *hostdata = shost_priv(host);
 
         /* Disable scsi chip ints */
@@ -123,25 +124,27 @@ mvme16x_device_remove(struct device *dev)
         return 0;
 }
 
-static struct device_driver mvme16x_scsi_driver = {
-        .name   = "mvme16x-scsi",
-        .bus    = &platform_bus_type,
-        .probe  = mvme16x_probe,
-        .remove = __devexit_p(mvme16x_device_remove),
+static struct platform_driver mvme16x_scsi_driver = {
+        .driver = {
+                .name           = "mvme16x-scsi",
+                .owner          = THIS_MODULE,
+        },
+        .probe          = mvme16x_probe,
+        .remove         = __devexit_p(mvme16x_device_remove),
 };
 
 static int __init mvme16x_scsi_init(void)
 {
         int err;
 
-        err = driver_register(&mvme16x_scsi_driver);
+        err = platform_driver_register(&mvme16x_scsi_driver);
         if (err)
                 return err;
 
         mvme16x_scsi_device = platform_device_register_simple("mvme16x-scsi",
                                                               -1, NULL, 0);
         if (IS_ERR(mvme16x_scsi_device)) {
-                driver_unregister(&mvme16x_scsi_driver);
+                platform_driver_unregister(&mvme16x_scsi_driver);
                 return PTR_ERR(mvme16x_scsi_device);
         }
 
@@ -151,7 +154,7 @@ static int __init mvme16x_scsi_init(void)
 static void __exit mvme16x_scsi_exit(void)
 {
         platform_device_unregister(mvme16x_scsi_device);
-        driver_unregister(&mvme16x_scsi_driver);
+        platform_driver_unregister(&mvme16x_scsi_driver);
 }
 
 module_init(mvme16x_scsi_init);
diff --git a/drivers/serial/sunzilog.c b/drivers/serial/sunzilog.c
index 45a299f35617..e09d3cebb4fb 100644
--- a/drivers/serial/sunzilog.c
+++ b/drivers/serial/sunzilog.c
@@ -1438,12 +1438,12 @@ static int __devinit zs_probe(struct of_device *op, const struct of_device_id *m
         } else {
                 printk(KERN_INFO "%s: Keyboard at MMIO 0x%llx (irq = %d) "
                        "is a %s\n",
-                       op->dev.bus_id,
+                       dev_name(&op->dev),
                        (unsigned long long) up[0].port.mapbase,
                        op->irqs[0], sunzilog_type(&up[0].port));
                 printk(KERN_INFO "%s: Mouse at MMIO 0x%llx (irq = %d) "
                        "is a %s\n",
-                       op->dev.bus_id,
+                       dev_name(&op->dev),
                        (unsigned long long) up[1].port.mapbase,
                        op->irqs[0], sunzilog_type(&up[1].port));
                 kbm_inst++;
diff --git a/drivers/sh/maple/maple.c b/drivers/sh/maple/maple.c
index c71bb4b4ce84..cab1ab7cfb78 100644
--- a/drivers/sh/maple/maple.c
+++ b/drivers/sh/maple/maple.c
@@ -379,7 +379,6 @@ static void maple_attach_driver(struct maple_device *mdev)
                         dev_info(&mdev->dev, "no driver found\n");
                         mdev->driver = &maple_unsupported_device;
                 }
-
                 dev_set_name(&mdev->dev, "%d:0%d.%lX", mdev->port,
                              mdev->unit, function);
         }
diff --git a/drivers/spi/atmel_spi.c b/drivers/spi/atmel_spi.c
index 56ff3e6864ea..12e443cc4ac9 100644
--- a/drivers/spi/atmel_spi.c
+++ b/drivers/spi/atmel_spi.c
@@ -322,7 +322,7 @@ static void atmel_spi_next_message(struct spi_master *master)
         spi = msg->spi;
 
         dev_dbg(master->dev.parent, "start message %p for %s\n",
-                        msg, spi->dev.bus_id);
+                        msg, dev_name(&spi->dev));
 
         /* select chip if it's not still active */
         if (as->stay) {
@@ -627,7 +627,7 @@ static int atmel_spi_setup(struct spi_device *spi)
                 if (!asd)
                         return -ENOMEM;
 
-                ret = gpio_request(npcs_pin, spi->dev.bus_id);
+                ret = gpio_request(npcs_pin, dev_name(&spi->dev));
                 if (ret) {
                         kfree(asd);
                         return ret;
@@ -668,7 +668,7 @@ static int atmel_spi_transfer(struct spi_device *spi, struct spi_message *msg)
         as = spi_master_get_devdata(spi->master);
 
         dev_dbg(controller, "new message %p submitted for %s\n",
-                        msg, spi->dev.bus_id);
+                        msg, dev_name(&spi->dev));
 
         if (unlikely(list_empty(&msg->transfers)))
                 return -EINVAL;
@@ -803,7 +803,7 @@ static int __init atmel_spi_probe(struct platform_device *pdev)
         as->clk = clk;
 
         ret = request_irq(irq, atmel_spi_interrupt, 0,
-                        pdev->dev.bus_id, master);
+                        dev_name(&pdev->dev), master);
         if (ret)
                 goto out_unmap_regs;
 
diff --git a/drivers/spi/mpc52xx_psc_spi.c b/drivers/spi/mpc52xx_psc_spi.c
index 3b97803e1d11..68c77a911595 100644
--- a/drivers/spi/mpc52xx_psc_spi.c
+++ b/drivers/spi/mpc52xx_psc_spi.c
@@ -429,7 +429,7 @@ static int __init mpc52xx_psc_spi_do_probe(struct device *dev, u32 regaddr,
         INIT_LIST_HEAD(&mps->queue);
 
         mps->workqueue = create_singlethread_workqueue(
-                master->dev.parent->bus_id);
+                dev_name(master->dev.parent));
         if (mps->workqueue == NULL) {
                 ret = -EBUSY;
                 goto free_irq;
diff --git a/drivers/spi/omap2_mcspi.c b/drivers/spi/omap2_mcspi.c
index 454a2712e629..1c65e380c845 100644
--- a/drivers/spi/omap2_mcspi.c
+++ b/drivers/spi/omap2_mcspi.c
@@ -1003,7 +1003,7 @@ static int __init omap2_mcspi_probe(struct platform_device *pdev)
                 goto err1;
         }
         if (!request_mem_region(r->start, (r->end - r->start) + 1,
-                        pdev->dev.bus_id)) {
+                        dev_name(&pdev->dev))) {
                 status = -EBUSY;
                 goto err1;
         }
diff --git a/drivers/spi/omap_uwire.c b/drivers/spi/omap_uwire.c
index bab6ff061e91..60b5381c65c4 100644
--- a/drivers/spi/omap_uwire.c
+++ b/drivers/spi/omap_uwire.c
@@ -245,7 +245,7 @@ static int uwire_txrx(struct spi_device *spi, struct spi_transfer *t)
 
 #ifdef  VERBOSE
                         pr_debug("%s: write-%d =%04x\n",
-                                        spi->dev.bus_id, bits, val);
+                                        dev_name(&spi->dev), bits, val);
 #endif
                         if (wait_uwire_csr_flag(CSRB, 0, 0))
                                 goto eio;
@@ -305,7 +305,7 @@ static int uwire_txrx(struct spi_device *spi, struct spi_transfer *t)
                         status += bytes;
 #ifdef  VERBOSE
                         pr_debug("%s: read-%d =%04x\n",
-                                        spi->dev.bus_id, bits, val);
+                                        dev_name(&spi->dev), bits, val);
 #endif
 
                 }
@@ -331,7 +331,7 @@ static int uwire_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
         uwire = spi_master_get_devdata(spi->master);
 
         if (spi->chip_select > 3) {
-                pr_debug("%s: cs%d?\n", spi->dev.bus_id, spi->chip_select);
+                pr_debug("%s: cs%d?\n", dev_name(&spi->dev), spi->chip_select);
                 status = -ENODEV;
                 goto done;
         }
@@ -343,7 +343,7 @@ static int uwire_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
                 bits = 8;
 
         if (bits > 16) {
-                pr_debug("%s: wordsize %d?\n", spi->dev.bus_id, bits);
+                pr_debug("%s: wordsize %d?\n", dev_name(&spi->dev), bits);
                 status = -ENODEV;
                 goto done;
         }
@@ -378,7 +378,7 @@ static int uwire_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
                 hz = t->speed_hz;
 
         if (!hz) {
-                pr_debug("%s: zero speed?\n", spi->dev.bus_id);
+                pr_debug("%s: zero speed?\n", dev_name(&spi->dev));
                 status = -EINVAL;
                 goto done;
         }
@@ -406,7 +406,7 @@ static int uwire_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
         }
         if (div1_idx == 4) {
                 pr_debug("%s: lowest clock %ld, need %d\n",
-                        spi->dev.bus_id, rate / 10 / 8, hz);
+                        dev_name(&spi->dev), rate / 10 / 8, hz);
                 status = -EDOM;
                 goto done;
         }
diff --git a/drivers/spi/orion_spi.c b/drivers/spi/orion_spi.c
index 014becb7d530..c8b0babdc2a6 100644
--- a/drivers/spi/orion_spi.c
+++ b/drivers/spi/orion_spi.c
@@ -496,7 +496,7 @@ static int __init orion_spi_probe(struct platform_device *pdev)
         }
 
         if (!request_mem_region(r->start, (r->end - r->start) + 1,
-                                pdev->dev.bus_id)) {
+                                dev_name(&pdev->dev))) {
                 status = -EBUSY;
                 goto out;
         }
diff --git a/drivers/spi/pxa2xx_spi.c b/drivers/spi/pxa2xx_spi.c
index d0fc4ca2f656..ec24f2d16f3c 100644
--- a/drivers/spi/pxa2xx_spi.c
+++ b/drivers/spi/pxa2xx_spi.c
@@ -1333,7 +1333,7 @@ static int __init init_queue(struct driver_data *drv_data)
 
         INIT_WORK(&drv_data->pump_messages, pump_messages);
         drv_data->workqueue = create_singlethread_workqueue(
-                                        drv_data->master->dev.parent->bus_id);
+                                dev_name(drv_data->master->dev.parent));
         if (drv_data->workqueue == NULL)
                 return -EBUSY;
 
@@ -1462,7 +1462,7 @@ static int __init pxa2xx_spi_probe(struct platform_device *pdev)
                 drv_data->mask_sr = SSSR_TINT | SSSR_RFS | SSSR_TFS | SSSR_ROR;
         }
 
-        status = request_irq(ssp->irq, ssp_int, 0, dev->bus_id, drv_data);
+        status = request_irq(ssp->irq, ssp_int, 0, dev_name(dev), drv_data);
         if (status < 0) {
                 dev_err(&pdev->dev, "cannot get IRQ %d\n", ssp->irq);
                 goto out_error_master_alloc;
diff --git a/drivers/spi/spi_bfin5xx.c b/drivers/spi/spi_bfin5xx.c
index 7fea3cf4588a..3410b0c55ed2 100644
--- a/drivers/spi/spi_bfin5xx.c
+++ b/drivers/spi/spi_bfin5xx.c
@@ -1160,8 +1160,8 @@ static inline int init_queue(struct driver_data *drv_data)
 
         /* init messages workqueue */
         INIT_WORK(&drv_data->pump_messages, pump_messages);
-        drv_data->workqueue =
-            create_singlethread_workqueue(drv_data->master->dev.parent->bus_id);
+        drv_data->workqueue = create_singlethread_workqueue(
+                                dev_name(drv_data->master->dev.parent));
         if (drv_data->workqueue == NULL)
                 return -EBUSY;
 
diff --git a/drivers/spi/spi_gpio.c b/drivers/spi/spi_gpio.c
index f5ed9721aabb..d2866c293dee 100644
--- a/drivers/spi/spi_gpio.c
+++ b/drivers/spi/spi_gpio.c
@@ -191,7 +191,7 @@ static int spi_gpio_setup(struct spi_device *spi)
                 return -EINVAL;
 
         if (!spi->controller_state) {
-                status = gpio_request(cs, spi->dev.bus_id);
+                status = gpio_request(cs, dev_name(&spi->dev));
                 if (status)
                         return status;
                 status = gpio_direction_output(cs, spi->mode & SPI_CS_HIGH);
diff --git a/drivers/spi/spi_imx.c b/drivers/spi/spi_imx.c
index 269a55ec52ef..0480d8bb19d3 100644
--- a/drivers/spi/spi_imx.c
+++ b/drivers/spi/spi_imx.c
@@ -1381,7 +1381,7 @@ static int __init init_queue(struct driver_data *drv_data)
 
         INIT_WORK(&drv_data->work, pump_messages);
         drv_data->workqueue = create_singlethread_workqueue(
-                                        drv_data->master->dev.parent->bus_id);
+                                dev_name(drv_data->master->dev.parent));
         if (drv_data->workqueue == NULL)
                 return -EBUSY;
 
@@ -1525,7 +1525,8 @@ static int __init spi_imx_probe(struct platform_device *pdev)
                 status = -ENODEV;
                 goto err_no_irqres;
         }
-        status = request_irq(irq, spi_int, IRQF_DISABLED, dev->bus_id, drv_data);
+        status = request_irq(irq, spi_int, IRQF_DISABLED,
+                             dev_name(dev), drv_data);
         if (status < 0) {
                 dev_err(&pdev->dev, "probe - cannot get IRQ (%d)\n", status);
                 goto err_no_irqres;
diff --git a/drivers/spi/spi_mpc83xx.c b/drivers/spi/spi_mpc83xx.c
index ac0e3e4b3c54..44a2b46ccb79 100644
--- a/drivers/spi/spi_mpc83xx.c
+++ b/drivers/spi/spi_mpc83xx.c
@@ -637,7 +637,7 @@ static int __init mpc83xx_spi_probe(struct platform_device *dev)
         INIT_LIST_HEAD(&mpc83xx_spi->queue);
 
         mpc83xx_spi->workqueue = create_singlethread_workqueue(
-                master->dev.parent->bus_id);
+                dev_name(master->dev.parent));
         if (mpc83xx_spi->workqueue == NULL) {
                 ret = -EBUSY;
                 goto free_irq;
@@ -649,7 +649,7 @@ static int __init mpc83xx_spi_probe(struct platform_device *dev)
 
         printk(KERN_INFO
                "%s: MPC83xx SPI Controller driver at 0x%p (irq = %d)\n",
-               dev->dev.bus_id, mpc83xx_spi->base, mpc83xx_spi->irq);
+               dev_name(&dev->dev), mpc83xx_spi->base, mpc83xx_spi->irq);
 
         return ret;
 
diff --git a/drivers/spi/spi_txx9.c b/drivers/spi/spi_txx9.c
index 2296f37ea3c6..29cbb065618a 100644
--- a/drivers/spi/spi_txx9.c
+++ b/drivers/spi/spi_txx9.c
@@ -404,7 +404,8 @@ static int __init txx9spi_probe(struct platform_device *dev)
         if (ret)
                 goto exit;
 
-        c->workqueue = create_singlethread_workqueue(master->dev.parent->bus_id);
+        c->workqueue = create_singlethread_workqueue(
+                                dev_name(master->dev.parent));
         if (!c->workqueue)
                 goto exit_busy;
         c->last_chipselect = -1;
diff --git a/drivers/tc/tc.c b/drivers/tc/tc.c
index f77f62a4b325..e5bd4470a570 100644
--- a/drivers/tc/tc.c
+++ b/drivers/tc/tc.c
@@ -86,7 +86,7 @@ static void __init tc_bus_add_devices(struct tc_bus *tbus)
                                slot);
                         goto out_err;
                 }
-                sprintf(tdev->dev.bus_id, "tc%x", slot);
+                dev_set_name(&tdev->dev, "tc%x", slot);
                 tdev->bus = tbus;
                 tdev->dev.parent = &tbus->dev;
                 tdev->dev.bus = &tc_bus_type;
@@ -104,7 +104,7 @@ static void __init tc_bus_add_devices(struct tc_bus *tbus)
                 tdev->vendor[8] = 0;
                 tdev->name[8] = 0;
 
-                pr_info("%s: %s %s %s\n", tdev->dev.bus_id, tdev->vendor,
+                pr_info("%s: %s %s %s\n", dev_name(&tdev->dev), tdev->vendor,
                         tdev->name, tdev->firmware);
 
                 devsize = readb(module + offset + TC_SLOT_SIZE);
@@ -118,7 +118,7 @@ static void __init tc_bus_add_devices(struct tc_bus *tbus)
                 } else {
                         printk(KERN_ERR "%s: Cannot provide slot space "
                                "(%dMiB required, up to %dMiB supported)\n",
-                               tdev->dev.bus_id, devsize >> 20,
+                               dev_name(&tdev->dev), devsize >> 20,
                                max(slotsize, extslotsize) >> 20);
                         kfree(tdev);
                         goto out_err;
@@ -146,7 +146,7 @@ static int __init tc_init(void)
                 return 0;
 
         INIT_LIST_HEAD(&tc_bus.devices);
-        strcpy(tc_bus.dev.bus_id, "tc");
+        dev_set_name(&tc_bus.dev, "tc");
         device_register(&tc_bus.dev);
 
         if (tc_bus.info.slot_size) {
diff --git a/drivers/uio/Kconfig b/drivers/uio/Kconfig
index 04b954cfce76..7f86534de269 100644
--- a/drivers/uio/Kconfig
+++ b/drivers/uio/Kconfig
@@ -58,6 +58,24 @@ config UIO_SMX
 
           If you compile this as a module, it will be called uio_smx.
 
+config UIO_AEC
+        tristate "AEC video timestamp device"
+        depends on PCI
+        default n
+        help
+
+          UIO driver for the Adrienne Electronics Corporation PCI time
+          code device.
+
+          This device differs from other UIO devices since it uses I/O
+          ports instead of memory mapped I/O. In order to make it
+          possible for UIO to work with this device a utility, uioport,
+          can be used to read and write the ports:
+
+            git clone git://ifup.org/philips/uioport.git
+
+          If you compile this as a module, it will be called uio_aec.
+
 config UIO_SERCOS3
         tristate "Automata Sercos III PCI card driver"
         default n
diff --git a/drivers/uio/Makefile b/drivers/uio/Makefile
index e69558149859..5c2586d75797 100644
--- a/drivers/uio/Makefile
+++ b/drivers/uio/Makefile
@@ -3,4 +3,5 @@ obj-$(CONFIG_UIO_CIF)	+= uio_cif.o
 obj-$(CONFIG_UIO_PDRV)  += uio_pdrv.o
 obj-$(CONFIG_UIO_PDRV_GENIRQ)   += uio_pdrv_genirq.o
 obj-$(CONFIG_UIO_SMX)   += uio_smx.o
+obj-$(CONFIG_UIO_AEC)   += uio_aec.o
 obj-$(CONFIG_UIO_SERCOS3)       += uio_sercos3.o
diff --git a/drivers/uio/uio.c b/drivers/uio/uio.c
index 4ca85a113aa2..03efb065455f 100644
--- a/drivers/uio/uio.c
+++ b/drivers/uio/uio.c
@@ -61,6 +61,14 @@ struct uio_map {
 };
 #define to_map(map) container_of(map, struct uio_map, kobj)
 
+static ssize_t map_name_show(struct uio_mem *mem, char *buf)
+{
+        if (unlikely(!mem->name))
+                mem->name = "";
+
+        return sprintf(buf, "%s\n", mem->name);
+}
+
 static ssize_t map_addr_show(struct uio_mem *mem, char *buf)
 {
         return sprintf(buf, "0x%lx\n", mem->addr);
@@ -82,6 +90,8 @@ struct map_sysfs_entry {
         ssize_t (*store)(struct uio_mem *, const char *, size_t);
 };
 
+static struct map_sysfs_entry name_attribute =
+        __ATTR(name, S_IRUGO, map_name_show, NULL);
 static struct map_sysfs_entry addr_attribute =
         __ATTR(addr, S_IRUGO, map_addr_show, NULL);
 static struct map_sysfs_entry size_attribute =
@@ -90,6 +100,7 @@ static struct map_sysfs_entry offset_attribute =
         __ATTR(offset, S_IRUGO, map_offset_show, NULL);
 
 static struct attribute *attrs[] = {
+        &name_attribute.attr,
         &addr_attribute.attr,
         &size_attribute.attr,
         &offset_attribute.attr,
@@ -133,6 +144,14 @@ struct uio_portio {
 };
 #define to_portio(portio) container_of(portio, struct uio_portio, kobj)
 
+static ssize_t portio_name_show(struct uio_port *port, char *buf)
+{
+        if (unlikely(!port->name))
+                port->name = "";
+
+        return sprintf(buf, "%s\n", port->name);
+}
+
 static ssize_t portio_start_show(struct uio_port *port, char *buf)
 {
         return sprintf(buf, "0x%lx\n", port->start);
@@ -159,6 +178,8 @@ struct portio_sysfs_entry {
         ssize_t (*store)(struct uio_port *, const char *, size_t);
 };
 
+static struct portio_sysfs_entry portio_name_attribute =
+        __ATTR(name, S_IRUGO, portio_name_show, NULL);
 static struct portio_sysfs_entry portio_start_attribute =
         __ATTR(start, S_IRUGO, portio_start_show, NULL);
 static struct portio_sysfs_entry portio_size_attribute =
@@ -167,6 +188,7 @@ static struct portio_sysfs_entry portio_porttype_attribute =
         __ATTR(porttype, S_IRUGO, portio_porttype_show, NULL);
 
 static struct attribute *portio_attrs[] = {
+        &portio_name_attribute.attr,
         &portio_start_attribute.attr,
         &portio_size_attribute.attr,
         &portio_porttype_attribute.attr,
@@ -686,7 +708,8 @@ static int uio_mmap(struct file *filep, struct vm_area_struct *vma)
                 return -EINVAL;
 
         requested_pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
-        actual_pages = (idev->info->mem[mi].size + PAGE_SIZE -1) >> PAGE_SHIFT;
+        actual_pages = ((idev->info->mem[mi].addr & ~PAGE_MASK)
+                        + idev->info->mem[mi].size + PAGE_SIZE -1) >> PAGE_SHIFT;
         if (requested_pages > actual_pages)
                 return -EINVAL;
 
diff --git a/drivers/uio/uio_aec.c b/drivers/uio/uio_aec.c
new file mode 100644
index 000000000000..b7830e9a3baa
--- /dev/null
+++ b/drivers/uio/uio_aec.c
@@ -0,0 +1,175 @@
+/*
+ * uio_aec.c -- simple driver for Adrienne Electronics Corp time code PCI device
+ *
+ * Copyright (C) 2008 Brandon Philips <brandon@ifup.org>
+ *
+ *   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.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License along
+ *   with this program; if not, write to the Free Software Foundation, Inc., 59
+ *   Temple Place, Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/cdev.h>
+#include <linux/fs.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
+#include <linux/uio_driver.h>
+
+#define PCI_VENDOR_ID_AEC 0xaecb
+#define PCI_DEVICE_ID_AEC_VITCLTC 0x6250
+
+#define INT_ENABLE_ADDR         0xFC
+#define INT_ENABLE              0x10
+#define INT_DISABLE             0x0
+
+#define INT_MASK_ADDR           0x2E
+#define INT_MASK_ALL            0x3F
+
+#define INTA_DRVR_ADDR          0xFE
+#define INTA_ENABLED_FLAG       0x08
+#define INTA_FLAG               0x01
+
+#define MAILBOX                 0x0F
+
+static struct pci_device_id ids[] = {
+        { PCI_DEVICE(PCI_VENDOR_ID_AEC, PCI_DEVICE_ID_AEC_VITCLTC), },
+        { 0, }
+};
+MODULE_DEVICE_TABLE(pci, ids);
+
+static irqreturn_t aectc_irq(int irq, struct uio_info *dev_info)
+{
+        void __iomem *int_flag = dev_info->priv + INTA_DRVR_ADDR;
+        unsigned char status = ioread8(int_flag);
+
+
+        if ((status & INTA_ENABLED_FLAG) && (status & INTA_FLAG)) {
+                /* application writes 0x00 to 0x2F to get next interrupt */
+                status = ioread8(dev_info->priv + MAILBOX);
+                return IRQ_HANDLED;
+        }
+
+        return IRQ_NONE;
+}
+
+static void print_board_data(struct pci_dev *pdev, struct uio_info *i)
+{
+        dev_info(&pdev->dev, "PCI-TC board vendor: %x%x number: %x%x"
+                " revision: %c%c\n",
+                ioread8(i->priv + 0x01),
+                ioread8(i->priv + 0x00),
+                ioread8(i->priv + 0x03),
+                ioread8(i->priv + 0x02),
+                ioread8(i->priv + 0x06),
+                ioread8(i->priv + 0x07));
+}
+
+static int __devinit probe(struct pci_dev *pdev, const struct pci_device_id *id)
+{
+        struct uio_info *info;
+        int ret;
+
+        info = kzalloc(sizeof(struct uio_info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+
+        if (pci_enable_device(pdev))
+                goto out_free;
+
+        if (pci_request_regions(pdev, "aectc"))
+                goto out_disable;
+
+        info->name = "aectc";
+        info->port[0].start = pci_resource_start(pdev, 0);
+        if (!info->port[0].start)
+                goto out_release;
+        info->priv = pci_iomap(pdev, 0, 0);
+        if (!info->priv)
+                goto out_release;
+        info->port[0].size = pci_resource_len(pdev, 0);
+        info->port[0].porttype = UIO_PORT_GPIO;
+
+        info->version = "0.0.1";
+        info->irq = pdev->irq;
+        info->irq_flags = IRQF_SHARED;
+        info->handler = aectc_irq;
+
+        print_board_data(pdev, info);
+        ret = uio_register_device(&pdev->dev, info);
+        if (ret)
+                goto out_unmap;
+
+        iowrite32(INT_ENABLE, info->priv + INT_ENABLE_ADDR);
+        iowrite8(INT_MASK_ALL, info->priv + INT_MASK_ADDR);
+        if (!(ioread8(info->priv + INTA_DRVR_ADDR)
+                        & INTA_ENABLED_FLAG))
+                dev_err(&pdev->dev, "aectc: interrupts not enabled\n");
+
+        pci_set_drvdata(pdev, info);
+
+        return 0;
+
+out_unmap:
+        pci_iounmap(pdev, info->priv);
+out_release:
+        pci_release_regions(pdev);
+out_disable:
+        pci_disable_device(pdev);
+out_free:
+        kfree(info);
+        return -ENODEV;
+}
+
+static void remove(struct pci_dev *pdev)
+{
+        struct uio_info *info = pci_get_drvdata(pdev);
+
+        /* disable interrupts */
+        iowrite8(INT_DISABLE, info->priv + INT_MASK_ADDR);
+        iowrite32(INT_DISABLE, info->priv + INT_ENABLE_ADDR);
+        /* read mailbox to ensure board drops irq */
+        ioread8(info->priv + MAILBOX);
+
+        uio_unregister_device(info);
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+        pci_set_drvdata(pdev, NULL);
+        iounmap(info->priv);
+
+        kfree(info);
+}
+
+static struct pci_driver pci_driver = {
+        .name = "aectc",
+        .id_table = ids,
+        .probe = probe,
+        .remove = remove,
+};
+
+static int __init aectc_init(void)
+{
+        return pci_register_driver(&pci_driver);
+}
+
+static void __exit aectc_exit(void)
+{
+        pci_unregister_driver(&pci_driver);
+}
+
+MODULE_LICENSE("GPL");
+
+module_init(aectc_init);
+module_exit(aectc_exit);
diff --git a/drivers/usb/gadget/ci13xxx_udc.c b/drivers/usb/gadget/ci13xxx_udc.c
index bebf911c7e5f..7f4e5eb1dc80 100644
--- a/drivers/usb/gadget/ci13xxx_udc.c
+++ b/drivers/usb/gadget/ci13xxx_udc.c
@@ -2626,7 +2626,7 @@ static int udc_probe(struct device *dev, void __iomem *regs, const char *name)
         INIT_LIST_HEAD(&udc->gadget.ep_list);
         udc->gadget.ep0 = NULL;
 
-        strcpy(udc->gadget.dev.bus_id, "gadget");
+        dev_set_name(&udc->gadget.dev, "gadget");
         udc->gadget.dev.dma_mask = dev->dma_mask;
         udc->gadget.dev.parent   = dev;
         udc->gadget.dev.release  = udc_release;
diff --git a/drivers/usb/gadget/imx_udc.c b/drivers/usb/gadget/imx_udc.c
index 77c5d0a8a06e..cd67ac75e624 100644
--- a/drivers/usb/gadget/imx_udc.c
+++ b/drivers/usb/gadget/imx_udc.c
@@ -1186,8 +1186,8 @@ static struct imx_udc_struct controller = {
                 .ep0            = &controller.imx_ep[0].ep,
                 .name           = driver_name,
                 .dev = {
-                         .bus_id        = "gadget",
-                 },
+                        .init_name      = "gadget",
+                },
         },
 
         .imx_ep[0] = {
diff --git a/drivers/usb/host/fhci-dbg.c b/drivers/usb/host/fhci-dbg.c
index 34e14edf390b..ea8a4255c5da 100644
--- a/drivers/usb/host/fhci-dbg.c
+++ b/drivers/usb/host/fhci-dbg.c
@@ -108,7 +108,7 @@ void fhci_dfs_create(struct fhci_hcd *fhci)
 {
         struct device *dev = fhci_to_hcd(fhci)->self.controller;
 
-        fhci->dfs_root = debugfs_create_dir(dev->bus_id, NULL);
+        fhci->dfs_root = debugfs_create_dir(dev_name(dev), NULL);
         if (!fhci->dfs_root) {
                 WARN_ON(1);
                 return;
diff --git a/drivers/usb/host/fhci-hcd.c b/drivers/usb/host/fhci-hcd.c
index ba622cc8a9ba..0951818ef93b 100644
--- a/drivers/usb/host/fhci-hcd.c
+++ b/drivers/usb/host/fhci-hcd.c
@@ -583,7 +583,7 @@ static int __devinit of_fhci_probe(struct of_device *ofdev,
         if (sprop && strcmp(sprop, "host"))
                 return -ENODEV;
 
-        hcd = usb_create_hcd(&fhci_driver, dev, dev->bus_id);
+        hcd = usb_create_hcd(&fhci_driver, dev, dev_name(dev));
         if (!hcd) {
                 dev_err(dev, "could not create hcd\n");
                 return -ENOMEM;
@@ -650,7 +650,7 @@ static int __devinit of_fhci_probe(struct of_device *ofdev,
                         }
                 }
 
-                ret = gpio_request(gpio, dev->bus_id);
+                ret = gpio_request(gpio, dev_name(dev));
                 if (ret) {
                         dev_err(dev, "failed to request gpio %d", i);
                         goto err_gpios;
diff --git a/drivers/video/au1100fb.c b/drivers/video/au1100fb.c
index 62bd4441b5e0..378f27745a1d 100644
--- a/drivers/video/au1100fb.c
+++ b/drivers/video/au1100fb.c
@@ -457,7 +457,7 @@ static struct fb_ops au1100fb_ops =
 
 /* AU1100 LCD controller device driver */
 
-static int __init au1100fb_drv_probe(struct device *dev)
+static int __init au1100fb_drv_probe(struct platform_device *dev)
 {
         struct au1100fb_device *fbdev = NULL;
         struct resource *regs_res;
@@ -475,7 +475,7 @@ static int __init au1100fb_drv_probe(struct device *dev)
 
         fbdev->panel = &known_lcd_panels[drv_info.panel_idx];
 
-        dev_set_drvdata(dev, (void*)fbdev);
+        platform_set_drvdata(dev, (void *)fbdev);
 
         /* Allocate region for our registers and map them */
         if (!(regs_res = platform_get_resource(to_platform_device(dev),
@@ -583,19 +583,19 @@ failed:
                 fb_dealloc_cmap(&fbdev->info.cmap);
         }
         kfree(fbdev);
-        dev_set_drvdata(dev, NULL);
+        platform_set_drvdata(dev, NULL);
 
         return 0;
 }
 
-int au1100fb_drv_remove(struct device *dev)
+int au1100fb_drv_remove(struct platform_device *dev)
 {
         struct au1100fb_device *fbdev = NULL;
 
         if (!dev)
                 return -ENODEV;
 
-        fbdev = (struct au1100fb_device*) dev_get_drvdata(dev);
+        fbdev = (struct au1100fb_device *) platform_get_drvdata(dev);
 
 #if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
         au1100fb_fb_blank(VESA_POWERDOWN, &fbdev->info);
@@ -620,9 +620,9 @@ int au1100fb_drv_remove(struct device *dev)
 static u32 sys_clksrc;
 static struct au1100fb_regs fbregs;
 
-int au1100fb_drv_suspend(struct device *dev, pm_message_t state)
+int au1100fb_drv_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct au1100fb_device *fbdev = dev_get_drvdata(dev);
+        struct au1100fb_device *fbdev = platform_get_drvdata(dev);
 
         if (!fbdev)
                 return 0;
@@ -641,9 +641,9 @@ int au1100fb_drv_suspend(struct device *dev, pm_message_t state)
         return 0;
 }
 
-int au1100fb_drv_resume(struct device *dev)
+int au1100fb_drv_resume(struct platform_device *dev)
 {
-        struct au1100fb_device *fbdev = dev_get_drvdata(dev);
+        struct au1100fb_device *fbdev = platform_get_drvdata(dev);
 
         if (!fbdev)
                 return 0;
@@ -663,10 +663,11 @@ int au1100fb_drv_resume(struct device *dev)
 #define au1100fb_drv_resume NULL
 #endif
 
-static struct device_driver au1100fb_driver = {
-        .name           = "au1100-lcd",
-        .bus            = &platform_bus_type,
-
+static struct platform_driver au1100fb_driver = {
+        .driver = {
+                .name           = "au1100-lcd",
+                .owner          = THIS_MODULE,
+        },
         .probe          = au1100fb_drv_probe,
         .remove         = au1100fb_drv_remove,
         .suspend        = au1100fb_drv_suspend,
@@ -753,12 +754,12 @@ int __init au1100fb_init(void)
                 return ret;
         }
 
-        return driver_register(&au1100fb_driver);
+        return platform_driver_register(&au1100fb_driver);
 }
 
 void __exit au1100fb_cleanup(void)
 {
-        driver_unregister(&au1100fb_driver);
+        platform_driver_unregister(&au1100fb_driver);
 
         kfree(drv_info.opt_mode);
 }
diff --git a/drivers/video/au1200fb.c b/drivers/video/au1200fb.c
index 03e57ef88378..0d96f1d2d4c5 100644
--- a/drivers/video/au1200fb.c
+++ b/drivers/video/au1200fb.c
@@ -1622,7 +1622,7 @@ static int au1200fb_init_fbinfo(struct au1200fb_device *fbdev)
 
 /* AU1200 LCD controller device driver */
 
-static int au1200fb_drv_probe(struct device *dev)
+static int au1200fb_drv_probe(struct platform_device *dev)
 {
         struct au1200fb_device *fbdev;
         unsigned long page;
@@ -1645,7 +1645,7 @@ static int au1200fb_drv_probe(struct device *dev)
                 /* Allocate the framebuffer to the maximum screen size */
                 fbdev->fb_len = (win->w[plane].xres * win->w[plane].yres * bpp) / 8;
 
-                fbdev->fb_mem = dma_alloc_noncoherent(dev,
+                fbdev->fb_mem = dma_alloc_noncoherent(&dev->dev,
                                 PAGE_ALIGN(fbdev->fb_len),
                                 &fbdev->fb_phys, GFP_KERNEL);
                 if (!fbdev->fb_mem) {
@@ -1715,7 +1715,7 @@ failed:
         return ret;
 }
 
-static int au1200fb_drv_remove(struct device *dev)
+static int au1200fb_drv_remove(struct platform_device *dev)
 {
         struct au1200fb_device *fbdev;
         int plane;
@@ -1733,7 +1733,8 @@ static int au1200fb_drv_remove(struct device *dev)
                 /* Clean up all probe data */
                 unregister_framebuffer(&fbdev->fb_info);
                 if (fbdev->fb_mem)
-                        dma_free_noncoherent(dev, PAGE_ALIGN(fbdev->fb_len),
+                        dma_free_noncoherent(&dev->dev,
+                                        PAGE_ALIGN(fbdev->fb_len),
                                         fbdev->fb_mem, fbdev->fb_phys);
                 if (fbdev->fb_info.cmap.len != 0)
                         fb_dealloc_cmap(&fbdev->fb_info.cmap);
@@ -1747,22 +1748,24 @@ static int au1200fb_drv_remove(struct device *dev)
 }
 
 #ifdef CONFIG_PM
-static int au1200fb_drv_suspend(struct device *dev, u32 state, u32 level)
+static int au1200fb_drv_suspend(struct platform_device *dev, u32 state)
 {
         /* TODO */
         return 0;
 }
 
-static int au1200fb_drv_resume(struct device *dev, u32 level)
+static int au1200fb_drv_resume(struct platform_device *dev)
 {
         /* TODO */
         return 0;
 }
 #endif /* CONFIG_PM */
 
-static struct device_driver au1200fb_driver = {
-        .name           = "au1200-lcd",
-        .bus            = &platform_bus_type,
+static struct platform_driver au1200fb_driver = {
+        .driver = {
+                .name           = "au1200-lcd",
+                .owner          = THIS_MODULE,
+        },
         .probe          = au1200fb_drv_probe,
         .remove         = au1200fb_drv_remove,
 #ifdef CONFIG_PM
@@ -1906,12 +1909,12 @@ static int __init au1200fb_init(void)
                 printk(KERN_INFO "Power management device entry for the au1200fb loaded.\n");
         #endif
 
-        return driver_register(&au1200fb_driver);
+        return platform_driver_register(&au1200fb_driver);
 }
 
 static void __exit au1200fb_cleanup(void)
 {
-        driver_unregister(&au1200fb_driver);
+        platform_driver_unregister(&au1200fb_driver);
 }
 
 module_init(au1200fb_init);
diff --git a/drivers/video/pmag-ba-fb.c b/drivers/video/pmag-ba-fb.c
index 3a3f80f65219..0573ec685a57 100644
--- a/drivers/video/pmag-ba-fb.c
+++ b/drivers/video/pmag-ba-fb.c
@@ -151,7 +151,7 @@ static int __init pmagbafb_probe(struct device *dev)
 
         info = framebuffer_alloc(sizeof(struct pmagbafb_par), dev);
         if (!info) {
-                printk(KERN_ERR "%s: Cannot allocate memory\n", dev->bus_id);
+                printk(KERN_ERR "%s: Cannot allocate memory\n", dev_name(dev));
                 return -ENOMEM;
         }
 
@@ -160,7 +160,7 @@ static int __init pmagbafb_probe(struct device *dev)
 
         if (fb_alloc_cmap(&info->cmap, 256, 0) < 0) {
                 printk(KERN_ERR "%s: Cannot allocate color map\n",
-                       dev->bus_id);
+                       dev_name(dev));
                 err = -ENOMEM;
                 goto err_alloc;
         }
@@ -173,8 +173,9 @@ static int __init pmagbafb_probe(struct device *dev)
         /* Request the I/O MEM resource.  */
         start = tdev->resource.start;
         len = tdev->resource.end - start + 1;
-        if (!request_mem_region(start, len, dev->bus_id)) {
-                printk(KERN_ERR "%s: Cannot reserve FB region\n", dev->bus_id);
+        if (!request_mem_region(start, len, dev_name(dev))) {
+                printk(KERN_ERR "%s: Cannot reserve FB region\n",
+                       dev_name(dev));
                 err = -EBUSY;
                 goto err_cmap;
         }
@@ -183,7 +184,7 @@ static int __init pmagbafb_probe(struct device *dev)
         info->fix.mmio_start = start;
         par->mmio = ioremap_nocache(info->fix.mmio_start, info->fix.mmio_len);
         if (!par->mmio) {
-                printk(KERN_ERR "%s: Cannot map MMIO\n", dev->bus_id);
+                printk(KERN_ERR "%s: Cannot map MMIO\n", dev_name(dev));
                 err = -ENOMEM;
                 goto err_resource;
         }
@@ -194,7 +195,7 @@ static int __init pmagbafb_probe(struct device *dev)
         info->screen_base = ioremap_nocache(info->fix.smem_start,
                                             info->fix.smem_len);
         if (!info->screen_base) {
-                printk(KERN_ERR "%s: Cannot map FB\n", dev->bus_id);
+                printk(KERN_ERR "%s: Cannot map FB\n", dev_name(dev));
                 err = -ENOMEM;
                 goto err_mmio_map;
         }
@@ -205,14 +206,14 @@ static int __init pmagbafb_probe(struct device *dev)
         err = register_framebuffer(info);
         if (err < 0) {
                 printk(KERN_ERR "%s: Cannot register framebuffer\n",
-                       dev->bus_id);
+                       dev_name(dev));
                 goto err_smem_map;
         }
 
         get_device(dev);
 
         pr_info("fb%d: %s frame buffer device at %s\n",
-                info->node, info->fix.id, dev->bus_id);
+                info->node, info->fix.id, dev_name(dev));
 
         return 0;
 
diff --git a/drivers/video/pmagb-b-fb.c b/drivers/video/pmagb-b-fb.c
index 9b80597241b0..98748723af9f 100644
--- a/drivers/video/pmagb-b-fb.c
+++ b/drivers/video/pmagb-b-fb.c
@@ -258,7 +258,7 @@ static int __init pmagbbfb_probe(struct device *dev)
 
         info = framebuffer_alloc(sizeof(struct pmagbbfb_par), dev);
         if (!info) {
-                printk(KERN_ERR "%s: Cannot allocate memory\n", dev->bus_id);
+                printk(KERN_ERR "%s: Cannot allocate memory\n", dev_name(dev));
                 return -ENOMEM;
         }
 
@@ -267,7 +267,7 @@ static int __init pmagbbfb_probe(struct device *dev)
 
         if (fb_alloc_cmap(&info->cmap, 256, 0) < 0) {
                 printk(KERN_ERR "%s: Cannot allocate color map\n",
-                       dev->bus_id);
+                       dev_name(dev));
                 err = -ENOMEM;
                 goto err_alloc;
         }
@@ -280,8 +280,9 @@ static int __init pmagbbfb_probe(struct device *dev)
         /* Request the I/O MEM resource.  */
         start = tdev->resource.start;
         len = tdev->resource.end - start + 1;
-        if (!request_mem_region(start, len, dev->bus_id)) {
-                printk(KERN_ERR "%s: Cannot reserve FB region\n", dev->bus_id);
+        if (!request_mem_region(start, len, dev_name(dev))) {
+                printk(KERN_ERR "%s: Cannot reserve FB region\n",
+                       dev_name(dev));
                 err = -EBUSY;
                 goto err_cmap;
         }
@@ -290,7 +291,7 @@ static int __init pmagbbfb_probe(struct device *dev)
         info->fix.mmio_start = start;
         par->mmio = ioremap_nocache(info->fix.mmio_start, info->fix.mmio_len);
         if (!par->mmio) {
-                printk(KERN_ERR "%s: Cannot map MMIO\n", dev->bus_id);
+                printk(KERN_ERR "%s: Cannot map MMIO\n", dev_name(dev));
                 err = -ENOMEM;
                 goto err_resource;
         }
@@ -301,7 +302,7 @@ static int __init pmagbbfb_probe(struct device *dev)
         info->fix.smem_start = start + PMAGB_B_FBMEM;
         par->smem = ioremap_nocache(info->fix.smem_start, info->fix.smem_len);
         if (!par->smem) {
-                printk(KERN_ERR "%s: Cannot map FB\n", dev->bus_id);
+                printk(KERN_ERR "%s: Cannot map FB\n", dev_name(dev));
                 err = -ENOMEM;
                 goto err_mmio_map;
         }
@@ -316,7 +317,7 @@ static int __init pmagbbfb_probe(struct device *dev)
         err = register_framebuffer(info);
         if (err < 0) {
                 printk(KERN_ERR "%s: Cannot register framebuffer\n",
-                       dev->bus_id);
+                       dev_name(dev));
                 goto err_smem_map;
         }
 
@@ -328,7 +329,7 @@ static int __init pmagbbfb_probe(struct device *dev)
                  par->osc1 / 1000, par->osc1 % 1000);
 
         pr_info("fb%d: %s frame buffer device at %s\n",
-                info->node, info->fix.id, dev->bus_id);
+                info->node, info->fix.id, dev_name(dev));
         pr_info("fb%d: Osc0: %s, Osc1: %s, Osc%u selected\n",
                 info->node, freq0, par->osc1 ? freq1 : "disabled",
                 par->osc1 != 0);
diff --git a/drivers/video/ps3fb.c b/drivers/video/ps3fb.c
index 87f826e4c958..e00c1dff55de 100644
--- a/drivers/video/ps3fb.c
+++ b/drivers/video/ps3fb.c
@@ -1213,7 +1213,7 @@ static int __devinit ps3fb_probe(struct ps3_system_bus_device *dev)
         dev->core.driver_data = info;
 
         dev_info(info->device, "%s %s, using %u KiB of video memory\n",
-                 dev_driver_string(info->dev), info->dev->bus_id,
+                 dev_driver_string(info->dev), dev_name(info->dev),
                  info->fix.smem_len >> 10);
 
         task = kthread_run(ps3fbd, info, DEVICE_NAME);
diff --git a/drivers/video/sh_mobile_lcdcfb.c b/drivers/video/sh_mobile_lcdcfb.c
index b433b8ac76d9..92ea0ab44ce2 100644
--- a/drivers/video/sh_mobile_lcdcfb.c
+++ b/drivers/video/sh_mobile_lcdcfb.c
@@ -737,7 +737,7 @@ static int __init sh_mobile_lcdc_probe(struct platform_device *pdev)
         }
 
         error = request_irq(i, sh_mobile_lcdc_irq, IRQF_DISABLED,
-                            pdev->dev.bus_id, priv);
+                            dev_name(&pdev->dev), priv);
         if (error) {
                 dev_err(&pdev->dev, "unable to request irq\n");
                 goto err1;
diff --git a/drivers/video/tmiofb.c b/drivers/video/tmiofb.c
index 7baf2dd12d50..a1eb0862255b 100644
--- a/drivers/video/tmiofb.c
+++ b/drivers/video/tmiofb.c
@@ -751,7 +751,7 @@ static int __devinit tmiofb_probe(struct platform_device *dev)
         }
 
         retval = request_irq(irq, &tmiofb_irq, IRQF_DISABLED,
-                                        dev->dev.bus_id, info);
+                                        dev_name(&dev->dev), info);
 
         if (retval)
                 goto err_request_irq;
diff --git a/drivers/watchdog/rm9k_wdt.c b/drivers/watchdog/rm9k_wdt.c
index f1ae3729a19e..cce1982a1b58 100644
--- a/drivers/watchdog/rm9k_wdt.c
+++ b/drivers/watchdog/rm9k_wdt.c
@@ -59,8 +59,8 @@ static long wdt_gpi_ioctl(struct file *, unsigned int, unsigned long);
 static int wdt_gpi_notify(struct notifier_block *, unsigned long, void *);
 static const struct resource *wdt_gpi_get_resource(struct platform_device *,
                                                 const char *, unsigned int);
-static int __init wdt_gpi_probe(struct device *);
-static int __exit wdt_gpi_remove(struct device *);
+static int __init wdt_gpi_probe(struct platform_device *);
+static int __exit wdt_gpi_remove(struct platform_device *);
 
 
 static const char wdt_gpi_name[] = "wdt_gpi";
@@ -346,10 +346,9 @@ static const struct resource *wdt_gpi_get_resource(struct platform_device *pdv,
 }
 
 /* No hotplugging on the platform bus - use __init */
-static int __init wdt_gpi_probe(struct device *dev)
+static int __init wdt_gpi_probe(struct platform_device *pdv)
 {
         int res;
-        struct platform_device * const pdv = to_platform_device(dev);
         const struct resource
                 * const rr = wdt_gpi_get_resource(pdv, WDT_RESOURCE_REGS,
                                                   IORESOURCE_MEM),
@@ -374,7 +373,7 @@ static int __init wdt_gpi_probe(struct device *dev)
         return res;
 }
 
-static int __exit wdt_gpi_remove(struct device *dev)
+static int __exit wdt_gpi_remove(struct platform_device *dev)
 {
         int res;
 
@@ -387,15 +386,13 @@ static int __exit wdt_gpi_remove(struct device *dev)
 
 
 /* Device driver init & exit */
-static struct device_driver wdt_gpi_driver = {
-        .name           = (char *) wdt_gpi_name,
-        .bus            = &platform_bus_type,
-        .owner          = THIS_MODULE,
+static struct platform_driver wgt_gpi_driver = {
+        .driver = {
+                .name           = wdt_gpi_name,
+                .owner          = THIS_MODULE,
+        },
         .probe          = wdt_gpi_probe,
-        .remove         = __exit_p(wdt_gpi_remove),
-        .shutdown       = NULL,
-        .suspend        = NULL,
-        .resume         = NULL,
+        .remove         = __devexit_p(wdt_gpi_remove),
 };
 
 static int __init wdt_gpi_init_module(void)
@@ -403,12 +400,12 @@ static int __init wdt_gpi_init_module(void)
         atomic_set(&opencnt, 1);
         if (timeout > MAX_TIMEOUT_SECONDS)
                 timeout = MAX_TIMEOUT_SECONDS;
-        return driver_register(&wdt_gpi_driver);
+        return platform_driver_register(&wdt_gpi_driver);
 }
 
 static void __exit wdt_gpi_cleanup_module(void)
 {
-        driver_unregister(&wdt_gpi_driver);
+        platform_driver_unregister(&wdt_gpi_driver);
 }
 
 module_init(wdt_gpi_init_module);
diff --git a/drivers/zorro/zorro.c b/drivers/zorro/zorro.c
index a1585d6f6486..d45fb34e2d23 100644
--- a/drivers/zorro/zorro.c
+++ b/drivers/zorro/zorro.c
@@ -140,7 +140,7 @@ static int __init zorro_init(void)
 
     /* Initialize the Zorro bus */
     INIT_LIST_HEAD(&zorro_bus.devices);
-    strcpy(zorro_bus.dev.bus_id, "zorro");
+    dev_set_name(&zorro_bus.dev, "zorro");
     error = device_register(&zorro_bus.dev);
     if (error) {
         pr_err("Zorro: Error registering zorro_bus\n");
@@ -167,7 +167,7 @@ static int __init zorro_init(void)
         if (request_resource(zorro_find_parent_resource(z), &z->resource))
             pr_err("Zorro: Address space collision on device %s %pR\n",
                    z->name, &z->resource);
-        sprintf(z->dev.bus_id, "%02x", i);
+        dev_set_name(&z->dev, "%02x", i);
         z->dev.parent = &zorro_bus.dev;
         z->dev.bus = &zorro_bus_type;
         error = device_register(&z->dev);