device_set_intretry(sch);
        /* Call handler. */
        if (sch->driver && sch->driver->termination)
-               sch->driver->termination(&sch->dev);
+               sch->driver->termination(sch);
 }
 
 static int
                        terminate_internal_io(sch);
                        /* Re-start path verification. */
                        if (sch->driver && sch->driver->verify)
-                               sch->driver->verify(&sch->dev);
+                               sch->driver->verify(sch);
                }
        } else {
                /* trigger path verification. */
                if (sch->driver && sch->driver->verify)
-                       sch->driver->verify(&sch->dev);
+                       sch->driver->verify(sch);
                else if (sch->lpm == mask)
                        goto out_unreg;
        }
        if (!old_lpm && sch->lpm)
                device_trigger_reprobe(sch);
        else if (sch->driver && sch->driver->verify)
-               sch->driver->verify(&sch->dev);
+               sch->driver->verify(sch);
 out:
        spin_unlock_irq(sch->lock);
        put_device(&sch->dev);
                    | mask) & sch->opm;
 
        if (sch->driver && sch->driver->verify)
-               sch->driver->verify(&sch->dev);
+               sch->driver->verify(sch);
 
        spin_unlock_irq(sch->lock);
        put_device(&sch->dev);
                        if (!old_lpm)
                                device_trigger_reprobe(sch);
                        else if (sch->driver && sch->driver->verify)
-                               sch->driver->verify(&sch->dev);
+                               sch->driver->verify(sch);
                        break;
                }
                sch->opm &= ~mask;
                                terminate_internal_io(sch);
                                /* Re-start path verification. */
                                if (sch->driver && sch->driver->verify)
-                                       sch->driver->verify(&sch->dev);
+                                       sch->driver->verify(sch);
                        }
                } else if (!sch->lpm) {
                        if (device_trigger_verify(sch) != 0)
                                css_schedule_eval(sch->schid);
                } else if (sch->driver && sch->driver->verify)
-                       sch->driver->verify(&sch->dev);
+                       sch->driver->verify(sch);
                break;
        }
        spin_unlock_irqrestore(sch->lock, flags);
 
        spin_lock(sch->lock);
        memcpy (&sch->schib.scsw, &irb->scsw, sizeof (struct scsw));
        if (sch->driver && sch->driver->irq)
-               sch->driver->irq(&sch->dev);
+               sch->driver->irq(sch);
        spin_unlock(sch->lock);
        irq_exit ();
        _local_bh_enable();
                                sizeof (irb->scsw));
                        /* Call interrupt handler if there is one. */
                        if (sch->driver && sch->driver->irq)
-                               sch->driver->irq(&sch->dev);
+                               sch->driver->irq(sch);
                }
                if (sch)
                        spin_unlock(sch->lock);
 
                action = UNREGISTER;
                if (sch->driver && sch->driver->notify) {
                        spin_unlock_irqrestore(sch->lock, flags);
-                       ret = sch->driver->notify(&sch->dev, event);
+                       ret = sch->driver->notify(sch, event);
                        spin_lock_irqsave(sch->lock, flags);
                        if (ret)
                                action = NONE;
 
 struct css_driver {
        unsigned int subchannel_type;
        struct device_driver drv;
-       void (*irq)(struct device *);
-       int (*notify)(struct device *, int);
-       void (*verify)(struct device *);
-       void (*termination)(struct device *);
+       void (*irq)(struct subchannel *);
+       int (*notify)(struct subchannel *, int);
+       void (*verify)(struct subchannel *);
+       void (*termination)(struct subchannel *);
        int (*probe)(struct subchannel *);
        int (*remove)(struct subchannel *);
        void (*shutdown)(struct subchannel *);
 
 
 struct bus_type ccw_bus_type;
 
-static int io_subchannel_probe (struct subchannel *);
-static int io_subchannel_remove (struct subchannel *);
-static int io_subchannel_notify(struct device *, int);
-static void io_subchannel_verify(struct device *);
-static void io_subchannel_ioterm(struct device *);
+static void io_subchannel_irq(struct subchannel *);
+static int io_subchannel_probe(struct subchannel *);
+static int io_subchannel_remove(struct subchannel *);
+static int io_subchannel_notify(struct subchannel *, int);
+static void io_subchannel_verify(struct subchannel *);
+static void io_subchannel_ioterm(struct subchannel *);
 static void io_subchannel_shutdown(struct subchannel *);
 
 static struct css_driver io_subchannel_driver = {
        put_device(&cdev->dev);
 }
 
+static void io_subchannel_irq(struct subchannel *sch)
+{
+       struct ccw_device *cdev;
+
+       cdev = sch->dev.driver_data;
+
+       CIO_TRACE_EVENT(3, "IRQ");
+       CIO_TRACE_EVENT(3, sch->dev.bus_id);
+       if (cdev)
+               dev_fsm_event(cdev, DEV_EVENT_INTERRUPT);
+}
+
 static int
 io_subchannel_probe (struct subchannel *sch)
 {
        return 0;
 }
 
-static int
-io_subchannel_notify(struct device *dev, int event)
+static int io_subchannel_notify(struct subchannel *sch, int event)
 {
        struct ccw_device *cdev;
 
-       cdev = dev->driver_data;
+       cdev = sch->dev.driver_data;
        if (!cdev)
                return 0;
        if (!cdev->drv)
        return cdev->drv->notify ? cdev->drv->notify(cdev, event) : 0;
 }
 
-static void
-io_subchannel_verify(struct device *dev)
+static void io_subchannel_verify(struct subchannel *sch)
 {
        struct ccw_device *cdev;
 
-       cdev = dev->driver_data;
+       cdev = sch->dev.driver_data;
        if (cdev)
                dev_fsm_event(cdev, DEV_EVENT_VERIFY);
 }
 
-static void
-io_subchannel_ioterm(struct device *dev)
+static void io_subchannel_ioterm(struct subchannel *sch)
 {
        struct ccw_device *cdev;
 
-       cdev = dev->driver_data;
+       cdev = sch->dev.driver_data;
        if (!cdev)
                return;
        /* Internal I/O will be retried by the interrupt handler. */
 
 extern wait_queue_head_t ccw_device_init_wq;
 extern atomic_t ccw_device_init_count;
 
-void io_subchannel_irq (struct device *pdev);
 void io_subchannel_recog_done(struct ccw_device *cdev);
 
 int ccw_device_cancel_halt_clear(struct ccw_device *);
 
        sch = to_subchannel(cdev->dev.parent);
        if (sch->driver && sch->driver->notify) {
                spin_unlock_irqrestore(cdev->ccwlock, flags);
-               ret = sch->driver->notify(&sch->dev, CIO_OPER);
+               ret = sch->driver->notify(sch, CIO_OPER);
                spin_lock_irqsave(cdev->ccwlock, flags);
        } else
                ret = 0;
        },
 };
 
-/*
- * io_subchannel_irq is called for "real" interrupts or for status
- * pending conditions on msch.
- */
-void
-io_subchannel_irq (struct device *pdev)
-{
-       struct ccw_device *cdev;
-
-       cdev = to_subchannel(pdev)->dev.driver_data;
-
-       CIO_TRACE_EVENT (3, "IRQ");
-       CIO_TRACE_EVENT (3, pdev->bus_id);
-       if (cdev)
-               dev_fsm_event(cdev, DEV_EVENT_INTERRUPT);
-}
-
 EXPORT_SYMBOL_GPL(ccw_device_set_timeout);