17 files changed, 162 insertions, 99 deletions

diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index dad0449475b6..aaccc8ecfa8f 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -2508,8 +2508,6 @@ int dasd_generic_restore_device(struct ccw_device *cdev)
         device->stopped &= ~DASD_UNRESUMED_PM;
 
         dasd_schedule_device_bh(device);
-        if (device->block)
-                dasd_schedule_block_bh(device->block);
 
         if (device->discipline->restore)
                 rc = device->discipline->restore(device);
@@ -2520,6 +2518,9 @@ int dasd_generic_restore_device(struct ccw_device *cdev)
                  */
                 device->stopped |= DASD_UNRESUMED_PM;
 
+        if (device->block)
+                dasd_schedule_block_bh(device->block);
+
         dasd_put_device(device);
         return 0;
 }
@@ -2532,6 +2533,7 @@ static struct dasd_ccw_req *dasd_generic_build_rdc(struct dasd_device *device,
 {
         struct dasd_ccw_req *cqr;
         struct ccw1 *ccw;
+        unsigned long *idaw;
 
         cqr = dasd_smalloc_request(magic, 1 /* RDC */, rdc_buffer_size, device);
 
@@ -2545,9 +2547,17 @@ static struct dasd_ccw_req *dasd_generic_build_rdc(struct dasd_device *device,
 
         ccw = cqr->cpaddr;
         ccw->cmd_code = CCW_CMD_RDC;
-        ccw->cda = (__u32)(addr_t)rdc_buffer;
-        ccw->count = rdc_buffer_size;
+        if (idal_is_needed(rdc_buffer, rdc_buffer_size)) {
+                idaw = (unsigned long *) (cqr->data);
+                ccw->cda = (__u32)(addr_t) idaw;
+                ccw->flags = CCW_FLAG_IDA;
+                idaw = idal_create_words(idaw, rdc_buffer, rdc_buffer_size);
+        } else {
+                ccw->cda = (__u32)(addr_t) rdc_buffer;
+                ccw->flags = 0;
+        }
 
+        ccw->count = rdc_buffer_size;
         cqr->startdev = device;
         cqr->memdev = device;
         cqr->expires = 10*HZ;
diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index ab3521755588..417b97cd3f94 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -2338,6 +2338,8 @@ static struct dasd_ccw_req *dasd_eckd_build_cp(struct dasd_device *startdev,
         /* Calculate number of blocks/records per track. */
         blksize = block->bp_block;
         blk_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
+        if (blk_per_trk == 0)
+                return ERR_PTR(-EINVAL);
         /* Calculate record id of first and last block. */
         first_rec = first_trk = blk_rq_pos(req) >> block->s2b_shift;
         first_offs = sector_div(first_trk, blk_per_trk);
@@ -3211,8 +3213,10 @@ int dasd_eckd_pm_freeze(struct dasd_device *device)
 int dasd_eckd_restore_device(struct dasd_device *device)
 {
         struct dasd_eckd_private *private;
+        struct dasd_eckd_characteristics temp_rdc_data;
         int is_known, rc;
         struct dasd_uid temp_uid;
+        unsigned long flags;
 
         private = (struct dasd_eckd_private *) device->private;
 
@@ -3225,7 +3229,8 @@ int dasd_eckd_restore_device(struct dasd_device *device)
         rc = dasd_eckd_generate_uid(device, &private->uid);
         dasd_get_uid(device->cdev, &temp_uid);
         if (memcmp(&private->uid, &temp_uid, sizeof(struct dasd_uid)) != 0)
-                dev_err(&device->cdev->dev, "The UID of the DASD has changed\n");
+                dev_err(&device->cdev->dev, "The UID of the DASD has "
+                        "changed\n");
         if (rc)
                 goto out_err;
         dasd_set_uid(device->cdev, &private->uid);
@@ -3245,15 +3250,17 @@ int dasd_eckd_restore_device(struct dasd_device *device)
         dasd_eckd_read_features(device);
 
         /* Read Device Characteristics */
-        memset(&private->rdc_data, 0, sizeof(private->rdc_data));
         rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC,
-                                         &private->rdc_data, 64);
+                                         &temp_rdc_data, 64);
         if (rc) {
                 DBF_EVENT(DBF_WARNING,
                           "Read device characteristics failed, rc=%d for "
                           "device: %s", rc, dev_name(&device->cdev->dev));
                 goto out_err;
         }
+        spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
+        memcpy(&private->rdc_data, &temp_rdc_data, sizeof(temp_rdc_data));
+        spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
 
         /* add device to alias management */
         dasd_alias_add_device(device);
diff --git a/drivers/s390/char/raw3270.c b/drivers/s390/char/raw3270.c
index d6a022f55e92..62ddf5202b79 100644
--- a/drivers/s390/char/raw3270.c
+++ b/drivers/s390/char/raw3270.c
@@ -1361,11 +1361,13 @@ static int raw3270_pm_start(struct ccw_device *cdev)
 
 void raw3270_pm_unfreeze(struct raw3270_view *view)
 {
+#ifdef CONFIG_TN3270_CONSOLE
         struct raw3270 *rp;
 
         rp = view->dev;
         if (rp && test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
                 ccw_device_force_console();
+#endif
 }
 
 static struct ccw_device_id raw3270_id[] = {
diff --git a/drivers/s390/char/sclp_async.c b/drivers/s390/char/sclp_async.c
index daaec185ed36..a4f68e5b9c96 100644
--- a/drivers/s390/char/sclp_async.c
+++ b/drivers/s390/char/sclp_async.c
@@ -62,7 +62,7 @@ static struct notifier_block call_home_panic_nb = {
         .priority = INT_MAX,
 };
 
-static int proc_handler_callhome(ctl_table *ctl, int write, struct file *filp,
+static int proc_handler_callhome(struct ctl_table *ctl, int write,
                                  void __user *buffer, size_t *count,
                                  loff_t *ppos)
 {
@@ -100,7 +100,7 @@ static struct ctl_table callhome_table[] = {
         {
                 .procname       = "callhome",
                 .mode           = 0644,
-                .proc_handler   = &proc_handler_callhome,
+                .proc_handler   = proc_handler_callhome,
         },
         { .ctl_name = 0 }
 };
diff --git a/drivers/s390/char/sclp_vt220.c b/drivers/s390/char/sclp_vt220.c
index 178724f2a4c3..b9d2a007e93b 100644
--- a/drivers/s390/char/sclp_vt220.c
+++ b/drivers/s390/char/sclp_vt220.c
@@ -705,21 +705,6 @@ out_driver:
 }
 __initcall(sclp_vt220_tty_init);
 
-#ifdef CONFIG_SCLP_VT220_CONSOLE
-
-static void
-sclp_vt220_con_write(struct console *con, const char *buf, unsigned int count)
-{
-        __sclp_vt220_write((const unsigned char *) buf, count, 1, 1, 0);
-}
-
-static struct tty_driver *
-sclp_vt220_con_device(struct console *c, int *index)
-{
-        *index = 0;
-        return sclp_vt220_driver;
-}
-
 static void __sclp_vt220_flush_buffer(void)
 {
         unsigned long flags;
@@ -776,6 +761,21 @@ static void sclp_vt220_pm_event_fn(struct sclp_register *reg,
         }
 }
 
+#ifdef CONFIG_SCLP_VT220_CONSOLE
+
+static void
+sclp_vt220_con_write(struct console *con, const char *buf, unsigned int count)
+{
+        __sclp_vt220_write((const unsigned char *) buf, count, 1, 1, 0);
+}
+
+static struct tty_driver *
+sclp_vt220_con_device(struct console *c, int *index)
+{
+        *index = 0;
+        return sclp_vt220_driver;
+}
+
 static int
 sclp_vt220_notify(struct notifier_block *self,
                           unsigned long event, void *data)
diff --git a/drivers/s390/char/tape_block.c b/drivers/s390/char/tape_block.c
index 64f57ef2763c..0c0705b91c28 100644
--- a/drivers/s390/char/tape_block.c
+++ b/drivers/s390/char/tape_block.c
@@ -162,9 +162,10 @@ tapeblock_requeue(struct work_struct *work) {
         spin_lock_irq(&device->blk_data.request_queue_lock);
         while (
                 !blk_queue_plugged(queue) &&
-                (req = blk_fetch_request(queue)) &&
+                blk_peek_request(queue) &&
                 nr_queued < TAPEBLOCK_MIN_REQUEUE
         ) {
+                req = blk_fetch_request(queue);
                 if (rq_data_dir(req) == WRITE) {
                         DBF_EVENT(1, "TBLOCK: Rejecting write request\n");
                         spin_unlock_irq(&device->blk_data.request_queue_lock);
diff --git a/drivers/s390/cio/blacklist.c b/drivers/s390/cio/blacklist.c
index 6565f027791e..7eab9ab9f406 100644
--- a/drivers/s390/cio/blacklist.c
+++ b/drivers/s390/cio/blacklist.c
@@ -265,13 +265,11 @@ struct ccwdev_iter {
 static void *
 cio_ignore_proc_seq_start(struct seq_file *s, loff_t *offset)
 {
-        struct ccwdev_iter *iter;
+        struct ccwdev_iter *iter = s->private;
 
         if (*offset >= (__MAX_SUBCHANNEL + 1) * (__MAX_SSID + 1))
                 return NULL;
-        iter = kzalloc(sizeof(struct ccwdev_iter), GFP_KERNEL);
-        if (!iter)
-                return ERR_PTR(-ENOMEM);
+        memset(iter, 0, sizeof(*iter));
         iter->ssid = *offset / (__MAX_SUBCHANNEL + 1);
         iter->devno = *offset % (__MAX_SUBCHANNEL + 1);
         return iter;
@@ -280,8 +278,6 @@ cio_ignore_proc_seq_start(struct seq_file *s, loff_t *offset)
 static void
 cio_ignore_proc_seq_stop(struct seq_file *s, void *it)
 {
-        if (!IS_ERR(it))
-                kfree(it);
 }
 
 static void *
@@ -378,14 +374,15 @@ static const struct seq_operations cio_ignore_proc_seq_ops = {
 static int
 cio_ignore_proc_open(struct inode *inode, struct file *file)
 {
-        return seq_open(file, &cio_ignore_proc_seq_ops);
+        return seq_open_private(file, &cio_ignore_proc_seq_ops,
+                                sizeof(struct ccwdev_iter));
 }
 
 static const struct file_operations cio_ignore_proc_fops = {
         .open    = cio_ignore_proc_open,
         .read    = seq_read,
         .llseek  = seq_lseek,
-        .release = seq_release,
+        .release = seq_release_private,
         .write   = cio_ignore_write,
 };
 
diff --git a/drivers/s390/cio/chp.c b/drivers/s390/cio/chp.c
index 40002830d48a..8ab51608da55 100644
--- a/drivers/s390/cio/chp.c
+++ b/drivers/s390/cio/chp.c
@@ -393,7 +393,6 @@ int chp_new(struct chp_id chpid)
         chp->state = 1;
         chp->dev.parent = &channel_subsystems[chpid.cssid]->device;
         chp->dev.release = chp_release;
-        dev_set_name(&chp->dev, "chp%x.%02x", chpid.cssid, chpid.id);
 
         /* Obtain channel path description and fill it in. */
         ret = chsc_determine_base_channel_path_desc(chpid, &chp->desc);
@@ -411,6 +410,7 @@ int chp_new(struct chp_id chpid)
         } else {
                 chp->cmg = -1;
         }
+        dev_set_name(&chp->dev, "chp%x.%02x", chpid.cssid, chpid.id);
 
         /* make it known to the system */
         ret = device_register(&chp->dev);
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index f780bdd3a04e..2490b741e16a 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -1250,8 +1250,7 @@ static int io_subchannel_probe(struct subchannel *sch)
         unsigned long flags;
         struct ccw_dev_id dev_id;
 
-        cdev = sch_get_cdev(sch);
-        if (cdev) {
+        if (cio_is_console(sch->schid)) {
                 rc = sysfs_create_group(&sch->dev.kobj,
                                         &io_subchannel_attr_group);
                 if (rc)
@@ -1260,13 +1259,13 @@ static int io_subchannel_probe(struct subchannel *sch)
                                       "0.%x.%04x (rc=%d)\n",
                                       sch->schid.ssid, sch->schid.sch_no, rc);
                 /*
-                 * This subchannel already has an associated ccw_device.
+                 * The console subchannel already has an associated ccw_device.
                  * Throw the delayed uevent for the subchannel, register
-                 * the ccw_device and exit. This happens for all early
-                 * devices, e.g. the console.
+                 * the ccw_device and exit.
                  */
                 dev_set_uevent_suppress(&sch->dev, 0);
                 kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
+                cdev = sch_get_cdev(sch);
                 cdev->dev.groups = ccwdev_attr_groups;
                 device_initialize(&cdev->dev);
                 ccw_device_register(cdev);
@@ -1609,7 +1608,7 @@ int ccw_purge_blacklisted(void)
         return 0;
 }
 
-static void device_set_disconnected(struct ccw_device *cdev)
+void ccw_device_set_disconnected(struct ccw_device *cdev)
 {
         if (!cdev)
                 return;
@@ -1705,7 +1704,7 @@ static int io_subchannel_sch_event(struct subchannel *sch, int slow)
                 ccw_device_trigger_reprobe(cdev);
                 break;
         case DISC:
-                device_set_disconnected(cdev);
+                ccw_device_set_disconnected(cdev);
                 break;
         default:
                 break;
diff --git a/drivers/s390/cio/device.h b/drivers/s390/cio/device.h
index ed39a2caaf47..246c6482842c 100644
--- a/drivers/s390/cio/device.h
+++ b/drivers/s390/cio/device.h
@@ -125,6 +125,7 @@ int ccw_device_stlck(struct ccw_device *);
 void ccw_device_trigger_reprobe(struct ccw_device *);
 void ccw_device_kill_io(struct ccw_device *);
 int ccw_device_notify(struct ccw_device *, int);
+void ccw_device_set_disconnected(struct ccw_device *cdev);
 void ccw_device_set_notoper(struct ccw_device *cdev);
 
 /* qdio needs this. */
diff --git a/drivers/s390/cio/device_fsm.c b/drivers/s390/cio/device_fsm.c
index e728ce447f6e..b9613d7df9ef 100644
--- a/drivers/s390/cio/device_fsm.c
+++ b/drivers/s390/cio/device_fsm.c
@@ -387,19 +387,35 @@ ccw_device_done(struct ccw_device *cdev, int state)
 
         cdev->private->state = state;
 
-        if (state == DEV_STATE_BOXED) {
+        switch (state) {
+        case DEV_STATE_BOXED:
                 CIO_MSG_EVENT(0, "Boxed device %04x on subchannel %04x\n",
                               cdev->private->dev_id.devno, sch->schid.sch_no);
                 if (cdev->online && !ccw_device_notify(cdev, CIO_BOXED))
                         ccw_device_schedule_sch_unregister(cdev);
                 cdev->private->flags.donotify = 0;
-        }
-        if (state == DEV_STATE_NOT_OPER) {
+                break;
+        case DEV_STATE_NOT_OPER:
                 CIO_MSG_EVENT(0, "Device %04x gone on subchannel %04x\n",
                               cdev->private->dev_id.devno, sch->schid.sch_no);
                 if (!ccw_device_notify(cdev, CIO_GONE))
                         ccw_device_schedule_sch_unregister(cdev);
+                else
+                        ccw_device_set_disconnected(cdev);
                 cdev->private->flags.donotify = 0;
+                break;
+        case DEV_STATE_DISCONNECTED:
+                CIO_MSG_EVENT(0, "Disconnected device %04x on subchannel "
+                              "%04x\n", cdev->private->dev_id.devno,
+                              sch->schid.sch_no);
+                if (!ccw_device_notify(cdev, CIO_NO_PATH))
+                        ccw_device_schedule_sch_unregister(cdev);
+                else
+                        ccw_device_set_disconnected(cdev);
+                cdev->private->flags.donotify = 0;
+                break;
+        default:
+                break;
         }
 
         if (cdev->private->flags.donotify) {
@@ -671,6 +687,10 @@ ccw_device_offline(struct ccw_device *cdev)
                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
                 return 0;
         }
+        if (cdev->private->state == DEV_STATE_BOXED) {
+                ccw_device_done(cdev, DEV_STATE_BOXED);
+                return 0;
+        }
         if (ccw_device_is_orphan(cdev)) {
                 ccw_device_done(cdev, DEV_STATE_OFFLINE);
                 return 0;
@@ -730,11 +750,10 @@ ccw_device_recog_notoper(struct ccw_device *cdev, enum dev_event dev_event)
 static void ccw_device_generic_notoper(struct ccw_device *cdev,
                                        enum dev_event dev_event)
 {
-        struct subchannel *sch;
-
-        ccw_device_set_notoper(cdev);
-        sch = to_subchannel(cdev->dev.parent);
-        css_schedule_eval(sch->schid);
+        if (!ccw_device_notify(cdev, CIO_GONE))
+                ccw_device_schedule_sch_unregister(cdev);
+        else
+                ccw_device_set_disconnected(cdev);
 }
 
 /*
diff --git a/drivers/s390/crypto/zcrypt_pcixcc.c b/drivers/s390/crypto/zcrypt_pcixcc.c
index c20d4790258e..5677b40e4ac0 100644
--- a/drivers/s390/crypto/zcrypt_pcixcc.c
+++ b/drivers/s390/crypto/zcrypt_pcixcc.c
@@ -361,7 +361,7 @@ static void rng_type6CPRB_msgX(struct ap_device *ap_dev,
                 .ToCardLen1     = sizeof *msg - sizeof(msg->hdr),
                 .FromCardLen1   = sizeof *msg - sizeof(msg->hdr),
         };
-        static struct CPRBX static_cprbx = {
+        static struct CPRBX local_cprbx = {
                 .cprb_len       = 0x00dc,
                 .cprb_ver_id    = 0x02,
                 .func_id        = {0x54, 0x32},
@@ -372,7 +372,7 @@ static void rng_type6CPRB_msgX(struct ap_device *ap_dev,
 
         msg->hdr = static_type6_hdrX;
         msg->hdr.FromCardLen2 = random_number_length,
-        msg->cprbx = static_cprbx;
+        msg->cprbx = local_cprbx;
         msg->cprbx.rpl_datal = random_number_length,
         msg->cprbx.domain = AP_QID_QUEUE(ap_dev->qid);
         memcpy(msg->function_code, msg->hdr.function_code, 0x02);
@@ -561,7 +561,8 @@ static int convert_response_ica(struct zcrypt_device *zdev,
                 if (msg->cprbx.cprb_ver_id == 0x02)
                         return convert_type86_ica(zdev, reply,
                                                   outputdata, outputdatalength);
-                /* no break, incorrect cprb version is an unknown response */
+                /* Fall through, no break, incorrect cprb version is an unknown
+                 * response */
         default: /* Unknown response type, this should NEVER EVER happen */
                 zdev->online = 0;
                 return -EAGAIN; /* repeat the request on a different device. */
@@ -587,7 +588,8 @@ static int convert_response_xcrb(struct zcrypt_device *zdev,
                 }
                 if (msg->cprbx.cprb_ver_id == 0x02)
                         return convert_type86_xcrb(zdev, reply, xcRB);
-                /* no break, incorrect cprb version is an unknown response */
+                /* Fall through, no break, incorrect cprb version is an unknown
+                 * response */
         default: /* Unknown response type, this should NEVER EVER happen */
                 xcRB->status = 0x0008044DL; /* HDD_InvalidParm */
                 zdev->online = 0;
@@ -610,7 +612,8 @@ static int convert_response_rng(struct zcrypt_device *zdev,
                         return -EINVAL;
                 if (msg->cprbx.cprb_ver_id == 0x02)
                         return convert_type86_rng(zdev, reply, data);
-                /* no break, incorrect cprb version is an unknown response */
+                /* Fall through, no break, incorrect cprb version is an unknown
+                 * response */
         default: /* Unknown response type, this should NEVER EVER happen */
                 zdev->online = 0;
                 return -EAGAIN; /* repeat the request on a different device. */
diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c
index 1be6bf7e8ce6..0f79f3af4f54 100644
--- a/drivers/s390/scsi/zfcp_aux.c
+++ b/drivers/s390/scsi/zfcp_aux.c
@@ -80,28 +80,35 @@ int zfcp_reqlist_isempty(struct zfcp_adapter *adapter)
 
 static void __init zfcp_init_device_configure(char *busid, u64 wwpn, u64 lun)
 {
+        struct ccw_device *ccwdev;
         struct zfcp_adapter *adapter;
         struct zfcp_port *port;
         struct zfcp_unit *unit;
 
-        mutex_lock(&zfcp_data.config_mutex);
-        read_lock_irq(&zfcp_data.config_lock);
-        adapter = zfcp_get_adapter_by_busid(busid);
-        if (adapter)
-                zfcp_adapter_get(adapter);
-        read_unlock_irq(&zfcp_data.config_lock);
+        ccwdev = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
+        if (!ccwdev)
+                return;
+
+        if (ccw_device_set_online(ccwdev))
+                goto out_ccwdev;
 
+        mutex_lock(&zfcp_data.config_mutex);
+        adapter = dev_get_drvdata(&ccwdev->dev);
         if (!adapter)
-                goto out_adapter;
-        port = zfcp_port_enqueue(adapter, wwpn, 0, 0);
-        if (IS_ERR(port))
+                goto out_unlock;
+        zfcp_adapter_get(adapter);
+
+        port = zfcp_get_port_by_wwpn(adapter, wwpn);
+        if (!port)
                 goto out_port;
+
+        zfcp_port_get(port);
         unit = zfcp_unit_enqueue(port, lun);
         if (IS_ERR(unit))
                 goto out_unit;
         mutex_unlock(&zfcp_data.config_mutex);
-        ccw_device_set_online(adapter->ccw_device);
 
+        zfcp_erp_unit_reopen(unit, 0, "auidc_1", NULL);
         zfcp_erp_wait(adapter);
         flush_work(&unit->scsi_work);
 
@@ -111,8 +118,10 @@ out_unit:
         zfcp_port_put(port);
 out_port:
         zfcp_adapter_put(adapter);
-out_adapter:
+out_unlock:
         mutex_unlock(&zfcp_data.config_mutex);
+out_ccwdev:
+        put_device(&ccwdev->dev);
         return;
 }
 
@@ -593,10 +602,8 @@ void zfcp_adapter_dequeue(struct zfcp_adapter *adapter)
         int retval = 0;
         unsigned long flags;
 
-        cancel_work_sync(&adapter->scan_work);
         cancel_work_sync(&adapter->stat_work);
         zfcp_fc_wka_ports_force_offline(adapter->gs);
-        zfcp_adapter_scsi_unregister(adapter);
         sysfs_remove_group(&adapter->ccw_device->dev.kobj,
                            &zfcp_sysfs_adapter_attrs);
         dev_set_drvdata(&adapter->ccw_device->dev, NULL);
diff --git a/drivers/s390/scsi/zfcp_ccw.c b/drivers/s390/scsi/zfcp_ccw.c
index 0c90f8e71605..e08339428ecf 100644
--- a/drivers/s390/scsi/zfcp_ccw.c
+++ b/drivers/s390/scsi/zfcp_ccw.c
@@ -102,6 +102,14 @@ static void zfcp_ccw_remove(struct ccw_device *ccw_device)
         adapter = dev_get_drvdata(&ccw_device->dev);
         if (!adapter)
                 goto out;
+        mutex_unlock(&zfcp_data.config_mutex);
+
+        cancel_work_sync(&adapter->scan_work);
+
+        mutex_lock(&zfcp_data.config_mutex);
+
+        /* this also removes the scsi devices, so call it first */
+        zfcp_adapter_scsi_unregister(adapter);
 
         write_lock_irq(&zfcp_data.config_lock);
         list_for_each_entry_safe(port, p, &adapter->port_list_head, list) {
@@ -117,11 +125,8 @@ static void zfcp_ccw_remove(struct ccw_device *ccw_device)
         write_unlock_irq(&zfcp_data.config_lock);
 
         list_for_each_entry_safe(port, p, &port_remove_lh, list) {
-                list_for_each_entry_safe(unit, u, &unit_remove_lh, list) {
-                        if (unit->device)
-                                scsi_remove_device(unit->device);
+                list_for_each_entry_safe(unit, u, &unit_remove_lh, list)
                         zfcp_unit_dequeue(unit);
-                }
                 zfcp_port_dequeue(port);
         }
         wait_event(adapter->remove_wq, atomic_read(&adapter->refcount) == 0);
@@ -192,13 +197,9 @@ static int zfcp_ccw_set_offline(struct ccw_device *ccw_device)
 
         mutex_lock(&zfcp_data.config_mutex);
         adapter = dev_get_drvdata(&ccw_device->dev);
-        if (!adapter)
-                goto out;
-
         zfcp_erp_adapter_shutdown(adapter, 0, "ccsoff1", NULL);
         zfcp_erp_wait(adapter);
         mutex_unlock(&zfcp_data.config_mutex);
-out:
         return 0;
 }
 
@@ -253,13 +254,17 @@ static void zfcp_ccw_shutdown(struct ccw_device *cdev)
 
         mutex_lock(&zfcp_data.config_mutex);
         adapter = dev_get_drvdata(&cdev->dev);
+        if (!adapter)
+                goto out;
+
         zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1", NULL);
         zfcp_erp_wait(adapter);
         zfcp_erp_thread_kill(adapter);
+out:
         mutex_unlock(&zfcp_data.config_mutex);
 }
 
-static struct ccw_driver zfcp_ccw_driver = {
+struct ccw_driver zfcp_ccw_driver = {
         .owner       = THIS_MODULE,
         .name        = "zfcp",
         .ids         = zfcp_ccw_device_id,
@@ -284,20 +289,3 @@ int __init zfcp_ccw_register(void)
 {
         return ccw_driver_register(&zfcp_ccw_driver);
 }
-
-/**
- * zfcp_get_adapter_by_busid - find zfcp_adapter struct
- * @busid: bus id string of zfcp adapter to find
- */
-struct zfcp_adapter *zfcp_get_adapter_by_busid(char *busid)
-{
-        struct ccw_device *ccw_device;
-        struct zfcp_adapter *adapter = NULL;
-
-        ccw_device = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
-        if (ccw_device) {
-                adapter = dev_get_drvdata(&ccw_device->dev);
-                put_device(&ccw_device->dev);
-        }
-        return adapter;
-}
diff --git a/drivers/s390/scsi/zfcp_cfdc.c b/drivers/s390/scsi/zfcp_cfdc.c
index 8305c874e86f..ef681dfed0cc 100644
--- a/drivers/s390/scsi/zfcp_cfdc.c
+++ b/drivers/s390/scsi/zfcp_cfdc.c
@@ -86,8 +86,23 @@ static int zfcp_cfdc_copy_to_user(void __user  *user_buffer,
 static struct zfcp_adapter *zfcp_cfdc_get_adapter(u32 devno)
 {
         char busid[9];
+        struct ccw_device *ccwdev;
+        struct zfcp_adapter *adapter = NULL;
+
         snprintf(busid, sizeof(busid), "0.0.%04x", devno);
-        return zfcp_get_adapter_by_busid(busid);
+        ccwdev = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
+        if (!ccwdev)
+                goto out;
+
+        adapter = dev_get_drvdata(&ccwdev->dev);
+        if (!adapter)
+                goto out_put;
+
+        zfcp_adapter_get(adapter);
+out_put:
+        put_device(&ccwdev->dev);
+out:
+        return adapter;
 }
 
 static int zfcp_cfdc_set_fsf(struct zfcp_fsf_cfdc *fsf_cfdc, int command)
diff --git a/drivers/s390/scsi/zfcp_ext.h b/drivers/s390/scsi/zfcp_ext.h
index 36935bc0818f..629edec70405 100644
--- a/drivers/s390/scsi/zfcp_ext.h
+++ b/drivers/s390/scsi/zfcp_ext.h
@@ -28,7 +28,7 @@ extern int zfcp_sg_setup_table(struct scatterlist *, int);
 /* zfcp_ccw.c */
 extern int zfcp_ccw_register(void);
 extern int zfcp_ccw_priv_sch(struct zfcp_adapter *);
-extern struct zfcp_adapter *zfcp_get_adapter_by_busid(char *);
+extern struct ccw_driver zfcp_ccw_driver;
 
 /* zfcp_cfdc.c */
 extern struct miscdevice zfcp_cfdc_misc;
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
index f09c863dc6bd..38a7e4a6b639 100644
--- a/drivers/s390/scsi/zfcp_fsf.c
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -1058,11 +1058,25 @@ static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req *req,
         bytes = zfcp_qdio_sbals_from_sg(adapter->qdio, &req->queue_req,
                                         SBAL_FLAGS0_TYPE_WRITE_READ,
                                         sg_resp, max_sbals);
+        req->qtcb->bottom.support.resp_buf_length = bytes;
         if (bytes <= 0)
                 return -EIO;
 
+        return 0;
+}
+
+static int zfcp_fsf_setup_ct_els(struct zfcp_fsf_req *req,
+                                 struct scatterlist *sg_req,
+                                 struct scatterlist *sg_resp,
+                                 int max_sbals)
+{
+        int ret;
+
+        ret = zfcp_fsf_setup_ct_els_sbals(req, sg_req, sg_resp, max_sbals);
+        if (ret)
+                return ret;
+
         /* common settings for ct/gs and els requests */
-        req->qtcb->bottom.support.resp_buf_length = bytes;
         req->qtcb->bottom.support.service_class = FSF_CLASS_3;
         req->qtcb->bottom.support.timeout = 2 * R_A_TOV;
         zfcp_fsf_start_timer(req, 2 * R_A_TOV + 10);
@@ -1094,8 +1108,8 @@ int zfcp_fsf_send_ct(struct zfcp_send_ct *ct, mempool_t *pool)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        ret = zfcp_fsf_setup_ct_els_sbals(req, ct->req, ct->resp,
-                                          FSF_MAX_SBALS_PER_REQ);
+        ret = zfcp_fsf_setup_ct_els(req, ct->req, ct->resp,
+                                    FSF_MAX_SBALS_PER_REQ);
         if (ret)
                 goto failed_send;
 
@@ -1192,7 +1206,7 @@ int zfcp_fsf_send_els(struct zfcp_send_els *els)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        ret = zfcp_fsf_setup_ct_els_sbals(req, els->req, els->resp, 2);
+        ret = zfcp_fsf_setup_ct_els(req, els->req, els->resp, 2);
 
         if (ret)
                 goto failed_send;