gdev = to_ccwgroupdev(dev);
 
        for (i = 0; i < gdev->count; i++) {
-               gdev->cdev[i]->dev.driver_data = NULL;
+               dev_set_drvdata(&gdev->cdev[i]->dev, NULL);
                put_device(&gdev->cdev[i]->dev);
        }
        kfree(gdev);
                        goto error;
                }
                /* Don't allow a device to belong to more than one group. */
-               if (gdev->cdev[i]->dev.driver_data) {
+               if (dev_get_drvdata(&gdev->cdev[i]->dev)) {
                        rc = -EINVAL;
                        goto error;
                }
-               gdev->cdev[i]->dev.driver_data = gdev;
+               dev_set_drvdata(&gdev->cdev[i]->dev, gdev);
        }
 
        gdev->creator_id = creator_id;
 error:
        for (i = 0; i < argc; i++)
                if (gdev->cdev[i]) {
-                       if (gdev->cdev[i]->dev.driver_data == gdev)
-                               gdev->cdev[i]->dev.driver_data = NULL;
+                       if (dev_get_drvdata(&gdev->cdev[i]->dev) == gdev)
+                               dev_set_drvdata(&gdev->cdev[i]->dev, NULL);
                        put_device(&gdev->cdev[i]->dev);
                }
        mutex_unlock(&gdev->reg_mutex);
 {
        struct ccwgroup_device *gdev;
 
-       if (cdev->dev.driver_data) {
-               gdev = (struct ccwgroup_device *)cdev->dev.driver_data;
+       gdev = dev_get_drvdata(&cdev->dev);
+       if (gdev) {
                if (get_device(&gdev->dev)) {
                        mutex_lock(&gdev->reg_mutex);
                        if (device_is_registered(&gdev->dev))
 
 {
        css_update_ssd_info(sch);
        spin_lock_irq(sch->lock);
-       sch->dev.driver_data = cdev;
+       sch_set_cdev(sch, cdev);
        cdev->private->schid = sch->schid;
        cdev->ccwlock = sch->lock;
        device_trigger_reprobe(sch);
                put_device(&other_sch->dev);
                return;
        }
-       other_sch->dev.driver_data = NULL;
+       sch_set_cdev(other_sch, NULL);
        /* No need to keep a subchannel without ccw device around. */
        css_sch_device_unregister(other_sch);
        put_device(&other_sch->dev);
                return;
        }
        spin_lock_irq(sch->lock);
-       sch->dev.driver_data = cdev;
+       sch_set_cdev(sch, cdev);
        spin_unlock_irq(sch->lock);
        /* Start recognition for the new ccw device. */
        if (io_subchannel_recog(cdev, sch)) {
                spin_lock_irq(sch->lock);
-               sch->dev.driver_data = NULL;
+               sch_set_cdev(sch, NULL);
                spin_unlock_irq(sch->lock);
                if (cdev->dev.release)
                        cdev->dev.release(&cdev->dev);
                              cdev->private->dev_id.devno, ret);
                put_device(&cdev->dev);
                spin_lock_irqsave(sch->lock, flags);
-               sch->dev.driver_data = NULL;
+               sch_set_cdev(sch, NULL);
                spin_unlock_irqrestore(sch->lock, flags);
                kfree (cdev->private);
                kfree (cdev);
        int rc;
        struct ccw_device_private *priv;
 
-       sch->dev.driver_data = cdev;
+       sch_set_cdev(sch, cdev);
        sch->driver = &io_subchannel_driver;
        cdev->ccwlock = sch->lock;
 
        }
        if (former_parent) {
                spin_lock_irq(former_parent->lock);
-               former_parent->dev.driver_data = NULL;
+               sch_set_cdev(former_parent, NULL);
                spin_unlock_irq(former_parent->lock);
                css_sch_device_unregister(former_parent);
                /* Reset intparm to zeroes. */
 {
        struct ccw_device *cdev;
 
-       cdev = sch->dev.driver_data;
+       cdev = sch_get_cdev(sch);
 
        CIO_TRACE_EVENT(3, "IRQ");
        CIO_TRACE_EVENT(3, sch->dev.bus_id);
        unsigned long flags;
        struct ccw_dev_id dev_id;
 
-       if (sch->dev.driver_data) {
+       cdev = sch_get_cdev(sch);
+       if (cdev) {
                /*
                 * This subchannel already has an associated ccw_device.
                 * Register it and exit. This happens for all early
                 * device, e.g. the console.
                 */
-               cdev = sch->dev.driver_data;
                cdev->dev.groups = ccwdev_attr_groups;
                device_initialize(&cdev->dev);
                ccw_device_register(cdev);
        rc = io_subchannel_recog(cdev, sch);
        if (rc) {
                spin_lock_irqsave(sch->lock, flags);
-               sch->dev.driver_data = NULL;
+               sch_set_cdev(sch, NULL);
                spin_unlock_irqrestore(sch->lock, flags);
                if (cdev->dev.release)
                        cdev->dev.release(&cdev->dev);
        struct ccw_device *cdev;
        unsigned long flags;
 
-       if (!sch->dev.driver_data)
+       cdev = sch_get_cdev(sch);
+       if (!cdev)
                return 0;
-       cdev = sch->dev.driver_data;
        /* Set ccw device to not operational and drop reference. */
        spin_lock_irqsave(cdev->ccwlock, flags);
-       sch->dev.driver_data = NULL;
+       sch_set_cdev(sch, NULL);
        cdev->private->state = DEV_STATE_NOT_OPER;
        spin_unlock_irqrestore(cdev->ccwlock, flags);
        ccw_device_unregister(cdev);
 {
        struct ccw_device *cdev;
 
-       cdev = sch->dev.driver_data;
+       cdev = sch_get_cdev(sch);
        if (!cdev)
                return 0;
        if (!cdev->drv)
 {
        struct ccw_device *cdev;
 
-       cdev = sch->dev.driver_data;
+       cdev = sch_get_cdev(sch);
        if (cdev)
                dev_fsm_event(cdev, DEV_EVENT_VERIFY);
 }
 {
        struct ccw_device *cdev;
 
-       cdev = sch->dev.driver_data;
+       cdev = sch_get_cdev(sch);
        if (!cdev)
                return;
        /* Internal I/O will be retried by the interrupt handler. */
        struct ccw_device *cdev;
        int ret;
 
-       cdev = sch->dev.driver_data;
+       cdev = sch_get_cdev(sch);
 
        if (cio_is_console(sch->schid))
                return;
 
 {
        struct ccw_device *cdev;
 
-       if (!sch->dev.driver_data)
+       cdev = sch_get_cdev(sch);
+       if (!cdev)
                return 0;
-       cdev = sch->dev.driver_data;
        return (cdev->private->state == DEV_STATE_ONLINE);
 }
 
 {
        struct ccw_device *cdev;
 
-       if (!sch->dev.driver_data)
+       cdev = sch_get_cdev(sch);
+       if (!cdev)
                return 0;
-       cdev = sch->dev.driver_data;
        return (cdev->private->state == DEV_STATE_DISCONNECTED ||
                cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID);
 }
 {
        struct ccw_device *cdev;
 
-       if (!sch->dev.driver_data)
+       cdev = sch_get_cdev(sch);
+       if (!cdev)
                return;
-       cdev = sch->dev.driver_data;
        ccw_device_set_timeout(cdev, 0);
        cdev->private->flags.fake_irb = 0;
        cdev->private->state = DEV_STATE_DISCONNECTED;
 {
        struct ccw_device *cdev;
 
-       cdev = sch->dev.driver_data;
+       cdev = sch_get_cdev(sch);
        if (!cdev)
                return;
        cdev->private->flags.intretry = 1;
 {
        struct ccw_device *cdev;
 
-       cdev = sch->dev.driver_data;
+       cdev = sch_get_cdev(sch);
        if (!cdev || !cdev->online)
                return -EINVAL;
        dev_fsm_event(cdev, DEV_EVENT_VERIFY);
 {
        struct ccw_device *cdev;
 
-       if (!sch->dev.driver_data)
+       cdev = sch_get_cdev(sch);
+       if (!cdev)
                return;
-       cdev = sch->dev.driver_data;
        ccw_device_set_timeout(cdev, 0);
 }
 
        int ret;
        struct ccw_device *cdev;
 
-       cdev = sch->dev.driver_data;
+       cdev = sch_get_cdev(sch);
        ret = ccw_device_cancel_halt_clear(cdev);
        if (ret == -EBUSY) {
                ccw_device_set_timeout(cdev, 3*HZ);
 {
        struct ccw_device *cdev;
 
-       if (!sch->dev.driver_data)
+       cdev = sch_get_cdev(sch);
+       if (!cdev)
                return;
-       cdev = sch->dev.driver_data;
        if (cdev->private->state != DEV_STATE_DISCONNECTED)
                return;