Merge branch 'wip-2.6.34' into old-private-masterarchived-private-master

127 files changed, 6762 insertions, 5560 deletions

diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index aaccc8ecfa8f..fa2339cb1681 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -20,12 +20,13 @@
 #include <linux/buffer_head.h>
 #include <linux/hdreg.h>
 #include <linux/async.h>
+#include <linux/mutex.h>
 
 #include <asm/ccwdev.h>
 #include <asm/ebcdic.h>
 #include <asm/idals.h>
-#include <asm/todclk.h>
 #include <asm/itcw.h>
+#include <asm/diag.h>
 
 /* This is ugly... */
 #define PRINTK_HEADER "dasd:"
@@ -36,6 +37,9 @@
  */
 #define DASD_CHANQ_MAX_SIZE 4
 
+#define DASD_SLEEPON_START_TAG  (void *) 1
+#define DASD_SLEEPON_END_TAG    (void *) 2
+
 /*
  * SECTION: exported variables of dasd.c
  */
@@ -64,6 +68,7 @@ static void do_restore_device(struct work_struct *);
 static void dasd_return_cqr_cb(struct dasd_ccw_req *, void *);
 static void dasd_device_timeout(unsigned long);
 static void dasd_block_timeout(unsigned long);
+static void __dasd_process_erp(struct dasd_device *, struct dasd_ccw_req *);
 
 /*
  * SECTION: Operations on the device structure.
@@ -112,6 +117,7 @@ struct dasd_device *dasd_alloc_device(void)
         INIT_WORK(&device->restore_device, do_restore_device);
         device->state = DASD_STATE_NEW;
         device->target = DASD_STATE_NEW;
+        mutex_init(&device->state_mutex);
 
         return device;
 }
@@ -321,8 +327,8 @@ static int dasd_state_ready_to_basic(struct dasd_device *device)
                         device->state = DASD_STATE_READY;
                         return rc;
                 }
-                dasd_destroy_partitions(block);
                 dasd_flush_request_queue(block);
+                dasd_destroy_partitions(block);
                 block->blocks = 0;
                 block->bp_block = 0;
                 block->s2b_shift = 0;
@@ -484,10 +490,8 @@ static void dasd_change_state(struct dasd_device *device)
         if (rc)
                 device->target = device->state;
 
-        if (device->state == device->target) {
+        if (device->state == device->target)
                 wake_up(&dasd_init_waitq);
-                dasd_put_device(device);
-        }
 
         /* let user-space know that the device status changed */
         kobject_uevent(&device->cdev->dev.kobj, KOBJ_CHANGE);
@@ -502,7 +506,9 @@ static void dasd_change_state(struct dasd_device *device)
 static void do_kick_device(struct work_struct *work)
 {
         struct dasd_device *device = container_of(work, struct dasd_device, kick_work);
+        mutex_lock(&device->state_mutex);
         dasd_change_state(device);
+        mutex_unlock(&device->state_mutex);
         dasd_schedule_device_bh(device);
         dasd_put_device(device);
 }
@@ -539,18 +545,19 @@ void dasd_restore_device(struct dasd_device *device)
 void dasd_set_target_state(struct dasd_device *device, int target)
 {
         dasd_get_device(device);
+        mutex_lock(&device->state_mutex);
         /* If we are in probeonly mode stop at DASD_STATE_READY. */
         if (dasd_probeonly && target > DASD_STATE_READY)
                 target = DASD_STATE_READY;
         if (device->target != target) {
-                if (device->state == target) {
+                if (device->state == target)
                         wake_up(&dasd_init_waitq);
-                        dasd_put_device(device);
-                }
                 device->target = target;
         }
         if (device->state != device->target)
                 dasd_change_state(device);
+        mutex_unlock(&device->state_mutex);
+        dasd_put_device(device);
 }
 
 /*
@@ -960,7 +967,7 @@ static void dasd_device_timeout(unsigned long ptr)
         device = (struct dasd_device *) ptr;
         spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
         /* re-activate request queue */
-        device->stopped &= ~DASD_STOPPED_PENDING;
+        dasd_device_remove_stop_bits(device, DASD_STOPPED_PENDING);
         spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
         dasd_schedule_device_bh(device);
 }
@@ -994,19 +1001,26 @@ static void dasd_handle_killed_request(struct ccw_device *cdev,
                 return;
         cqr = (struct dasd_ccw_req *) intparm;
         if (cqr->status != DASD_CQR_IN_IO) {
-                DBF_EVENT(DBF_DEBUG,
-                        "invalid status in handle_killed_request: "
-                        "bus_id %s, status %02x",
-                        dev_name(&cdev->dev), cqr->status);
+                DBF_EVENT_DEVID(DBF_DEBUG, cdev,
+                                "invalid status in handle_killed_request: "
+                                "%02x", cqr->status);
                 return;
         }
 
-        device = (struct dasd_device *) cqr->startdev;
-        if (device == NULL ||
-            device != dasd_device_from_cdev_locked(cdev) ||
-            strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) {
-                DBF_DEV_EVENT(DBF_DEBUG, device, "invalid device in request: "
-                              "bus_id %s", dev_name(&cdev->dev));
+        device = dasd_device_from_cdev_locked(cdev);
+        if (IS_ERR(device)) {
+                DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s",
+                                "unable to get device from cdev");
+                return;
+        }
+
+        if (!cqr->startdev ||
+            device != cqr->startdev ||
+            strncmp(cqr->startdev->discipline->ebcname,
+                    (char *) &cqr->magic, 4)) {
+                DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s",
+                                "invalid device in request");
+                dasd_put_device(device);
                 return;
         }
 
@@ -1023,7 +1037,7 @@ void dasd_generic_handle_state_change(struct dasd_device *device)
         /* First of all start sense subsystem status request. */
         dasd_eer_snss(device);
 
-        device->stopped &= ~DASD_STOPPED_PENDING;
+        dasd_device_remove_stop_bits(device, DASD_STOPPED_PENDING);
         dasd_schedule_device_bh(device);
         if (device->block)
                 dasd_schedule_block_bh(device->block);
@@ -1045,12 +1059,13 @@ void dasd_int_handler(struct ccw_device *cdev, unsigned long intparm,
                 case -EIO:
                         break;
                 case -ETIMEDOUT:
-                        DBF_EVENT(DBF_WARNING, "%s(%s): request timed out\n",
-                               __func__, dev_name(&cdev->dev));
+                        DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s: "
+                                        "request timed out\n", __func__);
                         break;
                 default:
-                        DBF_EVENT(DBF_WARNING, "%s(%s): unknown error %ld\n",
-                               __func__, dev_name(&cdev->dev), PTR_ERR(irb));
+                        DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s: "
+                                        "unknown error %ld\n", __func__,
+                                        PTR_ERR(irb));
                 }
                 dasd_handle_killed_request(cdev, intparm);
                 return;
@@ -1078,8 +1093,8 @@ void dasd_int_handler(struct ccw_device *cdev, unsigned long intparm,
         device = (struct dasd_device *) cqr->startdev;
         if (!device ||
             strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) {
-                DBF_DEV_EVENT(DBF_DEBUG, device, "invalid device in request: "
-                              "bus_id %s", dev_name(&cdev->dev));
+                DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s",
+                                "invalid device in request");
                 return;
         }
 
@@ -1405,6 +1420,20 @@ void dasd_schedule_device_bh(struct dasd_device *device)
         tasklet_hi_schedule(&device->tasklet);
 }
 
+void dasd_device_set_stop_bits(struct dasd_device *device, int bits)
+{
+        device->stopped |= bits;
+}
+EXPORT_SYMBOL_GPL(dasd_device_set_stop_bits);
+
+void dasd_device_remove_stop_bits(struct dasd_device *device, int bits)
+{
+        device->stopped &= ~bits;
+        if (!device->stopped)
+                wake_up(&generic_waitq);
+}
+EXPORT_SYMBOL_GPL(dasd_device_remove_stop_bits);
+
 /*
  * Queue a request to the head of the device ccw_queue.
  * Start the I/O if possible.
@@ -1446,7 +1475,10 @@ void dasd_add_request_tail(struct dasd_ccw_req *cqr)
  */
 static void dasd_wakeup_cb(struct dasd_ccw_req *cqr, void *data)
 {
-        wake_up((wait_queue_head_t *) data);
+        spin_lock_irq(get_ccwdev_lock(cqr->startdev->cdev));
+        cqr->callback_data = DASD_SLEEPON_END_TAG;
+        spin_unlock_irq(get_ccwdev_lock(cqr->startdev->cdev));
+        wake_up(&generic_waitq);
 }
 
 static inline int _wait_for_wakeup(struct dasd_ccw_req *cqr)
@@ -1456,67 +1488,141 @@ static inline int _wait_for_wakeup(struct dasd_ccw_req *cqr)
 
         device = cqr->startdev;
         spin_lock_irq(get_ccwdev_lock(device->cdev));
-        rc = ((cqr->status == DASD_CQR_DONE ||
-               cqr->status == DASD_CQR_NEED_ERP ||
-               cqr->status == DASD_CQR_TERMINATED) &&
-              list_empty(&cqr->devlist));
+        rc = (cqr->callback_data == DASD_SLEEPON_END_TAG);
         spin_unlock_irq(get_ccwdev_lock(device->cdev));
         return rc;
 }
 
 /*
- * Queue a request to the tail of the device ccw_queue and wait for
- * it's completion.
+ * checks if error recovery is necessary, returns 1 if yes, 0 otherwise.
  */
-int dasd_sleep_on(struct dasd_ccw_req *cqr)
+static int __dasd_sleep_on_erp(struct dasd_ccw_req *cqr)
 {
         struct dasd_device *device;
-        int rc;
+        dasd_erp_fn_t erp_fn;
 
+        if (cqr->status == DASD_CQR_FILLED)
+                return 0;
         device = cqr->startdev;
+        if (test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags)) {
+                if (cqr->status == DASD_CQR_TERMINATED) {
+                        device->discipline->handle_terminated_request(cqr);
+                        return 1;
+                }
+                if (cqr->status == DASD_CQR_NEED_ERP) {
+                        erp_fn = device->discipline->erp_action(cqr);
+                        erp_fn(cqr);
+                        return 1;
+                }
+                if (cqr->status == DASD_CQR_FAILED)
+                        dasd_log_sense(cqr, &cqr->irb);
+                if (cqr->refers) {
+                        __dasd_process_erp(device, cqr);
+                        return 1;
+                }
+        }
+        return 0;
+}
 
-        cqr->callback = dasd_wakeup_cb;
-        cqr->callback_data = (void *) &generic_waitq;
-        dasd_add_request_tail(cqr);
-        wait_event(generic_waitq, _wait_for_wakeup(cqr));
+static int __dasd_sleep_on_loop_condition(struct dasd_ccw_req *cqr)
+{
+        if (test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags)) {
+                if (cqr->refers) /* erp is not done yet */
+                        return 1;
+                return ((cqr->status != DASD_CQR_DONE) &&
+                        (cqr->status != DASD_CQR_FAILED));
+        } else
+                return (cqr->status == DASD_CQR_FILLED);
+}
 
-        if (cqr->status == DASD_CQR_DONE)
+static int _dasd_sleep_on(struct dasd_ccw_req *maincqr, int interruptible)
+{
+        struct dasd_device *device;
+        int rc;
+        struct list_head ccw_queue;
+        struct dasd_ccw_req *cqr;
+
+        INIT_LIST_HEAD(&ccw_queue);
+        maincqr->status = DASD_CQR_FILLED;
+        device = maincqr->startdev;
+        list_add(&maincqr->blocklist, &ccw_queue);
+        for (cqr = maincqr;  __dasd_sleep_on_loop_condition(cqr);
+             cqr = list_first_entry(&ccw_queue,
+                                    struct dasd_ccw_req, blocklist)) {
+
+                if (__dasd_sleep_on_erp(cqr))
+                        continue;
+                if (cqr->status != DASD_CQR_FILLED) /* could be failed */
+                        continue;
+
+                /* Non-temporary stop condition will trigger fail fast */
+                if (device->stopped & ~DASD_STOPPED_PENDING &&
+                    test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) &&
+                    (!dasd_eer_enabled(device))) {
+                        cqr->status = DASD_CQR_FAILED;
+                        continue;
+                }
+
+                /* Don't try to start requests if device is stopped */
+                if (interruptible) {
+                        rc = wait_event_interruptible(
+                                generic_waitq, !(device->stopped));
+                        if (rc == -ERESTARTSYS) {
+                                cqr->status = DASD_CQR_FAILED;
+                                maincqr->intrc = rc;
+                                continue;
+                        }
+                } else
+                        wait_event(generic_waitq, !(device->stopped));
+
+                cqr->callback = dasd_wakeup_cb;
+                cqr->callback_data = DASD_SLEEPON_START_TAG;
+                dasd_add_request_tail(cqr);
+                if (interruptible) {
+                        rc = wait_event_interruptible(
+                                generic_waitq, _wait_for_wakeup(cqr));
+                        if (rc == -ERESTARTSYS) {
+                                dasd_cancel_req(cqr);
+                                /* wait (non-interruptible) for final status */
+                                wait_event(generic_waitq,
+                                           _wait_for_wakeup(cqr));
+                                cqr->status = DASD_CQR_FAILED;
+                                maincqr->intrc = rc;
+                                continue;
+                        }
+                } else
+                        wait_event(generic_waitq, _wait_for_wakeup(cqr));
+        }
+
+        maincqr->endclk = get_clock();
+        if ((maincqr->status != DASD_CQR_DONE) &&
+            (maincqr->intrc != -ERESTARTSYS))
+                dasd_log_sense(maincqr, &maincqr->irb);
+        if (maincqr->status == DASD_CQR_DONE)
                 rc = 0;
-        else if (cqr->intrc)
-                rc = cqr->intrc;
+        else if (maincqr->intrc)
+                rc = maincqr->intrc;
         else
                 rc = -EIO;
         return rc;
 }
 
 /*
+ * Queue a request to the tail of the device ccw_queue and wait for
+ * it's completion.
+ */
+int dasd_sleep_on(struct dasd_ccw_req *cqr)
+{
+        return _dasd_sleep_on(cqr, 0);
+}
+
+/*
  * Queue a request to the tail of the device ccw_queue and wait
  * interruptible for it's completion.
  */
 int dasd_sleep_on_interruptible(struct dasd_ccw_req *cqr)
 {
-        struct dasd_device *device;
-        int rc;
-
-        device = cqr->startdev;
-        cqr->callback = dasd_wakeup_cb;
-        cqr->callback_data = (void *) &generic_waitq;
-        dasd_add_request_tail(cqr);
-        rc = wait_event_interruptible(generic_waitq, _wait_for_wakeup(cqr));
-        if (rc == -ERESTARTSYS) {
-                dasd_cancel_req(cqr);
-                /* wait (non-interruptible) for final status */
-                wait_event(generic_waitq, _wait_for_wakeup(cqr));
-                cqr->intrc = rc;
-        }
-
-        if (cqr->status == DASD_CQR_DONE)
-                rc = 0;
-        else if (cqr->intrc)
-                rc = cqr->intrc;
-        else
-                rc = -EIO;
-        return rc;
+        return _dasd_sleep_on(cqr, 1);
 }
 
 /*
@@ -1549,7 +1655,7 @@ int dasd_sleep_on_immediatly(struct dasd_ccw_req *cqr)
         }
 
         cqr->callback = dasd_wakeup_cb;
-        cqr->callback_data = (void *) &generic_waitq;
+        cqr->callback_data = DASD_SLEEPON_START_TAG;
         cqr->status = DASD_CQR_QUEUED;
         list_add(&cqr->devlist, &device->ccw_queue);
 
@@ -1601,7 +1707,6 @@ int dasd_cancel_req(struct dasd_ccw_req *cqr)
                                 cqr, rc);
                 } else {
                         cqr->stopclk = get_clock();
-                        rc = 1;
                 }
                 break;
         default: /* already finished or clear pending - do nothing */
@@ -1630,7 +1735,7 @@ static void dasd_block_timeout(unsigned long ptr)
         block = (struct dasd_block *) ptr;
         spin_lock_irqsave(get_ccwdev_lock(block->base->cdev), flags);
         /* re-activate request queue */
-        block->base->stopped &= ~DASD_STOPPED_PENDING;
+        dasd_device_remove_stop_bits(block->base, DASD_STOPPED_PENDING);
         spin_unlock_irqrestore(get_ccwdev_lock(block->base->cdev), flags);
         dasd_schedule_block_bh(block);
 }
@@ -1657,11 +1762,10 @@ void dasd_block_clear_timer(struct dasd_block *block)
 /*
  * Process finished error recovery ccw.
  */
-static inline void __dasd_block_process_erp(struct dasd_block *block,
-                                            struct dasd_ccw_req *cqr)
+static void __dasd_process_erp(struct dasd_device *device,
+                               struct dasd_ccw_req *cqr)
 {
         dasd_erp_fn_t erp_fn;
-        struct dasd_device *device = block->base;
 
         if (cqr->status == DASD_CQR_DONE)
                 DBF_DEV_EVENT(DBF_NOTICE, device, "%s", "ERP successful");
@@ -1725,9 +1829,12 @@ static void __dasd_process_request_queue(struct dasd_block *block)
                                  */
                                 if (!list_empty(&block->ccw_queue))
                                         break;
-                                spin_lock_irqsave(get_ccwdev_lock(basedev->cdev), flags);
-                                basedev->stopped |= DASD_STOPPED_PENDING;
-                                spin_unlock_irqrestore(get_ccwdev_lock(basedev->cdev), flags);
+                                spin_lock_irqsave(
+                                        get_ccwdev_lock(basedev->cdev), flags);
+                                dasd_device_set_stop_bits(basedev,
+                                                          DASD_STOPPED_PENDING);
+                                spin_unlock_irqrestore(
+                                        get_ccwdev_lock(basedev->cdev), flags);
                                 dasd_block_set_timer(block, HZ/2);
                                 break;
                         }
@@ -1795,7 +1902,8 @@ restart:
                 /*  Process requests that may be recovered */
                 if (cqr->status == DASD_CQR_NEED_ERP) {
                         erp_fn = base->discipline->erp_action(cqr);
-                        erp_fn(cqr);
+                        if (IS_ERR(erp_fn(cqr)))
+                                continue;
                         goto restart;
                 }
 
@@ -1813,7 +1921,7 @@ restart:
                         cqr->status = DASD_CQR_FILLED;
                         cqr->retries = 255;
                         spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
-                        base->stopped |= DASD_STOPPED_QUIESCE;
+                        dasd_device_set_stop_bits(base, DASD_STOPPED_QUIESCE);
                         spin_unlock_irqrestore(get_ccwdev_lock(base->cdev),
                                                flags);
                         goto restart;
@@ -1821,7 +1929,7 @@ restart:
 
                 /* Process finished ERP request. */
                 if (cqr->refers) {
-                        __dasd_block_process_erp(block, cqr);
+                        __dasd_process_erp(base, cqr);
                         goto restart;
                 }
 
@@ -1952,7 +2060,7 @@ restart_cb:
                 /* Process finished ERP request. */
                 if (cqr->refers) {
                         spin_lock_bh(&block->queue_lock);
-                        __dasd_block_process_erp(block, cqr);
+                        __dasd_process_erp(block->base, cqr);
                         spin_unlock_bh(&block->queue_lock);
                         /* restart list_for_xx loop since dasd_process_erp
                          * might remove multiple elements */
@@ -2036,9 +2144,8 @@ static void dasd_setup_queue(struct dasd_block *block)
 
         blk_queue_logical_block_size(block->request_queue, block->bp_block);
         max = block->base->discipline->max_blocks << block->s2b_shift;
-        blk_queue_max_sectors(block->request_queue, max);
-        blk_queue_max_phys_segments(block->request_queue, -1L);
-        blk_queue_max_hw_segments(block->request_queue, -1L);
+        blk_queue_max_hw_sectors(block->request_queue, max);
+        blk_queue_max_segments(block->request_queue, -1L);
         /* with page sized segments we can translate each segement into
          * one idaw/tidaw
          */
@@ -2077,9 +2184,13 @@ static void dasd_flush_request_queue(struct dasd_block *block)
 static int dasd_open(struct block_device *bdev, fmode_t mode)
 {
         struct dasd_block *block = bdev->bd_disk->private_data;
-        struct dasd_device *base = block->base;
+        struct dasd_device *base;
         int rc;
 
+        if (!block)
+                return -ENODEV;
+
+        base = block->base;
         atomic_inc(&block->open_count);
         if (test_bit(DASD_FLAG_OFFLINE, &base->flags)) {
                 rc = -ENODEV;
@@ -2106,6 +2217,13 @@ static int dasd_open(struct block_device *bdev, fmode_t mode)
                 goto out;
         }
 
+        if ((mode & FMODE_WRITE) &&
+            (test_bit(DASD_FLAG_DEVICE_RO, &base->flags) ||
+             (base->features & DASD_FEATURE_READONLY))) {
+                rc = -EROFS;
+                goto out;
+        }
+
         return 0;
 
 out:
@@ -2183,6 +2301,34 @@ dasd_exit(void)
  * SECTION: common functions for ccw_driver use
  */
 
+/*
+ * Is the device read-only?
+ * Note that this function does not report the setting of the
+ * readonly device attribute, but how it is configured in z/VM.
+ */
+int dasd_device_is_ro(struct dasd_device *device)
+{
+        struct ccw_dev_id dev_id;
+        struct diag210 diag_data;
+        int rc;
+
+        if (!MACHINE_IS_VM)
+                return 0;
+        ccw_device_get_id(device->cdev, &dev_id);
+        memset(&diag_data, 0, sizeof(diag_data));
+        diag_data.vrdcdvno = dev_id.devno;
+        diag_data.vrdclen = sizeof(diag_data);
+        rc = diag210(&diag_data);
+        if (rc == 0 || rc == 2) {
+                return diag_data.vrdcvfla & 0x80;
+        } else {
+                DBF_EVENT(DBF_WARNING, "diag210 failed for dev=%04x with rc=%d",
+                          dev_id.devno, rc);
+                return 0;
+        }
+}
+EXPORT_SYMBOL_GPL(dasd_device_is_ro);
+
 static void dasd_generic_auto_online(void *data, async_cookie_t cookie)
 {
         struct ccw_device *cdev = data;
@@ -2192,11 +2338,6 @@ static void dasd_generic_auto_online(void *data, async_cookie_t cookie)
         if (ret)
                 pr_warning("%s: Setting the DASD online failed with rc=%d\n",
                            dev_name(&cdev->dev), ret);
-        else {
-                struct dasd_device *device = dasd_device_from_cdev(cdev);
-                wait_event(dasd_init_waitq, _wait_for_device(device));
-                dasd_put_device(device);
-        }
 }
 
 /*
@@ -2208,18 +2349,11 @@ int dasd_generic_probe(struct ccw_device *cdev,
 {
         int ret;
 
-        ret = ccw_device_set_options(cdev, CCWDEV_DO_PATHGROUP);
-        if (ret) {
-                DBF_EVENT(DBF_WARNING,
-                       "dasd_generic_probe: could not set ccw-device options "
-                       "for %s\n", dev_name(&cdev->dev));
-                return ret;
-        }
         ret = dasd_add_sysfs_files(cdev);
         if (ret) {
-                DBF_EVENT(DBF_WARNING,
-                       "dasd_generic_probe: could not add sysfs entries "
-                       "for %s\n", dev_name(&cdev->dev));
+                DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s",
+                                "dasd_generic_probe: could not add "
+                                "sysfs entries");
                 return ret;
         }
         cdev->handler = &dasd_int_handler;
@@ -2338,6 +2472,9 @@ int dasd_generic_set_online(struct ccw_device *cdev,
         } else
                 pr_debug("dasd_generic device %s found\n",
                                 dev_name(&cdev->dev));
+
+        wait_event(dasd_init_waitq, _wait_for_device(device));
+
         dasd_put_device(device);
         return rc;
 }
@@ -2418,16 +2555,16 @@ int dasd_generic_notify(struct ccw_device *cdev, int event)
                                 cqr->status = DASD_CQR_QUEUED;
                                 cqr->retries++;
                         }
-                device->stopped |= DASD_STOPPED_DC_WAIT;
+                dasd_device_set_stop_bits(device, DASD_STOPPED_DC_WAIT);
                 dasd_device_clear_timer(device);
                 dasd_schedule_device_bh(device);
                 ret = 1;
                 break;
         case CIO_OPER:
                 /* FIXME: add a sanity check. */
-                device->stopped &= ~DASD_STOPPED_DC_WAIT;
+                dasd_device_remove_stop_bits(device, DASD_STOPPED_DC_WAIT);
                 if (device->stopped & DASD_UNRESUMED_PM) {
-                        device->stopped &= ~DASD_UNRESUMED_PM;
+                        dasd_device_remove_stop_bits(device, DASD_UNRESUMED_PM);
                         dasd_restore_device(device);
                         ret = 1;
                         break;
@@ -2452,7 +2589,7 @@ int dasd_generic_pm_freeze(struct ccw_device *cdev)
         if (IS_ERR(device))
                 return PTR_ERR(device);
         /* disallow new I/O  */
-        device->stopped |= DASD_STOPPED_PM;
+        dasd_device_set_stop_bits(device, DASD_STOPPED_PM);
         /* clear active requests */
         INIT_LIST_HEAD(&freeze_queue);
         spin_lock_irq(get_ccwdev_lock(cdev));
@@ -2504,14 +2641,18 @@ int dasd_generic_restore_device(struct ccw_device *cdev)
                 return PTR_ERR(device);
 
         /* allow new IO again */
-        device->stopped &= ~DASD_STOPPED_PM;
-        device->stopped &= ~DASD_UNRESUMED_PM;
+        dasd_device_remove_stop_bits(device,
+                                     (DASD_STOPPED_PM | DASD_UNRESUMED_PM));
 
         dasd_schedule_device_bh(device);
 
-        if (device->discipline->restore)
+        /*
+         * call discipline restore function
+         * if device is stopped do nothing e.g. for disconnected devices
+         */
+        if (device->discipline->restore && !(device->stopped))
                 rc = device->discipline->restore(device);
-        if (rc)
+        if (rc || device->stopped)
                 /*
                  * if the resume failed for the DASD we put it in
                  * an UNRESUMED stop state
@@ -2561,8 +2702,7 @@ static struct dasd_ccw_req *dasd_generic_build_rdc(struct dasd_device *device,
         cqr->startdev = device;
         cqr->memdev = device;
         cqr->expires = 10*HZ;
-        clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
-        cqr->retries = 2;
+        cqr->retries = 256;
         cqr->buildclk = get_clock();
         cqr->status = DASD_CQR_FILLED;
         return cqr;
diff --git a/drivers/s390/block/dasd_3990_erp.c b/drivers/s390/block/dasd_3990_erp.c
index e8ff7b0c961d..6632649dd6aa 100644
--- a/drivers/s390/block/dasd_3990_erp.c
+++ b/drivers/s390/block/dasd_3990_erp.c
@@ -10,9 +10,7 @@
 #define KMSG_COMPONENT "dasd-eckd"
 
 #include <linux/timer.h>
-#include <linux/slab.h>
 #include <asm/idals.h>
-#include <asm/todclk.h>
 
 #define PRINTK_HEADER "dasd_erp(3990): "
 
@@ -70,8 +68,7 @@ dasd_3990_erp_cleanup(struct dasd_ccw_req * erp, char final_status)
  *   processing until the started timer has expired or an related
  *   interrupt was received.
  */
-static void
-dasd_3990_erp_block_queue(struct dasd_ccw_req * erp, int expires)
+static void dasd_3990_erp_block_queue(struct dasd_ccw_req *erp, int expires)
 {
 
         struct dasd_device *device = erp->startdev;
@@ -81,10 +78,13 @@ dasd_3990_erp_block_queue(struct dasd_ccw_req * erp, int expires)
                     "blocking request queue for %is", expires/HZ);
 
         spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
-        device->stopped |= DASD_STOPPED_PENDING;
+        dasd_device_set_stop_bits(device, DASD_STOPPED_PENDING);
         spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
         erp->status = DASD_CQR_FILLED;
-        dasd_block_set_timer(device->block, expires);
+        if (erp->block)
+                dasd_block_set_timer(erp->block, expires);
+        else
+                dasd_device_set_timer(device, expires);
 }
 
 /*
@@ -243,9 +243,13 @@ dasd_3990_erp_DCTL(struct dasd_ccw_req * erp, char modifier)
  * DESCRIPTION
  *   Setup ERP to do the ERP action 1 (see Reference manual).
  *   Repeat the operation on a different channel path.
- *   If all alternate paths have been tried, the request is posted with a
- *   permanent error.
- *   Note: duplex handling is not implemented (yet).
+ *   As deviation from the recommended recovery action, we reset the path mask
+ *   after we have tried each path and go through all paths a second time.
+ *   This will cover situations where only one path at a time is actually down,
+ *   but all paths fail and recover just with the same sequence and timing as
+ *   we try to use them (flapping links).
+ *   If all alternate paths have been tried twice, the request is posted with
+ *   a permanent error.
  *
  *  PARAMETER
  *   erp                pointer to the current ERP
@@ -254,17 +258,25 @@ dasd_3990_erp_DCTL(struct dasd_ccw_req * erp, char modifier)
  *   erp                pointer to the ERP
  *
  */
-static struct dasd_ccw_req *
-dasd_3990_erp_action_1(struct dasd_ccw_req * erp)
+static struct dasd_ccw_req *dasd_3990_erp_action_1_sec(struct dasd_ccw_req *erp)
 {
+        erp->function = dasd_3990_erp_action_1_sec;
+        dasd_3990_erp_alternate_path(erp);
+        return erp;
+}
 
+static struct dasd_ccw_req *dasd_3990_erp_action_1(struct dasd_ccw_req *erp)
+{
         erp->function = dasd_3990_erp_action_1;
-
         dasd_3990_erp_alternate_path(erp);
-
+        if (erp->status == DASD_CQR_FAILED) {
+                erp->status = DASD_CQR_FILLED;
+                erp->retries = 10;
+                erp->lpm = LPM_ANYPATH;
+                erp->function = dasd_3990_erp_action_1_sec;
+        }
         return erp;
-
-}                               /* end dasd_3990_erp_action_1 */
+}                               /* end dasd_3990_erp_action_1(b) */
 
 /*
  * DASD_3990_ERP_ACTION_4
@@ -1032,6 +1044,10 @@ dasd_3990_erp_com_rej(struct dasd_ccw_req * erp, char *sense)
 
                 erp->retries = 5;
 
+        } else if (sense[1] & SNS1_WRITE_INHIBITED) {
+                dev_err(&device->cdev->dev, "An I/O request was rejected"
+                        " because writing is inhibited\n");
+                erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
         } else {
                 /* fatal error -  set status to FAILED
                    internal error 09 - Command Reject */
@@ -2270,7 +2286,8 @@ static struct dasd_ccw_req *dasd_3990_erp_add_erp(struct dasd_ccw_req *cqr)
 
         if (cqr->cpmode == 1) {
                 cplength = 0;
-                datasize = sizeof(struct tcw) + sizeof(struct tsb);
+                /* TCW needs to be 64 byte aligned, so leave enough room */
+                datasize = 64 + sizeof(struct tcw) + sizeof(struct tsb);
         } else {
                 cplength = 2;
                 datasize = 0;
@@ -2292,17 +2309,21 @@ static struct dasd_ccw_req *dasd_3990_erp_add_erp(struct dasd_ccw_req *cqr)
                                      cqr->retries);
                         dasd_block_set_timer(device->block, (HZ << 3));
                 }
-                return cqr;
+                return erp;
         }
 
+        ccw = cqr->cpaddr;
         if (cqr->cpmode == 1) {
                 /* make a shallow copy of the original tcw but set new tsb */
                 erp->cpmode = 1;
-                erp->cpaddr = erp->data;
-                tcw = erp->data;
+                erp->cpaddr = PTR_ALIGN(erp->data, 64);
+                tcw = erp->cpaddr;
                 tsb = (struct tsb *) &tcw[1];
                 *tcw = *((struct tcw *)cqr->cpaddr);
                 tcw->tsb = (long)tsb;
+        } else if (ccw->cmd_code == DASD_ECKD_CCW_PSF) {
+                /* PSF cannot be chained from NOOP/TIC */
+                erp->cpaddr = cqr->cpaddr;
         } else {
                 /* initialize request with default TIC to current ERP/CQR */
                 ccw = erp->cpaddr;
@@ -2351,6 +2372,9 @@ dasd_3990_erp_additional_erp(struct dasd_ccw_req * cqr)
         /* add erp and initialize with default TIC */
         erp = dasd_3990_erp_add_erp(cqr);
 
+        if (IS_ERR(erp))
+                return erp;
+
         /* inspect sense, determine specific ERP if possible */
         if (erp != cqr) {
 
@@ -2487,6 +2511,8 @@ dasd_3990_erp_further_erp(struct dasd_ccw_req *erp)
 
                 erp = dasd_3990_erp_action_1(erp);
 
+        } else if (erp->function == dasd_3990_erp_action_1_sec) {
+                erp = dasd_3990_erp_action_1_sec(erp);
         } else if (erp->function == dasd_3990_erp_action_5) {
 
                 /* retries have not been successful */
@@ -2688,6 +2714,8 @@ dasd_3990_erp_action(struct dasd_ccw_req * cqr)
         if (erp == NULL) {
                 /* no matching erp found - set up erp */
                 erp = dasd_3990_erp_additional_erp(cqr);
+                if (IS_ERR(erp))
+                        return erp;
         } else {
                 /* matching erp found - set all leading erp's to DONE */
                 erp = dasd_3990_erp_handle_match_erp(cqr, erp);
diff --git a/drivers/s390/block/dasd_alias.c b/drivers/s390/block/dasd_alias.c
index 70a008c00522..8c4814258e93 100644
--- a/drivers/s390/block/dasd_alias.c
+++ b/drivers/s390/block/dasd_alias.c
@@ -8,6 +8,7 @@
 #define KMSG_COMPONENT "dasd-eckd"
 
 #include <linux/list.h>
+#include <linux/slab.h>
 #include <asm/ebcdic.h>
 #include "dasd_int.h"
 #include "dasd_eckd.h"
@@ -152,6 +153,7 @@ static struct alias_lcu *_allocate_lcu(struct dasd_uid *uid)
         INIT_WORK(&lcu->suc_data.worker, summary_unit_check_handling_work);
         INIT_DELAYED_WORK(&lcu->ruac_data.dwork, lcu_update_work);
         spin_lock_init(&lcu->lock);
+        init_completion(&lcu->lcu_setup);
         return lcu;
 
 out_err4:
@@ -217,7 +219,7 @@ int dasd_alias_make_device_known_to_lcu(struct dasd_device *device)
                 spin_unlock_irqrestore(&aliastree.lock, flags);
                 newlcu = _allocate_lcu(uid);
                 if (IS_ERR(newlcu))
-                        return PTR_ERR(lcu);
+                        return PTR_ERR(newlcu);
                 spin_lock_irqsave(&aliastree.lock, flags);
                 lcu = _find_lcu(server, uid);
                 if (!lcu) {
@@ -240,6 +242,67 @@ int dasd_alias_make_device_known_to_lcu(struct dasd_device *device)
 }
 
 /*
+ * The first device to be registered on an LCU will have to do
+ * some additional setup steps to configure that LCU on the
+ * storage server. All further devices should wait with their
+ * initialization until the first device is done.
+ * To synchronize this work, the first device will call
+ * dasd_alias_lcu_setup_complete when it is done, and all
+ * other devices will wait for it with dasd_alias_wait_for_lcu_setup.
+ */
+void dasd_alias_lcu_setup_complete(struct dasd_device *device)
+{
+        struct dasd_eckd_private *private;
+        unsigned long flags;
+        struct alias_server *server;
+        struct alias_lcu *lcu;
+        struct dasd_uid *uid;
+
+        private = (struct dasd_eckd_private *) device->private;
+        uid = &private->uid;
+        lcu = NULL;
+        spin_lock_irqsave(&aliastree.lock, flags);
+        server = _find_server(uid);
+        if (server)
+                lcu = _find_lcu(server, uid);
+        spin_unlock_irqrestore(&aliastree.lock, flags);
+        if (!lcu) {
+                DBF_EVENT_DEVID(DBF_ERR, device->cdev,
+                                "could not find lcu for %04x %02x",
+                                uid->ssid, uid->real_unit_addr);
+                WARN_ON(1);
+                return;
+        }
+        complete_all(&lcu->lcu_setup);
+}
+
+void dasd_alias_wait_for_lcu_setup(struct dasd_device *device)
+{
+        struct dasd_eckd_private *private;
+        unsigned long flags;
+        struct alias_server *server;
+        struct alias_lcu *lcu;
+        struct dasd_uid *uid;
+
+        private = (struct dasd_eckd_private *) device->private;
+        uid = &private->uid;
+        lcu = NULL;
+        spin_lock_irqsave(&aliastree.lock, flags);
+        server = _find_server(uid);
+        if (server)
+                lcu = _find_lcu(server, uid);
+        spin_unlock_irqrestore(&aliastree.lock, flags);
+        if (!lcu) {
+                DBF_EVENT_DEVID(DBF_ERR, device->cdev,
+                                "could not find lcu for %04x %02x",
+                                uid->ssid, uid->real_unit_addr);
+                WARN_ON(1);
+                return;
+        }
+        wait_for_completion(&lcu->lcu_setup);
+}
+
+/*
  * This function removes a device from the scope of alias management.
  * The complicated part is to make sure that it is not in use by
  * any of the workers. If necessary cancel the work.
@@ -755,11 +818,11 @@ static void __stop_device_on_lcu(struct dasd_device *device,
 {
         /* If pos == device then device is already locked! */
         if (pos == device) {
-                pos->stopped |= DASD_STOPPED_SU;
+                dasd_device_set_stop_bits(pos, DASD_STOPPED_SU);
                 return;
         }
         spin_lock(get_ccwdev_lock(pos->cdev));
-        pos->stopped |= DASD_STOPPED_SU;
+        dasd_device_set_stop_bits(pos, DASD_STOPPED_SU);
         spin_unlock(get_ccwdev_lock(pos->cdev));
 }
 
@@ -793,26 +856,26 @@ static void _unstop_all_devices_on_lcu(struct alias_lcu *lcu)
 
         list_for_each_entry(device, &lcu->active_devices, alias_list) {
                 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
-                device->stopped &= ~DASD_STOPPED_SU;
+                dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
                 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
         }
 
         list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
                 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
-                device->stopped &= ~DASD_STOPPED_SU;
+                dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
                 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
         }
 
         list_for_each_entry(pavgroup, &lcu->grouplist, group) {
                 list_for_each_entry(device, &pavgroup->baselist, alias_list) {
                         spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
-                        device->stopped &= ~DASD_STOPPED_SU;
+                        dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
                         spin_unlock_irqrestore(get_ccwdev_lock(device->cdev),
                                                flags);
                 }
                 list_for_each_entry(device, &pavgroup->aliaslist, alias_list) {
                         spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
-                        device->stopped &= ~DASD_STOPPED_SU;
+                        dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
                         spin_unlock_irqrestore(get_ccwdev_lock(device->cdev),
                                                flags);
                 }
@@ -836,7 +899,8 @@ static void summary_unit_check_handling_work(struct work_struct *work)
 
         /* 2. reset summary unit check */
         spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
-        device->stopped &= ~(DASD_STOPPED_SU | DASD_STOPPED_PENDING);
+        dasd_device_remove_stop_bits(device,
+                                     (DASD_STOPPED_SU | DASD_STOPPED_PENDING));
         spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
         reset_summary_unit_check(lcu, device, suc_data->reason);
 
diff --git a/drivers/s390/block/dasd_devmap.c b/drivers/s390/block/dasd_devmap.c
index 4cac5b54f26a..eff9c812c5c2 100644
--- a/drivers/s390/block/dasd_devmap.c
+++ b/drivers/s390/block/dasd_devmap.c
@@ -18,6 +18,7 @@
 #include <linux/ctype.h>
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 
 #include <asm/debug.h>
 #include <asm/uaccess.h>
@@ -742,6 +743,7 @@ dasd_ro_store(struct device *dev, struct device_attribute *attr,
               const char *buf, size_t count)
 {
         struct dasd_devmap *devmap;
+        struct dasd_device *device;
         int val;
         char *endp;
 
@@ -758,12 +760,14 @@ dasd_ro_store(struct device *dev, struct device_attribute *attr,
                 devmap->features |= DASD_FEATURE_READONLY;
         else
                 devmap->features &= ~DASD_FEATURE_READONLY;
-        if (devmap->device)
-                devmap->device->features = devmap->features;
-        if (devmap->device && devmap->device->block
-            && devmap->device->block->gdp)
-                set_disk_ro(devmap->device->block->gdp, val);
+        device = devmap->device;
+        if (device) {
+                device->features = devmap->features;
+                val = val || test_bit(DASD_FLAG_DEVICE_RO, &device->flags);
+        }
         spin_unlock(&dasd_devmap_lock);
+        if (device && device->block && device->block->gdp)
+                set_disk_ro(device->block->gdp, val);
         return count;
 }
 
@@ -874,12 +878,19 @@ dasd_discipline_show(struct device *dev, struct device_attribute *attr,
         ssize_t len;
 
         device = dasd_device_from_cdev(to_ccwdev(dev));
-        if (!IS_ERR(device) && device->discipline) {
+        if (IS_ERR(device))
+                goto out;
+        else if (!device->discipline) {
+                dasd_put_device(device);
+                goto out;
+        } else {
                 len = snprintf(buf, PAGE_SIZE, "%s\n",
                                device->discipline->name);
                 dasd_put_device(device);
-        } else
-                len = snprintf(buf, PAGE_SIZE, "none\n");
+                return len;
+        }
+out:
+        len = snprintf(buf, PAGE_SIZE, "none\n");
         return len;
 }
 
diff --git a/drivers/s390/block/dasd_diag.c b/drivers/s390/block/dasd_diag.c
index 4e49b4a6c880..687f323cdc38 100644
--- a/drivers/s390/block/dasd_diag.c
+++ b/drivers/s390/block/dasd_diag.c
@@ -8,7 +8,7 @@
  *
  */
 
-#define KMSG_COMPONENT "dasd-diag"
+#define KMSG_COMPONENT "dasd"
 
 #include <linux/stddef.h>
 #include <linux/kernel.h>
@@ -24,7 +24,6 @@
 #include <asm/ebcdic.h>
 #include <asm/io.h>
 #include <asm/s390_ext.h>
-#include <asm/todclk.h>
 #include <asm/vtoc.h>
 #include <asm/diag.h>
 
@@ -145,9 +144,16 @@ dasd_diag_erp(struct dasd_device *device)
 
         mdsk_term_io(device);
         rc = mdsk_init_io(device, device->block->bp_block, 0, NULL);
+        if (rc == 4) {
+                if (!(test_and_set_bit(DASD_FLAG_DEVICE_RO, &device->flags)))
+                        pr_warning("%s: The access mode of a DIAG device "
+                                   "changed to read-only\n",
+                                   dev_name(&device->cdev->dev));
+                rc = 0;
+        }
         if (rc)
-                dev_warn(&device->cdev->dev, "DIAG ERP failed with "
-                            "rc=%d\n", rc);
+                pr_warning("%s: DIAG ERP failed with "
+                            "rc=%d\n", dev_name(&device->cdev->dev), rc);
 }
 
 /* Start a given request at the device. Return zero on success, non-zero
@@ -363,8 +369,9 @@ dasd_diag_check_device(struct dasd_device *device)
                 private->pt_block = 2;
                 break;
         default:
-                dev_warn(&device->cdev->dev, "Device type %d is not supported "
-                            "in DIAG mode\n", private->rdc_data.vdev_class);
+                pr_warning("%s: Device type %d is not supported "
+                           "in DIAG mode\n", dev_name(&device->cdev->dev),
+                           private->rdc_data.vdev_class);
                 rc = -EOPNOTSUPP;
                 goto out;
         }
@@ -405,8 +412,8 @@ dasd_diag_check_device(struct dasd_device *device)
                 private->iob.flaga = DASD_DIAG_FLAGA_DEFAULT;
                 rc = dia250(&private->iob, RW_BIO);
                 if (rc == 3) {
-                        dev_warn(&device->cdev->dev,
-                                "A 64-bit DIAG call failed\n");
+                        pr_warning("%s: A 64-bit DIAG call failed\n",
+                                   dev_name(&device->cdev->dev));
                         rc = -EOPNOTSUPP;
                         goto out_label;
                 }
@@ -415,8 +422,9 @@ dasd_diag_check_device(struct dasd_device *device)
                         break;
         }
         if (bsize > PAGE_SIZE) {
-                dev_warn(&device->cdev->dev, "Accessing the DASD failed because"
-                         " of an incorrect format (rc=%d)\n", rc);
+                pr_warning("%s: Accessing the DASD failed because of an "
+                           "incorrect format (rc=%d)\n",
+                           dev_name(&device->cdev->dev), rc);
                 rc = -EIO;
                 goto out_label;
         }
@@ -433,16 +441,20 @@ dasd_diag_check_device(struct dasd_device *device)
         for (sb = 512; sb < bsize; sb = sb << 1)
                 block->s2b_shift++;
         rc = mdsk_init_io(device, block->bp_block, 0, NULL);
-        if (rc) {
-                dev_warn(&device->cdev->dev, "DIAG initialization "
-                        "failed with rc=%d\n", rc);
+        if (rc && (rc != 4)) {
+                pr_warning("%s: DIAG initialization failed with rc=%d\n",
+                           dev_name(&device->cdev->dev), rc);
                 rc = -EIO;
         } else {
-                dev_info(&device->cdev->dev,
-                         "New DASD with %ld byte/block, total size %ld KB\n",
-                         (unsigned long) block->bp_block,
-                         (unsigned long) (block->blocks <<
-                                          block->s2b_shift) >> 1);
+                if (rc == 4)
+                        set_bit(DASD_FLAG_DEVICE_RO, &device->flags);
+                pr_info("%s: New DASD with %ld byte/block, total size %ld "
+                        "KB%s\n", dev_name(&device->cdev->dev),
+                        (unsigned long) block->bp_block,
+                        (unsigned long) (block->blocks <<
+                                         block->s2b_shift) >> 1,
+                        (rc == 4) ? ", read-only device" : "");
+                rc = 0;
         }
 out_label:
         free_page((long) label);
diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index 417b97cd3f94..0cb233116855 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -23,8 +23,8 @@
 #include <asm/debug.h>
 #include <asm/idals.h>
 #include <asm/ebcdic.h>
+#include <asm/compat.h>
 #include <asm/io.h>
-#include <asm/todclk.h>
 #include <asm/uaccess.h>
 #include <asm/cio.h>
 #include <asm/ccwdev.h>
@@ -78,6 +78,11 @@ MODULE_DEVICE_TABLE(ccw, dasd_eckd_ids);
 
 static struct ccw_driver dasd_eckd_driver; /* see below */
 
+#define INIT_CQR_OK 0
+#define INIT_CQR_UNFORMATTED 1
+#define INIT_CQR_ERROR 2
+
+
 /* initial attempt at a probe function. this can be simplified once
  * the other detection code is gone */
 static int
@@ -86,11 +91,12 @@ dasd_eckd_probe (struct ccw_device *cdev)
         int ret;
 
         /* set ECKD specific ccw-device options */
-        ret = ccw_device_set_options(cdev, CCWDEV_ALLOW_FORCE);
+        ret = ccw_device_set_options(cdev, CCWDEV_ALLOW_FORCE |
+                                     CCWDEV_DO_PATHGROUP | CCWDEV_DO_MULTIPATH);
         if (ret) {
-                DBF_EVENT(DBF_WARNING,
-                       "dasd_eckd_probe: could not set ccw-device options "
-                       "for %s\n", dev_name(&cdev->dev));
+                DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s",
+                                "dasd_eckd_probe: could not set "
+                                "ccw-device options");
                 return ret;
         }
         ret = dasd_generic_probe(cdev, &dasd_eckd_discipline);
@@ -749,8 +755,7 @@ static struct dasd_ccw_req *dasd_eckd_build_rcd_lpm(struct dasd_device *device,
         cqr->block = NULL;
         cqr->expires = 10*HZ;
         cqr->lpm = lpm;
-        clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
-        cqr->retries = 2;
+        cqr->retries = 256;
         cqr->buildclk = get_clock();
         cqr->status = DASD_CQR_FILLED;
         return cqr;
@@ -885,16 +890,15 @@ static int dasd_eckd_read_conf(struct dasd_device *device)
                         rc = dasd_eckd_read_conf_lpm(device, &conf_data,
                                                      &conf_len, lpm);
                         if (rc && rc != -EOPNOTSUPP) {  /* -EOPNOTSUPP is ok */
-                                DBF_EVENT(DBF_WARNING,
+                                DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
                                           "Read configuration data returned "
-                                          "error %d for device: %s", rc,
-                                          dev_name(&device->cdev->dev));
+                                          "error %d", rc);
                                 return rc;
                         }
                         if (conf_data == NULL) {
-                                DBF_EVENT(DBF_WARNING, "No configuration "
-                                          "data retrieved for device: %s",
-                                          dev_name(&device->cdev->dev));
+                                DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
+                                                "No configuration data "
+                                                "retrieved");
                                 continue;       /* no error */
                         }
                         /* save first valid configuration data */
@@ -941,16 +945,14 @@ static int dasd_eckd_read_features(struct dasd_device *device)
                                     sizeof(struct dasd_rssd_features)),
                                    device);
         if (IS_ERR(cqr)) {
-                DBF_EVENT(DBF_WARNING, "Could not allocate initialization "
-                          "request for device: %s",
-                          dev_name(&device->cdev->dev));
+                DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", "Could not "
+                                "allocate initialization request");
                 return PTR_ERR(cqr);
         }
         cqr->startdev = device;
         cqr->memdev = device;
         cqr->block = NULL;
-        clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
-        cqr->retries = 5;
+        cqr->retries = 256;
         cqr->expires = 10 * HZ;
 
         /* Prepare for Read Subsystem Data */
@@ -1012,9 +1014,9 @@ static struct dasd_ccw_req *dasd_eckd_build_psf_ssc(struct dasd_device *device,
         }
         psf_ssc_data = (struct dasd_psf_ssc_data *)cqr->data;
         psf_ssc_data->order = PSF_ORDER_SSC;
-        psf_ssc_data->suborder = 0x40;
+        psf_ssc_data->suborder = 0xc0;
         if (enable_pav) {
-                psf_ssc_data->suborder |= 0x88;
+                psf_ssc_data->suborder |= 0x08;
                 psf_ssc_data->reserved[0] = 0x88;
         }
         ccw = cqr->cpaddr;
@@ -1025,6 +1027,7 @@ static struct dasd_ccw_req *dasd_eckd_build_psf_ssc(struct dasd_device *device,
         cqr->startdev = device;
         cqr->memdev = device;
         cqr->block = NULL;
+        cqr->retries = 256;
         cqr->expires = 10*HZ;
         cqr->buildclk = get_clock();
         cqr->status = DASD_CQR_FILLED;
@@ -1057,7 +1060,7 @@ dasd_eckd_psf_ssc(struct dasd_device *device, int enable_pav)
 /*
  * Valide storage server of current device.
  */
-static int dasd_eckd_validate_server(struct dasd_device *device)
+static void dasd_eckd_validate_server(struct dasd_device *device)
 {
         int rc;
         struct dasd_eckd_private *private;
@@ -1068,15 +1071,12 @@ static int dasd_eckd_validate_server(struct dasd_device *device)
         else
                 enable_pav = 1;
         rc = dasd_eckd_psf_ssc(device, enable_pav);
+
         /* may be requested feature is not available on server,
          * therefore just report error and go ahead */
         private = (struct dasd_eckd_private *) device->private;
-        DBF_EVENT(DBF_WARNING, "PSF-SSC on storage subsystem %s.%s.%04x "
-                  "returned rc=%d for device: %s",
-                  private->uid.vendor, private->uid.serial,
-                  private->uid.ssid, rc, dev_name(&device->cdev->dev));
-        /* RE-Read Configuration Data */
-        return dasd_eckd_read_conf(device);
+        DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "PSF-SSC for SSID %04x "
+                        "returned rc=%d", private->uid.ssid, rc);
 }
 
 /*
@@ -1089,7 +1089,17 @@ dasd_eckd_check_characteristics(struct dasd_device *device)
         struct dasd_eckd_private *private;
         struct dasd_block *block;
         int is_known, rc;
+        int readonly;
 
+        if (!ccw_device_is_pathgroup(device->cdev)) {
+                dev_warn(&device->cdev->dev,
+                         "A channel path group could not be established\n");
+                return -EIO;
+        }
+        if (!ccw_device_is_multipath(device->cdev)) {
+                dev_info(&device->cdev->dev,
+                         "The DASD is not operating in multipath mode\n");
+        }
         private = (struct dasd_eckd_private *) device->private;
         if (!private) {
                 private = kzalloc(sizeof(*private), GFP_KERNEL | GFP_DMA);
@@ -1123,9 +1133,9 @@ dasd_eckd_check_characteristics(struct dasd_device *device)
         if (private->uid.type == UA_BASE_DEVICE) {
                 block = dasd_alloc_block();
                 if (IS_ERR(block)) {
-                        DBF_EVENT(DBF_WARNING, "could not allocate dasd "
-                                  "block structure for device: %s",
-                                  dev_name(&device->cdev->dev));
+                        DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
+                                        "could not allocate dasd "
+                                        "block structure");
                         rc = PTR_ERR(block);
                         goto out_err1;
                 }
@@ -1139,12 +1149,21 @@ dasd_eckd_check_characteristics(struct dasd_device *device)
                 rc = is_known;
                 goto out_err2;
         }
+        /*
+         * dasd_eckd_vaildate_server is done on the first device that
+         * is found for an LCU. All later other devices have to wait
+         * for it, so they will read the correct feature codes.
+         */
         if (!is_known) {
-                /* new lcu found */
-                rc = dasd_eckd_validate_server(device); /* will switch pav on */
-                if (rc)
-                        goto out_err3;
-        }
+                dasd_eckd_validate_server(device);
+                dasd_alias_lcu_setup_complete(device);
+        } else
+                dasd_alias_wait_for_lcu_setup(device);
+
+        /* device may report different configuration data after LCU setup */
+        rc = dasd_eckd_read_conf(device);
+        if (rc)
+                goto out_err3;
 
         /* Read Feature Codes */
         dasd_eckd_read_features(device);
@@ -1153,9 +1172,8 @@ dasd_eckd_check_characteristics(struct dasd_device *device)
         rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC,
                                          &private->rdc_data, 64);
         if (rc) {
-                DBF_EVENT(DBF_WARNING,
-                          "Read device characteristics failed, rc=%d for "
-                          "device: %s", rc, dev_name(&device->cdev->dev));
+                DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
+                                "Read device characteristic failed, rc=%d", rc);
                 goto out_err3;
         }
         /* find the vaild cylinder size */
@@ -1165,15 +1183,20 @@ dasd_eckd_check_characteristics(struct dasd_device *device)
         else
                 private->real_cyl = private->rdc_data.no_cyl;
 
+        readonly = dasd_device_is_ro(device);
+        if (readonly)
+                set_bit(DASD_FLAG_DEVICE_RO, &device->flags);
+
         dev_info(&device->cdev->dev, "New DASD %04X/%02X (CU %04X/%02X) "
-                 "with %d cylinders, %d heads, %d sectors\n",
+                 "with %d cylinders, %d heads, %d sectors%s\n",
                  private->rdc_data.dev_type,
                  private->rdc_data.dev_model,
                  private->rdc_data.cu_type,
                  private->rdc_data.cu_model.model,
                  private->real_cyl,
                  private->rdc_data.trk_per_cyl,
-                 private->rdc_data.sec_per_trk);
+                 private->rdc_data.sec_per_trk,
+                 readonly ? ", read-only device" : "");
         return 0;
 
 out_err3:
@@ -1256,12 +1279,29 @@ dasd_eckd_analysis_ccw(struct dasd_device *device)
         cqr->block = NULL;
         cqr->startdev = device;
         cqr->memdev = device;
-        cqr->retries = 0;
+        cqr->retries = 255;
         cqr->buildclk = get_clock();
         cqr->status = DASD_CQR_FILLED;
         return cqr;
 }
 
+/* differentiate between 'no record found' and any other error */
+static int dasd_eckd_analysis_evaluation(struct dasd_ccw_req *init_cqr)
+{
+        char *sense;
+        if (init_cqr->status == DASD_CQR_DONE)
+                return INIT_CQR_OK;
+        else if (init_cqr->status == DASD_CQR_NEED_ERP ||
+                 init_cqr->status == DASD_CQR_FAILED) {
+                sense = dasd_get_sense(&init_cqr->irb);
+                if (sense && (sense[1] & SNS1_NO_REC_FOUND))
+                        return INIT_CQR_UNFORMATTED;
+                else
+                        return INIT_CQR_ERROR;
+        } else
+                return INIT_CQR_ERROR;
+}
+
 /*
  * This is the callback function for the init_analysis cqr. It saves
  * the status of the initial analysis ccw before it frees it and kicks
@@ -1269,21 +1309,20 @@ dasd_eckd_analysis_ccw(struct dasd_device *device)
  * dasd_eckd_do_analysis again (if the devices has not been marked
  * for deletion in the meantime).
  */
-static void
-dasd_eckd_analysis_callback(struct dasd_ccw_req *init_cqr, void *data)
+static void dasd_eckd_analysis_callback(struct dasd_ccw_req *init_cqr,
+                                        void *data)
 {
         struct dasd_eckd_private *private;
         struct dasd_device *device;
 
         device = init_cqr->startdev;
         private = (struct dasd_eckd_private *) device->private;
-        private->init_cqr_status = init_cqr->status;
+        private->init_cqr_status = dasd_eckd_analysis_evaluation(init_cqr);
         dasd_sfree_request(init_cqr, device);
         dasd_kick_device(device);
 }
 
-static int
-dasd_eckd_start_analysis(struct dasd_block *block)
+static int dasd_eckd_start_analysis(struct dasd_block *block)
 {
         struct dasd_eckd_private *private;
         struct dasd_ccw_req *init_cqr;
@@ -1295,27 +1334,44 @@ dasd_eckd_start_analysis(struct dasd_block *block)
         init_cqr->callback = dasd_eckd_analysis_callback;
         init_cqr->callback_data = NULL;
         init_cqr->expires = 5*HZ;
+        /* first try without ERP, so we can later handle unformatted
+         * devices as special case
+         */
+        clear_bit(DASD_CQR_FLAGS_USE_ERP, &init_cqr->flags);
+        init_cqr->retries = 0;
         dasd_add_request_head(init_cqr);
         return -EAGAIN;
 }
 
-static int
-dasd_eckd_end_analysis(struct dasd_block *block)
+static int dasd_eckd_end_analysis(struct dasd_block *block)
 {
         struct dasd_device *device;
         struct dasd_eckd_private *private;
         struct eckd_count *count_area;
         unsigned int sb, blk_per_trk;
         int status, i;
+        struct dasd_ccw_req *init_cqr;
 
         device = block->base;
         private = (struct dasd_eckd_private *) device->private;
         status = private->init_cqr_status;
         private->init_cqr_status = -1;
-        if (status != DASD_CQR_DONE) {
-                dev_warn(&device->cdev->dev,
-                            "The DASD is not formatted\n");
+        if (status == INIT_CQR_ERROR) {
+                /* try again, this time with full ERP */
+                init_cqr = dasd_eckd_analysis_ccw(device);
+                dasd_sleep_on(init_cqr);
+                status = dasd_eckd_analysis_evaluation(init_cqr);
+                dasd_sfree_request(init_cqr, device);
+        }
+
+        if (status == INIT_CQR_UNFORMATTED) {
+                dev_warn(&device->cdev->dev, "The DASD is not formatted\n");
                 return -EMEDIUMTYPE;
+        } else if (status == INIT_CQR_ERROR) {
+                dev_err(&device->cdev->dev,
+                        "Detecting the DASD disk layout failed because "
+                        "of an I/O error\n");
+                return -EIO;
         }
 
         private->uses_cdl = 1;
@@ -1607,8 +1663,7 @@ dasd_eckd_format_device(struct dasd_device * device,
         }
         fcp->startdev = device;
         fcp->memdev = device;
-        clear_bit(DASD_CQR_FLAGS_USE_ERP, &fcp->flags);
-        fcp->retries = 5;       /* set retry counter to enable default ERP */
+        fcp->retries = 256;
         fcp->buildclk = get_clock();
         fcp->status = DASD_CQR_FILLED;
         return fcp;
@@ -2690,6 +2745,7 @@ dasd_eckd_performance(struct dasd_device *device, void __user *argp)
         cqr->startdev = device;
         cqr->memdev = device;
         cqr->retries = 0;
+        clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
         cqr->expires = 10 * HZ;
 
         /* Prepare for Read Subsystem Data */
@@ -2789,19 +2845,27 @@ static int dasd_symm_io(struct dasd_device *device, void __user *argp)
         char *psf_data, *rssd_result;
         struct dasd_ccw_req *cqr;
         struct ccw1 *ccw;
+        char psf0, psf1;
         int rc;
 
+        if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO))
+                return -EACCES;
+        psf0 = psf1 = 0;
+
         /* Copy parms from caller */
         rc = -EFAULT;
         if (copy_from_user(&usrparm, argp, sizeof(usrparm)))
                 goto out;
-#ifndef CONFIG_64BIT
-        /* Make sure pointers are sane even on 31 bit. */
-        if ((usrparm.psf_data >> 32) != 0 || (usrparm.rssd_result >> 32) != 0) {
+        if (is_compat_task() || sizeof(long) == 4) {
+                /* Make sure pointers are sane even on 31 bit. */
                 rc = -EINVAL;
-                goto out;
+                if ((usrparm.psf_data >> 32) != 0)
+                        goto out;
+                if ((usrparm.rssd_result >> 32) != 0)
+                        goto out;
+                usrparm.psf_data &= 0x7fffffffULL;
+                usrparm.rssd_result &= 0x7fffffffULL;
         }
-#endif
         /* alloc I/O data area */
         psf_data = kzalloc(usrparm.psf_data_len, GFP_KERNEL | GFP_DMA);
         rssd_result = kzalloc(usrparm.rssd_result_len, GFP_KERNEL | GFP_DMA);
@@ -2816,12 +2880,8 @@ static int dasd_symm_io(struct dasd_device *device, void __user *argp)
                            (void __user *)(unsigned long) usrparm.psf_data,
                            usrparm.psf_data_len))
                 goto out_free;
-
-        /* sanity check on syscall header */
-        if (psf_data[0] != 0x17 && psf_data[1] != 0xce) {
-                rc = -EINVAL;
-                goto out_free;
-        }
+        psf0 = psf_data[0];
+        psf1 = psf_data[1];
 
         /* setup CCWs for PSF + RSSD */
         cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 2 , 0, device);
@@ -2872,7 +2932,9 @@ out_free:
         kfree(rssd_result);
         kfree(psf_data);
 out:
-        DBF_DEV_EVENT(DBF_WARNING, device, "Symmetrix ioctl: rc=%d", rc);
+        DBF_DEV_EVENT(DBF_WARNING, device,
+                      "Symmetrix ioctl (0x%02x 0x%02x): rc=%d",
+                      (int) psf0, (int) psf1, rc);
         return rc;
 }
 
@@ -2980,7 +3042,7 @@ static void dasd_eckd_dump_sense_ccw(struct dasd_device *device,
         len += sprintf(page + len, KERN_ERR PRINTK_HEADER
                        " in req: %p CS: 0x%02X DS: 0x%02X CC: 0x%02X RC: %d\n",
                        req, scsw_cstat(&irb->scsw), scsw_dstat(&irb->scsw),
-                       scsw_cc(&irb->scsw), req->intrc);
+                       scsw_cc(&irb->scsw), req ? req->intrc : 0);
         len += sprintf(page + len, KERN_ERR PRINTK_HEADER
                        " device %s: Failing CCW: %p\n",
                        dev_name(&device->cdev->dev),
@@ -3093,11 +3155,11 @@ static void dasd_eckd_dump_sense_tcw(struct dasd_device *device,
 
         tsb = NULL;
         sense = NULL;
-        if (irb->scsw.tm.tcw)
+        if (irb->scsw.tm.tcw && (irb->scsw.tm.fcxs == 0x01))
                 tsb = tcw_get_tsb(
                         (struct tcw *)(unsigned long)irb->scsw.tm.tcw);
 
-        if (tsb && (irb->scsw.tm.fcxs == 0x01)) {
+        if (tsb) {
                 len += sprintf(page + len, KERN_ERR PRINTK_HEADER
                                " tsb->length %d\n", tsb->length);
                 len += sprintf(page + len, KERN_ERR PRINTK_HEADER
@@ -3240,11 +3302,15 @@ int dasd_eckd_restore_device(struct dasd_device *device)
         if (is_known < 0)
                 return is_known;
         if (!is_known) {
-                /* new lcu found */
-                rc = dasd_eckd_validate_server(device); /* will switch pav on */
-                if (rc)
-                        goto out_err;
-        }
+                dasd_eckd_validate_server(device);
+                dasd_alias_lcu_setup_complete(device);
+        } else
+                dasd_alias_wait_for_lcu_setup(device);
+
+        /* RE-Read Configuration Data */
+        rc = dasd_eckd_read_conf(device);
+        if (rc)
+                goto out_err;
 
         /* Read Feature Codes */
         dasd_eckd_read_features(device);
@@ -3253,9 +3319,8 @@ int dasd_eckd_restore_device(struct dasd_device *device)
         rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC,
                                          &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));
+                DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
+                                "Read device characteristic failed, rc=%d", rc);
                 goto out_err;
         }
         spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
diff --git a/drivers/s390/block/dasd_eckd.h b/drivers/s390/block/dasd_eckd.h
index ad45bcac3ce4..864d53c04201 100644
--- a/drivers/s390/block/dasd_eckd.h
+++ b/drivers/s390/block/dasd_eckd.h
@@ -414,6 +414,7 @@ struct alias_lcu {
         struct summary_unit_check_work_data suc_data;
         struct read_uac_work_data ruac_data;
         struct dasd_ccw_req *rsu_cqr;
+        struct completion lcu_setup;
 };
 
 struct alias_pav_group {
@@ -460,5 +461,6 @@ int dasd_alias_remove_device(struct dasd_device *);
 struct dasd_device *dasd_alias_get_start_dev(struct dasd_device *);
 void dasd_alias_handle_summary_unit_check(struct dasd_device *, struct irb *);
 void dasd_eckd_reset_ccw_to_base_io(struct dasd_ccw_req *);
-
+void dasd_alias_lcu_setup_complete(struct dasd_device *);
+void dasd_alias_wait_for_lcu_setup(struct dasd_device *);
 #endif                          /* DASD_ECKD_H */
diff --git a/drivers/s390/block/dasd_eer.c b/drivers/s390/block/dasd_eer.c
index d96039eae59b..dd88803e4899 100644
--- a/drivers/s390/block/dasd_eer.c
+++ b/drivers/s390/block/dasd_eer.c
@@ -19,6 +19,7 @@
 #include <linux/mutex.h>
 #include <linux/smp_lock.h>
 #include <linux/err.h>
+#include <linux/slab.h>
 
 #include <asm/uaccess.h>
 #include <asm/atomic.h>
@@ -536,7 +537,6 @@ static int dasd_eer_open(struct inode *inp, struct file *filp)
         eerb = kzalloc(sizeof(struct eerbuffer), GFP_KERNEL);
         if (!eerb)
                 return -ENOMEM;
-        lock_kernel();
         eerb->buffer_page_count = eer_pages;
         if (eerb->buffer_page_count < 1 ||
             eerb->buffer_page_count > INT_MAX / PAGE_SIZE) {
@@ -544,7 +544,6 @@ static int dasd_eer_open(struct inode *inp, struct file *filp)
                 DBF_EVENT(DBF_WARNING, "can't open device since module "
                         "parameter eer_pages is smaller than 1 or"
                         " bigger than %d", (int)(INT_MAX / PAGE_SIZE));
-                unlock_kernel();
                 return -EINVAL;
         }
         eerb->buffersize = eerb->buffer_page_count * PAGE_SIZE;
@@ -552,14 +551,12 @@ static int dasd_eer_open(struct inode *inp, struct file *filp)
                                GFP_KERNEL);
         if (!eerb->buffer) {
                 kfree(eerb);
-                unlock_kernel();
                 return -ENOMEM;
         }
         if (dasd_eer_allocate_buffer_pages(eerb->buffer,
                                            eerb->buffer_page_count)) {
                 kfree(eerb->buffer);
                 kfree(eerb);
-                unlock_kernel();
                 return -ENOMEM;
         }
         filp->private_data = eerb;
@@ -567,7 +564,6 @@ static int dasd_eer_open(struct inode *inp, struct file *filp)
         list_add(&eerb->list, &bufferlist);
         spin_unlock_irqrestore(&bufferlock, flags);
 
-        unlock_kernel();
         return nonseekable_open(inp,filp);
 }
 
diff --git a/drivers/s390/block/dasd_fba.c b/drivers/s390/block/dasd_fba.c
index f245377e8e27..37282b90eecc 100644
--- a/drivers/s390/block/dasd_fba.c
+++ b/drivers/s390/block/dasd_fba.c
@@ -20,7 +20,6 @@
 #include <asm/idals.h>
 #include <asm/ebcdic.h>
 #include <asm/io.h>
-#include <asm/todclk.h>
 #include <asm/ccwdev.h>
 
 #include "dasd_int.h"
@@ -125,6 +124,7 @@ dasd_fba_check_characteristics(struct dasd_device *device)
         struct dasd_fba_private *private;
         struct ccw_device *cdev = device->cdev;
         int rc;
+        int readonly;
 
         private = (struct dasd_fba_private *) device->private;
         if (!private) {
@@ -141,9 +141,8 @@ dasd_fba_check_characteristics(struct dasd_device *device)
         }
         block = dasd_alloc_block();
         if (IS_ERR(block)) {
-                DBF_EVENT(DBF_WARNING, "could not allocate dasd block "
-                          "structure for device: %s",
-                          dev_name(&device->cdev->dev));
+                DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s", "could not allocate "
+                                "dasd block structure");
                 device->private = NULL;
                 kfree(private);
                 return PTR_ERR(block);
@@ -155,9 +154,8 @@ dasd_fba_check_characteristics(struct dasd_device *device)
         rc = dasd_generic_read_dev_chars(device, DASD_FBA_MAGIC,
                                          &private->rdc_data, 32);
         if (rc) {
-                DBF_EVENT(DBF_WARNING, "Read device characteristics returned "
-                          "error %d for device: %s",
-                          rc, dev_name(&device->cdev->dev));
+                DBF_EVENT_DEVID(DBF_WARNING, cdev, "Read device "
+                                "characteristics returned error %d", rc);
                 device->block = NULL;
                 dasd_free_block(block);
                 device->private = NULL;
@@ -165,16 +163,21 @@ dasd_fba_check_characteristics(struct dasd_device *device)
                 return rc;
         }
 
+        readonly = dasd_device_is_ro(device);
+        if (readonly)
+                set_bit(DASD_FLAG_DEVICE_RO, &device->flags);
+
         dev_info(&device->cdev->dev,
                  "New FBA DASD %04X/%02X (CU %04X/%02X) with %d MB "
-                 "and %d B/blk\n",
+                 "and %d B/blk%s\n",
                  cdev->id.dev_type,
                  cdev->id.dev_model,
                  cdev->id.cu_type,
                  cdev->id.cu_model,
                  ((private->rdc_data.blk_bdsa *
                    (private->rdc_data.blk_size >> 9)) >> 11),
-                 private->rdc_data.blk_size);
+                 private->rdc_data.blk_size,
+                 readonly ? ", read-only device" : "");
         return 0;
 }
 
diff --git a/drivers/s390/block/dasd_genhd.c b/drivers/s390/block/dasd_genhd.c
index d3198303b93c..30a1ca3d08b7 100644
--- a/drivers/s390/block/dasd_genhd.c
+++ b/drivers/s390/block/dasd_genhd.c
@@ -70,7 +70,8 @@ int dasd_gendisk_alloc(struct dasd_block *block)
         }
         len += sprintf(gdp->disk_name + len, "%c", 'a'+(base->devindex%26));
 
-        if (block->base->features & DASD_FEATURE_READONLY)
+        if (base->features & DASD_FEATURE_READONLY ||
+            test_bit(DASD_FLAG_DEVICE_RO, &base->flags))
                 set_disk_ro(gdp, 1);
         gdp->private_data = block;
         gdp->queue = block->request_queue;
@@ -88,6 +89,7 @@ void dasd_gendisk_free(struct dasd_block *block)
         if (block->gdp) {
                 del_gendisk(block->gdp);
                 block->gdp->queue = NULL;
+                block->gdp->private_data = NULL;
                 put_disk(block->gdp);
                 block->gdp = NULL;
         }
diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
index 8afd9fa00875..a91d4a97d4f2 100644
--- a/drivers/s390/block/dasd_int.h
+++ b/drivers/s390/block/dasd_int.h
@@ -108,6 +108,16 @@ do { \
                             d_data); \
 } while(0)
 
+#define DBF_EVENT_DEVID(d_level, d_cdev, d_str, d_data...)      \
+do { \
+        struct ccw_dev_id __dev_id;                     \
+        ccw_device_get_id(d_cdev, &__dev_id);           \
+        debug_sprintf_event(dasd_debug_area,            \
+                            d_level,                                    \
+                            "0.%x.%04x " d_str "\n",                    \
+                            __dev_id.ssid, __dev_id.devno, d_data);     \
+} while (0)
+
 #define DBF_EXC(d_level, d_str, d_data...)\
 do { \
         debug_sprintf_exception(dasd_debug_area, \
@@ -358,6 +368,7 @@ struct dasd_device {
 
         /* Device state and target state. */
         int state, target;
+        struct mutex state_mutex;
         int stopped;            /* device (ccw_device_start) was stopped */
 
         /* reference count. */
@@ -425,6 +436,10 @@ struct dasd_block {
 #define DASD_FLAG_OFFLINE       3       /* device is in offline processing */
 #define DASD_FLAG_EER_SNSS      4       /* A SNSS is required */
 #define DASD_FLAG_EER_IN_USE    5       /* A SNSS request is running */
+#define DASD_FLAG_DEVICE_RO     6       /* The device itself is read-only. Don't
+                                         * confuse this with the user specified
+                                         * read-only feature.
+                                         */
 
 void dasd_put_device_wake(struct dasd_device *);
 
@@ -595,6 +610,12 @@ int dasd_generic_restore_device(struct ccw_device *);
 int dasd_generic_read_dev_chars(struct dasd_device *, int, void *, int);
 char *dasd_get_sense(struct irb *);
 
+void dasd_device_set_stop_bits(struct dasd_device *, int);
+void dasd_device_remove_stop_bits(struct dasd_device *, int);
+
+int dasd_device_is_ro(struct dasd_device *);
+
+
 /* externals in dasd_devmap.c */
 extern int dasd_max_devindex;
 extern int dasd_probeonly;
diff --git a/drivers/s390/block/dasd_ioctl.c b/drivers/s390/block/dasd_ioctl.c
index f756a1b0c57a..1557214944f7 100644
--- a/drivers/s390/block/dasd_ioctl.c
+++ b/drivers/s390/block/dasd_ioctl.c
@@ -17,7 +17,8 @@
 #include <linux/fs.h>
 #include <linux/blkpg.h>
 #include <linux/smp_lock.h>
-
+#include <linux/slab.h>
+#include <asm/compat.h>
 #include <asm/ccwdev.h>
 #include <asm/cmb.h>
 #include <asm/uaccess.h>
@@ -101,7 +102,7 @@ static int dasd_ioctl_quiesce(struct dasd_block *block)
         pr_info("%s: The DASD has been put in the quiesce "
                 "state\n", dev_name(&base->cdev->dev));
         spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
-        base->stopped |= DASD_STOPPED_QUIESCE;
+        dasd_device_set_stop_bits(base, DASD_STOPPED_QUIESCE);
         spin_unlock_irqrestore(get_ccwdev_lock(base->cdev), flags);
         return 0;
 }
@@ -122,7 +123,7 @@ static int dasd_ioctl_resume(struct dasd_block *block)
         pr_info("%s: I/O operations have been resumed "
                 "on the DASD\n", dev_name(&base->cdev->dev));
         spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
-        base->stopped &= ~DASD_STOPPED_QUIESCE;
+        dasd_device_remove_stop_bits(base, DASD_STOPPED_QUIESCE);
         spin_unlock_irqrestore(get_ccwdev_lock(base->cdev), flags);
 
         dasd_schedule_block_bh(block);
@@ -199,7 +200,8 @@ dasd_ioctl_format(struct block_device *bdev, void __user *argp)
         if (!argp)
                 return -EINVAL;
 
-        if (block->base->features & DASD_FEATURE_READONLY)
+        if (block->base->features & DASD_FEATURE_READONLY ||
+            test_bit(DASD_FLAG_DEVICE_RO, &block->base->flags))
                 return -EROFS;
         if (copy_from_user(&fdata, argp, sizeof(struct format_data_t)))
                 return -EFAULT;
@@ -260,7 +262,7 @@ static int dasd_ioctl_information(struct dasd_block *block,
         struct ccw_dev_id dev_id;
 
         base = block->base;
-        if (!base->discipline->fill_info)
+        if (!base->discipline || !base->discipline->fill_info)
                 return -EINVAL;
 
         dasd_info = kzalloc(sizeof(struct dasd_information2_t), GFP_KERNEL);
@@ -303,10 +305,7 @@ static int dasd_ioctl_information(struct dasd_block *block,
         dasd_info->features |=
                 ((base->features & DASD_FEATURE_READONLY) != 0);
 
-        if (base->discipline)
-                memcpy(dasd_info->type, base->discipline->name, 4);
-        else
-                memcpy(dasd_info->type, "none", 4);
+        memcpy(dasd_info->type, base->discipline->name, 4);
 
         if (block->request_queue->request_fn) {
                 struct list_head *l;
@@ -352,15 +351,15 @@ dasd_ioctl_set_ro(struct block_device *bdev, void __user *argp)
                 return -EINVAL;
         if (get_user(intval, (int __user *)argp))
                 return -EFAULT;
-
+        if (!intval && test_bit(DASD_FLAG_DEVICE_RO, &block->base->flags))
+                return -EROFS;
         set_disk_ro(bdev->bd_disk, intval);
         return dasd_set_feature(block->base->cdev, DASD_FEATURE_READONLY, intval);
 }
 
 static int dasd_ioctl_readall_cmb(struct dasd_block *block, unsigned int cmd,
-                unsigned long arg)
+                                  struct cmbdata __user *argp)
 {
-        struct cmbdata __user *argp = (void __user *) arg;
         size_t size = _IOC_SIZE(cmd);
         struct cmbdata data;
         int ret;
@@ -376,7 +375,12 @@ dasd_do_ioctl(struct block_device *bdev, fmode_t mode,
               unsigned int cmd, unsigned long arg)
 {
         struct dasd_block *block = bdev->bd_disk->private_data;
-        void __user *argp = (void __user *)arg;
+        void __user *argp;
+
+        if (is_compat_task())
+                argp = compat_ptr(arg);
+        else
+                argp = (void __user *)arg;
 
         if (!block)
                 return -ENODEV;
@@ -414,7 +418,7 @@ dasd_do_ioctl(struct block_device *bdev, fmode_t mode,
         case BIODASDCMFDISABLE:
                 return disable_cmf(block->base->cdev);
         case BIODASDREADALLCMB:
-                return dasd_ioctl_readall_cmb(block, cmd, arg);
+                return dasd_ioctl_readall_cmb(block, cmd, argp);
         default:
                 /* if the discipline has an ioctl method try it. */
                 if (block->base->discipline->ioctl) {
diff --git a/drivers/s390/block/dasd_proc.c b/drivers/s390/block/dasd_proc.c
index 654daa3cdfda..2eb025592809 100644
--- a/drivers/s390/block/dasd_proc.c
+++ b/drivers/s390/block/dasd_proc.c
@@ -14,6 +14,8 @@
 #define KMSG_COMPONENT "dasd"
 
 #include <linux/ctype.h>
+#include <linux/slab.h>
+#include <linux/string.h>
 #include <linux/seq_file.h>
 #include <linux/vmalloc.h>
 #include <linux/proc_fs.h>
@@ -71,7 +73,7 @@ dasd_devices_show(struct seq_file *m, void *v)
         /* Print device number. */
         seq_printf(m, "%s", dev_name(&device->cdev->dev));
         /* Print discipline string. */
-        if (device != NULL && device->discipline != NULL)
+        if (device->discipline != NULL)
                 seq_printf(m, "(%s)", device->discipline->name);
         else
                 seq_printf(m, "(none)");
@@ -91,10 +93,7 @@ dasd_devices_show(struct seq_file *m, void *v)
         substr = (device->features & DASD_FEATURE_READONLY) ? "(ro)" : " ";
         seq_printf(m, "%4s: ", substr);
         /* Print device status information. */
-        switch ((device != NULL) ? device->state : -1) {
-        case -1:
-                seq_printf(m, "unknown");
-                break;
+        switch (device->state) {
         case DASD_STATE_NEW:
                 seq_printf(m, "new");
                 break;
@@ -167,99 +166,82 @@ static const struct file_operations dasd_devices_file_ops = {
         .release        = seq_release,
 };
 
-static int
-dasd_calc_metrics(char *page, char **start, off_t off,
-                  int count, int *eof, int len)
-{
-        len = (len > off) ? len - off : 0;
-        if (len > count)
-                len = count;
-        if (len < count)
-                *eof = 1;
-        *start = page + off;
-        return len;
-}
-
 #ifdef CONFIG_DASD_PROFILE
-static char *
-dasd_statistics_array(char *str, unsigned int *array, int factor)
+static void dasd_statistics_array(struct seq_file *m, unsigned int *array, int factor)
 {
         int i;
 
         for (i = 0; i < 32; i++) {
-                str += sprintf(str, "%7d ", array[i] / factor);
+                seq_printf(m, "%7d ", array[i] / factor);
                 if (i == 15)
-                        str += sprintf(str, "\n");
+                        seq_putc(m, '\n');
         }
-        str += sprintf(str,"\n");
-        return str;
+        seq_putc(m, '\n');
 }
 #endif /* CONFIG_DASD_PROFILE */
 
-static int
-dasd_statistics_read(char *page, char **start, off_t off,
-                     int count, int *eof, void *data)
+static int dasd_stats_proc_show(struct seq_file *m, void *v)
 {
-        unsigned long len;
 #ifdef CONFIG_DASD_PROFILE
         struct dasd_profile_info_t *prof;
-        char *str;
         int factor;
 
         /* check for active profiling */
         if (dasd_profile_level == DASD_PROFILE_OFF) {
-                len = sprintf(page, "Statistics are off - they might be "
+                seq_printf(m, "Statistics are off - they might be "
                                     "switched on using 'echo set on > "
                                     "/proc/dasd/statistics'\n");
-                return dasd_calc_metrics(page, start, off, count, eof, len);
+                return 0;
         }
 
         prof = &dasd_global_profile;
-        /* prevent couter 'overflow' on output */
+        /* prevent counter 'overflow' on output */
         for (factor = 1; (prof->dasd_io_reqs / factor) > 9999999;
              factor *= 10);
 
-        str = page;
-        str += sprintf(str, "%d dasd I/O requests\n", prof->dasd_io_reqs);
-        str += sprintf(str, "with %u sectors(512B each)\n",
+        seq_printf(m, "%d dasd I/O requests\n", prof->dasd_io_reqs);
+        seq_printf(m, "with %u sectors(512B each)\n",
                        prof->dasd_io_sects);
-        str += sprintf(str, "Scale Factor is  %d\n", factor);
-        str += sprintf(str,
+        seq_printf(m, "Scale Factor is  %d\n", factor);
+        seq_printf(m,
                        "   __<4    ___8    __16    __32    __64    _128 "
                        "   _256    _512    __1k    __2k    __4k    __8k "
                        "   _16k    _32k    _64k    128k\n");
-        str += sprintf(str,
+        seq_printf(m,
                        "   _256    _512    __1M    __2M    __4M    __8M "
                        "   _16M    _32M    _64M    128M    256M    512M "
                        "   __1G    __2G    __4G " "   _>4G\n");
 
-        str += sprintf(str, "Histogram of sizes (512B secs)\n");
-        str = dasd_statistics_array(str, prof->dasd_io_secs, factor);
-        str += sprintf(str, "Histogram of I/O times (microseconds)\n");
-        str = dasd_statistics_array(str, prof->dasd_io_times, factor);
-        str += sprintf(str, "Histogram of I/O times per sector\n");
-        str = dasd_statistics_array(str, prof->dasd_io_timps, factor);
-        str += sprintf(str, "Histogram of I/O time till ssch\n");
-        str = dasd_statistics_array(str, prof->dasd_io_time1, factor);
-        str += sprintf(str, "Histogram of I/O time between ssch and irq\n");
-        str = dasd_statistics_array(str, prof->dasd_io_time2, factor);
-        str += sprintf(str, "Histogram of I/O time between ssch "
+        seq_printf(m, "Histogram of sizes (512B secs)\n");
+        dasd_statistics_array(m, prof->dasd_io_secs, factor);
+        seq_printf(m, "Histogram of I/O times (microseconds)\n");
+        dasd_statistics_array(m, prof->dasd_io_times, factor);
+        seq_printf(m, "Histogram of I/O times per sector\n");
+        dasd_statistics_array(m, prof->dasd_io_timps, factor);
+        seq_printf(m, "Histogram of I/O time till ssch\n");
+        dasd_statistics_array(m, prof->dasd_io_time1, factor);
+        seq_printf(m, "Histogram of I/O time between ssch and irq\n");
+        dasd_statistics_array(m, prof->dasd_io_time2, factor);
+        seq_printf(m, "Histogram of I/O time between ssch "
                             "and irq per sector\n");
-        str = dasd_statistics_array(str, prof->dasd_io_time2ps, factor);
-        str += sprintf(str, "Histogram of I/O time between irq and end\n");
-        str = dasd_statistics_array(str, prof->dasd_io_time3, factor);
-        str += sprintf(str, "# of req in chanq at enqueuing (1..32) \n");
-        str = dasd_statistics_array(str, prof->dasd_io_nr_req, factor);
-        len = str - page;
+        dasd_statistics_array(m, prof->dasd_io_time2ps, factor);
+        seq_printf(m, "Histogram of I/O time between irq and end\n");
+        dasd_statistics_array(m, prof->dasd_io_time3, factor);
+        seq_printf(m, "# of req in chanq at enqueuing (1..32) \n");
+        dasd_statistics_array(m, prof->dasd_io_nr_req, factor);
 #else
-        len = sprintf(page, "Statistics are not activated in this kernel\n");
+        seq_printf(m, "Statistics are not activated in this kernel\n");
 #endif
-        return dasd_calc_metrics(page, start, off, count, eof, len);
+        return 0;
 }
 
-static int
-dasd_statistics_write(struct file *file, const char __user *user_buf,
-                      unsigned long user_len, void *data)
+static int dasd_stats_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, dasd_stats_proc_show, NULL);
+}
+
+static ssize_t dasd_stats_proc_write(struct file *file,
+                const char __user *user_buf, size_t user_len, loff_t *pos)
 {
 #ifdef CONFIG_DASD_PROFILE
         char *buffer, *str;
@@ -272,10 +254,10 @@ dasd_statistics_write(struct file *file, const char __user *user_buf,
         DBF_EVENT(DBF_DEBUG, "/proc/dasd/statictics: '%s'\n", buffer);
 
         /* check for valid verbs */
-        for (str = buffer; isspace(*str); str++);
+        str = skip_spaces(buffer);
         if (strncmp(str, "set", 3) == 0 && isspace(str[3])) {
                 /* 'set xxx' was given */
-                for (str = str + 4; isspace(*str); str++);
+                str = skip_spaces(str + 4);
                 if (strcmp(str, "on") == 0) {
                         /* switch on statistics profiling */
                         dasd_profile_level = DASD_PROFILE_ON;
@@ -310,6 +292,15 @@ out_error:
 #endif                          /* CONFIG_DASD_PROFILE */
 }
 
+static const struct file_operations dasd_stats_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = dasd_stats_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+        .write          = dasd_stats_proc_write,
+};
+
 /*
  * Create dasd proc-fs entries.
  * In case creation failed, cleanup and return -ENOENT.
@@ -326,13 +317,12 @@ dasd_proc_init(void)
                                          &dasd_devices_file_ops);
         if (!dasd_devices_entry)
                 goto out_nodevices;
-        dasd_statistics_entry = create_proc_entry("statistics",
-                                                  S_IFREG | S_IRUGO | S_IWUSR,
-                                                  dasd_proc_root_entry);
+        dasd_statistics_entry = proc_create("statistics",
+                                            S_IFREG | S_IRUGO | S_IWUSR,
+                                            dasd_proc_root_entry,
+                                            &dasd_stats_proc_fops);
         if (!dasd_statistics_entry)
                 goto out_nostatistics;
-        dasd_statistics_entry->read_proc = dasd_statistics_read;
-        dasd_statistics_entry->write_proc = dasd_statistics_write;
         return 0;
 
  out_nostatistics:
diff --git a/drivers/s390/block/dcssblk.c b/drivers/s390/block/dcssblk.c
index f76f4bd82b9f..9b43ae94beba 100644
--- a/drivers/s390/block/dcssblk.c
+++ b/drivers/s390/block/dcssblk.c
@@ -1005,7 +1005,7 @@ static int dcssblk_thaw(struct device *dev)
         return 0;
 }
 
-static struct dev_pm_ops dcssblk_pm_ops = {
+static const struct dev_pm_ops dcssblk_pm_ops = {
         .freeze         = dcssblk_freeze,
         .thaw           = dcssblk_thaw,
         .restore        = dcssblk_restore,
diff --git a/drivers/s390/block/xpram.c b/drivers/s390/block/xpram.c
index 116d1b3eeb15..c881a14fa5dd 100644
--- a/drivers/s390/block/xpram.c
+++ b/drivers/s390/block/xpram.c
@@ -33,7 +33,6 @@
 #include <linux/ctype.h>  /* isdigit, isxdigit */
 #include <linux/errno.h>
 #include <linux/init.h>
-#include <linux/slab.h>
 #include <linux/blkdev.h>
 #include <linux/blkpg.h>
 #include <linux/hdreg.h>  /* HDIO_GETGEO */
@@ -41,6 +40,7 @@
 #include <linux/bio.h>
 #include <linux/suspend.h>
 #include <linux/platform_device.h>
+#include <linux/gfp.h>
 #include <asm/uaccess.h>
 
 #define XPRAM_NAME      "xpram"
@@ -407,7 +407,7 @@ static int xpram_restore(struct device *dev)
         return 0;
 }
 
-static struct dev_pm_ops xpram_pm_ops = {
+static const struct dev_pm_ops xpram_pm_ops = {
         .restore        = xpram_restore,
 };
 
diff --git a/drivers/s390/char/con3215.c b/drivers/s390/char/con3215.c
index 21639d6c996f..59ec073724bf 100644
--- a/drivers/s390/char/con3215.c
+++ b/drivers/s390/char/con3215.c
@@ -857,7 +857,6 @@ static struct console con3215 = {
 
 /*
  * 3215 console initialization code called from console_init().
- * NOTE: This is called before kmalloc is available.
  */
 static int __init con3215_init(void)
 {
@@ -1038,22 +1037,6 @@ static void tty3215_flush_buffer(struct tty_struct *tty)
 }
 
 /*
- * Currently we don't have any io controls for 3215 ttys
- */
-static int tty3215_ioctl(struct tty_struct *tty, struct file * file,
-                         unsigned int cmd, unsigned long arg)
-{
-        if (tty->flags & (1 << TTY_IO_ERROR))
-                return -EIO;
-
-        switch (cmd) {
-        default:
-                return -ENOIOCTLCMD;
-        }
-        return 0;
-}
-
-/*
  * Disable reading from a 3215 tty
  */
 static void tty3215_throttle(struct tty_struct * tty)
@@ -1118,7 +1101,6 @@ static const struct tty_operations tty3215_ops = {
         .write_room = tty3215_write_room,
         .chars_in_buffer = tty3215_chars_in_buffer,
         .flush_buffer = tty3215_flush_buffer,
-        .ioctl = tty3215_ioctl,
         .throttle = tty3215_throttle,
         .unthrottle = tty3215_unthrottle,
         .stop = tty3215_stop,
diff --git a/drivers/s390/char/con3270.c b/drivers/s390/char/con3270.c
index bb838bdf829d..bb07577e8fd4 100644
--- a/drivers/s390/char/con3270.c
+++ b/drivers/s390/char/con3270.c
@@ -12,6 +12,7 @@
 #include <linux/interrupt.h>
 #include <linux/list.h>
 #include <linux/types.h>
+#include <linux/slab.h>
 #include <linux/err.h>
 #include <linux/reboot.h>
 
@@ -572,7 +573,6 @@ static struct console con3270 = {
 
 /*
  * 3270 console initialization code called from console_init().
- * NOTE: This is called before kmalloc is available.
  */
 static int __init
 con3270_init(void)
diff --git a/drivers/s390/char/fs3270.c b/drivers/s390/char/fs3270.c
index 097d3846a828..0eabcca3c92d 100644
--- a/drivers/s390/char/fs3270.c
+++ b/drivers/s390/char/fs3270.c
@@ -12,9 +12,11 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/smp_lock.h>
 
+#include <asm/compat.h>
 #include <asm/ccwdev.h>
 #include <asm/cio.h>
 #include <asm/ebcdic.h>
@@ -38,6 +40,8 @@ struct fs3270 {
         size_t rdbuf_size;              /* size of data returned by RDBUF */
 };
 
+static DEFINE_MUTEX(fs3270_mutex);
+
 static void
 fs3270_wake_up(struct raw3270_request *rq, void *data)
 {
@@ -74,7 +78,7 @@ fs3270_do_io(struct raw3270_view *view, struct raw3270_request *rq)
                 }
                 rc = raw3270_start(view, rq);
                 if (rc == 0) {
-                        /* Started sucessfully. Now wait for completion. */
+                        /* Started successfully. Now wait for completion. */
                         wait_event(fp->wait, raw3270_request_final(rq));
                 }
         } while (rc == -EACCES);
@@ -320,6 +324,7 @@ fs3270_write(struct file *filp, const char __user *data, size_t count, loff_t *o
 static long
 fs3270_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
+        char __user *argp;
         struct fs3270 *fp;
         struct raw3270_iocb iocb;
         int rc;
@@ -327,8 +332,12 @@ fs3270_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
         fp = filp->private_data;
         if (!fp)
                 return -ENODEV;
+        if (is_compat_task())
+                argp = compat_ptr(arg);
+        else
+                argp = (char __user *)arg;
         rc = 0;
-        lock_kernel();
+        mutex_lock(&fs3270_mutex);
         switch (cmd) {
         case TUBICMD:
                 fp->read_command = arg;
@@ -337,10 +346,10 @@ fs3270_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                 fp->write_command = arg;
                 break;
         case TUBGETI:
-                rc = put_user(fp->read_command, (char __user *) arg);
+                rc = put_user(fp->read_command, argp);
                 break;
         case TUBGETO:
-                rc = put_user(fp->write_command,(char __user *) arg);
+                rc = put_user(fp->write_command, argp);
                 break;
         case TUBGETMOD:
                 iocb.model = fp->view.model;
@@ -349,12 +358,11 @@ fs3270_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                 iocb.pf_cnt = 24;
                 iocb.re_cnt = 20;
                 iocb.map = 0;
-                if (copy_to_user((char __user *) arg, &iocb,
-                                 sizeof(struct raw3270_iocb)))
+                if (copy_to_user(argp, &iocb, sizeof(struct raw3270_iocb)))
                         rc = -EFAULT;
                 break;
         }
-        unlock_kernel();
+        mutex_unlock(&fs3270_mutex);
         return rc;
 }
 
@@ -437,7 +445,7 @@ fs3270_open(struct inode *inode, struct file *filp)
                 minor = tty->index + RAW3270_FIRSTMINOR;
                 tty_kref_put(tty);
         }
-        lock_kernel();
+        mutex_lock(&fs3270_mutex);
         /* Check if some other program is already using fullscreen mode. */
         fp = (struct fs3270 *) raw3270_find_view(&fs3270_fn, minor);
         if (!IS_ERR(fp)) {
@@ -465,7 +473,7 @@ fs3270_open(struct inode *inode, struct file *filp)
         if (IS_ERR(ib)) {
                 raw3270_put_view(&fp->view);
                 raw3270_del_view(&fp->view);
-                rc = PTR_ERR(fp);
+                rc = PTR_ERR(ib);
                 goto out;
         }
         fp->rdbuf = ib;
@@ -478,7 +486,7 @@ fs3270_open(struct inode *inode, struct file *filp)
         }
         filp->private_data = fp;
 out:
-        unlock_kernel();
+        mutex_unlock(&fs3270_mutex);
         return rc;
 }
 
@@ -509,8 +517,8 @@ static const struct file_operations fs3270_fops = {
         .write           = fs3270_write,        /* write */
         .unlocked_ioctl  = fs3270_ioctl,        /* ioctl */
         .compat_ioctl    = fs3270_ioctl,        /* ioctl */
-        .open           = fs3270_open,          /* open */
-        .release        = fs3270_close,         /* release */
+        .open            = fs3270_open,         /* open */
+        .release         = fs3270_close,        /* release */
 };
 
 /*
diff --git a/drivers/s390/char/keyboard.c b/drivers/s390/char/keyboard.c
index cee4d4e42429..cb6bffe7141a 100644
--- a/drivers/s390/char/keyboard.c
+++ b/drivers/s390/char/keyboard.c
@@ -9,6 +9,7 @@
 
 #include <linux/module.h>
 #include <linux/sched.h>
+#include <linux/slab.h>
 #include <linux/sysrq.h>
 
 #include <linux/consolemap.h>
diff --git a/drivers/s390/char/monreader.c b/drivers/s390/char/monreader.c
index 66e21dd23154..2ed3f82e5c30 100644
--- a/drivers/s390/char/monreader.c
+++ b/drivers/s390/char/monreader.c
@@ -12,7 +12,6 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
@@ -22,6 +21,7 @@
 #include <linux/interrupt.h>
 #include <linux/poll.h>
 #include <linux/device.h>
+#include <linux/slab.h>
 #include <net/iucv/iucv.h>
 #include <asm/uaccess.h>
 #include <asm/ebcdic.h>
@@ -283,7 +283,6 @@ static int mon_open(struct inode *inode, struct file *filp)
         /*
          * only one user allowed
          */
-        lock_kernel();
         rc = -EBUSY;
         if (test_and_set_bit(MON_IN_USE, &mon_in_use))
                 goto out;
@@ -321,7 +320,6 @@ static int mon_open(struct inode *inode, struct file *filp)
         }
         filp->private_data = monpriv;
         dev_set_drvdata(monreader_device, monpriv);
-        unlock_kernel();
         return nonseekable_open(inode, filp);
 
 out_path:
@@ -331,7 +329,6 @@ out_priv:
 out_use:
         clear_bit(MON_IN_USE, &mon_in_use);
 out:
-        unlock_kernel();
         return rc;
 }
 
@@ -533,7 +530,7 @@ static int monreader_restore(struct device *dev)
         return monreader_thaw(dev);
 }
 
-static struct dev_pm_ops monreader_pm_ops = {
+static const struct dev_pm_ops monreader_pm_ops = {
         .freeze  = monreader_freeze,
         .thaw    = monreader_thaw,
         .restore = monreader_restore,
@@ -607,6 +604,10 @@ static int __init mon_init(void)
         }
         dcss_mkname(mon_dcss_name, &user_data_connect[8]);
 
+        /*
+         * misc_register() has to be the last action in module_init(), because
+         * file operations will be available right after this.
+         */
         rc = misc_register(&mon_dev);
         if (rc < 0 )
                 goto out;
diff --git a/drivers/s390/char/monwriter.c b/drivers/s390/char/monwriter.c
index 66fb8eba93f4..98a49dfda1de 100644
--- a/drivers/s390/char/monwriter.c
+++ b/drivers/s390/char/monwriter.c
@@ -13,7 +13,6 @@
 #include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/errno.h>
-#include <linux/smp_lock.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/miscdevice.h>
@@ -21,6 +20,7 @@
 #include <linux/poll.h>
 #include <linux/mutex.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <asm/uaccess.h>
 #include <asm/ebcdic.h>
 #include <asm/io.h>
@@ -185,13 +185,11 @@ static int monwrite_open(struct inode *inode, struct file *filp)
         monpriv = kzalloc(sizeof(struct mon_private), GFP_KERNEL);
         if (!monpriv)
                 return -ENOMEM;
-        lock_kernel();
         INIT_LIST_HEAD(&monpriv->list);
         monpriv->hdr_to_read = sizeof(monpriv->hdr);
         mutex_init(&monpriv->thread_mutex);
         filp->private_data = monpriv;
         list_add_tail(&monpriv->priv_list, &mon_priv_list);
-        unlock_kernel();
         return nonseekable_open(inode, filp);
 }
 
@@ -326,7 +324,7 @@ static int monwriter_thaw(struct device *dev)
         return monwriter_restore(dev);
 }
 
-static struct dev_pm_ops monwriter_pm_ops = {
+static const struct dev_pm_ops monwriter_pm_ops = {
         .freeze         = monwriter_freeze,
         .thaw           = monwriter_thaw,
         .restore        = monwriter_restore,
@@ -364,6 +362,10 @@ static int __init mon_init(void)
                 goto out_driver;
         }
 
+        /*
+         * misc_register() has to be the last action in module_init(), because
+         * file operations will be available right after this.
+         */
         rc = misc_register(&mon_dev);
         if (rc)
                 goto out_device;
diff --git a/drivers/s390/char/raw3270.c b/drivers/s390/char/raw3270.c
index 62ddf5202b79..2a4c566456e7 100644
--- a/drivers/s390/char/raw3270.c
+++ b/drivers/s390/char/raw3270.c
@@ -373,7 +373,7 @@ raw3270_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
                 rq->rc = ccw_device_start(rp->cdev, &rq->ccw,
                                           (unsigned long) rq, 0, 0);
                 if (rq->rc == 0)
-                        return; /* Sucessfully restarted. */
+                        return; /* Successfully restarted. */
                 break;
         case RAW3270_IO_STOP:
                 if (!rq)
diff --git a/drivers/s390/char/sclp.c b/drivers/s390/char/sclp.c
index a983f5086788..f6d72e1f2a38 100644
--- a/drivers/s390/char/sclp.c
+++ b/drivers/s390/char/sclp.c
@@ -196,7 +196,7 @@ __sclp_start_request(struct sclp_req *req)
         req->start_count++;
 
         if (rc == 0) {
-                /* Sucessfully started request */
+                /* Successfully started request */
                 req->status = SCLP_REQ_RUNNING;
                 sclp_running_state = sclp_running_state_running;
                 __sclp_set_request_timer(SCLP_RETRY_INTERVAL * HZ,
@@ -1019,7 +1019,7 @@ static int sclp_restore(struct device *dev)
         return sclp_undo_suspend(SCLP_PM_EVENT_RESTORE);
 }
 
-static struct dev_pm_ops sclp_pm_ops = {
+static const struct dev_pm_ops sclp_pm_ops = {
         .freeze         = sclp_freeze,
         .thaw           = sclp_thaw,
         .restore        = sclp_restore,
diff --git a/drivers/s390/char/sclp_async.c b/drivers/s390/char/sclp_async.c
index b44462a6c6d3..7ad30e72f868 100644
--- a/drivers/s390/char/sclp_async.c
+++ b/drivers/s390/char/sclp_async.c
@@ -11,6 +11,7 @@
 #include <linux/device.h>
 #include <linux/stat.h>
 #include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/ctype.h>
 #include <linux/kmod.h>
 #include <linux/err.h>
@@ -84,6 +85,7 @@ static int proc_handler_callhome(struct ctl_table *ctl, int write,
                 rc = copy_from_user(buf, buffer, sizeof(buf));
                 if (rc != 0)
                         return -EFAULT;
+                buf[sizeof(buf) - 1] = '\0';
                 if (strict_strtoul(buf, 0, &val) != 0)
                         return -EINVAL;
                 if (val != 0 && val != 1)
@@ -101,18 +103,17 @@ static struct ctl_table callhome_table[] = {
                 .mode           = 0644,
                 .proc_handler   = proc_handler_callhome,
         },
-        { .ctl_name = 0 }
+        {}
 };
 
 static struct ctl_table kern_dir_table[] = {
         {
-                .ctl_name       = CTL_KERN,
                 .procname       = "kernel",
                 .maxlen         = 0,
                 .mode           = 0555,
                 .child          = callhome_table,
         },
-        { .ctl_name = 0 }
+        {}
 };
 
 /*
diff --git a/drivers/s390/char/sclp_cmd.c b/drivers/s390/char/sclp_cmd.c
index 5cc11c636d38..4b60ede07f0e 100644
--- a/drivers/s390/char/sclp_cmd.c
+++ b/drivers/s390/char/sclp_cmd.c
@@ -84,6 +84,7 @@ static void __init sclp_read_info_early(void)
                 do {
                         memset(sccb, 0, sizeof(*sccb));
                         sccb->header.length = sizeof(*sccb);
+                        sccb->header.function_code = 0x80;
                         sccb->header.control_mask[2] = 0x80;
                         rc = sclp_cmd_sync_early(commands[i], sccb);
                 } while (rc == -EBUSY);
@@ -307,6 +308,13 @@ struct assign_storage_sccb {
         u16 rn;
 } __packed;
 
+int arch_get_memory_phys_device(unsigned long start_pfn)
+{
+        if (!rzm)
+                return 0;
+        return PFN_PHYS(start_pfn) >> ilog2(rzm);
+}
+
 static unsigned long long rn2addr(u16 rn)
 {
         return (unsigned long long) (rn - 1) * rzm;
@@ -546,7 +554,7 @@ struct read_storage_sccb {
         u32 entries[0];
 } __packed;
 
-static struct dev_pm_ops sclp_mem_pm_ops = {
+static const struct dev_pm_ops sclp_mem_pm_ops = {
         .freeze         = sclp_mem_freeze,
 };
 
diff --git a/drivers/s390/char/sclp_con.c b/drivers/s390/char/sclp_con.c
index ad698d30cb3b..ecf45c54f8c4 100644
--- a/drivers/s390/char/sclp_con.c
+++ b/drivers/s390/char/sclp_con.c
@@ -14,6 +14,7 @@
 #include <linux/termios.h>
 #include <linux/err.h>
 #include <linux/reboot.h>
+#include <linux/gfp.h>
 
 #include "sclp.h"
 #include "sclp_rw.h"
diff --git a/drivers/s390/char/sclp_tty.c b/drivers/s390/char/sclp_tty.c
index 434ba04b1309..8258d590505f 100644
--- a/drivers/s390/char/sclp_tty.c
+++ b/drivers/s390/char/sclp_tty.c
@@ -13,10 +13,10 @@
 #include <linux/tty.h>
 #include <linux/tty_driver.h>
 #include <linux/tty_flip.h>
-#include <linux/slab.h>
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
+#include <linux/gfp.h>
 #include <asm/uaccess.h>
 
 #include "ctrlchar.h"
diff --git a/drivers/s390/char/sclp_vt220.c b/drivers/s390/char/sclp_vt220.c
index b9d2a007e93b..5d706e6c946f 100644
--- a/drivers/s390/char/sclp_vt220.c
+++ b/drivers/s390/char/sclp_vt220.c
@@ -23,6 +23,7 @@
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/reboot.h>
+#include <linux/slab.h>
 
 #include <asm/uaccess.h>
 #include "sclp.h"
@@ -495,6 +496,10 @@ sclp_vt220_open(struct tty_struct *tty, struct file *filp)
                 if (tty->driver_data == NULL)
                         return -ENOMEM;
                 tty->low_latency = 0;
+                if (!tty->winsize.ws_row && !tty->winsize.ws_col) {
+                        tty->winsize.ws_row = 24;
+                        tty->winsize.ws_col = 80;
+                }
         }
         return 0;
 }
diff --git a/drivers/s390/char/tape.h b/drivers/s390/char/tape.h
index a26333774701..7a242f073632 100644
--- a/drivers/s390/char/tape.h
+++ b/drivers/s390/char/tape.h
@@ -212,6 +212,9 @@ struct tape_device {
         struct tape_class_device *      nt;
         struct tape_class_device *      rt;
 
+        /* Device mutex to serialize tape commands. */
+        struct mutex                    mutex;
+
         /* Device discipline information. */
         struct tape_discipline *        discipline;
         void *                          discdata;
@@ -292,9 +295,9 @@ extern int tape_generic_pm_suspend(struct ccw_device *);
 extern int tape_generic_probe(struct ccw_device *);
 extern void tape_generic_remove(struct ccw_device *);
 
-extern struct tape_device *tape_get_device(int devindex);
-extern struct tape_device *tape_get_device_reference(struct tape_device *);
-extern struct tape_device *tape_put_device(struct tape_device *);
+extern struct tape_device *tape_find_device(int devindex);
+extern struct tape_device *tape_get_device(struct tape_device *);
+extern void tape_put_device(struct tape_device *);
 
 /* Externals from tape_char.c */
 extern int tapechar_init(void);
diff --git a/drivers/s390/char/tape_34xx.c b/drivers/s390/char/tape_34xx.c
index 2fe45ff77b75..c17f35b6136a 100644
--- a/drivers/s390/char/tape_34xx.c
+++ b/drivers/s390/char/tape_34xx.c
@@ -9,11 +9,13 @@
  */
 
 #define KMSG_COMPONENT "tape_34xx"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/bio.h>
 #include <linux/workqueue.h>
+#include <linux/slab.h>
 
 #define TAPE_DBF_AREA   tape_34xx_dbf
 
@@ -113,16 +115,16 @@ tape_34xx_work_handler(struct work_struct *work)
 {
         struct tape_34xx_work *p =
                 container_of(work, struct tape_34xx_work, work);
+        struct tape_device *device = p->device;
 
         switch(p->op) {
                 case TO_MSEN:
-                        tape_34xx_medium_sense(p->device);
+                        tape_34xx_medium_sense(device);
                         break;
                 default:
                         DBF_EVENT(3, "T34XX: internal error: unknown work\n");
         }
-
-        p->device = tape_put_device(p->device);
+        tape_put_device(device);
         kfree(p);
 }
 
@@ -136,7 +138,7 @@ tape_34xx_schedule_work(struct tape_device *device, enum tape_op op)
 
         INIT_WORK(&p->work, tape_34xx_work_handler);
 
-        p->device = tape_get_device_reference(device);
+        p->device = tape_get_device(device);
         p->op     = op;
 
         schedule_work(&p->work);
diff --git a/drivers/s390/char/tape_3590.c b/drivers/s390/char/tape_3590.c
index e4cc3aae9162..fc993acf99b6 100644
--- a/drivers/s390/char/tape_3590.c
+++ b/drivers/s390/char/tape_3590.c
@@ -9,8 +9,10 @@
  */
 
 #define KMSG_COMPONENT "tape_3590"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/bio.h>
 #include <asm/ebcdic.h>
@@ -136,7 +138,7 @@ static void int_to_ext_kekl(struct tape3592_kekl *in,
                 out->type_on_tape = TAPE390_KEKL_TYPE_LABEL;
         memcpy(out->label, in->label, sizeof(in->label));
         EBCASC(out->label, sizeof(in->label));
-        strstrip(out->label);
+        strim(out->label);
 }
 
 static void int_to_ext_kekl_pair(struct tape3592_kekl_pair *in,
@@ -608,7 +610,7 @@ tape_3590_schedule_work(struct tape_device *device, enum tape_op op)
 
         INIT_WORK(&p->work, tape_3590_work_handler);
 
-        p->device = tape_get_device_reference(device);
+        p->device = tape_get_device(device);
         p->op = op;
 
         schedule_work(&p->work);
diff --git a/drivers/s390/char/tape_block.c b/drivers/s390/char/tape_block.c
index 0c0705b91c28..097da8ce6be6 100644
--- a/drivers/s390/char/tape_block.c
+++ b/drivers/s390/char/tape_block.c
@@ -11,6 +11,7 @@
  */
 
 #define KMSG_COMPONENT "tape"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include <linux/fs.h>
 #include <linux/module.h>
@@ -45,8 +46,6 @@
  */
 static int tapeblock_open(struct block_device *, fmode_t);
 static int tapeblock_release(struct gendisk *, fmode_t);
-static int tapeblock_ioctl(struct block_device *, fmode_t, unsigned int,
-                                unsigned long);
 static int tapeblock_medium_changed(struct gendisk *);
 static int tapeblock_revalidate_disk(struct gendisk *);
 
@@ -54,7 +53,6 @@ static const struct block_device_operations tapeblock_fops = {
         .owner           = THIS_MODULE,
         .open            = tapeblock_open,
         .release         = tapeblock_release,
-        .locked_ioctl           = tapeblock_ioctl,
         .media_changed   = tapeblock_medium_changed,
         .revalidate_disk = tapeblock_revalidate_disk,
 };
@@ -224,9 +222,8 @@ tapeblock_setup_device(struct tape_device * device)
                 goto cleanup_queue;
 
         blk_queue_logical_block_size(blkdat->request_queue, TAPEBLOCK_HSEC_SIZE);
-        blk_queue_max_sectors(blkdat->request_queue, TAPEBLOCK_MAX_SEC);
-        blk_queue_max_phys_segments(blkdat->request_queue, -1L);
-        blk_queue_max_hw_segments(blkdat->request_queue, -1L);
+        blk_queue_max_hw_sectors(blkdat->request_queue, TAPEBLOCK_MAX_SEC);
+        blk_queue_max_segments(blkdat->request_queue, -1L);
         blk_queue_max_segment_size(blkdat->request_queue, -1L);
         blk_queue_segment_boundary(blkdat->request_queue, -1L);
 
@@ -239,7 +236,7 @@ tapeblock_setup_device(struct tape_device * device)
         disk->major = tapeblock_major;
         disk->first_minor = device->first_minor;
         disk->fops = &tapeblock_fops;
-        disk->private_data = tape_get_device_reference(device);
+        disk->private_data = tape_get_device(device);
         disk->queue = blkdat->request_queue;
         set_capacity(disk, 0);
         sprintf(disk->disk_name, "btibm%d",
@@ -247,11 +244,11 @@ tapeblock_setup_device(struct tape_device * device)
 
         blkdat->disk = disk;
         blkdat->medium_changed = 1;
-        blkdat->request_queue->queuedata = tape_get_device_reference(device);
+        blkdat->request_queue->queuedata = tape_get_device(device);
 
         add_disk(disk);
 
-        tape_get_device_reference(device);
+        tape_get_device(device);
         INIT_WORK(&blkdat->requeue_task, tapeblock_requeue);
 
         return 0;
@@ -274,13 +271,14 @@ tapeblock_cleanup_device(struct tape_device *device)
         }
 
         del_gendisk(device->blk_data.disk);
-        device->blk_data.disk->private_data =
-                tape_put_device(device->blk_data.disk->private_data);
+        device->blk_data.disk->private_data = NULL;
+        tape_put_device(device);
         put_disk(device->blk_data.disk);
 
         device->blk_data.disk = NULL;
 cleanup_queue:
-        device->blk_data.request_queue->queuedata = tape_put_device(device);
+        device->blk_data.request_queue->queuedata = NULL;
+        tape_put_device(device);
 
         blk_cleanup_queue(device->blk_data.request_queue);
         device->blk_data.request_queue = NULL;
@@ -363,7 +361,7 @@ tapeblock_open(struct block_device *bdev, fmode_t mode)
         struct tape_device *    device;
         int                     rc;
 
-        device = tape_get_device_reference(disk->private_data);
+        device = tape_get_device(disk->private_data);
 
         if (device->required_tapemarks) {
                 DBF_EVENT(2, "TBLOCK: missing tapemarks\n");
@@ -414,42 +412,6 @@ tapeblock_release(struct gendisk *disk, fmode_t mode)
 }
 
 /*
- * Support of some generic block device IOCTLs.
- */
-static int
-tapeblock_ioctl(
-        struct block_device *   bdev,
-        fmode_t                 mode,
-        unsigned int            command,
-        unsigned long           arg
-) {
-        int rc;
-        int minor;
-        struct gendisk *disk = bdev->bd_disk;
-        struct tape_device *device;
-
-        rc     = 0;
-        BUG_ON(!disk);
-        device = disk->private_data;
-        BUG_ON(!device);
-        minor  = MINOR(bdev->bd_dev);
-
-        DBF_LH(6, "tapeblock_ioctl(0x%0x)\n", command);
-        DBF_LH(6, "device = %d:%d\n", tapeblock_major, minor);
-
-        switch (command) {
-                /* Refuse some IOCTL calls without complaining (mount). */
-                case 0x5310:            /* CDROMMULTISESSION */
-                        rc = -EINVAL;
-                        break;
-                default:
-                        rc = -EINVAL;
-        }
-
-        return rc;
-}
-
-/*
  * Initialize block device frontend.
  */
 int
diff --git a/drivers/s390/char/tape_char.c b/drivers/s390/char/tape_char.c
index 31566c55adfe..539045acaad4 100644
--- a/drivers/s390/char/tape_char.c
+++ b/drivers/s390/char/tape_char.c
@@ -10,11 +10,15 @@
  *               Martin Schwidefsky <schwidefsky@de.ibm.com>
  */
 
+#define KMSG_COMPONENT "tape"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/proc_fs.h>
 #include <linux/mtio.h>
 #include <linux/smp_lock.h>
+#include <linux/compat.h>
 
 #include <asm/uaccess.h>
 
@@ -33,18 +37,20 @@ static ssize_t tapechar_read(struct file *, char __user *, size_t, loff_t *);
 static ssize_t tapechar_write(struct file *, const char __user *, size_t, loff_t *);
 static int tapechar_open(struct inode *,struct file *);
 static int tapechar_release(struct inode *,struct file *);
-static int tapechar_ioctl(struct inode *, struct file *, unsigned int,
-                          unsigned long);
-static long tapechar_compat_ioctl(struct file *, unsigned int,
-                          unsigned long);
+static long tapechar_ioctl(struct file *, unsigned int, unsigned long);
+#ifdef CONFIG_COMPAT
+static long tapechar_compat_ioctl(struct file *, unsigned int, unsigned long);
+#endif
 
 static const struct file_operations tape_fops =
 {
         .owner = THIS_MODULE,
         .read = tapechar_read,
         .write = tapechar_write,
-        .ioctl = tapechar_ioctl,
+        .unlocked_ioctl = tapechar_ioctl,
+#ifdef CONFIG_COMPAT
         .compat_ioctl = tapechar_compat_ioctl,
+#endif
         .open = tapechar_open,
         .release = tapechar_release,
 };
@@ -170,7 +176,6 @@ tapechar_read(struct file *filp, char __user *data, size_t count, loff_t *ppos)
         if (rc == 0) {
                 rc = block_size - request->rescnt;
                 DBF_EVENT(6, "TCHAR:rbytes:  %x\n", rc);
-                filp->f_pos += rc;
                 /* Copy data from idal buffer to user space. */
                 if (idal_buffer_to_user(device->char_data.idal_buf,
                                         data, rc) != 0)
@@ -238,7 +243,6 @@ tapechar_write(struct file *filp, const char __user *data, size_t count, loff_t
                         break;
                 DBF_EVENT(6, "TCHAR:wbytes: %lx\n",
                           block_size - request->rescnt);
-                filp->f_pos += block_size - request->rescnt;
                 written += block_size - request->rescnt;
                 if (request->rescnt != 0)
                         break;
@@ -286,26 +290,20 @@ tapechar_open (struct inode *inode, struct file *filp)
         if (imajor(filp->f_path.dentry->d_inode) != tapechar_major)
                 return -ENODEV;
 
-        lock_kernel();
         minor = iminor(filp->f_path.dentry->d_inode);
-        device = tape_get_device(minor / TAPE_MINORS_PER_DEV);
+        device = tape_find_device(minor / TAPE_MINORS_PER_DEV);
         if (IS_ERR(device)) {
-                DBF_EVENT(3, "TCHAR:open: tape_get_device() failed\n");
-                rc = PTR_ERR(device);
-                goto out;
+                DBF_EVENT(3, "TCHAR:open: tape_find_device() failed\n");
+                return PTR_ERR(device);
         }
 
-
         rc = tape_open(device);
         if (rc == 0) {
                 filp->private_data = device;
-                rc = nonseekable_open(inode, filp);
-        }
-        else
+                nonseekable_open(inode, filp);
+        } else
                 tape_put_device(device);
 
-out:
-        unlock_kernel();
         return rc;
 }
 
@@ -342,7 +340,8 @@ tapechar_release(struct inode *inode, struct file *filp)
                 device->char_data.idal_buf = NULL;
         }
         tape_release(device);
-        filp->private_data = tape_put_device(device);
+        filp->private_data = NULL;
+        tape_put_device(device);
 
         return 0;
 }
@@ -351,16 +350,11 @@ tapechar_release(struct inode *inode, struct file *filp)
  * Tape device io controls.
  */
 static int
-tapechar_ioctl(struct inode *inp, struct file *filp,
-               unsigned int no, unsigned long data)
+__tapechar_ioctl(struct tape_device *device,
+                 unsigned int no, unsigned long data)
 {
-        struct tape_device *device;
         int rc;
 
-        DBF_EVENT(6, "TCHAR:ioct\n");
-
-        device = (struct tape_device *) filp->private_data;
-
         if (no == MTIOCTOP) {
                 struct mtop op;
 
@@ -453,21 +447,44 @@ tapechar_ioctl(struct inode *inp, struct file *filp,
 }
 
 static long
+tapechar_ioctl(struct file *filp, unsigned int no, unsigned long data)
+{
+        struct tape_device *device;
+        long rc;
+
+        DBF_EVENT(6, "TCHAR:ioct\n");
+
+        device = (struct tape_device *) filp->private_data;
+        mutex_lock(&device->mutex);
+        rc = __tapechar_ioctl(device, no, data);
+        mutex_unlock(&device->mutex);
+        return rc;
+}
+
+#ifdef CONFIG_COMPAT
+static long
 tapechar_compat_ioctl(struct file *filp, unsigned int no, unsigned long data)
 {
         struct tape_device *device = filp->private_data;
         int rval = -ENOIOCTLCMD;
+        unsigned long argp;
 
+        /* The 'arg' argument of any ioctl function may only be used for
+         * pointers because of the compat pointer conversion.
+         * Consider this when adding new ioctls.
+         */
+        argp = (unsigned long) compat_ptr(data);
         if (device->discipline->ioctl_fn) {
-                lock_kernel();
-                rval = device->discipline->ioctl_fn(device, no, data);
-                unlock_kernel();
+                mutex_lock(&device->mutex);
+                rval = device->discipline->ioctl_fn(device, no, argp);
+                mutex_unlock(&device->mutex);
                 if (rval == -EINVAL)
                         rval = -ENOIOCTLCMD;
         }
 
         return rval;
 }
+#endif /* CONFIG_COMPAT */
 
 /*
  * Initialize character device frontend.
diff --git a/drivers/s390/char/tape_class.c b/drivers/s390/char/tape_class.c
index ddc914ccea8f..55343df61edd 100644
--- a/drivers/s390/char/tape_class.c
+++ b/drivers/s390/char/tape_class.c
@@ -7,6 +7,12 @@
  * Author: Stefan Bader <shbader@de.ibm.com>
  * Based on simple class device code by Greg K-H
  */
+
+#define KMSG_COMPONENT "tape"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+
+#include <linux/slab.h>
+
 #include "tape_class.h"
 
 MODULE_AUTHOR("Stefan Bader <shbader@de.ibm.com>");
diff --git a/drivers/s390/char/tape_core.c b/drivers/s390/char/tape_core.c
index 5cd31e071647..29c2d73d719d 100644
--- a/drivers/s390/char/tape_core.c
+++ b/drivers/s390/char/tape_core.c
@@ -12,12 +12,15 @@
  */
 
 #define KMSG_COMPONENT "tape"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+
 #include <linux/module.h>
 #include <linux/init.h>      // for kernel parameters
 #include <linux/kmod.h>      // for requesting modules
 #include <linux/spinlock.h>  // for locks
 #include <linux/vmalloc.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 
 #include <asm/types.h>       // for variable types
 
@@ -492,6 +495,7 @@ tape_alloc_device(void)
                 kfree(device);
                 return ERR_PTR(-ENOMEM);
         }
+        mutex_init(&device->mutex);
         INIT_LIST_HEAD(&device->req_queue);
         INIT_LIST_HEAD(&device->node);
         init_waitqueue_head(&device->state_change_wq);
@@ -511,11 +515,12 @@ tape_alloc_device(void)
  * increment the reference count.
  */
 struct tape_device *
-tape_get_device_reference(struct tape_device *device)
+tape_get_device(struct tape_device *device)
 {
-        DBF_EVENT(4, "tape_get_device_reference(%p) = %i\n", device,
-                atomic_inc_return(&device->ref_count));
+        int count;
 
+        count = atomic_inc_return(&device->ref_count);
+        DBF_EVENT(4, "tape_get_device(%p) = %i\n", device, count);
         return device;
 }
 
@@ -525,32 +530,25 @@ tape_get_device_reference(struct tape_device *device)
  * The function returns a NULL pointer to be used by the caller
  * for clearing reference pointers.
  */
-struct tape_device *
+void
 tape_put_device(struct tape_device *device)
 {
-        int remain;
+        int count;
 
-        remain = atomic_dec_return(&device->ref_count);
-        if (remain > 0) {
-                DBF_EVENT(4, "tape_put_device(%p) -> %i\n", device, remain);
-        } else {
-                if (remain < 0) {
-                        DBF_EVENT(4, "put device without reference\n");
-                } else {
-                        DBF_EVENT(4, "tape_free_device(%p)\n", device);
-                        kfree(device->modeset_byte);
-                        kfree(device);
-                }
+        count = atomic_dec_return(&device->ref_count);
+        DBF_EVENT(4, "tape_put_device(%p) -> %i\n", device, count);
+        BUG_ON(count < 0);
+        if (count == 0) {
+                kfree(device->modeset_byte);
+                kfree(device);
         }
-
-        return NULL;                    
 }
 
 /*
  * Find tape device by a device index.
  */
 struct tape_device *
-tape_get_device(int devindex)
+tape_find_device(int devindex)
 {
         struct tape_device *device, *tmp;
 
@@ -558,7 +556,7 @@ tape_get_device(int devindex)
         read_lock(&tape_device_lock);
         list_for_each_entry(tmp, &tape_device_list, node) {
                 if (tmp->first_minor / TAPE_MINORS_PER_DEV == devindex) {
-                        device = tape_get_device_reference(tmp);
+                        device = tape_get_device(tmp);
                         break;
                 }
         }
@@ -579,7 +577,8 @@ tape_generic_probe(struct ccw_device *cdev)
         device = tape_alloc_device();
         if (IS_ERR(device))
                 return -ENODEV;
-        ccw_device_set_options(cdev, CCWDEV_DO_PATHGROUP);
+        ccw_device_set_options(cdev, CCWDEV_DO_PATHGROUP |
+                                     CCWDEV_DO_MULTIPATH);
         ret = sysfs_create_group(&cdev->dev.kobj, &tape_attr_group);
         if (ret) {
                 tape_put_device(device);
@@ -606,7 +605,8 @@ __tape_discard_requests(struct tape_device *device)
                 list_del(&request->list);
 
                 /* Decrease ref_count for removed request. */
-                request->device = tape_put_device(device);
+                request->device = NULL;
+                tape_put_device(device);
                 request->rc = -EIO;
                 if (request->callback != NULL)
                         request->callback(request, request->callback_data);
@@ -664,9 +664,11 @@ tape_generic_remove(struct ccw_device *cdev)
                         tape_cleanup_device(device);
         }
 
-        if (!dev_get_drvdata(&cdev->dev)) {
+        device = dev_get_drvdata(&cdev->dev);
+        if (device) {
                 sysfs_remove_group(&cdev->dev.kobj, &tape_attr_group);
-                dev_set_drvdata(&cdev->dev, tape_put_device(dev_get_drvdata(&cdev->dev)));
+                dev_set_drvdata(&cdev->dev, NULL);
+                tape_put_device(device);
         }
 }
 
@@ -721,9 +723,8 @@ tape_free_request (struct tape_request * request)
 {
         DBF_LH(6, "Free request %p\n", request);
 
-        if (request->device != NULL) {
-                request->device = tape_put_device(request->device);
-        }
+        if (request->device)
+                tape_put_device(request->device);
         kfree(request->cpdata);
         kfree(request->cpaddr);
         kfree(request);
@@ -838,7 +839,8 @@ static void tape_long_busy_timeout(unsigned long data)
         BUG_ON(request->status != TAPE_REQUEST_LONG_BUSY);
         DBF_LH(6, "%08x: Long busy timeout.\n", device->cdev_id);
         __tape_start_next_request(device);
-        device->lb_timeout.data = (unsigned long) tape_put_device(device);
+        device->lb_timeout.data = 0UL;
+        tape_put_device(device);
         spin_unlock_irq(get_ccwdev_lock(device->cdev));
 }
 
@@ -918,7 +920,7 @@ __tape_start_request(struct tape_device *device, struct tape_request *request)
         }
 
         /* Increase use count of device for the added request. */
-        request->device = tape_get_device_reference(device);
+        request->device = tape_get_device(device);
 
         if (list_empty(&device->req_queue)) {
                 /* No other requests are on the queue. Start this one. */
@@ -1117,8 +1119,8 @@ __tape_do_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
                 if (req->status == TAPE_REQUEST_LONG_BUSY) {
                         DBF_EVENT(3, "(%08x): del timer\n", device->cdev_id);
                         if (del_timer(&device->lb_timeout)) {
-                                device->lb_timeout.data = (unsigned long)
-                                        tape_put_device(device);
+                                device->lb_timeout.data = 0UL;
+                                tape_put_device(device);
                                 __tape_start_next_request(device);
                         }
                         return;
@@ -1173,7 +1175,7 @@ __tape_do_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
                         break;
                 case TAPE_IO_LONG_BUSY:
                         device->lb_timeout.data =
-                                (unsigned long)tape_get_device_reference(device);
+                                (unsigned long) tape_get_device(device);
                         device->lb_timeout.expires = jiffies +
                                 LONG_BUSY_TIMEOUT * HZ;
                         DBF_EVENT(3, "(%08x): add timer\n", device->cdev_id);
@@ -1326,7 +1328,7 @@ EXPORT_SYMBOL(tape_generic_online);
 EXPORT_SYMBOL(tape_generic_offline);
 EXPORT_SYMBOL(tape_generic_pm_suspend);
 EXPORT_SYMBOL(tape_put_device);
-EXPORT_SYMBOL(tape_get_device_reference);
+EXPORT_SYMBOL(tape_get_device);
 EXPORT_SYMBOL(tape_state_verbose);
 EXPORT_SYMBOL(tape_op_verbose);
 EXPORT_SYMBOL(tape_state_set);
diff --git a/drivers/s390/char/tape_proc.c b/drivers/s390/char/tape_proc.c
index 202f42132939..0ceb37984f77 100644
--- a/drivers/s390/char/tape_proc.c
+++ b/drivers/s390/char/tape_proc.c
@@ -11,6 +11,9 @@
  * PROCFS Functions
  */
 
+#define KMSG_COMPONENT "tape"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+
 #include <linux/module.h>
 #include <linux/vmalloc.h>
 #include <linux/seq_file.h>
@@ -45,7 +48,7 @@ static int tape_proc_show(struct seq_file *m, void *v)
                 seq_printf(m, "TapeNo\tBusID      CuType/Model\t"
                         "DevType/Model\tBlkSize\tState\tOp\tMedState\n");
         }
-        device = tape_get_device(n);
+        device = tape_find_device(n);
         if (IS_ERR(device))
                 return 0;
         spin_lock_irq(get_ccwdev_lock(device->cdev));
diff --git a/drivers/s390/char/tape_std.c b/drivers/s390/char/tape_std.c
index 750354ad16e5..03f07e5dd6e9 100644
--- a/drivers/s390/char/tape_std.c
+++ b/drivers/s390/char/tape_std.c
@@ -11,6 +11,9 @@
  *               Stefan Bader <shbader@de.ibm.com>
  */
 
+#define KMSG_COMPONENT "tape"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+
 #include <linux/stddef.h>
 #include <linux/kernel.h>
 #include <linux/bio.h>
diff --git a/drivers/s390/char/tty3270.c b/drivers/s390/char/tty3270.c
index 38385677c653..911822db614d 100644
--- a/drivers/s390/char/tty3270.c
+++ b/drivers/s390/char/tty3270.c
@@ -19,6 +19,7 @@
 
 #include <linux/slab.h>
 #include <linux/bootmem.h>
+#include <linux/compat.h>
 
 #include <asm/ccwdev.h>
 #include <asm/cio.h>
@@ -1731,6 +1732,22 @@ tty3270_ioctl(struct tty_struct *tty, struct file *file,
         return kbd_ioctl(tp->kbd, file, cmd, arg);
 }
 
+#ifdef CONFIG_COMPAT
+static long
+tty3270_compat_ioctl(struct tty_struct *tty, struct file *file,
+              unsigned int cmd, unsigned long arg)
+{
+        struct tty3270 *tp;
+
+        tp = tty->driver_data;
+        if (!tp)
+                return -ENODEV;
+        if (tty->flags & (1 << TTY_IO_ERROR))
+                return -EIO;
+        return kbd_ioctl(tp->kbd, file, cmd, (unsigned long)compat_ptr(arg));
+}
+#endif
+
 static const struct tty_operations tty3270_ops = {
         .open = tty3270_open,
         .close = tty3270_close,
@@ -1745,6 +1762,9 @@ static const struct tty_operations tty3270_ops = {
         .hangup = tty3270_hangup,
         .wait_until_sent = tty3270_wait_until_sent,
         .ioctl = tty3270_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl = tty3270_compat_ioctl,
+#endif
         .set_termios = tty3270_set_termios
 };
 
diff --git a/drivers/s390/char/vmcp.c b/drivers/s390/char/vmcp.c
index a6087cec55b4..5bb59d36a6d4 100644
--- a/drivers/s390/char/vmcp.c
+++ b/drivers/s390/char/vmcp.c
@@ -19,6 +19,8 @@
 #include <linux/kernel.h>
 #include <linux/miscdevice.h>
 #include <linux/module.h>
+#include <linux/slab.h>
+#include <asm/compat.h>
 #include <asm/cpcmd.h>
 #include <asm/debug.h>
 #include <asm/uaccess.h>
@@ -139,21 +141,26 @@ vmcp_write(struct file *file, const char __user *buff, size_t count,
 static long vmcp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         struct vmcp_session *session;
+        int __user *argp;
         int temp;
 
         session = (struct vmcp_session *)file->private_data;
+        if (is_compat_task())
+                argp = compat_ptr(arg);
+        else
+                argp = (int __user *)arg;
         if (mutex_lock_interruptible(&session->mutex))
                 return -ERESTARTSYS;
         switch (cmd) {
         case VMCP_GETCODE:
                 temp = session->resp_code;
                 mutex_unlock(&session->mutex);
-                return put_user(temp, (int __user *)arg);
+                return put_user(temp, argp);
         case VMCP_SETBUF:
                 free_pages((unsigned long)session->response,
                                 get_order(session->bufsize));
                 session->response=NULL;
-                temp = get_user(session->bufsize, (int __user *)arg);
+                temp = get_user(session->bufsize, argp);
                 if (get_order(session->bufsize) > 8) {
                         session->bufsize = PAGE_SIZE;
                         temp = -EINVAL;
@@ -163,7 +170,7 @@ static long vmcp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         case VMCP_GETSIZE:
                 temp = session->resp_size;
                 mutex_unlock(&session->mutex);
-                return put_user(temp, (int __user *)arg);
+                return put_user(temp, argp);
         default:
                 mutex_unlock(&session->mutex);
                 return -ENOIOCTLCMD;
diff --git a/drivers/s390/char/vmlogrdr.c b/drivers/s390/char/vmlogrdr.c
index d1a142fa3eb4..e40a1b892866 100644
--- a/drivers/s390/char/vmlogrdr.c
+++ b/drivers/s390/char/vmlogrdr.c
@@ -16,6 +16,7 @@
 
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/interrupt.h>
@@ -312,11 +313,9 @@ static int vmlogrdr_open (struct inode *inode, struct file *filp)
                 return -ENOSYS;
 
         /* Besure this device hasn't already been opened */
-        lock_kernel();
         spin_lock_bh(&logptr->priv_lock);
         if (logptr->dev_in_use) {
                 spin_unlock_bh(&logptr->priv_lock);
-                unlock_kernel();
                 return -EBUSY;
         }
         logptr->dev_in_use = 1;
@@ -360,9 +359,8 @@ static int vmlogrdr_open (struct inode *inode, struct file *filp)
                    || (logptr->iucv_path_severed));
         if (logptr->iucv_path_severed)
                 goto out_record;
-        ret = nonseekable_open(inode, filp);
-        unlock_kernel();
-        return ret;
+        nonseekable_open(inode, filp);
+        return 0;
 
 out_record:
         if (logptr->autorecording)
@@ -372,7 +370,6 @@ out_path:
         logptr->path = NULL;
 out_dev:
         logptr->dev_in_use = 0;
-        unlock_kernel();
         return -EIO;
 }
 
@@ -679,7 +676,7 @@ static int vmlogrdr_pm_prepare(struct device *dev)
 }
 
 
-static struct dev_pm_ops vmlogrdr_pm_ops = {
+static const struct dev_pm_ops vmlogrdr_pm_ops = {
         .prepare = vmlogrdr_pm_prepare,
 };
 
diff --git a/drivers/s390/char/vmur.c b/drivers/s390/char/vmur.c
index 77571b68539a..1de672f21037 100644
--- a/drivers/s390/char/vmur.c
+++ b/drivers/s390/char/vmur.c
@@ -12,6 +12,7 @@
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include <linux/cdev.h>
+#include <linux/slab.h>
 #include <linux/smp_lock.h>
 
 #include <asm/uaccess.h>
@@ -695,7 +696,6 @@ static int ur_open(struct inode *inode, struct file *file)
 
         if (accmode == O_RDWR)
                 return -EACCES;
-        lock_kernel();
         /*
          * We treat the minor number as the devno of the ur device
          * to find in the driver tree.
@@ -749,7 +749,6 @@ static int ur_open(struct inode *inode, struct file *file)
                 goto fail_urfile_free;
         urf->file_reclen = rc;
         file->private_data = urf;
-        unlock_kernel();
         return 0;
 
 fail_urfile_free:
@@ -761,7 +760,6 @@ fail_unlock:
 fail_put:
         urdev_put(urd);
 out:
-        unlock_kernel();
         return rc;
 }
 
diff --git a/drivers/s390/char/vmwatchdog.c b/drivers/s390/char/vmwatchdog.c
index f2bc287b69e4..e13508c98b1a 100644
--- a/drivers/s390/char/vmwatchdog.c
+++ b/drivers/s390/char/vmwatchdog.c
@@ -17,9 +17,9 @@
 #include <linux/miscdevice.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/slab.h>
 #include <linux/suspend.h>
 #include <linux/watchdog.h>
-#include <linux/smp_lock.h>
 
 #include <asm/ebcdic.h>
 #include <asm/io.h>
@@ -49,6 +49,8 @@ static unsigned int vmwdt_interval = 60;
 static unsigned long vmwdt_is_open;
 static int vmwdt_expect_close;
 
+static DEFINE_MUTEX(vmwdt_mutex);
+
 #define VMWDT_OPEN      0       /* devnode is open or suspend in progress */
 #define VMWDT_RUNNING   1       /* The watchdog is armed */
 
@@ -133,15 +135,11 @@ static int __init vmwdt_probe(void)
 static int vmwdt_open(struct inode *i, struct file *f)
 {
         int ret;
-        lock_kernel();
-        if (test_and_set_bit(VMWDT_OPEN, &vmwdt_is_open)) {
-                unlock_kernel();
+        if (test_and_set_bit(VMWDT_OPEN, &vmwdt_is_open))
                 return -EBUSY;
-        }
         ret = vmwdt_keepalive();
         if (ret)
                 clear_bit(VMWDT_OPEN, &vmwdt_is_open);
-        unlock_kernel();
         return ret ? ret : nonseekable_open(i, f);
 }
 
@@ -160,8 +158,7 @@ static struct watchdog_info vmwdt_info = {
         .identity = "z/VM Watchdog Timer",
 };
 
-static int vmwdt_ioctl(struct inode *i, struct file *f,
-                          unsigned int cmd, unsigned long arg)
+static int __vmwdt_ioctl(unsigned int cmd, unsigned long arg)
 {
         switch (cmd) {
         case WDIOC_GETSUPPORT:
@@ -205,10 +202,19 @@ static int vmwdt_ioctl(struct inode *i, struct file *f,
         case WDIOC_KEEPALIVE:
                 return vmwdt_keepalive();
         }
-
         return -EINVAL;
 }
 
+static long vmwdt_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
+{
+        int rc;
+
+        mutex_lock(&vmwdt_mutex);
+        rc = __vmwdt_ioctl(cmd, arg);
+        mutex_unlock(&vmwdt_mutex);
+        return (long) rc;
+}
+
 static ssize_t vmwdt_write(struct file *f, const char __user *buf,
                                 size_t count, loff_t *ppos)
 {
@@ -288,7 +294,7 @@ static struct notifier_block vmwdt_power_notifier = {
 static const struct file_operations vmwdt_fops = {
         .open    = &vmwdt_open,
         .release = &vmwdt_close,
-        .ioctl   = &vmwdt_ioctl,
+        .unlocked_ioctl = &vmwdt_ioctl,
         .write   = &vmwdt_write,
         .owner   = THIS_MODULE,
 };
@@ -309,6 +315,10 @@ static int __init vmwdt_init(void)
         ret = register_pm_notifier(&vmwdt_power_notifier);
         if (ret)
                 return ret;
+        /*
+         * misc_register() has to be the last action in module_init(), because
+         * file operations will be available right after this.
+         */
         ret = misc_register(&vmwdt_dev);
         if (ret) {
                 unregister_pm_notifier(&vmwdt_power_notifier);
diff --git a/drivers/s390/char/zcore.c b/drivers/s390/char/zcore.c
index 82daa3c1dc9c..7217966f7d31 100644
--- a/drivers/s390/char/zcore.c
+++ b/drivers/s390/char/zcore.c
@@ -13,8 +13,10 @@
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/miscdevice.h>
 #include <linux/debugfs.h>
+#include <asm/asm-offsets.h>
 #include <asm/ipl.h>
 #include <asm/sclp.h>
 #include <asm/setup.h>
@@ -40,12 +42,12 @@ enum arch_id {
 /* dump system info */
 
 struct sys_info {
-        enum arch_id    arch;
-        unsigned long   sa_base;
-        u32             sa_size;
-        int             cpu_map[NR_CPUS];
-        unsigned long   mem_size;
-        union save_area lc_mask;
+        enum arch_id     arch;
+        unsigned long    sa_base;
+        u32              sa_size;
+        int              cpu_map[NR_CPUS];
+        unsigned long    mem_size;
+        struct save_area lc_mask;
 };
 
 struct ipib_info {
@@ -140,33 +142,6 @@ static int memcpy_hsa_kernel(void *dest, unsigned long src, size_t count)
         return memcpy_hsa(dest, src, count, TO_KERNEL);
 }
 
-static int memcpy_real(void *dest, unsigned long src, size_t count)
-{
-        unsigned long flags;
-        int rc = -EFAULT;
-        register unsigned long _dest asm("2") = (unsigned long) dest;
-        register unsigned long _len1 asm("3") = (unsigned long) count;
-        register unsigned long _src  asm("4") = src;
-        register unsigned long _len2 asm("5") = (unsigned long) count;
-
-        if (count == 0)
-                return 0;
-        flags = __raw_local_irq_stnsm(0xf8UL); /* switch to real mode */
-        asm volatile (
-                "0:     mvcle   %1,%2,0x0\n"
-                "1:     jo      0b\n"
-                "       lhi     %0,0x0\n"
-                "2:\n"
-                EX_TABLE(1b,2b)
-                : "+d" (rc), "+d" (_dest), "+d" (_src), "+d" (_len1),
-                  "+d" (_len2), "=m" (*((long*)dest))
-                : "m" (*((long*)src))
-                : "cc", "memory");
-        __raw_local_irq_ssm(flags);
-
-        return rc;
-}
-
 static int memcpy_real_user(void __user *dest, unsigned long src, size_t count)
 {
         static char buf[4096];
@@ -174,7 +149,7 @@ static int memcpy_real_user(void __user *dest, unsigned long src, size_t count)
 
         while (offs < count) {
                 size = min(sizeof(buf), count - offs);
-                if (memcpy_real(buf, src + offs, size))
+                if (memcpy_real(buf, (void *) src + offs, size))
                         return -EFAULT;
                 if (copy_to_user(dest + offs, buf, size))
                         return -EFAULT;
@@ -183,52 +158,9 @@ static int memcpy_real_user(void __user *dest, unsigned long src, size_t count)
         return 0;
 }
 
-#ifdef __s390x__
-/*
- * Convert s390x (64 bit) cpu info to s390 (32 bit) cpu info
- */
-static void __init s390x_to_s390_regs(union save_area *out, union save_area *in,
-                                      int cpu)
-{
-        int i;
-
-        for (i = 0; i < 16; i++) {
-                out->s390.gp_regs[i] = in->s390x.gp_regs[i] & 0x00000000ffffffff;
-                out->s390.acc_regs[i] = in->s390x.acc_regs[i];
-                out->s390.ctrl_regs[i] =
-                        in->s390x.ctrl_regs[i] & 0x00000000ffffffff;
-        }
-        /* locore for 31 bit has only space for fpregs 0,2,4,6 */
-        out->s390.fp_regs[0] = in->s390x.fp_regs[0];
-        out->s390.fp_regs[1] = in->s390x.fp_regs[2];
-        out->s390.fp_regs[2] = in->s390x.fp_regs[4];
-        out->s390.fp_regs[3] = in->s390x.fp_regs[6];
-        memcpy(&(out->s390.psw[0]), &(in->s390x.psw[0]), 4);
-        out->s390.psw[1] |= 0x8; /* set bit 12 */
-        memcpy(&(out->s390.psw[4]),&(in->s390x.psw[12]), 4);
-        out->s390.psw[4] |= 0x80; /* set (31bit) addressing bit */
-        out->s390.pref_reg = in->s390x.pref_reg;
-        out->s390.timer = in->s390x.timer;
-        out->s390.clk_cmp = in->s390x.clk_cmp;
-}
-
-static void __init s390x_to_s390_save_areas(void)
-{
-        int i = 1;
-        static union save_area tmp;
-
-        while (zfcpdump_save_areas[i]) {
-                s390x_to_s390_regs(&tmp, zfcpdump_save_areas[i], i);
-                memcpy(zfcpdump_save_areas[i], &tmp, sizeof(tmp));
-                i++;
-        }
-}
-
-#endif /* __s390x__ */
-
 static int __init init_cpu_info(enum arch_id arch)
 {
-        union save_area *sa;
+        struct save_area *sa;
 
         /* get info for boot cpu from lowcore, stored in the HSA */
 
@@ -241,20 +173,12 @@ static int __init init_cpu_info(enum arch_id arch)
                 return -EIO;
         }
         zfcpdump_save_areas[0] = sa;
-
-#ifdef __s390x__
-        /* convert s390x regs to s390, if we are dumping an s390 Linux */
-
-        if (arch == ARCH_S390)
-                s390x_to_s390_save_areas();
-#endif
-
         return 0;
 }
 
 static DEFINE_MUTEX(zcore_mutex);
 
-#define DUMP_VERSION    0x3
+#define DUMP_VERSION    0x5
 #define DUMP_MAGIC      0xa8190173618f23fdULL
 #define DUMP_ARCH_S390X 2
 #define DUMP_ARCH_S390  1
@@ -279,7 +203,14 @@ struct zcore_header {
         u32 volnr;
         u32 build_arch;
         u64 rmem_size;
-        char pad2[4016];
+        u8 mvdump;
+        u16 cpu_cnt;
+        u16 real_cpu_cnt;
+        u8 end_pad1[0x200-0x061];
+        u64 mvdump_sign;
+        u64 mvdump_zipl_time;
+        u8 end_pad2[0x800-0x210];
+        u32 lc_vec[512];
 } __attribute__((packed,__aligned__(16)));
 
 static struct zcore_header zcore_header = {
@@ -289,7 +220,7 @@ static struct zcore_header zcore_header = {
         .dump_level     = 0,
         .page_size      = PAGE_SIZE,
         .mem_start      = 0,
-#ifdef __s390x__
+#ifdef CONFIG_64BIT
         .build_arch     = DUMP_ARCH_S390X,
 #else
         .build_arch     = DUMP_ARCH_S390,
@@ -340,11 +271,7 @@ static int zcore_add_lc(char __user *buf, unsigned long start, size_t count)
                 unsigned long prefix;
                 unsigned long sa_off, len, buf_off;
 
-                if (sys_info.arch == ARCH_S390)
-                        prefix = zfcpdump_save_areas[i]->s390.pref_reg;
-                else
-                        prefix = zfcpdump_save_areas[i]->s390x.pref_reg;
-
+                prefix = zfcpdump_save_areas[i]->pref_reg;
                 sa_start = prefix + sys_info.sa_base;
                 sa_end = prefix + sys_info.sa_base + sys_info.sa_size;
 
@@ -561,34 +488,39 @@ static const struct file_operations zcore_reipl_fops = {
         .release        = zcore_reipl_release,
 };
 
+#ifdef CONFIG_32BIT
 
-static void __init set_s390_lc_mask(union save_area *map)
+static void __init set_lc_mask(struct save_area *map)
 {
-        memset(&map->s390.ext_save, 0xff, sizeof(map->s390.ext_save));
-        memset(&map->s390.timer, 0xff, sizeof(map->s390.timer));
-        memset(&map->s390.clk_cmp, 0xff, sizeof(map->s390.clk_cmp));
-        memset(&map->s390.psw, 0xff, sizeof(map->s390.psw));
-        memset(&map->s390.pref_reg, 0xff, sizeof(map->s390.pref_reg));
-        memset(&map->s390.acc_regs, 0xff, sizeof(map->s390.acc_regs));
-        memset(&map->s390.fp_regs, 0xff, sizeof(map->s390.fp_regs));
-        memset(&map->s390.gp_regs, 0xff, sizeof(map->s390.gp_regs));
-        memset(&map->s390.ctrl_regs, 0xff, sizeof(map->s390.ctrl_regs));
+        memset(&map->ext_save, 0xff, sizeof(map->ext_save));
+        memset(&map->timer, 0xff, sizeof(map->timer));
+        memset(&map->clk_cmp, 0xff, sizeof(map->clk_cmp));
+        memset(&map->psw, 0xff, sizeof(map->psw));
+        memset(&map->pref_reg, 0xff, sizeof(map->pref_reg));
+        memset(&map->acc_regs, 0xff, sizeof(map->acc_regs));
+        memset(&map->fp_regs, 0xff, sizeof(map->fp_regs));
+        memset(&map->gp_regs, 0xff, sizeof(map->gp_regs));
+        memset(&map->ctrl_regs, 0xff, sizeof(map->ctrl_regs));
 }
 
-static void __init set_s390x_lc_mask(union save_area *map)
+#else /* CONFIG_32BIT */
+
+static void __init set_lc_mask(struct save_area *map)
 {
-        memset(&map->s390x.fp_regs, 0xff, sizeof(map->s390x.fp_regs));
-        memset(&map->s390x.gp_regs, 0xff, sizeof(map->s390x.gp_regs));
-        memset(&map->s390x.psw, 0xff, sizeof(map->s390x.psw));
-        memset(&map->s390x.pref_reg, 0xff, sizeof(map->s390x.pref_reg));
-        memset(&map->s390x.fp_ctrl_reg, 0xff, sizeof(map->s390x.fp_ctrl_reg));
-        memset(&map->s390x.tod_reg, 0xff, sizeof(map->s390x.tod_reg));
-        memset(&map->s390x.timer, 0xff, sizeof(map->s390x.timer));
-        memset(&map->s390x.clk_cmp, 0xff, sizeof(map->s390x.clk_cmp));
-        memset(&map->s390x.acc_regs, 0xff, sizeof(map->s390x.acc_regs));
-        memset(&map->s390x.ctrl_regs, 0xff, sizeof(map->s390x.ctrl_regs));
+        memset(&map->fp_regs, 0xff, sizeof(map->fp_regs));
+        memset(&map->gp_regs, 0xff, sizeof(map->gp_regs));
+        memset(&map->psw, 0xff, sizeof(map->psw));
+        memset(&map->pref_reg, 0xff, sizeof(map->pref_reg));
+        memset(&map->fp_ctrl_reg, 0xff, sizeof(map->fp_ctrl_reg));
+        memset(&map->tod_reg, 0xff, sizeof(map->tod_reg));
+        memset(&map->timer, 0xff, sizeof(map->timer));
+        memset(&map->clk_cmp, 0xff, sizeof(map->clk_cmp));
+        memset(&map->acc_regs, 0xff, sizeof(map->acc_regs));
+        memset(&map->ctrl_regs, 0xff, sizeof(map->ctrl_regs));
 }
 
+#endif /* CONFIG_32BIT */
+
 /*
  * Initialize dump globals for a given architecture
  */
@@ -599,21 +531,18 @@ static int __init sys_info_init(enum arch_id arch)
         switch (arch) {
         case ARCH_S390X:
                 pr_alert("DETECTED 'S390X (64 bit) OS'\n");
-                sys_info.sa_base = SAVE_AREA_BASE_S390X;
-                sys_info.sa_size = sizeof(struct save_area_s390x);
-                set_s390x_lc_mask(&sys_info.lc_mask);
                 break;
         case ARCH_S390:
                 pr_alert("DETECTED 'S390 (32 bit) OS'\n");
-                sys_info.sa_base = SAVE_AREA_BASE_S390;
-                sys_info.sa_size = sizeof(struct save_area_s390);
-                set_s390_lc_mask(&sys_info.lc_mask);
                 break;
         default:
                 pr_alert("0x%x is an unknown architecture.\n",arch);
                 return -EINVAL;
         }
+        sys_info.sa_base = SAVE_AREA_BASE;
+        sys_info.sa_size = sizeof(struct save_area);
         sys_info.arch = arch;
+        set_lc_mask(&sys_info.lc_mask);
         rc = init_cpu_info(arch);
         if (rc)
                 return rc;
@@ -660,8 +589,9 @@ static int __init get_mem_size(unsigned long *mem)
 
 static int __init zcore_header_init(int arch, struct zcore_header *hdr)
 {
-        int rc;
+        int rc, i;
         unsigned long memory = 0;
+        u32 prefix;
 
         if (arch == ARCH_S390X)
                 hdr->arch_id = DUMP_ARCH_S390X;
@@ -676,6 +606,14 @@ static int __init zcore_header_init(int arch, struct zcore_header *hdr)
         hdr->num_pages = memory / PAGE_SIZE;
         hdr->tod = get_clock();
         get_cpu_id(&hdr->cpu_id);
+        for (i = 0; zfcpdump_save_areas[i]; i++) {
+                prefix = zfcpdump_save_areas[i]->pref_reg;
+                hdr->real_cpu_cnt++;
+                if (!prefix)
+                        continue;
+                hdr->lc_vec[hdr->cpu_cnt] = prefix;
+                hdr->cpu_cnt++;
+        }
         return 0;
 }
 
@@ -699,12 +637,8 @@ static int __init zcore_reipl_init(void)
         if (ipib_info.ipib < ZFCPDUMP_HSA_SIZE)
                 rc = memcpy_hsa_kernel(ipl_block, ipib_info.ipib, PAGE_SIZE);
         else
-                rc = memcpy_real(ipl_block, ipib_info.ipib, PAGE_SIZE);
-        if (rc) {
-                free_page((unsigned long) ipl_block);
-                return rc;
-        }
-        if (csum_partial(ipl_block, ipl_block->hdr.len, 0) !=
+                rc = memcpy_real(ipl_block, (void *) ipib_info.ipib, PAGE_SIZE);
+        if (rc || csum_partial(ipl_block, ipl_block->hdr.len, 0) !=
             ipib_info.checksum) {
                 TRACE("Checksum does not match\n");
                 free_page((unsigned long) ipl_block);
@@ -741,14 +675,21 @@ static int __init zcore_init(void)
         if (rc)
                 goto fail;
 
-#ifndef __s390x__
+#ifdef CONFIG_64BIT
+        if (arch == ARCH_S390) {
+                pr_alert("The 64-bit dump tool cannot be used for a "
+                         "32-bit system\n");
+                rc = -EINVAL;
+                goto fail;
+        }
+#else /* CONFIG_64BIT */
         if (arch == ARCH_S390X) {
                 pr_alert("The 32-bit dump tool cannot be used for a "
                          "64-bit system\n");
                 rc = -EINVAL;
                 goto fail;
         }
-#endif
+#endif /* CONFIG_64BIT */
 
         rc = sys_info_init(arch);
         if (rc)
diff --git a/drivers/s390/cio/Makefile b/drivers/s390/cio/Makefile
index fa4c9662f65e..e1b700a19648 100644
--- a/drivers/s390/cio/Makefile
+++ b/drivers/s390/cio/Makefile
@@ -3,12 +3,12 @@
 #
 
 obj-y += airq.o blacklist.o chsc.o cio.o css.o chp.o idset.o isc.o \
-        fcx.o itcw.o crw.o
+        fcx.o itcw.o crw.o ccwreq.o
 ccw_device-objs += device.o device_fsm.o device_ops.o
 ccw_device-objs += device_id.o device_pgid.o device_status.o
 obj-y += ccw_device.o cmf.o
 obj-$(CONFIG_CHSC_SCH) += chsc_sch.o
 obj-$(CONFIG_CCWGROUP) += ccwgroup.o
 
-qdio-objs := qdio_main.o qdio_thinint.o qdio_debug.o qdio_perf.o qdio_setup.o
+qdio-objs := qdio_main.o qdio_thinint.o qdio_debug.o qdio_setup.o
 obj-$(CONFIG_QDIO) += qdio.o
diff --git a/drivers/s390/cio/blacklist.c b/drivers/s390/cio/blacklist.c
index 7eab9ab9f406..13cb60162e42 100644
--- a/drivers/s390/cio/blacklist.c
+++ b/drivers/s390/cio/blacklist.c
@@ -14,7 +14,6 @@
 
 #include <linux/init.h>
 #include <linux/vmalloc.h>
-#include <linux/slab.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/ctype.h>
diff --git a/drivers/s390/cio/ccwgroup.c b/drivers/s390/cio/ccwgroup.c
index a5a62f1f7747..5f97ea2ee6b1 100644
--- a/drivers/s390/cio/ccwgroup.c
+++ b/drivers/s390/cio/ccwgroup.c
@@ -560,7 +560,7 @@ static int ccwgroup_pm_restore(struct device *dev)
         return gdrv->restore ? gdrv->restore(gdev) : 0;
 }
 
-static struct dev_pm_ops ccwgroup_pm_ops = {
+static const struct dev_pm_ops ccwgroup_pm_ops = {
         .prepare = ccwgroup_pm_prepare,
         .complete = ccwgroup_pm_complete,
         .freeze = ccwgroup_pm_freeze,
diff --git a/drivers/s390/cio/ccwreq.c b/drivers/s390/cio/ccwreq.c
new file mode 100644
index 000000000000..37df42af05ec
--- /dev/null
+++ b/drivers/s390/cio/ccwreq.c
@@ -0,0 +1,325 @@
+/*
+ *  Handling of internal CCW device requests.
+ *
+ *    Copyright IBM Corp. 2009
+ *    Author(s): Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
+ */
+
+#include <linux/types.h>
+#include <linux/err.h>
+#include <asm/ccwdev.h>
+#include <asm/cio.h>
+
+#include "io_sch.h"
+#include "cio.h"
+#include "device.h"
+#include "cio_debug.h"
+
+/**
+ * lpm_adjust - adjust path mask
+ * @lpm: path mask to adjust
+ * @mask: mask of available paths
+ *
+ * Shift @lpm right until @lpm and @mask have at least one bit in common or
+ * until @lpm is zero. Return the resulting lpm.
+ */
+int lpm_adjust(int lpm, int mask)
+{
+        while (lpm && ((lpm & mask) == 0))
+                lpm >>= 1;
+        return lpm;
+}
+
+/*
+ * Adjust path mask to use next path and reset retry count. Return resulting
+ * path mask.
+ */
+static u16 ccwreq_next_path(struct ccw_device *cdev)
+{
+        struct ccw_request *req = &cdev->private->req;
+
+        req->retries    = req->maxretries;
+        req->mask       = lpm_adjust(req->mask >>= 1, req->lpm);
+
+        return req->mask;
+}
+
+/*
+ * Clean up device state and report to callback.
+ */
+static void ccwreq_stop(struct ccw_device *cdev, int rc)
+{
+        struct ccw_request *req = &cdev->private->req;
+
+        if (req->done)
+                return;
+        req->done = 1;
+        ccw_device_set_timeout(cdev, 0);
+        memset(&cdev->private->irb, 0, sizeof(struct irb));
+        if (rc && rc != -ENODEV && req->drc)
+                rc = req->drc;
+        req->callback(cdev, req->data, rc);
+}
+
+/*
+ * (Re-)Start the operation until retries and paths are exhausted.
+ */
+static void ccwreq_do(struct ccw_device *cdev)
+{
+        struct ccw_request *req = &cdev->private->req;
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct ccw1 *cp = req->cp;
+        int rc = -EACCES;
+
+        while (req->mask) {
+                if (req->retries-- == 0) {
+                        /* Retries exhausted, try next path. */
+                        ccwreq_next_path(cdev);
+                        continue;
+                }
+                /* Perform start function. */
+                memset(&cdev->private->irb, 0, sizeof(struct irb));
+                rc = cio_start(sch, cp, (u8) req->mask);
+                if (rc == 0) {
+                        /* I/O started successfully. */
+                        ccw_device_set_timeout(cdev, req->timeout);
+                        return;
+                }
+                if (rc == -ENODEV) {
+                        /* Permanent device error. */
+                        break;
+                }
+                if (rc == -EACCES) {
+                        /* Permant path error. */
+                        ccwreq_next_path(cdev);
+                        continue;
+                }
+                /* Temporary improper status. */
+                rc = cio_clear(sch);
+                if (rc)
+                        break;
+                return;
+        }
+        ccwreq_stop(cdev, rc);
+}
+
+/**
+ * ccw_request_start - perform I/O request
+ * @cdev: ccw device
+ *
+ * Perform the I/O request specified by cdev->req.
+ */
+void ccw_request_start(struct ccw_device *cdev)
+{
+        struct ccw_request *req = &cdev->private->req;
+
+        /* Try all paths twice to counter link flapping. */
+        req->mask       = 0x8080;
+        req->retries    = req->maxretries;
+        req->mask       = lpm_adjust(req->mask, req->lpm);
+        req->drc        = 0;
+        req->done       = 0;
+        req->cancel     = 0;
+        if (!req->mask)
+                goto out_nopath;
+        ccwreq_do(cdev);
+        return;
+
+out_nopath:
+        ccwreq_stop(cdev, -EACCES);
+}
+
+/**
+ * ccw_request_cancel - cancel running I/O request
+ * @cdev: ccw device
+ *
+ * Cancel the I/O request specified by cdev->req. Return non-zero if request
+ * has already finished, zero otherwise.
+ */
+int ccw_request_cancel(struct ccw_device *cdev)
+{
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct ccw_request *req = &cdev->private->req;
+        int rc;
+
+        if (req->done)
+                return 1;
+        req->cancel = 1;
+        rc = cio_clear(sch);
+        if (rc)
+                ccwreq_stop(cdev, rc);
+        return 0;
+}
+
+/*
+ * Return the status of the internal I/O started on the specified ccw device.
+ * Perform BASIC SENSE if required.
+ */
+static enum io_status ccwreq_status(struct ccw_device *cdev, struct irb *lcirb)
+{
+        struct irb *irb = &cdev->private->irb;
+        struct cmd_scsw *scsw = &irb->scsw.cmd;
+
+        /* Perform BASIC SENSE if needed. */
+        if (ccw_device_accumulate_and_sense(cdev, lcirb))
+                return IO_RUNNING;
+        /* Check for halt/clear interrupt. */
+        if (scsw->fctl & (SCSW_FCTL_HALT_FUNC | SCSW_FCTL_CLEAR_FUNC))
+                return IO_KILLED;
+        /* Check for path error. */
+        if (scsw->cc == 3 || scsw->pno)
+                return IO_PATH_ERROR;
+        /* Handle BASIC SENSE data. */
+        if (irb->esw.esw0.erw.cons) {
+                CIO_TRACE_EVENT(2, "sensedata");
+                CIO_HEX_EVENT(2, &cdev->private->dev_id,
+                              sizeof(struct ccw_dev_id));
+                CIO_HEX_EVENT(2, &cdev->private->irb.ecw, SENSE_MAX_COUNT);
+                /* Check for command reject. */
+                if (irb->ecw[0] & SNS0_CMD_REJECT)
+                        return IO_REJECTED;
+                /* Assume that unexpected SENSE data implies an error. */
+                return IO_STATUS_ERROR;
+        }
+        /* Check for channel errors. */
+        if (scsw->cstat != 0)
+                return IO_STATUS_ERROR;
+        /* Check for device errors. */
+        if (scsw->dstat & ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END))
+                return IO_STATUS_ERROR;
+        /* Check for final state. */
+        if (!(scsw->dstat & DEV_STAT_DEV_END))
+                return IO_RUNNING;
+        /* Check for other improper status. */
+        if (scsw->cc == 1 && (scsw->stctl & SCSW_STCTL_ALERT_STATUS))
+                return IO_STATUS_ERROR;
+        return IO_DONE;
+}
+
+/*
+ * Log ccw request status.
+ */
+static void ccwreq_log_status(struct ccw_device *cdev, enum io_status status)
+{
+        struct ccw_request *req = &cdev->private->req;
+        struct {
+                struct ccw_dev_id dev_id;
+                u16 retries;
+                u8 lpm;
+                u8 status;
+        }  __attribute__ ((packed)) data;
+        data.dev_id     = cdev->private->dev_id;
+        data.retries    = req->retries;
+        data.lpm        = (u8) req->mask;
+        data.status     = (u8) status;
+        CIO_TRACE_EVENT(2, "reqstat");
+        CIO_HEX_EVENT(2, &data, sizeof(data));
+}
+
+/**
+ * ccw_request_handler - interrupt handler for I/O request procedure.
+ * @cdev: ccw device
+ *
+ * Handle interrupt during I/O request procedure.
+ */
+void ccw_request_handler(struct ccw_device *cdev)
+{
+        struct irb *irb = (struct irb *)&S390_lowcore.irb;
+        struct ccw_request *req = &cdev->private->req;
+        enum io_status status;
+        int rc = -EOPNOTSUPP;
+
+        /* Check status of I/O request. */
+        status = ccwreq_status(cdev, irb);
+        if (req->filter)
+                status = req->filter(cdev, req->data, irb, status);
+        if (status != IO_RUNNING)
+                ccw_device_set_timeout(cdev, 0);
+        if (status != IO_DONE && status != IO_RUNNING)
+                ccwreq_log_status(cdev, status);
+        switch (status) {
+        case IO_DONE:
+                break;
+        case IO_RUNNING:
+                return;
+        case IO_REJECTED:
+                goto err;
+        case IO_PATH_ERROR:
+                goto out_next_path;
+        case IO_STATUS_ERROR:
+                goto out_restart;
+        case IO_KILLED:
+                /* Check if request was cancelled on purpose. */
+                if (req->cancel) {
+                        rc = -EIO;
+                        goto err;
+                }
+                goto out_restart;
+        }
+        /* Check back with request initiator. */
+        if (!req->check)
+                goto out;
+        switch (req->check(cdev, req->data)) {
+        case 0:
+                break;
+        case -EAGAIN:
+                goto out_restart;
+        case -EACCES:
+                goto out_next_path;
+        default:
+                goto err;
+        }
+out:
+        ccwreq_stop(cdev, 0);
+        return;
+
+out_next_path:
+        /* Try next path and restart I/O. */
+        if (!ccwreq_next_path(cdev)) {
+                rc = -EACCES;
+                goto err;
+        }
+out_restart:
+        /* Restart. */
+        ccwreq_do(cdev);
+        return;
+err:
+        ccwreq_stop(cdev, rc);
+}
+
+
+/**
+ * ccw_request_timeout - timeout handler for I/O request procedure
+ * @cdev: ccw device
+ *
+ * Handle timeout during I/O request procedure.
+ */
+void ccw_request_timeout(struct ccw_device *cdev)
+{
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct ccw_request *req = &cdev->private->req;
+        int rc;
+
+        if (!ccwreq_next_path(cdev)) {
+                /* set the final return code for this request */
+                req->drc = -ETIME;
+        }
+        rc = cio_clear(sch);
+        if (rc)
+                goto err;
+        return;
+
+err:
+        ccwreq_stop(cdev, rc);
+}
+
+/**
+ * ccw_request_notoper - notoper handler for I/O request procedure
+ * @cdev: ccw device
+ *
+ * Handle timeout during I/O request procedure.
+ */
+void ccw_request_notoper(struct ccw_device *cdev)
+{
+        ccwreq_stop(cdev, -ENODEV);
+}
diff --git a/drivers/s390/cio/chp.c b/drivers/s390/cio/chp.c
index 8ab51608da55..1d16189f2f2d 100644
--- a/drivers/s390/cio/chp.c
+++ b/drivers/s390/cio/chp.c
@@ -15,6 +15,7 @@
 #include <linux/wait.h>
 #include <linux/mutex.h>
 #include <linux/errno.h>
+#include <linux/slab.h>
 #include <asm/chpid.h>
 #include <asm/sclp.h>
 #include <asm/crw.h>
@@ -65,7 +66,7 @@ static void set_chp_logically_online(struct chp_id chpid, int onoff)
         chpid_to_chp(chpid)->state = onoff;
 }
 
-/* On succes return 0 if channel-path is varied offline, 1 if it is varied
+/* On success return 0 if channel-path is varied offline, 1 if it is varied
  * online. Return -ENODEV if channel-path is not registered. */
 int chp_get_status(struct chp_id chpid)
 {
diff --git a/drivers/s390/cio/chsc.c b/drivers/s390/cio/chsc.c
index 1ecd3e567648..ce7cb87479fe 100644
--- a/drivers/s390/cio/chsc.c
+++ b/drivers/s390/cio/chsc.c
@@ -29,6 +29,7 @@
 #include "chsc.h"
 
 static void *sei_page;
+static DEFINE_SPINLOCK(sda_lock);
 
 /**
  * chsc_error_from_response() - convert a chsc response to an error
@@ -574,7 +575,7 @@ int __chsc_do_secm(struct channel_subsystem *css, int enable, void *page)
         secm_area->request.length = 0x0050;
         secm_area->request.code = 0x0016;
 
-        secm_area->key = PAGE_DEFAULT_KEY;
+        secm_area->key = PAGE_DEFAULT_KEY >> 4;
         secm_area->cub_addr1 = (u64)(unsigned long)css->cub_addr1;
         secm_area->cub_addr2 = (u64)(unsigned long)css->cub_addr2;
 
@@ -832,11 +833,10 @@ void __init chsc_free_sei_area(void)
         kfree(sei_page);
 }
 
-int __init
-chsc_enable_facility(int operation_code)
+int chsc_enable_facility(int operation_code)
 {
         int ret;
-        struct {
+        static struct {
                 struct chsc_header request;
                 u8 reserved1:4;
                 u8 format:4;
@@ -849,33 +849,32 @@ chsc_enable_facility(int operation_code)
                 u32 reserved5:4;
                 u32 format2:4;
                 u32 reserved6:24;
-        } __attribute__ ((packed)) *sda_area;
+        } __attribute__ ((packed, aligned(4096))) sda_area;
 
-        sda_area = (void *)get_zeroed_page(GFP_KERNEL|GFP_DMA);
-        if (!sda_area)
-                return -ENOMEM;
-        sda_area->request.length = 0x0400;
-        sda_area->request.code = 0x0031;
-        sda_area->operation_code = operation_code;
+        spin_lock(&sda_lock);
+        memset(&sda_area, 0, sizeof(sda_area));
+        sda_area.request.length = 0x0400;
+        sda_area.request.code = 0x0031;
+        sda_area.operation_code = operation_code;
 
-        ret = chsc(sda_area);
+        ret = chsc(&sda_area);
         if (ret > 0) {
                 ret = (ret == 3) ? -ENODEV : -EBUSY;
                 goto out;
         }
 
-        switch (sda_area->response.code) {
+        switch (sda_area.response.code) {
         case 0x0101:
                 ret = -EOPNOTSUPP;
                 break;
         default:
-                ret = chsc_error_from_response(sda_area->response.code);
+                ret = chsc_error_from_response(sda_area.response.code);
         }
         if (ret != 0)
                 CIO_CRW_EVENT(2, "chsc: sda (oc=%x) failed (rc=%04x)\n",
-                              operation_code, sda_area->response.code);
+                              operation_code, sda_area.response.code);
  out:
-        free_page((unsigned long)sda_area);
+        spin_unlock(&sda_lock);
         return ret;
 }
 
diff --git a/drivers/s390/cio/chsc_sch.c b/drivers/s390/cio/chsc_sch.c
index cc5144b6f9d9..3b6f4adc5094 100644
--- a/drivers/s390/cio/chsc_sch.c
+++ b/drivers/s390/cio/chsc_sch.c
@@ -7,11 +7,13 @@
  *
  */
 
+#include <linux/slab.h>
 #include <linux/device.h>
 #include <linux/module.h>
 #include <linux/uaccess.h>
 #include <linux/miscdevice.h>
 
+#include <asm/compat.h>
 #include <asm/cio.h>
 #include <asm/chsc.h>
 #include <asm/isc.h>
@@ -50,7 +52,7 @@ static void chsc_subchannel_irq(struct subchannel *sch)
 {
         struct chsc_private *private = sch->private;
         struct chsc_request *request = private->request;
-        struct irb *irb = (struct irb *)__LC_IRB;
+        struct irb *irb = (struct irb *)&S390_lowcore.irb;
 
         CHSC_LOG(4, "irb");
         CHSC_LOG_HEX(4, irb, sizeof(*irb));
@@ -122,7 +124,7 @@ static int chsc_subchannel_prepare(struct subchannel *sch)
          * since we don't have a way to clear the subchannel and
          * cannot disable it with a request running.
          */
-        cc = stsch(sch->schid, &schib);
+        cc = stsch_err(sch->schid, &schib);
         if (!cc && scsw_stctl(&schib.scsw))
                 return -EAGAIN;
         return 0;
@@ -236,7 +238,7 @@ static int chsc_async(struct chsc_async_area *chsc_area,
         int ret = -ENODEV;
         char dbf[10];
 
-        chsc_area->header.key = PAGE_DEFAULT_KEY;
+        chsc_area->header.key = PAGE_DEFAULT_KEY >> 4;
         while ((sch = chsc_get_next_subchannel(sch))) {
                 spin_lock(sch->lock);
                 private = sch->private;
@@ -770,24 +772,30 @@ out_free:
 static long chsc_ioctl(struct file *filp, unsigned int cmd,
                        unsigned long arg)
 {
+        void __user *argp;
+
         CHSC_MSG(2, "chsc_ioctl called, cmd=%x\n", cmd);
+        if (is_compat_task())
+                argp = compat_ptr(arg);
+        else
+                argp = (void __user *)arg;
         switch (cmd) {
         case CHSC_START:
-                return chsc_ioctl_start((void __user *)arg);
+                return chsc_ioctl_start(argp);
         case CHSC_INFO_CHANNEL_PATH:
-                return chsc_ioctl_info_channel_path((void __user *)arg);
+                return chsc_ioctl_info_channel_path(argp);
         case CHSC_INFO_CU:
-                return chsc_ioctl_info_cu((void __user *)arg);
+                return chsc_ioctl_info_cu(argp);
         case CHSC_INFO_SCH_CU:
-                return chsc_ioctl_info_sch_cu((void __user *)arg);
+                return chsc_ioctl_info_sch_cu(argp);
         case CHSC_INFO_CI:
-                return chsc_ioctl_conf_info((void __user *)arg);
+                return chsc_ioctl_conf_info(argp);
         case CHSC_INFO_CCL:
-                return chsc_ioctl_conf_comp_list((void __user *)arg);
+                return chsc_ioctl_conf_comp_list(argp);
         case CHSC_INFO_CPD:
-                return chsc_ioctl_chpd((void __user *)arg);
+                return chsc_ioctl_chpd(argp);
         case CHSC_INFO_DCAL:
-                return chsc_ioctl_dcal((void __user *)arg);
+                return chsc_ioctl_dcal(argp);
         default: /* unknown ioctl number */
                 return -ENOIOCTLCMD;
         }
diff --git a/drivers/s390/cio/cio.c b/drivers/s390/cio/cio.c
index 138124fcfcad..5feea1a371e1 100644
--- a/drivers/s390/cio/cio.c
+++ b/drivers/s390/cio/cio.c
@@ -361,7 +361,7 @@ int cio_commit_config(struct subchannel *sch)
         struct schib schib;
         int ccode, retry, ret = 0;
 
-        if (stsch(sch->schid, &schib) || !css_sch_is_valid(&schib))
+        if (stsch_err(sch->schid, &schib) || !css_sch_is_valid(&schib))
                 return -ENODEV;
 
         for (retry = 0; retry < 5; retry++) {
@@ -372,7 +372,7 @@ int cio_commit_config(struct subchannel *sch)
                         return ccode;
                 switch (ccode) {
                 case 0: /* successful */
-                        if (stsch(sch->schid, &schib) ||
+                        if (stsch_err(sch->schid, &schib) ||
                             !css_sch_is_valid(&schib))
                                 return -ENODEV;
                         if (cio_check_config(sch, &schib)) {
@@ -404,7 +404,7 @@ int cio_update_schib(struct subchannel *sch)
 {
         struct schib schib;
 
-        if (stsch(sch->schid, &schib) || !css_sch_is_valid(&schib))
+        if (stsch_err(sch->schid, &schib) || !css_sch_is_valid(&schib))
                 return -ENODEV;
 
         memcpy(&sch->schib, &schib, sizeof(schib));
@@ -618,14 +618,15 @@ void __irq_entry do_IRQ(struct pt_regs *regs)
         old_regs = set_irq_regs(regs);
         s390_idle_check();
         irq_enter();
+        __get_cpu_var(s390_idle).nohz_delay = 1;
         if (S390_lowcore.int_clock >= S390_lowcore.clock_comparator)
                 /* Serve timer interrupts first. */
                 clock_comparator_work();
         /*
          * Get interrupt information from lowcore
          */
-        tpi_info = (struct tpi_info *) __LC_SUBCHANNEL_ID;
-        irb = (struct irb *) __LC_IRB;
+        tpi_info = (struct tpi_info *)&S390_lowcore.subchannel_id;
+        irb = (struct irb *)&S390_lowcore.irb;
         do {
                 kstat_cpu(smp_processor_id()).irqs[IO_INTERRUPT]++;
                 /*
@@ -660,7 +661,7 @@ void __irq_entry do_IRQ(struct pt_regs *regs)
                  * We don't do this for VM because a tpi drops the cpu
                  * out of the sie which costs more cycles than it saves.
                  */
-        } while (!MACHINE_IS_VM && tpi (NULL) != 0);
+        } while (MACHINE_IS_LPAR && tpi(NULL) != 0);
         irq_exit();
         set_irq_regs(old_regs);
 }
@@ -681,10 +682,10 @@ static int cio_tpi(void)
         struct irb *irb;
         int irq_context;
 
-        tpi_info = (struct tpi_info *) __LC_SUBCHANNEL_ID;
+        tpi_info = (struct tpi_info *)&S390_lowcore.subchannel_id;
         if (tpi(NULL) != 1)
                 return 0;
-        irb = (struct irb *) __LC_IRB;
+        irb = (struct irb *)&S390_lowcore.irb;
         /* Store interrupt response block to lowcore. */
         if (tsch(tpi_info->schid, irb) != 0)
                 /* Not status pending or not operational. */
@@ -770,7 +771,7 @@ cio_get_console_sch_no(void)
         if (console_irq != -1) {
                 /* VM provided us with the irq number of the console. */
                 schid.sch_no = console_irq;
-                if (stsch(schid, &console_subchannel.schib) != 0 ||
+                if (stsch_err(schid, &console_subchannel.schib) != 0 ||
                     (console_subchannel.schib.pmcw.st != SUBCHANNEL_TYPE_IO) ||
                     !console_subchannel.schib.pmcw.dnv)
                         return -1;
@@ -862,10 +863,10 @@ __disable_subchannel_easy(struct subchannel_id schid, struct schib *schib)
         cc = 0;
         for (retry=0;retry<3;retry++) {
                 schib->pmcw.ena = 0;
-                cc = msch(schid, schib);
+                cc = msch_err(schid, schib);
                 if (cc)
                         return (cc==3?-ENODEV:-EBUSY);
-                if (stsch(schid, schib) || !css_sch_is_valid(schib))
+                if (stsch_err(schid, schib) || !css_sch_is_valid(schib))
                         return -ENODEV;
                 if (!schib->pmcw.ena)
                         return 0;
@@ -884,7 +885,7 @@ __clear_io_subchannel_easy(struct subchannel_id schid)
                 struct tpi_info ti;
 
                 if (tpi(&ti)) {
-                        tsch(ti.schid, (struct irb *)__LC_IRB);
+                        tsch(ti.schid, (struct irb *)&S390_lowcore.irb);
                         if (schid_equal(&ti.schid, &schid))
                                 return 0;
                 }
@@ -912,7 +913,7 @@ static int stsch_reset(struct subchannel_id schid, struct schib *addr)
 
         pgm_check_occured = 0;
         s390_base_pgm_handler_fn = cio_reset_pgm_check_handler;
-        rc = stsch(schid, addr);
+        rc = stsch_err(schid, addr);
         s390_base_pgm_handler_fn = NULL;
 
         /* The program check handler could have changed pgm_check_occured. */
@@ -949,7 +950,7 @@ static int __shutdown_subchannel_easy(struct subchannel_id schid, void *data)
                         /* No default clear strategy */
                         break;
                 }
-                stsch(schid, &schib);
+                stsch_err(schid, &schib);
                 __disable_subchannel_easy(schid, &schib);
         }
 out:
@@ -1082,10 +1083,10 @@ int __init cio_get_iplinfo(struct cio_iplinfo *iplinfo)
         struct subchannel_id schid;
         struct schib schib;
 
-        schid = *(struct subchannel_id *)__LC_SUBCHANNEL_ID;
+        schid = *(struct subchannel_id *)&S390_lowcore.subchannel_id;
         if (!schid.one)
                 return -ENODEV;
-        if (stsch(schid, &schib))
+        if (stsch_err(schid, &schib))
                 return -ENODEV;
         if (schib.pmcw.st != SUBCHANNEL_TYPE_IO)
                 return -ENODEV;
diff --git a/drivers/s390/cio/cio.h b/drivers/s390/cio/cio.h
index 2e43558c704b..bf7f80f5a330 100644
--- a/drivers/s390/cio/cio.h
+++ b/drivers/s390/cio/cio.h
@@ -68,6 +68,11 @@ struct schib {
         __u8 mda[4];             /* model dependent area */
 } __attribute__ ((packed,aligned(4)));
 
+enum sch_todo {
+        SCH_TODO_NOTHING,
+        SCH_TODO_UNREG,
+};
+
 /* subchannel data structure used by I/O subroutines */
 struct subchannel {
         struct subchannel_id schid;
@@ -95,7 +100,8 @@ struct subchannel {
         struct device dev;      /* entry in device tree */
         struct css_driver *driver;
         void *private; /* private per subchannel type data */
-        struct work_struct work;
+        enum sch_todo todo;
+        struct work_struct todo_work;
         struct schib_config config;
 } __attribute__ ((aligned(8)));
 
diff --git a/drivers/s390/cio/cmf.c b/drivers/s390/cio/cmf.c
index 30f516111307..2985eb439485 100644
--- a/drivers/s390/cio/cmf.c
+++ b/drivers/s390/cio/cmf.c
@@ -462,7 +462,7 @@ static struct cmb_area cmb_area = {
  * block of memory, which can not be moved as long as any channel
  * is active. Therefore, a maximum number of subchannels needs to
  * be defined somewhere. This is a module parameter, defaulting to
- * a resonable value of 1024, or 32 kb of memory.
+ * a reasonable value of 1024, or 32 kb of memory.
  * Current kernels don't allow kmalloc with more than 128kb, so the
  * maximum is 4096.
  */
diff --git a/drivers/s390/cio/crw.c b/drivers/s390/cio/crw.c
index d157665d0e76..425f741a280c 100644
--- a/drivers/s390/cio/crw.c
+++ b/drivers/s390/cio/crw.c
@@ -8,15 +8,16 @@
  *               Heiko Carstens <heiko.carstens@de.ibm.com>,
  */
 
-#include <linux/semaphore.h>
 #include <linux/mutex.h>
 #include <linux/kthread.h>
 #include <linux/init.h>
+#include <linux/wait.h>
 #include <asm/crw.h>
 
-static struct semaphore crw_semaphore;
 static DEFINE_MUTEX(crw_handler_mutex);
 static crw_handler_t crw_handlers[NR_RSCS];
+static atomic_t crw_nr_req = ATOMIC_INIT(0);
+static DECLARE_WAIT_QUEUE_HEAD(crw_handler_wait_q);
 
 /**
  * crw_register_handler() - register a channel report word handler
@@ -59,12 +60,14 @@ void crw_unregister_handler(int rsc)
 static int crw_collect_info(void *unused)
 {
         struct crw crw[2];
-        int ccode;
+        int ccode, signal;
         unsigned int chain;
-        int ignore;
 
 repeat:
-        ignore = down_interruptible(&crw_semaphore);
+        signal = wait_event_interruptible(crw_handler_wait_q,
+                                          atomic_read(&crw_nr_req) > 0);
+        if (unlikely(signal))
+                atomic_inc(&crw_nr_req);
         chain = 0;
         while (1) {
                 crw_handler_t handler;
@@ -122,25 +125,23 @@ repeat:
                 /* chain is always 0 or 1 here. */
                 chain = crw[chain].chn ? chain + 1 : 0;
         }
+        if (atomic_dec_and_test(&crw_nr_req))
+                wake_up(&crw_handler_wait_q);
         goto repeat;
         return 0;
 }
 
 void crw_handle_channel_report(void)
 {
-        up(&crw_semaphore);
+        atomic_inc(&crw_nr_req);
+        wake_up(&crw_handler_wait_q);
 }
 
-/*
- * Separate initcall needed for semaphore initialization since
- * crw_handle_channel_report might be called before crw_machine_check_init.
- */
-static int __init crw_init_semaphore(void)
+void crw_wait_for_channel_report(void)
 {
-        init_MUTEX_LOCKED(&crw_semaphore);
-        return 0;
+        crw_handle_channel_report();
+        wait_event(crw_handler_wait_q, atomic_read(&crw_nr_req) == 0);
 }
-pure_initcall(crw_init_semaphore);
 
 /*
  * Machine checks for the channel subsystem must be enabled
diff --git a/drivers/s390/cio/css.c b/drivers/s390/cio/css.c
index 91c25706fa83..511649115bd7 100644
--- a/drivers/s390/cio/css.c
+++ b/drivers/s390/cio/css.c
@@ -18,6 +18,7 @@
 #include <linux/list.h>
 #include <linux/reboot.h>
 #include <linux/suspend.h>
+#include <linux/proc_fs.h>
 #include <asm/isc.h>
 #include <asm/crw.h>
 
@@ -133,6 +134,8 @@ out:
         return rc;
 }
 
+static void css_sch_todo(struct work_struct *work);
+
 static struct subchannel *
 css_alloc_subchannel(struct subchannel_id schid)
 {
@@ -147,6 +150,7 @@ css_alloc_subchannel(struct subchannel_id schid)
                 kfree(sch);
                 return ERR_PTR(ret);
         }
+        INIT_WORK(&sch->todo_work, css_sch_todo);
         return sch;
 }
 
@@ -190,6 +194,51 @@ void css_sch_device_unregister(struct subchannel *sch)
 }
 EXPORT_SYMBOL_GPL(css_sch_device_unregister);
 
+static void css_sch_todo(struct work_struct *work)
+{
+        struct subchannel *sch;
+        enum sch_todo todo;
+
+        sch = container_of(work, struct subchannel, todo_work);
+        /* Find out todo. */
+        spin_lock_irq(sch->lock);
+        todo = sch->todo;
+        CIO_MSG_EVENT(4, "sch_todo: sch=0.%x.%04x, todo=%d\n", sch->schid.ssid,
+                      sch->schid.sch_no, todo);
+        sch->todo = SCH_TODO_NOTHING;
+        spin_unlock_irq(sch->lock);
+        /* Perform todo. */
+        if (todo == SCH_TODO_UNREG)
+                css_sch_device_unregister(sch);
+        /* Release workqueue ref. */
+        put_device(&sch->dev);
+}
+
+/**
+ * css_sched_sch_todo - schedule a subchannel operation
+ * @sch: subchannel
+ * @todo: todo
+ *
+ * Schedule the operation identified by @todo to be performed on the slow path
+ * workqueue. Do nothing if another operation with higher priority is already
+ * scheduled. Needs to be called with subchannel lock held.
+ */
+void css_sched_sch_todo(struct subchannel *sch, enum sch_todo todo)
+{
+        CIO_MSG_EVENT(4, "sch_todo: sched sch=0.%x.%04x todo=%d\n",
+                      sch->schid.ssid, sch->schid.sch_no, todo);
+        if (sch->todo >= todo)
+                return;
+        /* Get workqueue ref. */
+        if (!get_device(&sch->dev))
+                return;
+        sch->todo = todo;
+        if (!queue_work(cio_work_q, &sch->todo_work)) {
+                /* Already queued, release workqueue ref. */
+                put_device(&sch->dev);
+        }
+}
+
 static void ssd_from_pmcw(struct chsc_ssd_info *ssd, struct pmcw *pmcw)
 {
         int i;
@@ -376,8 +425,8 @@ static int css_evaluate_new_subchannel(struct subchannel_id schid, int slow)
                 /* Unusable - ignore. */
                 return 0;
         }
-        CIO_MSG_EVENT(4, "Evaluating schid 0.%x.%04x, event %d, unknown, "
-                         "slow path.\n", schid.ssid, schid.sch_no, CIO_OPER);
+        CIO_MSG_EVENT(4, "event: sch 0.%x.%04x, new\n", schid.ssid,
+                      schid.sch_no);
 
         return css_probe_device(schid);
 }
@@ -394,6 +443,10 @@ static int css_evaluate_known_subchannel(struct subchannel *sch, int slow)
                                 "Got subchannel machine check but "
                                 "no sch_event handler provided.\n");
         }
+        if (ret != 0 && ret != -EAGAIN) {
+                CIO_MSG_EVENT(2, "eval: sch 0.%x.%04x, rc=%d\n",
+                              sch->schid.ssid, sch->schid.sch_no, ret);
+        }
         return ret;
 }
 
@@ -491,7 +544,7 @@ static void css_slow_path_func(struct work_struct *unused)
 }
 
 static DECLARE_WORK(slow_path_work, css_slow_path_func);
-struct workqueue_struct *slow_path_wq;
+struct workqueue_struct *cio_work_q;
 
 void css_schedule_eval(struct subchannel_id schid)
 {
@@ -500,7 +553,7 @@ void css_schedule_eval(struct subchannel_id schid)
         spin_lock_irqsave(&slow_subchannel_lock, flags);
         idset_sch_add(slow_subchannel_set, schid);
         atomic_set(&css_eval_scheduled, 1);
-        queue_work(slow_path_wq, &slow_path_work);
+        queue_work(cio_work_q, &slow_path_work);
         spin_unlock_irqrestore(&slow_subchannel_lock, flags);
 }
 
@@ -511,7 +564,7 @@ void css_schedule_eval_all(void)
         spin_lock_irqsave(&slow_subchannel_lock, flags);
         idset_fill(slow_subchannel_set);
         atomic_set(&css_eval_scheduled, 1);
-        queue_work(slow_path_wq, &slow_path_work);
+        queue_work(cio_work_q, &slow_path_work);
         spin_unlock_irqrestore(&slow_subchannel_lock, flags);
 }
 
@@ -542,14 +595,14 @@ void css_schedule_eval_all_unreg(void)
         spin_lock_irqsave(&slow_subchannel_lock, flags);
         idset_add_set(slow_subchannel_set, unreg_set);
         atomic_set(&css_eval_scheduled, 1);
-        queue_work(slow_path_wq, &slow_path_work);
+        queue_work(cio_work_q, &slow_path_work);
         spin_unlock_irqrestore(&slow_subchannel_lock, flags);
         idset_free(unreg_set);
 }
 
 void css_wait_for_slow_path(void)
 {
-        flush_workqueue(slow_path_wq);
+        flush_workqueue(cio_work_q);
 }
 
 /* Schedule reprobing of all unregistered subchannels. */
@@ -684,6 +737,7 @@ static int __init setup_css(int nr)
         css->pseudo_subchannel->dev.parent = &css->device;
         css->pseudo_subchannel->dev.release = css_subchannel_release;
         dev_set_name(&css->pseudo_subchannel->dev, "defunct");
+        mutex_init(&css->pseudo_subchannel->reg_mutex);
         ret = cio_create_sch_lock(css->pseudo_subchannel);
         if (ret) {
                 kfree(css->pseudo_subchannel);
@@ -816,15 +870,10 @@ static int __init css_bus_init(void)
 
         /* Try to enable MSS. */
         ret = chsc_enable_facility(CHSC_SDA_OC_MSS);
-        switch (ret) {
-        case 0: /* Success. */
-                max_ssid = __MAX_SSID;
-                break;
-        case -ENOMEM:
-                goto out;
-        default:
+        if (ret)
                 max_ssid = 0;
-        }
+        else /* Success. */
+                max_ssid = __MAX_SSID;
 
         ret = slow_subchannel_init();
         if (ret)
@@ -939,12 +988,21 @@ static int __init channel_subsystem_init(void)
         ret = css_bus_init();
         if (ret)
                 return ret;
-
+        cio_work_q = create_singlethread_workqueue("cio");
+        if (!cio_work_q) {
+                ret = -ENOMEM;
+                goto out_bus;
+        }
         ret = io_subchannel_init();
         if (ret)
-                css_bus_cleanup();
+                goto out_wq;
 
         return ret;
+out_wq:
+        destroy_workqueue(cio_work_q);
+out_bus:
+        css_bus_cleanup();
+        return ret;
 }
 subsys_initcall(channel_subsystem_init);
 
@@ -953,10 +1011,25 @@ static int css_settle(struct device_driver *drv, void *unused)
         struct css_driver *cssdrv = to_cssdriver(drv);
 
         if (cssdrv->settle)
-                cssdrv->settle();
+                return cssdrv->settle();
         return 0;
 }
 
+int css_complete_work(void)
+{
+        int ret;
+
+        /* Wait for the evaluation of subchannels to finish. */
+        ret = wait_event_interruptible(css_eval_wq,
+                                       atomic_read(&css_eval_scheduled) == 0);
+        if (ret)
+                return -EINTR;
+        flush_workqueue(cio_work_q);
+        /* Wait for the subchannel type specific initialization to finish */
+        return bus_for_each_drv(&css_bus_type, NULL, NULL, css_settle);
+}
+
+
 /*
  * Wait for the initialization of devices to finish, to make sure we are
  * done with our setup if the search for the root device starts.
@@ -965,13 +1038,46 @@ static int __init channel_subsystem_init_sync(void)
 {
         /* Start initial subchannel evaluation. */
         css_schedule_eval_all();
-        /* Wait for the evaluation of subchannels to finish. */
-        wait_event(css_eval_wq, atomic_read(&css_eval_scheduled) == 0);
-        /* Wait for the subchannel type specific initialization to finish */
-        return bus_for_each_drv(&css_bus_type, NULL, NULL, css_settle);
+        css_complete_work();
+        return 0;
 }
 subsys_initcall_sync(channel_subsystem_init_sync);
 
+void channel_subsystem_reinit(void)
+{
+        chsc_enable_facility(CHSC_SDA_OC_MSS);
+}
+
+#ifdef CONFIG_PROC_FS
+static ssize_t cio_settle_write(struct file *file, const char __user *buf,
+                                size_t count, loff_t *ppos)
+{
+        int ret;
+
+        /* Handle pending CRW's. */
+        crw_wait_for_channel_report();
+        ret = css_complete_work();
+
+        return ret ? ret : count;
+}
+
+static const struct file_operations cio_settle_proc_fops = {
+        .write = cio_settle_write,
+};
+
+static int __init cio_settle_init(void)
+{
+        struct proc_dir_entry *entry;
+
+        entry = proc_create("cio_settle", S_IWUSR, NULL,
+                            &cio_settle_proc_fops);
+        if (!entry)
+                return -ENOMEM;
+        return 0;
+}
+device_initcall(cio_settle_init);
+#endif /*CONFIG_PROC_FS*/
+
 int sch_is_pseudo_sch(struct subchannel *sch)
 {
         return sch == to_css(sch->dev.parent)->pseudo_subchannel;
@@ -1095,7 +1201,7 @@ static int css_pm_restore(struct device *dev)
         return drv->restore ? drv->restore(sch) : 0;
 }
 
-static struct dev_pm_ops css_pm_ops = {
+static const struct dev_pm_ops css_pm_ops = {
         .prepare = css_pm_prepare,
         .complete = css_pm_complete,
         .freeze = css_pm_freeze,
diff --git a/drivers/s390/cio/css.h b/drivers/s390/cio/css.h
index 68d6b0bf151c..7e37886de231 100644
--- a/drivers/s390/cio/css.h
+++ b/drivers/s390/cio/css.h
@@ -11,6 +11,8 @@
 #include <asm/chpid.h>
 #include <asm/schid.h>
 
+#include "cio.h"
+
 /*
  * path grouping stuff
  */
@@ -93,7 +95,7 @@ struct css_driver {
         int (*freeze)(struct subchannel *);
         int (*thaw) (struct subchannel *);
         int (*restore)(struct subchannel *);
-        void (*settle)(void);
+        int (*settle)(void);
         const char *name;
 };
 
@@ -144,11 +146,13 @@ extern struct channel_subsystem *channel_subsystems[];
 /* Helper functions to build lists for the slow path. */
 void css_schedule_eval(struct subchannel_id schid);
 void css_schedule_eval_all(void);
+int css_complete_work(void);
 
 int sch_is_pseudo_sch(struct subchannel *);
 struct schib;
 int css_sch_is_valid(struct schib *);
 
-extern struct workqueue_struct *slow_path_wq;
+extern struct workqueue_struct *cio_work_q;
 void css_wait_for_slow_path(void);
+void css_sched_sch_todo(struct subchannel *sch, enum sch_todo todo);
 #endif
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index 2490b741e16a..6d229f3523a0 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -7,6 +7,10 @@
  *               Cornelia Huck (cornelia.huck@de.ibm.com)
  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
  */
+
+#define KMSG_COMPONENT "cio"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
@@ -132,7 +136,6 @@ static int io_subchannel_sch_event(struct subchannel *, int);
 static int io_subchannel_chp_event(struct subchannel *, struct chp_link *,
                                    int);
 static void recovery_func(unsigned long data);
-struct workqueue_struct *ccw_device_work;
 wait_queue_head_t ccw_device_init_wq;
 atomic_t ccw_device_init_count;
 
@@ -155,11 +158,16 @@ static int io_subchannel_prepare(struct subchannel *sch)
         return 0;
 }
 
-static void io_subchannel_settle(void)
+static int io_subchannel_settle(void)
 {
-        wait_event(ccw_device_init_wq,
-                   atomic_read(&ccw_device_init_count) == 0);
-        flush_workqueue(ccw_device_work);
+        int ret;
+
+        ret = wait_event_interruptible(ccw_device_init_wq,
+                                atomic_read(&ccw_device_init_count) == 0);
+        if (ret)
+                return -EINTR;
+        flush_workqueue(cio_work_q);
+        return 0;
 }
 
 static struct css_driver io_subchannel_driver = {
@@ -184,27 +192,13 @@ int __init io_subchannel_init(void)
         atomic_set(&ccw_device_init_count, 0);
         setup_timer(&recovery_timer, recovery_func, 0);
 
-        ccw_device_work = create_singlethread_workqueue("cio");
-        if (!ccw_device_work)
-                return -ENOMEM;
-        slow_path_wq = create_singlethread_workqueue("kslowcrw");
-        if (!slow_path_wq) {
-                ret = -ENOMEM;
-                goto out_err;
-        }
-        if ((ret = bus_register (&ccw_bus_type)))
-                goto out_err;
-
+        ret = bus_register(&ccw_bus_type);
+        if (ret)
+                return ret;
         ret = css_driver_register(&io_subchannel_driver);
         if (ret)
-                goto out_err;
+                bus_unregister(&ccw_bus_type);
 
-        return 0;
-out_err:
-        if (ccw_device_work)
-                destroy_workqueue(ccw_device_work);
-        if (slow_path_wq)
-                destroy_workqueue(slow_path_wq);
         return ret;
 }
 
@@ -299,53 +293,18 @@ int ccw_device_is_orphan(struct ccw_device *cdev)
 
 static void ccw_device_unregister(struct ccw_device *cdev)
 {
-        if (test_and_clear_bit(1, &cdev->private->registered)) {
+        if (device_is_registered(&cdev->dev)) {
+                /* Undo device_add(). */
                 device_del(&cdev->dev);
+        }
+        if (cdev->private->flags.initialized) {
+                cdev->private->flags.initialized = 0;
                 /* Release reference from device_initialize(). */
                 put_device(&cdev->dev);
         }
 }
 
-static void ccw_device_remove_orphan_cb(struct work_struct *work)
-{
-        struct ccw_device_private *priv;
-        struct ccw_device *cdev;
-
-        priv = container_of(work, struct ccw_device_private, kick_work);
-        cdev = priv->cdev;
-        ccw_device_unregister(cdev);
-        /* Release cdev reference for workqueue processing. */
-        put_device(&cdev->dev);
-}
-
-static void
-ccw_device_remove_disconnected(struct ccw_device *cdev)
-{
-        unsigned long flags;
-
-        /*
-         * Forced offline in disconnected state means
-         * 'throw away device'.
-         */
-        if (ccw_device_is_orphan(cdev)) {
-                /*
-                 * Deregister ccw device.
-                 * Unfortunately, we cannot do this directly from the
-                 * attribute method.
-                 */
-                /* Get cdev reference for workqueue processing. */
-                if (!get_device(&cdev->dev))
-                        return;
-                spin_lock_irqsave(cdev->ccwlock, flags);
-                cdev->private->state = DEV_STATE_NOT_OPER;
-                spin_unlock_irqrestore(cdev->ccwlock, flags);
-                PREPARE_WORK(&cdev->private->kick_work,
-                                ccw_device_remove_orphan_cb);
-                queue_work(slow_path_wq, &cdev->private->kick_work);
-        } else
-                /* Deregister subchannel, which will kill the ccw device. */
-                ccw_device_schedule_sch_unregister(cdev);
-}
+static void io_subchannel_quiesce(struct subchannel *);
 
 /**
  * ccw_device_set_offline() - disable a ccw device for I/O
@@ -360,7 +319,8 @@ ccw_device_remove_disconnected(struct ccw_device *cdev)
  */
 int ccw_device_set_offline(struct ccw_device *cdev)
 {
-        int ret;
+        struct subchannel *sch;
+        int ret, state;
 
         if (!cdev)
                 return -ENODEV;
@@ -374,6 +334,7 @@ int ccw_device_set_offline(struct ccw_device *cdev)
         }
         cdev->online = 0;
         spin_lock_irq(cdev->ccwlock);
+        sch = to_subchannel(cdev->dev.parent);
         /* Wait until a final state or DISCONNECTED is reached */
         while (!dev_fsm_final_state(cdev) &&
                cdev->private->state != DEV_STATE_DISCONNECTED) {
@@ -382,20 +343,37 @@ int ccw_device_set_offline(struct ccw_device *cdev)
                            cdev->private->state == DEV_STATE_DISCONNECTED));
                 spin_lock_irq(cdev->ccwlock);
         }
-        ret = ccw_device_offline(cdev);
-        if (ret)
-                goto error;
+        do {
+                ret = ccw_device_offline(cdev);
+                if (!ret)
+                        break;
+                CIO_MSG_EVENT(0, "ccw_device_offline returned %d, device "
+                              "0.%x.%04x\n", ret, cdev->private->dev_id.ssid,
+                              cdev->private->dev_id.devno);
+                if (ret != -EBUSY)
+                        goto error;
+                state = cdev->private->state;
+                spin_unlock_irq(cdev->ccwlock);
+                io_subchannel_quiesce(sch);
+                spin_lock_irq(cdev->ccwlock);
+                cdev->private->state = state;
+        } while (ret == -EBUSY);
         spin_unlock_irq(cdev->ccwlock);
         wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||
                    cdev->private->state == DEV_STATE_DISCONNECTED));
+        /* Inform the user if set offline failed. */
+        if (cdev->private->state == DEV_STATE_BOXED) {
+                pr_warning("%s: The device entered boxed state while "
+                           "being set offline\n", dev_name(&cdev->dev));
+        } else if (cdev->private->state == DEV_STATE_NOT_OPER) {
+                pr_warning("%s: The device stopped operating while "
+                           "being set offline\n", dev_name(&cdev->dev));
+        }
         /* Give up reference from ccw_device_set_online(). */
         put_device(&cdev->dev);
         return 0;
 
 error:
-        CIO_MSG_EVENT(0, "ccw_device_offline returned %d, device 0.%x.%04x\n",
-                      ret, cdev->private->dev_id.ssid,
-                      cdev->private->dev_id.devno);
         cdev->private->state = DEV_STATE_OFFLINE;
         dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
         spin_unlock_irq(cdev->ccwlock);
@@ -448,6 +426,16 @@ int ccw_device_set_online(struct ccw_device *cdev)
         if ((cdev->private->state != DEV_STATE_ONLINE) &&
             (cdev->private->state != DEV_STATE_W4SENSE)) {
                 spin_unlock_irq(cdev->ccwlock);
+                /* Inform the user that set online failed. */
+                if (cdev->private->state == DEV_STATE_BOXED) {
+                        pr_warning("%s: Setting the device online failed "
+                                   "because it is boxed\n",
+                                   dev_name(&cdev->dev));
+                } else if (cdev->private->state == DEV_STATE_NOT_OPER) {
+                        pr_warning("%s: Setting the device online failed "
+                                   "because it is not operational\n",
+                                   dev_name(&cdev->dev));
+                }
                 /* Give up online reference since onlining failed. */
                 put_device(&cdev->dev);
                 return -ENODEV;
@@ -494,27 +482,22 @@ error:
 
 static int online_store_handle_offline(struct ccw_device *cdev)
 {
-        if (cdev->private->state == DEV_STATE_DISCONNECTED)
-                ccw_device_remove_disconnected(cdev);
-        else if (cdev->online && cdev->drv && cdev->drv->set_offline)
+        if (cdev->private->state == DEV_STATE_DISCONNECTED) {
+                spin_lock_irq(cdev->ccwlock);
+                ccw_device_sched_todo(cdev, CDEV_TODO_UNREG_EVAL);
+                spin_unlock_irq(cdev->ccwlock);
+        } else if (cdev->online && cdev->drv && cdev->drv->set_offline)
                 return ccw_device_set_offline(cdev);
         return 0;
 }
 
 static int online_store_recog_and_online(struct ccw_device *cdev)
 {
-        int ret;
-
         /* Do device recognition, if needed. */
         if (cdev->private->state == DEV_STATE_BOXED) {
-                ret = ccw_device_recognition(cdev);
-                if (ret) {
-                        CIO_MSG_EVENT(0, "Couldn't start recognition "
-                                      "for device 0.%x.%04x (ret=%d)\n",
-                                      cdev->private->dev_id.ssid,
-                                      cdev->private->dev_id.devno, ret);
-                        return ret;
-                }
+                spin_lock_irq(cdev->ccwlock);
+                ccw_device_recognition(cdev);
+                spin_unlock_irq(cdev->ccwlock);
                 wait_event(cdev->private->wait_q,
                            cdev->private->flags.recog_done);
                 if (cdev->private->state != DEV_STATE_OFFLINE)
@@ -553,11 +536,10 @@ static ssize_t online_store (struct device *dev, struct device_attribute *attr,
         int force, ret;
         unsigned long i;
 
-        if ((cdev->private->state != DEV_STATE_OFFLINE &&
-             cdev->private->state != DEV_STATE_ONLINE &&
-             cdev->private->state != DEV_STATE_BOXED &&
-             cdev->private->state != DEV_STATE_DISCONNECTED) ||
-            atomic_cmpxchg(&cdev->private->onoff, 0, 1) != 0)
+        if (!dev_fsm_final_state(cdev) &&
+            cdev->private->state != DEV_STATE_DISCONNECTED)
+                return -EAGAIN;
+        if (atomic_cmpxchg(&cdev->private->onoff, 0, 1) != 0)
                 return -EAGAIN;
 
         if (cdev->drv && !try_module_get(cdev->drv->owner)) {
@@ -665,81 +647,31 @@ static int ccw_device_register(struct ccw_device *cdev)
                            cdev->private->dev_id.devno);
         if (ret)
                 return ret;
-        ret = device_add(dev);
-        if (ret)
-                return ret;
-
-        set_bit(1, &cdev->private->registered);
-        return ret;
-}
-
-struct match_data {
-        struct ccw_dev_id dev_id;
-        struct ccw_device * sibling;
-};
-
-static int
-match_devno(struct device * dev, void * data)
-{
-        struct match_data * d = data;
-        struct ccw_device * cdev;
-
-        cdev = to_ccwdev(dev);
-        if ((cdev->private->state == DEV_STATE_DISCONNECTED) &&
-            !ccw_device_is_orphan(cdev) &&
-            ccw_dev_id_is_equal(&cdev->private->dev_id, &d->dev_id) &&
-            (cdev != d->sibling))
-                return 1;
-        return 0;
+        return device_add(dev);
 }
 
-static struct ccw_device * get_disc_ccwdev_by_dev_id(struct ccw_dev_id *dev_id,
-                                                     struct ccw_device *sibling)
+static int match_dev_id(struct device *dev, void *data)
 {
-        struct device *dev;
-        struct match_data data;
-
-        data.dev_id = *dev_id;
-        data.sibling = sibling;
-        dev = bus_find_device(&ccw_bus_type, NULL, &data, match_devno);
-
-        return dev ? to_ccwdev(dev) : NULL;
-}
-
-static int match_orphan(struct device *dev, void *data)
-{
-        struct ccw_dev_id *dev_id;
-        struct ccw_device *cdev;
+        struct ccw_device *cdev = to_ccwdev(dev);
+        struct ccw_dev_id *dev_id = data;
 
-        dev_id = data;
-        cdev = to_ccwdev(dev);
         return ccw_dev_id_is_equal(&cdev->private->dev_id, dev_id);
 }
 
-static struct ccw_device *
-get_orphaned_ccwdev_by_dev_id(struct channel_subsystem *css,
-                              struct ccw_dev_id *dev_id)
+static struct ccw_device *get_ccwdev_by_dev_id(struct ccw_dev_id *dev_id)
 {
         struct device *dev;
 
-        dev = device_find_child(&css->pseudo_subchannel->dev, dev_id,
-                                match_orphan);
+        dev = bus_find_device(&ccw_bus_type, NULL, dev_id, match_dev_id);
 
         return dev ? to_ccwdev(dev) : NULL;
 }
 
-void ccw_device_do_unbind_bind(struct work_struct *work)
+static void ccw_device_do_unbind_bind(struct ccw_device *cdev)
 {
-        struct ccw_device_private *priv;
-        struct ccw_device *cdev;
-        struct subchannel *sch;
         int ret;
 
-        priv = container_of(work, struct ccw_device_private, kick_work);
-        cdev = priv->cdev;
-        sch = to_subchannel(cdev->dev.parent);
-
-        if (test_bit(1, &cdev->private->registered)) {
+        if (device_is_registered(&cdev->dev)) {
                 device_release_driver(&cdev->dev);
                 ret = device_attach(&cdev->dev);
                 WARN_ON(ret == -ENODEV);
@@ -773,6 +705,8 @@ static struct ccw_device * io_subchannel_allocate_dev(struct subchannel *sch)
         return ERR_PTR(-ENOMEM);
 }
 
+static void ccw_device_todo(struct work_struct *work);
+
 static int io_subchannel_initialize_dev(struct subchannel *sch,
                                         struct ccw_device *cdev)
 {
@@ -780,7 +714,7 @@ static int io_subchannel_initialize_dev(struct subchannel *sch,
         atomic_set(&cdev->private->onoff, 0);
         cdev->dev.parent = &sch->dev;
         cdev->dev.release = ccw_device_release;
-        INIT_WORK(&cdev->private->kick_work, NULL);
+        INIT_WORK(&cdev->private->todo_work, ccw_device_todo);
         cdev->dev.groups = ccwdev_attr_groups;
         /* Do first half of device_register. */
         device_initialize(&cdev->dev);
@@ -789,6 +723,7 @@ static int io_subchannel_initialize_dev(struct subchannel *sch,
                 put_device(&cdev->dev);
                 return -ENODEV;
         }
+        cdev->private->flags.initialized = 1;
         return 0;
 }
 
@@ -806,76 +741,7 @@ static struct ccw_device * io_subchannel_create_ccwdev(struct subchannel *sch)
         return cdev;
 }
 
-static int io_subchannel_recog(struct ccw_device *, struct subchannel *);
-
-static void sch_attach_device(struct subchannel *sch,
-                              struct ccw_device *cdev)
-{
-        css_update_ssd_info(sch);
-        spin_lock_irq(sch->lock);
-        sch_set_cdev(sch, cdev);
-        cdev->private->schid = sch->schid;
-        cdev->ccwlock = sch->lock;
-        ccw_device_trigger_reprobe(cdev);
-        spin_unlock_irq(sch->lock);
-}
-
-static void sch_attach_disconnected_device(struct subchannel *sch,
-                                           struct ccw_device *cdev)
-{
-        struct subchannel *other_sch;
-        int ret;
-
-        /* Get reference for new parent. */
-        if (!get_device(&sch->dev))
-                return;
-        other_sch = to_subchannel(cdev->dev.parent);
-        /* Note: device_move() changes cdev->dev.parent */
-        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,
-                              cdev->private->dev_id.devno, ret);
-                /* Put reference for new parent. */
-                put_device(&sch->dev);
-                return;
-        }
-        sch_set_cdev(other_sch, NULL);
-        /* No need to keep a subchannel without ccw device around. */
-        css_sch_device_unregister(other_sch);
-        sch_attach_device(sch, cdev);
-        /* Put reference for old parent. */
-        put_device(&other_sch->dev);
-}
-
-static void sch_attach_orphaned_device(struct subchannel *sch,
-                                       struct ccw_device *cdev)
-{
-        int ret;
-        struct subchannel *pseudo_sch;
-
-        /* Get reference for new parent. */
-        if (!get_device(&sch->dev))
-                return;
-        pseudo_sch = to_subchannel(cdev->dev.parent);
-        /*
-         * Try to move the ccw device to its new subchannel.
-         * Note: device_move() changes cdev->dev.parent
-         */
-        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",
-                              cdev->private->dev_id.ssid,
-                              cdev->private->dev_id.devno, ret);
-                /* Put reference for new parent. */
-                put_device(&sch->dev);
-                return;
-        }
-        sch_attach_device(sch, cdev);
-        /* Put reference on pseudo subchannel. */
-        put_device(&pseudo_sch->dev);
-}
+static void io_subchannel_recog(struct ccw_device *, struct subchannel *);
 
 static void sch_create_and_recog_new_device(struct subchannel *sch)
 {
@@ -888,100 +754,19 @@ static void sch_create_and_recog_new_device(struct subchannel *sch)
                 css_sch_device_unregister(sch);
                 return;
         }
-        spin_lock_irq(sch->lock);
-        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_set_cdev(sch, NULL);
-                spin_unlock_irq(sch->lock);
-                css_sch_device_unregister(sch);
-                /* Put reference from io_subchannel_create_ccwdev(). */
-                put_device(&sch->dev);
-                /* Give up initial reference. */
-                put_device(&cdev->dev);
-        }
-}
-
-
-void ccw_device_move_to_orphanage(struct work_struct *work)
-{
-        struct ccw_device_private *priv;
-        struct ccw_device *cdev;
-        struct ccw_device *replacing_cdev;
-        struct subchannel *sch;
-        int ret;
-        struct channel_subsystem *css;
-        struct ccw_dev_id dev_id;
-
-        priv = container_of(work, struct ccw_device_private, kick_work);
-        cdev = priv->cdev;
-        sch = to_subchannel(cdev->dev.parent);
-        css = to_css(sch->dev.parent);
-        dev_id.devno = sch->schib.pmcw.dev;
-        dev_id.ssid = sch->schid.ssid;
-
-        /* Increase refcount for pseudo subchannel. */
-        get_device(&css->pseudo_subchannel->dev);
-        /*
-         * Move the orphaned ccw device to the orphanage so the replacing
-         * 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,
-                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,
-                              cdev->private->dev_id.devno, ret);
-                /* Decrease refcount for pseudo subchannel again. */
-                put_device(&css->pseudo_subchannel->dev);
-                return;
-        }
-        cdev->ccwlock = css->pseudo_subchannel->lock;
-        /*
-         * Search for the replacing ccw device
-         * - among the disconnected devices
-         * - in the orphanage
-         */
-        replacing_cdev = get_disc_ccwdev_by_dev_id(&dev_id, cdev);
-        if (replacing_cdev) {
-                sch_attach_disconnected_device(sch, replacing_cdev);
-                /* Release reference from get_disc_ccwdev_by_dev_id() */
-                put_device(&replacing_cdev->dev);
-                /* Release reference of subchannel from old cdev. */
-                put_device(&sch->dev);
-                return;
-        }
-        replacing_cdev = get_orphaned_ccwdev_by_dev_id(css, &dev_id);
-        if (replacing_cdev) {
-                sch_attach_orphaned_device(sch, replacing_cdev);
-                /* Release reference from get_orphaned_ccwdev_by_dev_id() */
-                put_device(&replacing_cdev->dev);
-                /* Release reference of subchannel from old cdev. */
-                put_device(&sch->dev);
-                return;
-        }
-        sch_create_and_recog_new_device(sch);
-        /* Release reference of subchannel from old cdev. */
-        put_device(&sch->dev);
+        io_subchannel_recog(cdev, sch);
 }
 
 /*
  * Register recognized device.
  */
-static void
-io_subchannel_register(struct work_struct *work)
+static void io_subchannel_register(struct ccw_device *cdev)
 {
-        struct ccw_device_private *priv;
-        struct ccw_device *cdev;
         struct subchannel *sch;
-        int ret;
+        int ret, adjust_init_count = 1;
         unsigned long flags;
 
-        priv = container_of(work, struct ccw_device_private, kick_work);
-        cdev = priv->cdev;
         sch = to_subchannel(cdev->dev.parent);
         /*
          * Check if subchannel is still registered. It may have become
@@ -1008,6 +793,7 @@ io_subchannel_register(struct work_struct *work)
                                               cdev->private->dev_id.ssid,
                                               cdev->private->dev_id.devno);
                 }
+                adjust_init_count = 0;
                 goto out;
         }
         /*
@@ -1033,41 +819,23 @@ out:
         cdev->private->flags.recog_done = 1;
         wake_up(&cdev->private->wait_q);
 out_err:
-        /* Release reference for workqueue processing. */
-        put_device(&cdev->dev);
-        if (atomic_dec_and_test(&ccw_device_init_count))
+        if (adjust_init_count && atomic_dec_and_test(&ccw_device_init_count))
                 wake_up(&ccw_device_init_wq);
 }
 
-static void ccw_device_call_sch_unregister(struct work_struct *work)
+static void ccw_device_call_sch_unregister(struct ccw_device *cdev)
 {
-        struct ccw_device_private *priv;
-        struct ccw_device *cdev;
         struct subchannel *sch;
 
-        priv = container_of(work, struct ccw_device_private, kick_work);
-        cdev = priv->cdev;
         /* Get subchannel reference for local processing. */
         if (!get_device(cdev->dev.parent))
                 return;
         sch = to_subchannel(cdev->dev.parent);
         css_sch_device_unregister(sch);
-        /* Release cdev reference for workqueue processing.*/
-        put_device(&cdev->dev);
         /* Release subchannel reference for local processing. */
         put_device(&sch->dev);
 }
 
-void ccw_device_schedule_sch_unregister(struct ccw_device *cdev)
-{
-        /* Get cdev reference for workqueue processing. */
-        if (!get_device(&cdev->dev))
-                return;
-        PREPARE_WORK(&cdev->private->kick_work,
-                     ccw_device_call_sch_unregister);
-        queue_work(slow_path_wq, &cdev->private->kick_work);
-}
-
 /*
  * subchannel recognition done. Called from the state machine.
  */
@@ -1083,7 +851,8 @@ io_subchannel_recog_done(struct ccw_device *cdev)
                 /* Device did not respond in time. */
         case DEV_STATE_NOT_OPER:
                 cdev->private->flags.recog_done = 1;
-                ccw_device_schedule_sch_unregister(cdev);
+                /* Remove device found not operational. */
+                ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
                 if (atomic_dec_and_test(&ccw_device_init_count))
                         wake_up(&ccw_device_init_wq);
                 break;
@@ -1092,22 +861,15 @@ io_subchannel_recog_done(struct ccw_device *cdev)
                  * We can't register the device in interrupt context so
                  * we schedule a work item.
                  */
-                if (!get_device(&cdev->dev))
-                        break;
-                PREPARE_WORK(&cdev->private->kick_work,
-                             io_subchannel_register);
-                queue_work(slow_path_wq, &cdev->private->kick_work);
+                ccw_device_sched_todo(cdev, CDEV_TODO_REGISTER);
                 break;
         }
 }
 
-static int
-io_subchannel_recog(struct ccw_device *cdev, struct subchannel *sch)
+static void io_subchannel_recog(struct ccw_device *cdev, struct subchannel *sch)
 {
-        int rc;
         struct ccw_device_private *priv;
 
-        sch_set_cdev(sch, cdev);
         cdev->ccwlock = sch->lock;
 
         /* Init private data. */
@@ -1125,62 +887,81 @@ io_subchannel_recog(struct ccw_device *cdev, struct subchannel *sch)
 
         /* Start async. device sensing. */
         spin_lock_irq(sch->lock);
-        rc = ccw_device_recognition(cdev);
+        sch_set_cdev(sch, cdev);
+        ccw_device_recognition(cdev);
         spin_unlock_irq(sch->lock);
-        if (rc) {
-                if (atomic_dec_and_test(&ccw_device_init_count))
-                        wake_up(&ccw_device_init_wq);
-        }
-        return rc;
 }
 
-static void ccw_device_move_to_sch(struct work_struct *work)
+static int ccw_device_move_to_sch(struct ccw_device *cdev,
+                                  struct subchannel *sch)
 {
-        struct ccw_device_private *priv;
-        int rc;
-        struct subchannel *sch;
-        struct ccw_device *cdev;
-        struct subchannel *former_parent;
+        struct subchannel *old_sch;
+        int rc, old_enabled = 0;
 
-        priv = container_of(work, struct ccw_device_private, kick_work);
-        sch = priv->sch;
-        cdev = priv->cdev;
-        former_parent = to_subchannel(cdev->dev.parent);
-        /* Get reference for new parent. */
+        old_sch = to_subchannel(cdev->dev.parent);
+        /* Obtain child reference for new parent. */
         if (!get_device(&sch->dev))
-                return;
+                return -ENODEV;
+
+        if (!sch_is_pseudo_sch(old_sch)) {
+                spin_lock_irq(old_sch->lock);
+                old_enabled = old_sch->schib.pmcw.ena;
+                rc = 0;
+                if (old_enabled)
+                        rc = cio_disable_subchannel(old_sch);
+                spin_unlock_irq(old_sch->lock);
+                if (rc == -EBUSY) {
+                        /* Release child reference for new parent. */
+                        put_device(&sch->dev);
+                        return rc;
+                }
+        }
+
         mutex_lock(&sch->reg_mutex);
-        /*
-         * Try to move the ccw device to its new subchannel.
-         * Note: device_move() changes cdev->dev.parent
-         */
         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 "
-                              "0.%x.%04x failed (ret=%d)!\n",
+                CIO_MSG_EVENT(0, "device_move(0.%x.%04x,0.%x.%04x)=%d\n",
                               cdev->private->dev_id.ssid,
                               cdev->private->dev_id.devno, sch->schid.ssid,
-                              sch->schid.sch_no, rc);
-                css_sch_device_unregister(sch);
-                /* Put reference for new parent again. */
+                              sch->schib.pmcw.dev, rc);
+                if (old_enabled) {
+                        /* Try to reenable the old subchannel. */
+                        spin_lock_irq(old_sch->lock);
+                        cio_enable_subchannel(old_sch, (u32)(addr_t)old_sch);
+                        spin_unlock_irq(old_sch->lock);
+                }
+                /* Release child reference for new parent. */
                 put_device(&sch->dev);
-                goto out;
+                return rc;
         }
-        if (!sch_is_pseudo_sch(former_parent)) {
-                spin_lock_irq(former_parent->lock);
-                sch_set_cdev(former_parent, NULL);
-                spin_unlock_irq(former_parent->lock);
-                css_sch_device_unregister(former_parent);
-                /* Reset intparm to zeroes. */
-                former_parent->config.intparm = 0;
-                cio_commit_config(former_parent);
+        /* Clean up old subchannel. */
+        if (!sch_is_pseudo_sch(old_sch)) {
+                spin_lock_irq(old_sch->lock);
+                sch_set_cdev(old_sch, NULL);
+                spin_unlock_irq(old_sch->lock);
+                css_schedule_eval(old_sch->schid);
         }
-        sch_attach_device(sch, cdev);
-out:
-        /* Put reference for old parent. */
-        put_device(&former_parent->dev);
-        put_device(&cdev->dev);
+        /* Release child reference for old parent. */
+        put_device(&old_sch->dev);
+        /* Initialize new subchannel. */
+        spin_lock_irq(sch->lock);
+        cdev->private->schid = sch->schid;
+        cdev->ccwlock = sch->lock;
+        if (!sch_is_pseudo_sch(sch))
+                sch_set_cdev(sch, cdev);
+        spin_unlock_irq(sch->lock);
+        if (!sch_is_pseudo_sch(sch))
+                css_update_ssd_info(sch);
+        return 0;
+}
+
+static int ccw_device_move_to_orph(struct ccw_device *cdev)
+{
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct channel_subsystem *css = to_css(sch->dev.parent);
+
+        return ccw_device_move_to_sch(cdev, css->pseudo_subchannel);
 }
 
 static void io_subchannel_irq(struct subchannel *sch)
@@ -1199,9 +980,6 @@ void io_subchannel_init_config(struct subchannel *sch)
 {
         memset(&sch->config, 0, sizeof(sch->config));
         sch->config.csense = 1;
-        /* Use subchannel mp mode when there is more than 1 installed CHPID. */
-        if ((sch->schib.pmcw.pim & (sch->schib.pmcw.pim - 1)) != 0)
-                sch->config.mp = 1;
 }
 
 static void io_subchannel_init_fields(struct subchannel *sch)
@@ -1222,23 +1000,6 @@ static void io_subchannel_init_fields(struct subchannel *sch)
         io_subchannel_init_config(sch);
 }
 
-static void io_subchannel_do_unreg(struct work_struct *work)
-{
-        struct subchannel *sch;
-
-        sch = container_of(work, struct subchannel, work);
-        css_sch_device_unregister(sch);
-        put_device(&sch->dev);
-}
-
-/* Schedule unregister if we have no cdev. */
-static void io_subchannel_schedule_removal(struct subchannel *sch)
-{
-        get_device(&sch->dev);
-        INIT_WORK(&sch->work, io_subchannel_do_unreg);
-        queue_work(slow_path_wq, &sch->work);
-}
-
 /*
  * Note: We always return 0 so that we bind to the device even on error.
  * This is needed so that our remove function is called on unregister.
@@ -1247,8 +1008,6 @@ static int io_subchannel_probe(struct subchannel *sch)
 {
         struct ccw_device *cdev;
         int rc;
-        unsigned long flags;
-        struct ccw_dev_id dev_id;
 
         if (cio_is_console(sch->schid)) {
                 rc = sysfs_create_group(&sch->dev.kobj,
@@ -1268,6 +1027,7 @@ static int io_subchannel_probe(struct subchannel *sch)
                 cdev = sch_get_cdev(sch);
                 cdev->dev.groups = ccwdev_attr_groups;
                 device_initialize(&cdev->dev);
+                cdev->private->flags.initialized = 1;
                 ccw_device_register(cdev);
                 /*
                  * Check if the device is already online. If it is
@@ -1292,44 +1052,14 @@ static int io_subchannel_probe(struct subchannel *sch)
         sch->private = kzalloc(sizeof(struct io_subchannel_private),
                                GFP_KERNEL | GFP_DMA);
         if (!sch->private)
-                goto out_err;
-        /*
-         * First check if a fitting device may be found amongst the
-         * disconnected devices or in the orphanage.
-         */
-        dev_id.devno = sch->schib.pmcw.dev;
-        dev_id.ssid = sch->schid.ssid;
-        cdev = get_disc_ccwdev_by_dev_id(&dev_id, NULL);
-        if (!cdev)
-                cdev = get_orphaned_ccwdev_by_dev_id(to_css(sch->dev.parent),
-                                                     &dev_id);
-        if (cdev) {
-                /*
-                 * Schedule moving the device until when we have a registered
-                 * subchannel to move to and succeed the probe. We can
-                 * unregister later again, when the probe is through.
-                 */
-                cdev->private->sch = sch;
-                PREPARE_WORK(&cdev->private->kick_work,
-                             ccw_device_move_to_sch);
-                queue_work(slow_path_wq, &cdev->private->kick_work);
-                return 0;
-        }
-        cdev = io_subchannel_create_ccwdev(sch);
-        if (IS_ERR(cdev))
-                goto out_err;
-        rc = io_subchannel_recog(cdev, sch);
-        if (rc) {
-                spin_lock_irqsave(sch->lock, flags);
-                io_subchannel_recog_done(cdev);
-                spin_unlock_irqrestore(sch->lock, flags);
-        }
+                goto out_schedule;
+        css_schedule_eval(sch->schid);
         return 0;
-out_err:
-        kfree(sch->private);
-        sysfs_remove_group(&sch->dev.kobj, &io_subchannel_attr_group);
+
 out_schedule:
-        io_subchannel_schedule_removal(sch);
+        spin_lock_irq(sch->lock);
+        css_sched_sch_todo(sch, SCH_TODO_UNREG);
+        spin_unlock_irq(sch->lock);
         return 0;
 }
 
@@ -1337,32 +1067,23 @@ static int
 io_subchannel_remove (struct subchannel *sch)
 {
         struct ccw_device *cdev;
-        unsigned long flags;
 
         cdev = sch_get_cdev(sch);
         if (!cdev)
-                return 0;
+                goto out_free;
+        io_subchannel_quiesce(sch);
         /* Set ccw device to not operational and drop reference. */
-        spin_lock_irqsave(cdev->ccwlock, flags);
+        spin_lock_irq(cdev->ccwlock);
         sch_set_cdev(sch, NULL);
         cdev->private->state = DEV_STATE_NOT_OPER;
-        spin_unlock_irqrestore(cdev->ccwlock, flags);
+        spin_unlock_irq(cdev->ccwlock);
         ccw_device_unregister(cdev);
+out_free:
         kfree(sch->private);
         sysfs_remove_group(&sch->dev.kobj, &io_subchannel_attr_group);
         return 0;
 }
 
-static int io_subchannel_notify(struct subchannel *sch, int event)
-{
-        struct ccw_device *cdev;
-
-        cdev = sch_get_cdev(sch);
-        if (!cdev)
-                return 0;
-        return ccw_device_notify(cdev, event);
-}
-
 static void io_subchannel_verify(struct subchannel *sch)
 {
         struct ccw_device *cdev;
@@ -1372,36 +1093,6 @@ static void io_subchannel_verify(struct subchannel *sch)
                 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
 }
 
-static int check_for_io_on_path(struct subchannel *sch, int mask)
-{
-        if (cio_update_schib(sch))
-                return 0;
-        if (scsw_actl(&sch->schib.scsw) && sch->schib.pmcw.lpum == mask)
-                return 1;
-        return 0;
-}
-
-static void terminate_internal_io(struct subchannel *sch,
-                                  struct ccw_device *cdev)
-{
-        if (cio_clear(sch)) {
-                /* Recheck device in case clear failed. */
-                sch->lpm = 0;
-                if (cdev->online)
-                        dev_fsm_event(cdev, DEV_EVENT_VERIFY);
-                else
-                        css_schedule_eval(sch->schid);
-                return;
-        }
-        cdev->private->state = DEV_STATE_CLEAR_VERIFY;
-        /* Request retry of internal operation. */
-        cdev->private->flags.intretry = 1;
-        /* Call handler. */
-        if (cdev->handler)
-                cdev->handler(cdev, cdev->private->intparm,
-                              ERR_PTR(-EIO));
-}
-
 static void io_subchannel_terminate_path(struct subchannel *sch, u8 mask)
 {
         struct ccw_device *cdev;
@@ -1409,18 +1100,24 @@ static void io_subchannel_terminate_path(struct subchannel *sch, u8 mask)
         cdev = sch_get_cdev(sch);
         if (!cdev)
                 return;
-        if (check_for_io_on_path(sch, mask)) {
-                if (cdev->private->state == DEV_STATE_ONLINE)
-                        ccw_device_kill_io(cdev);
-                else {
-                        terminate_internal_io(sch, cdev);
-                        /* Re-start path verification. */
-                        dev_fsm_event(cdev, DEV_EVENT_VERIFY);
-                }
-        } else
-                /* trigger path verification. */
-                dev_fsm_event(cdev, DEV_EVENT_VERIFY);
+        if (cio_update_schib(sch))
+                goto err;
+        /* Check for I/O on path. */
+        if (scsw_actl(&sch->schib.scsw) == 0 || sch->schib.pmcw.lpum != mask)
+                goto out;
+        if (cdev->private->state == DEV_STATE_ONLINE) {
+                ccw_device_kill_io(cdev);
+                goto out;
+        }
+        if (cio_clear(sch))
+                goto err;
+out:
+        /* Trigger path verification. */
+        dev_fsm_event(cdev, DEV_EVENT_VERIFY);
+        return;
 
+err:
+        dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
 }
 
 static int io_subchannel_chp_event(struct subchannel *sch,
@@ -1457,46 +1154,41 @@ static int io_subchannel_chp_event(struct subchannel *sch,
         return 0;
 }
 
-static void
-io_subchannel_shutdown(struct subchannel *sch)
+static void io_subchannel_quiesce(struct subchannel *sch)
 {
         struct ccw_device *cdev;
         int ret;
 
+        spin_lock_irq(sch->lock);
         cdev = sch_get_cdev(sch);
-
         if (cio_is_console(sch->schid))
-                return;
+                goto out_unlock;
         if (!sch->schib.pmcw.ena)
-                /* Nothing to do. */
-                return;
+                goto out_unlock;
         ret = cio_disable_subchannel(sch);
         if (ret != -EBUSY)
-                /* Subchannel is disabled, we're done. */
-                return;
-        cdev->private->state = DEV_STATE_QUIESCE;
+                goto out_unlock;
         if (cdev->handler)
-                cdev->handler(cdev, cdev->private->intparm,
-                              ERR_PTR(-EIO));
-        ret = ccw_device_cancel_halt_clear(cdev);
-        if (ret == -EBUSY) {
-                ccw_device_set_timeout(cdev, HZ/10);
-                wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev));
+                cdev->handler(cdev, cdev->private->intparm, ERR_PTR(-EIO));
+        while (ret == -EBUSY) {
+                cdev->private->state = DEV_STATE_QUIESCE;
+                ret = ccw_device_cancel_halt_clear(cdev);
+                if (ret == -EBUSY) {
+                        ccw_device_set_timeout(cdev, HZ/10);
+                        spin_unlock_irq(sch->lock);
+                        wait_event(cdev->private->wait_q,
+                                   cdev->private->state != DEV_STATE_QUIESCE);
+                        spin_lock_irq(sch->lock);
+                }
+                ret = cio_disable_subchannel(sch);
         }
-        cio_disable_subchannel(sch);
+out_unlock:
+        spin_unlock_irq(sch->lock);
 }
 
-static int io_subchannel_get_status(struct subchannel *sch)
+static void io_subchannel_shutdown(struct subchannel *sch)
 {
-        struct schib schib;
-
-        if (stsch(sch->schid, &schib) || !schib.pmcw.dnv)
-                return CIO_GONE;
-        if (sch->schib.pmcw.dnv && (schib.pmcw.dev != sch->schib.pmcw.dev))
-                return CIO_REVALIDATE;
-        if (!sch->lpm)
-                return CIO_NO_PATH;
-        return CIO_OPER;
+        io_subchannel_quiesce(sch);
 }
 
 static int device_is_disconnected(struct ccw_device *cdev)
@@ -1575,20 +1267,16 @@ static void ccw_device_schedule_recovery(void)
 static int purge_fn(struct device *dev, void *data)
 {
         struct ccw_device *cdev = to_ccwdev(dev);
-        struct ccw_device_private *priv = cdev->private;
-        int unreg;
+        struct ccw_dev_id *id = &cdev->private->dev_id;
 
         spin_lock_irq(cdev->ccwlock);
-        unreg = is_blacklisted(priv->dev_id.ssid, priv->dev_id.devno) &&
-                (priv->state == DEV_STATE_OFFLINE);
+        if (is_blacklisted(id->ssid, id->devno) &&
+            (cdev->private->state == DEV_STATE_OFFLINE)) {
+                CIO_MSG_EVENT(3, "ccw: purging 0.%x.%04x\n", id->ssid,
+                              id->devno);
+                ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
+        }
         spin_unlock_irq(cdev->ccwlock);
-        if (!unreg)
-                goto out;
-        CIO_MSG_EVENT(3, "ccw: purging 0.%x.%04x\n", priv->dev_id.ssid,
-                      priv->dev_id.devno);
-        ccw_device_schedule_sch_unregister(cdev);
-
-out:
         /* Abort loop in case of pending signal. */
         if (signal_pending(current))
                 return -EINTR;
@@ -1630,91 +1318,177 @@ void ccw_device_set_notoper(struct ccw_device *cdev)
         cdev->private->state = DEV_STATE_NOT_OPER;
 }
 
-static int io_subchannel_sch_event(struct subchannel *sch, int slow)
+enum io_sch_action {
+        IO_SCH_UNREG,
+        IO_SCH_ORPH_UNREG,
+        IO_SCH_ATTACH,
+        IO_SCH_UNREG_ATTACH,
+        IO_SCH_ORPH_ATTACH,
+        IO_SCH_REPROBE,
+        IO_SCH_VERIFY,
+        IO_SCH_DISC,
+        IO_SCH_NOP,
+};
+
+static enum io_sch_action sch_get_action(struct subchannel *sch)
 {
-        int event, ret, disc;
-        unsigned long flags;
-        enum { NONE, UNREGISTER, UNREGISTER_PROBE, REPROBE, DISC } action;
         struct ccw_device *cdev;
 
-        spin_lock_irqsave(sch->lock, flags);
         cdev = sch_get_cdev(sch);
-        disc = device_is_disconnected(cdev);
-        if (disc && slow) {
-                /* Disconnected devices are evaluated directly only.*/
-                spin_unlock_irqrestore(sch->lock, flags);
-                return 0;
+        if (cio_update_schib(sch)) {
+                /* Not operational. */
+                if (!cdev)
+                        return IO_SCH_UNREG;
+                if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
+                        return IO_SCH_UNREG;
+                return IO_SCH_ORPH_UNREG;
         }
-        /* No interrupt after machine check - kill pending timers. */
-        if (cdev)
-                ccw_device_set_timeout(cdev, 0);
-        if (!disc && !slow) {
-                /* Non-disconnected devices are evaluated on the slow path. */
-                spin_unlock_irqrestore(sch->lock, flags);
-                return -EAGAIN;
+        /* Operational. */
+        if (!cdev)
+                return IO_SCH_ATTACH;
+        if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {
+                if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
+                        return IO_SCH_UNREG_ATTACH;
+                return IO_SCH_ORPH_ATTACH;
         }
-        event = io_subchannel_get_status(sch);
-        CIO_MSG_EVENT(4, "Evaluating schid 0.%x.%04x, event %d, %s, %s path.\n",
-                      sch->schid.ssid, sch->schid.sch_no, event,
-                      disc ? "disconnected" : "normal",
-                      slow ? "slow" : "fast");
-        /* Analyze subchannel status. */
-        action = NONE;
-        switch (event) {
-        case CIO_NO_PATH:
-                if (disc) {
-                        /* Check if paths have become available. */
-                        action = REPROBE;
-                        break;
+        if ((sch->schib.pmcw.pam & sch->opm) == 0) {
+                if (ccw_device_notify(cdev, CIO_NO_PATH) != NOTIFY_OK)
+                        return IO_SCH_UNREG;
+                return IO_SCH_DISC;
+        }
+        if (device_is_disconnected(cdev))
+                return IO_SCH_REPROBE;
+        if (cdev->online)
+                return IO_SCH_VERIFY;
+        return IO_SCH_NOP;
+}
+
+/**
+ * io_subchannel_sch_event - process subchannel event
+ * @sch: subchannel
+ * @process: non-zero if function is called in process context
+ *
+ * An unspecified event occurred for this subchannel. Adjust data according
+ * to the current operational state of the subchannel and device. Return
+ * zero when the event has been handled sufficiently or -EAGAIN when this
+ * function should be called again in process context.
+ */
+static int io_subchannel_sch_event(struct subchannel *sch, int process)
+{
+        unsigned long flags;
+        struct ccw_device *cdev;
+        struct ccw_dev_id dev_id;
+        enum io_sch_action action;
+        int rc = -EAGAIN;
+
+        spin_lock_irqsave(sch->lock, flags);
+        if (!device_is_registered(&sch->dev))
+                goto out_unlock;
+        if (work_pending(&sch->todo_work))
+                goto out_unlock;
+        cdev = sch_get_cdev(sch);
+        if (cdev && work_pending(&cdev->private->todo_work))
+                goto out_unlock;
+        action = sch_get_action(sch);
+        CIO_MSG_EVENT(2, "event: sch 0.%x.%04x, process=%d, action=%d\n",
+                      sch->schid.ssid, sch->schid.sch_no, process,
+                      action);
+        /* Perform immediate actions while holding the lock. */
+        switch (action) {
+        case IO_SCH_REPROBE:
+                /* Trigger device recognition. */
+                ccw_device_trigger_reprobe(cdev);
+                rc = 0;
+                goto out_unlock;
+        case IO_SCH_VERIFY:
+                if (cdev->private->flags.resuming == 1) {
+                        if (cio_enable_subchannel(sch, (u32)(addr_t)sch)) {
+                                ccw_device_set_notoper(cdev);
+                                break;
+                        }
                 }
-                /* fall through */
-        case CIO_GONE:
-                /* Ask driver what to do with device. */
-                if (io_subchannel_notify(sch, event))
-                        action = DISC;
-                else
-                        action = UNREGISTER;
+                /* Trigger path verification. */
+                io_subchannel_verify(sch);
+                rc = 0;
+                goto out_unlock;
+        case IO_SCH_DISC:
+                ccw_device_set_disconnected(cdev);
+                rc = 0;
+                goto out_unlock;
+        case IO_SCH_ORPH_UNREG:
+        case IO_SCH_ORPH_ATTACH:
+                ccw_device_set_disconnected(cdev);
                 break;
-        case CIO_REVALIDATE:
-                /* Device will be removed, so no notify necessary. */
-                if (disc)
-                        /* Reprobe because immediate unregister might block. */
-                        action = REPROBE;
-                else
-                        action = UNREGISTER_PROBE;
+        case IO_SCH_UNREG_ATTACH:
+        case IO_SCH_UNREG:
+                if (cdev)
+                        ccw_device_set_notoper(cdev);
                 break;
-        case CIO_OPER:
-                if (disc)
-                        /* Get device operational again. */
-                        action = REPROBE;
+        case IO_SCH_NOP:
+                rc = 0;
+                goto out_unlock;
+        default:
                 break;
         }
-        /* Perform action. */
-        ret = 0;
+        spin_unlock_irqrestore(sch->lock, flags);
+        /* All other actions require process context. */
+        if (!process)
+                goto out;
+        /* Handle attached ccw device. */
         switch (action) {
-        case UNREGISTER:
-        case UNREGISTER_PROBE:
-                ccw_device_set_notoper(cdev);
-                /* Unregister device (will use subchannel lock). */
-                spin_unlock_irqrestore(sch->lock, flags);
-                css_sch_device_unregister(sch);
-                spin_lock_irqsave(sch->lock, flags);
+        case IO_SCH_ORPH_UNREG:
+        case IO_SCH_ORPH_ATTACH:
+                /* Move ccw device to orphanage. */
+                rc = ccw_device_move_to_orph(cdev);
+                if (rc)
+                        goto out;
                 break;
-        case REPROBE:
-                ccw_device_trigger_reprobe(cdev);
+        case IO_SCH_UNREG_ATTACH:
+                /* Unregister ccw device. */
+                if (!cdev->private->flags.resuming)
+                        ccw_device_unregister(cdev);
                 break;
-        case DISC:
-                ccw_device_set_disconnected(cdev);
+        default:
+                break;
+        }
+        /* Handle subchannel. */
+        switch (action) {
+        case IO_SCH_ORPH_UNREG:
+        case IO_SCH_UNREG:
+                if (!cdev || !cdev->private->flags.resuming)
+                        css_sch_device_unregister(sch);
+                break;
+        case IO_SCH_ORPH_ATTACH:
+        case IO_SCH_UNREG_ATTACH:
+        case IO_SCH_ATTACH:
+                dev_id.ssid = sch->schid.ssid;
+                dev_id.devno = sch->schib.pmcw.dev;
+                cdev = get_ccwdev_by_dev_id(&dev_id);
+                if (!cdev) {
+                        sch_create_and_recog_new_device(sch);
+                        break;
+                }
+                rc = ccw_device_move_to_sch(cdev, sch);
+                if (rc) {
+                        /* Release reference from get_ccwdev_by_dev_id() */
+                        put_device(&cdev->dev);
+                        goto out;
+                }
+                spin_lock_irqsave(sch->lock, flags);
+                ccw_device_trigger_reprobe(cdev);
+                spin_unlock_irqrestore(sch->lock, flags);
+                /* Release reference from get_ccwdev_by_dev_id() */
+                put_device(&cdev->dev);
                 break;
         default:
                 break;
         }
-        spin_unlock_irqrestore(sch->lock, flags);
-        /* Probe if necessary. */
-        if (action == UNREGISTER_PROBE)
-                ret = css_probe_device(sch->schid);
+        return 0;
 
-        return ret;
+out_unlock:
+        spin_unlock_irqrestore(sch->lock, flags);
+out:
+        return rc;
 }
 
 #ifdef CONFIG_CCW_CONSOLE
@@ -1744,10 +1518,8 @@ static int ccw_device_console_enable(struct ccw_device *cdev,
         sch->driver = &io_subchannel_driver;
         /* Initialize the ccw_device structure. */
         cdev->dev.parent= &sch->dev;
-        rc = io_subchannel_recog(cdev, sch);
-        if (rc)
-                return rc;
-
+        sch_set_cdev(sch, cdev);
+        io_subchannel_recog(cdev, sch);
         /* Now wait for the async. recognition to come to an end. */
         spin_lock_irq(cdev->ccwlock);
         while (!dev_fsm_final_state(cdev))
@@ -1763,7 +1535,7 @@ static int ccw_device_console_enable(struct ccw_device *cdev,
         rc = 0;
 out_unlock:
         spin_unlock_irq(cdev->ccwlock);
-        return 0;
+        return rc;
 }
 
 struct ccw_device *
@@ -1919,7 +1691,7 @@ static int ccw_device_pm_prepare(struct device *dev)
 {
         struct ccw_device *cdev = to_ccwdev(dev);
 
-        if (work_pending(&cdev->private->kick_work))
+        if (work_pending(&cdev->private->todo_work))
                 return -EAGAIN;
         /* Fail while device is being set online/offline. */
         if (atomic_read(&cdev->private->onoff))
@@ -2005,119 +1777,117 @@ static int ccw_device_pm_thaw(struct device *dev)
 static void __ccw_device_pm_restore(struct ccw_device *cdev)
 {
         struct subchannel *sch = to_subchannel(cdev->dev.parent);
-        int ret;
 
-        if (cio_is_console(sch->schid))
-                goto out;
+        spin_lock_irq(sch->lock);
+        if (cio_is_console(sch->schid)) {
+                cio_enable_subchannel(sch, (u32)(addr_t)sch);
+                goto out_unlock;
+        }
         /*
          * While we were sleeping, devices may have gone or become
          * available again. Kick re-detection.
          */
-        spin_lock_irq(sch->lock);
         cdev->private->flags.resuming = 1;
-        ret = ccw_device_recognition(cdev);
+        css_schedule_eval(sch->schid);
+        spin_unlock_irq(sch->lock);
+        css_complete_work();
+
+        /* cdev may have been moved to a different subchannel. */
+        sch = to_subchannel(cdev->dev.parent);
+        spin_lock_irq(sch->lock);
+        if (cdev->private->state != DEV_STATE_ONLINE &&
+            cdev->private->state != DEV_STATE_OFFLINE)
+                goto out_unlock;
+
+        ccw_device_recognition(cdev);
         spin_unlock_irq(sch->lock);
-        if (ret) {
-                CIO_MSG_EVENT(0, "Couldn't start recognition for device "
-                              "0.%x.%04x (ret=%d)\n",
-                              cdev->private->dev_id.ssid,
-                              cdev->private->dev_id.devno, ret);
-                spin_lock_irq(sch->lock);
-                cdev->private->state = DEV_STATE_DISCONNECTED;
-                spin_unlock_irq(sch->lock);
-                /* notify driver after the resume cb */
-                goto out;
-        }
         wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev) ||
                    cdev->private->state == DEV_STATE_DISCONNECTED);
+        spin_lock_irq(sch->lock);
 
-out:
+out_unlock:
         cdev->private->flags.resuming = 0;
+        spin_unlock_irq(sch->lock);
 }
 
 static int resume_handle_boxed(struct ccw_device *cdev)
 {
         cdev->private->state = DEV_STATE_BOXED;
-        if (ccw_device_notify(cdev, CIO_BOXED))
+        if (ccw_device_notify(cdev, CIO_BOXED) == NOTIFY_OK)
                 return 0;
-        ccw_device_schedule_sch_unregister(cdev);
+        ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
         return -ENODEV;
 }
 
 static int resume_handle_disc(struct ccw_device *cdev)
 {
         cdev->private->state = DEV_STATE_DISCONNECTED;
-        if (ccw_device_notify(cdev, CIO_GONE))
+        if (ccw_device_notify(cdev, CIO_GONE) == NOTIFY_OK)
                 return 0;
-        ccw_device_schedule_sch_unregister(cdev);
+        ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
         return -ENODEV;
 }
 
 static int ccw_device_pm_restore(struct device *dev)
 {
         struct ccw_device *cdev = to_ccwdev(dev);
-        struct subchannel *sch = to_subchannel(cdev->dev.parent);
-        int ret = 0, cm_enabled;
+        struct subchannel *sch;
+        int ret = 0;
 
         __ccw_device_pm_restore(cdev);
+        sch = to_subchannel(cdev->dev.parent);
         spin_lock_irq(sch->lock);
-        if (cio_is_console(sch->schid)) {
-                cio_enable_subchannel(sch, (u32)(addr_t)sch);
-                spin_unlock_irq(sch->lock);
+        if (cio_is_console(sch->schid))
                 goto out_restore;
-        }
-        cdev->private->flags.donotify = 0;
+
         /* check recognition results */
         switch (cdev->private->state) {
         case DEV_STATE_OFFLINE:
+        case DEV_STATE_ONLINE:
+                cdev->private->flags.donotify = 0;
                 break;
         case DEV_STATE_BOXED:
                 ret = resume_handle_boxed(cdev);
-                spin_unlock_irq(sch->lock);
                 if (ret)
-                        goto out;
+                        goto out_unlock;
                 goto out_restore;
-        case DEV_STATE_DISCONNECTED:
-                goto out_disc_unlock;
         default:
-                goto out_unreg_unlock;
-        }
-        /* check if the device id has changed */
-        if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {
-                CIO_MSG_EVENT(0, "resume: sch 0.%x.%04x: failed (devno "
-                              "changed from %04x to %04x)\n",
-                              sch->schid.ssid, sch->schid.sch_no,
-                              cdev->private->dev_id.devno,
-                              sch->schib.pmcw.dev);
-                goto out_unreg_unlock;
+                ret = resume_handle_disc(cdev);
+                if (ret)
+                        goto out_unlock;
+                goto out_restore;
         }
         /* check if the device type has changed */
         if (!ccw_device_test_sense_data(cdev)) {
                 ccw_device_update_sense_data(cdev);
-                PREPARE_WORK(&cdev->private->kick_work,
-                             ccw_device_do_unbind_bind);
-                queue_work(ccw_device_work, &cdev->private->kick_work);
+                ccw_device_sched_todo(cdev, CDEV_TODO_REBIND);
                 ret = -ENODEV;
                 goto out_unlock;
         }
-        if (!cdev->online) {
-                ret = 0;
+        if (!cdev->online)
                 goto out_unlock;
-        }
-        ret = ccw_device_online(cdev);
-        if (ret)
-                goto out_disc_unlock;
 
-        cm_enabled = cdev->private->cmb != NULL;
+        if (ccw_device_online(cdev)) {
+                ret = resume_handle_disc(cdev);
+                if (ret)
+                        goto out_unlock;
+                goto out_restore;
+        }
         spin_unlock_irq(sch->lock);
-
         wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev));
-        if (cdev->private->state != DEV_STATE_ONLINE) {
-                spin_lock_irq(sch->lock);
-                goto out_disc_unlock;
+        spin_lock_irq(sch->lock);
+
+        if (ccw_device_notify(cdev, CIO_OPER) == NOTIFY_BAD) {
+                ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
+                ret = -ENODEV;
+                goto out_unlock;
         }
-        if (cm_enabled) {
+
+        /* reenable cmf, if needed */
+        if (cdev->private->cmb) {
+                spin_unlock_irq(sch->lock);
                 ret = ccw_set_cmf(cdev, 1);
+                spin_lock_irq(sch->lock);
                 if (ret) {
                         CIO_MSG_EVENT(2, "resume: cdev 0.%x.%04x: cmf failed "
                                       "(rc=%d)\n", cdev->private->dev_id.ssid,
@@ -2127,27 +1897,17 @@ static int ccw_device_pm_restore(struct device *dev)
         }
 
 out_restore:
+        spin_unlock_irq(sch->lock);
         if (cdev->online && cdev->drv && cdev->drv->restore)
                 ret = cdev->drv->restore(cdev);
-out:
         return ret;
 
-out_disc_unlock:
-        ret = resume_handle_disc(cdev);
-        spin_unlock_irq(sch->lock);
-        if (ret)
-                return ret;
-        goto out_restore;
-
-out_unreg_unlock:
-        ccw_device_schedule_sch_unregister(cdev);
-        ret = -ENODEV;
 out_unlock:
         spin_unlock_irq(sch->lock);
         return ret;
 }
 
-static struct dev_pm_ops ccw_pm_ops = {
+static const struct dev_pm_ops ccw_pm_ops = {
         .prepare = ccw_device_pm_prepare,
         .complete = ccw_device_pm_complete,
         .freeze = ccw_device_pm_freeze,
@@ -2205,6 +1965,77 @@ ccw_device_get_subchannel_id(struct ccw_device *cdev)
         return sch->schid;
 }
 
+static void ccw_device_todo(struct work_struct *work)
+{
+        struct ccw_device_private *priv;
+        struct ccw_device *cdev;
+        struct subchannel *sch;
+        enum cdev_todo todo;
+
+        priv = container_of(work, struct ccw_device_private, todo_work);
+        cdev = priv->cdev;
+        sch = to_subchannel(cdev->dev.parent);
+        /* Find out todo. */
+        spin_lock_irq(cdev->ccwlock);
+        todo = priv->todo;
+        priv->todo = CDEV_TODO_NOTHING;
+        CIO_MSG_EVENT(4, "cdev_todo: cdev=0.%x.%04x todo=%d\n",
+                      priv->dev_id.ssid, priv->dev_id.devno, todo);
+        spin_unlock_irq(cdev->ccwlock);
+        /* Perform todo. */
+        switch (todo) {
+        case CDEV_TODO_ENABLE_CMF:
+                cmf_reenable(cdev);
+                break;
+        case CDEV_TODO_REBIND:
+                ccw_device_do_unbind_bind(cdev);
+                break;
+        case CDEV_TODO_REGISTER:
+                io_subchannel_register(cdev);
+                break;
+        case CDEV_TODO_UNREG_EVAL:
+                if (!sch_is_pseudo_sch(sch))
+                        css_schedule_eval(sch->schid);
+                /* fall-through */
+        case CDEV_TODO_UNREG:
+                if (sch_is_pseudo_sch(sch))
+                        ccw_device_unregister(cdev);
+                else
+                        ccw_device_call_sch_unregister(cdev);
+                break;
+        default:
+                break;
+        }
+        /* Release workqueue ref. */
+        put_device(&cdev->dev);
+}
+
+/**
+ * ccw_device_sched_todo - schedule ccw device operation
+ * @cdev: ccw device
+ * @todo: todo
+ *
+ * Schedule the operation identified by @todo to be performed on the slow path
+ * workqueue. Do nothing if another operation with higher priority is already
+ * scheduled. Needs to be called with ccwdev lock held.
+ */
+void ccw_device_sched_todo(struct ccw_device *cdev, enum cdev_todo todo)
+{
+        CIO_MSG_EVENT(4, "cdev_todo: sched cdev=0.%x.%04x todo=%d\n",
+                      cdev->private->dev_id.ssid, cdev->private->dev_id.devno,
+                      todo);
+        if (cdev->private->todo >= todo)
+                return;
+        cdev->private->todo = todo;
+        /* Get workqueue ref. */
+        if (!get_device(&cdev->dev))
+                return;
+        if (!queue_work(cio_work_q, &cdev->private->todo_work)) {
+                /* Already queued, release workqueue ref. */
+                put_device(&cdev->dev);
+        }
+}
+
 MODULE_LICENSE("GPL");
 EXPORT_SYMBOL(ccw_device_set_online);
 EXPORT_SYMBOL(ccw_device_set_offline);
@@ -2212,5 +2043,4 @@ EXPORT_SYMBOL(ccw_driver_register);
 EXPORT_SYMBOL(ccw_driver_unregister);
 EXPORT_SYMBOL(get_ccwdev_by_busid);
 EXPORT_SYMBOL(ccw_bus_type);
-EXPORT_SYMBOL(ccw_device_work);
 EXPORT_SYMBOL_GPL(ccw_device_get_subchannel_id);
diff --git a/drivers/s390/cio/device.h b/drivers/s390/cio/device.h
index 246c6482842c..379de2d1ec49 100644
--- a/drivers/s390/cio/device.h
+++ b/drivers/s390/cio/device.h
@@ -4,7 +4,7 @@
 #include <asm/ccwdev.h>
 #include <asm/atomic.h>
 #include <linux/wait.h>
-
+#include <linux/notifier.h>
 #include "io_sch.h"
 
 /*
@@ -21,7 +21,6 @@ enum dev_state {
         DEV_STATE_DISBAND_PGID,
         DEV_STATE_BOXED,
         /* states to wait for i/o completion before doing something */
-        DEV_STATE_CLEAR_VERIFY,
         DEV_STATE_TIMEOUT_KILL,
         DEV_STATE_QUIESCE,
         /* special states for devices gone not operational */
@@ -29,6 +28,7 @@ enum dev_state {
         DEV_STATE_DISCONNECTED_SENSE_ID,
         DEV_STATE_CMFCHANGE,
         DEV_STATE_CMFUPDATE,
+        DEV_STATE_STEAL_LOCK,
         /* last element! */
         NR_DEV_STATES
 };
@@ -71,7 +71,6 @@ dev_fsm_final_state(struct ccw_device *cdev)
                 cdev->private->state == DEV_STATE_BOXED);
 }
 
-extern struct workqueue_struct *ccw_device_work;
 extern wait_queue_head_t ccw_device_init_wq;
 extern atomic_t ccw_device_init_count;
 int __init io_subchannel_init(void);
@@ -81,17 +80,16 @@ void io_subchannel_init_config(struct subchannel *sch);
 
 int ccw_device_cancel_halt_clear(struct ccw_device *);
 
-void ccw_device_do_unbind_bind(struct work_struct *);
-void ccw_device_move_to_orphanage(struct work_struct *);
 int ccw_device_is_orphan(struct ccw_device *);
 
-int ccw_device_recognition(struct ccw_device *);
+void ccw_device_recognition(struct ccw_device *);
 int ccw_device_online(struct ccw_device *);
 int ccw_device_offline(struct ccw_device *);
 void ccw_device_update_sense_data(struct ccw_device *);
 int ccw_device_test_sense_data(struct ccw_device *);
 void ccw_device_schedule_sch_unregister(struct ccw_device *);
 int ccw_purge_blacklisted(void);
+void ccw_device_sched_todo(struct ccw_device *cdev, enum cdev_todo todo);
 
 /* Function prototypes for device status and basic sense stuff. */
 void ccw_device_accumulate_irb(struct ccw_device *, struct irb *);
@@ -99,24 +97,28 @@ void ccw_device_accumulate_basic_sense(struct ccw_device *, struct irb *);
 int ccw_device_accumulate_and_sense(struct ccw_device *, struct irb *);
 int ccw_device_do_sense(struct ccw_device *, struct irb *);
 
+/* Function prototype for internal request handling. */
+int lpm_adjust(int lpm, int mask);
+void ccw_request_start(struct ccw_device *);
+int ccw_request_cancel(struct ccw_device *cdev);
+void ccw_request_handler(struct ccw_device *cdev);
+void ccw_request_timeout(struct ccw_device *cdev);
+void ccw_request_notoper(struct ccw_device *cdev);
+
 /* Function prototypes for sense id stuff. */
 void ccw_device_sense_id_start(struct ccw_device *);
-void ccw_device_sense_id_irq(struct ccw_device *, enum dev_event);
 void ccw_device_sense_id_done(struct ccw_device *, int);
 
 /* Function prototypes for path grouping stuff. */
-void ccw_device_sense_pgid_start(struct ccw_device *);
-void ccw_device_sense_pgid_irq(struct ccw_device *, enum dev_event);
-void ccw_device_sense_pgid_done(struct ccw_device *, int);
-
 void ccw_device_verify_start(struct ccw_device *);
-void ccw_device_verify_irq(struct ccw_device *, enum dev_event);
 void ccw_device_verify_done(struct ccw_device *, int);
 
 void ccw_device_disband_start(struct ccw_device *);
-void ccw_device_disband_irq(struct ccw_device *, enum dev_event);
 void ccw_device_disband_done(struct ccw_device *, int);
 
+void ccw_device_stlck_start(struct ccw_device *, void *, void *, void *);
+void ccw_device_stlck_done(struct ccw_device *, void *, int);
+
 int ccw_device_call_handler(struct ccw_device *);
 
 int ccw_device_stlck(struct ccw_device *);
diff --git a/drivers/s390/cio/device_fsm.c b/drivers/s390/cio/device_fsm.c
index b9613d7df9ef..c9b852647f01 100644
--- a/drivers/s390/cio/device_fsm.c
+++ b/drivers/s390/cio/device_fsm.c
@@ -45,7 +45,7 @@ static void ccw_timeout_log(struct ccw_device *cdev)
         sch = to_subchannel(cdev->dev.parent);
         private = to_io_private(sch);
         orb = &private->orb;
-        cc = stsch(sch->schid, &schib);
+        cc = stsch_err(sch->schid, &schib);
 
         printk(KERN_WARNING "cio: ccw device timeout occurred at %llx, "
                "device information:\n", get_clock());
@@ -229,8 +229,8 @@ ccw_device_recog_done(struct ccw_device *cdev, int state)
 
         sch = to_subchannel(cdev->dev.parent);
 
-        ccw_device_set_timeout(cdev, 0);
-        cio_disable_subchannel(sch);
+        if (cio_disable_subchannel(sch))
+                state = DEV_STATE_NOT_OPER;
         /*
          * Now that we tried recognition, we have performed device selection
          * through ssch() and the path information is up to date.
@@ -263,22 +263,10 @@ ccw_device_recog_done(struct ccw_device *cdev, int state)
         }
         switch (state) {
         case DEV_STATE_NOT_OPER:
-                CIO_MSG_EVENT(2, "SenseID : unknown device %04x on "
-                              "subchannel 0.%x.%04x\n",
-                              cdev->private->dev_id.devno,
-                              sch->schid.ssid, sch->schid.sch_no);
                 break;
         case DEV_STATE_OFFLINE:
                 if (!cdev->online) {
                         ccw_device_update_sense_data(cdev);
-                        /* Issue device info message. */
-                        CIO_MSG_EVENT(4, "SenseID : device 0.%x.%04x reports: "
-                                      "CU  Type/Mod = %04X/%02X, Dev Type/Mod "
-                                      "= %04X/%02X\n",
-                                      cdev->private->dev_id.ssid,
-                                      cdev->private->dev_id.devno,
-                                      cdev->id.cu_type, cdev->id.cu_model,
-                                      cdev->id.dev_type, cdev->id.dev_model);
                         break;
                 }
                 cdev->private->state = DEV_STATE_OFFLINE;
@@ -289,16 +277,10 @@ ccw_device_recog_done(struct ccw_device *cdev, int state)
                         wake_up(&cdev->private->wait_q);
                 } else {
                         ccw_device_update_sense_data(cdev);
-                        PREPARE_WORK(&cdev->private->kick_work,
-                                     ccw_device_do_unbind_bind);
-                        queue_work(ccw_device_work, &cdev->private->kick_work);
+                        ccw_device_sched_todo(cdev, CDEV_TODO_REBIND);
                 }
                 return;
         case DEV_STATE_BOXED:
-                CIO_MSG_EVENT(0, "SenseID : boxed device %04x on "
-                              " subchannel 0.%x.%04x\n",
-                              cdev->private->dev_id.devno,
-                              sch->schid.ssid, sch->schid.sch_no);
                 if (cdev->id.cu_type != 0) { /* device was recognized before */
                         cdev->private->flags.recog_done = 1;
                         cdev->private->state = DEV_STATE_BOXED;
@@ -331,40 +313,50 @@ ccw_device_sense_id_done(struct ccw_device *cdev, int err)
         }
 }
 
+/**
+  * ccw_device_notify() - inform the device's driver about an event
+  * @cdev: device for which an event occured
+  * @event: event that occurred
+  *
+  * Returns:
+  *   -%EINVAL if the device is offline or has no driver.
+  *   -%EOPNOTSUPP if the device's driver has no notifier registered.
+  *   %NOTIFY_OK if the driver wants to keep the device.
+  *   %NOTIFY_BAD if the driver doesn't want to keep the device.
+  */
 int ccw_device_notify(struct ccw_device *cdev, int event)
 {
+        int ret = -EINVAL;
+
         if (!cdev->drv)
-                return 0;
+                goto out;
         if (!cdev->online)
-                return 0;
+                goto out;
         CIO_MSG_EVENT(2, "notify called for 0.%x.%04x, event=%d\n",
                       cdev->private->dev_id.ssid, cdev->private->dev_id.devno,
                       event);
-        return cdev->drv->notify ? cdev->drv->notify(cdev, event) : 0;
-}
-
-static void cmf_reenable_delayed(struct work_struct *work)
-{
-        struct ccw_device_private *priv;
-        struct ccw_device *cdev;
-
-        priv = container_of(work, struct ccw_device_private, kick_work);
-        cdev = priv->cdev;
-        cmf_reenable(cdev);
+        if (!cdev->drv->notify) {
+                ret = -EOPNOTSUPP;
+                goto out;
+        }
+        if (cdev->drv->notify(cdev, event))
+                ret = NOTIFY_OK;
+        else
+                ret = NOTIFY_BAD;
+out:
+        return ret;
 }
 
 static void ccw_device_oper_notify(struct ccw_device *cdev)
 {
-        if (ccw_device_notify(cdev, CIO_OPER)) {
+        if (ccw_device_notify(cdev, CIO_OPER) == NOTIFY_OK) {
                 /* Reenable channel measurements, if needed. */
-                PREPARE_WORK(&cdev->private->kick_work, cmf_reenable_delayed);
-                queue_work(ccw_device_work, &cdev->private->kick_work);
+                ccw_device_sched_todo(cdev, CDEV_TODO_ENABLE_CMF);
                 return;
         }
         /* Driver doesn't want device back. */
         ccw_device_set_notoper(cdev);
-        PREPARE_WORK(&cdev->private->kick_work, ccw_device_do_unbind_bind);
-        queue_work(ccw_device_work, &cdev->private->kick_work);
+        ccw_device_sched_todo(cdev, CDEV_TODO_REBIND);
 }
 
 /*
@@ -391,15 +383,16 @@ ccw_device_done(struct ccw_device *cdev, int 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);
+                if (cdev->online &&
+                    ccw_device_notify(cdev, CIO_BOXED) != NOTIFY_OK)
+                        ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
                 cdev->private->flags.donotify = 0;
                 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);
+                if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
+                        ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
                 else
                         ccw_device_set_disconnected(cdev);
                 cdev->private->flags.donotify = 0;
@@ -408,8 +401,8 @@ ccw_device_done(struct ccw_device *cdev, int state)
                 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);
+                if (ccw_device_notify(cdev, CIO_NO_PATH) != NOTIFY_OK)
+                        ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
                 else
                         ccw_device_set_disconnected(cdev);
                 cdev->private->flags.donotify = 0;
@@ -425,107 +418,12 @@ ccw_device_done(struct ccw_device *cdev, int state)
         wake_up(&cdev->private->wait_q);
 }
 
-static int cmp_pgid(struct pgid *p1, struct pgid *p2)
-{
-        char *c1;
-        char *c2;
-
-        c1 = (char *)p1;
-        c2 = (char *)p2;
-
-        return memcmp(c1 + 1, c2 + 1, sizeof(struct pgid) - 1);
-}
-
-static void __ccw_device_get_common_pgid(struct ccw_device *cdev)
-{
-        int i;
-        int last;
-
-        last = 0;
-        for (i = 0; i < 8; i++) {
-                if (cdev->private->pgid[i].inf.ps.state1 == SNID_STATE1_RESET)
-                        /* No PGID yet */
-                        continue;
-                if (cdev->private->pgid[last].inf.ps.state1 ==
-                    SNID_STATE1_RESET) {
-                        /* First non-zero PGID */
-                        last = i;
-                        continue;
-                }
-                if (cmp_pgid(&cdev->private->pgid[i],
-                             &cdev->private->pgid[last]) == 0)
-                        /* Non-conflicting PGIDs */
-                        continue;
-
-                /* PGID mismatch, can't pathgroup. */
-                CIO_MSG_EVENT(0, "SNID - pgid mismatch for device "
-                              "0.%x.%04x, can't pathgroup\n",
-                              cdev->private->dev_id.ssid,
-                              cdev->private->dev_id.devno);
-                cdev->private->options.pgroup = 0;
-                return;
-        }
-        if (cdev->private->pgid[last].inf.ps.state1 ==
-            SNID_STATE1_RESET)
-                /* No previous pgid found */
-                memcpy(&cdev->private->pgid[0],
-                       &channel_subsystems[0]->global_pgid,
-                       sizeof(struct pgid));
-        else
-                /* Use existing pgid */
-                memcpy(&cdev->private->pgid[0], &cdev->private->pgid[last],
-                       sizeof(struct pgid));
-}
-
-/*
- * Function called from device_pgid.c after sense path ground has completed.
- */
-void
-ccw_device_sense_pgid_done(struct ccw_device *cdev, int err)
-{
-        struct subchannel *sch;
-
-        sch = to_subchannel(cdev->dev.parent);
-        switch (err) {
-        case -EOPNOTSUPP: /* path grouping not supported, use nop instead. */
-                cdev->private->options.pgroup = 0;
-                break;
-        case 0: /* success */
-        case -EACCES: /* partial success, some paths not operational */
-                /* Check if all pgids are equal or 0. */
-                __ccw_device_get_common_pgid(cdev);
-                break;
-        case -ETIME:            /* Sense path group id stopped by timeout. */
-        case -EUSERS:           /* device is reserved for someone else. */
-                ccw_device_done(cdev, DEV_STATE_BOXED);
-                return;
-        default:
-                ccw_device_done(cdev, DEV_STATE_NOT_OPER);
-                return;
-        }
-        /* Start Path Group verification. */
-        cdev->private->state = DEV_STATE_VERIFY;
-        cdev->private->flags.doverify = 0;
-        ccw_device_verify_start(cdev);
-}
-
 /*
  * Start device recognition.
  */
-int
-ccw_device_recognition(struct ccw_device *cdev)
+void ccw_device_recognition(struct ccw_device *cdev)
 {
-        struct subchannel *sch;
-        int ret;
-
-        sch = to_subchannel(cdev->dev.parent);
-        ret = cio_enable_subchannel(sch, (u32)(addr_t)sch);
-        if (ret != 0)
-                /* Couldn't enable the subchannel for i/o. Sick device. */
-                return ret;
-
-        /* After 60s the device recognition is considered to have failed. */
-        ccw_device_set_timeout(cdev, 60*HZ);
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
 
         /*
          * We used to start here with a sense pgid to find out whether a device
@@ -537,32 +435,33 @@ ccw_device_recognition(struct ccw_device *cdev)
          */
         cdev->private->flags.recog_done = 0;
         cdev->private->state = DEV_STATE_SENSE_ID;
+        if (cio_enable_subchannel(sch, (u32) (addr_t) sch)) {
+                ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
+                return;
+        }
         ccw_device_sense_id_start(cdev);
-        return 0;
 }
 
 /*
- * Handle timeout in device recognition.
+ * Handle events for states that use the ccw request infrastructure.
  */
-static void
-ccw_device_recog_timeout(struct ccw_device *cdev, enum dev_event dev_event)
+static void ccw_device_request_event(struct ccw_device *cdev, enum dev_event e)
 {
-        int ret;
-
-        ret = ccw_device_cancel_halt_clear(cdev);
-        switch (ret) {
-        case 0:
-                ccw_device_recog_done(cdev, DEV_STATE_BOXED);
+        switch (e) {
+        case DEV_EVENT_NOTOPER:
+                ccw_request_notoper(cdev);
                 break;
-        case -ENODEV:
-                ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
+        case DEV_EVENT_INTERRUPT:
+                ccw_request_handler(cdev);
+                break;
+        case DEV_EVENT_TIMEOUT:
+                ccw_request_timeout(cdev);
                 break;
         default:
-                ccw_device_set_timeout(cdev, 3*HZ);
+                break;
         }
 }
 
-
 void
 ccw_device_verify_done(struct ccw_device *cdev, int err)
 {
@@ -571,21 +470,18 @@ ccw_device_verify_done(struct ccw_device *cdev, int err)
         sch = to_subchannel(cdev->dev.parent);
         /* Update schib - pom may have changed. */
         if (cio_update_schib(sch)) {
-                cdev->private->flags.donotify = 0;
-                ccw_device_done(cdev, DEV_STATE_NOT_OPER);
-                return;
+                err = -ENODEV;
+                goto callback;
         }
         /* Update lpm with verified path mask. */
         sch->lpm = sch->vpm;
         /* Repeat path verification? */
         if (cdev->private->flags.doverify) {
-                cdev->private->flags.doverify = 0;
                 ccw_device_verify_start(cdev);
                 return;
         }
+callback:
         switch (err) {
-        case -EOPNOTSUPP: /* path grouping not supported, just set online. */
-                cdev->private->options.pgroup = 0;
         case 0:
                 ccw_device_done(cdev, DEV_STATE_ONLINE);
                 /* Deliver fake irb to device driver, if needed. */
@@ -604,18 +500,20 @@ ccw_device_verify_done(struct ccw_device *cdev, int err)
                 }
                 break;
         case -ETIME:
+        case -EUSERS:
                 /* Reset oper notify indication after verify error. */
                 cdev->private->flags.donotify = 0;
                 ccw_device_done(cdev, DEV_STATE_BOXED);
                 break;
+        case -EACCES:
+                /* Reset oper notify indication after verify error. */
+                cdev->private->flags.donotify = 0;
+                ccw_device_done(cdev, DEV_STATE_DISCONNECTED);
+                break;
         default:
                 /* Reset oper notify indication after verify error. */
                 cdev->private->flags.donotify = 0;
-                if (cdev->online) {
-                        ccw_device_set_timeout(cdev, 0);
-                        dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
-                } else
-                        ccw_device_done(cdev, DEV_STATE_NOT_OPER);
+                ccw_device_done(cdev, DEV_STATE_NOT_OPER);
                 break;
         }
 }
@@ -640,17 +538,9 @@ ccw_device_online(struct ccw_device *cdev)
                         dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
                 return ret;
         }
-        /* Do we want to do path grouping? */
-        if (!cdev->private->options.pgroup) {
-                /* Start initial path verification. */
-                cdev->private->state = DEV_STATE_VERIFY;
-                cdev->private->flags.doverify = 0;
-                ccw_device_verify_start(cdev);
-                return 0;
-        }
-        /* Do a SensePGID first. */
-        cdev->private->state = DEV_STATE_SENSE_PGID;
-        ccw_device_sense_pgid_start(cdev);
+        /* Start initial path verification. */
+        cdev->private->state = DEV_STATE_VERIFY;
+        ccw_device_verify_start(cdev);
         return 0;
 }
 
@@ -666,7 +556,6 @@ ccw_device_disband_done(struct ccw_device *cdev, int err)
                 break;
         default:
                 cdev->private->flags.donotify = 0;
-                dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
                 break;
         }
@@ -703,7 +592,7 @@ ccw_device_offline(struct ccw_device *cdev)
         if (cdev->private->state != DEV_STATE_ONLINE)
                 return -EINVAL;
         /* Are we doing path grouping? */
-        if (!cdev->private->options.pgroup) {
+        if (!cdev->private->flags.pgroup) {
                 /* No, set state offline immediately. */
                 ccw_device_done(cdev, DEV_STATE_OFFLINE);
                 return 0;
@@ -715,43 +604,13 @@ ccw_device_offline(struct ccw_device *cdev)
 }
 
 /*
- * Handle timeout in device online/offline process.
- */
-static void
-ccw_device_onoff_timeout(struct ccw_device *cdev, enum dev_event dev_event)
-{
-        int ret;
-
-        ret = ccw_device_cancel_halt_clear(cdev);
-        switch (ret) {
-        case 0:
-                ccw_device_done(cdev, DEV_STATE_BOXED);
-                break;
-        case -ENODEV:
-                ccw_device_done(cdev, DEV_STATE_NOT_OPER);
-                break;
-        default:
-                ccw_device_set_timeout(cdev, 3*HZ);
-        }
-}
-
-/*
- * Handle not oper event in device recognition.
- */
-static void
-ccw_device_recog_notoper(struct ccw_device *cdev, enum dev_event dev_event)
-{
-        ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
-}
-
-/*
  * Handle not operational event in non-special state.
  */
 static void ccw_device_generic_notoper(struct ccw_device *cdev,
                                        enum dev_event dev_event)
 {
-        if (!ccw_device_notify(cdev, CIO_GONE))
-                ccw_device_schedule_sch_unregister(cdev);
+        if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
+                ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
         else
                 ccw_device_set_disconnected(cdev);
 }
@@ -802,11 +661,27 @@ ccw_device_online_verify(struct ccw_device *cdev, enum dev_event dev_event)
         }
         /* Device is idle, we can do the path verification. */
         cdev->private->state = DEV_STATE_VERIFY;
-        cdev->private->flags.doverify = 0;
         ccw_device_verify_start(cdev);
 }
 
 /*
+ * Handle path verification event in boxed state.
+ */
+static void ccw_device_boxed_verify(struct ccw_device *cdev,
+                                    enum dev_event dev_event)
+{
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+
+        if (cdev->online) {
+                if (cio_enable_subchannel(sch, (u32) (addr_t) sch))
+                        ccw_device_done(cdev, DEV_STATE_NOT_OPER);
+                else
+                        ccw_device_online_verify(cdev, dev_event);
+        } else
+                css_schedule_eval(sch->schid);
+}
+
+/*
  * Got an interrupt for a normal io (state online).
  */
 static void
@@ -815,7 +690,7 @@ ccw_device_irq(struct ccw_device *cdev, enum dev_event dev_event)
         struct irb *irb;
         int is_cmd;
 
-        irb = (struct irb *) __LC_IRB;
+        irb = (struct irb *)&S390_lowcore.irb;
         is_cmd = !scsw_is_tm(&irb->scsw);
         /* Check for unsolicited interrupt. */
         if (!scsw_is_solicited(&irb->scsw)) {
@@ -880,7 +755,7 @@ ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event)
 {
         struct irb *irb;
 
-        irb = (struct irb *) __LC_IRB;
+        irb = (struct irb *)&S390_lowcore.irb;
         /* Check for unsolicited interrupt. */
         if (scsw_stctl(&irb->scsw) ==
             (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
@@ -904,12 +779,6 @@ ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event)
          */
         if (scsw_fctl(&irb->scsw) &
             (SCSW_FCTL_CLEAR_FUNC | SCSW_FCTL_HALT_FUNC)) {
-                /* Retry Basic Sense if requested. */
-                if (cdev->private->flags.intretry) {
-                        cdev->private->flags.intretry = 0;
-                        ccw_device_do_sense(cdev, irb);
-                        return;
-                }
                 cdev->private->flags.dosense = 0;
                 memset(&cdev->private->irb, 0, sizeof(struct irb));
                 ccw_device_accumulate_irb(cdev, irb);
@@ -933,21 +802,6 @@ call_handler:
 }
 
 static void
-ccw_device_clear_verify(struct ccw_device *cdev, enum dev_event dev_event)
-{
-        struct irb *irb;
-
-        irb = (struct irb *) __LC_IRB;
-        /* Accumulate status. We don't do basic sense. */
-        ccw_device_accumulate_irb(cdev, irb);
-        /* Remember to clear irb to avoid residuals. */
-        memset(&cdev->private->irb, 0, sizeof(struct irb));
-        /* Try to start delayed device verification. */
-        ccw_device_online_verify(cdev, 0);
-        /* Note: Don't call handler for cio initiated clear! */
-}
-
-static void
 ccw_device_killing_irq(struct ccw_device *cdev, enum dev_event dev_event)
 {
         struct subchannel *sch;
@@ -1004,32 +858,6 @@ ccw_device_delay_verify(struct ccw_device *cdev, enum dev_event dev_event)
 }
 
 static void
-ccw_device_stlck_done(struct ccw_device *cdev, enum dev_event dev_event)
-{
-        struct irb *irb;
-
-        switch (dev_event) {
-        case DEV_EVENT_INTERRUPT:
-                irb = (struct irb *) __LC_IRB;
-                /* Check for unsolicited interrupt. */
-                if ((scsw_stctl(&irb->scsw) ==
-                     (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) &&
-                    (!scsw_cc(&irb->scsw)))
-                        /* FIXME: we should restart stlck here, but this
-                         * is extremely unlikely ... */
-                        goto out_wakeup;
-
-                ccw_device_accumulate_irb(cdev, irb);
-                /* We don't care about basic sense etc. */
-                break;
-        default: /* timeout */
-                break;
-        }
-out_wakeup:
-        wake_up(&cdev->private->wait_q);
-}
-
-static void
 ccw_device_start_id(struct ccw_device *cdev, enum dev_event dev_event)
 {
         struct subchannel *sch;
@@ -1038,10 +866,6 @@ ccw_device_start_id(struct ccw_device *cdev, enum dev_event dev_event)
         if (cio_enable_subchannel(sch, (u32)(addr_t)sch) != 0)
                 /* Couldn't enable the subchannel for i/o. Sick device. */
                 return;
-
-        /* After 60s the device recognition is considered to have failed. */
-        ccw_device_set_timeout(cdev, 60*HZ);
-
         cdev->private->state = DEV_STATE_DISCONNECTED_SENSE_ID;
         ccw_device_sense_id_start(cdev);
 }
@@ -1072,22 +896,20 @@ void ccw_device_trigger_reprobe(struct ccw_device *cdev)
 
         /* We should also udate ssd info, but this has to wait. */
         /* Check if this is another device which appeared on the same sch. */
-        if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {
-                PREPARE_WORK(&cdev->private->kick_work,
-                             ccw_device_move_to_orphanage);
-                queue_work(slow_path_wq, &cdev->private->kick_work);
-        } else
+        if (sch->schib.pmcw.dev != cdev->private->dev_id.devno)
+                css_schedule_eval(sch->schid);
+        else
                 ccw_device_start_id(cdev, 0);
 }
 
-static void
-ccw_device_offline_irq(struct ccw_device *cdev, enum dev_event dev_event)
+static void ccw_device_disabled_irq(struct ccw_device *cdev,
+                                    enum dev_event dev_event)
 {
         struct subchannel *sch;
 
         sch = to_subchannel(cdev->dev.parent);
         /*
-         * An interrupt in state offline means a previous disable was not
+         * An interrupt in a disabled state means a previous disable was not
          * successful - should not happen, but we try to disable again.
          */
         cio_disable_subchannel(sch);
@@ -1113,10 +935,7 @@ static void
 ccw_device_quiesce_done(struct ccw_device *cdev, enum dev_event dev_event)
 {
         ccw_device_set_timeout(cdev, 0);
-        if (dev_event == DEV_EVENT_NOTOPER)
-                cdev->private->state = DEV_STATE_NOT_OPER;
-        else
-                cdev->private->state = DEV_STATE_OFFLINE;
+        cdev->private->state = DEV_STATE_NOT_OPER;
         wake_up(&cdev->private->wait_q);
 }
 
@@ -1126,17 +945,11 @@ ccw_device_quiesce_timeout(struct ccw_device *cdev, enum dev_event dev_event)
         int ret;
 
         ret = ccw_device_cancel_halt_clear(cdev);
-        switch (ret) {
-        case 0:
-                cdev->private->state = DEV_STATE_OFFLINE;
-                wake_up(&cdev->private->wait_q);
-                break;
-        case -ENODEV:
+        if (ret == -EBUSY) {
+                ccw_device_set_timeout(cdev, HZ/10);
+        } else {
                 cdev->private->state = DEV_STATE_NOT_OPER;
                 wake_up(&cdev->private->wait_q);
-                break;
-        default:
-                ccw_device_set_timeout(cdev, HZ/10);
         }
 }
 
@@ -1150,50 +963,37 @@ ccw_device_nop(struct ccw_device *cdev, enum dev_event dev_event)
 }
 
 /*
- * Bug operation action. 
- */
-static void
-ccw_device_bug(struct ccw_device *cdev, enum dev_event dev_event)
-{
-        CIO_MSG_EVENT(0, "Internal state [%i][%i] not handled for device "
-                      "0.%x.%04x\n", cdev->private->state, dev_event,
-                      cdev->private->dev_id.ssid,
-                      cdev->private->dev_id.devno);
-        BUG();
-}
-
-/*
  * device statemachine
  */
 fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
         [DEV_STATE_NOT_OPER] = {
                 [DEV_EVENT_NOTOPER]     = ccw_device_nop,
-                [DEV_EVENT_INTERRUPT]   = ccw_device_bug,
+                [DEV_EVENT_INTERRUPT]   = ccw_device_disabled_irq,
                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
         },
         [DEV_STATE_SENSE_PGID] = {
-                [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
-                [DEV_EVENT_INTERRUPT]   = ccw_device_sense_pgid_irq,
-                [DEV_EVENT_TIMEOUT]     = ccw_device_onoff_timeout,
+                [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
+                [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
+                [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
         },
         [DEV_STATE_SENSE_ID] = {
-                [DEV_EVENT_NOTOPER]     = ccw_device_recog_notoper,
-                [DEV_EVENT_INTERRUPT]   = ccw_device_sense_id_irq,
-                [DEV_EVENT_TIMEOUT]     = ccw_device_recog_timeout,
+                [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
+                [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
+                [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
         },
         [DEV_STATE_OFFLINE] = {
                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
-                [DEV_EVENT_INTERRUPT]   = ccw_device_offline_irq,
+                [DEV_EVENT_INTERRUPT]   = ccw_device_disabled_irq,
                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
                 [DEV_EVENT_VERIFY]      = ccw_device_offline_verify,
         },
         [DEV_STATE_VERIFY] = {
-                [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
-                [DEV_EVENT_INTERRUPT]   = ccw_device_verify_irq,
-                [DEV_EVENT_TIMEOUT]     = ccw_device_onoff_timeout,
+                [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
+                [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
+                [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
                 [DEV_EVENT_VERIFY]      = ccw_device_delay_verify,
         },
         [DEV_STATE_ONLINE] = {
@@ -1209,24 +1009,18 @@ fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
                 [DEV_EVENT_VERIFY]      = ccw_device_online_verify,
         },
         [DEV_STATE_DISBAND_PGID] = {
-                [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
-                [DEV_EVENT_INTERRUPT]   = ccw_device_disband_irq,
-                [DEV_EVENT_TIMEOUT]     = ccw_device_onoff_timeout,
+                [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
+                [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
+                [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
         },
         [DEV_STATE_BOXED] = {
                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
-                [DEV_EVENT_INTERRUPT]   = ccw_device_stlck_done,
-                [DEV_EVENT_TIMEOUT]     = ccw_device_stlck_done,
-                [DEV_EVENT_VERIFY]      = ccw_device_nop,
-        },
-        /* states to wait for i/o completion before doing something */
-        [DEV_STATE_CLEAR_VERIFY] = {
-                [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
-                [DEV_EVENT_INTERRUPT]   = ccw_device_clear_verify,
+                [DEV_EVENT_INTERRUPT]   = ccw_device_nop,
                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
-                [DEV_EVENT_VERIFY]      = ccw_device_nop,
+                [DEV_EVENT_VERIFY]      = ccw_device_boxed_verify,
         },
+        /* states to wait for i/o completion before doing something */
         [DEV_STATE_TIMEOUT_KILL] = {
                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
                 [DEV_EVENT_INTERRUPT]   = ccw_device_killing_irq,
@@ -1243,13 +1037,13 @@ fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
         [DEV_STATE_DISCONNECTED] = {
                 [DEV_EVENT_NOTOPER]     = ccw_device_nop,
                 [DEV_EVENT_INTERRUPT]   = ccw_device_start_id,
-                [DEV_EVENT_TIMEOUT]     = ccw_device_bug,
+                [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
                 [DEV_EVENT_VERIFY]      = ccw_device_start_id,
         },
         [DEV_STATE_DISCONNECTED_SENSE_ID] = {
-                [DEV_EVENT_NOTOPER]     = ccw_device_recog_notoper,
-                [DEV_EVENT_INTERRUPT]   = ccw_device_sense_id_irq,
-                [DEV_EVENT_TIMEOUT]     = ccw_device_recog_timeout,
+                [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
+                [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
+                [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
         },
         [DEV_STATE_CMFCHANGE] = {
@@ -1264,6 +1058,12 @@ fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
                 [DEV_EVENT_TIMEOUT]     = ccw_device_update_cmfblock,
                 [DEV_EVENT_VERIFY]      = ccw_device_update_cmfblock,
         },
+        [DEV_STATE_STEAL_LOCK] = {
+                [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
+                [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
+                [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
+                [DEV_EVENT_VERIFY]      = ccw_device_nop,
+        },
 };
 
 EXPORT_SYMBOL_GPL(ccw_device_set_timeout);
diff --git a/drivers/s390/cio/device_id.c b/drivers/s390/cio/device_id.c
index 1bdaa614e34f..78a0b43862c5 100644
--- a/drivers/s390/cio/device_id.c
+++ b/drivers/s390/cio/device_id.c
@@ -1,40 +1,39 @@
 /*
- * drivers/s390/cio/device_id.c
+ *  CCW device SENSE ID I/O handling.
  *
- *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
- *                       IBM Corporation
- *    Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
- *               Martin Schwidefsky (schwidefsky@de.ibm.com)
- *
- * Sense ID functions.
+ *    Copyright IBM Corp. 2002,2009
+ *    Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
+ *               Martin Schwidefsky <schwidefsky@de.ibm.com>
+ *               Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
  */
 
-#include <linux/module.h>
-#include <linux/init.h>
 #include <linux/kernel.h>
-
+#include <linux/string.h>
+#include <linux/types.h>
+#include <linux/errno.h>
 #include <asm/ccwdev.h>
-#include <asm/delay.h>
+#include <asm/setup.h>
 #include <asm/cio.h>
-#include <asm/lowcore.h>
 #include <asm/diag.h>
 
 #include "cio.h"
 #include "cio_debug.h"
-#include "css.h"
 #include "device.h"
-#include "ioasm.h"
 #include "io_sch.h"
 
+#define SENSE_ID_RETRIES        256
+#define SENSE_ID_TIMEOUT        (10 * HZ)
+#define SENSE_ID_MIN_LEN        4
+#define SENSE_ID_BASIC_LEN      7
+
 /**
- * vm_vdev_to_cu_type - Convert vm virtual device into control unit type
- *                      for certain devices.
- * @class: virtual device class
- * @type: virtual device type
+ * diag210_to_senseid - convert diag 0x210 data to sense id information
+ * @senseid: sense id
+ * @diag: diag 0x210 data
  *
- * Returns control unit type if a match was made or %0xffff otherwise.
+ * Return 0 on success, non-zero otherwise.
  */
-static int vm_vdev_to_cu_type(int class, int type)
+static int diag210_to_senseid(struct senseid *senseid, struct diag210 *diag)
 {
         static struct {
                 int class, type, cu_type;
@@ -71,253 +70,153 @@ static int vm_vdev_to_cu_type(int class, int type)
         };
         int i;
 
-        for (i = 0; i < ARRAY_SIZE(vm_devices); i++)
-                if (class == vm_devices[i].class && type == vm_devices[i].type)
-                        return vm_devices[i].cu_type;
+        /* Special case for osa devices. */
+        if (diag->vrdcvcla == 0x02 && diag->vrdcvtyp == 0x20) {
+                senseid->cu_type = 0x3088;
+                senseid->cu_model = 0x60;
+                senseid->reserved = 0xff;
+                return 0;
+        }
+        for (i = 0; i < ARRAY_SIZE(vm_devices); i++) {
+                if (diag->vrdcvcla == vm_devices[i].class &&
+                    diag->vrdcvtyp == vm_devices[i].type) {
+                        senseid->cu_type = vm_devices[i].cu_type;
+                        senseid->reserved = 0xff;
+                        return 0;
+                }
+        }
 
-        return 0xffff;
+        return -ENODEV;
 }
 
 /**
- * diag_get_dev_info - retrieve device information via DIAG X'210'
- * @devno: device number
- * @ps: pointer to sense ID data area
+ * diag_get_dev_info - retrieve device information via diag 0x210
+ * @cdev: ccw device
  *
  * Returns zero on success, non-zero otherwise.
  */
-static int diag_get_dev_info(u16 devno, struct senseid *ps)
+static int diag210_get_dev_info(struct ccw_device *cdev)
 {
+        struct ccw_dev_id *dev_id = &cdev->private->dev_id;
+        struct senseid *senseid = &cdev->private->senseid;
         struct diag210 diag_data;
-        int ccode;
-
-        CIO_TRACE_EVENT (4, "VMvdinf");
-
-        diag_data = (struct diag210) {
-                .vrdcdvno = devno,
-                .vrdclen = sizeof (diag_data),
-        };
-
-        ccode = diag210 (&diag_data);
-        if ((ccode == 0) || (ccode == 2)) {
-                ps->reserved = 0xff;
-
-                /* Special case for osa devices. */
-                if (diag_data.vrdcvcla == 0x02 && diag_data.vrdcvtyp == 0x20) {
-                        ps->cu_type = 0x3088;
-                        ps->cu_model = 0x60;
-                        return 0;
-                }
-                ps->cu_type = vm_vdev_to_cu_type(diag_data.vrdcvcla,
-                                                diag_data.vrdcvtyp);
-                if (ps->cu_type != 0xffff)
-                        return 0;
-        }
-
-        CIO_MSG_EVENT(0, "DIAG X'210' for device %04X returned (cc = %d):"
-                      "vdev class : %02X, vdev type : %04X \n ...  "
-                      "rdev class : %02X, rdev type : %04X, "
-                      "rdev model: %02X\n",
-                      devno, ccode,
-                      diag_data.vrdcvcla, diag_data.vrdcvtyp,
-                      diag_data.vrdcrccl, diag_data.vrdccrty,
-                      diag_data.vrdccrmd);
-
+        int rc;
+
+        if (dev_id->ssid != 0)
+                return -ENODEV;
+        memset(&diag_data, 0, sizeof(diag_data));
+        diag_data.vrdcdvno      = dev_id->devno;
+        diag_data.vrdclen       = sizeof(diag_data);
+        rc = diag210(&diag_data);
+        CIO_TRACE_EVENT(4, "diag210");
+        CIO_HEX_EVENT(4, &rc, sizeof(rc));
+        CIO_HEX_EVENT(4, &diag_data, sizeof(diag_data));
+        if (rc != 0 && rc != 2)
+                goto err_failed;
+        if (diag210_to_senseid(senseid, &diag_data))
+                goto err_unknown;
+        return 0;
+
+err_unknown:
+        CIO_MSG_EVENT(0, "snsid: device 0.%x.%04x: unknown diag210 data\n",
+                      dev_id->ssid, dev_id->devno);
+        return -ENODEV;
+err_failed:
+        CIO_MSG_EVENT(0, "snsid: device 0.%x.%04x: diag210 failed (rc=%d)\n",
+                      dev_id->ssid, dev_id->devno, rc);
         return -ENODEV;
 }
 
 /*
- * Start Sense ID helper function.
- * Try to obtain the 'control unit'/'device type' information
- *  associated with the subchannel.
+ * Initialize SENSE ID data.
  */
-static int
-__ccw_device_sense_id_start(struct ccw_device *cdev)
-{
-        struct subchannel *sch;
-        struct ccw1 *ccw;
-        int ret;
-
-        sch = to_subchannel(cdev->dev.parent);
-        /* Setup sense channel program. */
-        ccw = cdev->private->iccws;
-        ccw->cmd_code = CCW_CMD_SENSE_ID;
-        ccw->cda = (__u32) __pa (&cdev->private->senseid);
-        ccw->count = sizeof (struct senseid);
-        ccw->flags = CCW_FLAG_SLI;
-
-        /* Reset device status. */
-        memset(&cdev->private->irb, 0, sizeof(struct irb));
-
-        /* Try on every path. */
-        ret = -ENODEV;
-        while (cdev->private->imask != 0) {
-                cdev->private->senseid.cu_type = 0xFFFF;
-                if ((sch->opm & cdev->private->imask) != 0 &&
-                    cdev->private->iretry > 0) {
-                        cdev->private->iretry--;
-                        /* Reset internal retry indication. */
-                        cdev->private->flags.intretry = 0;
-                        ret = cio_start (sch, cdev->private->iccws,
-                                         cdev->private->imask);
-                        /* ret is 0, -EBUSY, -EACCES or -ENODEV */
-                        if (ret != -EACCES)
-                                return ret;
-                }
-                cdev->private->imask >>= 1;
-                cdev->private->iretry = 5;
-        }
-        return ret;
-}
-
-void
-ccw_device_sense_id_start(struct ccw_device *cdev)
+static void snsid_init(struct ccw_device *cdev)
 {
-        int ret;
-
-        memset (&cdev->private->senseid, 0, sizeof (struct senseid));
-        cdev->private->imask = 0x80;
-        cdev->private->iretry = 5;
-        ret = __ccw_device_sense_id_start(cdev);
-        if (ret && ret != -EBUSY)
-                ccw_device_sense_id_done(cdev, ret);
+        cdev->private->flags.esid = 0;
+        memset(&cdev->private->senseid, 0, sizeof(cdev->private->senseid));
+        cdev->private->senseid.cu_type = 0xffff;
 }
 
 /*
- * Called from interrupt context to check if a valid answer
- * to Sense ID was received.
+ * Check for complete SENSE ID data.
  */
-static int
-ccw_device_check_sense_id(struct ccw_device *cdev)
+static int snsid_check(struct ccw_device *cdev, void *data)
 {
-        struct subchannel *sch;
-        struct irb *irb;
-
-        sch = to_subchannel(cdev->dev.parent);
-        irb = &cdev->private->irb;
-
-        /* Check the error cases. */
-        if (irb->scsw.cmd.fctl & (SCSW_FCTL_HALT_FUNC | SCSW_FCTL_CLEAR_FUNC)) {
-                /* Retry Sense ID if requested. */
-                if (cdev->private->flags.intretry) {
-                        cdev->private->flags.intretry = 0;
-                        return -EAGAIN;
-                }
-                return -ETIME;
-        }
-        if (irb->esw.esw0.erw.cons && (irb->ecw[0] & SNS0_CMD_REJECT)) {
-                /*
-                 * if the device doesn't support the SenseID
-                 *  command further retries wouldn't help ...
-                 * NB: We don't check here for intervention required like we
-                 *     did before, because tape devices with no tape inserted
-                 *     may present this status *in conjunction with* the
-                 *     sense id information. So, for intervention required,
-                 *     we use the "whack it until it talks" strategy...
-                 */
-                CIO_MSG_EVENT(0, "SenseID : device %04x on Subchannel "
-                              "0.%x.%04x reports cmd reject\n",
-                              cdev->private->dev_id.devno, sch->schid.ssid,
-                              sch->schid.sch_no);
+        struct cmd_scsw *scsw = &cdev->private->irb.scsw.cmd;
+        int len = sizeof(struct senseid) - scsw->count;
+
+        /* Check for incomplete SENSE ID data. */
+        if (len < SENSE_ID_MIN_LEN)
+                goto out_restart;
+        if (cdev->private->senseid.cu_type == 0xffff)
+                goto out_restart;
+        /* Check for incompatible SENSE ID data. */
+        if (cdev->private->senseid.reserved != 0xff)
                 return -EOPNOTSUPP;
-        }
-        if (irb->esw.esw0.erw.cons) {
-                CIO_MSG_EVENT(2, "SenseID : UC on dev 0.%x.%04x, "
-                              "lpum %02X, cnt %02d, sns :"
-                              " %02X%02X%02X%02X %02X%02X%02X%02X ...\n",
-                              cdev->private->dev_id.ssid,
-                              cdev->private->dev_id.devno,
-                              irb->esw.esw0.sublog.lpum,
-                              irb->esw.esw0.erw.scnt,
-                              irb->ecw[0], irb->ecw[1],
-                              irb->ecw[2], irb->ecw[3],
-                              irb->ecw[4], irb->ecw[5],
-                              irb->ecw[6], irb->ecw[7]);
-                return -EAGAIN;
-        }
-        if (irb->scsw.cmd.cc == 3) {
-                u8 lpm;
+        /* Check for extended-identification information. */
+        if (len > SENSE_ID_BASIC_LEN)
+                cdev->private->flags.esid = 1;
+        return 0;
 
-                lpm = to_io_private(sch)->orb.cmd.lpm;
-                if ((lpm & sch->schib.pmcw.pim & sch->schib.pmcw.pam) != 0)
-                        CIO_MSG_EVENT(4, "SenseID : path %02X for device %04x "
-                                      "on subchannel 0.%x.%04x is "
-                                      "'not operational'\n", lpm,
-                                      cdev->private->dev_id.devno,
-                                      sch->schid.ssid, sch->schid.sch_no);
-                return -EACCES;
-        }
-
-        /* Did we get a proper answer ? */
-        if (irb->scsw.cmd.cc == 0 && cdev->private->senseid.cu_type != 0xFFFF &&
-            cdev->private->senseid.reserved == 0xFF) {
-                if (irb->scsw.cmd.count < sizeof(struct senseid) - 8)
-                        cdev->private->flags.esid = 1;
-                return 0; /* Success */
-        }
-
-        /* Hmm, whatever happened, try again. */
-        CIO_MSG_EVENT(2, "SenseID : start_IO() for device %04x on "
-                      "subchannel 0.%x.%04x returns status %02X%02X\n",
-                      cdev->private->dev_id.devno, sch->schid.ssid,
-                      sch->schid.sch_no,
-                      irb->scsw.cmd.dstat, irb->scsw.cmd.cstat);
+out_restart:
+        snsid_init(cdev);
         return -EAGAIN;
 }
 
 /*
- * Got interrupt for Sense ID.
+ * Process SENSE ID request result.
  */
-void
-ccw_device_sense_id_irq(struct ccw_device *cdev, enum dev_event dev_event)
+static void snsid_callback(struct ccw_device *cdev, void *data, int rc)
 {
-        struct subchannel *sch;
-        struct irb *irb;
-        int ret;
-
-        sch = to_subchannel(cdev->dev.parent);
-        irb = (struct irb *) __LC_IRB;
-        /* Retry sense id, if needed. */
-        if (irb->scsw.cmd.stctl ==
-            (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
-                if ((irb->scsw.cmd.cc == 1) || !irb->scsw.cmd.actl) {
-                        ret = __ccw_device_sense_id_start(cdev);
-                        if (ret && ret != -EBUSY)
-                                ccw_device_sense_id_done(cdev, ret);
+        struct ccw_dev_id *id = &cdev->private->dev_id;
+        struct senseid *senseid = &cdev->private->senseid;
+        int vm = 0;
+
+        if (rc && MACHINE_IS_VM) {
+                /* Try diag 0x210 fallback on z/VM. */
+                snsid_init(cdev);
+                if (diag210_get_dev_info(cdev) == 0) {
+                        rc = 0;
+                        vm = 1;
                 }
-                return;
         }
-        if (ccw_device_accumulate_and_sense(cdev, irb) != 0)
-                return;
-        ret = ccw_device_check_sense_id(cdev);
-        memset(&cdev->private->irb, 0, sizeof(struct irb));
-        switch (ret) {
-        /* 0, -ETIME, -EOPNOTSUPP, -EAGAIN or -EACCES */
-        case 0:                 /* Sense id succeeded. */
-        case -ETIME:            /* Sense id stopped by timeout. */
-                ccw_device_sense_id_done(cdev, ret);
-                break;
-        case -EACCES:           /* channel is not operational. */
-                sch->lpm &= ~cdev->private->imask;
-                cdev->private->imask >>= 1;
-                cdev->private->iretry = 5;
-                /* fall through. */
-        case -EAGAIN:           /* try again. */
-                ret = __ccw_device_sense_id_start(cdev);
-                if (ret == 0 || ret == -EBUSY)
-                        break;
-                /* fall through. */
-        default:                /* Sense ID failed. Try asking VM. */
-                if (MACHINE_IS_VM)
-                        ret = diag_get_dev_info(cdev->private->dev_id.devno,
-                                                &cdev->private->senseid);
-                else
-                        /*
-                         * If we can't couldn't identify the device type we
-                         *  consider the device "not operational".
-                         */
-                        ret = -ENODEV;
+        CIO_MSG_EVENT(2, "snsid: device 0.%x.%04x: rc=%d %04x/%02x "
+                      "%04x/%02x%s\n", id->ssid, id->devno, rc,
+                      senseid->cu_type, senseid->cu_model, senseid->dev_type,
+                      senseid->dev_model, vm ? " (diag210)" : "");
+        ccw_device_sense_id_done(cdev, rc);
+}
 
-                ccw_device_sense_id_done(cdev, ret);
-                break;
-        }
+/**
+ * ccw_device_sense_id_start - perform SENSE ID
+ * @cdev: ccw device
+ *
+ * Execute a SENSE ID channel program on @cdev to update its sense id
+ * information. When finished, call ccw_device_sense_id_done with a
+ * return code specifying the result.
+ */
+void ccw_device_sense_id_start(struct ccw_device *cdev)
+{
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct ccw_request *req = &cdev->private->req;
+        struct ccw1 *cp = cdev->private->iccws;
+
+        CIO_TRACE_EVENT(4, "snsid");
+        CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
+        /* Data setup. */
+        snsid_init(cdev);
+        /* Channel program setup. */
+        cp->cmd_code    = CCW_CMD_SENSE_ID;
+        cp->cda         = (u32) (addr_t) &cdev->private->senseid;
+        cp->count       = sizeof(struct senseid);
+        cp->flags       = CCW_FLAG_SLI;
+        /* Request setup. */
+        memset(req, 0, sizeof(*req));
+        req->cp         = cp;
+        req->timeout    = SENSE_ID_TIMEOUT;
+        req->maxretries = SENSE_ID_RETRIES;
+        req->lpm        = sch->schib.pmcw.pam & sch->opm;
+        req->check      = snsid_check;
+        req->callback   = snsid_callback;
+        ccw_request_start(cdev);
 }
diff --git a/drivers/s390/cio/device_ops.c b/drivers/s390/cio/device_ops.c
index 2d0efee8a290..6da84543dfe9 100644
--- a/drivers/s390/cio/device_ops.c
+++ b/drivers/s390/cio/device_ops.c
@@ -11,6 +11,7 @@
 #include <linux/list.h>
 #include <linux/device.h>
 #include <linux/delay.h>
+#include <linux/completion.h>
 
 #include <asm/ccwdev.h>
 #include <asm/idals.h>
@@ -46,6 +47,7 @@ int ccw_device_set_options_mask(struct ccw_device *cdev, unsigned long flags)
         cdev->private->options.repall = (flags & CCWDEV_REPORT_ALL) != 0;
         cdev->private->options.pgroup = (flags & CCWDEV_DO_PATHGROUP) != 0;
         cdev->private->options.force = (flags & CCWDEV_ALLOW_FORCE) != 0;
+        cdev->private->options.mpath = (flags & CCWDEV_DO_MULTIPATH) != 0;
         return 0;
 }
 
@@ -74,6 +76,7 @@ int ccw_device_set_options(struct ccw_device *cdev, unsigned long flags)
         cdev->private->options.repall |= (flags & CCWDEV_REPORT_ALL) != 0;
         cdev->private->options.pgroup |= (flags & CCWDEV_DO_PATHGROUP) != 0;
         cdev->private->options.force |= (flags & CCWDEV_ALLOW_FORCE) != 0;
+        cdev->private->options.mpath |= (flags & CCWDEV_DO_MULTIPATH) != 0;
         return 0;
 }
 
@@ -90,9 +93,34 @@ void ccw_device_clear_options(struct ccw_device *cdev, unsigned long flags)
         cdev->private->options.repall &= (flags & CCWDEV_REPORT_ALL) == 0;
         cdev->private->options.pgroup &= (flags & CCWDEV_DO_PATHGROUP) == 0;
         cdev->private->options.force &= (flags & CCWDEV_ALLOW_FORCE) == 0;
+        cdev->private->options.mpath &= (flags & CCWDEV_DO_MULTIPATH) == 0;
 }
 
 /**
+ * ccw_device_is_pathgroup - determine if paths to this device are grouped
+ * @cdev: ccw device
+ *
+ * Return non-zero if there is a path group, zero otherwise.
+ */
+int ccw_device_is_pathgroup(struct ccw_device *cdev)
+{
+        return cdev->private->flags.pgroup;
+}
+EXPORT_SYMBOL(ccw_device_is_pathgroup);
+
+/**
+ * ccw_device_is_multipath - determine if device is operating in multipath mode
+ * @cdev: ccw device
+ *
+ * Return non-zero if device is operating in multipath mode, zero otherwise.
+ */
+int ccw_device_is_multipath(struct ccw_device *cdev)
+{
+        return cdev->private->flags.mpath;
+}
+EXPORT_SYMBOL(ccw_device_is_multipath);
+
+/**
  * ccw_device_clear() - terminate I/O request processing
  * @cdev: target ccw device
  * @intparm: interruption parameter; value is only used if no I/O is
@@ -167,8 +195,7 @@ int ccw_device_start_key(struct ccw_device *cdev, struct ccw1 *cpa,
                 return -EINVAL;
         if (cdev->private->state == DEV_STATE_NOT_OPER)
                 return -ENODEV;
-        if (cdev->private->state == DEV_STATE_VERIFY ||
-            cdev->private->state == DEV_STATE_CLEAR_VERIFY) {
+        if (cdev->private->state == DEV_STATE_VERIFY) {
                 /* Remember to fake irb when finished. */
                 if (!cdev->private->flags.fake_irb) {
                         cdev->private->flags.fake_irb = 1;
@@ -478,74 +505,65 @@ __u8 ccw_device_get_path_mask(struct ccw_device *cdev)
         return sch->lpm;
 }
 
-/*
- * Try to break the lock on a boxed device.
- */
-int
-ccw_device_stlck(struct ccw_device *cdev)
-{
-        void *buf, *buf2;
-        unsigned long flags;
-        struct subchannel *sch;
-        int ret;
+struct stlck_data {
+        struct completion done;
+        int rc;
+};
 
-        if (!cdev)
-                return -ENODEV;
+void ccw_device_stlck_done(struct ccw_device *cdev, void *data, int rc)
+{
+        struct stlck_data *sdata = data;
 
-        if (cdev->drv && !cdev->private->options.force)
-                return -EINVAL;
+        sdata->rc = rc;
+        complete(&sdata->done);
+}
 
-        sch = to_subchannel(cdev->dev.parent);
-        
-        CIO_TRACE_EVENT(2, "stl lock");
-        CIO_TRACE_EVENT(2, dev_name(&cdev->dev));
+/*
+ * Perform unconditional reserve + release.
+ */
+int ccw_device_stlck(struct ccw_device *cdev)
+{
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct stlck_data data;
+        u8 *buffer;
+        int rc;
 
-        buf = kmalloc(32*sizeof(char), GFP_DMA|GFP_KERNEL);
-        if (!buf)
-                return -ENOMEM;
-        buf2 = kmalloc(32*sizeof(char), GFP_DMA|GFP_KERNEL);
-        if (!buf2) {
-                kfree(buf);
-                return -ENOMEM;
+        /* Check if steal lock operation is valid for this device. */
+        if (cdev->drv) {
+                if (!cdev->private->options.force)
+                        return -EINVAL;
         }
-        spin_lock_irqsave(sch->lock, flags);
-        ret = cio_enable_subchannel(sch, (u32)(addr_t)sch);
-        if (ret)
-                goto out_unlock;
-        /*
-         * Setup ccw. We chain an unconditional reserve and a release so we
-         * only break the lock.
-         */
-        cdev->private->iccws[0].cmd_code = CCW_CMD_STLCK;
-        cdev->private->iccws[0].cda = (__u32) __pa(buf);
-        cdev->private->iccws[0].count = 32;
-        cdev->private->iccws[0].flags = CCW_FLAG_CC;
-        cdev->private->iccws[1].cmd_code = CCW_CMD_RELEASE;
-        cdev->private->iccws[1].cda = (__u32) __pa(buf2);
-        cdev->private->iccws[1].count = 32;
-        cdev->private->iccws[1].flags = 0;
-        ret = cio_start(sch, cdev->private->iccws, 0);
-        if (ret) {
-                cio_disable_subchannel(sch); //FIXME: return code?
+        buffer = kzalloc(64, GFP_DMA | GFP_KERNEL);
+        if (!buffer)
+                return -ENOMEM;
+        init_completion(&data.done);
+        data.rc = -EIO;
+        spin_lock_irq(sch->lock);
+        rc = cio_enable_subchannel(sch, (u32) (addr_t) sch);
+        if (rc)
                 goto out_unlock;
+        /* Perform operation. */
+        cdev->private->state = DEV_STATE_STEAL_LOCK,
+        ccw_device_stlck_start(cdev, &data, &buffer[0], &buffer[32]);
+        spin_unlock_irq(sch->lock);
+        /* Wait for operation to finish. */
+        if (wait_for_completion_interruptible(&data.done)) {
+                /* Got a signal. */
+                spin_lock_irq(sch->lock);
+                ccw_request_cancel(cdev);
+                spin_unlock_irq(sch->lock);
+                wait_for_completion(&data.done);
         }
-        cdev->private->irb.scsw.cmd.actl |= SCSW_ACTL_START_PEND;
-        spin_unlock_irqrestore(sch->lock, flags);
-        wait_event(cdev->private->wait_q,
-                   cdev->private->irb.scsw.cmd.actl == 0);
-        spin_lock_irqsave(sch->lock, flags);
-        cio_disable_subchannel(sch); //FIXME: return code?
-        if ((cdev->private->irb.scsw.cmd.dstat !=
-             (DEV_STAT_CHN_END|DEV_STAT_DEV_END)) ||
-            (cdev->private->irb.scsw.cmd.cstat != 0))
-                ret = -EIO;
-        /* Clear irb. */
-        memset(&cdev->private->irb, 0, sizeof(struct irb));
+        rc = data.rc;
+        /* Check results. */
+        spin_lock_irq(sch->lock);
+        cio_disable_subchannel(sch);
+        cdev->private->state = DEV_STATE_BOXED;
 out_unlock:
-        kfree(buf);
-        kfree(buf2);
-        spin_unlock_irqrestore(sch->lock, flags);
-        return ret;
+        spin_unlock_irq(sch->lock);
+        kfree(buffer);
+
+        return rc;
 }
 
 void *ccw_device_get_chp_desc(struct ccw_device *cdev, int chp_no)
diff --git a/drivers/s390/cio/device_pgid.c b/drivers/s390/cio/device_pgid.c
index fc5ca1dd52b3..6facb5499a65 100644
--- a/drivers/s390/cio/device_pgid.c
+++ b/drivers/s390/cio/device_pgid.c
@@ -1,594 +1,568 @@
 /*
- * drivers/s390/cio/device_pgid.c
+ *  CCW device PGID and path verification I/O handling.
  *
- *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
- *                       IBM Corporation
- *    Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
- *               Martin Schwidefsky (schwidefsky@de.ibm.com)
- *
- * Path Group ID functions.
+ *    Copyright IBM Corp. 2002,2009
+ *    Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
+ *               Martin Schwidefsky <schwidefsky@de.ibm.com>
+ *               Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
  */
 
-#include <linux/module.h>
-#include <linux/init.h>
-
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/bitops.h>
 #include <asm/ccwdev.h>
 #include <asm/cio.h>
-#include <asm/delay.h>
-#include <asm/lowcore.h>
 
 #include "cio.h"
 #include "cio_debug.h"
-#include "css.h"
 #include "device.h"
-#include "ioasm.h"
 #include "io_sch.h"
 
+#define PGID_RETRIES    256
+#define PGID_TIMEOUT    (10 * HZ)
+
 /*
- * Helper function called from interrupt context to decide whether an
- * operation should be tried again.
+ * Process path verification data and report result.
  */
-static int __ccw_device_should_retry(union scsw *scsw)
+static void verify_done(struct ccw_device *cdev, int rc)
 {
-        /* CC is only valid if start function bit is set. */
-        if ((scsw->cmd.fctl & SCSW_FCTL_START_FUNC) && scsw->cmd.cc == 1)
-                return 1;
-        /* No more activity. For sense and set PGID we stubbornly try again. */
-        if (!scsw->cmd.actl)
-                return 1;
-        return 0;
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct ccw_dev_id *id = &cdev->private->dev_id;
+        int mpath = cdev->private->flags.mpath;
+        int pgroup = cdev->private->flags.pgroup;
+
+        if (rc)
+                goto out;
+        /* Ensure consistent multipathing state at device and channel. */
+        if (sch->config.mp != mpath) {
+                sch->config.mp = mpath;
+                rc = cio_commit_config(sch);
+        }
+out:
+        CIO_MSG_EVENT(2, "vrfy: device 0.%x.%04x: rc=%d pgroup=%d mpath=%d "
+                         "vpm=%02x\n", id->ssid, id->devno, rc, pgroup, mpath,
+                         sch->vpm);
+        ccw_device_verify_done(cdev, rc);
 }
 
 /*
- * Start Sense Path Group ID helper function. Used in ccw_device_recog
- * and ccw_device_sense_pgid.
+ * Create channel program to perform a NOOP.
  */
-static int
-__ccw_device_sense_pgid_start(struct ccw_device *cdev)
+static void nop_build_cp(struct ccw_device *cdev)
 {
-        struct subchannel *sch;
-        struct ccw1 *ccw;
-        int ret;
-        int i;
-
-        sch = to_subchannel(cdev->dev.parent);
-        /* Return if we already checked on all paths. */
-        if (cdev->private->imask == 0)
-                return (sch->lpm == 0) ? -ENODEV : -EACCES;
-        i = 8 - ffs(cdev->private->imask);
-
-        /* Setup sense path group id channel program. */
-        ccw = cdev->private->iccws;
-        ccw->cmd_code = CCW_CMD_SENSE_PGID;
-        ccw->count = sizeof (struct pgid);
-        ccw->flags = CCW_FLAG_SLI;
-
-        /* Reset device status. */
-        memset(&cdev->private->irb, 0, sizeof(struct irb));
-        /* Try on every path. */
-        ret = -ENODEV;
-        while (cdev->private->imask != 0) {
-                /* Try every path multiple times. */
-                ccw->cda = (__u32) __pa (&cdev->private->pgid[i]);
-                if (cdev->private->iretry > 0) {
-                        cdev->private->iretry--;
-                        /* Reset internal retry indication. */
-                        cdev->private->flags.intretry = 0;
-                        ret = cio_start (sch, cdev->private->iccws, 
-                                         cdev->private->imask);
-                        /* ret is 0, -EBUSY, -EACCES or -ENODEV */
-                        if (ret != -EACCES)
-                                return ret;
-                        CIO_MSG_EVENT(3, "SNID - Device %04x on Subchannel "
-                                      "0.%x.%04x, lpm %02X, became 'not "
-                                      "operational'\n",
-                                      cdev->private->dev_id.devno,
-                                      sch->schid.ssid,
-                                      sch->schid.sch_no, cdev->private->imask);
-
-                }
-                cdev->private->imask >>= 1;
-                cdev->private->iretry = 5;
-                i++;
-        }
-
-        return ret;
+        struct ccw_request *req = &cdev->private->req;
+        struct ccw1 *cp = cdev->private->iccws;
+
+        cp->cmd_code    = CCW_CMD_NOOP;
+        cp->cda         = 0;
+        cp->count       = 0;
+        cp->flags       = CCW_FLAG_SLI;
+        req->cp         = cp;
 }
 
-void
-ccw_device_sense_pgid_start(struct ccw_device *cdev)
+/*
+ * Perform NOOP on a single path.
+ */
+static void nop_do(struct ccw_device *cdev)
 {
-        int ret;
-
-        /* Set a timeout of 60s */
-        ccw_device_set_timeout(cdev, 60*HZ);
-
-        cdev->private->state = DEV_STATE_SENSE_PGID;
-        cdev->private->imask = 0x80;
-        cdev->private->iretry = 5;
-        memset (&cdev->private->pgid, 0, sizeof (cdev->private->pgid));
-        ret = __ccw_device_sense_pgid_start(cdev);
-        if (ret && ret != -EBUSY)
-                ccw_device_sense_pgid_done(cdev, ret);
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct ccw_request *req = &cdev->private->req;
+
+        /* Adjust lpm. */
+        req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam & sch->opm);
+        if (!req->lpm)
+                goto out_nopath;
+        nop_build_cp(cdev);
+        ccw_request_start(cdev);
+        return;
+
+out_nopath:
+        verify_done(cdev, sch->vpm ? 0 : -EACCES);
 }
 
 /*
- * Called from interrupt context to check if a valid answer
- * to Sense Path Group ID was received.
+ * Adjust NOOP I/O status.
  */
-static int
-__ccw_device_check_sense_pgid(struct ccw_device *cdev)
+static enum io_status nop_filter(struct ccw_device *cdev, void *data,
+                                 struct irb *irb, enum io_status status)
 {
-        struct subchannel *sch;
-        struct irb *irb;
-        int i;
-
-        sch = to_subchannel(cdev->dev.parent);
-        irb = &cdev->private->irb;
-        if (irb->scsw.cmd.fctl & (SCSW_FCTL_HALT_FUNC | SCSW_FCTL_CLEAR_FUNC)) {
-                /* Retry Sense PGID if requested. */
-                if (cdev->private->flags.intretry) {
-                        cdev->private->flags.intretry = 0;
-                        return -EAGAIN;
-                }
-                return -ETIME;
-        }
-        if (irb->esw.esw0.erw.cons &&
-            (irb->ecw[0]&(SNS0_CMD_REJECT|SNS0_INTERVENTION_REQ))) {
-                /*
-                 * If the device doesn't support the Sense Path Group ID
-                 *  command further retries wouldn't help ...
-                 */
-                return -EOPNOTSUPP;
-        }
-        if (irb->esw.esw0.erw.cons) {
-                CIO_MSG_EVENT(2, "SNID - device 0.%x.%04x, unit check, "
-                              "lpum %02X, cnt %02d, sns : "
-                              "%02X%02X%02X%02X %02X%02X%02X%02X ...\n",
-                              cdev->private->dev_id.ssid,
-                              cdev->private->dev_id.devno,
-                              irb->esw.esw0.sublog.lpum,
-                              irb->esw.esw0.erw.scnt,
-                              irb->ecw[0], irb->ecw[1],
-                              irb->ecw[2], irb->ecw[3],
-                              irb->ecw[4], irb->ecw[5],
-                              irb->ecw[6], irb->ecw[7]);
-                return -EAGAIN;
-        }
-        if (irb->scsw.cmd.cc == 3) {
-                u8 lpm;
-
-                lpm = to_io_private(sch)->orb.cmd.lpm;
-                CIO_MSG_EVENT(3, "SNID - Device %04x on Subchannel 0.%x.%04x,"
-                              " lpm %02X, became 'not operational'\n",
-                              cdev->private->dev_id.devno, sch->schid.ssid,
-                              sch->schid.sch_no, lpm);
-                return -EACCES;
-        }
-        i = 8 - ffs(cdev->private->imask);
-        if (cdev->private->pgid[i].inf.ps.state2 == SNID_STATE2_RESVD_ELSE) {
-                CIO_MSG_EVENT(2, "SNID - Device %04x on Subchannel 0.%x.%04x "
-                              "is reserved by someone else\n",
-                              cdev->private->dev_id.devno, sch->schid.ssid,
-                              sch->schid.sch_no);
-                return -EUSERS;
-        }
-        return 0;
+        /* Only subchannel status might indicate a path error. */
+        if (status == IO_STATUS_ERROR && irb->scsw.cmd.cstat == 0)
+                return IO_DONE;
+        return status;
 }
 
 /*
- * Got interrupt for Sense Path Group ID.
+ * Process NOOP request result for a single path.
  */
-void
-ccw_device_sense_pgid_irq(struct ccw_device *cdev, enum dev_event dev_event)
+static void nop_callback(struct ccw_device *cdev, void *data, int rc)
 {
-        struct subchannel *sch;
-        struct irb *irb;
-        int ret;
-
-        irb = (struct irb *) __LC_IRB;
-
-        if (irb->scsw.cmd.stctl ==
-            (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
-                if (__ccw_device_should_retry(&irb->scsw)) {
-                        ret = __ccw_device_sense_pgid_start(cdev);
-                        if (ret && ret != -EBUSY)
-                                ccw_device_sense_pgid_done(cdev, ret);
-                }
-                return;
-        }
-        if (ccw_device_accumulate_and_sense(cdev, irb) != 0)
-                return;
-        sch = to_subchannel(cdev->dev.parent);
-        ret = __ccw_device_check_sense_pgid(cdev);
-        memset(&cdev->private->irb, 0, sizeof(struct irb));
-        switch (ret) {
-        /* 0, -ETIME, -EOPNOTSUPP, -EAGAIN, -EACCES or -EUSERS */
-        case -EOPNOTSUPP:       /* Sense Path Group ID not supported */
-                ccw_device_sense_pgid_done(cdev, -EOPNOTSUPP);
-                break;
-        case -ETIME:            /* Sense path group id stopped by timeout. */
-                ccw_device_sense_pgid_done(cdev, -ETIME);
-                break;
-        case -EACCES:           /* channel is not operational. */
-                sch->lpm &= ~cdev->private->imask;
-                /* Fall through. */
-        case 0:                 /* Sense Path Group ID successful. */
-                cdev->private->imask >>= 1;
-                cdev->private->iretry = 5;
-                /* Fall through. */
-        case -EAGAIN:           /* Try again. */
-                ret = __ccw_device_sense_pgid_start(cdev);
-                if (ret != 0 && ret != -EBUSY)
-                        ccw_device_sense_pgid_done(cdev, ret);
-                break;
-        case -EUSERS:           /* device is reserved for someone else. */
-                ccw_device_sense_pgid_done(cdev, -EUSERS);
-                break;
-        }
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct ccw_request *req = &cdev->private->req;
+
+        if (rc == 0)
+                sch->vpm |= req->lpm;
+        else if (rc != -EACCES)
+                goto err;
+        req->lpm >>= 1;
+        nop_do(cdev);
+        return;
+
+err:
+        verify_done(cdev, rc);
 }
 
 /*
- * Path Group ID helper function.
+ * Create channel program to perform SET PGID on a single path.
  */
-static int
-__ccw_device_do_pgid(struct ccw_device *cdev, __u8 func)
+static void spid_build_cp(struct ccw_device *cdev, u8 fn)
 {
-        struct subchannel *sch;
-        struct ccw1 *ccw;
-        int ret;
-
-        sch = to_subchannel(cdev->dev.parent);
-
-        /* Setup sense path group id channel program. */
-        cdev->private->pgid[0].inf.fc = func;
-        ccw = cdev->private->iccws;
-        if (cdev->private->flags.pgid_single)
-                cdev->private->pgid[0].inf.fc |= SPID_FUNC_SINGLE_PATH;
-        else
-                cdev->private->pgid[0].inf.fc |= SPID_FUNC_MULTI_PATH;
-        ccw->cmd_code = CCW_CMD_SET_PGID;
-        ccw->cda = (__u32) __pa (&cdev->private->pgid[0]);
-        ccw->count = sizeof (struct pgid);
-        ccw->flags = CCW_FLAG_SLI;
-
-        /* Reset device status. */
-        memset(&cdev->private->irb, 0, sizeof(struct irb));
-
-        /* Try multiple times. */
-        ret = -EACCES;
-        if (cdev->private->iretry > 0) {
-                cdev->private->iretry--;
-                /* Reset internal retry indication. */
-                cdev->private->flags.intretry = 0;
-                ret = cio_start (sch, cdev->private->iccws,
-                                 cdev->private->imask);
-                /* We expect an interrupt in case of success or busy
-                 * indication. */
-                if ((ret == 0) || (ret == -EBUSY))
-                        return ret;
-        }
-        /* PGID command failed on this path. */
-        CIO_MSG_EVENT(3, "SPID - Device %04x on Subchannel "
-                      "0.%x.%04x, lpm %02X, became 'not operational'\n",
-                      cdev->private->dev_id.devno, sch->schid.ssid,
-                      sch->schid.sch_no, cdev->private->imask);
-        return ret;
+        struct ccw_request *req = &cdev->private->req;
+        struct ccw1 *cp = cdev->private->iccws;
+        int i = 8 - ffs(req->lpm);
+        struct pgid *pgid = &cdev->private->pgid[i];
+
+        pgid->inf.fc    = fn;
+        cp->cmd_code    = CCW_CMD_SET_PGID;
+        cp->cda         = (u32) (addr_t) pgid;
+        cp->count       = sizeof(*pgid);
+        cp->flags       = CCW_FLAG_SLI;
+        req->cp         = cp;
 }
 
 /*
- * Helper function to send a nop ccw down a path.
+ * Perform establish/resign SET PGID on a single path.
  */
-static int __ccw_device_do_nop(struct ccw_device *cdev)
+static void spid_do(struct ccw_device *cdev)
 {
-        struct subchannel *sch;
-        struct ccw1 *ccw;
-        int ret;
-
-        sch = to_subchannel(cdev->dev.parent);
-
-        /* Setup nop channel program. */
-        ccw = cdev->private->iccws;
-        ccw->cmd_code = CCW_CMD_NOOP;
-        ccw->cda = 0;
-        ccw->count = 0;
-        ccw->flags = CCW_FLAG_SLI;
-
-        /* Reset device status. */
-        memset(&cdev->private->irb, 0, sizeof(struct irb));
-
-        /* Try multiple times. */
-        ret = -EACCES;
-        if (cdev->private->iretry > 0) {
-                cdev->private->iretry--;
-                /* Reset internal retry indication. */
-                cdev->private->flags.intretry = 0;
-                ret = cio_start (sch, cdev->private->iccws,
-                                 cdev->private->imask);
-                /* We expect an interrupt in case of success or busy
-                 * indication. */
-                if ((ret == 0) || (ret == -EBUSY))
-                        return ret;
-        }
-        /* nop command failed on this path. */
-        CIO_MSG_EVENT(3, "NOP - Device %04x on Subchannel "
-                      "0.%x.%04x, lpm %02X, became 'not operational'\n",
-                      cdev->private->dev_id.devno, sch->schid.ssid,
-                      sch->schid.sch_no, cdev->private->imask);
-        return ret;
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct ccw_request *req = &cdev->private->req;
+        u8 fn;
+
+        /* Use next available path that is not already in correct state. */
+        req->lpm = lpm_adjust(req->lpm, cdev->private->pgid_todo_mask);
+        if (!req->lpm)
+                goto out_nopath;
+        /* Channel program setup. */
+        if (req->lpm & sch->opm)
+                fn = SPID_FUNC_ESTABLISH;
+        else
+                fn = SPID_FUNC_RESIGN;
+        if (cdev->private->flags.mpath)
+                fn |= SPID_FUNC_MULTI_PATH;
+        spid_build_cp(cdev, fn);
+        ccw_request_start(cdev);
+        return;
+
+out_nopath:
+        verify_done(cdev, sch->vpm ? 0 : -EACCES);
 }
 
+static void verify_start(struct ccw_device *cdev);
 
 /*
- * Called from interrupt context to check if a valid answer
- * to Set Path Group ID was received.
+ * Process SET PGID request result for a single path.
  */
-static int
-__ccw_device_check_pgid(struct ccw_device *cdev)
+static void spid_callback(struct ccw_device *cdev, void *data, int rc)
 {
-        struct subchannel *sch;
-        struct irb *irb;
-
-        sch = to_subchannel(cdev->dev.parent);
-        irb = &cdev->private->irb;
-        if (irb->scsw.cmd.fctl & (SCSW_FCTL_HALT_FUNC | SCSW_FCTL_CLEAR_FUNC)) {
-                /* Retry Set PGID if requested. */
-                if (cdev->private->flags.intretry) {
-                        cdev->private->flags.intretry = 0;
-                        return -EAGAIN;
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct ccw_request *req = &cdev->private->req;
+
+        switch (rc) {
+        case 0:
+                sch->vpm |= req->lpm & sch->opm;
+                break;
+        case -EACCES:
+                break;
+        case -EOPNOTSUPP:
+                if (cdev->private->flags.mpath) {
+                        /* Try without multipathing. */
+                        cdev->private->flags.mpath = 0;
+                        goto out_restart;
                 }
-                return -ETIME;
-        }
-        if (irb->esw.esw0.erw.cons) {
-                if (irb->ecw[0] & SNS0_CMD_REJECT)
-                        return -EOPNOTSUPP;
-                /* Hmm, whatever happened, try again. */
-                CIO_MSG_EVENT(2, "SPID - device 0.%x.%04x, unit check, "
-                              "cnt %02d, "
-                              "sns : %02X%02X%02X%02X %02X%02X%02X%02X ...\n",
-                              cdev->private->dev_id.ssid,
-                              cdev->private->dev_id.devno,
-                              irb->esw.esw0.erw.scnt,
-                              irb->ecw[0], irb->ecw[1],
-                              irb->ecw[2], irb->ecw[3],
-                              irb->ecw[4], irb->ecw[5],
-                              irb->ecw[6], irb->ecw[7]);
-                return -EAGAIN;
+                /* Try without pathgrouping. */
+                cdev->private->flags.pgroup = 0;
+                goto out_restart;
+        default:
+                goto err;
         }
-        if (irb->scsw.cmd.cc == 3) {
-                CIO_MSG_EVENT(3, "SPID - Device %04x on Subchannel 0.%x.%04x,"
-                              " lpm %02X, became 'not operational'\n",
-                              cdev->private->dev_id.devno, sch->schid.ssid,
-                              sch->schid.sch_no, cdev->private->imask);
-                return -EACCES;
-        }
-        return 0;
+        req->lpm >>= 1;
+        spid_do(cdev);
+        return;
+
+out_restart:
+        verify_start(cdev);
+        return;
+err:
+        verify_done(cdev, rc);
+}
+
+static void spid_start(struct ccw_device *cdev)
+{
+        struct ccw_request *req = &cdev->private->req;
+
+        /* Initialize request data. */
+        memset(req, 0, sizeof(*req));
+        req->timeout    = PGID_TIMEOUT;
+        req->maxretries = PGID_RETRIES;
+        req->lpm        = 0x80;
+        req->callback   = spid_callback;
+        spid_do(cdev);
+}
+
+static int pgid_cmp(struct pgid *p1, struct pgid *p2)
+{
+        return memcmp((char *) p1 + 1, (char *) p2 + 1,
+                      sizeof(struct pgid) - 1);
 }
 
 /*
- * Called from interrupt context to check the path status after a nop has
- * been send.
+ * Determine pathgroup state from PGID data.
  */
-static int __ccw_device_check_nop(struct ccw_device *cdev)
+static void pgid_analyze(struct ccw_device *cdev, struct pgid **p,
+                         int *mismatch, int *reserved, int *reset)
 {
-        struct subchannel *sch;
-        struct irb *irb;
-
-        sch = to_subchannel(cdev->dev.parent);
-        irb = &cdev->private->irb;
-        if (irb->scsw.cmd.fctl & (SCSW_FCTL_HALT_FUNC | SCSW_FCTL_CLEAR_FUNC)) {
-                /* Retry NOP if requested. */
-                if (cdev->private->flags.intretry) {
-                        cdev->private->flags.intretry = 0;
-                        return -EAGAIN;
+        struct pgid *pgid = &cdev->private->pgid[0];
+        struct pgid *first = NULL;
+        int lpm;
+        int i;
+
+        *mismatch = 0;
+        *reserved = 0;
+        *reset = 0;
+        for (i = 0, lpm = 0x80; i < 8; i++, pgid++, lpm >>= 1) {
+                if ((cdev->private->pgid_valid_mask & lpm) == 0)
+                        continue;
+                if (pgid->inf.ps.state2 == SNID_STATE2_RESVD_ELSE)
+                        *reserved = 1;
+                if (pgid->inf.ps.state1 == SNID_STATE1_RESET) {
+                        /* A PGID was reset. */
+                        *reset = 1;
+                        continue;
                 }
-                return -ETIME;
-        }
-        if (irb->scsw.cmd.cc == 3) {
-                CIO_MSG_EVENT(3, "NOP - Device %04x on Subchannel 0.%x.%04x,"
-                              " lpm %02X, became 'not operational'\n",
-                              cdev->private->dev_id.devno, sch->schid.ssid,
-                              sch->schid.sch_no, cdev->private->imask);
-                return -EACCES;
+                if (!first) {
+                        first = pgid;
+                        continue;
+                }
+                if (pgid_cmp(pgid, first) != 0)
+                        *mismatch = 1;
         }
-        return 0;
+        if (!first)
+                first = &channel_subsystems[0]->global_pgid;
+        *p = first;
 }
 
-static void
-__ccw_device_verify_start(struct ccw_device *cdev)
+static u8 pgid_to_donepm(struct ccw_device *cdev)
 {
-        struct subchannel *sch;
-        __u8 func;
-        int ret;
-
-        sch = to_subchannel(cdev->dev.parent);
-        /* Repeat for all paths. */
-        for (; cdev->private->imask; cdev->private->imask >>= 1,
-                                     cdev->private->iretry = 5) {
-                if ((cdev->private->imask & sch->schib.pmcw.pam) == 0)
-                        /* Path not available, try next. */
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct pgid *pgid;
+        int i;
+        int lpm;
+        u8 donepm = 0;
+
+        /* Set bits for paths which are already in the target state. */
+        for (i = 0; i < 8; i++) {
+                lpm = 0x80 >> i;
+                if ((cdev->private->pgid_valid_mask & lpm) == 0)
                         continue;
-                if (cdev->private->options.pgroup) {
-                        if (sch->opm & cdev->private->imask)
-                                func = SPID_FUNC_ESTABLISH;
-                        else
-                                func = SPID_FUNC_RESIGN;
-                        ret = __ccw_device_do_pgid(cdev, func);
-                } else
-                        ret = __ccw_device_do_nop(cdev);
-                /* We expect an interrupt in case of success or busy
-                 * indication. */
-                if (ret == 0 || ret == -EBUSY)
-                        return;
-                /* Permanent path failure, try next. */
+                pgid = &cdev->private->pgid[i];
+                if (sch->opm & lpm) {
+                        if (pgid->inf.ps.state1 != SNID_STATE1_GROUPED)
+                                continue;
+                } else {
+                        if (pgid->inf.ps.state1 != SNID_STATE1_UNGROUPED)
+                                continue;
+                }
+                if (cdev->private->flags.mpath) {
+                        if (pgid->inf.ps.state3 != SNID_STATE3_MULTI_PATH)
+                                continue;
+                } else {
+                        if (pgid->inf.ps.state3 != SNID_STATE3_SINGLE_PATH)
+                                continue;
+                }
+                donepm |= lpm;
         }
-        /* Done with all paths. */
-        ccw_device_verify_done(cdev, (sch->vpm != 0) ? 0 : -ENODEV);
+
+        return donepm;
 }
-                
-/*
- * Got interrupt for Set Path Group ID.
- */
-void
-ccw_device_verify_irq(struct ccw_device *cdev, enum dev_event dev_event)
+
+static void pgid_fill(struct ccw_device *cdev, struct pgid *pgid)
 {
-        struct subchannel *sch;
-        struct irb *irb;
-        int ret;
+        int i;
 
-        irb = (struct irb *) __LC_IRB;
+        for (i = 0; i < 8; i++)
+                memcpy(&cdev->private->pgid[i], pgid, sizeof(struct pgid));
+}
 
-        if (irb->scsw.cmd.stctl ==
-            (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
-                if (__ccw_device_should_retry(&irb->scsw))
-                        __ccw_device_verify_start(cdev);
-                return;
+/*
+ * Process SENSE PGID data and report result.
+ */
+static void snid_done(struct ccw_device *cdev, int rc)
+{
+        struct ccw_dev_id *id = &cdev->private->dev_id;
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct pgid *pgid;
+        int mismatch = 0;
+        int reserved = 0;
+        int reset = 0;
+        u8 donepm;
+
+        if (rc)
+                goto out;
+        pgid_analyze(cdev, &pgid, &mismatch, &reserved, &reset);
+        if (reserved)
+                rc = -EUSERS;
+        else if (mismatch)
+                rc = -EOPNOTSUPP;
+        else {
+                donepm = pgid_to_donepm(cdev);
+                sch->vpm = donepm & sch->opm;
+                cdev->private->pgid_todo_mask &= ~donepm;
+                pgid_fill(cdev, pgid);
         }
-        if (ccw_device_accumulate_and_sense(cdev, irb) != 0)
-                return;
-        sch = to_subchannel(cdev->dev.parent);
-        if (cdev->private->options.pgroup)
-                ret = __ccw_device_check_pgid(cdev);
-        else
-                ret = __ccw_device_check_nop(cdev);
-        memset(&cdev->private->irb, 0, sizeof(struct irb));
-
-        switch (ret) {
-        /* 0, -ETIME, -EAGAIN, -EOPNOTSUPP or -EACCES */
+out:
+        CIO_MSG_EVENT(2, "snid: device 0.%x.%04x: rc=%d pvm=%02x vpm=%02x "
+                      "todo=%02x mism=%d rsvd=%d reset=%d\n", id->ssid,
+                      id->devno, rc, cdev->private->pgid_valid_mask, sch->vpm,
+                      cdev->private->pgid_todo_mask, mismatch, reserved, reset);
+        switch (rc) {
         case 0:
-                /* Path verification ccw finished successfully, update lpm. */
-                sch->vpm |= sch->opm & cdev->private->imask;
-                /* Go on with next path. */
-                cdev->private->imask >>= 1;
-                cdev->private->iretry = 5;
-                __ccw_device_verify_start(cdev);
+                /* Anything left to do? */
+                if (cdev->private->pgid_todo_mask == 0) {
+                        verify_done(cdev, sch->vpm == 0 ? -EACCES : 0);
+                        return;
+                }
+                /* Perform path-grouping. */
+                spid_start(cdev);
                 break;
         case -EOPNOTSUPP:
-                /*
-                 * One of those strange devices which claim to be able
-                 * to do multipathing but not for Set Path Group ID.
-                 */
-                if (cdev->private->flags.pgid_single)
-                        cdev->private->options.pgroup = 0;
-                else
-                        cdev->private->flags.pgid_single = 1;
-                /* Retry */
-                sch->vpm = 0;
-                cdev->private->imask = 0x80;
-                cdev->private->iretry = 5;
-                /* fall through. */
-        case -EAGAIN:           /* Try again. */
-                __ccw_device_verify_start(cdev);
-                break;
-        case -ETIME:            /* Set path group id stopped by timeout. */
-                ccw_device_verify_done(cdev, -ETIME);
-                break;
-        case -EACCES:           /* channel is not operational. */
-                cdev->private->imask >>= 1;
-                cdev->private->iretry = 5;
-                __ccw_device_verify_start(cdev);
+                /* Path-grouping not supported. */
+                cdev->private->flags.pgroup = 0;
+                cdev->private->flags.mpath = 0;
+                verify_start(cdev);
                 break;
+        default:
+                verify_done(cdev, rc);
         }
 }
 
-void
-ccw_device_verify_start(struct ccw_device *cdev)
+/*
+ * Create channel program to perform a SENSE PGID on a single path.
+ */
+static void snid_build_cp(struct ccw_device *cdev)
+{
+        struct ccw_request *req = &cdev->private->req;
+        struct ccw1 *cp = cdev->private->iccws;
+        int i = 8 - ffs(req->lpm);
+
+        /* Channel program setup. */
+        cp->cmd_code    = CCW_CMD_SENSE_PGID;
+        cp->cda         = (u32) (addr_t) &cdev->private->pgid[i];
+        cp->count       = sizeof(struct pgid);
+        cp->flags       = CCW_FLAG_SLI;
+        req->cp         = cp;
+}
+
+/*
+ * Perform SENSE PGID on a single path.
+ */
+static void snid_do(struct ccw_device *cdev)
 {
         struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct ccw_request *req = &cdev->private->req;
+
+        /* Adjust lpm if paths are not set in pam. */
+        req->lpm = lpm_adjust(req->lpm, sch->schib.pmcw.pam);
+        if (!req->lpm)
+                goto out_nopath;
+        snid_build_cp(cdev);
+        ccw_request_start(cdev);
+        return;
+
+out_nopath:
+        snid_done(cdev, cdev->private->pgid_valid_mask ? 0 : -EACCES);
+}
 
-        cdev->private->flags.pgid_single = 0;
-        cdev->private->imask = 0x80;
-        cdev->private->iretry = 5;
+/*
+ * Process SENSE PGID request result for single path.
+ */
+static void snid_callback(struct ccw_device *cdev, void *data, int rc)
+{
+        struct ccw_request *req = &cdev->private->req;
+
+        if (rc == 0)
+                cdev->private->pgid_valid_mask |= req->lpm;
+        else if (rc != -EACCES)
+                goto err;
+        req->lpm >>= 1;
+        snid_do(cdev);
+        return;
+
+err:
+        snid_done(cdev, rc);
+}
 
-        /* Start with empty vpm. */
-        sch->vpm = 0;
+/*
+ * Perform path verification.
+ */
+static void verify_start(struct ccw_device *cdev)
+{
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct ccw_request *req = &cdev->private->req;
+        struct ccw_dev_id *devid = &cdev->private->dev_id;
 
-        /* Get current pam. */
-        if (cio_update_schib(sch)) {
-                ccw_device_verify_done(cdev, -ENODEV);
-                return;
+        sch->vpm = 0;
+        sch->lpm = sch->schib.pmcw.pam;
+        /* Initialize request data. */
+        memset(req, 0, sizeof(*req));
+        req->timeout    = PGID_TIMEOUT;
+        req->maxretries = PGID_RETRIES;
+        req->lpm        = 0x80;
+        if (cdev->private->flags.pgroup) {
+                CIO_TRACE_EVENT(4, "snid");
+                CIO_HEX_EVENT(4, devid, sizeof(*devid));
+                req->callback   = snid_callback;
+                snid_do(cdev);
+        } else {
+                CIO_TRACE_EVENT(4, "nop");
+                CIO_HEX_EVENT(4, devid, sizeof(*devid));
+                req->filter     = nop_filter;
+                req->callback   = nop_callback;
+                nop_do(cdev);
         }
-        /* After 60s path verification is considered to have failed. */
-        ccw_device_set_timeout(cdev, 60*HZ);
-        __ccw_device_verify_start(cdev);
 }
 
-static void
-__ccw_device_disband_start(struct ccw_device *cdev)
+/**
+ * ccw_device_verify_start - perform path verification
+ * @cdev: ccw device
+ *
+ * Perform an I/O on each available channel path to @cdev to determine which
+ * paths are operational. The resulting path mask is stored in sch->vpm.
+ * If device options specify pathgrouping, establish a pathgroup for the
+ * operational paths. When finished, call ccw_device_verify_done with a
+ * return code specifying the result.
+ */
+void ccw_device_verify_start(struct ccw_device *cdev)
 {
-        struct subchannel *sch;
-        int ret;
-
-        sch = to_subchannel(cdev->dev.parent);
-        while (cdev->private->imask != 0) {
-                if (sch->lpm & cdev->private->imask) {
-                        ret = __ccw_device_do_pgid(cdev, SPID_FUNC_DISBAND);
-                        if (ret == 0)
-                                return;
-                }
-                cdev->private->iretry = 5;
-                cdev->private->imask >>= 1;
-        }
-        ccw_device_disband_done(cdev, (sch->lpm != 0) ? 0 : -ENODEV);
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+
+        CIO_TRACE_EVENT(4, "vrfy");
+        CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
+        /* Initialize PGID data. */
+        memset(cdev->private->pgid, 0, sizeof(cdev->private->pgid));
+        cdev->private->pgid_valid_mask = 0;
+        cdev->private->pgid_todo_mask = sch->schib.pmcw.pam;
+        /*
+         * Initialize pathgroup and multipath state with target values.
+         * They may change in the course of path verification.
+         */
+        cdev->private->flags.pgroup = cdev->private->options.pgroup;
+        cdev->private->flags.mpath = cdev->private->options.mpath;
+        cdev->private->flags.doverify = 0;
+        verify_start(cdev);
 }
 
 /*
- * Got interrupt for Unset Path Group ID.
+ * Process disband SET PGID request result.
  */
-void
-ccw_device_disband_irq(struct ccw_device *cdev, enum dev_event dev_event)
+static void disband_callback(struct ccw_device *cdev, void *data, int rc)
 {
-        struct subchannel *sch;
-        struct irb *irb;
-        int ret;
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct ccw_dev_id *id = &cdev->private->dev_id;
+
+        if (rc)
+                goto out;
+        /* Ensure consistent multipathing state at device and channel. */
+        cdev->private->flags.mpath = 0;
+        if (sch->config.mp) {
+                sch->config.mp = 0;
+                rc = cio_commit_config(sch);
+        }
+out:
+        CIO_MSG_EVENT(0, "disb: device 0.%x.%04x: rc=%d\n", id->ssid, id->devno,
+                      rc);
+        ccw_device_disband_done(cdev, rc);
+}
 
-        irb = (struct irb *) __LC_IRB;
+/**
+ * ccw_device_disband_start - disband pathgroup
+ * @cdev: ccw device
+ *
+ * Execute a SET PGID channel program on @cdev to disband a previously
+ * established pathgroup. When finished, call ccw_device_disband_done with
+ * a return code specifying the result.
+ */
+void ccw_device_disband_start(struct ccw_device *cdev)
+{
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct ccw_request *req = &cdev->private->req;
+        u8 fn;
+
+        CIO_TRACE_EVENT(4, "disb");
+        CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
+        /* Request setup. */
+        memset(req, 0, sizeof(*req));
+        req->timeout    = PGID_TIMEOUT;
+        req->maxretries = PGID_RETRIES;
+        req->lpm        = sch->schib.pmcw.pam & sch->opm;
+        req->callback   = disband_callback;
+        fn = SPID_FUNC_DISBAND;
+        if (cdev->private->flags.mpath)
+                fn |= SPID_FUNC_MULTI_PATH;
+        spid_build_cp(cdev, fn);
+        ccw_request_start(cdev);
+}
 
-        if (irb->scsw.cmd.stctl ==
-            (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
-                if (__ccw_device_should_retry(&irb->scsw))
-                        __ccw_device_disband_start(cdev);
-                return;
-        }
-        if (ccw_device_accumulate_and_sense(cdev, irb) != 0)
-                return;
-        sch = to_subchannel(cdev->dev.parent);
-        ret = __ccw_device_check_pgid(cdev);
-        memset(&cdev->private->irb, 0, sizeof(struct irb));
-        switch (ret) {
-        /* 0, -ETIME, -EAGAIN, -EOPNOTSUPP or -EACCES */
-        case 0:                 /* disband successful. */
-                ccw_device_disband_done(cdev, ret);
-                break;
-        case -EOPNOTSUPP:
-                /*
-                 * One of those strange devices which claim to be able
-                 * to do multipathing but not for Unset Path Group ID.
-                 */
-                cdev->private->flags.pgid_single = 1;
-                /* fall through. */
-        case -EAGAIN:           /* Try again. */
-                __ccw_device_disband_start(cdev);
-                break;
-        case -ETIME:            /* Set path group id stopped by timeout. */
-                ccw_device_disband_done(cdev, -ETIME);
-                break;
-        case -EACCES:           /* channel is not operational. */
-                cdev->private->imask >>= 1;
-                cdev->private->iretry = 5;
-                __ccw_device_disband_start(cdev);
-                break;
-        }
+static void stlck_build_cp(struct ccw_device *cdev, void *buf1, void *buf2)
+{
+        struct ccw_request *req = &cdev->private->req;
+        struct ccw1 *cp = cdev->private->iccws;
+
+        cp[0].cmd_code = CCW_CMD_STLCK;
+        cp[0].cda = (u32) (addr_t) buf1;
+        cp[0].count = 32;
+        cp[0].flags = CCW_FLAG_CC;
+        cp[1].cmd_code = CCW_CMD_RELEASE;
+        cp[1].cda = (u32) (addr_t) buf2;
+        cp[1].count = 32;
+        cp[1].flags = 0;
+        req->cp = cp;
 }
 
-void
-ccw_device_disband_start(struct ccw_device *cdev)
+static void stlck_callback(struct ccw_device *cdev, void *data, int rc)
 {
-        /* After 60s disbanding is considered to have failed. */
-        ccw_device_set_timeout(cdev, 60*HZ);
+        ccw_device_stlck_done(cdev, data, rc);
+}
 
-        cdev->private->flags.pgid_single = 0;
-        cdev->private->iretry = 5;
-        cdev->private->imask = 0x80;
-        __ccw_device_disband_start(cdev);
+/**
+ * ccw_device_stlck_start - perform unconditional release
+ * @cdev: ccw device
+ * @data: data pointer to be passed to ccw_device_stlck_done
+ * @buf1: data pointer used in channel program
+ * @buf2: data pointer used in channel program
+ *
+ * Execute a channel program on @cdev to release an existing PGID reservation.
+ * When finished, call ccw_device_stlck_done with a return code specifying the
+ * result.
+ */
+void ccw_device_stlck_start(struct ccw_device *cdev, void *data, void *buf1,
+                            void *buf2)
+{
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct ccw_request *req = &cdev->private->req;
+
+        CIO_TRACE_EVENT(4, "stlck");
+        CIO_HEX_EVENT(4, &cdev->private->dev_id, sizeof(cdev->private->dev_id));
+        /* Request setup. */
+        memset(req, 0, sizeof(*req));
+        req->timeout    = PGID_TIMEOUT;
+        req->maxretries = PGID_RETRIES;
+        req->lpm        = sch->schib.pmcw.pam & sch->opm;
+        req->data       = data;
+        req->callback   = stlck_callback;
+        stlck_build_cp(cdev, buf1, buf2);
+        ccw_request_start(cdev);
 }
+
diff --git a/drivers/s390/cio/device_status.c b/drivers/s390/cio/device_status.c
index 5814dbee2410..66d8066ef22a 100644
--- a/drivers/s390/cio/device_status.c
+++ b/drivers/s390/cio/device_status.c
@@ -336,9 +336,6 @@ ccw_device_do_sense(struct ccw_device *cdev, struct irb *irb)
         sense_ccw->count = SENSE_MAX_COUNT;
         sense_ccw->flags = CCW_FLAG_SLI;
 
-        /* Reset internal retry indication. */
-        cdev->private->flags.intretry = 0;
-
         rc = cio_start(sch, sense_ccw, 0xff);
         if (rc == -ENODEV || rc == -EACCES)
                 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
diff --git a/drivers/s390/cio/fcx.c b/drivers/s390/cio/fcx.c
index 61677dfbdc9b..ca5e9bb9d458 100644
--- a/drivers/s390/cio/fcx.c
+++ b/drivers/s390/cio/fcx.c
@@ -163,7 +163,7 @@ void tcw_finalize(struct tcw *tcw, int num_tidaws)
         /* Add tcat to tccb. */
         tccb = tcw_get_tccb(tcw);
         tcat = (struct tccb_tcat *) &tccb->tca[tca_size(tccb)];
-        memset(tcat, 0, sizeof(tcat));
+        memset(tcat, 0, sizeof(*tcat));
         /* Calculate tcw input/output count and tcat transport count. */
         count = calc_dcw_count(tccb);
         if (tcw->w && (tcw->flags & TCW_FLAGS_OUTPUT_TIDA))
@@ -269,7 +269,7 @@ EXPORT_SYMBOL(tccb_init);
  */
 void tsb_init(struct tsb *tsb)
 {
-        memset(tsb, 0, sizeof(tsb));
+        memset(tsb, 0, sizeof(*tsb));
 }
 EXPORT_SYMBOL(tsb_init);
 
diff --git a/drivers/s390/cio/io_sch.h b/drivers/s390/cio/io_sch.h
index 0b8f381bd20e..b9ce712a7f25 100644
--- a/drivers/s390/cio/io_sch.h
+++ b/drivers/s390/cio/io_sch.h
@@ -1,7 +1,10 @@
 #ifndef S390_IO_SCH_H
 #define S390_IO_SCH_H
 
+#include <linux/types.h>
 #include <asm/schid.h>
+#include <asm/ccwdev.h>
+#include "css.h"
 
 /*
  * command-mode operation request block
@@ -68,6 +71,52 @@ struct io_subchannel_private {
 #define MAX_CIWS 8
 
 /*
+ * Possible status values for a CCW request's I/O.
+ */
+enum io_status {
+        IO_DONE,
+        IO_RUNNING,
+        IO_STATUS_ERROR,
+        IO_PATH_ERROR,
+        IO_REJECTED,
+        IO_KILLED
+};
+
+/**
+ * ccw_request - Internal CCW request.
+ * @cp: channel program to start
+ * @timeout: maximum allowable time in jiffies between start I/O and interrupt
+ * @maxretries: number of retries per I/O operation and path
+ * @lpm: mask of paths to use
+ * @check: optional callback that determines if results are final
+ * @filter: optional callback to adjust request status based on IRB data
+ * @callback: final callback
+ * @data: user-defined pointer passed to all callbacks
+ * @mask: current path mask
+ * @retries: current number of retries
+ * @drc: delayed return code
+ * @cancel: non-zero if request was cancelled
+ * @done: non-zero if request was finished
+ */
+struct ccw_request {
+        struct ccw1 *cp;
+        unsigned long timeout;
+        u16 maxretries;
+        u8 lpm;
+        int (*check)(struct ccw_device *, void *);
+        enum io_status (*filter)(struct ccw_device *, void *, struct irb *,
+                                 enum io_status);
+        void (*callback)(struct ccw_device *, void *, int);
+        void *data;
+        /* These fields are used internally. */
+        u16 mask;
+        u16 retries;
+        int drc;
+        int cancel:1;
+        int done:1;
+} __attribute__((packed));
+
+/*
  * sense-id response buffer layout
  */
 struct senseid {
@@ -82,32 +131,44 @@ struct senseid {
         struct ciw ciw[MAX_CIWS];       /* variable # of CIWs */
 }  __attribute__ ((packed, aligned(4)));
 
+enum cdev_todo {
+        CDEV_TODO_NOTHING,
+        CDEV_TODO_ENABLE_CMF,
+        CDEV_TODO_REBIND,
+        CDEV_TODO_REGISTER,
+        CDEV_TODO_UNREG,
+        CDEV_TODO_UNREG_EVAL,
+};
+
 struct ccw_device_private {
         struct ccw_device *cdev;
         struct subchannel *sch;
         int state;              /* device state */
         atomic_t onoff;
-        unsigned long registered;
         struct ccw_dev_id dev_id;       /* device id */
         struct subchannel_id schid;     /* subchannel number */
-        u8 imask;               /* lpm mask for SNID/SID/SPGID */
-        int iretry;             /* retry counter SNID/SID/SPGID */
+        struct ccw_request req;         /* internal I/O request */
+        int iretry;
+        u8 pgid_valid_mask;             /* mask of valid PGIDs */
+        u8 pgid_todo_mask;              /* mask of PGIDs to be adjusted */
         struct {
                 unsigned int fast:1;    /* post with "channel end" */
                 unsigned int repall:1;  /* report every interrupt status */
                 unsigned int pgroup:1;  /* do path grouping */
                 unsigned int force:1;   /* allow forced online */
+                unsigned int mpath:1;   /* do multipathing */
         } __attribute__ ((packed)) options;
         struct {
-                unsigned int pgid_single:1; /* use single path for Set PGID */
                 unsigned int esid:1;        /* Ext. SenseID supported by HW */
                 unsigned int dosense:1;     /* delayed SENSE required */
                 unsigned int doverify:1;    /* delayed path verification */
                 unsigned int donotify:1;    /* call notify function */
                 unsigned int recog_done:1;  /* dev. recog. complete */
                 unsigned int fake_irb:1;    /* deliver faked irb */
-                unsigned int intretry:1;    /* retry internal operation */
                 unsigned int resuming:1;    /* recognition while resume */
+                unsigned int pgroup:1;      /* pathgroup is set up */
+                unsigned int mpath:1;       /* multipathing is set up */
+                unsigned int initialized:1; /* set if initial reference held */
         } __attribute__((packed)) flags;
         unsigned long intparm;  /* user interruption parameter */
         struct qdio_irq *qdio_data;
@@ -115,7 +176,8 @@ struct ccw_device_private {
         struct senseid senseid; /* SenseID info */
         struct pgid pgid[8];    /* path group IDs per chpid*/
         struct ccw1 iccws[2];   /* ccws for SNID/SID/SPGID commands */
-        struct work_struct kick_work;
+        struct work_struct todo_work;
+        enum cdev_todo todo;
         wait_queue_head_t wait_q;
         struct timer_list timer;
         void *cmb;                      /* measurement information */
diff --git a/drivers/s390/cio/qdio.h b/drivers/s390/cio/qdio.h
index ff7748a9199d..48aa0647432b 100644
--- a/drivers/s390/cio/qdio.h
+++ b/drivers/s390/cio/qdio.h
@@ -182,16 +182,53 @@ struct scssc_area {
         u32:32;
 } __attribute__ ((packed));
 
+struct qdio_dev_perf_stat {
+        unsigned int adapter_int;
+        unsigned int qdio_int;
+        unsigned int pci_request_int;
+
+        unsigned int tasklet_inbound;
+        unsigned int tasklet_inbound_resched;
+        unsigned int tasklet_inbound_resched2;
+        unsigned int tasklet_outbound;
+
+        unsigned int siga_read;
+        unsigned int siga_write;
+        unsigned int siga_sync;
+
+        unsigned int inbound_call;
+        unsigned int inbound_handler;
+        unsigned int stop_polling;
+        unsigned int inbound_queue_full;
+        unsigned int outbound_call;
+        unsigned int outbound_handler;
+        unsigned int fast_requeue;
+        unsigned int target_full;
+        unsigned int eqbs;
+        unsigned int eqbs_partial;
+        unsigned int sqbs;
+        unsigned int sqbs_partial;
+} ____cacheline_aligned;
+
+struct qdio_queue_perf_stat {
+        /*
+         * Sorted into order-2 buckets: 1, 2-3, 4-7, ... 64-127, 128.
+         * Since max. 127 SBALs are scanned reuse entry for 128 as queue full
+         * aka 127 SBALs found.
+         */
+        unsigned int nr_sbals[8];
+        unsigned int nr_sbal_error;
+        unsigned int nr_sbal_nop;
+        unsigned int nr_sbal_total;
+};
+
 struct qdio_input_q {
         /* input buffer acknowledgement flag */
         int polling;
-
         /* first ACK'ed buffer */
         int ack_start;
-
         /* how much sbals are acknowledged with qebsm */
         int ack_count;
-
         /* last time of noticing incoming data */
         u64 timestamp;
 };
@@ -199,40 +236,27 @@ struct qdio_input_q {
 struct qdio_output_q {
         /* PCIs are enabled for the queue */
         int pci_out_enabled;
-
         /* IQDIO: output multiple buffers (enhanced SIGA) */
         int use_enh_siga;
-
         /* timer to check for more outbound work */
         struct timer_list timer;
 };
 
+/*
+ * Note on cache alignment: grouped slsb and write mostly data at the beginning
+ * sbal[] is read-only and starts on a new cacheline followed by read mostly.
+ */
 struct qdio_q {
         struct slsb slsb;
+
         union {
                 struct qdio_input_q in;
                 struct qdio_output_q out;
         } u;
 
-        /* queue number */
-        int nr;
-
-        /* bitmask of queue number */
-        int mask;
-
-        /* input or output queue */
-        int is_input_q;
-
-        /* list of thinint input queues */
-        struct list_head entry;
-
-        /* upper-layer program handler */
-        qdio_handler_t (*handler);
-
         /*
          * inbound: next buffer the program should check for
-         * outbound: next buffer to check for having been processed
-         * by the card
+         * outbound: next buffer to check if adapter processed it
          */
         int first_to_check;
 
@@ -245,16 +269,32 @@ struct qdio_q {
         /* number of buffers in use by the adapter */
         atomic_t nr_buf_used;
 
-        struct qdio_irq *irq_ptr;
-        struct dentry *debugfs_q;
-        struct tasklet_struct tasklet;
-
         /* error condition during a data transfer */
         unsigned int qdio_error;
 
-        struct sl *sl;
-        struct qdio_buffer *sbal[QDIO_MAX_BUFFERS_PER_Q];
+        struct tasklet_struct tasklet;
+        struct qdio_queue_perf_stat q_stats;
+
+        struct qdio_buffer *sbal[QDIO_MAX_BUFFERS_PER_Q] ____cacheline_aligned;
+
+        /* queue number */
+        int nr;
+
+        /* bitmask of queue number */
+        int mask;
+
+        /* input or output queue */
+        int is_input_q;
+
+        /* list of thinint input queues */
+        struct list_head entry;
 
+        /* upper-layer program handler */
+        qdio_handler_t (*handler);
+
+        struct dentry *debugfs_q;
+        struct qdio_irq *irq_ptr;
+        struct sl *sl;
         /*
          * Warning: Leave this member at the end so it won't be cleared in
          * qdio_fill_qs. A page is allocated under this pointer and used for
@@ -269,6 +309,7 @@ struct qdio_irq {
         u32 *dsci;              /* address of device state change indicator */
         struct ccw_device *cdev;
         struct dentry *debugfs_dev;
+        struct dentry *debugfs_perf;
 
         unsigned long int_parm;
         struct subchannel_id schid;
@@ -286,13 +327,10 @@ struct qdio_irq {
         struct ciw aqueue;
 
         struct qdio_ssqd_desc ssqd_desc;
-
         void (*orig_handler) (struct ccw_device *, unsigned long, struct irb *);
 
-        /*
-         * Warning: Leave these members together at the end so they won't be
-         * cleared in qdio_setup_irq.
-         */
+        int perf_stat_enabled;
+
         struct qdr *qdr;
         unsigned long chsc_page;
 
@@ -301,6 +339,7 @@ struct qdio_irq {
 
         debug_info_t *debug_area;
         struct mutex setup_mutex;
+        struct qdio_dev_perf_stat perf_stat;
 };
 
 /* helper functions */
@@ -311,6 +350,21 @@ struct qdio_irq {
         (irq->qib.qfmt == QDIO_IQDIO_QFMT || \
          css_general_characteristics.aif_osa)
 
+#define qperf(__qdev, __attr)   ((__qdev)->perf_stat.(__attr))
+
+#define qperf_inc(__q, __attr)                                          \
+({                                                                      \
+        struct qdio_irq *qdev = (__q)->irq_ptr;                         \
+        if (qdev->perf_stat_enabled)                                    \
+                (qdev->perf_stat.__attr)++;                             \
+})
+
+static inline void account_sbals_error(struct qdio_q *q, int count)
+{
+        q->q_stats.nr_sbal_error += count;
+        q->q_stats.nr_sbal_total += count;
+}
+
 /* the highest iqdio queue is used for multicast */
 static inline int multicast_outbound(struct qdio_q *q)
 {
diff --git a/drivers/s390/cio/qdio_debug.c b/drivers/s390/cio/qdio_debug.c
index 76769978285f..6ce83f56d537 100644
--- a/drivers/s390/cio/qdio_debug.c
+++ b/drivers/s390/cio/qdio_debug.c
@@ -33,7 +33,6 @@ void qdio_allocate_dbf(struct qdio_initialize *init_data,
         DBF_HEX(&init_data->input_handler, sizeof(void *));
         DBF_HEX(&init_data->output_handler, sizeof(void *));
         DBF_HEX(&init_data->int_parm, sizeof(long));
-        DBF_HEX(&init_data->flags, sizeof(long));
         DBF_HEX(&init_data->input_sbal_addr_array, sizeof(void *));
         DBF_HEX(&init_data->output_sbal_addr_array, sizeof(void *));
         DBF_EVENT("irq:%8lx", (unsigned long)irq_ptr);
@@ -55,14 +54,12 @@ static int qstat_show(struct seq_file *m, void *v)
         if (!q)
                 return 0;
 
-        seq_printf(m, "device state indicator: %d\n", *(u32 *)q->irq_ptr->dsci);
-        seq_printf(m, "nr_used: %d\n", atomic_read(&q->nr_buf_used));
-        seq_printf(m, "ftc: %d\n", q->first_to_check);
-        seq_printf(m, "last_move: %d\n", q->last_move);
-        seq_printf(m, "polling: %d\n", q->u.in.polling);
-        seq_printf(m, "ack start: %d\n", q->u.in.ack_start);
-        seq_printf(m, "ack count: %d\n", q->u.in.ack_count);
-        seq_printf(m, "slsb buffer states:\n");
+        seq_printf(m, "DSCI: %d   nr_used: %d\n",
+                   *(u32 *)q->irq_ptr->dsci, atomic_read(&q->nr_buf_used));
+        seq_printf(m, "ftc: %d  last_move: %d\n", q->first_to_check, q->last_move);
+        seq_printf(m, "polling: %d  ack start: %d  ack count: %d\n",
+                   q->u.in.polling, q->u.in.ack_start, q->u.in.ack_count);
+        seq_printf(m, "SBAL states:\n");
         seq_printf(m, "|0      |8      |16     |24     |32     |40     |48     |56  63|\n");
 
         for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; i++) {
@@ -99,6 +96,20 @@ static int qstat_show(struct seq_file *m, void *v)
         }
         seq_printf(m, "\n");
         seq_printf(m, "|64     |72     |80     |88     |96     |104    |112    |   127|\n");
+
+        seq_printf(m, "\nSBAL statistics:");
+        if (!q->irq_ptr->perf_stat_enabled) {
+                seq_printf(m, " disabled\n");
+                return 0;
+        }
+
+        seq_printf(m, "\n1          2..        4..        8..        "
+                   "16..       32..       64..       127\n");
+        for (i = 0; i < ARRAY_SIZE(q->q_stats.nr_sbals); i++)
+                seq_printf(m, "%-10u ", q->q_stats.nr_sbals[i]);
+        seq_printf(m, "\nError      NOP        Total\n%-10u %-10u %-10u\n\n",
+                   q->q_stats.nr_sbal_error, q->q_stats.nr_sbal_nop,
+                   q->q_stats.nr_sbal_total);
         return 0;
 }
 
@@ -110,7 +121,6 @@ static ssize_t qstat_seq_write(struct file *file, const char __user *buf,
 
         if (!q)
                 return 0;
-
         if (q->is_input_q)
                 xchg(q->irq_ptr->dsci, 1);
         local_bh_disable();
@@ -134,6 +144,103 @@ static const struct file_operations debugfs_fops = {
         .release = single_release,
 };
 
+static char *qperf_names[] = {
+        "Assumed adapter interrupts",
+        "QDIO interrupts",
+        "Requested PCIs",
+        "Inbound tasklet runs",
+        "Inbound tasklet resched",
+        "Inbound tasklet resched2",
+        "Outbound tasklet runs",
+        "SIGA read",
+        "SIGA write",
+        "SIGA sync",
+        "Inbound calls",
+        "Inbound handler",
+        "Inbound stop_polling",
+        "Inbound queue full",
+        "Outbound calls",
+        "Outbound handler",
+        "Outbound fast_requeue",
+        "Outbound target_full",
+        "QEBSM eqbs",
+        "QEBSM eqbs partial",
+        "QEBSM sqbs",
+        "QEBSM sqbs partial"
+};
+
+static int qperf_show(struct seq_file *m, void *v)
+{
+        struct qdio_irq *irq_ptr = m->private;
+        unsigned int *stat;
+        int i;
+
+        if (!irq_ptr)
+                return 0;
+        if (!irq_ptr->perf_stat_enabled) {
+                seq_printf(m, "disabled\n");
+                return 0;
+        }
+        stat = (unsigned int *)&irq_ptr->perf_stat;
+
+        for (i = 0; i < ARRAY_SIZE(qperf_names); i++)
+                seq_printf(m, "%26s:\t%u\n",
+                           qperf_names[i], *(stat + i));
+        return 0;
+}
+
+static ssize_t qperf_seq_write(struct file *file, const char __user *ubuf,
+                               size_t count, loff_t *off)
+{
+        struct seq_file *seq = file->private_data;
+        struct qdio_irq *irq_ptr = seq->private;
+        struct qdio_q *q;
+        unsigned long val;
+        char buf[8];
+        int ret, i;
+
+        if (!irq_ptr)
+                return 0;
+        if (count >= sizeof(buf))
+                return -EINVAL;
+        if (copy_from_user(&buf, ubuf, count))
+                return -EFAULT;
+        buf[count] = 0;
+
+        ret = strict_strtoul(buf, 10, &val);
+        if (ret < 0)
+                return ret;
+
+        switch (val) {
+        case 0:
+                irq_ptr->perf_stat_enabled = 0;
+                memset(&irq_ptr->perf_stat, 0, sizeof(irq_ptr->perf_stat));
+                for_each_input_queue(irq_ptr, q, i)
+                        memset(&q->q_stats, 0, sizeof(q->q_stats));
+                for_each_output_queue(irq_ptr, q, i)
+                        memset(&q->q_stats, 0, sizeof(q->q_stats));
+                break;
+        case 1:
+                irq_ptr->perf_stat_enabled = 1;
+                break;
+        }
+        return count;
+}
+
+static int qperf_seq_open(struct inode *inode, struct file *filp)
+{
+        return single_open(filp, qperf_show,
+                           filp->f_path.dentry->d_inode->i_private);
+}
+
+static struct file_operations debugfs_perf_fops = {
+        .owner   = THIS_MODULE,
+        .open    = qperf_seq_open,
+        .read    = seq_read,
+        .write   = qperf_seq_write,
+        .llseek  = seq_lseek,
+        .release = single_release,
+};
 static void setup_debugfs_entry(struct qdio_q *q, struct ccw_device *cdev)
 {
         char name[QDIO_DEBUGFS_NAME_LEN];
@@ -156,6 +263,14 @@ void qdio_setup_debug_entries(struct qdio_irq *irq_ptr, struct ccw_device *cdev)
                                                   debugfs_root);
         if (IS_ERR(irq_ptr->debugfs_dev))
                 irq_ptr->debugfs_dev = NULL;
+
+        irq_ptr->debugfs_perf = debugfs_create_file("statistics",
+                                S_IFREG | S_IRUGO | S_IWUSR,
+                                irq_ptr->debugfs_dev, irq_ptr,
+                                &debugfs_perf_fops);
+        if (IS_ERR(irq_ptr->debugfs_perf))
+                irq_ptr->debugfs_perf = NULL;
+
         for_each_input_queue(irq_ptr, q, i)
                 setup_debugfs_entry(q, cdev);
         for_each_output_queue(irq_ptr, q, i)
@@ -171,6 +286,7 @@ void qdio_shutdown_debug_entries(struct qdio_irq *irq_ptr, struct ccw_device *cd
                 debugfs_remove(q->debugfs_q);
         for_each_output_queue(irq_ptr, q, i)
                 debugfs_remove(q->debugfs_q);
+        debugfs_remove(irq_ptr->debugfs_perf);
         debugfs_remove(irq_ptr->debugfs_dev);
 }
 
diff --git a/drivers/s390/cio/qdio_main.c b/drivers/s390/cio/qdio_main.c
index 4be6e84b9599..88be7b9ea6e1 100644
--- a/drivers/s390/cio/qdio_main.c
+++ b/drivers/s390/cio/qdio_main.c
@@ -13,6 +13,7 @@
 #include <linux/kernel.h>
 #include <linux/timer.h>
 #include <linux/delay.h>
+#include <linux/gfp.h>
 #include <asm/atomic.h>
 #include <asm/debug.h>
 #include <asm/qdio.h>
@@ -22,7 +23,6 @@
 #include "device.h"
 #include "qdio.h"
 #include "qdio_debug.h"
-#include "qdio_perf.h"
 
 MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com>,"\
         "Jan Glauber <jang@linux.vnet.ibm.com>");
@@ -126,7 +126,7 @@ static int qdio_do_eqbs(struct qdio_q *q, unsigned char *state,
         int rc;
 
         BUG_ON(!q->irq_ptr->sch_token);
-        qdio_perf_stat_inc(&perf_stats.debug_eqbs_all);
+        qperf_inc(q, eqbs);
 
         if (!q->is_input_q)
                 nr += q->irq_ptr->nr_input_qs;
@@ -139,7 +139,7 @@ again:
          * buffers later.
          */
         if ((ccq == 96) && (count != tmp_count)) {
-                qdio_perf_stat_inc(&perf_stats.debug_eqbs_incomplete);
+                qperf_inc(q, eqbs_partial);
                 return (count - tmp_count);
         }
 
@@ -182,7 +182,7 @@ static int qdio_do_sqbs(struct qdio_q *q, unsigned char state, int start,
                 return 0;
 
         BUG_ON(!q->irq_ptr->sch_token);
-        qdio_perf_stat_inc(&perf_stats.debug_sqbs_all);
+        qperf_inc(q, sqbs);
 
         if (!q->is_input_q)
                 nr += q->irq_ptr->nr_input_qs;
@@ -191,7 +191,7 @@ again:
         rc = qdio_check_ccq(q, ccq);
         if (rc == 1) {
                 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "SQBS again:%2d", ccq);
-                qdio_perf_stat_inc(&perf_stats.debug_sqbs_incomplete);
+                qperf_inc(q, sqbs_partial);
                 goto again;
         }
         if (rc < 0) {
@@ -285,7 +285,7 @@ static inline int qdio_siga_sync(struct qdio_q *q, unsigned int output,
                 return 0;
 
         DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "siga-s:%1d", q->nr);
-        qdio_perf_stat_inc(&perf_stats.siga_sync);
+        qperf_inc(q, siga_sync);
 
         cc = do_siga_sync(q->irq_ptr->schid, output, input);
         if (cc)
@@ -350,7 +350,7 @@ static inline int qdio_siga_input(struct qdio_q *q)
         int cc;
 
         DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "siga-r:%1d", q->nr);
-        qdio_perf_stat_inc(&perf_stats.siga_in);
+        qperf_inc(q, siga_read);
 
         cc = do_siga_input(q->irq_ptr->schid, q->mask);
         if (cc)
@@ -382,7 +382,7 @@ static inline void qdio_stop_polling(struct qdio_q *q)
                 return;
 
         q->u.in.polling = 0;
-        qdio_perf_stat_inc(&perf_stats.debug_stop_polling);
+        qperf_inc(q, stop_polling);
 
         /* show the card that we are not polling anymore */
         if (is_qebsm(q)) {
@@ -393,6 +393,20 @@ static inline void qdio_stop_polling(struct qdio_q *q)
                 set_buf_state(q, q->u.in.ack_start, SLSB_P_INPUT_NOT_INIT);
 }
 
+static inline void account_sbals(struct qdio_q *q, int count)
+{
+        int pos = 0;
+
+        q->q_stats.nr_sbal_total += count;
+        if (count == QDIO_MAX_BUFFERS_MASK) {
+                q->q_stats.nr_sbals[7]++;
+                return;
+        }
+        while (count >>= 1)
+                pos++;
+        q->q_stats.nr_sbals[pos]++;
+}
+
 static void announce_buffer_error(struct qdio_q *q, int count)
 {
         q->qdio_error |= QDIO_ERROR_SLSB_STATE;
@@ -400,7 +414,7 @@ static void announce_buffer_error(struct qdio_q *q, int count)
         /* special handling for no target buffer empty */
         if ((!q->is_input_q &&
             (q->sbal[q->first_to_check]->element[15].flags & 0xff) == 0x10)) {
-                qdio_perf_stat_inc(&perf_stats.outbound_target_full);
+                qperf_inc(q, target_full);
                 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "OUTFULL FTC:%02x",
                               q->first_to_check);
                 return;
@@ -486,17 +500,24 @@ static int get_inbound_buffer_frontier(struct qdio_q *q)
         case SLSB_P_INPUT_PRIMED:
                 inbound_primed(q, count);
                 q->first_to_check = add_buf(q->first_to_check, count);
-                atomic_sub(count, &q->nr_buf_used);
+                if (atomic_sub(count, &q->nr_buf_used) == 0)
+                        qperf_inc(q, inbound_queue_full);
+                if (q->irq_ptr->perf_stat_enabled)
+                        account_sbals(q, count);
                 break;
         case SLSB_P_INPUT_ERROR:
                 announce_buffer_error(q, count);
                 /* process the buffer, the upper layer will take care of it */
                 q->first_to_check = add_buf(q->first_to_check, count);
                 atomic_sub(count, &q->nr_buf_used);
+                if (q->irq_ptr->perf_stat_enabled)
+                        account_sbals_error(q, count);
                 break;
         case SLSB_CU_INPUT_EMPTY:
         case SLSB_P_INPUT_NOT_INIT:
         case SLSB_P_INPUT_ACK:
+                if (q->irq_ptr->perf_stat_enabled)
+                        q->q_stats.nr_sbal_nop++;
                 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "in nop");
                 break;
         default:
@@ -514,7 +535,7 @@ static int qdio_inbound_q_moved(struct qdio_q *q)
 
         if ((bufnr != q->last_move) || q->qdio_error) {
                 q->last_move = bufnr;
-                if (!is_thinint_irq(q->irq_ptr) && !MACHINE_IS_VM)
+                if (!is_thinint_irq(q->irq_ptr) && MACHINE_IS_LPAR)
                         q->u.in.timestamp = get_usecs();
                 return 1;
         } else
@@ -531,7 +552,7 @@ static inline int qdio_inbound_q_done(struct qdio_q *q)
         qdio_siga_sync_q(q);
         get_buf_state(q, q->first_to_check, &state, 0);
 
-        if (state == SLSB_P_INPUT_PRIMED)
+        if (state == SLSB_P_INPUT_PRIMED || state == SLSB_P_INPUT_ERROR)
                 /* more work coming */
                 return 0;
 
@@ -566,11 +587,13 @@ static void qdio_kick_handler(struct qdio_q *q)
         count = sub_buf(end, start);
 
         if (q->is_input_q) {
-                qdio_perf_stat_inc(&perf_stats.inbound_handler);
+                qperf_inc(q, inbound_handler);
                 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "kih s:%02x c:%02x", start, count);
-        } else
+        } else {
+                qperf_inc(q, outbound_handler);
                 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "koh: s:%02x c:%02x",
                               start, count);
+        }
 
         q->handler(q->irq_ptr->cdev, q->qdio_error, q->nr, start, count,
                    q->irq_ptr->int_parm);
@@ -582,24 +605,28 @@ static void qdio_kick_handler(struct qdio_q *q)
 
 static void __qdio_inbound_processing(struct qdio_q *q)
 {
-        qdio_perf_stat_inc(&perf_stats.tasklet_inbound);
+        qperf_inc(q, tasklet_inbound);
 again:
         if (!qdio_inbound_q_moved(q))
                 return;
 
         qdio_kick_handler(q);
 
-        if (!qdio_inbound_q_done(q))
+        if (!qdio_inbound_q_done(q)) {
                 /* means poll time is not yet over */
+                qperf_inc(q, tasklet_inbound_resched);
                 goto again;
+        }
 
         qdio_stop_polling(q);
         /*
          * We need to check again to not lose initiative after
          * resetting the ACK state.
          */
-        if (!qdio_inbound_q_done(q))
+        if (!qdio_inbound_q_done(q)) {
+                qperf_inc(q, tasklet_inbound_resched2);
                 goto again;
+        }
 }
 
 void qdio_inbound_processing(unsigned long data)
@@ -638,15 +665,21 @@ static int get_outbound_buffer_frontier(struct qdio_q *q)
 
                 atomic_sub(count, &q->nr_buf_used);
                 q->first_to_check = add_buf(q->first_to_check, count);
+                if (q->irq_ptr->perf_stat_enabled)
+                        account_sbals(q, count);
                 break;
         case SLSB_P_OUTPUT_ERROR:
                 announce_buffer_error(q, count);
                 /* process the buffer, the upper layer will take care of it */
                 q->first_to_check = add_buf(q->first_to_check, count);
                 atomic_sub(count, &q->nr_buf_used);
+                if (q->irq_ptr->perf_stat_enabled)
+                        account_sbals_error(q, count);
                 break;
         case SLSB_CU_OUTPUT_PRIMED:
                 /* the adapter has not fetched the output yet */
+                if (q->irq_ptr->perf_stat_enabled)
+                        q->q_stats.nr_sbal_nop++;
                 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "out primed:%1d", q->nr);
                 break;
         case SLSB_P_OUTPUT_NOT_INIT:
@@ -687,7 +720,7 @@ static int qdio_kick_outbound_q(struct qdio_q *q)
                 return 0;
 
         DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "siga-w:%1d", q->nr);
-        qdio_perf_stat_inc(&perf_stats.siga_out);
+        qperf_inc(q, siga_write);
 
         cc = qdio_siga_output(q, &busy_bit);
         switch (cc) {
@@ -710,7 +743,7 @@ static int qdio_kick_outbound_q(struct qdio_q *q)
 
 static void __qdio_outbound_processing(struct qdio_q *q)
 {
-        qdio_perf_stat_inc(&perf_stats.tasklet_outbound);
+        qperf_inc(q, tasklet_outbound);
         BUG_ON(atomic_read(&q->nr_buf_used) < 0);
 
         if (qdio_outbound_q_moved(q))
@@ -738,12 +771,9 @@ static void __qdio_outbound_processing(struct qdio_q *q)
          */
         if (qdio_outbound_q_done(q))
                 del_timer(&q->u.out.timer);
-        else {
-                if (!timer_pending(&q->u.out.timer)) {
+        else
+                if (!timer_pending(&q->u.out.timer))
                         mod_timer(&q->u.out.timer, jiffies + 10 * HZ);
-                        qdio_perf_stat_inc(&perf_stats.debug_tl_out_timer);
-                }
-        }
         return;
 
 sched:
@@ -783,7 +813,7 @@ static inline void qdio_check_outbound_after_thinint(struct qdio_q *q)
 
 static void __tiqdio_inbound_processing(struct qdio_q *q)
 {
-        qdio_perf_stat_inc(&perf_stats.thinint_inbound);
+        qperf_inc(q, tasklet_inbound);
         qdio_sync_after_thinint(q);
 
         /*
@@ -798,7 +828,7 @@ static void __tiqdio_inbound_processing(struct qdio_q *q)
         qdio_kick_handler(q);
 
         if (!qdio_inbound_q_done(q)) {
-                qdio_perf_stat_inc(&perf_stats.thinint_inbound_loop);
+                qperf_inc(q, tasklet_inbound_resched);
                 if (likely(q->irq_ptr->state != QDIO_IRQ_STATE_STOPPED)) {
                         tasklet_schedule(&q->tasklet);
                         return;
@@ -811,7 +841,7 @@ static void __tiqdio_inbound_processing(struct qdio_q *q)
          * resetting the ACK state.
          */
         if (!qdio_inbound_q_done(q)) {
-                qdio_perf_stat_inc(&perf_stats.thinint_inbound_loop2);
+                qperf_inc(q, tasklet_inbound_resched2);
                 if (likely(q->irq_ptr->state != QDIO_IRQ_STATE_STOPPED))
                         tasklet_schedule(&q->tasklet);
         }
@@ -850,8 +880,6 @@ static void qdio_int_handler_pci(struct qdio_irq *irq_ptr)
         if (unlikely(irq_ptr->state == QDIO_IRQ_STATE_STOPPED))
                 return;
 
-        qdio_perf_stat_inc(&perf_stats.pci_int);
-
         for_each_input_queue(irq_ptr, q, i)
                 tasklet_schedule(&q->tasklet);
 
@@ -922,8 +950,6 @@ void qdio_int_handler(struct ccw_device *cdev, unsigned long intparm,
         struct qdio_irq *irq_ptr = cdev->private->qdio_data;
         int cstat, dstat;
 
-        qdio_perf_stat_inc(&perf_stats.qdio_int);
-
         if (!intparm || !irq_ptr) {
                 DBF_ERROR("qint:%4x", cdev->private->schid.sch_no);
                 return;
@@ -962,6 +988,8 @@ void qdio_int_handler(struct ccw_device *cdev, unsigned long intparm,
                         qdio_handle_activate_check(cdev, intparm, cstat,
                                                    dstat);
                 break;
+        case QDIO_IRQ_STATE_STOPPED:
+                break;
         default:
                 WARN_ON(1);
         }
@@ -1382,6 +1410,8 @@ static int handle_inbound(struct qdio_q *q, unsigned int callflags,
 {
         int used, diff;
 
+        qperf_inc(q, inbound_call);
+
         if (!q->u.in.polling)
                 goto set;
 
@@ -1437,14 +1467,16 @@ static int handle_outbound(struct qdio_q *q, unsigned int callflags,
         unsigned char state;
         int used, rc = 0;
 
-        qdio_perf_stat_inc(&perf_stats.outbound_handler);
+        qperf_inc(q, outbound_call);
 
         count = set_buf_states(q, bufnr, SLSB_CU_OUTPUT_PRIMED, count);
         used = atomic_add_return(count, &q->nr_buf_used);
         BUG_ON(used > QDIO_MAX_BUFFERS_PER_Q);
 
-        if (callflags & QDIO_FLAG_PCI_OUT)
+        if (callflags & QDIO_FLAG_PCI_OUT) {
                 q->u.out.pci_out_enabled = 1;
+                qperf_inc(q, pci_request_int);
+        }
         else
                 q->u.out.pci_out_enabled = 0;
 
@@ -1483,7 +1515,7 @@ static int handle_outbound(struct qdio_q *q, unsigned int callflags,
         if (state != SLSB_CU_OUTPUT_PRIMED)
                 rc = qdio_kick_outbound_q(q);
         else
-                qdio_perf_stat_inc(&perf_stats.fast_requeue);
+                qperf_inc(q, fast_requeue);
 
 out:
         tasklet_schedule(&q->tasklet);
@@ -1539,16 +1571,11 @@ static int __init init_QDIO(void)
         rc = qdio_debug_init();
         if (rc)
                 goto out_ti;
-        rc = qdio_setup_perf_stats();
-        if (rc)
-                goto out_debug;
         rc = tiqdio_register_thinints();
         if (rc)
-                goto out_perf;
+                goto out_debug;
         return 0;
 
-out_perf:
-        qdio_remove_perf_stats();
 out_debug:
         qdio_debug_exit();
 out_ti:
@@ -1562,7 +1589,6 @@ static void __exit exit_QDIO(void)
 {
         tiqdio_unregister_thinints();
         tiqdio_free_memory();
-        qdio_remove_perf_stats();
         qdio_debug_exit();
         qdio_setup_exit();
 }
diff --git a/drivers/s390/cio/qdio_perf.c b/drivers/s390/cio/qdio_perf.c
deleted file mode 100644
index 968e3c7c2632..000000000000
--- a/drivers/s390/cio/qdio_perf.c
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- *  drivers/s390/cio/qdio_perf.c
- *
- *  Copyright IBM Corp. 2008
- *
- *  Author: Jan Glauber (jang@linux.vnet.ibm.com)
- */
-#include <linux/kernel.h>
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
-#include <asm/ccwdev.h>
-
-#include "cio.h"
-#include "css.h"
-#include "device.h"
-#include "ioasm.h"
-#include "chsc.h"
-#include "qdio_debug.h"
-#include "qdio_perf.h"
-
-int qdio_performance_stats;
-struct qdio_perf_stats perf_stats;
-
-#ifdef CONFIG_PROC_FS
-static struct proc_dir_entry *qdio_perf_pde;
-#endif
-
-/*
- * procfs functions
- */
-static int qdio_perf_proc_show(struct seq_file *m, void *v)
-{
-        seq_printf(m, "Number of qdio interrupts\t\t\t: %li\n",
-                   (long)atomic_long_read(&perf_stats.qdio_int));
-        seq_printf(m, "Number of PCI interrupts\t\t\t: %li\n",
-                   (long)atomic_long_read(&perf_stats.pci_int));
-        seq_printf(m, "Number of adapter interrupts\t\t\t: %li\n",
-                   (long)atomic_long_read(&perf_stats.thin_int));
-        seq_printf(m, "\n");
-        seq_printf(m, "Inbound tasklet runs\t\t\t\t: %li\n",
-                   (long)atomic_long_read(&perf_stats.tasklet_inbound));
-        seq_printf(m, "Outbound tasklet runs\t\t\t\t: %li\n",
-                   (long)atomic_long_read(&perf_stats.tasklet_outbound));
-        seq_printf(m, "Adapter interrupt tasklet runs/loops\t\t: %li/%li\n",
-                   (long)atomic_long_read(&perf_stats.tasklet_thinint),
-                   (long)atomic_long_read(&perf_stats.tasklet_thinint_loop));
-        seq_printf(m, "Adapter interrupt inbound tasklet runs/loops\t: %li/%li\n",
-                   (long)atomic_long_read(&perf_stats.thinint_inbound),
-                   (long)atomic_long_read(&perf_stats.thinint_inbound_loop));
-        seq_printf(m, "\n");
-        seq_printf(m, "Number of SIGA In issued\t\t\t: %li\n",
-                   (long)atomic_long_read(&perf_stats.siga_in));
-        seq_printf(m, "Number of SIGA Out issued\t\t\t: %li\n",
-                   (long)atomic_long_read(&perf_stats.siga_out));
-        seq_printf(m, "Number of SIGA Sync issued\t\t\t: %li\n",
-                   (long)atomic_long_read(&perf_stats.siga_sync));
-        seq_printf(m, "\n");
-        seq_printf(m, "Number of inbound transfers\t\t\t: %li\n",
-                   (long)atomic_long_read(&perf_stats.inbound_handler));
-        seq_printf(m, "Number of outbound transfers\t\t\t: %li\n",
-                   (long)atomic_long_read(&perf_stats.outbound_handler));
-        seq_printf(m, "\n");
-        seq_printf(m, "Number of fast requeues (outg. SBAL w/o SIGA)\t: %li\n",
-                   (long)atomic_long_read(&perf_stats.fast_requeue));
-        seq_printf(m, "Number of outbound target full condition\t: %li\n",
-                   (long)atomic_long_read(&perf_stats.outbound_target_full));
-        seq_printf(m, "Number of outbound tasklet mod_timer calls\t: %li\n",
-                   (long)atomic_long_read(&perf_stats.debug_tl_out_timer));
-        seq_printf(m, "Number of stop polling calls\t\t\t: %li\n",
-                   (long)atomic_long_read(&perf_stats.debug_stop_polling));
-        seq_printf(m, "AI inbound tasklet loops after stop polling\t: %li\n",
-                   (long)atomic_long_read(&perf_stats.thinint_inbound_loop2));
-        seq_printf(m, "QEBSM EQBS total/incomplete\t\t\t: %li/%li\n",
-                   (long)atomic_long_read(&perf_stats.debug_eqbs_all),
-                   (long)atomic_long_read(&perf_stats.debug_eqbs_incomplete));
-        seq_printf(m, "QEBSM SQBS total/incomplete\t\t\t: %li/%li\n",
-                   (long)atomic_long_read(&perf_stats.debug_sqbs_all),
-                   (long)atomic_long_read(&perf_stats.debug_sqbs_incomplete));
-        seq_printf(m, "\n");
-        return 0;
-}
-static int qdio_perf_seq_open(struct inode *inode, struct file *filp)
-{
-        return single_open(filp, qdio_perf_proc_show, NULL);
-}
-
-static const struct file_operations qdio_perf_proc_fops = {
-        .owner   = THIS_MODULE,
-        .open    = qdio_perf_seq_open,
-        .read    = seq_read,
-        .llseek  = seq_lseek,
-        .release = single_release,
-};
-
-/*
- * sysfs functions
- */
-static ssize_t qdio_perf_stats_show(struct bus_type *bus, char *buf)
-{
-        return sprintf(buf, "%i\n", qdio_performance_stats ? 1 : 0);
-}
-
-static ssize_t qdio_perf_stats_store(struct bus_type *bus,
-                              const char *buf, size_t count)
-{
-        unsigned long i;
-
-        if (strict_strtoul(buf, 16, &i) != 0)
-                return -EINVAL;
-        if ((i != 0) && (i != 1))
-                return -EINVAL;
-        if (i == qdio_performance_stats)
-                return count;
-
-        qdio_performance_stats = i;
-        /* reset performance statistics */
-        if (i == 0)
-                memset(&perf_stats, 0, sizeof(struct qdio_perf_stats));
-        return count;
-}
-
-static BUS_ATTR(qdio_performance_stats, 0644, qdio_perf_stats_show,
-                qdio_perf_stats_store);
-
-int __init qdio_setup_perf_stats(void)
-{
-        int rc;
-
-        rc = bus_create_file(&ccw_bus_type, &bus_attr_qdio_performance_stats);
-        if (rc)
-                return rc;
-
-#ifdef CONFIG_PROC_FS
-        memset(&perf_stats, 0, sizeof(struct qdio_perf_stats));
-        qdio_perf_pde = proc_create("qdio_perf", S_IFREG | S_IRUGO,
-                                    NULL, &qdio_perf_proc_fops);
-#endif
-        return 0;
-}
-
-void qdio_remove_perf_stats(void)
-{
-#ifdef CONFIG_PROC_FS
-        remove_proc_entry("qdio_perf", NULL);
-#endif
-        bus_remove_file(&ccw_bus_type, &bus_attr_qdio_performance_stats);
-}
diff --git a/drivers/s390/cio/qdio_perf.h b/drivers/s390/cio/qdio_perf.h
deleted file mode 100644
index ff4504ce1e3c..000000000000
--- a/drivers/s390/cio/qdio_perf.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- *  drivers/s390/cio/qdio_perf.h
- *
- *  Copyright IBM Corp. 2008
- *
- *  Author: Jan Glauber (jang@linux.vnet.ibm.com)
- */
-#ifndef QDIO_PERF_H
-#define QDIO_PERF_H
-
-#include <linux/types.h>
-#include <asm/atomic.h>
-
-struct qdio_perf_stats {
-        /* interrupt handler calls */
-        atomic_long_t qdio_int;
-        atomic_long_t pci_int;
-        atomic_long_t thin_int;
-
-        /* tasklet runs */
-        atomic_long_t tasklet_inbound;
-        atomic_long_t tasklet_outbound;
-        atomic_long_t tasklet_thinint;
-        atomic_long_t tasklet_thinint_loop;
-        atomic_long_t thinint_inbound;
-        atomic_long_t thinint_inbound_loop;
-        atomic_long_t thinint_inbound_loop2;
-
-        /* signal adapter calls */
-        atomic_long_t siga_out;
-        atomic_long_t siga_in;
-        atomic_long_t siga_sync;
-
-        /* misc */
-        atomic_long_t inbound_handler;
-        atomic_long_t outbound_handler;
-        atomic_long_t fast_requeue;
-        atomic_long_t outbound_target_full;
-
-        /* for debugging */
-        atomic_long_t debug_tl_out_timer;
-        atomic_long_t debug_stop_polling;
-        atomic_long_t debug_eqbs_all;
-        atomic_long_t debug_eqbs_incomplete;
-        atomic_long_t debug_sqbs_all;
-        atomic_long_t debug_sqbs_incomplete;
-};
-
-extern struct qdio_perf_stats perf_stats;
-extern int qdio_performance_stats;
-
-static inline void qdio_perf_stat_inc(atomic_long_t *count)
-{
-        if (qdio_performance_stats)
-                atomic_long_inc(count);
-}
-
-int qdio_setup_perf_stats(void);
-void qdio_remove_perf_stats(void);
-
-#endif
diff --git a/drivers/s390/cio/qdio_setup.c b/drivers/s390/cio/qdio_setup.c
index 18d54fc21ce9..7f4a75465140 100644
--- a/drivers/s390/cio/qdio_setup.c
+++ b/drivers/s390/cio/qdio_setup.c
@@ -48,7 +48,6 @@ static void set_impl_params(struct qdio_irq *irq_ptr,
         if (!irq_ptr)
                 return;
 
-        WARN_ON((unsigned long)&irq_ptr->qib & 0xff);
         irq_ptr->qib.pfmt = qib_param_field_format;
         if (qib_param_field)
                 memcpy(irq_ptr->qib.parm, qib_param_field,
@@ -82,14 +81,12 @@ static int __qdio_allocate_qs(struct qdio_q **irq_ptr_qs, int nr_queues)
                 q = kmem_cache_alloc(qdio_q_cache, GFP_KERNEL);
                 if (!q)
                         return -ENOMEM;
-                WARN_ON((unsigned long)q & 0xff);
 
                 q->slib = (struct slib *) __get_free_page(GFP_KERNEL);
                 if (!q->slib) {
                         kmem_cache_free(qdio_q_cache, q);
                         return -ENOMEM;
                 }
-                WARN_ON((unsigned long)q->slib & 0x7ff);
                 irq_ptr_qs[i] = q;
         }
         return 0;
@@ -131,7 +128,7 @@ static void setup_storage_lists(struct qdio_q *q, struct qdio_irq *irq_ptr,
         /* fill in sbal */
         for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; j++) {
                 q->sbal[j] = *sbals_array++;
-                WARN_ON((unsigned long)q->sbal[j] & 0xff);
+                BUG_ON((unsigned long)q->sbal[j] & 0xff);
         }
 
         /* fill in slib */
@@ -147,11 +144,6 @@ static void setup_storage_lists(struct qdio_q *q, struct qdio_irq *irq_ptr,
         /* fill in sl */
         for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; j++)
                 q->sl->element[j].sbal = (unsigned long)q->sbal[j];
-
-        DBF_EVENT("sl-slsb-sbal");
-        DBF_HEX(q->sl, sizeof(void *));
-        DBF_HEX(&q->slsb, sizeof(void *));
-        DBF_HEX(q->sbal, sizeof(void *));
 }
 
 static void setup_queues(struct qdio_irq *irq_ptr,
@@ -341,10 +333,10 @@ static void __qdio_allocate_fill_qdr(struct qdio_irq *irq_ptr,
         irq_ptr->qdr->qdf0[i + nr].slsba =
                 (unsigned long)&irq_ptr_qs[i]->slsb.val[0];
 
-        irq_ptr->qdr->qdf0[i + nr].akey = PAGE_DEFAULT_KEY;
-        irq_ptr->qdr->qdf0[i + nr].bkey = PAGE_DEFAULT_KEY;
-        irq_ptr->qdr->qdf0[i + nr].ckey = PAGE_DEFAULT_KEY;
-        irq_ptr->qdr->qdf0[i + nr].dkey = PAGE_DEFAULT_KEY;
+        irq_ptr->qdr->qdf0[i + nr].akey = PAGE_DEFAULT_KEY >> 4;
+        irq_ptr->qdr->qdf0[i + nr].bkey = PAGE_DEFAULT_KEY >> 4;
+        irq_ptr->qdr->qdf0[i + nr].ckey = PAGE_DEFAULT_KEY >> 4;
+        irq_ptr->qdr->qdf0[i + nr].dkey = PAGE_DEFAULT_KEY >> 4;
 }
 
 static void setup_qdr(struct qdio_irq *irq_ptr,
@@ -358,7 +350,7 @@ static void setup_qdr(struct qdio_irq *irq_ptr,
         irq_ptr->qdr->iqdsz = sizeof(struct qdesfmt0) / 4; /* size in words */
         irq_ptr->qdr->oqdsz = sizeof(struct qdesfmt0) / 4;
         irq_ptr->qdr->qiba = (unsigned long)&irq_ptr->qib;
-        irq_ptr->qdr->qkey = PAGE_DEFAULT_KEY;
+        irq_ptr->qdr->qkey = PAGE_DEFAULT_KEY >> 4;
 
         for (i = 0; i < qdio_init->no_input_qs; i++)
                 __qdio_allocate_fill_qdr(irq_ptr, irq_ptr->input_qs, i, 0);
@@ -390,7 +382,15 @@ int qdio_setup_irq(struct qdio_initialize *init_data)
         struct qdio_irq *irq_ptr = init_data->cdev->private->qdio_data;
         int rc;
 
-        memset(irq_ptr, 0, ((char *)&irq_ptr->qdr) - ((char *)irq_ptr));
+        memset(&irq_ptr->qib, 0, sizeof(irq_ptr->qib));
+        memset(&irq_ptr->siga_flag, 0, sizeof(irq_ptr->siga_flag));
+        memset(&irq_ptr->ccw, 0, sizeof(irq_ptr->ccw));
+        memset(&irq_ptr->ssqd_desc, 0, sizeof(irq_ptr->ssqd_desc));
+        memset(&irq_ptr->perf_stat, 0, sizeof(irq_ptr->perf_stat));
+
+        irq_ptr->debugfs_dev = irq_ptr->debugfs_perf = NULL;
+        irq_ptr->sch_token = irq_ptr->state = irq_ptr->perf_stat_enabled = 0;
+
         /* wipes qib.ac, required by ar7063 */
         memset(irq_ptr->qdr, 0, sizeof(struct qdr));
 
diff --git a/drivers/s390/cio/qdio_thinint.c b/drivers/s390/cio/qdio_thinint.c
index 981a77ea7ee2..ce5f8910ff83 100644
--- a/drivers/s390/cio/qdio_thinint.c
+++ b/drivers/s390/cio/qdio_thinint.c
@@ -1,14 +1,13 @@
 /*
  * linux/drivers/s390/cio/thinint_qdio.c
  *
- * thin interrupt support for qdio
- *
- * Copyright 2000-2008 IBM Corp.
+ * Copyright 2000,2009 IBM Corp.
  * Author(s): Utz Bacher <utz.bacher@de.ibm.com>
  *            Cornelia Huck <cornelia.huck@de.ibm.com>
  *            Jan Glauber <jang@linux.vnet.ibm.com>
  */
 #include <linux/io.h>
+#include <linux/slab.h>
 #include <asm/atomic.h>
 #include <asm/debug.h>
 #include <asm/qdio.h>
@@ -19,7 +18,6 @@
 #include "ioasm.h"
 #include "qdio.h"
 #include "qdio_debug.h"
-#include "qdio_perf.h"
 
 /*
  * Restriction: only 63 iqdio subchannels would have its own indicator,
@@ -132,8 +130,6 @@ static void tiqdio_thinint_handler(void *ind, void *drv_data)
 {
         struct qdio_q *q;
 
-        qdio_perf_stat_inc(&perf_stats.thin_int);
-
         /*
          * SVS only when needed: issue SVS to benefit from iqdio interrupt
          * avoidance (SVS clears adapter interrupt suppression overwrite)
@@ -154,6 +150,7 @@ static void tiqdio_thinint_handler(void *ind, void *drv_data)
         list_for_each_entry_rcu(q, &tiq_list, entry)
                 /* only process queues from changed sets */
                 if (*q->irq_ptr->dsci) {
+                        qperf_inc(q, adapter_int);
 
                         /* only clear it if the indicator is non-shared */
                         if (!shared_ind(q->irq_ptr))
@@ -202,8 +199,8 @@ static int set_subchannel_ind(struct qdio_irq *irq_ptr, int reset)
                 .code   = 0x0021,
         };
         scssc_area->operation_code = 0;
-        scssc_area->ks = PAGE_DEFAULT_KEY;
-        scssc_area->kc = PAGE_DEFAULT_KEY;
+        scssc_area->ks = PAGE_DEFAULT_KEY >> 4;
+        scssc_area->kc = PAGE_DEFAULT_KEY >> 4;
         scssc_area->isc = QDIO_AIRQ_ISC;
         scssc_area->schid = irq_ptr->schid;
 
diff --git a/drivers/s390/crypto/ap_bus.c b/drivers/s390/crypto/ap_bus.c
index 1294876bf7b4..91c6028d7b74 100644
--- a/drivers/s390/crypto/ap_bus.c
+++ b/drivers/s390/crypto/ap_bus.c
@@ -33,6 +33,7 @@
 #include <linux/err.h>
 #include <linux/interrupt.h>
 #include <linux/workqueue.h>
+#include <linux/slab.h>
 #include <linux/notifier.h>
 #include <linux/kthread.h>
 #include <linux/mutex.h>
@@ -102,6 +103,7 @@ static atomic_t ap_poll_requests = ATOMIC_INIT(0);
 static DECLARE_WAIT_QUEUE_HEAD(ap_poll_wait);
 static struct task_struct *ap_poll_kthread = NULL;
 static DEFINE_MUTEX(ap_poll_thread_mutex);
+static DEFINE_SPINLOCK(ap_poll_timer_lock);
 static void *ap_interrupt_indicator;
 static struct hrtimer ap_poll_timer;
 /* In LPAR poll with 4kHz frequency. Poll every 250000 nanoseconds.
@@ -282,6 +284,7 @@ static int ap_queue_enable_interruption(ap_qid_t qid, void *ind)
  * @psmid: The program supplied message identifier
  * @msg: The message text
  * @length: The message length
+ * @special: Special Bit
  *
  * Returns AP queue status structure.
  * Condition code 1 on NQAP can't happen because the L bit is 1.
@@ -289,7 +292,8 @@ static int ap_queue_enable_interruption(ap_qid_t qid, void *ind)
  * because a segment boundary was reached. The NQAP is repeated.
  */
 static inline struct ap_queue_status
-__ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length)
+__ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length,
+          unsigned int special)
 {
         typedef struct { char _[length]; } msgblock;
         register unsigned long reg0 asm ("0") = qid | 0x40000000UL;
@@ -299,6 +303,9 @@ __ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length)
         register unsigned long reg4 asm ("4") = (unsigned int) (psmid >> 32);
         register unsigned long reg5 asm ("5") = (unsigned int) psmid;
 
+        if (special == 1)
+                reg0 |= 0x400000UL;
+
         asm volatile (
                 "0: .long 0xb2ad0042\n"         /* DQAP */
                 "   brc   2,0b"
@@ -312,13 +319,15 @@ int ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length)
 {
         struct ap_queue_status status;
 
-        status = __ap_send(qid, psmid, msg, length);
+        status = __ap_send(qid, psmid, msg, length, 0);
         switch (status.response_code) {
         case AP_RESPONSE_NORMAL:
                 return 0;
         case AP_RESPONSE_Q_FULL:
         case AP_RESPONSE_RESET_IN_PROGRESS:
                 return -EBUSY;
+        case AP_RESPONSE_REQ_FAC_NOT_INST:
+                return -EINVAL;
         default:        /* Device is gone. */
                 return -ENODEV;
         }
@@ -1008,7 +1017,7 @@ static int ap_probe_device_type(struct ap_device *ap_dev)
         }
 
         status = __ap_send(ap_dev->qid, 0x0102030405060708ULL,
-                           msg, sizeof(msg));
+                           msg, sizeof(msg), 0);
         if (status.response_code != AP_RESPONSE_NORMAL) {
                 rc = -ENODEV;
                 goto out_free;
@@ -1163,16 +1172,19 @@ ap_config_timeout(unsigned long ptr)
 static inline void ap_schedule_poll_timer(void)
 {
         ktime_t hr_time;
+
+        spin_lock_bh(&ap_poll_timer_lock);
         if (ap_using_interrupts() || ap_suspend_flag)
-                return;
+                goto out;
         if (hrtimer_is_queued(&ap_poll_timer))
-                return;
+                goto out;
         if (ktime_to_ns(hrtimer_expires_remaining(&ap_poll_timer)) <= 0) {
                 hr_time = ktime_set(0, poll_timeout);
                 hrtimer_forward_now(&ap_poll_timer, hr_time);
                 hrtimer_restart(&ap_poll_timer);
         }
-        return;
+out:
+        spin_unlock_bh(&ap_poll_timer_lock);
 }
 
 /**
@@ -1243,7 +1255,7 @@ static int ap_poll_write(struct ap_device *ap_dev, unsigned long *flags)
         /* Start the next request on the queue. */
         ap_msg = list_entry(ap_dev->requestq.next, struct ap_message, list);
         status = __ap_send(ap_dev->qid, ap_msg->psmid,
-                           ap_msg->message, ap_msg->length);
+                           ap_msg->message, ap_msg->length, ap_msg->special);
         switch (status.response_code) {
         case AP_RESPONSE_NORMAL:
                 atomic_inc(&ap_poll_requests);
@@ -1261,6 +1273,7 @@ static int ap_poll_write(struct ap_device *ap_dev, unsigned long *flags)
                 *flags |= 2;
                 break;
         case AP_RESPONSE_MESSAGE_TOO_BIG:
+        case AP_RESPONSE_REQ_FAC_NOT_INST:
                 return -EINVAL;
         default:
                 return -ENODEV;
@@ -1302,7 +1315,8 @@ static int __ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_ms
         if (list_empty(&ap_dev->requestq) &&
             ap_dev->queue_count < ap_dev->queue_depth) {
                 status = __ap_send(ap_dev->qid, ap_msg->psmid,
-                                   ap_msg->message, ap_msg->length);
+                                   ap_msg->message, ap_msg->length,
+                                   ap_msg->special);
                 switch (status.response_code) {
                 case AP_RESPONSE_NORMAL:
                         list_add_tail(&ap_msg->list, &ap_dev->pendingq);
@@ -1317,6 +1331,7 @@ static int __ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_ms
                         ap_dev->requestq_count++;
                         ap_dev->total_request_count++;
                         return -EBUSY;
+                case AP_RESPONSE_REQ_FAC_NOT_INST:
                 case AP_RESPONSE_MESSAGE_TOO_BIG:
                         ap_dev->drv->receive(ap_dev, ap_msg, ERR_PTR(-EINVAL));
                         return -EINVAL;
@@ -1658,6 +1673,7 @@ int __init ap_module_init(void)
          */
         if (MACHINE_IS_VM)
                 poll_timeout = 1500000;
+        spin_lock_init(&ap_poll_timer_lock);
         hrtimer_init(&ap_poll_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
         ap_poll_timer.function = ap_poll_timeout;
 
diff --git a/drivers/s390/crypto/ap_bus.h b/drivers/s390/crypto/ap_bus.h
index a35362241805..4785d07cd447 100644
--- a/drivers/s390/crypto/ap_bus.h
+++ b/drivers/s390/crypto/ap_bus.h
@@ -87,6 +87,7 @@ struct ap_queue_status {
 #define AP_RESPONSE_INDEX_TOO_BIG       0x11
 #define AP_RESPONSE_NO_FIRST_PART       0x13
 #define AP_RESPONSE_MESSAGE_TOO_BIG     0x15
+#define AP_RESPONSE_REQ_FAC_NOT_INST    0x16
 
 /*
  * Known device types
@@ -96,8 +97,8 @@ struct ap_queue_status {
 #define AP_DEVICE_TYPE_PCIXCC   5
 #define AP_DEVICE_TYPE_CEX2A    6
 #define AP_DEVICE_TYPE_CEX2C    7
-#define AP_DEVICE_TYPE_CEX2A2   8
-#define AP_DEVICE_TYPE_CEX2C2   9
+#define AP_DEVICE_TYPE_CEX3A    8
+#define AP_DEVICE_TYPE_CEX3C    9
 
 /*
  * AP reset flag states
@@ -161,12 +162,25 @@ struct ap_message {
         size_t length;                  /* Message length. */
 
         void *private;                  /* ap driver private pointer. */
+        unsigned int special:1;         /* Used for special commands. */
 };
 
 #define AP_DEVICE(dt)                                   \
         .dev_type=(dt),                                 \
         .match_flags=AP_DEVICE_ID_MATCH_DEVICE_TYPE,
 
+/**
+ * ap_init_message() - Initialize ap_message.
+ * Initialize a message before using. Otherwise this might result in
+ * unexpected behaviour.
+ */
+static inline void ap_init_message(struct ap_message *ap_msg)
+{
+        ap_msg->psmid = 0;
+        ap_msg->length = 0;
+        ap_msg->special = 0;
+}
+
 /*
  * Note: don't use ap_send/ap_recv after using ap_queue_message
  * for the first time. Otherwise the ap message queue will get
diff --git a/drivers/s390/crypto/zcrypt_api.c b/drivers/s390/crypto/zcrypt_api.c
index 65b6a96afe6b..304caf549973 100644
--- a/drivers/s390/crypto/zcrypt_api.c
+++ b/drivers/s390/crypto/zcrypt_api.c
@@ -33,8 +33,10 @@
 #include <linux/miscdevice.h>
 #include <linux/fs.h>
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/compat.h>
 #include <linux/smp_lock.h>
+#include <linux/slab.h>
 #include <asm/atomic.h>
 #include <asm/uaccess.h>
 #include <linux/hw_random.h>
@@ -299,9 +301,7 @@ static ssize_t zcrypt_write(struct file *filp, const char __user *buf,
  */
 static int zcrypt_open(struct inode *inode, struct file *filp)
 {
-        lock_kernel();
         atomic_inc(&zcrypt_open_count);
-        unlock_kernel();
         return 0;
 }
 
@@ -395,10 +395,12 @@ static long zcrypt_rsa_crt(struct ica_rsa_modexpo_crt *crt)
                          * u_mult_inv > 128 bytes.
                          */
                         if (copied == 0) {
-                                int len;
+                                unsigned int len;
                                 spin_unlock_bh(&zcrypt_device_lock);
                                 /* len is max 256 / 2 - 120 = 8 */
                                 len = crt->inputdatalength / 2 - 120;
+                                if (len > sizeof(z1))
+                                        return -EFAULT;
                                 z1 = z2 = z3 = 0;
                                 if (copy_from_user(&z1, crt->np_prime, len) ||
                                     copy_from_user(&z2, crt->bp_key, len) ||
@@ -912,122 +914,105 @@ static struct miscdevice zcrypt_misc_device = {
  */
 static struct proc_dir_entry *zcrypt_entry;
 
-static int sprintcl(unsigned char *outaddr, unsigned char *addr,
-                    unsigned int len)
+static void sprintcl(struct seq_file *m, unsigned char *addr, unsigned int len)
 {
-        int hl, i;
+        int i;
 
-        hl = 0;
         for (i = 0; i < len; i++)
-                hl += sprintf(outaddr+hl, "%01x", (unsigned int) addr[i]);
-        hl += sprintf(outaddr+hl, " ");
-        return hl;
+                seq_printf(m, "%01x", (unsigned int) addr[i]);
+        seq_putc(m, ' ');
 }
 
-static int sprintrw(unsigned char *outaddr, unsigned char *addr,
-                    unsigned int len)
+static void sprintrw(struct seq_file *m, unsigned char *addr, unsigned int len)
 {
-        int hl, inl, c, cx;
+        int inl, c, cx;
 
-        hl = sprintf(outaddr, "    ");
+        seq_printf(m, "    ");
         inl = 0;
         for (c = 0; c < (len / 16); c++) {
-                hl += sprintcl(outaddr+hl, addr+inl, 16);
+                sprintcl(m, addr+inl, 16);
                 inl += 16;
         }
         cx = len%16;
         if (cx) {
-                hl += sprintcl(outaddr+hl, addr+inl, cx);
+                sprintcl(m, addr+inl, cx);
                 inl += cx;
         }
-        hl += sprintf(outaddr+hl, "\n");
-        return hl;
+        seq_putc(m, '\n');
 }
 
-static int sprinthx(unsigned char *title, unsigned char *outaddr,
-                    unsigned char *addr, unsigned int len)
+static void sprinthx(unsigned char *title, struct seq_file *m,
+                     unsigned char *addr, unsigned int len)
 {
-        int hl, inl, r, rx;
+        int inl, r, rx;
 
-        hl = sprintf(outaddr, "\n%s\n", title);
+        seq_printf(m, "\n%s\n", title);
         inl = 0;
         for (r = 0; r < (len / 64); r++) {
-                hl += sprintrw(outaddr+hl, addr+inl, 64);
+                sprintrw(m, addr+inl, 64);
                 inl += 64;
         }
         rx = len % 64;
         if (rx) {
-                hl += sprintrw(outaddr+hl, addr+inl, rx);
+                sprintrw(m, addr+inl, rx);
                 inl += rx;
         }
-        hl += sprintf(outaddr+hl, "\n");
-        return hl;
+        seq_putc(m, '\n');
 }
 
-static int sprinthx4(unsigned char *title, unsigned char *outaddr,
-                     unsigned int *array, unsigned int len)
+static void sprinthx4(unsigned char *title, struct seq_file *m,
+                      unsigned int *array, unsigned int len)
 {
-        int hl, r;
+        int r;
 
-        hl = sprintf(outaddr, "\n%s\n", title);
+        seq_printf(m, "\n%s\n", title);
         for (r = 0; r < len; r++) {
                 if ((r % 8) == 0)
-                        hl += sprintf(outaddr+hl, "    ");
-                hl += sprintf(outaddr+hl, "%08X ", array[r]);
+                        seq_printf(m, "    ");
+                seq_printf(m, "%08X ", array[r]);
                 if ((r % 8) == 7)
-                        hl += sprintf(outaddr+hl, "\n");
+                        seq_putc(m, '\n');
         }
-        hl += sprintf(outaddr+hl, "\n");
-        return hl;
+        seq_putc(m, '\n');
 }
 
-static int zcrypt_status_read(char *resp_buff, char **start, off_t offset,
-                              int count, int *eof, void *data)
+static int zcrypt_proc_show(struct seq_file *m, void *v)
 {
-        unsigned char *workarea;
-        int len;
-
-        len = 0;
-
-        /* resp_buff is a page. Use the right half for a work area */
-        workarea = resp_buff + 2000;
-        len += sprintf(resp_buff + len, "\nzcrypt version: %d.%d.%d\n",
-                ZCRYPT_VERSION, ZCRYPT_RELEASE, ZCRYPT_VARIANT);
-        len += sprintf(resp_buff + len, "Cryptographic domain: %d\n",
-                       ap_domain_index);
-        len += sprintf(resp_buff + len, "Total device count: %d\n",
-                       zcrypt_device_count);
-        len += sprintf(resp_buff + len, "PCICA count: %d\n",
-                       zcrypt_count_type(ZCRYPT_PCICA));
-        len += sprintf(resp_buff + len, "PCICC count: %d\n",
-                       zcrypt_count_type(ZCRYPT_PCICC));
-        len += sprintf(resp_buff + len, "PCIXCC MCL2 count: %d\n",
-                       zcrypt_count_type(ZCRYPT_PCIXCC_MCL2));
-        len += sprintf(resp_buff + len, "PCIXCC MCL3 count: %d\n",
-                       zcrypt_count_type(ZCRYPT_PCIXCC_MCL3));
-        len += sprintf(resp_buff + len, "CEX2C count: %d\n",
-                       zcrypt_count_type(ZCRYPT_CEX2C));
-        len += sprintf(resp_buff + len, "CEX2A count: %d\n",
-                       zcrypt_count_type(ZCRYPT_CEX2A));
-        len += sprintf(resp_buff + len, "requestq count: %d\n",
-                       zcrypt_requestq_count());
-        len += sprintf(resp_buff + len, "pendingq count: %d\n",
-                       zcrypt_pendingq_count());
-        len += sprintf(resp_buff + len, "Total open handles: %d\n\n",
-                       atomic_read(&zcrypt_open_count));
+        char workarea[sizeof(int) * AP_DEVICES];
+
+        seq_printf(m, "\nzcrypt version: %d.%d.%d\n",
+                   ZCRYPT_VERSION, ZCRYPT_RELEASE, ZCRYPT_VARIANT);
+        seq_printf(m, "Cryptographic domain: %d\n", ap_domain_index);
+        seq_printf(m, "Total device count: %d\n", zcrypt_device_count);
+        seq_printf(m, "PCICA count: %d\n", zcrypt_count_type(ZCRYPT_PCICA));
+        seq_printf(m, "PCICC count: %d\n", zcrypt_count_type(ZCRYPT_PCICC));
+        seq_printf(m, "PCIXCC MCL2 count: %d\n",
+                   zcrypt_count_type(ZCRYPT_PCIXCC_MCL2));
+        seq_printf(m, "PCIXCC MCL3 count: %d\n",
+                   zcrypt_count_type(ZCRYPT_PCIXCC_MCL3));
+        seq_printf(m, "CEX2C count: %d\n", zcrypt_count_type(ZCRYPT_CEX2C));
+        seq_printf(m, "CEX2A count: %d\n", zcrypt_count_type(ZCRYPT_CEX2A));
+        seq_printf(m, "CEX3C count: %d\n", zcrypt_count_type(ZCRYPT_CEX3C));
+        seq_printf(m, "CEX3A count: %d\n", zcrypt_count_type(ZCRYPT_CEX3A));
+        seq_printf(m, "requestq count: %d\n", zcrypt_requestq_count());
+        seq_printf(m, "pendingq count: %d\n", zcrypt_pendingq_count());
+        seq_printf(m, "Total open handles: %d\n\n",
+                   atomic_read(&zcrypt_open_count));
         zcrypt_status_mask(workarea);
-        len += sprinthx("Online devices: 1=PCICA 2=PCICC 3=PCIXCC(MCL2) "
-                        "4=PCIXCC(MCL3) 5=CEX2C 6=CEX2A",
-                        resp_buff+len, workarea, AP_DEVICES);
+        sprinthx("Online devices: 1=PCICA 2=PCICC 3=PCIXCC(MCL2) "
+                 "4=PCIXCC(MCL3) 5=CEX2C 6=CEX2A 7=CEX3C 8=CEX3A",
+                 m, workarea, AP_DEVICES);
         zcrypt_qdepth_mask(workarea);
-        len += sprinthx("Waiting work element counts",
-                        resp_buff+len, workarea, AP_DEVICES);
+        sprinthx("Waiting work element counts", m, workarea, AP_DEVICES);
         zcrypt_perdev_reqcnt((int *) workarea);
-        len += sprinthx4("Per-device successfully completed request counts",
-                         resp_buff+len,(unsigned int *) workarea, AP_DEVICES);
-        *eof = 1;
-        memset((void *) workarea, 0x00, AP_DEVICES * sizeof(unsigned int));
-        return len;
+        sprinthx4("Per-device successfully completed request counts",
+                  m, (unsigned int *) workarea, AP_DEVICES);
+        return 0;
+}
+
+static int zcrypt_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, zcrypt_proc_show, NULL);
 }
 
 static void zcrypt_disable_card(int index)
@@ -1057,11 +1042,11 @@ static void zcrypt_enable_card(int index)
         spin_unlock_bh(&zcrypt_device_lock);
 }
 
-static int zcrypt_status_write(struct file *file, const char __user *buffer,
-                               unsigned long count, void *data)
+static ssize_t zcrypt_proc_write(struct file *file, const char __user *buffer,
+                                 size_t count, loff_t *pos)
 {
         unsigned char *lbuf, *ptr;
-        unsigned long local_count;
+        size_t local_count;
         int j;
 
         if (count <= 0)
@@ -1095,8 +1080,9 @@ static int zcrypt_status_write(struct file *file, const char __user *buffer,
                  * '0' for no device, '1' for PCICA, '2' for PCICC,
                  * '3' for PCIXCC_MCL2, '4' for PCIXCC_MCL3,
                  * '5' for CEX2C and '6' for CEX2A'
+                 * '7' for CEX3C and '8' for CEX3A
                  */
-                if (*ptr >= '0' && *ptr <= '6')
+                if (*ptr >= '0' && *ptr <= '8')
                         j++;
                 else if (*ptr == 'd' || *ptr == 'D')
                         zcrypt_disable_card(j++);
@@ -1110,6 +1096,15 @@ out:
         return count;
 }
 
+static const struct file_operations zcrypt_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = zcrypt_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+        .write          = zcrypt_proc_write,
+};
+
 static int zcrypt_rng_device_count;
 static u32 *zcrypt_rng_buffer;
 static int zcrypt_rng_buffer_index;
@@ -1192,14 +1187,11 @@ int __init zcrypt_api_init(void)
                 goto out;
 
         /* Set up the proc file system */
-        zcrypt_entry = create_proc_entry("driver/z90crypt", 0644, NULL);
+        zcrypt_entry = proc_create("driver/z90crypt", 0644, NULL, &zcrypt_proc_fops);
         if (!zcrypt_entry) {
                 rc = -ENOMEM;
                 goto out_misc;
         }
-        zcrypt_entry->data = NULL;
-        zcrypt_entry->read_proc = zcrypt_status_read;
-        zcrypt_entry->write_proc = zcrypt_status_write;
 
         return 0;
 
diff --git a/drivers/s390/crypto/zcrypt_api.h b/drivers/s390/crypto/zcrypt_api.h
index 1d1ec74dadb2..8e7ffbf2466c 100644
--- a/drivers/s390/crypto/zcrypt_api.h
+++ b/drivers/s390/crypto/zcrypt_api.h
@@ -71,6 +71,8 @@ struct ica_z90_status {
 #define ZCRYPT_PCIXCC_MCL3      4
 #define ZCRYPT_CEX2C            5
 #define ZCRYPT_CEX2A            6
+#define ZCRYPT_CEX3C            7
+#define ZCRYPT_CEX3A            8
 
 /**
  * Large random numbers are pulled in 4096 byte chunks from the crypto cards
diff --git a/drivers/s390/crypto/zcrypt_cex2a.c b/drivers/s390/crypto/zcrypt_cex2a.c
index 326ea08f67c9..9c409efa1ecf 100644
--- a/drivers/s390/crypto/zcrypt_cex2a.c
+++ b/drivers/s390/crypto/zcrypt_cex2a.c
@@ -27,6 +27,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/err.h>
 #include <asm/atomic.h>
@@ -39,17 +40,24 @@
 
 #define CEX2A_MIN_MOD_SIZE        1     /*    8 bits    */
 #define CEX2A_MAX_MOD_SIZE      256     /* 2048 bits    */
+#define CEX3A_MIN_MOD_SIZE      CEX2A_MIN_MOD_SIZE
+#define CEX3A_MAX_MOD_SIZE      CEX2A_MAX_MOD_SIZE
 
 #define CEX2A_SPEED_RATING      970
+#define CEX3A_SPEED_RATING      900 /* Fixme: Needs finetuning */
 
 #define CEX2A_MAX_MESSAGE_SIZE  0x390   /* sizeof(struct type50_crb2_msg)    */
 #define CEX2A_MAX_RESPONSE_SIZE 0x110   /* max outputdatalength + type80_hdr */
 
+#define CEX3A_MAX_MESSAGE_SIZE  CEX2A_MAX_MESSAGE_SIZE
+#define CEX3A_MAX_RESPONSE_SIZE CEX2A_MAX_RESPONSE_SIZE
+
 #define CEX2A_CLEANUP_TIME      (15*HZ)
+#define CEX3A_CLEANUP_TIME      CEX2A_CLEANUP_TIME
 
 static struct ap_device_id zcrypt_cex2a_ids[] = {
         { AP_DEVICE(AP_DEVICE_TYPE_CEX2A) },
-        { AP_DEVICE(AP_DEVICE_TYPE_CEX2A2) },
+        { AP_DEVICE(AP_DEVICE_TYPE_CEX3A) },
         { /* end of list */ },
 };
 
@@ -298,6 +306,7 @@ static long zcrypt_cex2a_modexpo(struct zcrypt_device *zdev,
         struct completion work;
         int rc;
 
+        ap_init_message(&ap_msg);
         ap_msg.message = kmalloc(CEX2A_MAX_MESSAGE_SIZE, GFP_KERNEL);
         if (!ap_msg.message)
                 return -ENOMEM;
@@ -335,6 +344,7 @@ static long zcrypt_cex2a_modexpo_crt(struct zcrypt_device *zdev,
         struct completion work;
         int rc;
 
+        ap_init_message(&ap_msg);
         ap_msg.message = kmalloc(CEX2A_MAX_MESSAGE_SIZE, GFP_KERNEL);
         if (!ap_msg.message)
                 return -ENOMEM;
@@ -373,31 +383,45 @@ static struct zcrypt_ops zcrypt_cex2a_ops = {
  */
 static int zcrypt_cex2a_probe(struct ap_device *ap_dev)
 {
-        struct zcrypt_device *zdev;
-        int rc;
-
-        zdev = zcrypt_device_alloc(CEX2A_MAX_RESPONSE_SIZE);
-        if (!zdev)
-                return -ENOMEM;
-        zdev->ap_dev = ap_dev;
-        zdev->ops = &zcrypt_cex2a_ops;
-        zdev->online = 1;
-        zdev->user_space_type = ZCRYPT_CEX2A;
-        zdev->type_string = "CEX2A";
-        zdev->min_mod_size = CEX2A_MIN_MOD_SIZE;
-        zdev->max_mod_size = CEX2A_MAX_MOD_SIZE;
-        zdev->short_crt = 1;
-        zdev->speed_rating = CEX2A_SPEED_RATING;
-        ap_dev->reply = &zdev->reply;
-        ap_dev->private = zdev;
-        rc = zcrypt_device_register(zdev);
-        if (rc)
-                goto out_free;
-        return 0;
-
-out_free:
-        ap_dev->private = NULL;
-        zcrypt_device_free(zdev);
+        struct zcrypt_device *zdev = NULL;
+        int rc = 0;
+
+        switch (ap_dev->device_type) {
+        case AP_DEVICE_TYPE_CEX2A:
+                zdev = zcrypt_device_alloc(CEX2A_MAX_RESPONSE_SIZE);
+                if (!zdev)
+                        return -ENOMEM;
+                zdev->user_space_type = ZCRYPT_CEX2A;
+                zdev->type_string = "CEX2A";
+                zdev->min_mod_size = CEX2A_MIN_MOD_SIZE;
+                zdev->max_mod_size = CEX2A_MAX_MOD_SIZE;
+                zdev->short_crt = 1;
+                zdev->speed_rating = CEX2A_SPEED_RATING;
+                break;
+        case AP_DEVICE_TYPE_CEX3A:
+                zdev = zcrypt_device_alloc(CEX3A_MAX_RESPONSE_SIZE);
+                if (!zdev)
+                        return -ENOMEM;
+                zdev->user_space_type = ZCRYPT_CEX3A;
+                zdev->type_string = "CEX3A";
+                zdev->min_mod_size = CEX3A_MIN_MOD_SIZE;
+                zdev->max_mod_size = CEX3A_MAX_MOD_SIZE;
+                zdev->short_crt = 1;
+                zdev->speed_rating = CEX3A_SPEED_RATING;
+                break;
+        }
+        if (zdev != NULL) {
+                zdev->ap_dev = ap_dev;
+                zdev->ops = &zcrypt_cex2a_ops;
+                zdev->online = 1;
+                ap_dev->reply = &zdev->reply;
+                ap_dev->private = zdev;
+                rc = zcrypt_device_register(zdev);
+        }
+        if (rc) {
+                ap_dev->private = NULL;
+                zcrypt_device_free(zdev);
+        }
         return rc;
 }
 
diff --git a/drivers/s390/crypto/zcrypt_pcica.c b/drivers/s390/crypto/zcrypt_pcica.c
index 17ba81b58c78..09e934b295a0 100644
--- a/drivers/s390/crypto/zcrypt_pcica.c
+++ b/drivers/s390/crypto/zcrypt_pcica.c
@@ -27,6 +27,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/err.h>
 #include <asm/atomic.h>
@@ -281,6 +282,7 @@ static long zcrypt_pcica_modexpo(struct zcrypt_device *zdev,
         struct completion work;
         int rc;
 
+        ap_init_message(&ap_msg);
         ap_msg.message = kmalloc(PCICA_MAX_MESSAGE_SIZE, GFP_KERNEL);
         if (!ap_msg.message)
                 return -ENOMEM;
@@ -318,6 +320,7 @@ static long zcrypt_pcica_modexpo_crt(struct zcrypt_device *zdev,
         struct completion work;
         int rc;
 
+        ap_init_message(&ap_msg);
         ap_msg.message = kmalloc(PCICA_MAX_MESSAGE_SIZE, GFP_KERNEL);
         if (!ap_msg.message)
                 return -ENOMEM;
diff --git a/drivers/s390/crypto/zcrypt_pcicc.c b/drivers/s390/crypto/zcrypt_pcicc.c
index f4b0c4795434..9dec5c77cff4 100644
--- a/drivers/s390/crypto/zcrypt_pcicc.c
+++ b/drivers/s390/crypto/zcrypt_pcicc.c
@@ -28,6 +28,7 @@
 
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/gfp.h>
 #include <linux/err.h>
 #include <asm/atomic.h>
 #include <asm/uaccess.h>
@@ -373,6 +374,8 @@ static int convert_type86(struct zcrypt_device *zdev,
                         zdev->max_mod_size = PCICC_MAX_MOD_SIZE_OLD;
                         return -EAGAIN;
                 }
+                if (service_rc == 8 && service_rs == 72)
+                        return -EINVAL;
                 zdev->online = 0;
                 return -EAGAIN; /* repeat the request on a different device. */
         }
@@ -483,6 +486,7 @@ static long zcrypt_pcicc_modexpo(struct zcrypt_device *zdev,
         struct completion work;
         int rc;
 
+        ap_init_message(&ap_msg);
         ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
         if (!ap_msg.message)
                 return -ENOMEM;
@@ -521,6 +525,7 @@ static long zcrypt_pcicc_modexpo_crt(struct zcrypt_device *zdev,
         struct completion work;
         int rc;
 
+        ap_init_message(&ap_msg);
         ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
         if (!ap_msg.message)
                 return -ENOMEM;
diff --git a/drivers/s390/crypto/zcrypt_pcixcc.c b/drivers/s390/crypto/zcrypt_pcixcc.c
index 5677b40e4ac0..510fab4577d4 100644
--- a/drivers/s390/crypto/zcrypt_pcixcc.c
+++ b/drivers/s390/crypto/zcrypt_pcixcc.c
@@ -30,6 +30,7 @@
 #include <linux/init.h>
 #include <linux/err.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <asm/atomic.h>
 #include <asm/uaccess.h>
 
@@ -43,10 +44,13 @@
 #define PCIXCC_MIN_MOD_SIZE      16     /*  128 bits    */
 #define PCIXCC_MIN_MOD_SIZE_OLD  64     /*  512 bits    */
 #define PCIXCC_MAX_MOD_SIZE     256     /* 2048 bits    */
+#define CEX3C_MIN_MOD_SIZE      PCIXCC_MIN_MOD_SIZE
+#define CEX3C_MAX_MOD_SIZE      PCIXCC_MAX_MOD_SIZE
 
-#define PCIXCC_MCL2_SPEED_RATING        7870    /* FIXME: needs finetuning */
+#define PCIXCC_MCL2_SPEED_RATING        7870
 #define PCIXCC_MCL3_SPEED_RATING        7870
-#define CEX2C_SPEED_RATING              8540
+#define CEX2C_SPEED_RATING              7000
+#define CEX3C_SPEED_RATING              6500    /* FIXME: needs finetuning */
 
 #define PCIXCC_MAX_ICA_MESSAGE_SIZE 0x77c  /* max size type6 v2 crt message */
 #define PCIXCC_MAX_ICA_RESPONSE_SIZE 0x77c /* max size type86 v2 reply      */
@@ -72,7 +76,7 @@ struct response_type {
 static struct ap_device_id zcrypt_pcixcc_ids[] = {
         { AP_DEVICE(AP_DEVICE_TYPE_PCIXCC) },
         { AP_DEVICE(AP_DEVICE_TYPE_CEX2C) },
-        { AP_DEVICE(AP_DEVICE_TYPE_CEX2C2) },
+        { AP_DEVICE(AP_DEVICE_TYPE_CEX3C) },
         { /* end of list */ },
 };
 
@@ -326,6 +330,11 @@ static int XCRB_msg_to_type6CPRB_msgX(struct zcrypt_device *zdev,
         function_code = ((unsigned char *)&msg->cprbx) + msg->cprbx.cprb_len;
         memcpy(msg->hdr.function_code, function_code, sizeof(msg->hdr.function_code));
 
+        if (memcmp(function_code, "US", 2) == 0)
+                ap_msg->special = 1;
+        else
+                ap_msg->special = 0;
+
         /* copy data block */
         if (xcRB->request_data_length &&
             copy_from_user(req_data, xcRB->request_data_address,
@@ -462,6 +471,8 @@ static int convert_type86_ica(struct zcrypt_device *zdev,
                 }
                 if (service_rc == 12 && service_rs == 769)
                         return -EINVAL;
+                if (service_rc == 8 && service_rs == 72)
+                        return -EINVAL;
                 zdev->online = 0;
                 return -EAGAIN; /* repeat the request on a different device. */
         }
@@ -688,6 +699,7 @@ static long zcrypt_pcixcc_modexpo(struct zcrypt_device *zdev,
         };
         int rc;
 
+        ap_init_message(&ap_msg);
         ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
         if (!ap_msg.message)
                 return -ENOMEM;
@@ -727,6 +739,7 @@ static long zcrypt_pcixcc_modexpo_crt(struct zcrypt_device *zdev,
         };
         int rc;
 
+        ap_init_message(&ap_msg);
         ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
         if (!ap_msg.message)
                 return -ENOMEM;
@@ -766,6 +779,7 @@ static long zcrypt_pcixcc_send_cprb(struct zcrypt_device *zdev,
         };
         int rc;
 
+        ap_init_message(&ap_msg);
         ap_msg.message = kmalloc(PCIXCC_MAX_XCRB_MESSAGE_SIZE, GFP_KERNEL);
         if (!ap_msg.message)
                 return -ENOMEM;
@@ -805,6 +819,7 @@ static long zcrypt_pcixcc_rng(struct zcrypt_device *zdev,
         };
         int rc;
 
+        ap_init_message(&ap_msg);
         ap_msg.message = kmalloc(PCIXCC_MAX_XCRB_MESSAGE_SIZE, GFP_KERNEL);
         if (!ap_msg.message)
                 return -ENOMEM;
@@ -972,6 +987,7 @@ static int zcrypt_pcixcc_rng_supported(struct ap_device *ap_dev)
         } __attribute__((packed)) *reply;
         int rc, i;
 
+        ap_init_message(&ap_msg);
         ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
         if (!ap_msg.message)
                 return -ENOMEM;
@@ -1016,14 +1032,15 @@ out_free:
 static int zcrypt_pcixcc_probe(struct ap_device *ap_dev)
 {
         struct zcrypt_device *zdev;
-        int rc;
+        int rc = 0;
 
         zdev = zcrypt_device_alloc(PCIXCC_MAX_RESPONSE_SIZE);
         if (!zdev)
                 return -ENOMEM;
         zdev->ap_dev = ap_dev;
         zdev->online = 1;
-        if (ap_dev->device_type == AP_DEVICE_TYPE_PCIXCC) {
+        switch (ap_dev->device_type) {
+        case AP_DEVICE_TYPE_PCIXCC:
                 rc = zcrypt_pcixcc_mcl(ap_dev);
                 if (rc < 0) {
                         zcrypt_device_free(zdev);
@@ -1041,13 +1058,25 @@ static int zcrypt_pcixcc_probe(struct ap_device *ap_dev)
                         zdev->min_mod_size = PCIXCC_MIN_MOD_SIZE;
                         zdev->max_mod_size = PCIXCC_MAX_MOD_SIZE;
                 }
-        } else {
+                break;
+        case AP_DEVICE_TYPE_CEX2C:
                 zdev->user_space_type = ZCRYPT_CEX2C;
                 zdev->type_string = "CEX2C";
                 zdev->speed_rating = CEX2C_SPEED_RATING;
                 zdev->min_mod_size = PCIXCC_MIN_MOD_SIZE;
                 zdev->max_mod_size = PCIXCC_MAX_MOD_SIZE;
+                break;
+        case AP_DEVICE_TYPE_CEX3C:
+                zdev->user_space_type = ZCRYPT_CEX3C;
+                zdev->type_string = "CEX3C";
+                zdev->speed_rating = CEX3C_SPEED_RATING;
+                zdev->min_mod_size = CEX3C_MIN_MOD_SIZE;
+                zdev->max_mod_size = CEX3C_MAX_MOD_SIZE;
+                break;
+        default:
+                goto out_free;
         }
+
         rc = zcrypt_pcixcc_rng_supported(ap_dev);
         if (rc < 0) {
                 zcrypt_device_free(zdev);
diff --git a/drivers/s390/kvm/kvm_virtio.c b/drivers/s390/kvm/kvm_virtio.c
index 2930fc763ac5..4e298bc8949d 100644
--- a/drivers/s390/kvm/kvm_virtio.c
+++ b/drivers/s390/kvm/kvm_virtio.c
@@ -15,6 +15,7 @@
 #include <linux/err.h>
 #include <linux/virtio.h>
 #include <linux/virtio_config.h>
+#include <linux/slab.h>
 #include <linux/virtio_console.h>
 #include <linux/interrupt.h>
 #include <linux/virtio_ring.h>
@@ -340,11 +341,11 @@ static void kvm_extint_handler(u16 code)
                 return;
 
         /* The LSB might be overloaded, we have to mask it */
-        vq = (struct virtqueue *) ((*(long *) __LC_PFAULT_INTPARM) & ~1UL);
+        vq = (struct virtqueue *)(S390_lowcore.ext_params2 & ~1UL);
 
         /* We use the LSB of extparam, to decide, if this interrupt is a config
          * change or a "standard" interrupt */
-        config_changed =  (*(int *)  __LC_EXT_PARAMS & 1);
+        config_changed = S390_lowcore.ext_params & 1;
 
         if (config_changed) {
                 struct virtio_driver *drv;
diff --git a/drivers/s390/net/Kconfig b/drivers/s390/net/Kconfig
index cb909a5b5047..977bb4d4ed15 100644
--- a/drivers/s390/net/Kconfig
+++ b/drivers/s390/net/Kconfig
@@ -43,6 +43,16 @@ config SMSGIUCV
           Select this option if you want to be able to receive SMSG messages
           from other VM guest systems.
 
+config SMSGIUCV_EVENT
+        tristate "Deliver IUCV special messages as uevents (VM only)"
+        depends on SMSGIUCV
+        help
+          Select this option to deliver CP special messages (SMSGs) as
+          uevents.  The driver handles only those special messages that
+          start with "APP".
+
+          To compile as a module, choose M. The module name is "smsgiucv_app".
+
 config CLAW
         tristate "CLAW device support"
         depends on CCW && NETDEVICES
diff --git a/drivers/s390/net/Makefile b/drivers/s390/net/Makefile
index 96eddb3b1d08..4dfe8c1092da 100644
--- a/drivers/s390/net/Makefile
+++ b/drivers/s390/net/Makefile
@@ -3,11 +3,12 @@
 #
 
 ctcm-y += ctcm_main.o ctcm_fsms.o ctcm_mpc.o ctcm_sysfs.o ctcm_dbug.o
-obj-$(CONFIG_CTCM) += ctcm.o fsm.o cu3088.o
+obj-$(CONFIG_CTCM) += ctcm.o fsm.o
 obj-$(CONFIG_NETIUCV) += netiucv.o fsm.o
 obj-$(CONFIG_SMSGIUCV) += smsgiucv.o
-obj-$(CONFIG_LCS) += lcs.o cu3088.o
-obj-$(CONFIG_CLAW) += claw.o cu3088.o
+obj-$(CONFIG_SMSGIUCV_EVENT) += smsgiucv_app.o
+obj-$(CONFIG_LCS) += lcs.o
+obj-$(CONFIG_CLAW) += claw.o
 qeth-y += qeth_core_sys.o qeth_core_main.o qeth_core_mpc.o
 obj-$(CONFIG_QETH) += qeth.o
 qeth_l2-y += qeth_l2_main.o
diff --git a/drivers/s390/net/claw.c b/drivers/s390/net/claw.c
index c63babefb698..147bb1a69aba 100644
--- a/drivers/s390/net/claw.c
+++ b/drivers/s390/net/claw.c
@@ -90,7 +90,6 @@
 #include <linux/timer.h>
 #include <linux/types.h>
 
-#include "cu3088.h"
 #include "claw.h"
 
 /*
@@ -258,6 +257,9 @@ static int claw_pm_prepare(struct ccwgroup_device *gdev)
         return -EPERM;
 }
 
+/* the root device for claw group devices */
+static struct device *claw_root_dev;
+
 /* ccwgroup table  */
 
 static struct ccwgroup_driver claw_group_driver = {
@@ -272,6 +274,47 @@ static struct ccwgroup_driver claw_group_driver = {
         .prepare     = claw_pm_prepare,
 };
 
+static struct ccw_device_id claw_ids[] = {
+        {CCW_DEVICE(0x3088, 0x61), .driver_info = claw_channel_type_claw},
+        {},
+};
+MODULE_DEVICE_TABLE(ccw, claw_ids);
+
+static struct ccw_driver claw_ccw_driver = {
+        .owner  = THIS_MODULE,
+        .name   = "claw",
+        .ids    = claw_ids,
+        .probe  = ccwgroup_probe_ccwdev,
+        .remove = ccwgroup_remove_ccwdev,
+};
+
+static ssize_t
+claw_driver_group_store(struct device_driver *ddrv, const char *buf,
+                        size_t count)
+{
+        int err;
+        err = ccwgroup_create_from_string(claw_root_dev,
+                                          claw_group_driver.driver_id,
+                                          &claw_ccw_driver, 3, buf);
+        return err ? err : count;
+}
+
+static DRIVER_ATTR(group, 0200, NULL, claw_driver_group_store);
+
+static struct attribute *claw_group_attrs[] = {
+        &driver_attr_group.attr,
+        NULL,
+};
+
+static struct attribute_group claw_group_attr_group = {
+        .attrs = claw_group_attrs,
+};
+
+static const struct attribute_group *claw_group_attr_groups[] = {
+        &claw_group_attr_group,
+        NULL,
+};
+
 /*
 *       Key functions
 */
@@ -3326,7 +3369,11 @@ claw_remove_files(struct device *dev)
 static void __exit
 claw_cleanup(void)
 {
-        unregister_cu3088_discipline(&claw_group_driver);
+        driver_remove_file(&claw_group_driver.driver,
+                           &driver_attr_group);
+        ccwgroup_driver_unregister(&claw_group_driver);
+        ccw_driver_unregister(&claw_ccw_driver);
+        root_device_unregister(claw_root_dev);
         claw_unregister_debug_facility();
         pr_info("Driver unloaded\n");
 
@@ -3348,16 +3395,31 @@ claw_init(void)
         if (ret) {
                 pr_err("Registering with the S/390 debug feature"
                         " failed with error code %d\n", ret);
-                return ret;
+                goto out_err;
         }
         CLAW_DBF_TEXT(2, setup, "init_mod");
-        ret = register_cu3088_discipline(&claw_group_driver);
-        if (ret) {
-                CLAW_DBF_TEXT(2, setup, "init_bad");
-                claw_unregister_debug_facility();
-                pr_err("Registering with the cu3088 device driver failed "
-                           "with error code %d\n", ret);
-        }
+        claw_root_dev = root_device_register("claw");
+        ret = IS_ERR(claw_root_dev) ? PTR_ERR(claw_root_dev) : 0;
+        if (ret)
+                goto register_err;
+        ret = ccw_driver_register(&claw_ccw_driver);
+        if (ret)
+                goto ccw_err;
+        claw_group_driver.driver.groups = claw_group_attr_groups;
+        ret = ccwgroup_driver_register(&claw_group_driver);
+        if (ret)
+                goto ccwgroup_err;
+        return 0;
+
+ccwgroup_err:
+        ccw_driver_unregister(&claw_ccw_driver);
+ccw_err:
+        root_device_unregister(claw_root_dev);
+register_err:
+        CLAW_DBF_TEXT(2, setup, "init_bad");
+        claw_unregister_debug_facility();
+out_err:
+        pr_err("Initializing the claw device driver failed\n");
         return ret;
 }
 
diff --git a/drivers/s390/net/claw.h b/drivers/s390/net/claw.h
index 005072c420d3..46d59a13db12 100644
--- a/drivers/s390/net/claw.h
+++ b/drivers/s390/net/claw.h
@@ -129,6 +129,18 @@ static inline int claw_dbf_passes(debug_info_t *dbf_grp, int level)
                 } \
         } while (0)
 
+/**
+ * Enum for classifying detected devices.
+ */
+enum claw_channel_types {
+        /* Device is not a channel  */
+        claw_channel_type_none,
+
+        /* Device is a CLAW channel device */
+        claw_channel_type_claw
+};
+
+
 /*******************************************************
 *  Define Control Blocks                               *
 *                                                      *
diff --git a/drivers/s390/net/ctcm_dbug.c b/drivers/s390/net/ctcm_dbug.c
index 1ca58f153470..d962fd741a23 100644
--- a/drivers/s390/net/ctcm_dbug.c
+++ b/drivers/s390/net/ctcm_dbug.c
@@ -10,7 +10,6 @@
 #include <linux/string.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
-#include <linux/slab.h>
 #include <linux/ctype.h>
 #include <linux/sysctl.h>
 #include <linux/module.h>
diff --git a/drivers/s390/net/ctcm_fsms.c b/drivers/s390/net/ctcm_fsms.c
index 4ded9ac2c5ef..70eb7f138414 100644
--- a/drivers/s390/net/ctcm_fsms.c
+++ b/drivers/s390/net/ctcm_fsms.c
@@ -44,7 +44,6 @@
 #include <asm/idals.h>
 
 #include "fsm.h"
-#include "cu3088.h"
 
 #include "ctcm_dbug.h"
 #include "ctcm_main.h"
diff --git a/drivers/s390/net/ctcm_fsms.h b/drivers/s390/net/ctcm_fsms.h
index 2326aba9807a..046d077fabbb 100644
--- a/drivers/s390/net/ctcm_fsms.h
+++ b/drivers/s390/net/ctcm_fsms.h
@@ -39,7 +39,6 @@
 #include <asm/idals.h>
 
 #include "fsm.h"
-#include "cu3088.h"
 #include "ctcm_main.h"
 
 /*
diff --git a/drivers/s390/net/ctcm_main.c b/drivers/s390/net/ctcm_main.c
index c5b83874500c..e35713dd0504 100644
--- a/drivers/s390/net/ctcm_main.c
+++ b/drivers/s390/net/ctcm_main.c
@@ -51,12 +51,16 @@
 
 #include <asm/idals.h>
 
-#include "cu3088.h"
 #include "ctcm_fsms.h"
 #include "ctcm_main.h"
 
 /* Some common global variables */
 
+/**
+ * The root device for ctcm group devices
+ */
+static struct device *ctcm_root_dev;
+
 /*
  * Linked list of all detected channels.
  */
@@ -246,7 +250,7 @@ static void channel_remove(struct channel *ch)
  *
  * returns Pointer to a channel or NULL if no matching channel available.
  */
-static struct channel *channel_get(enum channel_types type,
+static struct channel *channel_get(enum ctcm_channel_types type,
                                         char *id, int direction)
 {
         struct channel *ch = channels;
@@ -1342,7 +1346,7 @@ static int ctcm_probe_device(struct ccwgroup_device *cgdev)
  *
  * returns 0 on success, !0 on error.
  */
-static int add_channel(struct ccw_device *cdev, enum channel_types type,
+static int add_channel(struct ccw_device *cdev, enum ctcm_channel_types type,
                                 struct ctcm_priv *priv)
 {
         struct channel **c = &channels;
@@ -1501,13 +1505,13 @@ free_return:	/* note that all channel pointers are 0 or valid */
 /*
  * Return type of a detected device.
  */
-static enum channel_types get_channel_type(struct ccw_device_id *id)
+static enum ctcm_channel_types get_channel_type(struct ccw_device_id *id)
 {
-        enum channel_types type;
-        type = (enum channel_types)id->driver_info;
+        enum ctcm_channel_types type;
+        type = (enum ctcm_channel_types)id->driver_info;
 
-        if (type == channel_type_ficon)
-                type = channel_type_escon;
+        if (type == ctcm_channel_type_ficon)
+                type = ctcm_channel_type_escon;
 
         return type;
 }
@@ -1525,16 +1529,21 @@ static int ctcm_new_device(struct ccwgroup_device *cgdev)
         char read_id[CTCM_ID_SIZE];
         char write_id[CTCM_ID_SIZE];
         int direction;
-        enum channel_types type;
+        enum ctcm_channel_types type;
         struct ctcm_priv *priv;
         struct net_device *dev;
         struct ccw_device *cdev0;
         struct ccw_device *cdev1;
+        struct channel *readc;
+        struct channel *writec;
         int ret;
+        int result;
 
         priv = dev_get_drvdata(&cgdev->dev);
-        if (!priv)
-                return -ENODEV;
+        if (!priv) {
+                result = -ENODEV;
+                goto out_err_result;
+        }
 
         cdev0 = cgdev->cdev[0];
         cdev1 = cgdev->cdev[1];
@@ -1545,31 +1554,40 @@ static int ctcm_new_device(struct ccwgroup_device *cgdev)
         snprintf(write_id, CTCM_ID_SIZE, "ch-%s", dev_name(&cdev1->dev));
 
         ret = add_channel(cdev0, type, priv);
-        if (ret)
-                return ret;
+        if (ret) {
+                result = ret;
+                goto out_err_result;
+        }
         ret = add_channel(cdev1, type, priv);
-        if (ret)
-                return ret;
+        if (ret) {
+                result = ret;
+                goto out_remove_channel1;
+        }
 
         ret = ccw_device_set_online(cdev0);
         if (ret != 0) {
-                /* may be ok to fail now - can be done later */
                 CTCM_DBF_TEXT_(TRACE, CTC_DBF_NOTICE,
                         "%s(%s) set_online rc=%d",
                                 CTCM_FUNTAIL, read_id, ret);
+                result = -EIO;
+                goto out_remove_channel2;
         }
 
         ret = ccw_device_set_online(cdev1);
         if (ret != 0) {
-                /* may be ok to fail now - can be done later */
                 CTCM_DBF_TEXT_(TRACE, CTC_DBF_NOTICE,
                         "%s(%s) set_online rc=%d",
                                 CTCM_FUNTAIL, write_id, ret);
+
+                result = -EIO;
+                goto out_ccw1;
         }
 
         dev = ctcm_init_netdevice(priv);
-        if (dev == NULL)
-                        goto out;
+        if (dev == NULL) {
+                result = -ENODEV;
+                goto out_ccw2;
+        }
 
         for (direction = READ; direction <= WRITE; direction++) {
                 priv->channel[direction] =
@@ -1587,12 +1605,14 @@ static int ctcm_new_device(struct ccwgroup_device *cgdev)
         /* sysfs magic */
         SET_NETDEV_DEV(dev, &cgdev->dev);
 
-        if (register_netdev(dev))
-                        goto out_dev;
+        if (register_netdev(dev)) {
+                result = -ENODEV;
+                goto out_dev;
+        }
 
         if (ctcm_add_attributes(&cgdev->dev)) {
-                unregister_netdev(dev);
-                        goto out_dev;
+                result = -ENODEV;
+                goto out_unregister;
         }
 
         strlcpy(priv->fsm->name, dev->name, sizeof(priv->fsm->name));
@@ -1608,13 +1628,22 @@ static int ctcm_new_device(struct ccwgroup_device *cgdev)
                         priv->channel[WRITE]->id, priv->protocol);
 
         return 0;
+out_unregister:
+        unregister_netdev(dev);
 out_dev:
         ctcm_free_netdevice(dev);
-out:
+out_ccw2:
         ccw_device_set_offline(cgdev->cdev[1]);
+out_ccw1:
         ccw_device_set_offline(cgdev->cdev[0]);
-
-        return -ENODEV;
+out_remove_channel2:
+        readc = channel_get(type, read_id, READ);
+        channel_remove(readc);
+out_remove_channel1:
+        writec = channel_get(type, write_id, WRITE);
+        channel_remove(writec);
+out_err_result:
+        return result;
 }
 
 /**
@@ -1695,6 +1724,11 @@ static int ctcm_pm_suspend(struct ccwgroup_device *gdev)
                 return 0;
         netif_device_detach(priv->channel[READ]->netdev);
         ctcm_close(priv->channel[READ]->netdev);
+        if (!wait_event_timeout(priv->fsm->wait_q,
+            fsm_getstate(priv->fsm) == DEV_STATE_STOPPED, CTCM_TIME_5_SEC)) {
+                netif_device_attach(priv->channel[READ]->netdev);
+                return -EBUSY;
+        }
         ccw_device_set_offline(gdev->cdev[1]);
         ccw_device_set_offline(gdev->cdev[0]);
         return 0;
@@ -1719,6 +1753,22 @@ err_out:
         return rc;
 }
 
+static struct ccw_device_id ctcm_ids[] = {
+        {CCW_DEVICE(0x3088, 0x08), .driver_info = ctcm_channel_type_parallel},
+        {CCW_DEVICE(0x3088, 0x1e), .driver_info = ctcm_channel_type_ficon},
+        {CCW_DEVICE(0x3088, 0x1f), .driver_info = ctcm_channel_type_escon},
+        {},
+};
+MODULE_DEVICE_TABLE(ccw, ctcm_ids);
+
+static struct ccw_driver ctcm_ccw_driver = {
+        .owner  = THIS_MODULE,
+        .name   = "ctcm",
+        .ids    = ctcm_ids,
+        .probe  = ccwgroup_probe_ccwdev,
+        .remove = ccwgroup_remove_ccwdev,
+};
+
 static struct ccwgroup_driver ctcm_group_driver = {
         .owner       = THIS_MODULE,
         .name        = CTC_DRIVER_NAME,
@@ -1733,6 +1783,33 @@ static struct ccwgroup_driver ctcm_group_driver = {
         .restore     = ctcm_pm_resume,
 };
 
+static ssize_t
+ctcm_driver_group_store(struct device_driver *ddrv, const char *buf,
+                        size_t count)
+{
+        int err;
+
+        err = ccwgroup_create_from_string(ctcm_root_dev,
+                                          ctcm_group_driver.driver_id,
+                                          &ctcm_ccw_driver, 2, buf);
+        return err ? err : count;
+}
+
+static DRIVER_ATTR(group, 0200, NULL, ctcm_driver_group_store);
+
+static struct attribute *ctcm_group_attrs[] = {
+        &driver_attr_group.attr,
+        NULL,
+};
+
+static struct attribute_group ctcm_group_attr_group = {
+        .attrs = ctcm_group_attrs,
+};
+
+static const struct attribute_group *ctcm_group_attr_groups[] = {
+        &ctcm_group_attr_group,
+        NULL,
+};
 
 /*
  * Module related routines
@@ -1746,7 +1823,10 @@ static struct ccwgroup_driver ctcm_group_driver = {
  */
 static void __exit ctcm_exit(void)
 {
-        unregister_cu3088_discipline(&ctcm_group_driver);
+        driver_remove_file(&ctcm_group_driver.driver, &driver_attr_group);
+        ccwgroup_driver_unregister(&ctcm_group_driver);
+        ccw_driver_unregister(&ctcm_ccw_driver);
+        root_device_unregister(ctcm_root_dev);
         ctcm_unregister_dbf_views();
         pr_info("CTCM driver unloaded\n");
 }
@@ -1772,17 +1852,31 @@ static int __init ctcm_init(void)
         channels = NULL;
 
         ret = ctcm_register_dbf_views();
-        if (ret) {
-                return ret;
-        }
-        ret = register_cu3088_discipline(&ctcm_group_driver);
-        if (ret) {
-                ctcm_unregister_dbf_views();
-                pr_err("%s / register_cu3088_discipline failed, ret = %d\n",
-                        __func__, ret);
-                return ret;
-        }
+        if (ret)
+                goto out_err;
+        ctcm_root_dev = root_device_register("ctcm");
+        ret = IS_ERR(ctcm_root_dev) ? PTR_ERR(ctcm_root_dev) : 0;
+        if (ret)
+                goto register_err;
+        ret = ccw_driver_register(&ctcm_ccw_driver);
+        if (ret)
+                goto ccw_err;
+        ctcm_group_driver.driver.groups = ctcm_group_attr_groups;
+        ret = ccwgroup_driver_register(&ctcm_group_driver);
+        if (ret)
+                goto ccwgroup_err;
         print_banner();
+        return 0;
+
+ccwgroup_err:
+        ccw_driver_unregister(&ctcm_ccw_driver);
+ccw_err:
+        root_device_unregister(ctcm_root_dev);
+register_err:
+        ctcm_unregister_dbf_views();
+out_err:
+        pr_err("%s / Initializing the ctcm device driver failed, ret = %d\n",
+                __func__, ret);
         return ret;
 }
 
diff --git a/drivers/s390/net/ctcm_main.h b/drivers/s390/net/ctcm_main.h
index d925e732b7d8..d34fa14f44e7 100644
--- a/drivers/s390/net/ctcm_main.h
+++ b/drivers/s390/net/ctcm_main.h
@@ -16,7 +16,6 @@
 #include <linux/netdevice.h>
 
 #include "fsm.h"
-#include "cu3088.h"
 #include "ctcm_dbug.h"
 #include "ctcm_mpc.h"
 
@@ -66,6 +65,23 @@
                         ctcmpc_dumpit(buf, len); \
         } while (0)
 
+/**
+ * Enum for classifying detected devices
+ */
+enum ctcm_channel_types {
+        /* Device is not a channel  */
+        ctcm_channel_type_none,
+
+        /* Device is a CTC/A */
+        ctcm_channel_type_parallel,
+
+        /* Device is a FICON channel */
+        ctcm_channel_type_ficon,
+
+        /* Device is a ESCON channel */
+        ctcm_channel_type_escon
+};
+
 /*
  * CCW commands, used in this driver.
  */
@@ -121,7 +137,7 @@ struct channel {
          * Type of this channel.
          * CTC/A or Escon for valid channels.
          */
-        enum channel_types type;
+        enum ctcm_channel_types type;
         /*
          * Misc. flags. See CHANNEL_FLAGS_... below
          */
diff --git a/drivers/s390/net/ctcm_mpc.c b/drivers/s390/net/ctcm_mpc.c
index 781e18be7e8f..5978b390153f 100644
--- a/drivers/s390/net/ctcm_mpc.c
+++ b/drivers/s390/net/ctcm_mpc.c
@@ -53,7 +53,6 @@
 #include <linux/moduleparam.h>
 #include <asm/idals.h>
 
-#include "cu3088.h"
 #include "ctcm_mpc.h"
 #include "ctcm_main.h"
 #include "ctcm_fsms.h"
diff --git a/drivers/s390/net/ctcm_sysfs.c b/drivers/s390/net/ctcm_sysfs.c
index 8452bb052d68..2b24550e865e 100644
--- a/drivers/s390/net/ctcm_sysfs.c
+++ b/drivers/s390/net/ctcm_sysfs.c
@@ -14,6 +14,7 @@
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include <linux/sysfs.h>
+#include <linux/slab.h>
 #include "ctcm_main.h"
 
 /*
@@ -158,6 +159,15 @@ static ssize_t ctcm_proto_store(struct device *dev,
         return count;
 }
 
+const char *ctcm_type[] = {
+        "not a channel",
+        "CTC/A",
+        "FICON channel",
+        "ESCON channel",
+        "unknown channel type",
+        "unsupported channel type",
+};
+
 static ssize_t ctcm_type_show(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
@@ -168,7 +178,7 @@ static ssize_t ctcm_type_show(struct device *dev,
                 return -ENODEV;
 
         return sprintf(buf, "%s\n",
-                        cu3088_type[cgdev->cdev[0]->id.driver_info]);
+                        ctcm_type[cgdev->cdev[0]->id.driver_info]);
 }
 
 static DEVICE_ATTR(buffer, 0644, ctcm_buffer_show, ctcm_buffer_write);
diff --git a/drivers/s390/net/cu3088.c b/drivers/s390/net/cu3088.c
deleted file mode 100644
index 48383459e99b..000000000000
--- a/drivers/s390/net/cu3088.c
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- * CTC / LCS ccw_device driver
- *
- * Copyright (C) 2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
- * Author(s): Arnd Bergmann <arndb@de.ibm.com>
- *            Cornelia Huck <cornelia.huck@de.ibm.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/err.h>
-
-#include <asm/ccwdev.h>
-#include <asm/ccwgroup.h>
-
-#include "cu3088.h"
-
-const char *cu3088_type[] = {
-        "not a channel",
-        "CTC/A",
-        "ESCON channel",
-        "FICON channel",
-        "OSA LCS card",
-        "CLAW channel device",
-        "unknown channel type",
-        "unsupported channel type",
-};
-
-/* static definitions */
-
-static struct ccw_device_id cu3088_ids[] = {
-        { CCW_DEVICE(0x3088, 0x08), .driver_info = channel_type_parallel },
-        { CCW_DEVICE(0x3088, 0x1f), .driver_info = channel_type_escon },
-        { CCW_DEVICE(0x3088, 0x1e), .driver_info = channel_type_ficon },
-        { CCW_DEVICE(0x3088, 0x60), .driver_info = channel_type_osa2 },
-        { CCW_DEVICE(0x3088, 0x61), .driver_info = channel_type_claw },
-        { /* end of list */ }
-};
-
-static struct ccw_driver cu3088_driver;
-
-static struct device *cu3088_root_dev;
-
-static ssize_t
-group_write(struct device_driver *drv, const char *buf, size_t count)
-{
-        int ret;
-        struct ccwgroup_driver *cdrv;
-
-        cdrv = to_ccwgroupdrv(drv);
-        if (!cdrv)
-                return -EINVAL;
-        ret = ccwgroup_create_from_string(cu3088_root_dev, cdrv->driver_id,
-                                          &cu3088_driver, 2, buf);
-
-        return (ret == 0) ? count : ret;
-}
-
-static DRIVER_ATTR(group, 0200, NULL, group_write);
-
-/* Register-unregister for ctc&lcs */
-int
-register_cu3088_discipline(struct ccwgroup_driver *dcp)
-{
-        int rc;
-
-        if (!dcp)
-                return -EINVAL;
-
-        /* Register discipline.*/
-        rc = ccwgroup_driver_register(dcp);
-        if (rc)
-                return rc;
-
-        rc = driver_create_file(&dcp->driver, &driver_attr_group);
-        if (rc)
-                ccwgroup_driver_unregister(dcp);
-
-        return rc;
-
-}
-
-void
-unregister_cu3088_discipline(struct ccwgroup_driver *dcp)
-{
-        if (!dcp)
-                return;
-
-        driver_remove_file(&dcp->driver, &driver_attr_group);
-        ccwgroup_driver_unregister(dcp);
-}
-
-static struct ccw_driver cu3088_driver = {
-        .owner       = THIS_MODULE,
-        .ids         = cu3088_ids,
-        .name        = "cu3088",
-        .probe       = ccwgroup_probe_ccwdev,
-        .remove      = ccwgroup_remove_ccwdev,
-};
-
-/* module setup */
-static int __init
-cu3088_init (void)
-{
-        int rc;
-
-        cu3088_root_dev = root_device_register("cu3088");
-        if (IS_ERR(cu3088_root_dev))
-                return PTR_ERR(cu3088_root_dev);
-        rc = ccw_driver_register(&cu3088_driver);
-        if (rc)
-                root_device_unregister(cu3088_root_dev);
-
-        return rc;
-}
-
-static void __exit
-cu3088_exit (void)
-{
-        ccw_driver_unregister(&cu3088_driver);
-        root_device_unregister(cu3088_root_dev);
-}
-
-MODULE_DEVICE_TABLE(ccw,cu3088_ids);
-MODULE_AUTHOR("Arnd Bergmann <arndb@de.ibm.com>");
-MODULE_LICENSE("GPL");
-
-module_init(cu3088_init);
-module_exit(cu3088_exit);
-
-EXPORT_SYMBOL_GPL(cu3088_type);
-EXPORT_SYMBOL_GPL(register_cu3088_discipline);
-EXPORT_SYMBOL_GPL(unregister_cu3088_discipline);
diff --git a/drivers/s390/net/cu3088.h b/drivers/s390/net/cu3088.h
deleted file mode 100644
index d8558a7105a5..000000000000
--- a/drivers/s390/net/cu3088.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef _CU3088_H
-#define _CU3088_H
-
-/**
- * Enum for classifying detected devices.
- */
-enum channel_types {
-        /* Device is not a channel  */
-        channel_type_none,
-
-        /* Device is a CTC/A */
-        channel_type_parallel,
-
-        /* Device is a ESCON channel */
-        channel_type_escon,
-
-        /* Device is a FICON channel */
-        channel_type_ficon,
-
-        /* Device is a OSA2 card */
-        channel_type_osa2,
-
-        /* Device is a CLAW channel device */
-        channel_type_claw,
-
-        /* Device is a channel, but we don't know
-         * anything about it */
-        channel_type_unknown,
-
-        /* Device is an unsupported model */
-        channel_type_unsupported,
-
-        /* number of type entries */
-        num_channel_types
-};
-
-extern const char *cu3088_type[num_channel_types];
-extern int register_cu3088_discipline(struct ccwgroup_driver *);
-extern void unregister_cu3088_discipline(struct ccwgroup_driver *);
-
-#endif
diff --git a/drivers/s390/net/fsm.c b/drivers/s390/net/fsm.c
index 2c1db8036b7c..e5dea67f902e 100644
--- a/drivers/s390/net/fsm.c
+++ b/drivers/s390/net/fsm.c
@@ -5,6 +5,7 @@
 
 #include "fsm.h"
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/timer.h>
 
 MODULE_AUTHOR("(C) 2000 IBM Corp. by Fritz Elfert (felfert@millenux.com)");
@@ -27,6 +28,7 @@ init_fsm(char *name, const char **state_names, const char **event_names, int nr_
                 return NULL;
         }
         strlcpy(this->name, name, sizeof(this->name));
+        init_waitqueue_head(&this->wait_q);
 
         f = kzalloc(sizeof(fsm), order);
         if (f == NULL) {
diff --git a/drivers/s390/net/fsm.h b/drivers/s390/net/fsm.h
index af679c10f1bd..1e8b235d95b5 100644
--- a/drivers/s390/net/fsm.h
+++ b/drivers/s390/net/fsm.h
@@ -66,6 +66,7 @@ typedef struct fsm_instance_t {
         char name[16];
         void *userdata;
         int userint;
+        wait_queue_head_t wait_q;
 #if FSM_DEBUG_HISTORY
         int         history_index;
         int         history_size;
@@ -197,6 +198,7 @@ fsm_newstate(fsm_instance *fi, int newstate)
         printk(KERN_DEBUG "fsm(%s): New state %s\n", fi->name,
                 fi->f->state_names[newstate]);
 #endif
+        wake_up(&fi->wait_q);
 }
 
 /**
diff --git a/drivers/s390/net/lcs.c b/drivers/s390/net/lcs.c
index a70de9b4bf29..9b19ea13b4d8 100644
--- a/drivers/s390/net/lcs.c
+++ b/drivers/s390/net/lcs.c
@@ -37,6 +37,7 @@
 #include <linux/igmp.h>
 #include <linux/delay.h>
 #include <linux/kthread.h>
+#include <linux/slab.h>
 #include <net/arp.h>
 #include <net/ip.h>
 
@@ -47,7 +48,6 @@
 #include <asm/ccwgroup.h>
 
 #include "lcs.h"
-#include "cu3088.h"
 
 
 #if !defined(CONFIG_NET_ETHERNET) && \
@@ -60,7 +60,11 @@
  */
 
 static char version[] __initdata = "LCS driver";
-static char debug_buffer[255];
+
+/**
+  * the root device for lcs group devices
+  */
+static struct device *lcs_root_dev;
 
 /**
  * Some prototypes.
@@ -76,6 +80,7 @@ static int lcs_recovery(void *ptr);
 /**
  * Debug Facility Stuff
  */
+static char debug_buffer[255];
 static debug_info_t *lcs_dbf_setup;
 static debug_info_t *lcs_dbf_trace;
 
@@ -889,7 +894,7 @@ lcs_send_lancmd(struct lcs_card *card, struct lcs_buffer *buffer,
         rc = lcs_ready_buffer(&card->write, buffer);
         if (rc)
                 return rc;
-        init_timer(&timer);
+        init_timer_on_stack(&timer);
         timer.function = lcs_lancmd_timeout;
         timer.data = (unsigned long) reply;
         timer.expires = jiffies + HZ*card->lancmd_timeout;
@@ -1968,6 +1973,15 @@ lcs_portno_store (struct device *dev, struct device_attribute *attr, const char
 
 static DEVICE_ATTR(portno, 0644, lcs_portno_show, lcs_portno_store);
 
+const char *lcs_type[] = {
+        "not a channel",
+        "2216 parallel",
+        "2216 channel",
+        "OSA LCS card",
+        "unknown channel type",
+        "unsupported channel type",
+};
+
 static ssize_t
 lcs_type_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -1977,7 +1991,7 @@ lcs_type_show(struct device *dev, struct device_attribute *attr, char *buf)
         if (!cgdev)
                 return -ENODEV;
 
-        return sprintf(buf, "%s\n", cu3088_type[cgdev->cdev[0]->id.driver_info]);
+        return sprintf(buf, "%s\n", lcs_type[cgdev->cdev[0]->id.driver_info]);
 }
 
 static DEVICE_ATTR(type, 0444, lcs_type_show, NULL);
@@ -2130,8 +2144,12 @@ lcs_new_device(struct ccwgroup_device *ccwgdev)
         card->write.ccwdev = ccwgdev->cdev[1];
 
         recover_state = card->state;
-        ccw_device_set_online(card->read.ccwdev);
-        ccw_device_set_online(card->write.ccwdev);
+        rc = ccw_device_set_online(card->read.ccwdev);
+        if (rc)
+                goto out_err;
+        rc = ccw_device_set_online(card->write.ccwdev);
+        if (rc)
+                goto out_werr;
 
         LCS_DBF_TEXT(3, setup, "lcsnewdv");
 
@@ -2210,8 +2228,10 @@ netdev_out:
         return 0;
 out:
 
-        ccw_device_set_offline(card->read.ccwdev);
         ccw_device_set_offline(card->write.ccwdev);
+out_werr:
+        ccw_device_set_offline(card->read.ccwdev);
+out_err:
         return -ENODEV;
 }
 
@@ -2364,6 +2384,22 @@ static int lcs_restore(struct ccwgroup_device *gdev)
         return lcs_pm_resume(card);
 }
 
+static struct ccw_device_id lcs_ids[] = {
+        {CCW_DEVICE(0x3088, 0x08), .driver_info = lcs_channel_type_parallel},
+        {CCW_DEVICE(0x3088, 0x1f), .driver_info = lcs_channel_type_2216},
+        {CCW_DEVICE(0x3088, 0x60), .driver_info = lcs_channel_type_osa2},
+        {},
+};
+MODULE_DEVICE_TABLE(ccw, lcs_ids);
+
+static struct ccw_driver lcs_ccw_driver = {
+        .owner  = THIS_MODULE,
+        .name   = "lcs",
+        .ids    = lcs_ids,
+        .probe  = ccwgroup_probe_ccwdev,
+        .remove = ccwgroup_remove_ccwdev,
+};
+
 /**
  * LCS ccwgroup driver registration
  */
@@ -2383,6 +2419,33 @@ static struct ccwgroup_driver lcs_group_driver = {
         .restore     = lcs_restore,
 };
 
+static ssize_t
+lcs_driver_group_store(struct device_driver *ddrv, const char *buf,
+                       size_t count)
+{
+        int err;
+        err = ccwgroup_create_from_string(lcs_root_dev,
+                                          lcs_group_driver.driver_id,
+                                          &lcs_ccw_driver, 2, buf);
+        return err ? err : count;
+}
+
+static DRIVER_ATTR(group, 0200, NULL, lcs_driver_group_store);
+
+static struct attribute *lcs_group_attrs[] = {
+        &driver_attr_group.attr,
+        NULL,
+};
+
+static struct attribute_group lcs_group_attr_group = {
+        .attrs = lcs_group_attrs,
+};
+
+static const struct attribute_group *lcs_group_attr_groups[] = {
+        &lcs_group_attr_group,
+        NULL,
+};
+
 /**
  *  LCS Module/Kernel initialization function
  */
@@ -2394,17 +2457,30 @@ __init lcs_init_module(void)
         pr_info("Loading %s\n", version);
         rc = lcs_register_debug_facility();
         LCS_DBF_TEXT(0, setup, "lcsinit");
-        if (rc) {
-                pr_err("Initialization failed\n");
-                return rc;
-        }
-
-        rc = register_cu3088_discipline(&lcs_group_driver);
-        if (rc) {
-                pr_err("Initialization failed\n");
-                return rc;
-        }
+        if (rc)
+                goto out_err;
+        lcs_root_dev = root_device_register("lcs");
+        rc = IS_ERR(lcs_root_dev) ? PTR_ERR(lcs_root_dev) : 0;
+        if (rc)
+                goto register_err;
+        rc = ccw_driver_register(&lcs_ccw_driver);
+        if (rc)
+                goto ccw_err;
+        lcs_group_driver.driver.groups = lcs_group_attr_groups;
+        rc = ccwgroup_driver_register(&lcs_group_driver);
+        if (rc)
+                goto ccwgroup_err;
         return 0;
+
+ccwgroup_err:
+        ccw_driver_unregister(&lcs_ccw_driver);
+ccw_err:
+        root_device_unregister(lcs_root_dev);
+register_err:
+        lcs_unregister_debug_facility();
+out_err:
+        pr_err("Initializing the lcs device driver failed\n");
+        return rc;
 }
 
 
@@ -2416,7 +2492,11 @@ __exit lcs_cleanup_module(void)
 {
         pr_info("Terminating lcs module.\n");
         LCS_DBF_TEXT(0, trace, "cleanup");
-        unregister_cu3088_discipline(&lcs_group_driver);
+        driver_remove_file(&lcs_group_driver.driver,
+                           &driver_attr_group);
+        ccwgroup_driver_unregister(&lcs_group_driver);
+        ccw_driver_unregister(&lcs_ccw_driver);
+        root_device_unregister(lcs_root_dev);
         lcs_unregister_debug_facility();
 }
 
diff --git a/drivers/s390/net/lcs.h b/drivers/s390/net/lcs.h
index 6d668642af27..8c03392ac833 100644
--- a/drivers/s390/net/lcs.h
+++ b/drivers/s390/net/lcs.h
@@ -36,6 +36,24 @@ static inline int lcs_dbf_passes(debug_info_t *dbf_grp, int level)
 #define CARD_FROM_DEV(cdev) \
         (struct lcs_card *) dev_get_drvdata( \
                 &((struct ccwgroup_device *)dev_get_drvdata(&cdev->dev))->dev);
+
+/**
+ * Enum for classifying detected devices.
+ */
+enum lcs_channel_types {
+        /* Device is not a channel  */
+        lcs_channel_type_none,
+
+        /* Device is a 2216 channel */
+        lcs_channel_type_parallel,
+
+        /* Device is a 2216 channel */
+        lcs_channel_type_2216,
+
+        /* Device is a OSA2 card */
+        lcs_channel_type_osa2
+};
+
 /**
  * CCW commands used in this driver
  */
diff --git a/drivers/s390/net/netiucv.c b/drivers/s390/net/netiucv.c
index c84eadd3602a..65ebee0a3266 100644
--- a/drivers/s390/net/netiucv.c
+++ b/drivers/s390/net/netiucv.c
@@ -113,11 +113,9 @@ static inline int iucv_dbf_passes(debug_info_t *dbf_grp, int level)
 #define IUCV_DBF_TEXT_(name, level, text...) \
         do { \
                 if (iucv_dbf_passes(iucv_dbf_##name, level)) { \
-                        char* iucv_dbf_txt_buf = \
-                                        get_cpu_var(iucv_dbf_txt_buf); \
-                        sprintf(iucv_dbf_txt_buf, text); \
-                        debug_text_event(iucv_dbf_##name, level, \
-                                                iucv_dbf_txt_buf); \
+                        char* __buf = get_cpu_var(iucv_dbf_txt_buf); \
+                        sprintf(__buf, text); \
+                        debug_text_event(iucv_dbf_##name, level, __buf); \
                         put_cpu_var(iucv_dbf_txt_buf); \
                 } \
         } while (0)
@@ -161,7 +159,7 @@ static void netiucv_pm_complete(struct device *);
 static int netiucv_pm_freeze(struct device *);
 static int netiucv_pm_restore_thaw(struct device *);
 
-static struct dev_pm_ops netiucv_pm_ops = {
+static const struct dev_pm_ops netiucv_pm_ops = {
         .prepare = netiucv_pm_prepare,
         .complete = netiucv_pm_complete,
         .freeze = netiucv_pm_freeze,
@@ -741,13 +739,13 @@ static void conn_action_txdone(fsm_instance *fi, int event, void *arg)
         if (single_flag) {
                 if ((skb = skb_dequeue(&conn->commit_queue))) {
                         atomic_dec(&skb->users);
-                        dev_kfree_skb_any(skb);
                         if (privptr) {
                                 privptr->stats.tx_packets++;
                                 privptr->stats.tx_bytes +=
                                         (skb->len - NETIUCV_HDRLEN
-                                                  - NETIUCV_HDRLEN);
+                                                  - NETIUCV_HDRLEN);
                         }
+                        dev_kfree_skb_any(skb);
                 }
         }
         conn->tx_buff->data = conn->tx_buff->head;
diff --git a/drivers/s390/net/qeth_core.h b/drivers/s390/net/qeth_core.h
index 31a2b4e502ce..fcd005aad989 100644
--- a/drivers/s390/net/qeth_core.h
+++ b/drivers/s390/net/qeth_core.h
@@ -122,7 +122,6 @@ struct qeth_perf_stats {
         __u64 outbound_do_qdio_start_time;
         unsigned int outbound_do_qdio_cnt;
         unsigned int outbound_do_qdio_time;
-        /* eddp data */
         unsigned int large_send_bytes;
         unsigned int large_send_cnt;
         unsigned int sg_skbs_sent;
@@ -135,6 +134,7 @@ struct qeth_perf_stats {
         unsigned int sg_frags_rx;
         unsigned int sg_alloc_page_rx;
         unsigned int tx_csum;
+        unsigned int tx_lin;
 };
 
 /* Routing stuff */
@@ -648,6 +648,8 @@ struct qeth_card_options {
         enum qeth_large_send_types large_send;
         int performance_stats;
         int rx_sg_cb;
+        enum qeth_ipa_isolation_modes isolation;
+        int sniffer;
 };
 
 /*
@@ -736,6 +738,7 @@ struct qeth_card {
         struct qeth_discipline discipline;
         atomic_t force_alloc_skb;
         struct service_level qeth_service_level;
+        struct qdio_ssqd_desc ssqd;
 };
 
 struct qeth_card_list_struct {
@@ -760,7 +763,8 @@ static inline int qeth_get_micros(void)
 
 static inline int qeth_get_ip_version(struct sk_buff *skb)
 {
-        switch (skb->protocol) {
+        struct ethhdr *ehdr = (struct ethhdr *)skb->data;
+        switch (ehdr->h_proto) {
         case ETH_P_IPV6:
                 return 6;
         case ETH_P_IP:
@@ -776,7 +780,6 @@ static inline void qeth_put_buffer_pool_entry(struct qeth_card *card,
         list_add_tail(&entry->list, &card->qdio.in_buf_pool.entry_list);
 }
 
-struct qeth_eddp_context;
 extern struct ccwgroup_driver qeth_l2_ccwgroup_driver;
 extern struct ccwgroup_driver qeth_l3_ccwgroup_driver;
 const char *qeth_get_cardname_short(struct qeth_card *);
@@ -811,7 +814,8 @@ int qeth_send_ipa_cmd(struct qeth_card *, struct qeth_cmd_buffer *,
 struct qeth_cmd_buffer *qeth_get_ipacmd_buffer(struct qeth_card *,
                         enum qeth_ipa_cmds, enum qeth_prot_versions);
 int qeth_query_setadapterparms(struct qeth_card *);
-int qeth_check_qdio_errors(struct qdio_buffer *, unsigned int, const char *);
+int qeth_check_qdio_errors(struct qeth_card *, struct qdio_buffer *,
+                unsigned int, const char *);
 void qeth_queue_input_buffer(struct qeth_card *, int);
 struct sk_buff *qeth_core_get_next_skb(struct qeth_card *,
                 struct qdio_buffer *, struct qdio_buffer_element **, int *,
@@ -836,7 +840,6 @@ void qeth_prepare_ipa_cmd(struct qeth_card *, struct qeth_cmd_buffer *, char);
 struct qeth_cmd_buffer *qeth_wait_for_buffer(struct qeth_channel *);
 int qeth_mdio_read(struct net_device *, int, int);
 int qeth_snmp_command(struct qeth_card *, char __user *);
-int qeth_set_large_send(struct qeth_card *, enum qeth_large_send_types);
 struct qeth_cmd_buffer *qeth_get_adapter_cmd(struct qeth_card *, __u32, __u32);
 int qeth_default_setadapterparms_cb(struct qeth_card *, struct qeth_reply *,
                                         unsigned long);
@@ -849,13 +852,14 @@ int qeth_do_send_packet_fast(struct qeth_card *, struct qeth_qdio_out_q *,
                         struct sk_buff *, struct qeth_hdr *, int, int, int);
 int qeth_do_send_packet(struct qeth_card *, struct qeth_qdio_out_q *,
                     struct sk_buff *, struct qeth_hdr *, int);
-int qeth_core_get_stats_count(struct net_device *);
+int qeth_core_get_sset_count(struct net_device *, int);
 void qeth_core_get_ethtool_stats(struct net_device *,
                                 struct ethtool_stats *, u64 *);
 void qeth_core_get_strings(struct net_device *, u32, u8 *);
 void qeth_core_get_drvinfo(struct net_device *, struct ethtool_drvinfo *);
 void qeth_dbf_longtext(enum qeth_dbf_names dbf_nix, int level, char *text, ...);
 int qeth_core_ethtool_get_settings(struct net_device *, struct ethtool_cmd *);
+int qeth_set_access_ctrl_online(struct qeth_card *card);
 
 /* exports for OSN */
 int qeth_osn_assist(struct net_device *, void *, int);
diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c
index c4a42d970158..3ba738b2e271 100644
--- a/drivers/s390/net/qeth_core_main.c
+++ b/drivers/s390/net/qeth_core_main.c
@@ -20,6 +20,7 @@
 #include <linux/tcp.h>
 #include <linux/mii.h>
 #include <linux/kthread.h>
+#include <linux/slab.h>
 
 #include <asm/ebcdic.h>
 #include <asm/io.h>
@@ -269,41 +270,7 @@ int qeth_realloc_buffer_pool(struct qeth_card *card, int bufcnt)
         card->qdio.init_pool.buf_count = bufcnt;
         return qeth_alloc_buffer_pool(card);
 }
-
-int qeth_set_large_send(struct qeth_card *card,
-                enum qeth_large_send_types type)
-{
-        int rc = 0;
-
-        if (card->dev == NULL) {
-                card->options.large_send = type;
-                return 0;
-        }
-        if (card->state == CARD_STATE_UP)
-                netif_tx_disable(card->dev);
-        card->options.large_send = type;
-        switch (card->options.large_send) {
-        case QETH_LARGE_SEND_TSO:
-                if (qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
-                        card->dev->features |= NETIF_F_TSO | NETIF_F_SG |
-                                                NETIF_F_HW_CSUM;
-                } else {
-                        card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
-                                                NETIF_F_HW_CSUM);
-                        card->options.large_send = QETH_LARGE_SEND_NO;
-                        rc = -EOPNOTSUPP;
-                }
-                break;
-        default: /* includes QETH_LARGE_SEND_NO */
-                card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
-                                        NETIF_F_HW_CSUM);
-                break;
-        }
-        if (card->state == CARD_STATE_UP)
-                netif_wake_queue(card->dev);
-        return rc;
-}
-EXPORT_SYMBOL_GPL(qeth_set_large_send);
+EXPORT_SYMBOL_GPL(qeth_realloc_buffer_pool);
 
 static int qeth_issue_next_read(struct qeth_card *card)
 {
@@ -385,8 +352,10 @@ static struct qeth_ipa_cmd *qeth_check_ipa_data(struct qeth_card *card,
         if (IS_IPA(iob->data)) {
                 cmd = (struct qeth_ipa_cmd *) PDU_ENCAPSULATION(iob->data);
                 if (IS_IPA_REPLY(cmd)) {
-                        if (cmd->hdr.command < IPA_CMD_SETCCID ||
-                            cmd->hdr.command > IPA_CMD_MODCCID)
+                        if (cmd->hdr.command != IPA_CMD_SETCCID &&
+                            cmd->hdr.command != IPA_CMD_DELCCID &&
+                            cmd->hdr.command != IPA_CMD_MODCCID &&
+                            cmd->hdr.command != IPA_CMD_SET_DIAG_ASS)
                                 qeth_issue_ipa_msg(cmd,
                                                 cmd->hdr.return_code, card);
                         return cmd;
@@ -569,7 +538,8 @@ static void qeth_send_control_data_cb(struct qeth_channel *channel,
                         dev_err(&card->gdev->dev,
                                 "The qeth device is not configured "
                                 "for the OSI layer required by z/VM\n");
-                qeth_schedule_recovery(card);
+                else
+                        qeth_schedule_recovery(card);
                 goto out;
         }
 
@@ -1079,6 +1049,7 @@ static void qeth_set_intial_options(struct qeth_card *card)
         card->options.add_hhlen = DEFAULT_ADD_HHLEN;
         card->options.performance_stats = 0;
         card->options.rx_sg_cb = QETH_RX_SG_CB;
+        card->options.isolation = ISOLATION_MODE_NONE;
 }
 
 static int qeth_do_start_thread(struct qeth_card *card, unsigned long thread)
@@ -1134,11 +1105,6 @@ static int qeth_setup_card(struct qeth_card *card)
         card->thread_running_mask = 0;
         INIT_WORK(&card->kernel_thread_starter, qeth_start_kernel_thread);
         INIT_LIST_HEAD(&card->ip_list);
-        card->ip_tbd_list = kmalloc(sizeof(struct list_head), GFP_KERNEL);
-        if (!card->ip_tbd_list) {
-                QETH_DBF_TEXT(SETUP, 0, "iptbdnom");
-                return -ENOMEM;
-        }
         INIT_LIST_HEAD(card->ip_tbd_list);
         INIT_LIST_HEAD(&card->cmd_waiter_list);
         init_waitqueue_head(&card->wait_q);
@@ -1149,8 +1115,6 @@ static int qeth_setup_card(struct qeth_card *card)
         card->ipato.enabled = 0;
         card->ipato.invert4 = 0;
         card->ipato.invert6 = 0;
-        if (card->info.type == QETH_CARD_TYPE_IQD)
-                card->options.checksum_type = NO_CHECKSUMMING;
         /* init QDIO stuff */
         qeth_init_qdio_info(card);
         return 0;
@@ -1172,21 +1136,30 @@ static struct qeth_card *qeth_alloc_card(void)
         QETH_DBF_TEXT(SETUP, 2, "alloccrd");
         card = kzalloc(sizeof(struct qeth_card), GFP_DMA|GFP_KERNEL);
         if (!card)
-                return NULL;
+                goto out;
         QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
-        if (qeth_setup_channel(&card->read)) {
-                kfree(card);
-                return NULL;
-        }
-        if (qeth_setup_channel(&card->write)) {
-                qeth_clean_channel(&card->read);
-                kfree(card);
-                return NULL;
+        card->ip_tbd_list = kmalloc(sizeof(struct list_head), GFP_KERNEL);
+        if (!card->ip_tbd_list) {
+                QETH_DBF_TEXT(SETUP, 0, "iptbdnom");
+                goto out_card;
         }
+        if (qeth_setup_channel(&card->read))
+                goto out_ip;
+        if (qeth_setup_channel(&card->write))
+                goto out_channel;
         card->options.layer2 = -1;
         card->qeth_service_level.seq_print = qeth_core_sl_print;
         register_service_level(&card->qeth_service_level);
         return card;
+
+out_channel:
+        qeth_clean_channel(&card->read);
+out_ip:
+        kfree(card->ip_tbd_list);
+out_card:
+        kfree(card);
+out:
+        return NULL;
 }
 
 static int qeth_determine_card_type(struct qeth_card *card)
@@ -1389,26 +1362,29 @@ static int qeth_read_conf_data(struct qeth_card *card, void **buffer,
         return ret;
 }
 
-static int qeth_get_unitaddr(struct qeth_card *card)
+static void qeth_configure_unitaddr(struct qeth_card *card, char *prcd)
 {
-        int length;
-        char *prcd;
-        int rc;
-
-        QETH_DBF_TEXT(SETUP, 2, "getunit");
-        rc = qeth_read_conf_data(card, (void **) &prcd, &length);
-        if (rc) {
-                QETH_DBF_MESSAGE(2, "%s qeth_read_conf_data returned %i\n",
-                        dev_name(&card->gdev->dev), rc);
-                return rc;
-        }
+        QETH_DBF_TEXT(SETUP, 2, "cfgunit");
         card->info.chpid = prcd[30];
         card->info.unit_addr2 = prcd[31];
         card->info.cula = prcd[63];
         card->info.guestlan = ((prcd[0x10] == _ascebc['V']) &&
                                (prcd[0x11] == _ascebc['M']));
-        kfree(prcd);
-        return 0;
+}
+
+static void qeth_configure_blkt_default(struct qeth_card *card, char *prcd)
+{
+        QETH_DBF_TEXT(SETUP, 2, "cfgblkt");
+
+        if (prcd[74] == 0xF0 && prcd[75] == 0xF0 && prcd[76] == 0xF5) {
+                card->info.blkt.time_total = 250;
+                card->info.blkt.inter_packet = 5;
+                card->info.blkt.inter_packet_jumbo = 15;
+        } else {
+                card->info.blkt.time_total = 0;
+                card->info.blkt.inter_packet = 0;
+                card->info.blkt.inter_packet_jumbo = 0;
+        }
 }
 
 static void qeth_init_tokens(struct qeth_card *card)
@@ -2607,8 +2583,8 @@ int qeth_query_setadapterparms(struct qeth_card *card)
 }
 EXPORT_SYMBOL_GPL(qeth_query_setadapterparms);
 
-int qeth_check_qdio_errors(struct qdio_buffer *buf, unsigned int qdio_error,
-                const char *dbftext)
+int qeth_check_qdio_errors(struct qeth_card *card, struct qdio_buffer *buf,
+                unsigned int qdio_error, const char *dbftext)
 {
         if (qdio_error) {
                 QETH_DBF_TEXT(TRACE, 2, dbftext);
@@ -2618,7 +2594,11 @@ int qeth_check_qdio_errors(struct qdio_buffer *buf, unsigned int qdio_error,
                 QETH_DBF_TEXT_(QERR, 2, " F14=%02X",
                                buf->element[14].flags & 0xff);
                 QETH_DBF_TEXT_(QERR, 2, " qerr=%X", qdio_error);
-                return 1;
+                if ((buf->element[15].flags & 0xff) == 0x12) {
+                        card->stats.rx_dropped++;
+                        return 0;
+                } else
+                        return 1;
         }
         return 0;
 }
@@ -2701,7 +2681,7 @@ static int qeth_handle_send_error(struct qeth_card *card,
                         qdio_err = 1;
                 }
         }
-        qeth_check_qdio_errors(buffer->buffer, qdio_err, "qouterr");
+        qeth_check_qdio_errors(card, buffer->buffer, qdio_err, "qouterr");
 
         if (!qdio_err)
                 return QETH_SEND_ERROR_NONE;
@@ -3389,10 +3369,161 @@ int qeth_setadpparms_change_macaddr(struct qeth_card *card)
 }
 EXPORT_SYMBOL_GPL(qeth_setadpparms_change_macaddr);
 
+static int qeth_setadpparms_set_access_ctrl_cb(struct qeth_card *card,
+                struct qeth_reply *reply, unsigned long data)
+{
+        struct qeth_ipa_cmd *cmd;
+        struct qeth_set_access_ctrl *access_ctrl_req;
+        int rc;
+
+        QETH_DBF_TEXT(TRACE, 4, "setaccb");
+
+        cmd = (struct qeth_ipa_cmd *) data;
+        access_ctrl_req = &cmd->data.setadapterparms.data.set_access_ctrl;
+        QETH_DBF_TEXT_(SETUP, 2, "setaccb");
+        QETH_DBF_TEXT_(SETUP, 2, "%s", card->gdev->dev.kobj.name);
+        QETH_DBF_TEXT_(SETUP, 2, "rc=%d",
+                cmd->data.setadapterparms.hdr.return_code);
+        switch (cmd->data.setadapterparms.hdr.return_code) {
+        case SET_ACCESS_CTRL_RC_SUCCESS:
+        case SET_ACCESS_CTRL_RC_ALREADY_NOT_ISOLATED:
+        case SET_ACCESS_CTRL_RC_ALREADY_ISOLATED:
+        {
+                card->options.isolation = access_ctrl_req->subcmd_code;
+                if (card->options.isolation == ISOLATION_MODE_NONE) {
+                        dev_info(&card->gdev->dev,
+                            "QDIO data connection isolation is deactivated\n");
+                } else {
+                        dev_info(&card->gdev->dev,
+                            "QDIO data connection isolation is activated\n");
+                }
+                QETH_DBF_MESSAGE(3, "OK:SET_ACCESS_CTRL(%s, %d)==%d\n",
+                        card->gdev->dev.kobj.name,
+                        access_ctrl_req->subcmd_code,
+                        cmd->data.setadapterparms.hdr.return_code);
+                rc = 0;
+                break;
+        }
+        case SET_ACCESS_CTRL_RC_NOT_SUPPORTED:
+        {
+                QETH_DBF_MESSAGE(3, "ERR:SET_ACCESS_CTRL(%s,%d)==%d\n",
+                        card->gdev->dev.kobj.name,
+                        access_ctrl_req->subcmd_code,
+                        cmd->data.setadapterparms.hdr.return_code);
+                dev_err(&card->gdev->dev, "Adapter does not "
+                        "support QDIO data connection isolation\n");
+
+                /* ensure isolation mode is "none" */
+                card->options.isolation = ISOLATION_MODE_NONE;
+                rc = -EOPNOTSUPP;
+                break;
+        }
+        case SET_ACCESS_CTRL_RC_NONE_SHARED_ADAPTER:
+        {
+                QETH_DBF_MESSAGE(3, "ERR:SET_ACCESS_MODE(%s,%d)==%d\n",
+                        card->gdev->dev.kobj.name,
+                        access_ctrl_req->subcmd_code,
+                        cmd->data.setadapterparms.hdr.return_code);
+                dev_err(&card->gdev->dev,
+                        "Adapter is dedicated. "
+                        "QDIO data connection isolation not supported\n");
+
+                /* ensure isolation mode is "none" */
+                card->options.isolation = ISOLATION_MODE_NONE;
+                rc = -EOPNOTSUPP;
+                break;
+        }
+        case SET_ACCESS_CTRL_RC_ACTIVE_CHECKSUM_OFF:
+        {
+                QETH_DBF_MESSAGE(3, "ERR:SET_ACCESS_MODE(%s,%d)==%d\n",
+                        card->gdev->dev.kobj.name,
+                        access_ctrl_req->subcmd_code,
+                        cmd->data.setadapterparms.hdr.return_code);
+                dev_err(&card->gdev->dev,
+                        "TSO does not permit QDIO data connection isolation\n");
+
+                /* ensure isolation mode is "none" */
+                card->options.isolation = ISOLATION_MODE_NONE;
+                rc = -EPERM;
+                break;
+        }
+        default:
+        {
+                /* this should never happen */
+                QETH_DBF_MESSAGE(3, "ERR:SET_ACCESS_MODE(%s,%d)==%d"
+                        "==UNKNOWN\n",
+                        card->gdev->dev.kobj.name,
+                        access_ctrl_req->subcmd_code,
+                        cmd->data.setadapterparms.hdr.return_code);
+
+                /* ensure isolation mode is "none" */
+                card->options.isolation = ISOLATION_MODE_NONE;
+                rc = 0;
+                break;
+        }
+        }
+        qeth_default_setadapterparms_cb(card, reply, (unsigned long) cmd);
+        return rc;
+}
+
+static int qeth_setadpparms_set_access_ctrl(struct qeth_card *card,
+                enum qeth_ipa_isolation_modes isolation)
+{
+        int rc;
+        struct qeth_cmd_buffer *iob;
+        struct qeth_ipa_cmd *cmd;
+        struct qeth_set_access_ctrl *access_ctrl_req;
+
+        QETH_DBF_TEXT(TRACE, 4, "setacctl");
+
+        QETH_DBF_TEXT_(SETUP, 2, "setacctl");
+        QETH_DBF_TEXT_(SETUP, 2, "%s", card->gdev->dev.kobj.name);
+
+        iob = qeth_get_adapter_cmd(card, IPA_SETADP_SET_ACCESS_CONTROL,
+                                   sizeof(struct qeth_ipacmd_setadpparms_hdr) +
+                                   sizeof(struct qeth_set_access_ctrl));
+        cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
+        access_ctrl_req = &cmd->data.setadapterparms.data.set_access_ctrl;
+        access_ctrl_req->subcmd_code = isolation;
+
+        rc = qeth_send_ipa_cmd(card, iob, qeth_setadpparms_set_access_ctrl_cb,
+                               NULL);
+        QETH_DBF_TEXT_(SETUP, 2, "rc=%d", rc);
+        return rc;
+}
+
+int qeth_set_access_ctrl_online(struct qeth_card *card)
+{
+        int rc = 0;
+
+        QETH_DBF_TEXT(TRACE, 4, "setactlo");
+
+        if (card->info.type == QETH_CARD_TYPE_OSAE &&
+            qeth_adp_supported(card, IPA_SETADP_SET_ACCESS_CONTROL)) {
+                rc = qeth_setadpparms_set_access_ctrl(card,
+                        card->options.isolation);
+                if (rc) {
+                        QETH_DBF_MESSAGE(3,
+                                "IPA(SET_ACCESS_CTRL,%s,%d) sent failed",
+                                card->gdev->dev.kobj.name,
+                                rc);
+                }
+        } else if (card->options.isolation != ISOLATION_MODE_NONE) {
+                card->options.isolation = ISOLATION_MODE_NONE;
+
+                dev_err(&card->gdev->dev, "Adapter does not "
+                        "support QDIO data connection isolation\n");
+                rc = -EOPNOTSUPP;
+        }
+        return rc;
+}
+EXPORT_SYMBOL_GPL(qeth_set_access_ctrl_online);
+
 void qeth_tx_timeout(struct net_device *dev)
 {
         struct qeth_card *card;
 
+        QETH_DBF_TEXT(TRACE, 4, "txtimeo");
         card = dev->ml_priv;
         card->stats.tx_errors++;
         qeth_schedule_recovery(card);
@@ -3674,9 +3805,6 @@ static int qeth_qdio_establish(struct qeth_card *card)
         init_data.input_handler          = card->discipline.input_handler;
         init_data.output_handler         = card->discipline.output_handler;
         init_data.int_parm               = (unsigned long) card;
-        init_data.flags                  = QDIO_INBOUND_0COPY_SBALS |
-                                           QDIO_OUTBOUND_0COPY_SBALS |
-                                           QDIO_USE_OUTBOUND_PCIS;
         init_data.input_sbal_addr_array  = (void **) in_sbal_ptrs;
         init_data.output_sbal_addr_array = (void **) out_sbal_ptrs;
 
@@ -3731,60 +3859,39 @@ static int qeth_core_driver_group(const char *buf, struct device *root_dev,
 
 int qeth_core_hardsetup_card(struct qeth_card *card)
 {
-        struct qdio_ssqd_desc *ssqd;
-        int retries = 3;
-        int mpno = 0;
+        int retries = 0;
         int rc;
 
         QETH_DBF_TEXT(SETUP, 2, "hrdsetup");
         atomic_set(&card->force_alloc_skb, 0);
 retry:
-        if (retries < 3) {
+        if (retries)
                 QETH_DBF_MESSAGE(2, "%s Retrying to do IDX activates.\n",
                         dev_name(&card->gdev->dev));
-                ccw_device_set_offline(CARD_DDEV(card));
-                ccw_device_set_offline(CARD_WDEV(card));
-                ccw_device_set_offline(CARD_RDEV(card));
-                ccw_device_set_online(CARD_RDEV(card));
-                ccw_device_set_online(CARD_WDEV(card));
-                ccw_device_set_online(CARD_DDEV(card));
-        }
+        ccw_device_set_offline(CARD_DDEV(card));
+        ccw_device_set_offline(CARD_WDEV(card));
+        ccw_device_set_offline(CARD_RDEV(card));
+        rc = ccw_device_set_online(CARD_RDEV(card));
+        if (rc)
+                goto retriable;
+        rc = ccw_device_set_online(CARD_WDEV(card));
+        if (rc)
+                goto retriable;
+        rc = ccw_device_set_online(CARD_DDEV(card));
+        if (rc)
+                goto retriable;
         rc = qeth_qdio_clear_card(card, card->info.type != QETH_CARD_TYPE_IQD);
+retriable:
         if (rc == -ERESTARTSYS) {
                 QETH_DBF_TEXT(SETUP, 2, "break1");
                 return rc;
         } else if (rc) {
                 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
-                if (--retries < 0)
+                if (++retries > 3)
                         goto out;
                 else
                         goto retry;
         }
-
-        rc = qeth_get_unitaddr(card);
-        if (rc) {
-                QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
-                return rc;
-        }
-
-        ssqd = kmalloc(sizeof(struct qdio_ssqd_desc), GFP_KERNEL);
-        if (!ssqd) {
-                rc = -ENOMEM;
-                goto out;
-        }
-        rc = qdio_get_ssqd_desc(CARD_DDEV(card), ssqd);
-        if (rc == 0)
-                mpno = ssqd->pcnt;
-        kfree(ssqd);
-
-        if (mpno)
-                mpno = min(mpno - 1, QETH_MAX_PORTNO);
-        if (card->info.portno > mpno) {
-                QETH_DBF_MESSAGE(2, "Device %s does not offer port number %d"
-                        "\n.", CARD_BUS_ID(card), card->info.portno);
-                rc = -ENODEV;
-                goto out;
-        }
         qeth_init_tokens(card);
         qeth_init_func_level(card);
         rc = qeth_idx_activate_channel(&card->read, qeth_idx_read_cb);
@@ -3868,7 +3975,7 @@ struct sk_buff *qeth_core_get_next_skb(struct qeth_card *card,
         struct qdio_buffer_element *element = *__element;
         int offset = *__offset;
         struct sk_buff *skb = NULL;
-        int skb_len;
+        int skb_len = 0;
         void *data_ptr;
         int data_len;
         int headroom = 0;
@@ -3887,20 +3994,24 @@ struct sk_buff *qeth_core_get_next_skb(struct qeth_card *card,
         *hdr = element->addr + offset;
 
         offset += sizeof(struct qeth_hdr);
-        if (card->options.layer2) {
-                if (card->info.type == QETH_CARD_TYPE_OSN) {
-                        skb_len = (*hdr)->hdr.osn.pdu_length;
-                        headroom = sizeof(struct qeth_hdr);
-                } else {
-                        skb_len = (*hdr)->hdr.l2.pkt_length;
-                }
-        } else {
+        switch ((*hdr)->hdr.l2.id) {
+        case QETH_HEADER_TYPE_LAYER2:
+                skb_len = (*hdr)->hdr.l2.pkt_length;
+                break;
+        case QETH_HEADER_TYPE_LAYER3:
                 skb_len = (*hdr)->hdr.l3.length;
                 if ((card->info.link_type == QETH_LINK_TYPE_LANE_TR) ||
                     (card->info.link_type == QETH_LINK_TYPE_HSTR))
                         headroom = TR_HLEN;
                 else
                         headroom = ETH_HLEN;
+                break;
+        case QETH_HEADER_TYPE_OSN:
+                skb_len = (*hdr)->hdr.osn.pdu_length;
+                headroom = sizeof(struct qeth_hdr);
+                break;
+        default:
+                break;
         }
 
         if (!skb_len)
@@ -4055,6 +4166,41 @@ void qeth_core_free_discipline(struct qeth_card *card)
         card->discipline.ccwgdriver = NULL;
 }
 
+static void qeth_determine_capabilities(struct qeth_card *card)
+{
+        int rc;
+        int length;
+        char *prcd;
+
+        QETH_DBF_TEXT(SETUP, 2, "detcapab");
+        rc = ccw_device_set_online(CARD_DDEV(card));
+        if (rc) {
+                QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc);
+                goto out;
+        }
+
+
+        rc = qeth_read_conf_data(card, (void **) &prcd, &length);
+        if (rc) {
+                QETH_DBF_MESSAGE(2, "%s qeth_read_conf_data returned %i\n",
+                        dev_name(&card->gdev->dev), rc);
+                QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc);
+                goto out_offline;
+        }
+        qeth_configure_unitaddr(card, prcd);
+        qeth_configure_blkt_default(card, prcd);
+        kfree(prcd);
+
+        rc = qdio_get_ssqd_desc(CARD_DDEV(card), &card->ssqd);
+        if (rc)
+                QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
+
+out_offline:
+        ccw_device_set_offline(CARD_DDEV(card));
+out:
+        return;
+}
+
 static int qeth_core_probe_device(struct ccwgroup_device *gdev)
 {
         struct qeth_card *card;
@@ -4120,6 +4266,8 @@ static int qeth_core_probe_device(struct ccwgroup_device *gdev)
         write_lock_irqsave(&qeth_core_card_list.rwlock, flags);
         list_add_tail(&card->list, &qeth_core_card_list.list);
         write_unlock_irqrestore(&qeth_core_card_list.rwlock, flags);
+
+        qeth_determine_capabilities(card);
         return 0;
 
 err_card:
@@ -4303,13 +4451,19 @@ static struct {
         {"tx do_QDIO time"},
         {"tx do_QDIO count"},
         {"tx csum"},
+        {"tx lin"},
 };
 
-int qeth_core_get_stats_count(struct net_device *dev)
+int qeth_core_get_sset_count(struct net_device *dev, int stringset)
 {
-        return (sizeof(qeth_ethtool_stats_keys) / ETH_GSTRING_LEN);
+        switch (stringset) {
+        case ETH_SS_STATS:
+                return (sizeof(qeth_ethtool_stats_keys) / ETH_GSTRING_LEN);
+        default:
+                return -EINVAL;
+        }
 }
-EXPORT_SYMBOL_GPL(qeth_core_get_stats_count);
+EXPORT_SYMBOL_GPL(qeth_core_get_sset_count);
 
 void qeth_core_get_ethtool_stats(struct net_device *dev,
                 struct ethtool_stats *stats, u64 *data)
@@ -4355,6 +4509,7 @@ void qeth_core_get_ethtool_stats(struct net_device *dev,
         data[31] = card->perf_stats.outbound_do_qdio_time;
         data[32] = card->perf_stats.outbound_do_qdio_cnt;
         data[33] = card->perf_stats.tx_csum;
+        data[34] = card->perf_stats.tx_lin;
 }
 EXPORT_SYMBOL_GPL(qeth_core_get_ethtool_stats);
 
diff --git a/drivers/s390/net/qeth_core_mpc.h b/drivers/s390/net/qeth_core_mpc.h
index eecb2ee62e85..104a3351e02b 100644
--- a/drivers/s390/net/qeth_core_mpc.h
+++ b/drivers/s390/net/qeth_core_mpc.h
@@ -156,6 +156,8 @@ enum qeth_ipa_return_codes {
         IPA_RC_IP_TABLE_FULL            = 0x0002,
         IPA_RC_UNKNOWN_ERROR            = 0x0003,
         IPA_RC_UNSUPPORTED_COMMAND      = 0x0004,
+        IPA_RC_TRACE_ALREADY_ACTIVE     = 0x0005,
+        IPA_RC_INVALID_FORMAT           = 0x0006,
         IPA_RC_DUP_IPV6_REMOTE          = 0x0008,
         IPA_RC_DUP_IPV6_HOME            = 0x0010,
         IPA_RC_UNREGISTERED_ADDR        = 0x0011,
@@ -196,6 +198,11 @@ enum qeth_ipa_return_codes {
         IPA_RC_INVALID_IP_VERSION2      = 0xf001,
         IPA_RC_FFFF                     = 0xffff
 };
+/* for DELIP */
+#define IPA_RC_IP_ADDRESS_NOT_DEFINED   IPA_RC_PRIMARY_ALREADY_DEFINED
+/* for SET_DIAGNOSTIC_ASSIST */
+#define IPA_RC_INVALID_SUBCMD           IPA_RC_IP_TABLE_FULL
+#define IPA_RC_HARDWARE_AUTH_ERROR      IPA_RC_UNKNOWN_ERROR
 
 /* IPA function flags; each flag marks availability of respective function */
 enum qeth_ipa_funcs {
@@ -234,18 +241,20 @@ enum qeth_ipa_setdelip_flags {
 
 /* SETADAPTER IPA Command: ****************************************************/
 enum qeth_ipa_setadp_cmd {
-        IPA_SETADP_QUERY_COMMANDS_SUPPORTED     = 0x0001,
-        IPA_SETADP_ALTER_MAC_ADDRESS            = 0x0002,
-        IPA_SETADP_ADD_DELETE_GROUP_ADDRESS     = 0x0004,
-        IPA_SETADP_ADD_DELETE_FUNCTIONAL_ADDR   = 0x0008,
-        IPA_SETADP_SET_ADDRESSING_MODE          = 0x0010,
-        IPA_SETADP_SET_CONFIG_PARMS             = 0x0020,
-        IPA_SETADP_SET_CONFIG_PARMS_EXTENDED    = 0x0040,
-        IPA_SETADP_SET_BROADCAST_MODE           = 0x0080,
-        IPA_SETADP_SEND_OSA_MESSAGE             = 0x0100,
-        IPA_SETADP_SET_SNMP_CONTROL             = 0x0200,
-        IPA_SETADP_QUERY_CARD_INFO              = 0x0400,
-        IPA_SETADP_SET_PROMISC_MODE             = 0x0800,
+        IPA_SETADP_QUERY_COMMANDS_SUPPORTED     = 0x00000001L,
+        IPA_SETADP_ALTER_MAC_ADDRESS            = 0x00000002L,
+        IPA_SETADP_ADD_DELETE_GROUP_ADDRESS     = 0x00000004L,
+        IPA_SETADP_ADD_DELETE_FUNCTIONAL_ADDR   = 0x00000008L,
+        IPA_SETADP_SET_ADDRESSING_MODE          = 0x00000010L,
+        IPA_SETADP_SET_CONFIG_PARMS             = 0x00000020L,
+        IPA_SETADP_SET_CONFIG_PARMS_EXTENDED    = 0x00000040L,
+        IPA_SETADP_SET_BROADCAST_MODE           = 0x00000080L,
+        IPA_SETADP_SEND_OSA_MESSAGE             = 0x00000100L,
+        IPA_SETADP_SET_SNMP_CONTROL             = 0x00000200L,
+        IPA_SETADP_QUERY_CARD_INFO              = 0x00000400L,
+        IPA_SETADP_SET_PROMISC_MODE             = 0x00000800L,
+        IPA_SETADP_SET_DIAG_ASSIST              = 0x00002000L,
+        IPA_SETADP_SET_ACCESS_CONTROL           = 0x00010000L,
 };
 enum qeth_ipa_mac_ops {
         CHANGE_ADDR_READ_MAC            = 0,
@@ -264,6 +273,20 @@ enum qeth_ipa_promisc_modes {
         SET_PROMISC_MODE_OFF            = 0,
         SET_PROMISC_MODE_ON             = 1,
 };
+enum qeth_ipa_isolation_modes {
+        ISOLATION_MODE_NONE             = 0x00000000L,
+        ISOLATION_MODE_FWD              = 0x00000001L,
+        ISOLATION_MODE_DROP             = 0x00000002L,
+};
+enum qeth_ipa_set_access_mode_rc {
+        SET_ACCESS_CTRL_RC_SUCCESS              = 0x0000,
+        SET_ACCESS_CTRL_RC_NOT_SUPPORTED        = 0x0004,
+        SET_ACCESS_CTRL_RC_ALREADY_NOT_ISOLATED = 0x0008,
+        SET_ACCESS_CTRL_RC_ALREADY_ISOLATED     = 0x0010,
+        SET_ACCESS_CTRL_RC_NONE_SHARED_ADAPTER  = 0x0014,
+        SET_ACCESS_CTRL_RC_ACTIVE_CHECKSUM_OFF  = 0x0018,
+};
+
 
 /* (SET)DELIP(M) IPA stuff ***************************************************/
 struct qeth_ipacmd_setdelip4 {
@@ -376,6 +399,11 @@ struct qeth_snmp_ureq {
         struct qeth_snmp_cmd cmd;
 } __attribute__((packed));
 
+/* SET_ACCESS_CONTROL: same format for request and reply */
+struct qeth_set_access_ctrl {
+        __u32 subcmd_code;
+} __attribute__((packed));
+
 struct qeth_ipacmd_setadpparms_hdr {
         __u32 supp_hw_cmds;
         __u32 reserved1;
@@ -394,6 +422,7 @@ struct qeth_ipacmd_setadpparms {
                 struct qeth_query_cmds_supp query_cmds_supp;
                 struct qeth_change_addr change_addr;
                 struct qeth_snmp_cmd snmp;
+                struct qeth_set_access_ctrl set_access_ctrl;
                 __u32 mode;
         } data;
 } __attribute__ ((packed));
@@ -403,6 +432,40 @@ struct qeth_create_destroy_address {
         __u8 unique_id[8];
 } __attribute__ ((packed));
 
+/* SET DIAGNOSTIC ASSIST IPA Command:    *************************************/
+
+enum qeth_diags_cmds {
+        QETH_DIAGS_CMD_QUERY    = 0x0001,
+        QETH_DIAGS_CMD_TRAP     = 0x0002,
+        QETH_DIAGS_CMD_TRACE    = 0x0004,
+        QETH_DIAGS_CMD_NOLOG    = 0x0008,
+        QETH_DIAGS_CMD_DUMP     = 0x0010,
+};
+
+enum qeth_diags_trace_types {
+        QETH_DIAGS_TYPE_HIPERSOCKET     = 0x02,
+};
+
+enum qeth_diags_trace_cmds {
+        QETH_DIAGS_CMD_TRACE_ENABLE     = 0x0001,
+        QETH_DIAGS_CMD_TRACE_DISABLE    = 0x0002,
+        QETH_DIAGS_CMD_TRACE_MODIFY     = 0x0004,
+        QETH_DIAGS_CMD_TRACE_REPLACE    = 0x0008,
+        QETH_DIAGS_CMD_TRACE_QUERY      = 0x0010,
+};
+
+struct qeth_ipacmd_diagass {
+        __u32  host_tod2;
+        __u32:32;
+        __u16  subcmd_len;
+        __u16:16;
+        __u32  subcmd;
+        __u8   type;
+        __u8   action;
+        __u16  options;
+        __u32:32;
+} __attribute__ ((packed));
+
 /* Header for each IPA command */
 struct qeth_ipacmd_hdr {
         __u8   command;
@@ -431,6 +494,7 @@ struct qeth_ipa_cmd {
                 struct qeth_create_destroy_address      create_destroy_addr;
                 struct qeth_ipacmd_setadpparms          setadapterparms;
                 struct qeth_set_routing                 setrtg;
+                struct qeth_ipacmd_diagass              diagass;
         } data;
 } __attribute__ ((packed));
 
@@ -448,7 +512,6 @@ enum qeth_ipa_arp_return_codes {
         QETH_IPA_ARP_RC_Q_NO_DATA    = 0x0008,
 };
 
-
 extern char *qeth_get_ipa_msg(enum qeth_ipa_return_codes rc);
 extern char *qeth_get_ipa_cmd_name(enum qeth_ipa_cmds cmd);
 
@@ -507,7 +570,7 @@ extern unsigned char ULP_ENABLE[];
                 (PDU_ENCAPSULATION(buffer) + 0x17)
 #define QETH_ULP_ENABLE_RESP_LINK_TYPE(buffer) \
                 (PDU_ENCAPSULATION(buffer) + 0x2b)
-/* Layer 2 defintions */
+/* Layer 2 definitions */
 #define QETH_PROT_LAYER2 0x08
 #define QETH_PROT_TCPIP  0x03
 #define QETH_PROT_OSN2   0x0a
diff --git a/drivers/s390/net/qeth_core_sys.c b/drivers/s390/net/qeth_core_sys.c
index 33505c2a0e3a..25dfd5abd19b 100644
--- a/drivers/s390/net/qeth_core_sys.c
+++ b/drivers/s390/net/qeth_core_sys.c
@@ -8,6 +8,9 @@
  *               Frank Blaschka <frank.blaschka@de.ibm.com>
  */
 
+#define KMSG_COMPONENT "qeth"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+
 #include <linux/list.h>
 #include <linux/rwsem.h>
 #include <asm/ebcdic.h>
@@ -118,7 +121,7 @@ static ssize_t qeth_dev_portno_store(struct device *dev,
 {
         struct qeth_card *card = dev_get_drvdata(dev);
         char *tmp;
-        unsigned int portno;
+        unsigned int portno, limit;
 
         if (!card)
                 return -EINVAL;
@@ -128,9 +131,11 @@ static ssize_t qeth_dev_portno_store(struct device *dev,
                 return -EPERM;
 
         portno = simple_strtoul(buf, &tmp, 16);
-        if (portno > QETH_MAX_PORTNO) {
+        if (portno > QETH_MAX_PORTNO)
+                return -EINVAL;
+        limit = (card->ssqd.pcnt ? card->ssqd.pcnt - 1 : card->ssqd.pcnt);
+        if (portno > limit)
                 return -EINVAL;
-        }
 
         card->info.portno = portno;
         return count;
@@ -416,7 +421,11 @@ static ssize_t qeth_dev_layer2_store(struct device *dev,
 static DEVICE_ATTR(layer2, 0644, qeth_dev_layer2_show,
                    qeth_dev_layer2_store);
 
-static ssize_t qeth_dev_large_send_show(struct device *dev,
+#define ATTR_QETH_ISOLATION_NONE        ("none")
+#define ATTR_QETH_ISOLATION_FWD         ("forward")
+#define ATTR_QETH_ISOLATION_DROP        ("drop")
+
+static ssize_t qeth_dev_isolation_show(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
         struct qeth_card *card = dev_get_drvdata(dev);
@@ -424,44 +433,69 @@ static ssize_t qeth_dev_large_send_show(struct device *dev,
         if (!card)
                 return -EINVAL;
 
-        switch (card->options.large_send) {
-        case QETH_LARGE_SEND_NO:
-                return sprintf(buf, "%s\n", "no");
-        case QETH_LARGE_SEND_TSO:
-                return sprintf(buf, "%s\n", "TSO");
+        switch (card->options.isolation) {
+        case ISOLATION_MODE_NONE:
+                return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_NONE);
+        case ISOLATION_MODE_FWD:
+                return snprintf(buf, 9, "%s\n", ATTR_QETH_ISOLATION_FWD);
+        case ISOLATION_MODE_DROP:
+                return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_DROP);
         default:
-                return sprintf(buf, "%s\n", "N/A");
+                return snprintf(buf, 5, "%s\n", "N/A");
         }
 }
 
-static ssize_t qeth_dev_large_send_store(struct device *dev,
+static ssize_t qeth_dev_isolation_store(struct device *dev,
                 struct device_attribute *attr, const char *buf, size_t count)
 {
         struct qeth_card *card = dev_get_drvdata(dev);
-        enum qeth_large_send_types type;
+        enum qeth_ipa_isolation_modes isolation;
         int rc = 0;
-        char *tmp;
+        char *tmp, *curtoken;
+        curtoken = (char *) buf;
 
-        if (!card)
-                return -EINVAL;
-        tmp = strsep((char **) &buf, "\n");
-        if (!strcmp(tmp, "no")) {
-                type = QETH_LARGE_SEND_NO;
-        } else if (!strcmp(tmp, "TSO")) {
-                type = QETH_LARGE_SEND_TSO;
+        if (!card) {
+                rc = -EINVAL;
+                goto out;
+        }
+
+        /* check for unknown, too, in case we do not yet know who we are */
+        if (card->info.type != QETH_CARD_TYPE_OSAE &&
+            card->info.type != QETH_CARD_TYPE_UNKNOWN) {
+                rc = -EOPNOTSUPP;
+                dev_err(&card->gdev->dev, "Adapter does not "
+                        "support QDIO data connection isolation\n");
+                goto out;
+        }
+
+        /* parse input into isolation mode */
+        tmp = strsep(&curtoken, "\n");
+        if (!strcmp(tmp, ATTR_QETH_ISOLATION_NONE)) {
+                isolation = ISOLATION_MODE_NONE;
+        } else if (!strcmp(tmp, ATTR_QETH_ISOLATION_FWD)) {
+                isolation = ISOLATION_MODE_FWD;
+        } else if (!strcmp(tmp, ATTR_QETH_ISOLATION_DROP)) {
+                isolation = ISOLATION_MODE_DROP;
         } else {
-                return -EINVAL;
+                rc = -EINVAL;
+                goto out;
         }
-        if (card->options.large_send == type)
-                return count;
-        rc = qeth_set_large_send(card, type);
-        if (rc)
-                return rc;
-        return count;
+        rc = count;
+
+        /* defer IP assist if device is offline (until discipline->set_online)*/
+        card->options.isolation = isolation;
+        if (card->state == CARD_STATE_SOFTSETUP ||
+            card->state == CARD_STATE_UP) {
+                int ipa_rc = qeth_set_access_ctrl_online(card);
+                if (ipa_rc != 0)
+                        rc = ipa_rc;
+        }
+out:
+        return rc;
 }
 
-static DEVICE_ATTR(large_send, 0644, qeth_dev_large_send_show,
-                   qeth_dev_large_send_store);
+static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show,
+                   qeth_dev_isolation_store);
 
 static ssize_t qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value)
 {
@@ -508,7 +542,7 @@ static ssize_t qeth_dev_blkt_total_store(struct device *dev,
         struct qeth_card *card = dev_get_drvdata(dev);
 
         return qeth_dev_blkt_store(card, buf, count,
-                                   &card->info.blkt.time_total, 1000);
+                                   &card->info.blkt.time_total, 5000);
 }
 
 
@@ -530,7 +564,7 @@ static ssize_t qeth_dev_blkt_inter_store(struct device *dev,
         struct qeth_card *card = dev_get_drvdata(dev);
 
         return qeth_dev_blkt_store(card, buf, count,
-                                   &card->info.blkt.inter_packet, 100);
+                                   &card->info.blkt.inter_packet, 1000);
 }
 
 static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show,
@@ -551,7 +585,7 @@ static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev,
         struct qeth_card *card = dev_get_drvdata(dev);
 
         return qeth_dev_blkt_store(card, buf, count,
-                                   &card->info.blkt.inter_packet_jumbo, 100);
+                                   &card->info.blkt.inter_packet_jumbo, 1000);
 }
 
 static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show,
@@ -582,7 +616,7 @@ static struct attribute *qeth_device_attrs[] = {
         &dev_attr_recover.attr,
         &dev_attr_performance_stats.attr,
         &dev_attr_layer2.attr,
-        &dev_attr_large_send.attr,
+        &dev_attr_isolation.attr,
         NULL,
 };
 
diff --git a/drivers/s390/net/qeth_l2_main.c b/drivers/s390/net/qeth_l2_main.c
index f4f3ca1393b2..6a801dc3bf8e 100644
--- a/drivers/s390/net/qeth_l2_main.c
+++ b/drivers/s390/net/qeth_l2_main.c
@@ -16,6 +16,7 @@
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/etherdevice.h>
 #include <linux/mii.h>
 #include <linux/ip.h>
@@ -486,22 +487,14 @@ static int qeth_l2_send_setmac_cb(struct qeth_card *card,
                 case IPA_RC_L2_DUP_MAC:
                 case IPA_RC_L2_DUP_LAYER3_MAC:
                         dev_warn(&card->gdev->dev,
-                                "MAC address "
-                                "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x "
-                                "already exists\n",
-                                card->dev->dev_addr[0], card->dev->dev_addr[1],
-                                card->dev->dev_addr[2], card->dev->dev_addr[3],
-                                card->dev->dev_addr[4], card->dev->dev_addr[5]);
+                                "MAC address %pM already exists\n",
+                                card->dev->dev_addr);
                         break;
                 case IPA_RC_L2_MAC_NOT_AUTH_BY_HYP:
                 case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
                         dev_warn(&card->gdev->dev,
-                                "MAC address "
-                                "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x "
-                                "is not authorized\n",
-                                card->dev->dev_addr[0], card->dev->dev_addr[1],
-                                card->dev->dev_addr[2], card->dev->dev_addr[3],
-                                card->dev->dev_addr[4], card->dev->dev_addr[5]);
+                                "MAC address %pM is not authorized\n",
+                                card->dev->dev_addr);
                         break;
                 default:
                         break;
@@ -512,12 +505,8 @@ static int qeth_l2_send_setmac_cb(struct qeth_card *card,
                 memcpy(card->dev->dev_addr, cmd->data.setdelmac.mac,
                        OSA_ADDR_LEN);
                 dev_info(&card->gdev->dev,
-                        "MAC address %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x "
-                        "successfully registered on device %s\n",
-                        card->dev->dev_addr[0], card->dev->dev_addr[1],
-                        card->dev->dev_addr[2], card->dev->dev_addr[3],
-                        card->dev->dev_addr[4], card->dev->dev_addr[5],
-                        card->dev->name);
+                        "MAC address %pM successfully registered on device %s\n",
+                        card->dev->dev_addr, card->dev->name);
         }
         return 0;
 }
@@ -634,7 +623,7 @@ static void qeth_l2_set_multicast_list(struct net_device *dev)
         for (dm = dev->mc_list; dm; dm = dm->next)
                 qeth_l2_add_mc(card, dm->da_addr, 0);
 
-        list_for_each_entry(ha, &dev->uc.list, list)
+        netdev_for_each_uc_addr(ha, dev)
                 qeth_l2_add_mc(card, ha->addr, 1);
 
         spin_unlock_bh(&card->mclock);
@@ -781,7 +770,8 @@ static void qeth_l2_qdio_input_handler(struct ccw_device *ccwdev,
                 index = i % QDIO_MAX_BUFFERS_PER_Q;
                 buffer = &card->qdio.in_q->bufs[index];
                 if (!(qdio_err &&
-                      qeth_check_qdio_errors(buffer->buffer, qdio_err, "qinerr")))
+                      qeth_check_qdio_errors(card, buffer->buffer, qdio_err,
+                                             "qinerr")))
                         qeth_l2_process_inbound_buffer(card, buffer, index);
                 /* clear buffer and give back to hardware */
                 qeth_put_buffer_pool_entry(card, buffer->pool_entry);
@@ -866,7 +856,7 @@ static const struct ethtool_ops qeth_l2_ethtool_ops = {
         .get_link = ethtool_op_get_link,
         .get_strings = qeth_core_get_strings,
         .get_ethtool_stats = qeth_core_get_ethtool_stats,
-        .get_stats_count = qeth_core_get_stats_count,
+        .get_sset_count = qeth_core_get_sset_count,
         .get_drvinfo = qeth_core_get_drvinfo,
         .get_settings = qeth_core_ethtool_get_settings,
 };
@@ -874,7 +864,7 @@ static const struct ethtool_ops qeth_l2_ethtool_ops = {
 static const struct ethtool_ops qeth_l2_osn_ops = {
         .get_strings = qeth_core_get_strings,
         .get_ethtool_stats = qeth_core_get_ethtool_stats,
-        .get_stats_count = qeth_core_get_stats_count,
+        .get_sset_count = qeth_core_get_sset_count,
         .get_drvinfo = qeth_core_get_drvinfo,
 };
 
@@ -938,32 +928,18 @@ static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode)
         QETH_DBF_TEXT(SETUP, 2, "setonlin");
         QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
 
-        qeth_set_allowed_threads(card, QETH_RECOVER_THREAD, 1);
         recover_flag = card->state;
-        rc = ccw_device_set_online(CARD_RDEV(card));
-        if (rc) {
-                QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
-                return -EIO;
-        }
-        rc = ccw_device_set_online(CARD_WDEV(card));
-        if (rc) {
-                QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
-                return -EIO;
-        }
-        rc = ccw_device_set_online(CARD_DDEV(card));
-        if (rc) {
-                QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
-                return -EIO;
-        }
-
         rc = qeth_core_hardsetup_card(card);
         if (rc) {
                 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
+                rc = -ENODEV;
                 goto out_remove;
         }
 
-        if (!card->dev && qeth_l2_setup_netdev(card))
+        if (!card->dev && qeth_l2_setup_netdev(card)) {
+                rc = -ENODEV;
                 goto out_remove;
+        }
 
         if (card->info.type != QETH_CARD_TYPE_OSN)
                 qeth_l2_send_setmac(card, &card->dev->dev_addr[0]);
@@ -983,12 +959,14 @@ static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode)
                         card->lan_online = 0;
                         return 0;
                 }
+                rc = -ENODEV;
                 goto out_remove;
         } else
                 card->lan_online = 1;
 
         if (card->info.type != QETH_CARD_TYPE_OSN) {
-                qeth_set_large_send(card, card->options.large_send);
+                /* configure isolation level */
+                qeth_set_access_ctrl_online(card);
                 qeth_l2_process_vlans(card, 0);
         }
 
@@ -997,6 +975,7 @@ static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode)
         rc = qeth_init_qdio_queues(card);
         if (rc) {
                 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
+                rc = -ENODEV;
                 goto out_remove;
         }
         card->state = CARD_STATE_SOFTSETUP;
@@ -1018,6 +997,7 @@ static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode)
         /* let user_space know that device is online */
         kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
         return 0;
+
 out_remove:
         card->use_hard_stop = 1;
         qeth_l2_stop_card(card, 0);
@@ -1028,7 +1008,7 @@ out_remove:
                 card->state = CARD_STATE_RECOVER;
         else
                 card->state = CARD_STATE_DOWN;
-        return -ENODEV;
+        return rc;
 }
 
 static int qeth_l2_set_online(struct ccwgroup_device *gdev)
@@ -1092,11 +1072,9 @@ static int qeth_l2_recover(void *ptr)
                 dev_info(&card->gdev->dev,
                         "Device successfully recovered!\n");
         else {
-                if (card->dev) {
-                        rtnl_lock();
-                        dev_close(card->dev);
-                        rtnl_unlock();
-                }
+                rtnl_lock();
+                dev_close(card->dev);
+                rtnl_unlock();
                 dev_warn(&card->gdev->dev, "The qeth device driver "
                         "failed to recover an error on the device\n");
         }
@@ -1150,11 +1128,9 @@ static int qeth_l2_pm_resume(struct ccwgroup_device *gdev)
         if (card->state == CARD_STATE_RECOVER) {
                 rc = __qeth_l2_set_online(card->gdev, 1);
                 if (rc) {
-                        if (card->dev) {
-                                rtnl_lock();
-                                dev_close(card->dev);
-                                rtnl_unlock();
-                        }
+                        rtnl_lock();
+                        dev_close(card->dev);
+                        rtnl_unlock();
                 }
         } else
                 rc = __qeth_l2_set_online(card->gdev, 0);
diff --git a/drivers/s390/net/qeth_l3.h b/drivers/s390/net/qeth_l3.h
index 9f143c83bba3..8447d233d0b3 100644
--- a/drivers/s390/net/qeth_l3.h
+++ b/drivers/s390/net/qeth_l3.h
@@ -13,6 +13,8 @@
 
 #include "qeth_core.h"
 
+#define QETH_SNIFF_AVAIL        0x0008
+
 struct qeth_ipaddr {
         struct list_head entry;
         enum qeth_ip_types type;
@@ -60,5 +62,7 @@ void qeth_l3_del_vipa(struct qeth_card *, enum qeth_prot_versions, const u8 *);
 int qeth_l3_add_rxip(struct qeth_card *, enum qeth_prot_versions, const u8 *);
 void qeth_l3_del_rxip(struct qeth_card *card, enum qeth_prot_versions,
                         const u8 *);
+int qeth_l3_set_large_send(struct qeth_card *, enum qeth_large_send_types);
+int qeth_l3_set_rx_csum(struct qeth_card *, enum qeth_checksum_types);
 
 #endif /* __QETH_L3_H__ */
diff --git a/drivers/s390/net/qeth_l3_main.c b/drivers/s390/net/qeth_l3_main.c
index 073b6d354915..fc6ca1da8b98 100644
--- a/drivers/s390/net/qeth_l3_main.c
+++ b/drivers/s390/net/qeth_l3_main.c
@@ -22,6 +22,7 @@
 #include <linux/ipv6.h>
 #include <linux/inetdevice.h>
 #include <linux/igmp.h>
+#include <linux/slab.h>
 
 #include <net/ip.h>
 #include <net/arp.h>
@@ -41,6 +42,32 @@ static int qeth_l3_deregister_addr_entry(struct qeth_card *,
 static int __qeth_l3_set_online(struct ccwgroup_device *, int);
 static int __qeth_l3_set_offline(struct ccwgroup_device *, int);
 
+int qeth_l3_set_large_send(struct qeth_card *card,
+                enum qeth_large_send_types type)
+{
+        int rc = 0;
+
+        card->options.large_send = type;
+        if (card->dev == NULL)
+                return 0;
+
+        if (card->options.large_send == QETH_LARGE_SEND_TSO) {
+                if (qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
+                        card->dev->features |= NETIF_F_TSO | NETIF_F_SG |
+                                        NETIF_F_HW_CSUM;
+                } else {
+                        card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
+                                        NETIF_F_HW_CSUM);
+                        card->options.large_send = QETH_LARGE_SEND_NO;
+                        rc = -EOPNOTSUPP;
+                }
+        } else {
+                card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
+                                        NETIF_F_HW_CSUM);
+                card->options.large_send = QETH_LARGE_SEND_NO;
+        }
+        return rc;
+}
 
 static int qeth_l3_isxdigit(char *buf)
 {
@@ -216,6 +243,8 @@ static int __qeth_l3_insert_ip_todo(struct qeth_card *card,
         struct qeth_ipaddr *tmp, *t;
         int found = 0;
 
+        if (card->options.sniffer)
+                return 0;
         list_for_each_entry_safe(tmp, t, card->ip_tbd_list, entry) {
                 if ((addr->type == QETH_IP_TYPE_DEL_ALL_MC) &&
                     (tmp->type == QETH_IP_TYPE_DEL_ALL_MC))
@@ -431,6 +460,8 @@ static void qeth_l3_set_ip_addr_list(struct qeth_card *card)
         QETH_DBF_TEXT(TRACE, 2, "sdiplist");
         QETH_DBF_HEX(TRACE, 2, &card, sizeof(void *));
 
+        if (card->options.sniffer)
+                return;
         spin_lock_irqsave(&card->ip_lock, flags);
         tbd_list = card->ip_tbd_list;
         card->ip_tbd_list = kmalloc(sizeof(struct list_head), GFP_ATOMIC);
@@ -469,7 +500,7 @@ static void qeth_l3_set_ip_addr_list(struct qeth_card *card)
                         spin_unlock_irqrestore(&card->ip_lock, flags);
                         rc = qeth_l3_deregister_addr_entry(card, addr);
                         spin_lock_irqsave(&card->ip_lock, flags);
-                        if (!rc || (rc == IPA_RC_PRIMARY_ALREADY_DEFINED))
+                        if (!rc || (rc == IPA_RC_IP_ADDRESS_NOT_DEFINED))
                                 kfree(addr);
                         else
                                 list_add_tail(&addr->entry, &card->ip_list);
@@ -487,6 +518,8 @@ static void qeth_l3_clear_ip_list(struct qeth_card *card, int clean,
         unsigned long flags;
 
         QETH_DBF_TEXT(TRACE, 4, "clearip");
+        if (recover && card->options.sniffer)
+                return;
         spin_lock_irqsave(&card->ip_lock, flags);
         /* clear todo list */
         list_for_each_entry_safe(addr, tmp, card->ip_tbd_list, entry) {
@@ -1439,6 +1472,35 @@ static int qeth_l3_send_checksum_command(struct qeth_card *card)
         return 0;
 }
 
+int qeth_l3_set_rx_csum(struct qeth_card *card,
+        enum qeth_checksum_types csum_type)
+{
+        int rc = 0;
+
+        if (card->options.checksum_type == HW_CHECKSUMMING) {
+                if ((csum_type != HW_CHECKSUMMING) &&
+                        (card->state != CARD_STATE_DOWN)) {
+                        rc = qeth_l3_send_simple_setassparms(card,
+                                IPA_INBOUND_CHECKSUM, IPA_CMD_ASS_STOP, 0);
+                        if (rc)
+                                return -EIO;
+                }
+        } else {
+                if (csum_type == HW_CHECKSUMMING) {
+                        if (card->state != CARD_STATE_DOWN) {
+                                if (!qeth_is_supported(card,
+                                    IPA_INBOUND_CHECKSUM))
+                                        return -EPERM;
+                                rc = qeth_l3_send_checksum_command(card);
+                                if (rc)
+                                        return -EIO;
+                        }
+                }
+        }
+        card->options.checksum_type = csum_type;
+        return rc;
+}
+
 static int qeth_l3_start_ipa_checksum(struct qeth_card *card)
 {
         int rc = 0;
@@ -1506,6 +1568,8 @@ static int qeth_l3_start_ipa_tso(struct qeth_card *card)
 static int qeth_l3_start_ipassists(struct qeth_card *card)
 {
         QETH_DBF_TEXT(TRACE, 3, "strtipas");
+
+        qeth_set_access_ctrl_online(card);      /* go on*/
         qeth_l3_start_ipa_arp_processing(card); /* go on*/
         qeth_l3_start_ipa_ip_fragmentation(card);       /* go on*/
         qeth_l3_start_ipa_source_mac(card);     /* go on*/
@@ -1617,6 +1681,80 @@ static int qeth_l3_get_unique_id(struct qeth_card *card)
         return rc;
 }
 
+static int
+qeth_diags_trace_cb(struct qeth_card *card, struct qeth_reply *reply,
+                            unsigned long data)
+{
+        struct qeth_ipa_cmd        *cmd;
+        __u16 rc;
+
+        QETH_DBF_TEXT(SETUP, 2, "diastrcb");
+
+        cmd = (struct qeth_ipa_cmd *)data;
+        rc = cmd->hdr.return_code;
+        if (rc)
+                QETH_DBF_TEXT_(TRACE, 2, "dxter%x", rc);
+        switch (cmd->data.diagass.action) {
+        case QETH_DIAGS_CMD_TRACE_QUERY:
+                break;
+        case QETH_DIAGS_CMD_TRACE_DISABLE:
+                switch (rc) {
+                case 0:
+                case IPA_RC_INVALID_SUBCMD:
+                        card->info.promisc_mode = SET_PROMISC_MODE_OFF;
+                        dev_info(&card->gdev->dev, "The HiperSockets network "
+                                "traffic analyzer is deactivated\n");
+                        break;
+                default:
+                        break;
+                }
+                break;
+        case QETH_DIAGS_CMD_TRACE_ENABLE:
+                switch (rc) {
+                case 0:
+                        card->info.promisc_mode = SET_PROMISC_MODE_ON;
+                        dev_info(&card->gdev->dev, "The HiperSockets network "
+                                "traffic analyzer is activated\n");
+                        break;
+                case IPA_RC_HARDWARE_AUTH_ERROR:
+                        dev_warn(&card->gdev->dev, "The device is not "
+                                "authorized to run as a HiperSockets network "
+                                "traffic analyzer\n");
+                        break;
+                case IPA_RC_TRACE_ALREADY_ACTIVE:
+                        dev_warn(&card->gdev->dev, "A HiperSockets "
+                                "network traffic analyzer is already "
+                                "active in the HiperSockets LAN\n");
+                        break;
+                default:
+                        break;
+                }
+                break;
+        default:
+                QETH_DBF_MESSAGE(2, "Unknown sniffer action (0x%04x) on %s\n",
+                        cmd->data.diagass.action, QETH_CARD_IFNAME(card));
+        }
+
+        return 0;
+}
+
+static int
+qeth_diags_trace(struct qeth_card *card, enum qeth_diags_trace_cmds diags_cmd)
+{
+        struct qeth_cmd_buffer *iob;
+        struct qeth_ipa_cmd    *cmd;
+
+        QETH_DBF_TEXT(SETUP, 2, "diagtrac");
+
+        iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SET_DIAG_ASS, 0);
+        cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
+        cmd->data.diagass.subcmd_len = 16;
+        cmd->data.diagass.subcmd = QETH_DIAGS_CMD_TRACE;
+        cmd->data.diagass.type = QETH_DIAGS_TYPE_HIPERSOCKET;
+        cmd->data.diagass.action = diags_cmd;
+        return qeth_send_ipa_cmd(card, iob, qeth_diags_trace_cb, NULL);
+}
+
 static void qeth_l3_get_mac_for_ipm(__u32 ipm, char *mac,
                                 struct net_device *dev)
 {
@@ -1894,7 +2032,10 @@ static inline __u16 qeth_l3_rebuild_skb(struct qeth_card *card,
                 case QETH_CAST_ANYCAST:
                 case QETH_CAST_NOCAST:
                 default:
-                        skb->pkt_type = PACKET_HOST;
+                        if (card->options.sniffer)
+                                skb->pkt_type = PACKET_OTHERHOST;
+                        else
+                                skb->pkt_type = PACKET_HOST;
                         memcpy(tg_addr, card->dev->dev_addr,
                                 card->dev->addr_len);
                 }
@@ -1950,7 +2091,6 @@ static void qeth_l3_process_inbound_buffer(struct qeth_card *card,
         int offset;
         __u16 vlan_tag = 0;
         unsigned int len;
-
         /* get first element of current buffer */
         element = (struct qdio_buffer_element *)&buf->buffer->element[0];
         offset = 0;
@@ -1969,7 +2109,7 @@ static void qeth_l3_process_inbound_buffer(struct qeth_card *card,
                 case QETH_HEADER_TYPE_LAYER3:
                         vlan_tag = qeth_l3_rebuild_skb(card, skb, hdr);
                         len = skb->len;
-                        if (vlan_tag)
+                        if (vlan_tag && !card->options.sniffer)
                                 if (card->vlangrp)
                                         vlan_hwaccel_rx(skb, card->vlangrp,
                                                 vlan_tag);
@@ -1980,6 +2120,16 @@ static void qeth_l3_process_inbound_buffer(struct qeth_card *card,
                         else
                                 netif_rx(skb);
                         break;
+                case QETH_HEADER_TYPE_LAYER2: /* for HiperSockets sniffer */
+                        skb->pkt_type = PACKET_HOST;
+                        skb->protocol = eth_type_trans(skb, skb->dev);
+                        if (card->options.checksum_type == NO_CHECKSUMMING)
+                                skb->ip_summed = CHECKSUM_UNNECESSARY;
+                        else
+                                skb->ip_summed = CHECKSUM_NONE;
+                        len = skb->len;
+                        netif_receive_skb(skb);
+                        break;
                 default:
                         dev_kfree_skb_any(skb);
                         QETH_DBF_TEXT(TRACE, 3, "inbunkno");
@@ -2061,17 +2211,18 @@ static int qeth_l3_stop_card(struct qeth_card *card, int recovery_mode)
         QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
 
         qeth_set_allowed_threads(card, 0, 1);
+        if (card->options.sniffer &&
+            (card->info.promisc_mode == SET_PROMISC_MODE_ON))
+                qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
         if (card->read.state == CH_STATE_UP &&
             card->write.state == CH_STATE_UP &&
             (card->state == CARD_STATE_UP)) {
                 if (recovery_mode)
                         qeth_l3_stop(card->dev);
                 else {
-                        if (card->dev) {
-                                rtnl_lock();
-                                dev_close(card->dev);
-                                rtnl_unlock();
-                        }
+                        rtnl_lock();
+                        dev_close(card->dev);
+                        rtnl_unlock();
                 }
                 if (!card->use_hard_stop) {
                         rc = qeth_send_stoplan(card);
@@ -2105,6 +2256,36 @@ static int qeth_l3_stop_card(struct qeth_card *card, int recovery_mode)
         return rc;
 }
 
+/*
+ * test for and Switch promiscuous mode (on or off)
+ *  either for guestlan or HiperSocket Sniffer
+ */
+static void
+qeth_l3_handle_promisc_mode(struct qeth_card *card)
+{
+        struct net_device *dev = card->dev;
+
+        if (((dev->flags & IFF_PROMISC) &&
+             (card->info.promisc_mode == SET_PROMISC_MODE_ON)) ||
+            (!(dev->flags & IFF_PROMISC) &&
+             (card->info.promisc_mode == SET_PROMISC_MODE_OFF)))
+                return;
+
+        if (card->info.guestlan) {              /* Guestlan trace */
+                if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
+                        qeth_setadp_promisc_mode(card);
+        } else if (card->options.sniffer &&     /* HiperSockets trace */
+                   qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST)) {
+                if (dev->flags & IFF_PROMISC) {
+                        QETH_DBF_TEXT(TRACE, 3, "+promisc");
+                        qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_ENABLE);
+                } else {
+                        QETH_DBF_TEXT(TRACE, 3, "-promisc");
+                        qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
+                }
+        }
+}
+
 static void qeth_l3_set_multicast_list(struct net_device *dev)
 {
         struct qeth_card *card = dev->ml_priv;
@@ -2113,15 +2294,17 @@ static void qeth_l3_set_multicast_list(struct net_device *dev)
         if (qeth_threads_running(card, QETH_RECOVER_THREAD) &&
             (card->state != CARD_STATE_UP))
                 return;
-        qeth_l3_delete_mc_addresses(card);
-        qeth_l3_add_multicast_ipv4(card);
+        if (!card->options.sniffer) {
+                qeth_l3_delete_mc_addresses(card);
+                qeth_l3_add_multicast_ipv4(card);
 #ifdef CONFIG_QETH_IPV6
-        qeth_l3_add_multicast_ipv6(card);
+                qeth_l3_add_multicast_ipv6(card);
 #endif
-        qeth_l3_set_ip_addr_list(card);
-        if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
-                return;
-        qeth_setadp_promisc_mode(card);
+                qeth_l3_set_ip_addr_list(card);
+                if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
+                        return;
+        }
+        qeth_l3_handle_promisc_mode(card);
 }
 
 static const char *qeth_l3_arp_get_error_cause(int *rc)
@@ -2684,6 +2867,24 @@ static void qeth_tx_csum(struct sk_buff *skb)
         *(__sum16 *)(skb->data + offset) = csum_fold(csum);
 }
 
+static inline int qeth_l3_tso_elements(struct sk_buff *skb)
+{
+        unsigned long tcpd = (unsigned long)tcp_hdr(skb) +
+                tcp_hdr(skb)->doff * 4;
+        int tcpd_len = skb->len - (tcpd - (unsigned long)skb->data);
+        int elements = PFN_UP(tcpd + tcpd_len) - PFN_DOWN(tcpd);
+        elements += skb_shinfo(skb)->nr_frags;
+        return elements;
+}
+
+static inline int qeth_l3_tso_check(struct sk_buff *skb)
+{
+        int len = ((unsigned long)tcp_hdr(skb) + tcp_hdr(skb)->doff * 4) -
+                (unsigned long)skb->data;
+        return (((unsigned long)skb->data & PAGE_MASK) !=
+                (((unsigned long)skb->data + len) & PAGE_MASK));
+}
+
 static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         int rc;
@@ -2702,9 +2903,8 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
         int data_offset = -1;
         int nr_frags;
 
-        if ((card->info.type == QETH_CARD_TYPE_IQD) &&
-            (skb->protocol != htons(ETH_P_IPV6)) &&
-            (skb->protocol != htons(ETH_P_IP)))
+        if (((card->info.type == QETH_CARD_TYPE_IQD) && (!ipv)) ||
+             card->options.sniffer)
                         goto tx_drop;
 
         if ((card->state != CARD_STATE_UP) || !card->lan_online) {
@@ -2750,14 +2950,14 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 if (data_offset < 0)
                         skb_pull(new_skb, ETH_HLEN);
         } else {
-                if (new_skb->protocol == htons(ETH_P_IP)) {
+                if (ipv == 4) {
                         if (card->dev->type == ARPHRD_IEEE802_TR)
                                 skb_pull(new_skb, TR_HLEN);
                         else
                                 skb_pull(new_skb, ETH_HLEN);
                 }
 
-                if (new_skb->protocol == ETH_P_IPV6 && card->vlangrp &&
+                if (ipv == 6 && card->vlangrp &&
                                 vlan_tx_tag_present(new_skb)) {
                         skb_push(new_skb, VLAN_HLEN);
                         skb_copy_to_linear_data(new_skb, new_skb->data + 4, 4);
@@ -2777,16 +2977,21 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
         /* fix hardware limitation: as long as we do not have sbal
          * chaining we can not send long frag lists
          */
-        if ((large_send == QETH_LARGE_SEND_TSO) &&
-            ((skb_shinfo(new_skb)->nr_frags + 2) > 16)) {
-                if (skb_linearize(new_skb))
-                        goto tx_drop;
+        if (large_send == QETH_LARGE_SEND_TSO) {
+                if (qeth_l3_tso_elements(new_skb) + 1 > 16) {
+                        if (skb_linearize(new_skb))
+                                goto tx_drop;
+                        if (card->options.performance_stats)
+                                card->perf_stats.tx_lin++;
+                }
         }
 
         if ((large_send == QETH_LARGE_SEND_TSO) &&
             (cast_type == RTN_UNSPEC)) {
                 hdr = (struct qeth_hdr *)skb_push(new_skb,
                                                 sizeof(struct qeth_hdr_tso));
+                if (qeth_l3_tso_check(new_skb))
+                        QETH_DBF_MESSAGE(2, "tso skb misaligned\n");
                 memset(hdr, 0, sizeof(struct qeth_hdr_tso));
                 qeth_l3_fill_header(card, hdr, new_skb, ipv, cast_type);
                 qeth_tso_fill_header(card, hdr, new_skb);
@@ -2903,46 +3108,28 @@ static u32 qeth_l3_ethtool_get_rx_csum(struct net_device *dev)
 static int qeth_l3_ethtool_set_rx_csum(struct net_device *dev, u32 data)
 {
         struct qeth_card *card = dev->ml_priv;
-        enum qeth_card_states old_state;
         enum qeth_checksum_types csum_type;
 
-        if ((card->state != CARD_STATE_UP) &&
-            (card->state != CARD_STATE_DOWN))
-                return -EPERM;
-
         if (data)
                 csum_type = HW_CHECKSUMMING;
         else
                 csum_type = SW_CHECKSUMMING;
 
-        if (card->options.checksum_type != csum_type) {
-                old_state = card->state;
-                if (card->state == CARD_STATE_UP)
-                        __qeth_l3_set_offline(card->gdev, 1);
-                card->options.checksum_type = csum_type;
-                if (old_state == CARD_STATE_UP)
-                        __qeth_l3_set_online(card->gdev, 1);
-        }
-        return 0;
+        return qeth_l3_set_rx_csum(card, csum_type);
 }
 
 static int qeth_l3_ethtool_set_tso(struct net_device *dev, u32 data)
 {
         struct qeth_card *card = dev->ml_priv;
+        int rc = 0;
 
         if (data) {
-                if (card->options.large_send == QETH_LARGE_SEND_NO) {
-                        if (card->info.type == QETH_CARD_TYPE_IQD)
-                                return -EPERM;
-                        else
-                                card->options.large_send = QETH_LARGE_SEND_TSO;
-                        dev->features |= NETIF_F_TSO;
-                }
+                rc = qeth_l3_set_large_send(card, QETH_LARGE_SEND_TSO);
         } else {
                 dev->features &= ~NETIF_F_TSO;
                 card->options.large_send = QETH_LARGE_SEND_NO;
         }
-        return 0;
+        return rc;
 }
 
 static const struct ethtool_ops qeth_l3_ethtool_ops = {
@@ -2957,7 +3144,7 @@ static const struct ethtool_ops qeth_l3_ethtool_ops = {
         .set_tso     = qeth_l3_ethtool_set_tso,
         .get_strings = qeth_core_get_strings,
         .get_ethtool_stats = qeth_core_get_ethtool_stats,
-        .get_stats_count = qeth_core_get_stats_count,
+        .get_sset_count = qeth_core_get_sset_count,
         .get_drvinfo = qeth_core_get_drvinfo,
         .get_settings = qeth_core_ethtool_get_settings,
 };
@@ -3058,6 +3245,7 @@ static int qeth_l3_setup_netdev(struct qeth_card *card)
                                 NETIF_F_HW_VLAN_RX |
                                 NETIF_F_HW_VLAN_FILTER;
         card->dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
+        card->dev->gso_max_size = 15 * PAGE_SIZE;
 
         SET_NETDEV_DEV(card->dev, &card->gdev->dev);
         return register_netdev(card->dev);
@@ -3092,7 +3280,7 @@ static void qeth_l3_qdio_input_handler(struct ccw_device *ccwdev,
                 index = i % QDIO_MAX_BUFFERS_PER_Q;
                 buffer = &card->qdio.in_q->bufs[index];
                 if (!(qdio_err &&
-                      qeth_check_qdio_errors(buffer->buffer,
+                      qeth_check_qdio_errors(card, buffer->buffer,
                                              qdio_err, "qinerr")))
                         qeth_l3_process_inbound_buffer(card, buffer, index);
                 /* clear buffer and give back to hardware */
@@ -3151,35 +3339,20 @@ static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
         QETH_DBF_TEXT(SETUP, 2, "setonlin");
         QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
 
-        qeth_set_allowed_threads(card, QETH_RECOVER_THREAD, 1);
-
         recover_flag = card->state;
-        rc = ccw_device_set_online(CARD_RDEV(card));
-        if (rc) {
-                QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
-                return -EIO;
-        }
-        rc = ccw_device_set_online(CARD_WDEV(card));
-        if (rc) {
-                QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
-                return -EIO;
-        }
-        rc = ccw_device_set_online(CARD_DDEV(card));
-        if (rc) {
-                QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
-                return -EIO;
-        }
-
         rc = qeth_core_hardsetup_card(card);
         if (rc) {
                 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
+                rc = -ENODEV;
                 goto out_remove;
         }
 
         qeth_l3_query_ipassists(card, QETH_PROT_IPV4);
 
-        if (!card->dev && qeth_l3_setup_netdev(card))
+        if (!card->dev && qeth_l3_setup_netdev(card)) {
+                rc = -ENODEV;
                 goto out_remove;
+        }
 
         card->state = CARD_STATE_HARDSETUP;
         qeth_print_status_message(card);
@@ -3196,28 +3369,32 @@ static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
                         card->lan_online = 0;
                         return 0;
                 }
+                rc = -ENODEV;
                 goto out_remove;
         } else
                 card->lan_online = 1;
-        qeth_set_large_send(card, card->options.large_send);
 
         rc = qeth_l3_setadapter_parms(card);
         if (rc)
                 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
-        rc = qeth_l3_start_ipassists(card);
-        if (rc)
-                QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc);
-        rc = qeth_l3_setrouting_v4(card);
-        if (rc)
-                QETH_DBF_TEXT_(SETUP, 2, "4err%d", rc);
-        rc = qeth_l3_setrouting_v6(card);
-        if (rc)
-                QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc);
+        if (!card->options.sniffer) {
+                rc = qeth_l3_start_ipassists(card);
+                if (rc)
+                        QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc);
+                qeth_l3_set_large_send(card, card->options.large_send);
+                rc = qeth_l3_setrouting_v4(card);
+                if (rc)
+                        QETH_DBF_TEXT_(SETUP, 2, "4err%d", rc);
+                rc = qeth_l3_setrouting_v6(card);
+                if (rc)
+                        QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc);
+        }
         netif_tx_disable(card->dev);
 
         rc = qeth_init_qdio_queues(card);
         if (rc) {
                 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
+                rc = -ENODEV;
                 goto out_remove;
         }
         card->state = CARD_STATE_SOFTSETUP;
@@ -3248,7 +3425,7 @@ out_remove:
                 card->state = CARD_STATE_RECOVER;
         else
                 card->state = CARD_STATE_DOWN;
-        return -ENODEV;
+        return rc;
 }
 
 static int qeth_l3_set_online(struct ccwgroup_device *gdev)
@@ -3358,11 +3535,9 @@ static int qeth_l3_pm_resume(struct ccwgroup_device *gdev)
         if (card->state == CARD_STATE_RECOVER) {
                 rc = __qeth_l3_set_online(card->gdev, 1);
                 if (rc) {
-                        if (card->dev) {
-                                rtnl_lock();
-                                dev_close(card->dev);
-                                rtnl_unlock();
-                        }
+                        rtnl_lock();
+                        dev_close(card->dev);
+                        rtnl_unlock();
                 }
         } else
                 rc = __qeth_l3_set_online(card->gdev, 0);
diff --git a/drivers/s390/net/qeth_l3_sys.c b/drivers/s390/net/qeth_l3_sys.c
index c144b9924d52..25b3e7aae44f 100644
--- a/drivers/s390/net/qeth_l3_sys.c
+++ b/drivers/s390/net/qeth_l3_sys.c
@@ -8,6 +8,8 @@
  *               Frank Blaschka <frank.blaschka@de.ibm.com>
  */
 
+#include <linux/slab.h>
+
 #include "qeth_l3.h"
 
 #define QETH_DEVICE_ATTR(_id, _name, _mode, _show, _store) \
@@ -293,31 +295,134 @@ static ssize_t qeth_l3_dev_checksum_store(struct device *dev,
                 struct device_attribute *attr, const char *buf, size_t count)
 {
         struct qeth_card *card = dev_get_drvdata(dev);
+        enum qeth_checksum_types csum_type;
         char *tmp;
+        int rc;
 
         if (!card)
                 return -EINVAL;
 
-        if ((card->state != CARD_STATE_DOWN) &&
-            (card->state != CARD_STATE_RECOVER))
-                return -EPERM;
-
         tmp = strsep((char **) &buf, "\n");
         if (!strcmp(tmp, "sw_checksumming"))
-                card->options.checksum_type = SW_CHECKSUMMING;
+                csum_type = SW_CHECKSUMMING;
         else if (!strcmp(tmp, "hw_checksumming"))
-                card->options.checksum_type = HW_CHECKSUMMING;
+                csum_type = HW_CHECKSUMMING;
         else if (!strcmp(tmp, "no_checksumming"))
-                card->options.checksum_type = NO_CHECKSUMMING;
-        else {
+                csum_type = NO_CHECKSUMMING;
+        else
                 return -EINVAL;
-        }
+
+        rc = qeth_l3_set_rx_csum(card, csum_type);
+        if (rc)
+                return rc;
         return count;
 }
 
 static DEVICE_ATTR(checksumming, 0644, qeth_l3_dev_checksum_show,
                 qeth_l3_dev_checksum_store);
 
+static ssize_t qeth_l3_dev_sniffer_show(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct qeth_card *card = dev_get_drvdata(dev);
+
+        if (!card)
+                return -EINVAL;
+
+        return sprintf(buf, "%i\n", card->options.sniffer ? 1 : 0);
+}
+
+static ssize_t qeth_l3_dev_sniffer_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct qeth_card *card = dev_get_drvdata(dev);
+        int ret;
+        unsigned long i;
+
+        if (!card)
+                return -EINVAL;
+
+        if (card->info.type != QETH_CARD_TYPE_IQD)
+                return -EPERM;
+
+        if ((card->state != CARD_STATE_DOWN) &&
+            (card->state != CARD_STATE_RECOVER))
+                return -EPERM;
+
+        ret = strict_strtoul(buf, 16, &i);
+        if (ret)
+                return -EINVAL;
+        switch (i) {
+        case 0:
+                card->options.sniffer = i;
+                break;
+        case 1:
+                ret = qdio_get_ssqd_desc(CARD_DDEV(card), &card->ssqd);
+                if (card->ssqd.qdioac2 & QETH_SNIFF_AVAIL) {
+                        card->options.sniffer = i;
+                        if (card->qdio.init_pool.buf_count !=
+                                        QETH_IN_BUF_COUNT_MAX)
+                                qeth_realloc_buffer_pool(card,
+                                        QETH_IN_BUF_COUNT_MAX);
+                        break;
+                } else
+                        return -EPERM;
+        default:   /* fall through */
+                return -EINVAL;
+        }
+        return count;
+}
+
+static DEVICE_ATTR(sniffer, 0644, qeth_l3_dev_sniffer_show,
+                qeth_l3_dev_sniffer_store);
+
+static ssize_t qeth_l3_dev_large_send_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct qeth_card *card = dev_get_drvdata(dev);
+
+        if (!card)
+                return -EINVAL;
+
+        switch (card->options.large_send) {
+        case QETH_LARGE_SEND_NO:
+                return sprintf(buf, "%s\n", "no");
+        case QETH_LARGE_SEND_TSO:
+                return sprintf(buf, "%s\n", "TSO");
+        default:
+                return sprintf(buf, "%s\n", "N/A");
+        }
+}
+
+static ssize_t qeth_l3_dev_large_send_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct qeth_card *card = dev_get_drvdata(dev);
+        enum qeth_large_send_types type;
+        int rc = 0;
+        char *tmp;
+
+        if (!card)
+                return -EINVAL;
+        tmp = strsep((char **) &buf, "\n");
+        if (!strcmp(tmp, "no"))
+                type = QETH_LARGE_SEND_NO;
+        else if (!strcmp(tmp, "TSO"))
+                type = QETH_LARGE_SEND_TSO;
+        else
+                return -EINVAL;
+
+        if (card->options.large_send == type)
+                return count;
+        rc = qeth_l3_set_large_send(card, type);
+        if (rc)
+                return rc;
+        return count;
+}
+
+static DEVICE_ATTR(large_send, 0644, qeth_l3_dev_large_send_show,
+                   qeth_l3_dev_large_send_store);
+
 static struct attribute *qeth_l3_device_attrs[] = {
         &dev_attr_route4.attr,
         &dev_attr_route6.attr,
@@ -325,6 +430,8 @@ static struct attribute *qeth_l3_device_attrs[] = {
         &dev_attr_broadcast_mode.attr,
         &dev_attr_canonical_macaddr.attr,
         &dev_attr_checksumming.attr,
+        &dev_attr_sniffer.attr,
+        &dev_attr_large_send.attr,
         NULL,
 };
 
diff --git a/drivers/s390/net/smsgiucv.c b/drivers/s390/net/smsgiucv.c
index 3012355f8304..70491274da16 100644
--- a/drivers/s390/net/smsgiucv.c
+++ b/drivers/s390/net/smsgiucv.c
@@ -24,6 +24,7 @@
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/device.h>
+#include <linux/slab.h>
 #include <net/iucv/iucv.h>
 #include <asm/cpcmd.h>
 #include <asm/ebcdic.h>
@@ -31,9 +32,9 @@
 
 struct smsg_callback {
         struct list_head list;
-        char *prefix;
+        const char *prefix;
         int len;
-        void (*callback)(char *from, char *str);
+        void (*callback)(const char *from, char *str);
 };
 
 MODULE_AUTHOR
@@ -100,8 +101,8 @@ static void smsg_message_pending(struct iucv_path *path,
         kfree(buffer);
 }
 
-int smsg_register_callback(char *prefix,
-                           void (*callback)(char *from, char *str))
+int smsg_register_callback(const char *prefix,
+                           void (*callback)(const char *from, char *str))
 {
         struct smsg_callback *cb;
 
@@ -117,8 +118,9 @@ int smsg_register_callback(char *prefix,
         return 0;
 }
 
-void smsg_unregister_callback(char *prefix,
-                              void (*callback)(char *from, char *str))
+void smsg_unregister_callback(const char *prefix,
+                              void (*callback)(const char *from,
+                                               char *str))
 {
         struct smsg_callback *cb, *tmp;
 
@@ -168,7 +170,7 @@ static int smsg_pm_restore_thaw(struct device *dev)
         return 0;
 }
 
-static struct dev_pm_ops smsg_pm_ops = {
+static const struct dev_pm_ops smsg_pm_ops = {
         .freeze = smsg_pm_freeze,
         .thaw = smsg_pm_restore_thaw,
         .restore = smsg_pm_restore_thaw,
@@ -176,7 +178,7 @@ static struct dev_pm_ops smsg_pm_ops = {
 
 static struct device_driver smsg_driver = {
         .owner = THIS_MODULE,
-        .name = "SMSGIUCV",
+        .name = SMSGIUCV_DRV_NAME,
         .bus  = &iucv_bus,
         .pm = &smsg_pm_ops,
 };
diff --git a/drivers/s390/net/smsgiucv.h b/drivers/s390/net/smsgiucv.h
index 67f5d4f8378d..149a1151608d 100644
--- a/drivers/s390/net/smsgiucv.h
+++ b/drivers/s390/net/smsgiucv.h
@@ -5,6 +5,10 @@
  * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
  */
 
-int  smsg_register_callback(char *, void (*)(char *, char *));
-void smsg_unregister_callback(char *, void (*)(char *, char *));
+#define SMSGIUCV_DRV_NAME     "SMSGIUCV"
+
+int  smsg_register_callback(const char *,
+                            void (*)(const char *, char *));
+void smsg_unregister_callback(const char *,
+                              void (*)(const char *, char *));
 
diff --git a/drivers/s390/net/smsgiucv_app.c b/drivers/s390/net/smsgiucv_app.c
new file mode 100644
index 000000000000..137688790207
--- /dev/null
+++ b/drivers/s390/net/smsgiucv_app.c
@@ -0,0 +1,212 @@
+/*
+ * Deliver z/VM CP special messages (SMSG) as uevents.
+ *
+ * The driver registers for z/VM CP special messages with the
+ * "APP" prefix. Incoming messages are delivered to user space
+ * as uevents.
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
+ *
+ */
+#define KMSG_COMPONENT          "smsgiucv_app"
+#define pr_fmt(fmt)             KMSG_COMPONENT ": " fmt
+
+#include <linux/ctype.h>
+#include <linux/err.h>
+#include <linux/device.h>
+#include <linux/list.h>
+#include <linux/kobject.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/workqueue.h>
+#include <net/iucv/iucv.h>
+#include "smsgiucv.h"
+
+/* prefix used for SMSG registration */
+#define SMSG_PREFIX             "APP"
+
+/* SMSG related uevent environment variables */
+#define ENV_SENDER_STR          "SMSG_SENDER="
+#define ENV_SENDER_LEN          (strlen(ENV_SENDER_STR) + 8 + 1)
+#define ENV_PREFIX_STR          "SMSG_ID="
+#define ENV_PREFIX_LEN          (strlen(ENV_PREFIX_STR) + \
+                                 strlen(SMSG_PREFIX) + 1)
+#define ENV_TEXT_STR            "SMSG_TEXT="
+#define ENV_TEXT_LEN(msg)       (strlen(ENV_TEXT_STR) + strlen((msg)) + 1)
+
+/* z/VM user ID which is permitted to send SMSGs
+ * If the value is undefined or empty (""), special messages are
+ * accepted from any z/VM user ID. */
+static char *sender;
+module_param(sender, charp, 0400);
+MODULE_PARM_DESC(sender, "z/VM user ID from which CP SMSGs are accepted");
+
+/* SMSG device representation */
+static struct device *smsg_app_dev;
+
+/* list element for queuing received messages for delivery */
+struct smsg_app_event {
+        struct list_head list;
+        char *buf;
+        char *envp[4];
+};
+
+/* queue for outgoing uevents */
+static LIST_HEAD(smsg_event_queue);
+static DEFINE_SPINLOCK(smsg_event_queue_lock);
+
+static void smsg_app_event_free(struct smsg_app_event *ev)
+{
+        kfree(ev->buf);
+        kfree(ev);
+}
+
+static struct smsg_app_event *smsg_app_event_alloc(const char *from,
+                                                   const char *msg)
+{
+        struct smsg_app_event *ev;
+
+        ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
+        if (!ev)
+                return NULL;
+
+        ev->buf = kzalloc(ENV_SENDER_LEN + ENV_PREFIX_LEN +
+                          ENV_TEXT_LEN(msg), GFP_ATOMIC);
+        if (!ev->buf) {
+                kfree(ev);
+                return NULL;
+        }
+
+        /* setting up environment pointers into buf */
+        ev->envp[0] = ev->buf;
+        ev->envp[1] = ev->envp[0] + ENV_SENDER_LEN;
+        ev->envp[2] = ev->envp[1] + ENV_PREFIX_LEN;
+        ev->envp[3] = NULL;
+
+        /* setting up environment: sender, prefix name, and message text */
+        snprintf(ev->envp[0], ENV_SENDER_LEN, ENV_SENDER_STR "%s", from);
+        snprintf(ev->envp[1], ENV_PREFIX_LEN, ENV_PREFIX_STR "%s", SMSG_PREFIX);
+        snprintf(ev->envp[2], ENV_TEXT_LEN(msg), ENV_TEXT_STR "%s", msg);
+
+        return ev;
+}
+
+static void smsg_event_work_fn(struct work_struct *work)
+{
+        LIST_HEAD(event_queue);
+        struct smsg_app_event *p, *n;
+        struct device *dev;
+
+        dev = get_device(smsg_app_dev);
+        if (!dev)
+                return;
+
+        spin_lock_bh(&smsg_event_queue_lock);
+        list_splice_init(&smsg_event_queue, &event_queue);
+        spin_unlock_bh(&smsg_event_queue_lock);
+
+        list_for_each_entry_safe(p, n, &event_queue, list) {
+                list_del(&p->list);
+                kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, p->envp);
+                smsg_app_event_free(p);
+        }
+
+        put_device(dev);
+}
+static DECLARE_WORK(smsg_event_work, smsg_event_work_fn);
+
+static void smsg_app_callback(const char *from, char *msg)
+{
+        struct smsg_app_event *se;
+
+        /* check if the originating z/VM user ID matches
+         * the configured sender. */
+        if (sender && strlen(sender) > 0 && strcmp(from, sender) != 0)
+                return;
+
+        /* get start of message text (skip prefix and leading blanks) */
+        msg += strlen(SMSG_PREFIX);
+        while (*msg && isspace(*msg))
+                msg++;
+        if (*msg == '\0')
+                return;
+
+        /* allocate event list element and its environment */
+        se = smsg_app_event_alloc(from, msg);
+        if (!se)
+                return;
+
+        /* queue event and schedule work function */
+        spin_lock(&smsg_event_queue_lock);
+        list_add_tail(&se->list, &smsg_event_queue);
+        spin_unlock(&smsg_event_queue_lock);
+
+        schedule_work(&smsg_event_work);
+        return;
+}
+
+static int __init smsgiucv_app_init(void)
+{
+        struct device_driver *smsgiucv_drv;
+        int rc;
+
+        if (!MACHINE_IS_VM)
+                return -ENODEV;
+
+        smsg_app_dev = kzalloc(sizeof(*smsg_app_dev), GFP_KERNEL);
+        if (!smsg_app_dev)
+                return -ENOMEM;
+
+        smsgiucv_drv = driver_find(SMSGIUCV_DRV_NAME, &iucv_bus);
+        if (!smsgiucv_drv) {
+                kfree(smsg_app_dev);
+                return -ENODEV;
+        }
+
+        rc = dev_set_name(smsg_app_dev, KMSG_COMPONENT);
+        if (rc) {
+                kfree(smsg_app_dev);
+                goto fail_put_driver;
+        }
+        smsg_app_dev->bus = &iucv_bus;
+        smsg_app_dev->parent = iucv_root;
+        smsg_app_dev->release = (void (*)(struct device *)) kfree;
+        smsg_app_dev->driver = smsgiucv_drv;
+        rc = device_register(smsg_app_dev);
+        if (rc) {
+                put_device(smsg_app_dev);
+                goto fail_put_driver;
+        }
+
+        /* register with the smsgiucv device driver */
+        rc = smsg_register_callback(SMSG_PREFIX, smsg_app_callback);
+        if (rc) {
+                device_unregister(smsg_app_dev);
+                goto fail_put_driver;
+        }
+
+        rc = 0;
+fail_put_driver:
+        put_driver(smsgiucv_drv);
+        return rc;
+}
+module_init(smsgiucv_app_init);
+
+static void __exit smsgiucv_app_exit(void)
+{
+        /* unregister callback */
+        smsg_unregister_callback(SMSG_PREFIX, smsg_app_callback);
+
+        /* cancel pending work and flush any queued event work */
+        cancel_work_sync(&smsg_event_work);
+        smsg_event_work_fn(&smsg_event_work);
+
+        device_unregister(smsg_app_dev);
+}
+module_exit(smsgiucv_app_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("Deliver z/VM CP SMSG as uevents");
+MODULE_AUTHOR("Hendrik Brueckner <brueckner@linux.vnet.ibm.com>");
diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c
index 2889e5f2dfd3..1e6183a86ce5 100644
--- a/drivers/s390/scsi/zfcp_aux.c
+++ b/drivers/s390/scsi/zfcp_aux.c
@@ -3,7 +3,7 @@
  *
  * Module interface and handling of zfcp data structures.
  *
- * Copyright IBM Corporation 2002, 2009
+ * Copyright IBM Corporation 2002, 2010
  */
 
 /*
@@ -30,7 +30,10 @@
 
 #include <linux/miscdevice.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 #include "zfcp_ext.h"
+#include "zfcp_fc.h"
+#include "zfcp_reqlist.h"
 
 #define ZFCP_BUS_ID_SIZE        20
 
@@ -48,80 +51,42 @@ static struct kmem_cache *zfcp_cache_hw_align(const char *name,
         return kmem_cache_create(name, size, roundup_pow_of_two(size), 0, NULL);
 }
 
-static int zfcp_reqlist_alloc(struct zfcp_adapter *adapter)
-{
-        int idx;
-
-        adapter->req_list = kcalloc(REQUEST_LIST_SIZE, sizeof(struct list_head),
-                                    GFP_KERNEL);
-        if (!adapter->req_list)
-                return -ENOMEM;
-
-        for (idx = 0; idx < REQUEST_LIST_SIZE; idx++)
-                INIT_LIST_HEAD(&adapter->req_list[idx]);
-        return 0;
-}
-
-/**
- * zfcp_reqlist_isempty - is the request list empty
- * @adapter: pointer to struct zfcp_adapter
- *
- * Returns: true if list is empty, false otherwise
- */
-int zfcp_reqlist_isempty(struct zfcp_adapter *adapter)
-{
-        unsigned int idx;
-
-        for (idx = 0; idx < REQUEST_LIST_SIZE; idx++)
-                if (!list_empty(&adapter->req_list[idx]))
-                        return 0;
-        return 1;
-}
-
 static void __init zfcp_init_device_configure(char *busid, u64 wwpn, u64 lun)
 {
-        struct ccw_device *ccwdev;
+        struct ccw_device *cdev;
         struct zfcp_adapter *adapter;
         struct zfcp_port *port;
         struct zfcp_unit *unit;
 
-        ccwdev = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
-        if (!ccwdev)
+        cdev = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
+        if (!cdev)
                 return;
 
-        if (ccw_device_set_online(ccwdev))
-                goto out_ccwdev;
+        if (ccw_device_set_online(cdev))
+                goto out_ccw_device;
 
-        mutex_lock(&zfcp_data.config_mutex);
-        adapter = dev_get_drvdata(&ccwdev->dev);
+        adapter = zfcp_ccw_adapter_by_cdev(cdev);
         if (!adapter)
-                goto out_unlock;
-        zfcp_adapter_get(adapter);
+                goto out_ccw_device;
 
         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);
 
         zfcp_erp_unit_reopen(unit, 0, "auidc_1", NULL);
         zfcp_erp_wait(adapter);
         flush_work(&unit->scsi_work);
 
-        mutex_lock(&zfcp_data.config_mutex);
-        zfcp_unit_put(unit);
 out_unit:
-        zfcp_port_put(port);
+        put_device(&port->dev);
 out_port:
-        zfcp_adapter_put(adapter);
-out_unlock:
-        mutex_unlock(&zfcp_data.config_mutex);
-out_ccwdev:
-        put_device(&ccwdev->dev);
+        zfcp_ccw_adapter_put(adapter);
+out_ccw_device:
+        put_device(&cdev->dev);
         return;
 }
 
@@ -167,7 +132,7 @@ static int __init zfcp_module_init(void)
         int retval = -ENOMEM;
 
         zfcp_data.gpn_ft_cache = zfcp_cache_hw_align("zfcp_gpn",
-                                        sizeof(struct ct_iu_gpn_ft_req));
+                                        sizeof(struct zfcp_fc_gpn_ft_req));
         if (!zfcp_data.gpn_ft_cache)
                 goto out;
 
@@ -182,12 +147,14 @@ static int __init zfcp_module_init(void)
                 goto out_sr_cache;
 
         zfcp_data.gid_pn_cache = zfcp_cache_hw_align("zfcp_gid",
-                                        sizeof(struct zfcp_gid_pn_data));
+                                        sizeof(struct zfcp_fc_gid_pn));
         if (!zfcp_data.gid_pn_cache)
                 goto out_gid_cache;
 
-        mutex_init(&zfcp_data.config_mutex);
-        rwlock_init(&zfcp_data.config_lock);
+        zfcp_data.adisc_cache = zfcp_cache_hw_align("zfcp_adisc",
+                                        sizeof(struct zfcp_fc_els_adisc));
+        if (!zfcp_data.adisc_cache)
+                goto out_adisc_cache;
 
         zfcp_data.scsi_transport_template =
                 fc_attach_transport(&zfcp_transport_functions);
@@ -200,7 +167,7 @@ static int __init zfcp_module_init(void)
                 goto out_misc;
         }
 
-        retval = zfcp_ccw_register();
+        retval = ccw_driver_register(&zfcp_ccw_driver);
         if (retval) {
                 pr_err("The zfcp device driver could not register with "
                        "the common I/O layer\n");
@@ -216,6 +183,8 @@ out_ccw_register:
 out_misc:
         fc_release_transport(zfcp_data.scsi_transport_template);
 out_transport:
+        kmem_cache_destroy(zfcp_data.adisc_cache);
+out_adisc_cache:
         kmem_cache_destroy(zfcp_data.gid_pn_cache);
 out_gid_cache:
         kmem_cache_destroy(zfcp_data.sr_buffer_cache);
@@ -229,6 +198,20 @@ out:
 
 module_init(zfcp_module_init);
 
+static void __exit zfcp_module_exit(void)
+{
+        ccw_driver_unregister(&zfcp_ccw_driver);
+        misc_deregister(&zfcp_cfdc_misc);
+        fc_release_transport(zfcp_data.scsi_transport_template);
+        kmem_cache_destroy(zfcp_data.adisc_cache);
+        kmem_cache_destroy(zfcp_data.gid_pn_cache);
+        kmem_cache_destroy(zfcp_data.sr_buffer_cache);
+        kmem_cache_destroy(zfcp_data.qtcb_cache);
+        kmem_cache_destroy(zfcp_data.gpn_ft_cache);
+}
+
+module_exit(zfcp_module_exit);
+
 /**
  * zfcp_get_unit_by_lun - find unit in unit list of port by FCP LUN
  * @port: pointer to port to search for unit
@@ -238,12 +221,18 @@ module_init(zfcp_module_init);
  */
 struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *port, u64 fcp_lun)
 {
+        unsigned long flags;
         struct zfcp_unit *unit;
 
-        list_for_each_entry(unit, &port->unit_list_head, list)
-                if ((unit->fcp_lun == fcp_lun) &&
-                    !(atomic_read(&unit->status) & ZFCP_STATUS_COMMON_REMOVE))
-                    return unit;
+        read_lock_irqsave(&port->unit_list_lock, flags);
+        list_for_each_entry(unit, &port->unit_list, list)
+                if (unit->fcp_lun == fcp_lun) {
+                        if (!get_device(&unit->dev))
+                                unit = NULL;
+                        read_unlock_irqrestore(&port->unit_list_lock, flags);
+                        return unit;
+                }
+        read_unlock_irqrestore(&port->unit_list_lock, flags);
         return NULL;
 }
 
@@ -257,18 +246,34 @@ struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *port, u64 fcp_lun)
 struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter,
                                         u64 wwpn)
 {
+        unsigned long flags;
         struct zfcp_port *port;
 
-        list_for_each_entry(port, &adapter->port_list_head, list)
-                if ((port->wwpn == wwpn) &&
-                    !(atomic_read(&port->status) & ZFCP_STATUS_COMMON_REMOVE))
+        read_lock_irqsave(&adapter->port_list_lock, flags);
+        list_for_each_entry(port, &adapter->port_list, list)
+                if (port->wwpn == wwpn) {
+                        if (!get_device(&port->dev))
+                                port = NULL;
+                        read_unlock_irqrestore(&adapter->port_list_lock, flags);
                         return port;
+                }
+        read_unlock_irqrestore(&adapter->port_list_lock, flags);
         return NULL;
 }
 
-static void zfcp_sysfs_unit_release(struct device *dev)
+/**
+ * zfcp_unit_release - dequeue unit
+ * @dev: pointer to device
+ *
+ * waits until all work is done on unit and removes it then from the unit->list
+ * of the associated port.
+ */
+static void zfcp_unit_release(struct device *dev)
 {
-        kfree(container_of(dev, struct zfcp_unit, sysfs_device));
+        struct zfcp_unit *unit = container_of(dev, struct zfcp_unit, dev);
+
+        put_device(&unit->port->dev);
+        kfree(unit);
 }
 
 /**
@@ -276,43 +281,40 @@ static void zfcp_sysfs_unit_release(struct device *dev)
  * @port: pointer to port where unit is added
  * @fcp_lun: FCP LUN of unit to be enqueued
  * Returns: pointer to enqueued unit on success, ERR_PTR on error
- * Locks: config_mutex must be held to serialize changes to the unit list
  *
  * Sets up some unit internal structures and creates sysfs entry.
  */
 struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun)
 {
         struct zfcp_unit *unit;
+        int retval = -ENOMEM;
+
+        get_device(&port->dev);
 
-        read_lock_irq(&zfcp_data.config_lock);
-        if (zfcp_get_unit_by_lun(port, fcp_lun)) {
-                read_unlock_irq(&zfcp_data.config_lock);
-                return ERR_PTR(-EINVAL);
+        unit = zfcp_get_unit_by_lun(port, fcp_lun);
+        if (unit) {
+                put_device(&unit->dev);
+                retval = -EEXIST;
+                goto err_out;
         }
-        read_unlock_irq(&zfcp_data.config_lock);
 
         unit = kzalloc(sizeof(struct zfcp_unit), GFP_KERNEL);
         if (!unit)
-                return ERR_PTR(-ENOMEM);
-
-        atomic_set(&unit->refcount, 0);
-        init_waitqueue_head(&unit->remove_wq);
-        INIT_WORK(&unit->scsi_work, zfcp_scsi_scan);
+                goto err_out;
 
         unit->port = port;
         unit->fcp_lun = fcp_lun;
+        unit->dev.parent = &port->dev;
+        unit->dev.release = zfcp_unit_release;
 
-        if (dev_set_name(&unit->sysfs_device, "0x%016llx",
+        if (dev_set_name(&unit->dev, "0x%016llx",
                          (unsigned long long) fcp_lun)) {
                 kfree(unit);
-                return ERR_PTR(-ENOMEM);
+                goto err_out;
         }
-        unit->sysfs_device.parent = &port->sysfs_device;
-        unit->sysfs_device.release = zfcp_sysfs_unit_release;
-        dev_set_drvdata(&unit->sysfs_device, unit);
+        retval = -EINVAL;
 
-        /* mark unit unusable as long as sysfs registration is not complete */
-        atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status);
+        INIT_WORK(&unit->scsi_work, zfcp_scsi_scan);
 
         spin_lock_init(&unit->latencies.lock);
         unit->latencies.write.channel.min = 0xFFFFFFFF;
@@ -322,52 +324,31 @@ struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun)
         unit->latencies.cmd.channel.min = 0xFFFFFFFF;
         unit->latencies.cmd.fabric.min = 0xFFFFFFFF;
 
-        if (device_register(&unit->sysfs_device)) {
-                put_device(&unit->sysfs_device);
-                return ERR_PTR(-EINVAL);
+        if (device_register(&unit->dev)) {
+                put_device(&unit->dev);
+                goto err_out;
         }
 
-        if (sysfs_create_group(&unit->sysfs_device.kobj,
-                               &zfcp_sysfs_unit_attrs)) {
-                device_unregister(&unit->sysfs_device);
-                return ERR_PTR(-EINVAL);
-        }
+        if (sysfs_create_group(&unit->dev.kobj, &zfcp_sysfs_unit_attrs))
+                goto err_out_put;
 
-        zfcp_unit_get(unit);
+        write_lock_irq(&port->unit_list_lock);
+        list_add_tail(&unit->list, &port->unit_list);
+        write_unlock_irq(&port->unit_list_lock);
 
-        write_lock_irq(&zfcp_data.config_lock);
-        list_add_tail(&unit->list, &port->unit_list_head);
-        atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status);
         atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &unit->status);
 
-        write_unlock_irq(&zfcp_data.config_lock);
-
-        zfcp_port_get(port);
-
         return unit;
-}
 
-/**
- * zfcp_unit_dequeue - dequeue unit
- * @unit: pointer to zfcp_unit
- *
- * waits until all work is done on unit and removes it then from the unit->list
- * of the associated port.
- */
-void zfcp_unit_dequeue(struct zfcp_unit *unit)
-{
-        wait_event(unit->remove_wq, atomic_read(&unit->refcount) == 0);
-        write_lock_irq(&zfcp_data.config_lock);
-        list_del(&unit->list);
-        write_unlock_irq(&zfcp_data.config_lock);
-        zfcp_port_put(unit->port);
-        sysfs_remove_group(&unit->sysfs_device.kobj, &zfcp_sysfs_unit_attrs);
-        device_unregister(&unit->sysfs_device);
+err_out_put:
+        device_unregister(&unit->dev);
+err_out:
+        put_device(&port->dev);
+        return ERR_PTR(retval);
 }
 
 static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter)
 {
-        /* must only be called with zfcp_data.config_mutex taken */
         adapter->pool.erp_req =
                 mempool_create_kmalloc_pool(1, sizeof(struct zfcp_fsf_req));
         if (!adapter->pool.erp_req)
@@ -405,9 +386,9 @@ static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter)
         if (!adapter->pool.status_read_data)
                 return -ENOMEM;
 
-        adapter->pool.gid_pn_data =
+        adapter->pool.gid_pn =
                 mempool_create_slab_pool(1, zfcp_data.gid_pn_cache);
-        if (!adapter->pool.gid_pn_data)
+        if (!adapter->pool.gid_pn)
                 return -ENOMEM;
 
         return 0;
@@ -415,7 +396,6 @@ static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter)
 
 static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter)
 {
-        /* zfcp_data.config_mutex must be held */
         if (adapter->pool.erp_req)
                 mempool_destroy(adapter->pool.erp_req);
         if (adapter->pool.scsi_req)
@@ -428,8 +408,8 @@ static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter)
                 mempool_destroy(adapter->pool.status_read_req);
         if (adapter->pool.status_read_data)
                 mempool_destroy(adapter->pool.status_read_data);
-        if (adapter->pool.gid_pn_data)
-                mempool_destroy(adapter->pool.gid_pn_data);
+        if (adapter->pool.gid_pn)
+                mempool_destroy(adapter->pool.gid_pn);
 }
 
 /**
@@ -497,139 +477,142 @@ static void zfcp_destroy_adapter_work_queue(struct zfcp_adapter *adapter)
  * zfcp_adapter_enqueue - enqueue a new adapter to the list
  * @ccw_device: pointer to the struct cc_device
  *
- * Returns:     0             if a new adapter was successfully enqueued
- *              -ENOMEM       if alloc failed
+ * Returns:     struct zfcp_adapter*
  * Enqueues an adapter at the end of the adapter list in the driver data.
  * All adapter internal structures are set up.
  * Proc-fs entries are also created.
- * locks: config_mutex must be held to serialize changes to the adapter list
  */
-int zfcp_adapter_enqueue(struct ccw_device *ccw_device)
+struct zfcp_adapter *zfcp_adapter_enqueue(struct ccw_device *ccw_device)
 {
         struct zfcp_adapter *adapter;
 
-        /*
-         * Note: It is safe to release the list_lock, as any list changes
-         * are protected by the config_mutex, which must be held to get here
-         */
+        if (!get_device(&ccw_device->dev))
+                return ERR_PTR(-ENODEV);
 
         adapter = kzalloc(sizeof(struct zfcp_adapter), GFP_KERNEL);
-        if (!adapter)
-                return -ENOMEM;
+        if (!adapter) {
+                put_device(&ccw_device->dev);
+                return ERR_PTR(-ENOMEM);
+        }
+
+        kref_init(&adapter->ref);
 
         ccw_device->handler = NULL;
         adapter->ccw_device = ccw_device;
-        atomic_set(&adapter->refcount, 0);
+
+        INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler);
+        INIT_WORK(&adapter->scan_work, zfcp_fc_scan_ports);
 
         if (zfcp_qdio_setup(adapter))
-                goto qdio_failed;
+                goto failed;
 
         if (zfcp_allocate_low_mem_buffers(adapter))
-                goto low_mem_buffers_failed;
+                goto failed;
 
-        if (zfcp_reqlist_alloc(adapter))
-                goto low_mem_buffers_failed;
+        adapter->req_list = zfcp_reqlist_alloc();
+        if (!adapter->req_list)
+                goto failed;
 
         if (zfcp_dbf_adapter_register(adapter))
-                goto debug_register_failed;
+                goto failed;
 
         if (zfcp_setup_adapter_work_queue(adapter))
-                goto work_queue_failed;
+                goto failed;
 
         if (zfcp_fc_gs_setup(adapter))
-                goto generic_services_failed;
+                goto failed;
+
+        rwlock_init(&adapter->port_list_lock);
+        INIT_LIST_HEAD(&adapter->port_list);
 
-        init_waitqueue_head(&adapter->remove_wq);
         init_waitqueue_head(&adapter->erp_ready_wq);
         init_waitqueue_head(&adapter->erp_done_wqh);
 
-        INIT_LIST_HEAD(&adapter->port_list_head);
         INIT_LIST_HEAD(&adapter->erp_ready_head);
         INIT_LIST_HEAD(&adapter->erp_running_head);
 
-        spin_lock_init(&adapter->req_list_lock);
-
         rwlock_init(&adapter->erp_lock);
         rwlock_init(&adapter->abort_lock);
 
         if (zfcp_erp_thread_setup(adapter))
-                goto erp_thread_failed;
-
-        INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler);
-        INIT_WORK(&adapter->scan_work, _zfcp_fc_scan_ports_later);
+                goto failed;
 
         adapter->service_level.seq_print = zfcp_print_sl;
 
-        /* mark adapter unusable as long as sysfs registration is not complete */
-        atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
-
         dev_set_drvdata(&ccw_device->dev, adapter);
 
         if (sysfs_create_group(&ccw_device->dev.kobj,
                                &zfcp_sysfs_adapter_attrs))
-                goto sysfs_failed;
-
-        atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
+                goto failed;
 
         if (!zfcp_adapter_scsi_register(adapter))
-                return 0;
+                return adapter;
 
-sysfs_failed:
-        zfcp_erp_thread_kill(adapter);
-erp_thread_failed:
-        zfcp_fc_gs_destroy(adapter);
-generic_services_failed:
+failed:
+        zfcp_adapter_unregister(adapter);
+        return ERR_PTR(-ENOMEM);
+}
+
+void zfcp_adapter_unregister(struct zfcp_adapter *adapter)
+{
+        struct ccw_device *cdev = adapter->ccw_device;
+
+        cancel_work_sync(&adapter->scan_work);
+        cancel_work_sync(&adapter->stat_work);
         zfcp_destroy_adapter_work_queue(adapter);
-work_queue_failed:
+
+        zfcp_fc_wka_ports_force_offline(adapter->gs);
+        zfcp_adapter_scsi_unregister(adapter);
+        sysfs_remove_group(&cdev->dev.kobj, &zfcp_sysfs_adapter_attrs);
+
+        zfcp_erp_thread_kill(adapter);
         zfcp_dbf_adapter_unregister(adapter->dbf);
-debug_register_failed:
-        dev_set_drvdata(&ccw_device->dev, NULL);
-        kfree(adapter->req_list);
-low_mem_buffers_failed:
-        zfcp_free_low_mem_buffers(adapter);
-qdio_failed:
         zfcp_qdio_destroy(adapter->qdio);
-        kfree(adapter);
-        return -ENOMEM;
+
+        zfcp_ccw_adapter_put(adapter); /* final put to release */
 }
 
 /**
- * zfcp_adapter_dequeue - remove the adapter from the resource list
- * @adapter: pointer to struct zfcp_adapter which should be removed
+ * zfcp_adapter_release - remove the adapter from the resource list
+ * @ref: pointer to struct kref
  * locks:       adapter list write lock is assumed to be held by caller
  */
-void zfcp_adapter_dequeue(struct zfcp_adapter *adapter)
+void zfcp_adapter_release(struct kref *ref)
 {
-        int retval = 0;
-        unsigned long flags;
+        struct zfcp_adapter *adapter = container_of(ref, struct zfcp_adapter,
+                                                    ref);
+        struct ccw_device *cdev = adapter->ccw_device;
 
-        cancel_work_sync(&adapter->stat_work);
-        zfcp_fc_wka_ports_force_offline(adapter->gs);
-        sysfs_remove_group(&adapter->ccw_device->dev.kobj,
-                           &zfcp_sysfs_adapter_attrs);
         dev_set_drvdata(&adapter->ccw_device->dev, NULL);
-        /* sanity check: no pending FSF requests */
-        spin_lock_irqsave(&adapter->req_list_lock, flags);
-        retval = zfcp_reqlist_isempty(adapter);
-        spin_unlock_irqrestore(&adapter->req_list_lock, flags);
-        if (!retval)
-                return;
-
         zfcp_fc_gs_destroy(adapter);
-        zfcp_erp_thread_kill(adapter);
-        zfcp_destroy_adapter_work_queue(adapter);
-        zfcp_dbf_adapter_unregister(adapter->dbf);
         zfcp_free_low_mem_buffers(adapter);
-        zfcp_qdio_destroy(adapter->qdio);
         kfree(adapter->req_list);
         kfree(adapter->fc_stats);
         kfree(adapter->stats_reset_data);
         kfree(adapter);
+        put_device(&cdev->dev);
 }
 
-static void zfcp_sysfs_port_release(struct device *dev)
+/**
+ * zfcp_device_unregister - remove port, unit from system
+ * @dev: reference to device which is to be removed
+ * @grp: related reference to attribute group
+ *
+ * Helper function to unregister port, unit from system
+ */
+void zfcp_device_unregister(struct device *dev,
+                            const struct attribute_group *grp)
 {
-        kfree(container_of(dev, struct zfcp_port, sysfs_device));
+        sysfs_remove_group(&dev->kobj, grp);
+        device_unregister(dev);
+}
+
+static void zfcp_port_release(struct device *dev)
+{
+        struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
+
+        zfcp_ccw_adapter_put(port->adapter);
+        kfree(port);
 }
 
 /**
@@ -639,7 +622,6 @@ static void zfcp_sysfs_port_release(struct device *dev)
  * @status: initial status for the port
  * @d_id: destination id of the remote port to be enqueued
  * Returns: pointer to enqueued port on success, ERR_PTR on error
- * Locks: config_mutex must be held to serialize changes to the port list
  *
  * All port internal structures are set up and the sysfs entry is generated.
  * d_id is used to enqueue ports with a well known address like the Directory
@@ -649,20 +631,24 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn,
                                      u32 status, u32 d_id)
 {
         struct zfcp_port *port;
+        int retval = -ENOMEM;
+
+        kref_get(&adapter->ref);
 
-        read_lock_irq(&zfcp_data.config_lock);
-        if (zfcp_get_port_by_wwpn(adapter, wwpn)) {
-                read_unlock_irq(&zfcp_data.config_lock);
-                return ERR_PTR(-EINVAL);
+        port = zfcp_get_port_by_wwpn(adapter, wwpn);
+        if (port) {
+                put_device(&port->dev);
+                retval = -EEXIST;
+                goto err_out;
         }
-        read_unlock_irq(&zfcp_data.config_lock);
 
         port = kzalloc(sizeof(struct zfcp_port), GFP_KERNEL);
         if (!port)
-                return ERR_PTR(-ENOMEM);
+                goto err_out;
+
+        rwlock_init(&port->unit_list_lock);
+        INIT_LIST_HEAD(&port->unit_list);
 
-        init_waitqueue_head(&port->remove_wq);
-        INIT_LIST_HEAD(&port->unit_list_head);
         INIT_WORK(&port->gid_pn_work, zfcp_fc_port_did_lookup);
         INIT_WORK(&port->test_link_work, zfcp_fc_link_test_work);
         INIT_WORK(&port->rport_work, zfcp_scsi_rport_work);
@@ -671,58 +657,37 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn,
         port->d_id = d_id;
         port->wwpn = wwpn;
         port->rport_task = RPORT_NONE;
+        port->dev.parent = &adapter->ccw_device->dev;
+        port->dev.release = zfcp_port_release;
 
-        /* mark port unusable as long as sysfs registration is not complete */
-        atomic_set_mask(status | ZFCP_STATUS_COMMON_REMOVE, &port->status);
-        atomic_set(&port->refcount, 0);
-
-        if (dev_set_name(&port->sysfs_device, "0x%016llx",
-                         (unsigned long long)wwpn)) {
+        if (dev_set_name(&port->dev, "0x%016llx", (unsigned long long)wwpn)) {
                 kfree(port);
-                return ERR_PTR(-ENOMEM);
-        }
-        port->sysfs_device.parent = &adapter->ccw_device->dev;
-        port->sysfs_device.release = zfcp_sysfs_port_release;
-        dev_set_drvdata(&port->sysfs_device, port);
-
-        if (device_register(&port->sysfs_device)) {
-                put_device(&port->sysfs_device);
-                return ERR_PTR(-EINVAL);
+                goto err_out;
         }
+        retval = -EINVAL;
 
-        if (sysfs_create_group(&port->sysfs_device.kobj,
-                               &zfcp_sysfs_port_attrs)) {
-                device_unregister(&port->sysfs_device);
-                return ERR_PTR(-EINVAL);
+        if (device_register(&port->dev)) {
+                put_device(&port->dev);
+                goto err_out;
         }
 
-        zfcp_port_get(port);
+        if (sysfs_create_group(&port->dev.kobj,
+                               &zfcp_sysfs_port_attrs))
+                goto err_out_put;
 
-        write_lock_irq(&zfcp_data.config_lock);
-        list_add_tail(&port->list, &adapter->port_list_head);
-        atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
-        atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &port->status);
+        write_lock_irq(&adapter->port_list_lock);
+        list_add_tail(&port->list, &adapter->port_list);
+        write_unlock_irq(&adapter->port_list_lock);
 
-        write_unlock_irq(&zfcp_data.config_lock);
+        atomic_set_mask(status | ZFCP_STATUS_COMMON_RUNNING, &port->status);
 
-        zfcp_adapter_get(adapter);
         return port;
-}
 
-/**
- * zfcp_port_dequeue - dequeues a port from the port list of the adapter
- * @port: pointer to struct zfcp_port which should be removed
- */
-void zfcp_port_dequeue(struct zfcp_port *port)
-{
-        write_lock_irq(&zfcp_data.config_lock);
-        list_del(&port->list);
-        write_unlock_irq(&zfcp_data.config_lock);
-        wait_event(port->remove_wq, atomic_read(&port->refcount) == 0);
-        cancel_work_sync(&port->rport_work); /* usually not necessary */
-        zfcp_adapter_put(port->adapter);
-        sysfs_remove_group(&port->sysfs_device.kobj, &zfcp_sysfs_port_attrs);
-        device_unregister(&port->sysfs_device);
+err_out_put:
+        device_unregister(&port->dev);
+err_out:
+        zfcp_ccw_adapter_put(adapter);
+        return ERR_PTR(retval);
 }
 
 /**
diff --git a/drivers/s390/scsi/zfcp_ccw.c b/drivers/s390/scsi/zfcp_ccw.c
index e08339428ecf..ce1cc7a11fb4 100644
--- a/drivers/s390/scsi/zfcp_ccw.c
+++ b/drivers/s390/scsi/zfcp_ccw.c
@@ -3,38 +3,45 @@
  *
  * Registration and callback for the s390 common I/O layer.
  *
- * Copyright IBM Corporation 2002, 2009
+ * Copyright IBM Corporation 2002, 2010
  */
 
 #define KMSG_COMPONENT "zfcp"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include "zfcp_ext.h"
+#include "zfcp_reqlist.h"
 
 #define ZFCP_MODEL_PRIV 0x4
 
-static int zfcp_ccw_suspend(struct ccw_device *cdev)
+static DEFINE_SPINLOCK(zfcp_ccw_adapter_ref_lock);
 
+struct zfcp_adapter *zfcp_ccw_adapter_by_cdev(struct ccw_device *cdev)
 {
-        struct zfcp_adapter *adapter = dev_get_drvdata(&cdev->dev);
-
-        if (!adapter)
-                return 0;
-
-        mutex_lock(&zfcp_data.config_mutex);
+        struct zfcp_adapter *adapter;
+        unsigned long flags;
 
-        zfcp_erp_adapter_shutdown(adapter, 0, "ccsusp1", NULL);
-        zfcp_erp_wait(adapter);
+        spin_lock_irqsave(&zfcp_ccw_adapter_ref_lock, flags);
+        adapter = dev_get_drvdata(&cdev->dev);
+        if (adapter)
+                kref_get(&adapter->ref);
+        spin_unlock_irqrestore(&zfcp_ccw_adapter_ref_lock, flags);
+        return adapter;
+}
 
-        mutex_unlock(&zfcp_data.config_mutex);
+void zfcp_ccw_adapter_put(struct zfcp_adapter *adapter)
+{
+        unsigned long flags;
 
-        return 0;
+        spin_lock_irqsave(&zfcp_ccw_adapter_ref_lock, flags);
+        kref_put(&adapter->ref, zfcp_adapter_release);
+        spin_unlock_irqrestore(&zfcp_ccw_adapter_ref_lock, flags);
 }
 
 static int zfcp_ccw_activate(struct ccw_device *cdev)
 
 {
-        struct zfcp_adapter *adapter = dev_get_drvdata(&cdev->dev);
+        struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
 
         if (!adapter)
                 return 0;
@@ -46,6 +53,8 @@ static int zfcp_ccw_activate(struct ccw_device *cdev)
         zfcp_erp_wait(adapter);
         flush_work(&adapter->scan_work);
 
+        zfcp_ccw_adapter_put(adapter);
+
         return 0;
 }
 
@@ -67,28 +76,28 @@ int zfcp_ccw_priv_sch(struct zfcp_adapter *adapter)
 
 /**
  * zfcp_ccw_probe - probe function of zfcp driver
- * @ccw_device: pointer to belonging ccw device
+ * @cdev: pointer to belonging ccw device
  *
  * This function gets called by the common i/o layer for each FCP
  * device found on the current system. This is only a stub to make cio
  * work: To only allocate adapter resources for devices actually used,
  * the allocation is deferred to the first call to ccw_set_online.
  */
-static int zfcp_ccw_probe(struct ccw_device *ccw_device)
+static int zfcp_ccw_probe(struct ccw_device *cdev)
 {
         return 0;
 }
 
 /**
  * zfcp_ccw_remove - remove function of zfcp driver
- * @ccw_device: pointer to belonging ccw device
+ * @cdev: pointer to belonging ccw device
  *
  * This function gets called by the common i/o layer and removes an adapter
  * from the system. Task of this function is to get rid of all units and
  * ports that belong to this adapter. And in addition all resources of this
  * adapter will be freed too.
  */
-static void zfcp_ccw_remove(struct ccw_device *ccw_device)
+static void zfcp_ccw_remove(struct ccw_device *cdev)
 {
         struct zfcp_adapter *adapter;
         struct zfcp_port *port, *p;
@@ -96,49 +105,35 @@ static void zfcp_ccw_remove(struct ccw_device *ccw_device)
         LIST_HEAD(unit_remove_lh);
         LIST_HEAD(port_remove_lh);
 
-        ccw_device_set_offline(ccw_device);
+        ccw_device_set_offline(cdev);
 
-        mutex_lock(&zfcp_data.config_mutex);
-        adapter = dev_get_drvdata(&ccw_device->dev);
+        adapter = zfcp_ccw_adapter_by_cdev(cdev);
         if (!adapter)
-                goto out;
-        mutex_unlock(&zfcp_data.config_mutex);
+                return;
 
-        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) {
-                list_for_each_entry_safe(unit, u, &port->unit_list_head, list) {
+        write_lock_irq(&adapter->port_list_lock);
+        list_for_each_entry_safe(port, p, &adapter->port_list, list) {
+                write_lock(&port->unit_list_lock);
+                list_for_each_entry_safe(unit, u, &port->unit_list, list)
                         list_move(&unit->list, &unit_remove_lh);
-                        atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE,
-                                        &unit->status);
-                }
+                write_unlock(&port->unit_list_lock);
                 list_move(&port->list, &port_remove_lh);
-                atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
         }
-        atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
-        write_unlock_irq(&zfcp_data.config_lock);
+        write_unlock_irq(&adapter->port_list_lock);
+        zfcp_ccw_adapter_put(adapter); /* put from zfcp_ccw_adapter_by_cdev */
 
-        list_for_each_entry_safe(port, p, &port_remove_lh, list) {
-                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);
-        zfcp_adapter_dequeue(adapter);
+        list_for_each_entry_safe(unit, u, &unit_remove_lh, list)
+                zfcp_device_unregister(&unit->dev, &zfcp_sysfs_unit_attrs);
 
-out:
-        mutex_unlock(&zfcp_data.config_mutex);
+        list_for_each_entry_safe(port, p, &port_remove_lh, list)
+                zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs);
+
+        zfcp_adapter_unregister(adapter);
 }
 
 /**
  * zfcp_ccw_set_online - set_online function of zfcp driver
- * @ccw_device: pointer to belonging ccw device
+ * @cdev: pointer to belonging ccw device
  *
  * This function gets called by the common i/o layer and sets an
  * adapter into state online.  The first call will allocate all
@@ -149,27 +144,24 @@ out:
  * the SCSI stack, that the QDIO queues will be set up and that the
  * adapter will be opened.
  */
-static int zfcp_ccw_set_online(struct ccw_device *ccw_device)
+static int zfcp_ccw_set_online(struct ccw_device *cdev)
 {
-        struct zfcp_adapter *adapter;
-        int ret = 0;
-
-        mutex_lock(&zfcp_data.config_mutex);
-        adapter = dev_get_drvdata(&ccw_device->dev);
+        struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
 
         if (!adapter) {
-                ret = zfcp_adapter_enqueue(ccw_device);
-                if (ret) {
-                        dev_err(&ccw_device->dev,
+                adapter = zfcp_adapter_enqueue(cdev);
+
+                if (IS_ERR(adapter)) {
+                        dev_err(&cdev->dev,
                                 "Setting up data structures for the "
                                 "FCP adapter failed\n");
-                        goto out;
+                        return PTR_ERR(adapter);
                 }
-                adapter = dev_get_drvdata(&ccw_device->dev);
+                kref_get(&adapter->ref);
         }
 
         /* initialize request counter */
-        BUG_ON(!zfcp_reqlist_isempty(adapter));
+        BUG_ON(!zfcp_reqlist_isempty(adapter->req_list));
         adapter->req_no = 0;
 
         zfcp_erp_modify_adapter_status(adapter, "ccsonl1", NULL,
@@ -177,58 +169,61 @@ static int zfcp_ccw_set_online(struct ccw_device *ccw_device)
         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
                                 "ccsonl2", NULL);
         zfcp_erp_wait(adapter);
-out:
-        mutex_unlock(&zfcp_data.config_mutex);
-        if (!ret)
-                flush_work(&adapter->scan_work);
-        return ret;
+
+        flush_work(&adapter->scan_work);
+
+        zfcp_ccw_adapter_put(adapter);
+        return 0;
 }
 
 /**
  * zfcp_ccw_set_offline - set_offline function of zfcp driver
- * @ccw_device: pointer to belonging ccw device
+ * @cdev: pointer to belonging ccw device
  *
  * This function gets called by the common i/o layer and sets an adapter
  * into state offline.
  */
-static int zfcp_ccw_set_offline(struct ccw_device *ccw_device)
+static int zfcp_ccw_set_offline(struct ccw_device *cdev)
 {
-        struct zfcp_adapter *adapter;
+        struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
+
+        if (!adapter)
+                return 0;
 
-        mutex_lock(&zfcp_data.config_mutex);
-        adapter = dev_get_drvdata(&ccw_device->dev);
         zfcp_erp_adapter_shutdown(adapter, 0, "ccsoff1", NULL);
         zfcp_erp_wait(adapter);
-        mutex_unlock(&zfcp_data.config_mutex);
+
+        zfcp_ccw_adapter_put(adapter);
         return 0;
 }
 
 /**
  * zfcp_ccw_notify - ccw notify function
- * @ccw_device: pointer to belonging ccw device
+ * @cdev: pointer to belonging ccw device
  * @event: indicates if adapter was detached or attached
  *
  * This function gets called by the common i/o layer if an adapter has gone
  * or reappeared.
  */
-static int zfcp_ccw_notify(struct ccw_device *ccw_device, int event)
+static int zfcp_ccw_notify(struct ccw_device *cdev, int event)
 {
-        struct zfcp_adapter *adapter = dev_get_drvdata(&ccw_device->dev);
+        struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
+
+        if (!adapter)
+                return 1;
 
         switch (event) {
         case CIO_GONE:
-                dev_warn(&adapter->ccw_device->dev,
-                         "The FCP device has been detached\n");
+                dev_warn(&cdev->dev, "The FCP device has been detached\n");
                 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1", NULL);
                 break;
         case CIO_NO_PATH:
-                dev_warn(&adapter->ccw_device->dev,
+                dev_warn(&cdev->dev,
                          "The CHPID for the FCP device is offline\n");
                 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2", NULL);
                 break;
         case CIO_OPER:
-                dev_info(&adapter->ccw_device->dev,
-                         "The FCP device is operational again\n");
+                dev_info(&cdev->dev, "The FCP device is operational again\n");
                 zfcp_erp_modify_adapter_status(adapter, "ccnoti3", NULL,
                                                ZFCP_STATUS_COMMON_RUNNING,
                                                ZFCP_SET);
@@ -236,11 +231,13 @@ static int zfcp_ccw_notify(struct ccw_device *ccw_device, int event)
                                         "ccnoti4", NULL);
                 break;
         case CIO_BOXED:
-                dev_warn(&adapter->ccw_device->dev, "The FCP device "
-                         "did not respond within the specified time\n");
+                dev_warn(&cdev->dev, "The FCP device did not respond within "
+                                     "the specified time\n");
                 zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5", NULL);
                 break;
         }
+
+        zfcp_ccw_adapter_put(adapter);
         return 1;
 }
 
@@ -250,18 +247,16 @@ static int zfcp_ccw_notify(struct ccw_device *ccw_device, int event)
  */
 static void zfcp_ccw_shutdown(struct ccw_device *cdev)
 {
-        struct zfcp_adapter *adapter;
+        struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
 
-        mutex_lock(&zfcp_data.config_mutex);
-        adapter = dev_get_drvdata(&cdev->dev);
         if (!adapter)
-                goto out;
+                return;
 
         zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1", NULL);
         zfcp_erp_wait(adapter);
         zfcp_erp_thread_kill(adapter);
-out:
-        mutex_unlock(&zfcp_data.config_mutex);
+
+        zfcp_ccw_adapter_put(adapter);
 }
 
 struct ccw_driver zfcp_ccw_driver = {
@@ -274,18 +269,7 @@ struct ccw_driver zfcp_ccw_driver = {
         .set_offline = zfcp_ccw_set_offline,
         .notify      = zfcp_ccw_notify,
         .shutdown    = zfcp_ccw_shutdown,
-        .freeze      = zfcp_ccw_suspend,
+        .freeze      = zfcp_ccw_set_offline,
         .thaw        = zfcp_ccw_activate,
         .restore     = zfcp_ccw_activate,
 };
-
-/**
- * zfcp_ccw_register - ccw register function
- *
- * Registers the driver at the common i/o layer. This function will be called
- * at module load time/system start.
- */
-int __init zfcp_ccw_register(void)
-{
-        return ccw_driver_register(&zfcp_ccw_driver);
-}
diff --git a/drivers/s390/scsi/zfcp_cfdc.c b/drivers/s390/scsi/zfcp_cfdc.c
index ef681dfed0cc..25d9e0ae9c57 100644
--- a/drivers/s390/scsi/zfcp_cfdc.c
+++ b/drivers/s390/scsi/zfcp_cfdc.c
@@ -10,8 +10,10 @@
 #define KMSG_COMPONENT "zfcp"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/miscdevice.h>
+#include <asm/compat.h>
 #include <asm/ccwdev.h>
 #include "zfcp_def.h"
 #include "zfcp_ext.h"
@@ -86,22 +88,17 @@ 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;
+        struct ccw_device *cdev;
+        struct zfcp_adapter *adapter;
 
         snprintf(busid, sizeof(busid), "0.0.%04x", devno);
-        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:
+        cdev = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
+        if (!cdev)
+                return NULL;
+
+        adapter = zfcp_ccw_adapter_by_cdev(cdev);
+
+        put_device(&cdev->dev);
         return adapter;
 }
 
@@ -168,7 +165,7 @@ static void zfcp_cfdc_req_to_sense(struct zfcp_cfdc_data *data,
 }
 
 static long zfcp_cfdc_dev_ioctl(struct file *file, unsigned int command,
-                                unsigned long buffer)
+                                unsigned long arg)
 {
         struct zfcp_cfdc_data *data;
         struct zfcp_cfdc_data __user *data_user;
@@ -180,7 +177,11 @@ static long zfcp_cfdc_dev_ioctl(struct file *file, unsigned int command,
         if (command != ZFCP_CFDC_IOC)
                 return -ENOTTY;
 
-        data_user = (void __user *) buffer;
+        if (is_compat_task())
+                data_user = compat_ptr(arg);
+        else
+                data_user = (void __user *)arg;
+
         if (!data_user)
                 return -EINVAL;
 
@@ -212,7 +213,6 @@ static long zfcp_cfdc_dev_ioctl(struct file *file, unsigned int command,
                 retval = -ENXIO;
                 goto free_buffer;
         }
-        zfcp_adapter_get(adapter);
 
         retval = zfcp_cfdc_sg_setup(data->command, fsf_cfdc->sg,
                                     data_user->control_file);
@@ -245,7 +245,7 @@ static long zfcp_cfdc_dev_ioctl(struct file *file, unsigned int command,
  free_sg:
         zfcp_sg_free_table(fsf_cfdc->sg, ZFCP_CFDC_PAGES);
  adapter_put:
-        zfcp_adapter_put(adapter);
+        zfcp_ccw_adapter_put(adapter);
  free_buffer:
         kfree(data);
  no_mem_sense:
diff --git a/drivers/s390/scsi/zfcp_dbf.c b/drivers/s390/scsi/zfcp_dbf.c
index 215b70749e95..075852f6968c 100644
--- a/drivers/s390/scsi/zfcp_dbf.c
+++ b/drivers/s390/scsi/zfcp_dbf.c
@@ -10,9 +10,11 @@
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include <linux/ctype.h>
+#include <linux/slab.h>
 #include <asm/debug.h>
 #include "zfcp_dbf.h"
 #include "zfcp_ext.h"
+#include "zfcp_fc.h"
 
 static u32 dbfsize = 4;
 
@@ -139,9 +141,9 @@ void _zfcp_dbf_hba_fsf_response(const char *tag2, int level,
         memcpy(response->fsf_status_qual,
                fsf_status_qual, FSF_STATUS_QUALIFIER_SIZE);
         response->fsf_req_status = fsf_req->status;
-        response->sbal_first = fsf_req->queue_req.sbal_first;
-        response->sbal_last = fsf_req->queue_req.sbal_last;
-        response->sbal_response = fsf_req->queue_req.sbal_response;
+        response->sbal_first = fsf_req->qdio_req.sbal_first;
+        response->sbal_last = fsf_req->qdio_req.sbal_last;
+        response->sbal_response = fsf_req->qdio_req.sbal_response;
         response->pool = fsf_req->pool != NULL;
         response->erp_action = (unsigned long)fsf_req->erp_action;
 
@@ -177,8 +179,7 @@ void _zfcp_dbf_hba_fsf_response(const char *tag2, int level,
 
         case FSF_QTCB_SEND_ELS:
                 send_els = (struct zfcp_send_els *)fsf_req->data;
-                response->u.els.d_id = qtcb->bottom.support.d_id;
-                response->u.els.ls_code = send_els->ls_code >> 24;
+                response->u.els.d_id = ntoh24(qtcb->bottom.support.d_id);
                 break;
 
         case FSF_QTCB_ABORT_FCP_CMND:
@@ -327,7 +328,7 @@ static void zfcp_dbf_hba_view_response(char **p,
                         break;
                 zfcp_dbf_out(p, "scsi_cmnd", "0x%0Lx", r->u.fcp.cmnd);
                 zfcp_dbf_out(p, "scsi_serial", "0x%016Lx", r->u.fcp.serial);
-                p += sprintf(*p, "\n");
+                *p += sprintf(*p, "\n");
                 break;
 
         case FSF_QTCB_OPEN_PORT_WITH_DID:
@@ -348,7 +349,6 @@ static void zfcp_dbf_hba_view_response(char **p,
 
         case FSF_QTCB_SEND_ELS:
                 zfcp_dbf_out(p, "d_id", "0x%06x", r->u.els.d_id);
-                zfcp_dbf_out(p, "ls_code", "0x%02x", r->u.els.ls_code);
                 break;
 
         case FSF_QTCB_ABORT_FCP_CMND:
@@ -577,7 +577,8 @@ void zfcp_dbf_rec_adapter(char *id, void *ref, struct zfcp_dbf *dbf)
         struct zfcp_adapter *adapter = dbf->adapter;
 
         zfcp_dbf_rec_target(id, ref, dbf, &adapter->status,
-                                  &adapter->erp_counter, 0, 0, 0);
+                            &adapter->erp_counter, 0, 0,
+                            ZFCP_DBF_INVALID_LUN);
 }
 
 /**
@@ -591,8 +592,8 @@ void zfcp_dbf_rec_port(char *id, void *ref, struct zfcp_port *port)
         struct zfcp_dbf *dbf = port->adapter->dbf;
 
         zfcp_dbf_rec_target(id, ref, dbf, &port->status,
-                                  &port->erp_counter, port->wwpn, port->d_id,
-                                  0);
+                            &port->erp_counter, port->wwpn, port->d_id,
+                            ZFCP_DBF_INVALID_LUN);
 }
 
 /**
@@ -643,10 +644,9 @@ void zfcp_dbf_rec_trigger(char *id2, void *ref, u8 want, u8 need, void *action,
                 r->u.trigger.ps = atomic_read(&port->status);
                 r->u.trigger.wwpn = port->wwpn;
         }
-        if (unit) {
+        if (unit)
                 r->u.trigger.us = atomic_read(&unit->status);
-                r->u.trigger.fcp_lun = unit->fcp_lun;
-        }
+        r->u.trigger.fcp_lun = unit ? unit->fcp_lun : ZFCP_DBF_INVALID_LUN;
         debug_event(dbf->rec, action ? 1 : 4, r, sizeof(*r));
         spin_unlock_irqrestore(&dbf->rec_lock, flags);
 }
@@ -669,7 +669,7 @@ void zfcp_dbf_rec_action(char *id2, struct zfcp_erp_action *erp_action)
         r->u.action.action = (unsigned long)erp_action;
         r->u.action.status = erp_action->status;
         r->u.action.step = erp_action->step;
-        r->u.action.fsf_req = (unsigned long)erp_action->fsf_req;
+        r->u.action.fsf_req = erp_action->fsf_req_id;
         debug_event(dbf->rec, 5, r, sizeof(*r));
         spin_unlock_irqrestore(&dbf->rec_lock, flags);
 }
@@ -677,14 +677,14 @@ void zfcp_dbf_rec_action(char *id2, struct zfcp_erp_action *erp_action)
 /**
  * zfcp_dbf_san_ct_request - trace event for issued CT request
  * @fsf_req: request containing issued CT data
+ * @d_id: destination id where ct request is sent to
  */
-void zfcp_dbf_san_ct_request(struct zfcp_fsf_req *fsf_req)
+void zfcp_dbf_san_ct_request(struct zfcp_fsf_req *fsf_req, u32 d_id)
 {
-        struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data;
-        struct zfcp_wka_port *wka_port = ct->wka_port;
-        struct zfcp_adapter *adapter = wka_port->adapter;
+        struct zfcp_fsf_ct_els *ct = (struct zfcp_fsf_ct_els *)fsf_req->data;
+        struct zfcp_adapter *adapter = fsf_req->adapter;
         struct zfcp_dbf *dbf = adapter->dbf;
-        struct ct_hdr *hdr = sg_virt(ct->req);
+        struct fc_ct_hdr *hdr = sg_virt(ct->req);
         struct zfcp_dbf_san_record *r = &dbf->san_buf;
         struct zfcp_dbf_san_record_ct_request *oct = &r->u.ct_req;
         int level = 3;
@@ -695,19 +695,18 @@ void zfcp_dbf_san_ct_request(struct zfcp_fsf_req *fsf_req)
         strncpy(r->tag, "octc", ZFCP_DBF_TAG_SIZE);
         r->fsf_reqid = fsf_req->req_id;
         r->fsf_seqno = fsf_req->seq_no;
-        r->s_id = fc_host_port_id(adapter->scsi_host);
-        r->d_id = wka_port->d_id;
-        oct->cmd_req_code = hdr->cmd_rsp_code;
-        oct->revision = hdr->revision;
-        oct->gs_type = hdr->gs_type;
-        oct->gs_subtype = hdr->gs_subtype;
-        oct->options = hdr->options;
-        oct->max_res_size = hdr->max_res_size;
-        oct->len = min((int)ct->req->length - (int)sizeof(struct ct_hdr),
+        oct->d_id = d_id;
+        oct->cmd_req_code = hdr->ct_cmd;
+        oct->revision = hdr->ct_rev;
+        oct->gs_type = hdr->ct_fs_type;
+        oct->gs_subtype = hdr->ct_fs_subtype;
+        oct->options = hdr->ct_options;
+        oct->max_res_size = hdr->ct_mr_size;
+        oct->len = min((int)ct->req->length - (int)sizeof(struct fc_ct_hdr),
                        ZFCP_DBF_SAN_MAX_PAYLOAD);
         debug_event(dbf->san, level, r, sizeof(*r));
         zfcp_dbf_hexdump(dbf->san, r, sizeof(*r), level,
-                         (void *)hdr + sizeof(struct ct_hdr), oct->len);
+                         (void *)hdr + sizeof(struct fc_ct_hdr), oct->len);
         spin_unlock_irqrestore(&dbf->san_lock, flags);
 }
 
@@ -717,10 +716,9 @@ void zfcp_dbf_san_ct_request(struct zfcp_fsf_req *fsf_req)
  */
 void zfcp_dbf_san_ct_response(struct zfcp_fsf_req *fsf_req)
 {
-        struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data;
-        struct zfcp_wka_port *wka_port = ct->wka_port;
-        struct zfcp_adapter *adapter = wka_port->adapter;
-        struct ct_hdr *hdr = sg_virt(ct->resp);
+        struct zfcp_fsf_ct_els *ct = (struct zfcp_fsf_ct_els *)fsf_req->data;
+        struct zfcp_adapter *adapter = fsf_req->adapter;
+        struct fc_ct_hdr *hdr = sg_virt(ct->resp);
         struct zfcp_dbf *dbf = adapter->dbf;
         struct zfcp_dbf_san_record *r = &dbf->san_buf;
         struct zfcp_dbf_san_record_ct_response *rct = &r->u.ct_resp;
@@ -732,25 +730,23 @@ void zfcp_dbf_san_ct_response(struct zfcp_fsf_req *fsf_req)
         strncpy(r->tag, "rctc", ZFCP_DBF_TAG_SIZE);
         r->fsf_reqid = fsf_req->req_id;
         r->fsf_seqno = fsf_req->seq_no;
-        r->s_id = wka_port->d_id;
-        r->d_id = fc_host_port_id(adapter->scsi_host);
-        rct->cmd_rsp_code = hdr->cmd_rsp_code;
-        rct->revision = hdr->revision;
-        rct->reason_code = hdr->reason_code;
-        rct->expl = hdr->reason_code_expl;
-        rct->vendor_unique = hdr->vendor_unique;
-        rct->max_res_size = hdr->max_res_size;
-        rct->len = min((int)ct->resp->length - (int)sizeof(struct ct_hdr),
+        rct->cmd_rsp_code = hdr->ct_cmd;
+        rct->revision = hdr->ct_rev;
+        rct->reason_code = hdr->ct_reason;
+        rct->expl = hdr->ct_explan;
+        rct->vendor_unique = hdr->ct_vendor;
+        rct->max_res_size = hdr->ct_mr_size;
+        rct->len = min((int)ct->resp->length - (int)sizeof(struct fc_ct_hdr),
                        ZFCP_DBF_SAN_MAX_PAYLOAD);
         debug_event(dbf->san, level, r, sizeof(*r));
         zfcp_dbf_hexdump(dbf->san, r, sizeof(*r), level,
-                         (void *)hdr + sizeof(struct ct_hdr), rct->len);
+                         (void *)hdr + sizeof(struct fc_ct_hdr), rct->len);
         spin_unlock_irqrestore(&dbf->san_lock, flags);
 }
 
 static void zfcp_dbf_san_els(const char *tag, int level,
-                             struct zfcp_fsf_req *fsf_req, u32 s_id, u32 d_id,
-                             u8 ls_code, void *buffer, int buflen)
+                             struct zfcp_fsf_req *fsf_req, u32 d_id,
+                             void *buffer, int buflen)
 {
         struct zfcp_adapter *adapter = fsf_req->adapter;
         struct zfcp_dbf *dbf = adapter->dbf;
@@ -762,9 +758,7 @@ static void zfcp_dbf_san_els(const char *tag, int level,
         strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE);
         rec->fsf_reqid = fsf_req->req_id;
         rec->fsf_seqno = fsf_req->seq_no;
-        rec->s_id = s_id;
-        rec->d_id = d_id;
-        rec->u.els.ls_code = ls_code;
+        rec->u.els.d_id = d_id;
         debug_event(dbf->san, level, rec, sizeof(*rec));
         zfcp_dbf_hexdump(dbf->san, rec, sizeof(*rec), level,
                          buffer, min(buflen, ZFCP_DBF_SAN_MAX_PAYLOAD));
@@ -777,12 +771,11 @@ static void zfcp_dbf_san_els(const char *tag, int level,
  */
 void zfcp_dbf_san_els_request(struct zfcp_fsf_req *fsf_req)
 {
-        struct zfcp_send_els *els = (struct zfcp_send_els *)fsf_req->data;
+        struct zfcp_fsf_ct_els *els = (struct zfcp_fsf_ct_els *)fsf_req->data;
+        u32 d_id = ntoh24(fsf_req->qtcb->bottom.support.d_id);
 
-        zfcp_dbf_san_els("oels", 2, fsf_req,
-                               fc_host_port_id(els->adapter->scsi_host),
-                               els->d_id, *(u8 *) sg_virt(els->req),
-                               sg_virt(els->req), els->req->length);
+        zfcp_dbf_san_els("oels", 2, fsf_req, d_id,
+                         sg_virt(els->req), els->req->length);
 }
 
 /**
@@ -791,12 +784,11 @@ void zfcp_dbf_san_els_request(struct zfcp_fsf_req *fsf_req)
  */
 void zfcp_dbf_san_els_response(struct zfcp_fsf_req *fsf_req)
 {
-        struct zfcp_send_els *els = (struct zfcp_send_els *)fsf_req->data;
+        struct zfcp_fsf_ct_els *els = (struct zfcp_fsf_ct_els *)fsf_req->data;
+        u32 d_id = ntoh24(fsf_req->qtcb->bottom.support.d_id);
 
-        zfcp_dbf_san_els("rels", 2, fsf_req, els->d_id,
-                               fc_host_port_id(els->adapter->scsi_host),
-                               *(u8 *)sg_virt(els->req), sg_virt(els->resp),
-                               els->resp->length);
+        zfcp_dbf_san_els("rels", 2, fsf_req, d_id,
+                               sg_virt(els->resp), els->resp->length);
 }
 
 /**
@@ -805,16 +797,13 @@ void zfcp_dbf_san_els_response(struct zfcp_fsf_req *fsf_req)
  */
 void zfcp_dbf_san_incoming_els(struct zfcp_fsf_req *fsf_req)
 {
-        struct zfcp_adapter *adapter = fsf_req->adapter;
         struct fsf_status_read_buffer *buf =
                         (struct fsf_status_read_buffer *)fsf_req->data;
         int length = (int)buf->length -
                      (int)((void *)&buf->payload - (void *)buf);
 
-        zfcp_dbf_san_els("iels", 1, fsf_req, buf->d_id,
-                               fc_host_port_id(adapter->scsi_host),
-                               buf->payload.data[0], (void *)buf->payload.data,
-                               length);
+        zfcp_dbf_san_els("iels", 1, fsf_req, ntoh24(buf->d_id),
+                               (void *)buf->payload.data, length);
 }
 
 static int zfcp_dbf_san_view_format(debug_info_t *id, struct debug_view *view,
@@ -829,11 +818,10 @@ static int zfcp_dbf_san_view_format(debug_info_t *id, struct debug_view *view,
         zfcp_dbf_tag(&p, "tag", r->tag);
         zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid);
         zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno);
-        zfcp_dbf_out(&p, "s_id", "0x%06x", r->s_id);
-        zfcp_dbf_out(&p, "d_id", "0x%06x", r->d_id);
 
         if (strncmp(r->tag, "octc", ZFCP_DBF_TAG_SIZE) == 0) {
                 struct zfcp_dbf_san_record_ct_request *ct = &r->u.ct_req;
+                zfcp_dbf_out(&p, "d_id", "0x%06x", ct->d_id);
                 zfcp_dbf_out(&p, "cmd_req_code", "0x%04x", ct->cmd_req_code);
                 zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision);
                 zfcp_dbf_out(&p, "gs_type", "0x%02x", ct->gs_type);
@@ -852,7 +840,7 @@ static int zfcp_dbf_san_view_format(debug_info_t *id, struct debug_view *view,
                    strncmp(r->tag, "rels", ZFCP_DBF_TAG_SIZE) == 0 ||
                    strncmp(r->tag, "iels", ZFCP_DBF_TAG_SIZE) == 0) {
                 struct zfcp_dbf_san_record_els *els = &r->u.els;
-                zfcp_dbf_out(&p, "ls_code", "0x%02x", els->ls_code);
+                zfcp_dbf_out(&p, "d_id", "0x%06x", els->d_id);
         }
         return p - out_buf;
 }
@@ -870,8 +858,9 @@ void _zfcp_dbf_scsi(const char *tag, const char *tag2, int level,
         struct zfcp_dbf_scsi_record *rec = &dbf->scsi_buf;
         struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)rec;
         unsigned long flags;
-        struct fcp_rsp_iu *fcp_rsp;
-        char *fcp_rsp_info = NULL, *fcp_sns_info = NULL;
+        struct fcp_resp_with_ext *fcp_rsp;
+        struct fcp_resp_rsp_info *fcp_rsp_info = NULL;
+        char *fcp_sns_info = NULL;
         int offset = 0, buflen = 0;
 
         spin_lock_irqsave(&dbf->scsi_lock, flags);
@@ -895,20 +884,22 @@ void _zfcp_dbf_scsi(const char *tag, const char *tag2, int level,
                                 rec->scsi_allowed = scsi_cmnd->allowed;
                         }
                         if (fsf_req != NULL) {
-                                fcp_rsp = (struct fcp_rsp_iu *)
-                                    &(fsf_req->qtcb->bottom.io.fcp_rsp);
-                                fcp_rsp_info = (unsigned char *) &fcp_rsp[1];
-                                fcp_sns_info =
-                                    zfcp_get_fcp_sns_info_ptr(fcp_rsp);
-
-                                rec->rsp_validity = fcp_rsp->validity.value;
-                                rec->rsp_scsi_status = fcp_rsp->scsi_status;
-                                rec->rsp_resid = fcp_rsp->fcp_resid;
-                                if (fcp_rsp->validity.bits.fcp_rsp_len_valid)
-                                        rec->rsp_code = *(fcp_rsp_info + 3);
-                                if (fcp_rsp->validity.bits.fcp_sns_len_valid) {
-                                        buflen = min((int)fcp_rsp->fcp_sns_len,
-                                                     ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO);
+                                fcp_rsp = (struct fcp_resp_with_ext *)
+                                        &(fsf_req->qtcb->bottom.io.fcp_rsp);
+                                fcp_rsp_info = (struct fcp_resp_rsp_info *)
+                                        &fcp_rsp[1];
+                                fcp_sns_info = (char *) &fcp_rsp[1];
+                                if (fcp_rsp->resp.fr_flags & FCP_RSP_LEN_VAL)
+                                        fcp_sns_info += fcp_rsp->ext.fr_sns_len;
+
+                                rec->rsp_validity = fcp_rsp->resp.fr_flags;
+                                rec->rsp_scsi_status = fcp_rsp->resp.fr_status;
+                                rec->rsp_resid = fcp_rsp->ext.fr_resid;
+                                if (fcp_rsp->resp.fr_flags & FCP_RSP_LEN_VAL)
+                                        rec->rsp_code = fcp_rsp_info->rsp_code;
+                                if (fcp_rsp->resp.fr_flags & FCP_SNS_LEN_VAL) {
+                                        buflen = min(fcp_rsp->ext.fr_sns_len,
+                                           (u32)ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO);
                                         rec->sns_info_len = buflen;
                                         memcpy(rec->sns_info, fcp_sns_info,
                                                min(buflen,
@@ -1067,6 +1058,8 @@ err_out:
  */
 void zfcp_dbf_adapter_unregister(struct zfcp_dbf *dbf)
 {
+        if (!dbf)
+                return;
         debug_unregister(dbf->scsi);
         debug_unregister(dbf->san);
         debug_unregister(dbf->hba);
diff --git a/drivers/s390/scsi/zfcp_dbf.h b/drivers/s390/scsi/zfcp_dbf.h
index 6b1461e8f847..457e046f2d28 100644
--- a/drivers/s390/scsi/zfcp_dbf.h
+++ b/drivers/s390/scsi/zfcp_dbf.h
@@ -22,6 +22,7 @@
 #ifndef ZFCP_DBF_H
 #define ZFCP_DBF_H
 
+#include <scsi/fc/fc_fcp.h>
 #include "zfcp_ext.h"
 #include "zfcp_fsf.h"
 #include "zfcp_def.h"
@@ -29,6 +30,8 @@
 #define ZFCP_DBF_TAG_SIZE      4
 #define ZFCP_DBF_ID_SIZE       7
 
+#define ZFCP_DBF_INVALID_LUN    0xFFFFFFFFFFFFFFFFull
+
 struct zfcp_dbf_dump {
         u8 tag[ZFCP_DBF_TAG_SIZE];
         u32 total_size;         /* size of total dump data */
@@ -122,7 +125,6 @@ struct zfcp_dbf_hba_record_response {
                 } unit;
                 struct {
                         u32 d_id;
-                        u8 ls_code;
                 } els;
         } u;
 } __attribute__ ((packed));
@@ -166,6 +168,7 @@ struct zfcp_dbf_san_record_ct_request {
         u8 options;
         u16 max_res_size;
         u32 len;
+        u32 d_id;
 } __attribute__ ((packed));
 
 struct zfcp_dbf_san_record_ct_response {
@@ -179,25 +182,22 @@ struct zfcp_dbf_san_record_ct_response {
 } __attribute__ ((packed));
 
 struct zfcp_dbf_san_record_els {
-        u8 ls_code;
-        u32 len;
+        u32 d_id;
 } __attribute__ ((packed));
 
 struct zfcp_dbf_san_record {
         u8 tag[ZFCP_DBF_TAG_SIZE];
         u64 fsf_reqid;
         u32 fsf_seqno;
-        u32 s_id;
-        u32 d_id;
         union {
                 struct zfcp_dbf_san_record_ct_request ct_req;
                 struct zfcp_dbf_san_record_ct_response ct_resp;
                 struct zfcp_dbf_san_record_els els;
         } u;
-#define ZFCP_DBF_SAN_MAX_PAYLOAD 1024
-        u8 payload[32];
 } __attribute__ ((packed));
 
+#define ZFCP_DBF_SAN_MAX_PAYLOAD 1024
+
 struct zfcp_dbf_scsi_record {
         u8 tag[ZFCP_DBF_TAG_SIZE];
         u8 tag2[ZFCP_DBF_TAG_SIZE];
@@ -303,17 +303,31 @@ void zfcp_dbf_scsi(const char *tag, const char *tag2, int level,
 
 /**
  * zfcp_dbf_scsi_result - trace event for SCSI command completion
- * @tag: tag indicating success or failure of SCSI command
- * @level: trace level applicable for this event
- * @adapter: adapter that has been used to issue the SCSI command
+ * @dbf: adapter dbf trace
+ * @scmd: SCSI command pointer
+ * @req: FSF request used to issue SCSI command
+ */
+static inline
+void zfcp_dbf_scsi_result(struct zfcp_dbf *dbf, struct scsi_cmnd *scmd,
+                          struct zfcp_fsf_req *req)
+{
+        if (scmd->result != 0)
+                zfcp_dbf_scsi("rslt", "erro", 3, dbf, scmd, req, 0);
+        else if (scmd->retries > 0)
+                zfcp_dbf_scsi("rslt", "retr", 4, dbf, scmd, req, 0);
+        else
+                zfcp_dbf_scsi("rslt", "norm", 6, dbf, scmd, req, 0);
+}
+
+/**
+ * zfcp_dbf_scsi_fail_send - trace event for failure to send SCSI command
+ * @dbf: adapter dbf trace
  * @scmd: SCSI command pointer
- * @fsf_req: request used to issue SCSI command (might be NULL)
  */
 static inline
-void zfcp_dbf_scsi_result(const char *tag, int level, struct zfcp_dbf *dbf,
-                          struct scsi_cmnd *scmd, struct zfcp_fsf_req *fsf_req)
+void zfcp_dbf_scsi_fail_send(struct zfcp_dbf *dbf, struct scsi_cmnd *scmd)
 {
-        zfcp_dbf_scsi("rslt", tag, level, dbf, scmd, fsf_req, 0);
+        zfcp_dbf_scsi("rslt", "fail", 4, dbf, scmd, NULL, 0);
 }
 
 /**
@@ -343,7 +357,7 @@ static inline
 void zfcp_dbf_scsi_devreset(const char *tag, u8 flag, struct zfcp_unit *unit,
                             struct scsi_cmnd *scsi_cmnd)
 {
-        zfcp_dbf_scsi(flag == FCP_TARGET_RESET ? "trst" : "lrst", tag, 1,
+        zfcp_dbf_scsi(flag == FCP_TMF_TGT_RESET ? "trst" : "lrst", tag, 1,
                             unit->port->adapter->dbf, scsi_cmnd, NULL, 0);
 }
 
diff --git a/drivers/s390/scsi/zfcp_def.h b/drivers/s390/scsi/zfcp_def.h
index 7da2fad8f515..7131c7db1f04 100644
--- a/drivers/s390/scsi/zfcp_def.h
+++ b/drivers/s390/scsi/zfcp_def.h
@@ -3,7 +3,7 @@
  *
  * Global definitions for the zfcp device driver.
  *
- * Copyright IBM Corporation 2002, 2009
+ * Copyright IBM Corporation 2002, 2010
  */
 
 #ifndef ZFCP_DEF_H
@@ -33,15 +33,13 @@
 #include <scsi/scsi_transport_fc.h>
 #include <scsi/scsi_bsg_fc.h>
 #include <asm/ccwdev.h>
-#include <asm/qdio.h>
 #include <asm/debug.h>
 #include <asm/ebcdic.h>
 #include <asm/sysinfo.h>
 #include "zfcp_fsf.h"
+#include "zfcp_qdio.h"
 
-/********************* GENERAL DEFINES *********************************/
-
-#define REQUEST_LIST_SIZE 128
+struct zfcp_reqlist;
 
 /********************* SCSI SPECIFIC DEFINES *********************************/
 #define ZFCP_SCSI_ER_TIMEOUT                    (10*HZ)
@@ -71,131 +69,6 @@
 /* timeout value for "default timer" for fsf requests */
 #define ZFCP_FSF_REQUEST_TIMEOUT (60*HZ)
 
-/*************** FIBRE CHANNEL PROTOCOL SPECIFIC DEFINES ********************/
-
-/* task attribute values in FCP-2 FCP_CMND IU */
-#define SIMPLE_Q        0
-#define HEAD_OF_Q       1
-#define ORDERED_Q       2
-#define ACA_Q           4
-#define UNTAGGED        5
-
-/* task management flags in FCP-2 FCP_CMND IU */
-#define FCP_CLEAR_ACA           0x40
-#define FCP_TARGET_RESET        0x20
-#define FCP_LOGICAL_UNIT_RESET  0x10
-#define FCP_CLEAR_TASK_SET      0x04
-#define FCP_ABORT_TASK_SET      0x02
-
-#define FCP_CDB_LENGTH          16
-
-#define ZFCP_DID_MASK           0x00FFFFFF
-
-/* FCP(-2) FCP_CMND IU */
-struct fcp_cmnd_iu {
-        u64 fcp_lun;       /* FCP logical unit number */
-        u8  crn;                   /* command reference number */
-        u8  reserved0:5;           /* reserved */
-        u8  task_attribute:3;      /* task attribute */
-        u8  task_management_flags; /* task management flags */
-        u8  add_fcp_cdb_length:6;  /* additional FCP_CDB length */
-        u8  rddata:1;              /* read data */
-        u8  wddata:1;              /* write data */
-        u8  fcp_cdb[FCP_CDB_LENGTH];
-} __attribute__((packed));
-
-/* FCP(-2) FCP_RSP IU */
-struct fcp_rsp_iu {
-        u8  reserved0[10];
-        union {
-                struct {
-                        u8 reserved1:3;
-                        u8 fcp_conf_req:1;
-                        u8 fcp_resid_under:1;
-                        u8 fcp_resid_over:1;
-                        u8 fcp_sns_len_valid:1;
-                        u8 fcp_rsp_len_valid:1;
-                } bits;
-                u8 value;
-        } validity;
-        u8  scsi_status;
-        u32 fcp_resid;
-        u32 fcp_sns_len;
-        u32 fcp_rsp_len;
-} __attribute__((packed));
-
-
-#define RSP_CODE_GOOD            0
-#define RSP_CODE_LENGTH_MISMATCH 1
-#define RSP_CODE_FIELD_INVALID   2
-#define RSP_CODE_RO_MISMATCH     3
-#define RSP_CODE_TASKMAN_UNSUPP  4
-#define RSP_CODE_TASKMAN_FAILED  5
-
-/* see fc-fs */
-#define LS_RSCN  0x61
-#define LS_LOGO  0x05
-#define LS_PLOGI 0x03
-
-struct fcp_rscn_head {
-        u8  command;
-        u8  page_length; /* always 0x04 */
-        u16 payload_len;
-} __attribute__((packed));
-
-struct fcp_rscn_element {
-        u8  reserved:2;
-        u8  event_qual:4;
-        u8  addr_format:2;
-        u32 nport_did:24;
-} __attribute__((packed));
-
-/* see fc-ph */
-struct fcp_logo {
-        u32 command;
-        u32 nport_did;
-        u64 nport_wwpn;
-} __attribute__((packed));
-
-/*
- * FC-FS stuff
- */
-#define R_A_TOV                         10 /* seconds */
-
-#define ZFCP_LS_RLS                     0x0f
-#define ZFCP_LS_ADISC                   0x52
-#define ZFCP_LS_RPS                     0x56
-#define ZFCP_LS_RSCN                    0x61
-#define ZFCP_LS_RNID                    0x78
-
-struct zfcp_ls_adisc {
-        u8              code;
-        u8              field[3];
-        u32             hard_nport_id;
-        u64             wwpn;
-        u64             wwnn;
-        u32             nport_id;
-} __attribute__ ((packed));
-
-/*
- * FC-GS-2 stuff
- */
-#define ZFCP_CT_REVISION                0x01
-#define ZFCP_CT_DIRECTORY_SERVICE       0xFC
-#define ZFCP_CT_NAME_SERVER             0x02
-#define ZFCP_CT_SYNCHRONOUS             0x00
-#define ZFCP_CT_SCSI_FCP                0x08
-#define ZFCP_CT_UNABLE_TO_PERFORM_CMD   0x09
-#define ZFCP_CT_GID_PN                  0x0121
-#define ZFCP_CT_GPN_FT                  0x0172
-#define ZFCP_CT_ACCEPT                  0x8002
-#define ZFCP_CT_REJECT                  0x8001
-
-/*
- * FC-GS-4 stuff
- */
-#define ZFCP_CT_TIMEOUT                 (3 * R_A_TOV)
-
 /*************** ADAPTER/PORT/UNIT AND FSF_REQ STATUS FLAGS ******************/
 
 /*
@@ -205,7 +78,6 @@ struct zfcp_ls_adisc {
 #define ZFCP_COMMON_FLAGS                       0xfff00000
 
 /* common status bits */
-#define ZFCP_STATUS_COMMON_REMOVE               0x80000000
 #define ZFCP_STATUS_COMMON_RUNNING              0x40000000
 #define ZFCP_STATUS_COMMON_ERP_FAILED           0x20000000
 #define ZFCP_STATUS_COMMON_UNBLOCKED            0x10000000
@@ -222,21 +94,10 @@ struct zfcp_ls_adisc {
 #define ZFCP_STATUS_ADAPTER_ERP_PENDING         0x00000100
 #define ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED      0x00000200
 
-/* FC-PH/FC-GS well-known address identifiers for generic services */
-#define ZFCP_DID_WKA                            0xFFFFF0
-
 /* remote port status */
 #define ZFCP_STATUS_PORT_PHYS_OPEN              0x00000001
 #define ZFCP_STATUS_PORT_LINK_TEST              0x00000002
 
-/* well known address (WKA) port status*/
-enum zfcp_wka_status {
-        ZFCP_WKA_PORT_OFFLINE,
-        ZFCP_WKA_PORT_CLOSING,
-        ZFCP_WKA_PORT_OPENING,
-        ZFCP_WKA_PORT_ONLINE,
-};
-
 /* logical unit status */
 #define ZFCP_STATUS_UNIT_SHARED                 0x00000004
 #define ZFCP_STATUS_UNIT_READONLY               0x00000008
@@ -247,10 +108,7 @@ enum zfcp_wka_status {
 #define ZFCP_STATUS_FSFREQ_CLEANUP              0x00000010
 #define ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED       0x00000040
 #define ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED       0x00000080
-#define ZFCP_STATUS_FSFREQ_ABORTED              0x00000100
 #define ZFCP_STATUS_FSFREQ_TMFUNCFAILED         0x00000200
-#define ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP        0x00000400
-#define ZFCP_STATUS_FSFREQ_RETRY                0x00000800
 #define ZFCP_STATUS_FSFREQ_DISMISSED            0x00001000
 
 /************************* STRUCTURE DEFINITIONS *****************************/
@@ -265,131 +123,10 @@ struct zfcp_adapter_mempool {
         mempool_t *scsi_abort;
         mempool_t *status_read_req;
         mempool_t *status_read_data;
-        mempool_t *gid_pn_data;
+        mempool_t *gid_pn;
         mempool_t *qtcb_pool;
 };
 
-/*
- * header for CT_IU
- */
-struct ct_hdr {
-        u8 revision;            // 0x01
-        u8 in_id[3];            // 0x00
-        u8 gs_type;             // 0xFC Directory Service
-        u8 gs_subtype;          // 0x02 Name Server
-        u8 options;             // 0x00 single bidirectional exchange
-        u8 reserved0;
-        u16 cmd_rsp_code;       // 0x0121 GID_PN, or 0x0100 GA_NXT
-        u16 max_res_size;       // <= (4096 - 16) / 4
-        u8 reserved1;
-        u8 reason_code;
-        u8 reason_code_expl;
-        u8 vendor_unique;
-} __attribute__ ((packed));
-
-/* nameserver request CT_IU -- for requests where
- * a port name is required */
-struct ct_iu_gid_pn_req {
-        struct ct_hdr header;
-        u64 wwpn;
-} __attribute__ ((packed));
-
-/* FS_ACC IU and data unit for GID_PN nameserver request */
-struct ct_iu_gid_pn_resp {
-        struct ct_hdr header;
-        u32 d_id;
-} __attribute__ ((packed));
-
-struct ct_iu_gpn_ft_req {
-        struct ct_hdr header;
-        u8 flags;
-        u8 domain_id_scope;
-        u8 area_id_scope;
-        u8 fc4_type;
-} __attribute__ ((packed));
-
-
-/**
- * struct zfcp_send_ct - used to pass parameters to function zfcp_fsf_send_ct
- * @wka_port: port where the request is sent to
- * @req: scatter-gather list for request
- * @resp: scatter-gather list for response
- * @handler: handler function (called for response to the request)
- * @handler_data: data passed to handler function
- * @completion: completion for synchronization purposes
- * @status: used to pass error status to calling function
- */
-struct zfcp_send_ct {
-        struct zfcp_wka_port *wka_port;
-        struct scatterlist *req;
-        struct scatterlist *resp;
-        void (*handler)(unsigned long);
-        unsigned long handler_data;
-        struct completion *completion;
-        int status;
-};
-
-/* used for name server requests in error recovery */
-struct zfcp_gid_pn_data {
-        struct zfcp_send_ct ct;
-        struct scatterlist req;
-        struct scatterlist resp;
-        struct ct_iu_gid_pn_req ct_iu_req;
-        struct ct_iu_gid_pn_resp ct_iu_resp;
-        struct zfcp_port *port;
-};
-
-/**
- * struct zfcp_send_els - used to pass parameters to function zfcp_fsf_send_els
- * @adapter: adapter where request is sent from
- * @port: port where ELS is destinated (port reference count has to be increased)
- * @d_id: destiniation id of port where request is sent to
- * @req: scatter-gather list for request
- * @resp: scatter-gather list for response
- * @handler: handler function (called for response to the request)
- * @handler_data: data passed to handler function
- * @completion: completion for synchronization purposes
- * @ls_code: hex code of ELS command
- * @status: used to pass error status to calling function
- */
-struct zfcp_send_els {
-        struct zfcp_adapter *adapter;
-        struct zfcp_port *port;
-        u32 d_id;
-        struct scatterlist *req;
-        struct scatterlist *resp;
-        void (*handler)(unsigned long);
-        unsigned long handler_data;
-        struct completion *completion;
-        int ls_code;
-        int status;
-};
-
-struct zfcp_wka_port {
-        struct zfcp_adapter     *adapter;
-        wait_queue_head_t       completion_wq;
-        enum zfcp_wka_status    status;
-        atomic_t                refcount;
-        u32                     d_id;
-        u32                     handle;
-        struct mutex            mutex;
-        struct delayed_work     work;
-};
-
-struct zfcp_wka_ports {
-        struct zfcp_wka_port ms;        /* management service */
-        struct zfcp_wka_port ts;        /* time service */
-        struct zfcp_wka_port ds;        /* directory service */
-        struct zfcp_wka_port as;        /* alias service */
-        struct zfcp_wka_port ks;        /* key distribution service */
-};
-
-struct zfcp_qdio_queue {
-        struct qdio_buffer *sbal[QDIO_MAX_BUFFERS_PER_Q];
-        u8                 first;       /* index of next free bfr in queue */
-        atomic_t           count;       /* number of free buffers in queue */
-};
-
 struct zfcp_erp_action {
         struct list_head list;
         int action;                   /* requested action code */
@@ -398,8 +135,7 @@ struct zfcp_erp_action {
         struct zfcp_unit *unit;
         u32             status;       /* recovery status */
         u32 step;                     /* active step of this erp action */
-        struct zfcp_fsf_req *fsf_req; /* fsf request currently pending
-                                         for this action */
+        unsigned long           fsf_req_id;
         struct timer_list timer;
 };
 
@@ -422,33 +158,8 @@ struct zfcp_latencies {
         spinlock_t lock;
 };
 
-/** struct zfcp_qdio - basic QDIO data structure
- * @resp_q: response queue
- * @req_q: request queue
- * @stat_lock: lock to protect req_q_util and req_q_time
- * @req_q_lock; lock to serialize access to request queue
- * @req_q_time: time of last fill level change
- * @req_q_util: used for accounting
- * @req_q_full: queue full incidents
- * @req_q_wq: used to wait for SBAL availability
- * @adapter: adapter used in conjunction with this QDIO structure
- */
-struct zfcp_qdio {
-        struct zfcp_qdio_queue  resp_q;
-        struct zfcp_qdio_queue  req_q;
-        spinlock_t              stat_lock;
-        spinlock_t              req_q_lock;
-        unsigned long long      req_q_time;
-        u64                     req_q_util;
-        atomic_t                req_q_full;
-        wait_queue_head_t       req_q_wq;
-        struct zfcp_adapter     *adapter;
-};
-
 struct zfcp_adapter {
-        atomic_t                refcount;          /* reference count */
-        wait_queue_head_t       remove_wq;         /* can be used to wait for
-                                                      refcount drop to zero */
+        struct kref             ref;
         u64                     peer_wwnn;         /* P2P peer WWNN */
         u64                     peer_wwpn;         /* P2P peer WWPN */
         u32                     peer_d_id;         /* P2P peer D_ID */
@@ -461,10 +172,10 @@ struct zfcp_adapter {
         u32                     hardware_version;  /* of FCP channel */
         u16                     timer_ticks;       /* time int for a tick */
         struct Scsi_Host        *scsi_host;        /* Pointer to mid-layer */
-        struct list_head        port_list_head;    /* remote port list */
+        struct list_head        port_list;         /* remote port list */
+        rwlock_t                port_list_lock;    /* port list lock */
         unsigned long           req_no;            /* unique FSF req number */
-        struct list_head        *req_list;         /* list of pending reqs */
-        spinlock_t              req_list_lock;     /* request list lock */
+        struct zfcp_reqlist     *req_list;
         u32                     fsf_req_seq_no;    /* FSF cmnd seq number */
         rwlock_t                abort_lock;        /* Protects against SCSI
                                                       stack abort/command
@@ -485,7 +196,7 @@ struct zfcp_adapter {
         u32                     erp_low_mem_count; /* nr of erp actions waiting
                                                       for memory */
         struct task_struct      *erp_thread;
-        struct zfcp_wka_ports   *gs;               /* generic services */
+        struct zfcp_fc_wka_ports *gs;              /* generic services */
         struct zfcp_dbf         *dbf;              /* debug traces */
         struct zfcp_adapter_mempool     pool;      /* Adapter memory pools */
         struct fc_host_statistics *fc_stats;
@@ -497,14 +208,12 @@ struct zfcp_adapter {
 };
 
 struct zfcp_port {
-        struct device          sysfs_device;   /* sysfs device */
+        struct device          dev;
         struct fc_rport        *rport;         /* rport of fc transport class */
         struct list_head       list;           /* list of remote ports */
-        atomic_t               refcount;       /* reference count */
-        wait_queue_head_t      remove_wq;      /* can be used to wait for
-                                                  refcount drop to zero */
         struct zfcp_adapter    *adapter;       /* adapter used to access port */
-        struct list_head       unit_list_head; /* head of logical unit list */
+        struct list_head        unit_list;      /* head of logical unit list */
+        rwlock_t                unit_list_lock; /* unit list lock */
         atomic_t               status;         /* status of this remote port */
         u64                    wwnn;           /* WWNN if known */
         u64                    wwpn;           /* WWPN */
@@ -521,11 +230,8 @@ struct zfcp_port {
 };
 
 struct zfcp_unit {
-        struct device          sysfs_device;   /* sysfs device */
+        struct device          dev;
         struct list_head       list;           /* list of logical units */
-        atomic_t               refcount;       /* reference count */
-        wait_queue_head_t      remove_wq;      /* can be used to wait for
-                                                  refcount drop to zero */
         struct zfcp_port       *port;          /* remote port of unit */
         atomic_t               status;         /* status of this logical unit */
         u64                    fcp_lun;        /* own FCP_LUN */
@@ -538,33 +244,11 @@ struct zfcp_unit {
 };
 
 /**
- * struct zfcp_queue_req - queue related values for a request
- * @sbal_number: number of free SBALs
- * @sbal_first: first SBAL for this request
- * @sbal_last: last SBAL for this request
- * @sbal_limit: last possible SBAL for this request
- * @sbale_curr: current SBALE at creation of this request
- * @sbal_response: SBAL used in interrupt
- * @qdio_outb_usage: usage of outbound queue
- * @qdio_inb_usage: usage of inbound queue
- */
-struct zfcp_queue_req {
-        u8                     sbal_number;
-        u8                     sbal_first;
-        u8                     sbal_last;
-        u8                     sbal_limit;
-        u8                     sbale_curr;
-        u8                     sbal_response;
-        u16                    qdio_outb_usage;
-        u16                    qdio_inb_usage;
-};
-
-/**
  * struct zfcp_fsf_req - basic FSF request structure
  * @list: list of FSF requests
  * @req_id: unique request ID
  * @adapter: adapter this request belongs to
- * @queue_req: queue related values
+ * @qdio_req: qdio queue related values
  * @completion: used to signal the completion of the request
  * @status: status of the request
  * @fsf_command: FSF command issued
@@ -582,7 +266,7 @@ struct zfcp_fsf_req {
         struct list_head        list;
         unsigned long           req_id;
         struct zfcp_adapter     *adapter;
-        struct zfcp_queue_req   queue_req;
+        struct zfcp_qdio_req    qdio_req;
         struct completion       completion;
         u32                     status;
         u32                     fsf_command;
@@ -601,14 +285,11 @@ struct zfcp_fsf_req {
 struct zfcp_data {
         struct scsi_host_template scsi_host_template;
         struct scsi_transport_template *scsi_transport_template;
-        rwlock_t                config_lock;        /* serialises changes
-                                                       to adapter/port/unit
-                                                       lists */
-        struct mutex            config_mutex;
         struct kmem_cache       *gpn_ft_cache;
         struct kmem_cache       *qtcb_cache;
         struct kmem_cache       *sr_buffer_cache;
         struct kmem_cache       *gid_pn_cache;
+        struct kmem_cache       *adisc_cache;
 };
 
 /********************** ZFCP SPECIFIC DEFINES ********************************/
@@ -616,88 +297,4 @@ struct zfcp_data {
 #define ZFCP_SET                0x00000100
 #define ZFCP_CLEAR              0x00000200
 
-/*
- * Helper functions for request ID management.
- */
-static inline int zfcp_reqlist_hash(unsigned long req_id)
-{
-        return req_id % REQUEST_LIST_SIZE;
-}
-
-static inline void zfcp_reqlist_remove(struct zfcp_adapter *adapter,
-                                       struct zfcp_fsf_req *fsf_req)
-{
-        list_del(&fsf_req->list);
-}
-
-static inline struct zfcp_fsf_req *
-zfcp_reqlist_find(struct zfcp_adapter *adapter, unsigned long req_id)
-{
-        struct zfcp_fsf_req *request;
-        unsigned int idx;
-
-        idx = zfcp_reqlist_hash(req_id);
-        list_for_each_entry(request, &adapter->req_list[idx], list)
-                if (request->req_id == req_id)
-                        return request;
-        return NULL;
-}
-
-static inline struct zfcp_fsf_req *
-zfcp_reqlist_find_safe(struct zfcp_adapter *adapter, struct zfcp_fsf_req *req)
-{
-        struct zfcp_fsf_req *request;
-        unsigned int idx;
-
-        for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) {
-                list_for_each_entry(request, &adapter->req_list[idx], list)
-                        if (request == req)
-                                return request;
-        }
-        return NULL;
-}
-
-/*
- *  functions needed for reference/usage counting
- */
-
-static inline void
-zfcp_unit_get(struct zfcp_unit *unit)
-{
-        atomic_inc(&unit->refcount);
-}
-
-static inline void
-zfcp_unit_put(struct zfcp_unit *unit)
-{
-        if (atomic_dec_return(&unit->refcount) == 0)
-                wake_up(&unit->remove_wq);
-}
-
-static inline void
-zfcp_port_get(struct zfcp_port *port)
-{
-        atomic_inc(&port->refcount);
-}
-
-static inline void
-zfcp_port_put(struct zfcp_port *port)
-{
-        if (atomic_dec_return(&port->refcount) == 0)
-                wake_up(&port->remove_wq);
-}
-
-static inline void
-zfcp_adapter_get(struct zfcp_adapter *adapter)
-{
-        atomic_inc(&adapter->refcount);
-}
-
-static inline void
-zfcp_adapter_put(struct zfcp_adapter *adapter)
-{
-        if (atomic_dec_return(&adapter->refcount) == 0)
-                wake_up(&adapter->remove_wq);
-}
-
 #endif /* ZFCP_DEF_H */
diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c
index f73e2180f333..0be5e7ea2828 100644
--- a/drivers/s390/scsi/zfcp_erp.c
+++ b/drivers/s390/scsi/zfcp_erp.c
@@ -3,7 +3,7 @@
  *
  * Error Recovery Procedures (ERP).
  *
- * Copyright IBM Corporation 2002, 2009
+ * Copyright IBM Corporation 2002, 2010
  */
 
 #define KMSG_COMPONENT "zfcp"
@@ -11,6 +11,7 @@
 
 #include <linux/kthread.h>
 #include "zfcp_ext.h"
+#include "zfcp_reqlist.h"
 
 #define ZFCP_MAX_ERPS                   3
 
@@ -99,9 +100,12 @@ static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
 
         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
                 zfcp_erp_action_dismiss(&port->erp_action);
-        else
-                list_for_each_entry(unit, &port->unit_list_head, list)
-                    zfcp_erp_action_dismiss_unit(unit);
+        else {
+                read_lock(&port->unit_list_lock);
+                list_for_each_entry(unit, &port->unit_list, list)
+                        zfcp_erp_action_dismiss_unit(unit);
+                read_unlock(&port->unit_list_lock);
+        }
 }
 
 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
@@ -110,9 +114,12 @@ static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
 
         if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
                 zfcp_erp_action_dismiss(&adapter->erp_action);
-        else
-                list_for_each_entry(port, &adapter->port_list_head, list)
+        else {
+                read_lock(&adapter->port_list_lock);
+                list_for_each_entry(port, &adapter->port_list, list)
                     zfcp_erp_action_dismiss_port(port);
+                read_unlock(&adapter->port_list_lock);
+        }
 }
 
 static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter,
@@ -168,7 +175,8 @@ static struct zfcp_erp_action *zfcp_erp_setup_act(int need,
 
         switch (need) {
         case ZFCP_ERP_ACTION_REOPEN_UNIT:
-                zfcp_unit_get(unit);
+                if (!get_device(&unit->dev))
+                        return NULL;
                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status);
                 erp_action = &unit->erp_action;
                 if (!(atomic_read(&unit->status) & ZFCP_STATUS_COMMON_RUNNING))
@@ -177,7 +185,8 @@ static struct zfcp_erp_action *zfcp_erp_setup_act(int need,
 
         case ZFCP_ERP_ACTION_REOPEN_PORT:
         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
-                zfcp_port_get(port);
+                if (!get_device(&port->dev))
+                        return NULL;
                 zfcp_erp_action_dismiss_port(port);
                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
                 erp_action = &port->erp_action;
@@ -186,7 +195,7 @@ static struct zfcp_erp_action *zfcp_erp_setup_act(int need,
                 break;
 
         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
-                zfcp_adapter_get(adapter);
+                kref_get(&adapter->ref);
                 zfcp_erp_action_dismiss_adapter(adapter);
                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
                 erp_action = &adapter->erp_action;
@@ -264,11 +273,16 @@ void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
 {
         unsigned long flags;
 
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
-        write_lock(&adapter->erp_lock);
-        _zfcp_erp_adapter_reopen(adapter, clear, id, ref);
-        write_unlock(&adapter->erp_lock);
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+        zfcp_erp_adapter_block(adapter, clear);
+        zfcp_scsi_schedule_rports_block(adapter);
+
+        write_lock_irqsave(&adapter->erp_lock, flags);
+        if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
+                zfcp_erp_adapter_failed(adapter, "erareo1", NULL);
+        else
+                zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter,
+                                        NULL, NULL, id, ref);
+        write_unlock_irqrestore(&adapter->erp_lock, flags);
 }
 
 /**
@@ -345,11 +359,9 @@ void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear, char *id,
         unsigned long flags;
         struct zfcp_adapter *adapter = port->adapter;
 
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
-        write_lock(&adapter->erp_lock);
+        write_lock_irqsave(&adapter->erp_lock, flags);
         _zfcp_erp_port_forced_reopen(port, clear, id, ref);
-        write_unlock(&adapter->erp_lock);
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+        write_unlock_irqrestore(&adapter->erp_lock, flags);
 }
 
 static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id,
@@ -377,15 +389,13 @@ static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id,
  */
 int zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id, void *ref)
 {
-        unsigned long flags;
         int retval;
+        unsigned long flags;
         struct zfcp_adapter *adapter = port->adapter;
 
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
-        write_lock(&adapter->erp_lock);
+        write_lock_irqsave(&adapter->erp_lock, flags);
         retval = _zfcp_erp_port_reopen(port, clear, id, ref);
-        write_unlock(&adapter->erp_lock);
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+        write_unlock_irqrestore(&adapter->erp_lock, flags);
 
         return retval;
 }
@@ -424,11 +434,9 @@ void zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear, char *id,
         struct zfcp_port *port = unit->port;
         struct zfcp_adapter *adapter = port->adapter;
 
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
-        write_lock(&adapter->erp_lock);
+        write_lock_irqsave(&adapter->erp_lock, flags);
         _zfcp_erp_unit_reopen(unit, clear, id, ref);
-        write_unlock(&adapter->erp_lock);
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+        write_unlock_irqrestore(&adapter->erp_lock, flags);
 }
 
 static int status_change_set(unsigned long mask, atomic_t *status)
@@ -471,26 +479,27 @@ static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
 static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
 {
         struct zfcp_adapter *adapter = act->adapter;
+        struct zfcp_fsf_req *req;
 
-        if (!act->fsf_req)
+        if (!act->fsf_req_id)
                 return;
 
-        spin_lock(&adapter->req_list_lock);
-        if (zfcp_reqlist_find_safe(adapter, act->fsf_req) &&
-            act->fsf_req->erp_action == act) {
+        spin_lock(&adapter->req_list->lock);
+        req = _zfcp_reqlist_find(adapter->req_list, act->fsf_req_id);
+        if (req && req->erp_action == act) {
                 if (act->status & (ZFCP_STATUS_ERP_DISMISSED |
                                    ZFCP_STATUS_ERP_TIMEDOUT)) {
-                        act->fsf_req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
+                        req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
                         zfcp_dbf_rec_action("erscf_1", act);
-                        act->fsf_req->erp_action = NULL;
+                        req->erp_action = NULL;
                 }
                 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
                         zfcp_dbf_rec_action("erscf_2", act);
-                if (act->fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
-                        act->fsf_req = NULL;
+                if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
+                        act->fsf_req_id = 0;
         } else
-                act->fsf_req = NULL;
-        spin_unlock(&adapter->req_list_lock);
+                act->fsf_req_id = 0;
+        spin_unlock(&adapter->req_list->lock);
 }
 
 /**
@@ -540,8 +549,10 @@ static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
 {
         struct zfcp_port *port;
 
-        list_for_each_entry(port, &adapter->port_list_head, list)
+        read_lock(&adapter->port_list_lock);
+        list_for_each_entry(port, &adapter->port_list, list)
                 _zfcp_erp_port_reopen(port, clear, id, ref);
+        read_unlock(&adapter->port_list_lock);
 }
 
 static void _zfcp_erp_unit_reopen_all(struct zfcp_port *port, int clear,
@@ -549,8 +560,10 @@ static void _zfcp_erp_unit_reopen_all(struct zfcp_port *port, int clear,
 {
         struct zfcp_unit *unit;
 
-        list_for_each_entry(unit, &port->unit_list_head, list)
+        read_lock(&port->unit_list_lock);
+        list_for_each_entry(unit, &port->unit_list, list)
                 _zfcp_erp_unit_reopen(unit, clear, id, ref);
+        read_unlock(&port->unit_list_lock);
 }
 
 static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
@@ -590,16 +603,14 @@ static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
 {
         unsigned long flags;
 
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
-        read_lock(&adapter->erp_lock);
+        read_lock_irqsave(&adapter->erp_lock, flags);
         if (list_empty(&adapter->erp_ready_head) &&
             list_empty(&adapter->erp_running_head)) {
                         atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
                                           &adapter->status);
                         wake_up(&adapter->erp_done_wqh);
         }
-        read_unlock(&adapter->erp_lock);
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+        read_unlock_irqrestore(&adapter->erp_lock, flags);
 }
 
 static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *act)
@@ -1170,28 +1181,28 @@ static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
         switch (act->action) {
         case ZFCP_ERP_ACTION_REOPEN_UNIT:
                 if ((result == ZFCP_ERP_SUCCEEDED) && !unit->device) {
-                        zfcp_unit_get(unit);
+                        get_device(&unit->dev);
                         if (scsi_queue_work(unit->port->adapter->scsi_host,
                                             &unit->scsi_work) <= 0)
-                                zfcp_unit_put(unit);
+                                put_device(&unit->dev);
                 }
-                zfcp_unit_put(unit);
+                put_device(&unit->dev);
                 break;
 
         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
         case ZFCP_ERP_ACTION_REOPEN_PORT:
                 if (result == ZFCP_ERP_SUCCEEDED)
                         zfcp_scsi_schedule_rport_register(port);
-                zfcp_port_put(port);
+                put_device(&port->dev);
                 break;
 
         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
                 if (result == ZFCP_ERP_SUCCEEDED) {
                         register_service_level(&adapter->service_level);
-                        schedule_work(&adapter->scan_work);
+                        queue_work(adapter->work_queue, &adapter->scan_work);
                 } else
                         unregister_service_level(&adapter->service_level);
-                zfcp_adapter_put(adapter);
+                kref_put(&adapter->ref, zfcp_adapter_release);
                 break;
         }
 }
@@ -1214,12 +1225,12 @@ static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
 static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
 {
         int retval;
-        struct zfcp_adapter *adapter = erp_action->adapter;
         unsigned long flags;
+        struct zfcp_adapter *adapter = erp_action->adapter;
 
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
-        write_lock(&adapter->erp_lock);
+        kref_get(&adapter->ref);
 
+        write_lock_irqsave(&adapter->erp_lock, flags);
         zfcp_erp_strategy_check_fsfreq(erp_action);
 
         if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
@@ -1231,11 +1242,9 @@ static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
         zfcp_erp_action_to_running(erp_action);
 
         /* no lock to allow for blocking operations */
-        write_unlock(&adapter->erp_lock);
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+        write_unlock_irqrestore(&adapter->erp_lock, flags);
         retval = zfcp_erp_strategy_do_action(erp_action);
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
-        write_lock(&adapter->erp_lock);
+        write_lock_irqsave(&adapter->erp_lock, flags);
 
         if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
                 retval = ZFCP_ERP_CONTINUES;
@@ -1273,12 +1282,12 @@ static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
                 zfcp_erp_strategy_followup_failed(erp_action);
 
  unlock:
-        write_unlock(&adapter->erp_lock);
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+        write_unlock_irqrestore(&adapter->erp_lock, flags);
 
         if (retval != ZFCP_ERP_CONTINUES)
                 zfcp_erp_action_cleanup(erp_action, retval);
 
+        kref_put(&adapter->ref, zfcp_adapter_release);
         return retval;
 }
 
@@ -1415,6 +1424,7 @@ void zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter, char *id,
                                     void *ref, u32 mask, int set_or_clear)
 {
         struct zfcp_port *port;
+        unsigned long flags;
         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
 
         if (set_or_clear == ZFCP_SET) {
@@ -1429,10 +1439,13 @@ void zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter, char *id,
                         atomic_set(&adapter->erp_counter, 0);
         }
 
-        if (common_mask)
-                list_for_each_entry(port, &adapter->port_list_head, list)
+        if (common_mask) {
+                read_lock_irqsave(&adapter->port_list_lock, flags);
+                list_for_each_entry(port, &adapter->port_list, list)
                         zfcp_erp_modify_port_status(port, id, ref, common_mask,
                                                     set_or_clear);
+                read_unlock_irqrestore(&adapter->port_list_lock, flags);
+        }
 }
 
 /**
@@ -1449,6 +1462,7 @@ void zfcp_erp_modify_port_status(struct zfcp_port *port, char *id, void *ref,
                                  u32 mask, int set_or_clear)
 {
         struct zfcp_unit *unit;
+        unsigned long flags;
         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
 
         if (set_or_clear == ZFCP_SET) {
@@ -1463,10 +1477,13 @@ void zfcp_erp_modify_port_status(struct zfcp_port *port, char *id, void *ref,
                         atomic_set(&port->erp_counter, 0);
         }
 
-        if (common_mask)
-                list_for_each_entry(unit, &port->unit_list_head, list)
+        if (common_mask) {
+                read_lock_irqsave(&port->unit_list_lock, flags);
+                list_for_each_entry(unit, &port->unit_list, list)
                         zfcp_erp_modify_unit_status(unit, id, ref, common_mask,
                                                     set_or_clear);
+                read_unlock_irqrestore(&port->unit_list_lock, flags);
+        }
 }
 
 /**
@@ -1502,12 +1519,8 @@ void zfcp_erp_modify_unit_status(struct zfcp_unit *unit, char *id, void *ref,
  */
 void zfcp_erp_port_boxed(struct zfcp_port *port, char *id, void *ref)
 {
-        unsigned long flags;
-
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
         zfcp_erp_modify_port_status(port, id, ref,
                                     ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET);
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
         zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
 }
 
@@ -1535,13 +1548,9 @@ void zfcp_erp_unit_boxed(struct zfcp_unit *unit, char *id, void *ref)
  */
 void zfcp_erp_port_access_denied(struct zfcp_port *port, char *id, void *ref)
 {
-        unsigned long flags;
-
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
         zfcp_erp_modify_port_status(port, id, ref,
                                     ZFCP_STATUS_COMMON_ERP_FAILED |
                                     ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 }
 
 /**
@@ -1574,12 +1583,15 @@ static void zfcp_erp_port_access_changed(struct zfcp_port *port, char *id,
                                          void *ref)
 {
         struct zfcp_unit *unit;
+        unsigned long flags;
         int status = atomic_read(&port->status);
 
         if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED |
                         ZFCP_STATUS_COMMON_ACCESS_BOXED))) {
-                list_for_each_entry(unit, &port->unit_list_head, list)
+                read_lock_irqsave(&port->unit_list_lock, flags);
+                list_for_each_entry(unit, &port->unit_list, list)
                                     zfcp_erp_unit_access_changed(unit, id, ref);
+                read_unlock_irqrestore(&port->unit_list_lock, flags);
                 return;
         }
 
@@ -1595,14 +1607,14 @@ static void zfcp_erp_port_access_changed(struct zfcp_port *port, char *id,
 void zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter, char *id,
                                      void *ref)
 {
-        struct zfcp_port *port;
         unsigned long flags;
+        struct zfcp_port *port;
 
         if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
                 return;
 
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
-        list_for_each_entry(port, &adapter->port_list_head, list)
+        read_lock_irqsave(&adapter->port_list_lock, flags);
+        list_for_each_entry(port, &adapter->port_list, list)
                 zfcp_erp_port_access_changed(port, id, ref);
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+        read_unlock_irqrestore(&adapter->port_list_lock, flags);
 }
diff --git a/drivers/s390/scsi/zfcp_ext.h b/drivers/s390/scsi/zfcp_ext.h
index b3f28deb4505..8786a79c7f8f 100644
--- a/drivers/s390/scsi/zfcp_ext.h
+++ b/drivers/s390/scsi/zfcp_ext.h
@@ -9,26 +9,30 @@
 #ifndef ZFCP_EXT_H
 #define ZFCP_EXT_H
 
+#include <linux/types.h>
+#include <scsi/fc/fc_els.h>
 #include "zfcp_def.h"
+#include "zfcp_fc.h"
 
 /* zfcp_aux.c */
 extern struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *, u64);
 extern struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *, u64);
-extern int zfcp_adapter_enqueue(struct ccw_device *);
-extern void zfcp_adapter_dequeue(struct zfcp_adapter *);
+extern struct zfcp_adapter *zfcp_adapter_enqueue(struct ccw_device *);
 extern struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *, u64, u32,
                                            u32);
-extern void zfcp_port_dequeue(struct zfcp_port *);
 extern struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *, u64);
-extern void zfcp_unit_dequeue(struct zfcp_unit *);
-extern int zfcp_reqlist_isempty(struct zfcp_adapter *);
 extern void zfcp_sg_free_table(struct scatterlist *, int);
 extern int zfcp_sg_setup_table(struct scatterlist *, int);
+extern void zfcp_device_unregister(struct device *,
+                                   const struct attribute_group *);
+extern void zfcp_adapter_release(struct kref *);
+extern void zfcp_adapter_unregister(struct zfcp_adapter *);
 
 /* zfcp_ccw.c */
-extern int zfcp_ccw_register(void);
 extern int zfcp_ccw_priv_sch(struct zfcp_adapter *);
 extern struct ccw_driver zfcp_ccw_driver;
+extern struct zfcp_adapter *zfcp_ccw_adapter_by_cdev(struct ccw_device *);
+extern void zfcp_ccw_adapter_put(struct zfcp_adapter *);
 
 /* zfcp_cfdc.c */
 extern struct miscdevice zfcp_cfdc_misc;
@@ -51,7 +55,7 @@ extern void _zfcp_dbf_hba_fsf_unsol(const char *, int level, struct zfcp_dbf *,
                                           struct fsf_status_read_buffer *);
 extern void zfcp_dbf_hba_qdio(struct zfcp_dbf *, unsigned int, int, int);
 extern void zfcp_dbf_hba_berr(struct zfcp_dbf *, struct zfcp_fsf_req *);
-extern void zfcp_dbf_san_ct_request(struct zfcp_fsf_req *);
+extern void zfcp_dbf_san_ct_request(struct zfcp_fsf_req *, u32);
 extern void zfcp_dbf_san_ct_response(struct zfcp_fsf_req *);
 extern void zfcp_dbf_san_els_request(struct zfcp_fsf_req *);
 extern void zfcp_dbf_san_els_response(struct zfcp_fsf_req *);
@@ -92,24 +96,23 @@ extern void zfcp_erp_adapter_access_changed(struct zfcp_adapter *, char *,
 extern void zfcp_erp_timeout_handler(unsigned long);
 
 /* zfcp_fc.c */
-extern int zfcp_fc_scan_ports(struct zfcp_adapter *);
-extern void _zfcp_fc_scan_ports_later(struct work_struct *);
+extern void zfcp_fc_scan_ports(struct work_struct *);
 extern void zfcp_fc_incoming_els(struct zfcp_fsf_req *);
 extern void zfcp_fc_port_did_lookup(struct work_struct *);
 extern void zfcp_fc_trigger_did_lookup(struct zfcp_port *);
-extern void zfcp_fc_plogi_evaluate(struct zfcp_port *, struct fsf_plogi *);
+extern void zfcp_fc_plogi_evaluate(struct zfcp_port *, struct fc_els_flogi *);
 extern void zfcp_fc_test_link(struct zfcp_port *);
 extern void zfcp_fc_link_test_work(struct work_struct *);
-extern void zfcp_fc_wka_ports_force_offline(struct zfcp_wka_ports *);
+extern void zfcp_fc_wka_ports_force_offline(struct zfcp_fc_wka_ports *);
 extern int zfcp_fc_gs_setup(struct zfcp_adapter *);
 extern void zfcp_fc_gs_destroy(struct zfcp_adapter *);
-extern int zfcp_fc_execute_els_fc_job(struct fc_bsg_job *);
-extern int zfcp_fc_execute_ct_fc_job(struct fc_bsg_job *);
+extern int zfcp_fc_exec_bsg_job(struct fc_bsg_job *);
+extern int zfcp_fc_timeout_bsg_job(struct fc_bsg_job *);
 
 /* zfcp_fsf.c */
 extern int zfcp_fsf_open_port(struct zfcp_erp_action *);
-extern int zfcp_fsf_open_wka_port(struct zfcp_wka_port *);
-extern int zfcp_fsf_close_wka_port(struct zfcp_wka_port *);
+extern int zfcp_fsf_open_wka_port(struct zfcp_fc_wka_port *);
+extern int zfcp_fsf_close_wka_port(struct zfcp_fc_wka_port *);
 extern int zfcp_fsf_close_port(struct zfcp_erp_action *);
 extern int zfcp_fsf_close_physical_port(struct zfcp_erp_action *);
 extern int zfcp_fsf_open_unit(struct zfcp_erp_action *);
@@ -125,8 +128,10 @@ extern struct zfcp_fsf_req *zfcp_fsf_control_file(struct zfcp_adapter *,
 extern void zfcp_fsf_req_dismiss_all(struct zfcp_adapter *);
 extern int zfcp_fsf_status_read(struct zfcp_qdio *);
 extern int zfcp_status_read_refill(struct zfcp_adapter *adapter);
-extern int zfcp_fsf_send_ct(struct zfcp_send_ct *, mempool_t *);
-extern int zfcp_fsf_send_els(struct zfcp_send_els *);
+extern int zfcp_fsf_send_ct(struct zfcp_fc_wka_port *, struct zfcp_fsf_ct_els *,
+                            mempool_t *, unsigned int);
+extern int zfcp_fsf_send_els(struct zfcp_adapter *, u32,
+                             struct zfcp_fsf_ct_els *, unsigned int);
 extern int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *,
                                           struct scsi_cmnd *);
 extern void zfcp_fsf_req_free(struct zfcp_fsf_req *);
@@ -138,13 +143,9 @@ extern void zfcp_fsf_reqid_check(struct zfcp_qdio *, int);
 /* zfcp_qdio.c */
 extern int zfcp_qdio_setup(struct zfcp_adapter *);
 extern void zfcp_qdio_destroy(struct zfcp_qdio *);
-extern int zfcp_qdio_send(struct zfcp_qdio *, struct zfcp_queue_req *);
-extern struct qdio_buffer_element
-        *zfcp_qdio_sbale_req(struct zfcp_qdio *, struct zfcp_queue_req *);
-extern struct qdio_buffer_element
-        *zfcp_qdio_sbale_curr(struct zfcp_qdio *, struct zfcp_queue_req *);
+extern int zfcp_qdio_send(struct zfcp_qdio *, struct zfcp_qdio_req *);
 extern int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *,
-                                   struct zfcp_queue_req *, unsigned long,
+                                   struct zfcp_qdio_req *, unsigned long,
                                    struct scatterlist *, int);
 extern int zfcp_qdio_open(struct zfcp_qdio *);
 extern void zfcp_qdio_close(struct zfcp_qdio *);
@@ -153,7 +154,6 @@ extern void zfcp_qdio_close(struct zfcp_qdio *);
 extern struct zfcp_data zfcp_data;
 extern int zfcp_adapter_scsi_register(struct zfcp_adapter *);
 extern void zfcp_adapter_scsi_unregister(struct zfcp_adapter *);
-extern char *zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *);
 extern struct fc_function_template zfcp_transport_functions;
 extern void zfcp_scsi_rport_work(struct work_struct *);
 extern void zfcp_scsi_schedule_rport_register(struct zfcp_port *);
diff --git a/drivers/s390/scsi/zfcp_fc.c b/drivers/s390/scsi/zfcp_fc.c
index df23bcead23d..2a1cbb74b99b 100644
--- a/drivers/s390/scsi/zfcp_fc.c
+++ b/drivers/s390/scsi/zfcp_fc.c
@@ -3,79 +3,45 @@
  *
  * Fibre Channel related functions for the zfcp device driver.
  *
- * Copyright IBM Corporation 2008, 2009
+ * Copyright IBM Corporation 2008, 2010
  */
 
 #define KMSG_COMPONENT "zfcp"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <scsi/fc/fc_els.h>
+#include <scsi/libfc.h>
 #include "zfcp_ext.h"
+#include "zfcp_fc.h"
 
-enum rscn_address_format {
-        RSCN_PORT_ADDRESS       = 0x0,
-        RSCN_AREA_ADDRESS       = 0x1,
-        RSCN_DOMAIN_ADDRESS     = 0x2,
-        RSCN_FABRIC_ADDRESS     = 0x3,
+static u32 zfcp_fc_rscn_range_mask[] = {
+        [ELS_ADDR_FMT_PORT]             = 0xFFFFFF,
+        [ELS_ADDR_FMT_AREA]             = 0xFFFF00,
+        [ELS_ADDR_FMT_DOM]              = 0xFF0000,
+        [ELS_ADDR_FMT_FAB]              = 0x000000,
 };
 
-static u32 rscn_range_mask[] = {
-        [RSCN_PORT_ADDRESS]             = 0xFFFFFF,
-        [RSCN_AREA_ADDRESS]             = 0xFFFF00,
-        [RSCN_DOMAIN_ADDRESS]           = 0xFF0000,
-        [RSCN_FABRIC_ADDRESS]           = 0x000000,
-};
-
-struct gpn_ft_resp_acc {
-        u8 control;
-        u8 port_id[3];
-        u8 reserved[4];
-        u64 wwpn;
-} __attribute__ ((packed));
-
-#define ZFCP_CT_SIZE_ONE_PAGE   (PAGE_SIZE - sizeof(struct ct_hdr))
-#define ZFCP_GPN_FT_ENTRIES     (ZFCP_CT_SIZE_ONE_PAGE \
-                                        / sizeof(struct gpn_ft_resp_acc))
-#define ZFCP_GPN_FT_BUFFERS 4
-#define ZFCP_GPN_FT_MAX_SIZE (ZFCP_GPN_FT_BUFFERS * PAGE_SIZE \
-                                - sizeof(struct ct_hdr))
-#define ZFCP_GPN_FT_MAX_ENTRIES ZFCP_GPN_FT_BUFFERS * (ZFCP_GPN_FT_ENTRIES + 1)
-
-struct ct_iu_gpn_ft_resp {
-        struct ct_hdr header;
-        struct gpn_ft_resp_acc accept[ZFCP_GPN_FT_ENTRIES];
-} __attribute__ ((packed));
-
-struct zfcp_gpn_ft {
-        struct zfcp_send_ct ct;
-        struct scatterlist sg_req;
-        struct scatterlist sg_resp[ZFCP_GPN_FT_BUFFERS];
-};
-
-struct zfcp_fc_ns_handler_data {
-        struct completion done;
-        void (*handler)(unsigned long);
-        unsigned long handler_data;
-};
-
-static int zfcp_fc_wka_port_get(struct zfcp_wka_port *wka_port)
+static int zfcp_fc_wka_port_get(struct zfcp_fc_wka_port *wka_port)
 {
         if (mutex_lock_interruptible(&wka_port->mutex))
                 return -ERESTARTSYS;
 
-        if (wka_port->status == ZFCP_WKA_PORT_OFFLINE ||
-            wka_port->status == ZFCP_WKA_PORT_CLOSING) {
-                wka_port->status = ZFCP_WKA_PORT_OPENING;
+        if (wka_port->status == ZFCP_FC_WKA_PORT_OFFLINE ||
+            wka_port->status == ZFCP_FC_WKA_PORT_CLOSING) {
+                wka_port->status = ZFCP_FC_WKA_PORT_OPENING;
                 if (zfcp_fsf_open_wka_port(wka_port))
-                        wka_port->status = ZFCP_WKA_PORT_OFFLINE;
+                        wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
         }
 
         mutex_unlock(&wka_port->mutex);
 
         wait_event(wka_port->completion_wq,
-                   wka_port->status == ZFCP_WKA_PORT_ONLINE ||
-                   wka_port->status == ZFCP_WKA_PORT_OFFLINE);
+                   wka_port->status == ZFCP_FC_WKA_PORT_ONLINE ||
+                   wka_port->status == ZFCP_FC_WKA_PORT_OFFLINE);
 
-        if (wka_port->status == ZFCP_WKA_PORT_ONLINE) {
+        if (wka_port->status == ZFCP_FC_WKA_PORT_ONLINE) {
                 atomic_inc(&wka_port->refcount);
                 return 0;
         }
@@ -85,24 +51,24 @@ static int zfcp_fc_wka_port_get(struct zfcp_wka_port *wka_port)
 static void zfcp_fc_wka_port_offline(struct work_struct *work)
 {
         struct delayed_work *dw = to_delayed_work(work);
-        struct zfcp_wka_port *wka_port =
-                        container_of(dw, struct zfcp_wka_port, work);
+        struct zfcp_fc_wka_port *wka_port =
+                        container_of(dw, struct zfcp_fc_wka_port, work);
 
         mutex_lock(&wka_port->mutex);
         if ((atomic_read(&wka_port->refcount) != 0) ||
-            (wka_port->status != ZFCP_WKA_PORT_ONLINE))
+            (wka_port->status != ZFCP_FC_WKA_PORT_ONLINE))
                 goto out;
 
-        wka_port->status = ZFCP_WKA_PORT_CLOSING;
+        wka_port->status = ZFCP_FC_WKA_PORT_CLOSING;
         if (zfcp_fsf_close_wka_port(wka_port)) {
-                wka_port->status = ZFCP_WKA_PORT_OFFLINE;
+                wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
                 wake_up(&wka_port->completion_wq);
         }
 out:
         mutex_unlock(&wka_port->mutex);
 }
 
-static void zfcp_fc_wka_port_put(struct zfcp_wka_port *wka_port)
+static void zfcp_fc_wka_port_put(struct zfcp_fc_wka_port *wka_port)
 {
         if (atomic_dec_return(&wka_port->refcount) != 0)
                 return;
@@ -110,7 +76,7 @@ static void zfcp_fc_wka_port_put(struct zfcp_wka_port *wka_port)
         schedule_delayed_work(&wka_port->work, HZ / 100);
 }
 
-static void zfcp_fc_wka_port_init(struct zfcp_wka_port *wka_port, u32 d_id,
+static void zfcp_fc_wka_port_init(struct zfcp_fc_wka_port *wka_port, u32 d_id,
                                   struct zfcp_adapter *adapter)
 {
         init_waitqueue_head(&wka_port->completion_wq);
@@ -118,107 +84,107 @@ static void zfcp_fc_wka_port_init(struct zfcp_wka_port *wka_port, u32 d_id,
         wka_port->adapter = adapter;
         wka_port->d_id = d_id;
 
-        wka_port->status = ZFCP_WKA_PORT_OFFLINE;
+        wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
         atomic_set(&wka_port->refcount, 0);
         mutex_init(&wka_port->mutex);
         INIT_DELAYED_WORK(&wka_port->work, zfcp_fc_wka_port_offline);
 }
 
-static void zfcp_fc_wka_port_force_offline(struct zfcp_wka_port *wka)
+static void zfcp_fc_wka_port_force_offline(struct zfcp_fc_wka_port *wka)
 {
         cancel_delayed_work_sync(&wka->work);
         mutex_lock(&wka->mutex);
-        wka->status = ZFCP_WKA_PORT_OFFLINE;
+        wka->status = ZFCP_FC_WKA_PORT_OFFLINE;
         mutex_unlock(&wka->mutex);
 }
 
-void zfcp_fc_wka_ports_force_offline(struct zfcp_wka_ports *gs)
+void zfcp_fc_wka_ports_force_offline(struct zfcp_fc_wka_ports *gs)
 {
+        if (!gs)
+                return;
         zfcp_fc_wka_port_force_offline(&gs->ms);
         zfcp_fc_wka_port_force_offline(&gs->ts);
         zfcp_fc_wka_port_force_offline(&gs->ds);
         zfcp_fc_wka_port_force_offline(&gs->as);
-        zfcp_fc_wka_port_force_offline(&gs->ks);
 }
 
 static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req, u32 range,
-                                   struct fcp_rscn_element *elem)
+                                   struct fc_els_rscn_page *page)
 {
         unsigned long flags;
+        struct zfcp_adapter *adapter = fsf_req->adapter;
         struct zfcp_port *port;
 
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
-        list_for_each_entry(port, &fsf_req->adapter->port_list_head, list) {
-                if ((port->d_id & range) == (elem->nport_did & range))
+        read_lock_irqsave(&adapter->port_list_lock, flags);
+        list_for_each_entry(port, &adapter->port_list, list) {
+                if ((port->d_id & range) == (ntoh24(page->rscn_fid) & range))
                         zfcp_fc_test_link(port);
                 if (!port->d_id)
                         zfcp_erp_port_reopen(port,
                                              ZFCP_STATUS_COMMON_ERP_FAILED,
                                              "fcrscn1", NULL);
         }
-
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+        read_unlock_irqrestore(&adapter->port_list_lock, flags);
 }
 
 static void zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req)
 {
         struct fsf_status_read_buffer *status_buffer = (void *)fsf_req->data;
-        struct fcp_rscn_head *fcp_rscn_head;
-        struct fcp_rscn_element *fcp_rscn_element;
+        struct fc_els_rscn *head;
+        struct fc_els_rscn_page *page;
         u16 i;
         u16 no_entries;
-        u32 range_mask;
+        unsigned int afmt;
 
-        fcp_rscn_head = (struct fcp_rscn_head *) status_buffer->payload.data;
-        fcp_rscn_element = (struct fcp_rscn_element *) fcp_rscn_head;
+        head = (struct fc_els_rscn *) status_buffer->payload.data;
+        page = (struct fc_els_rscn_page *) head;
 
         /* see FC-FS */
-        no_entries = fcp_rscn_head->payload_len /
-                        sizeof(struct fcp_rscn_element);
+        no_entries = head->rscn_plen / sizeof(struct fc_els_rscn_page);
 
         for (i = 1; i < no_entries; i++) {
                 /* skip head and start with 1st element */
-                fcp_rscn_element++;
-                range_mask = rscn_range_mask[fcp_rscn_element->addr_format];
-                _zfcp_fc_incoming_rscn(fsf_req, range_mask, fcp_rscn_element);
+                page++;
+                afmt = page->rscn_page_flags & ELS_RSCN_ADDR_FMT_MASK;
+                _zfcp_fc_incoming_rscn(fsf_req, zfcp_fc_rscn_range_mask[afmt],
+                                       page);
         }
-        schedule_work(&fsf_req->adapter->scan_work);
+        queue_work(fsf_req->adapter->work_queue, &fsf_req->adapter->scan_work);
 }
 
 static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req *req, u64 wwpn)
 {
+        unsigned long flags;
         struct zfcp_adapter *adapter = req->adapter;
         struct zfcp_port *port;
-        unsigned long flags;
 
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
-        list_for_each_entry(port, &adapter->port_list_head, list)
-                if (port->wwpn == wwpn)
+        read_lock_irqsave(&adapter->port_list_lock, flags);
+        list_for_each_entry(port, &adapter->port_list, list)
+                if (port->wwpn == wwpn) {
+                        zfcp_erp_port_forced_reopen(port, 0, "fciwwp1", req);
                         break;
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
-
-        if (port && (port->wwpn == wwpn))
-                zfcp_erp_port_forced_reopen(port, 0, "fciwwp1", req);
+                }
+        read_unlock_irqrestore(&adapter->port_list_lock, flags);
 }
 
 static void zfcp_fc_incoming_plogi(struct zfcp_fsf_req *req)
 {
-        struct fsf_status_read_buffer *status_buffer =
-                (struct fsf_status_read_buffer *)req->data;
-        struct fsf_plogi *els_plogi =
-                (struct fsf_plogi *) status_buffer->payload.data;
+        struct fsf_status_read_buffer *status_buffer;
+        struct fc_els_flogi *plogi;
 
-        zfcp_fc_incoming_wwpn(req, els_plogi->serv_param.wwpn);
+        status_buffer = (struct fsf_status_read_buffer *) req->data;
+        plogi = (struct fc_els_flogi *) status_buffer->payload.data;
+        zfcp_fc_incoming_wwpn(req, plogi->fl_wwpn);
 }
 
 static void zfcp_fc_incoming_logo(struct zfcp_fsf_req *req)
 {
         struct fsf_status_read_buffer *status_buffer =
                 (struct fsf_status_read_buffer *)req->data;
-        struct fcp_logo *els_logo =
-                (struct fcp_logo *) status_buffer->payload.data;
+        struct fc_els_logo *logo =
+                (struct fc_els_logo *) status_buffer->payload.data;
 
-        zfcp_fc_incoming_wwpn(req, els_logo->nport_wwpn);
+        zfcp_fc_incoming_wwpn(req, logo->fl_n_port_wwn);
 }
 
 /**
@@ -232,79 +198,73 @@ void zfcp_fc_incoming_els(struct zfcp_fsf_req *fsf_req)
         unsigned int els_type = status_buffer->payload.data[0];
 
         zfcp_dbf_san_incoming_els(fsf_req);
-        if (els_type == LS_PLOGI)
+        if (els_type == ELS_PLOGI)
                 zfcp_fc_incoming_plogi(fsf_req);
-        else if (els_type == LS_LOGO)
+        else if (els_type == ELS_LOGO)
                 zfcp_fc_incoming_logo(fsf_req);
-        else if (els_type == LS_RSCN)
+        else if (els_type == ELS_RSCN)
                 zfcp_fc_incoming_rscn(fsf_req);
 }
 
-static void zfcp_fc_ns_handler(unsigned long data)
+static void zfcp_fc_ns_gid_pn_eval(void *data)
 {
-        struct zfcp_fc_ns_handler_data *compl_rec =
-                        (struct zfcp_fc_ns_handler_data *) data;
-
-        if (compl_rec->handler)
-                compl_rec->handler(compl_rec->handler_data);
-
-        complete(&compl_rec->done);
-}
-
-static void zfcp_fc_ns_gid_pn_eval(unsigned long data)
-{
-        struct zfcp_gid_pn_data *gid_pn = (struct zfcp_gid_pn_data *) data;
-        struct zfcp_send_ct *ct = &gid_pn->ct;
-        struct ct_iu_gid_pn_req *ct_iu_req = sg_virt(ct->req);
-        struct ct_iu_gid_pn_resp *ct_iu_resp = sg_virt(ct->resp);
+        struct zfcp_fc_gid_pn *gid_pn = data;
+        struct zfcp_fsf_ct_els *ct = &gid_pn->ct;
+        struct zfcp_fc_gid_pn_req *gid_pn_req = sg_virt(ct->req);
+        struct zfcp_fc_gid_pn_resp *gid_pn_resp = sg_virt(ct->resp);
         struct zfcp_port *port = gid_pn->port;
 
         if (ct->status)
                 return;
-        if (ct_iu_resp->header.cmd_rsp_code != ZFCP_CT_ACCEPT)
+        if (gid_pn_resp->ct_hdr.ct_cmd != FC_FS_ACC)
                 return;
 
         /* paranoia */
-        if (ct_iu_req->wwpn != port->wwpn)
+        if (gid_pn_req->gid_pn.fn_wwpn != port->wwpn)
                 return;
         /* looks like a valid d_id */
-        port->d_id = ct_iu_resp->d_id & ZFCP_DID_MASK;
+        port->d_id = ntoh24(gid_pn_resp->gid_pn.fp_fid);
+}
+
+static void zfcp_fc_complete(void *data)
+{
+        complete(data);
 }
 
 static int zfcp_fc_ns_gid_pn_request(struct zfcp_port *port,
-                                     struct zfcp_gid_pn_data *gid_pn)
+                                     struct zfcp_fc_gid_pn *gid_pn)
 {
         struct zfcp_adapter *adapter = port->adapter;
-        struct zfcp_fc_ns_handler_data compl_rec;
+        DECLARE_COMPLETION_ONSTACK(completion);
         int ret;
 
         /* setup parameters for send generic command */
         gid_pn->port = port;
-        gid_pn->ct.wka_port = &adapter->gs->ds;
-        gid_pn->ct.handler = zfcp_fc_ns_handler;
-        gid_pn->ct.handler_data = (unsigned long) &compl_rec;
-        gid_pn->ct.req = &gid_pn->req;
-        gid_pn->ct.resp = &gid_pn->resp;
-        sg_init_one(&gid_pn->req, &gid_pn->ct_iu_req,
-                    sizeof(struct ct_iu_gid_pn_req));
-        sg_init_one(&gid_pn->resp, &gid_pn->ct_iu_resp,
-                    sizeof(struct ct_iu_gid_pn_resp));
+        gid_pn->ct.handler = zfcp_fc_complete;
+        gid_pn->ct.handler_data = &completion;
+        gid_pn->ct.req = &gid_pn->sg_req;
+        gid_pn->ct.resp = &gid_pn->sg_resp;
+        sg_init_one(&gid_pn->sg_req, &gid_pn->gid_pn_req,
+                    sizeof(struct zfcp_fc_gid_pn_req));
+        sg_init_one(&gid_pn->sg_resp, &gid_pn->gid_pn_resp,
+                    sizeof(struct zfcp_fc_gid_pn_resp));
 
         /* setup nameserver request */
-        gid_pn->ct_iu_req.header.revision = ZFCP_CT_REVISION;
-        gid_pn->ct_iu_req.header.gs_type = ZFCP_CT_DIRECTORY_SERVICE;
-        gid_pn->ct_iu_req.header.gs_subtype = ZFCP_CT_NAME_SERVER;
-        gid_pn->ct_iu_req.header.options = ZFCP_CT_SYNCHRONOUS;
-        gid_pn->ct_iu_req.header.cmd_rsp_code = ZFCP_CT_GID_PN;
-        gid_pn->ct_iu_req.header.max_res_size = ZFCP_CT_SIZE_ONE_PAGE / 4;
-        gid_pn->ct_iu_req.wwpn = port->wwpn;
-
-        init_completion(&compl_rec.done);
-        compl_rec.handler = zfcp_fc_ns_gid_pn_eval;
-        compl_rec.handler_data = (unsigned long) gid_pn;
-        ret = zfcp_fsf_send_ct(&gid_pn->ct, adapter->pool.gid_pn_req);
-        if (!ret)
-                wait_for_completion(&compl_rec.done);
+        gid_pn->gid_pn_req.ct_hdr.ct_rev = FC_CT_REV;
+        gid_pn->gid_pn_req.ct_hdr.ct_fs_type = FC_FST_DIR;
+        gid_pn->gid_pn_req.ct_hdr.ct_fs_subtype = FC_NS_SUBTYPE;
+        gid_pn->gid_pn_req.ct_hdr.ct_options = 0;
+        gid_pn->gid_pn_req.ct_hdr.ct_cmd = FC_NS_GID_PN;
+        gid_pn->gid_pn_req.ct_hdr.ct_mr_size = ZFCP_FC_CT_SIZE_PAGE / 4;
+        gid_pn->gid_pn_req.gid_pn.fn_wwpn = port->wwpn;
+
+        ret = zfcp_fsf_send_ct(&adapter->gs->ds, &gid_pn->ct,
+                               adapter->pool.gid_pn_req,
+                               ZFCP_FC_CTELS_TMO);
+        if (!ret) {
+                wait_for_completion(&completion);
+                zfcp_fc_ns_gid_pn_eval(gid_pn);
+        }
         return ret;
 }
 
@@ -316,10 +276,10 @@ static int zfcp_fc_ns_gid_pn_request(struct zfcp_port *port,
 static int zfcp_fc_ns_gid_pn(struct zfcp_port *port)
 {
         int ret;
-        struct zfcp_gid_pn_data *gid_pn;
+        struct zfcp_fc_gid_pn *gid_pn;
         struct zfcp_adapter *adapter = port->adapter;
 
-        gid_pn = mempool_alloc(adapter->pool.gid_pn_data, GFP_ATOMIC);
+        gid_pn = mempool_alloc(adapter->pool.gid_pn, GFP_ATOMIC);
         if (!gid_pn)
                 return -ENOMEM;
 
@@ -333,7 +293,7 @@ static int zfcp_fc_ns_gid_pn(struct zfcp_port *port)
 
         zfcp_fc_wka_port_put(&adapter->gs->ds);
 out:
-        mempool_free(gid_pn, adapter->pool.gid_pn_data);
+        mempool_free(gid_pn, adapter->pool.gid_pn);
         return ret;
 }
 
@@ -357,7 +317,7 @@ void zfcp_fc_port_did_lookup(struct work_struct *work)
 
         zfcp_erp_port_reopen(port, 0, "fcgpn_3", NULL);
 out:
-        zfcp_port_put(port);
+        put_device(&port->dev);
 }
 
 /**
@@ -366,9 +326,9 @@ out:
  */
 void zfcp_fc_trigger_did_lookup(struct zfcp_port *port)
 {
-        zfcp_port_get(port);
+        get_device(&port->dev);
         if (!queue_work(port->adapter->work_queue, &port->gid_pn_work))
-                zfcp_port_put(port);
+                put_device(&port->dev);
 }
 
 /**
@@ -378,33 +338,36 @@ void zfcp_fc_trigger_did_lookup(struct zfcp_port *port)
  *
  * Evaluate PLOGI playload and copy important fields into zfcp_port structure
  */
-void zfcp_fc_plogi_evaluate(struct zfcp_port *port, struct fsf_plogi *plogi)
-{
-        port->maxframe_size = plogi->serv_param.common_serv_param[7] |
-                ((plogi->serv_param.common_serv_param[6] & 0x0F) << 8);
-        if (plogi->serv_param.class1_serv_param[0] & 0x80)
+void zfcp_fc_plogi_evaluate(struct zfcp_port *port, struct fc_els_flogi *plogi)
+{
+        if (plogi->fl_wwpn != port->wwpn) {
+                port->d_id = 0;
+                dev_warn(&port->adapter->ccw_device->dev,
+                         "A port opened with WWPN 0x%016Lx returned data that "
+                         "identifies it as WWPN 0x%016Lx\n",
+                         (unsigned long long) port->wwpn,
+                         (unsigned long long) plogi->fl_wwpn);
+                return;
+        }
+
+        port->wwnn = plogi->fl_wwnn;
+        port->maxframe_size = plogi->fl_csp.sp_bb_data;
+
+        if (plogi->fl_cssp[0].cp_class & FC_CPC_VALID)
                 port->supported_classes |= FC_COS_CLASS1;
-        if (plogi->serv_param.class2_serv_param[0] & 0x80)
+        if (plogi->fl_cssp[1].cp_class & FC_CPC_VALID)
                 port->supported_classes |= FC_COS_CLASS2;
-        if (plogi->serv_param.class3_serv_param[0] & 0x80)
+        if (plogi->fl_cssp[2].cp_class & FC_CPC_VALID)
                 port->supported_classes |= FC_COS_CLASS3;
-        if (plogi->serv_param.class4_serv_param[0] & 0x80)
+        if (plogi->fl_cssp[3].cp_class & FC_CPC_VALID)
                 port->supported_classes |= FC_COS_CLASS4;
 }
 
-struct zfcp_els_adisc {
-        struct zfcp_send_els els;
-        struct scatterlist req;
-        struct scatterlist resp;
-        struct zfcp_ls_adisc ls_adisc;
-        struct zfcp_ls_adisc ls_adisc_acc;
-};
-
-static void zfcp_fc_adisc_handler(unsigned long data)
+static void zfcp_fc_adisc_handler(void *data)
 {
-        struct zfcp_els_adisc *adisc = (struct zfcp_els_adisc *) data;
+        struct zfcp_fc_els_adisc *adisc = data;
         struct zfcp_port *port = adisc->els.port;
-        struct zfcp_ls_adisc *ls_adisc = &adisc->ls_adisc_acc;
+        struct fc_els_adisc *adisc_resp = &adisc->adisc_resp;
 
         if (adisc->els.status) {
                 /* request rejected or timed out */
@@ -414,9 +377,9 @@ static void zfcp_fc_adisc_handler(unsigned long data)
         }
 
         if (!port->wwnn)
-                port->wwnn = ls_adisc->wwnn;
+                port->wwnn = adisc_resp->adisc_wwnn;
 
-        if ((port->wwpn != ls_adisc->wwpn) ||
+        if ((port->wwpn != adisc_resp->adisc_wwpn) ||
             !(atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)) {
                 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
                                      "fcadh_2", NULL);
@@ -427,40 +390,45 @@ static void zfcp_fc_adisc_handler(unsigned long data)
         zfcp_scsi_schedule_rport_register(port);
  out:
         atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status);
-        zfcp_port_put(port);
-        kfree(adisc);
+        put_device(&port->dev);
+        kmem_cache_free(zfcp_data.adisc_cache, adisc);
 }
 
 static int zfcp_fc_adisc(struct zfcp_port *port)
 {
-        struct zfcp_els_adisc *adisc;
+        struct zfcp_fc_els_adisc *adisc;
         struct zfcp_adapter *adapter = port->adapter;
+        int ret;
 
-        adisc = kzalloc(sizeof(struct zfcp_els_adisc), GFP_ATOMIC);
+        adisc = kmem_cache_alloc(zfcp_data.adisc_cache, GFP_ATOMIC);
         if (!adisc)
                 return -ENOMEM;
 
+        adisc->els.port = port;
         adisc->els.req = &adisc->req;
         adisc->els.resp = &adisc->resp;
-        sg_init_one(adisc->els.req, &adisc->ls_adisc,
-                    sizeof(struct zfcp_ls_adisc));
-        sg_init_one(adisc->els.resp, &adisc->ls_adisc_acc,
-                    sizeof(struct zfcp_ls_adisc));
+        sg_init_one(adisc->els.req, &adisc->adisc_req,
+                    sizeof(struct fc_els_adisc));
+        sg_init_one(adisc->els.resp, &adisc->adisc_resp,
+                    sizeof(struct fc_els_adisc));
 
-        adisc->els.adapter = adapter;
-        adisc->els.port = port;
-        adisc->els.d_id = port->d_id;
         adisc->els.handler = zfcp_fc_adisc_handler;
-        adisc->els.handler_data = (unsigned long) adisc;
-        adisc->els.ls_code = adisc->ls_adisc.code = ZFCP_LS_ADISC;
+        adisc->els.handler_data = adisc;
 
         /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports
            without FC-AL-2 capability, so we don't set it */
-        adisc->ls_adisc.wwpn = fc_host_port_name(adapter->scsi_host);
-        adisc->ls_adisc.wwnn = fc_host_node_name(adapter->scsi_host);
-        adisc->ls_adisc.nport_id = fc_host_port_id(adapter->scsi_host);
+        adisc->adisc_req.adisc_wwpn = fc_host_port_name(adapter->scsi_host);
+        adisc->adisc_req.adisc_wwnn = fc_host_node_name(adapter->scsi_host);
+        adisc->adisc_req.adisc_cmd = ELS_ADISC;
+        hton24(adisc->adisc_req.adisc_port_id,
+               fc_host_port_id(adapter->scsi_host));
+
+        ret = zfcp_fsf_send_els(adapter, port->d_id, &adisc->els,
+                                ZFCP_FC_CTELS_TMO);
+        if (ret)
+                kmem_cache_free(zfcp_data.adisc_cache, adisc);
 
-        return zfcp_fsf_send_els(&adisc->els);
+        return ret;
 }
 
 void zfcp_fc_link_test_work(struct work_struct *work)
@@ -469,7 +437,7 @@ void zfcp_fc_link_test_work(struct work_struct *work)
                 container_of(work, struct zfcp_port, test_link_work);
         int retval;
 
-        zfcp_port_get(port);
+        get_device(&port->dev);
         port->rport_task = RPORT_DEL;
         zfcp_scsi_rport_work(&port->rport_work);
 
@@ -488,7 +456,7 @@ void zfcp_fc_link_test_work(struct work_struct *work)
         zfcp_erp_port_forced_reopen(port, 0, "fcltwk1", NULL);
 
 out:
-        zfcp_port_put(port);
+        put_device(&port->dev);
 }
 
 /**
@@ -501,12 +469,12 @@ out:
  */
 void zfcp_fc_test_link(struct zfcp_port *port)
 {
-        zfcp_port_get(port);
+        get_device(&port->dev);
         if (!queue_work(port->adapter->work_queue, &port->test_link_work))
-                zfcp_port_put(port);
+                put_device(&port->dev);
 }
 
-static void zfcp_free_sg_env(struct zfcp_gpn_ft *gpn_ft, int buf_num)
+static void zfcp_free_sg_env(struct zfcp_fc_gpn_ft *gpn_ft, int buf_num)
 {
         struct scatterlist *sg = &gpn_ft->sg_req;
 
@@ -516,10 +484,10 @@ static void zfcp_free_sg_env(struct zfcp_gpn_ft *gpn_ft, int buf_num)
         kfree(gpn_ft);
 }
 
-static struct zfcp_gpn_ft *zfcp_alloc_sg_env(int buf_num)
+static struct zfcp_fc_gpn_ft *zfcp_alloc_sg_env(int buf_num)
 {
-        struct zfcp_gpn_ft *gpn_ft;
-        struct ct_iu_gpn_ft_req *req;
+        struct zfcp_fc_gpn_ft *gpn_ft;
+        struct zfcp_fc_gpn_ft_req *req;
 
         gpn_ft = kzalloc(sizeof(*gpn_ft), GFP_KERNEL);
         if (!gpn_ft)
@@ -542,159 +510,152 @@ out:
 }
 
 
-static int zfcp_fc_send_gpn_ft(struct zfcp_gpn_ft *gpn_ft,
+static int zfcp_fc_send_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
                                struct zfcp_adapter *adapter, int max_bytes)
 {
-        struct zfcp_send_ct *ct = &gpn_ft->ct;
-        struct ct_iu_gpn_ft_req *req = sg_virt(&gpn_ft->sg_req);
-        struct zfcp_fc_ns_handler_data compl_rec;
+        struct zfcp_fsf_ct_els *ct = &gpn_ft->ct;
+        struct zfcp_fc_gpn_ft_req *req = sg_virt(&gpn_ft->sg_req);
+        DECLARE_COMPLETION_ONSTACK(completion);
         int ret;
 
         /* prepare CT IU for GPN_FT */
-        req->header.revision = ZFCP_CT_REVISION;
-        req->header.gs_type = ZFCP_CT_DIRECTORY_SERVICE;
-        req->header.gs_subtype = ZFCP_CT_NAME_SERVER;
-        req->header.options = ZFCP_CT_SYNCHRONOUS;
-        req->header.cmd_rsp_code = ZFCP_CT_GPN_FT;
-        req->header.max_res_size = max_bytes / 4;
-        req->flags = 0;
-        req->domain_id_scope = 0;
-        req->area_id_scope = 0;
-        req->fc4_type = ZFCP_CT_SCSI_FCP;
+        req->ct_hdr.ct_rev = FC_CT_REV;
+        req->ct_hdr.ct_fs_type = FC_FST_DIR;
+        req->ct_hdr.ct_fs_subtype = FC_NS_SUBTYPE;
+        req->ct_hdr.ct_options = 0;
+        req->ct_hdr.ct_cmd = FC_NS_GPN_FT;
+        req->ct_hdr.ct_mr_size = max_bytes / 4;
+        req->gpn_ft.fn_domain_id_scope = 0;
+        req->gpn_ft.fn_area_id_scope = 0;
+        req->gpn_ft.fn_fc4_type = FC_TYPE_FCP;
 
         /* prepare zfcp_send_ct */
-        ct->wka_port = &adapter->gs->ds;
-        ct->handler = zfcp_fc_ns_handler;
-        ct->handler_data = (unsigned long)&compl_rec;
+        ct->handler = zfcp_fc_complete;
+        ct->handler_data = &completion;
         ct->req = &gpn_ft->sg_req;
         ct->resp = gpn_ft->sg_resp;
 
-        init_completion(&compl_rec.done);
-        compl_rec.handler = NULL;
-        ret = zfcp_fsf_send_ct(ct, NULL);
+        ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct, NULL,
+                               ZFCP_FC_CTELS_TMO);
         if (!ret)
-                wait_for_completion(&compl_rec.done);
+                wait_for_completion(&completion);
         return ret;
 }
 
-static void zfcp_fc_validate_port(struct zfcp_port *port)
+static void zfcp_fc_validate_port(struct zfcp_port *port, struct list_head *lh)
 {
-        struct zfcp_adapter *adapter = port->adapter;
-
         if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC))
                 return;
 
         atomic_clear_mask(ZFCP_STATUS_COMMON_NOESC, &port->status);
 
         if ((port->supported_classes != 0) ||
-            !list_empty(&port->unit_list_head)) {
-                zfcp_port_put(port);
+            !list_empty(&port->unit_list))
                 return;
-        }
-        zfcp_erp_port_shutdown(port, 0, "fcpval1", NULL);
-        zfcp_erp_wait(adapter);
-        zfcp_port_put(port);
-        zfcp_port_dequeue(port);
+
+        list_move_tail(&port->list, lh);
 }
 
-static int zfcp_fc_eval_gpn_ft(struct zfcp_gpn_ft *gpn_ft, int max_entries)
+static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
+                               struct zfcp_adapter *adapter, int max_entries)
 {
-        struct zfcp_send_ct *ct = &gpn_ft->ct;
+        struct zfcp_fsf_ct_els *ct = &gpn_ft->ct;
         struct scatterlist *sg = gpn_ft->sg_resp;
-        struct ct_hdr *hdr = sg_virt(sg);
-        struct gpn_ft_resp_acc *acc = sg_virt(sg);
-        struct zfcp_adapter *adapter = ct->wka_port->adapter;
+        struct fc_ct_hdr *hdr = sg_virt(sg);
+        struct fc_gpn_ft_resp *acc = sg_virt(sg);
         struct zfcp_port *port, *tmp;
+        unsigned long flags;
+        LIST_HEAD(remove_lh);
         u32 d_id;
         int ret = 0, x, last = 0;
 
         if (ct->status)
                 return -EIO;
 
-        if (hdr->cmd_rsp_code != ZFCP_CT_ACCEPT) {
-                if (hdr->reason_code == ZFCP_CT_UNABLE_TO_PERFORM_CMD)
+        if (hdr->ct_cmd != FC_FS_ACC) {
+                if (hdr->ct_reason == FC_BA_RJT_UNABLE)
                         return -EAGAIN; /* might be a temporary condition */
                 return -EIO;
         }
 
-        if (hdr->max_res_size) {
+        if (hdr->ct_mr_size) {
                 dev_warn(&adapter->ccw_device->dev,
                          "The name server reported %d words residual data\n",
-                         hdr->max_res_size);
+                         hdr->ct_mr_size);
                 return -E2BIG;
         }
 
-        mutex_lock(&zfcp_data.config_mutex);
-
         /* first entry is the header */
         for (x = 1; x < max_entries && !last; x++) {
-                if (x % (ZFCP_GPN_FT_ENTRIES + 1))
+                if (x % (ZFCP_FC_GPN_FT_ENT_PAGE + 1))
                         acc++;
                 else
                         acc = sg_virt(++sg);
 
-                last = acc->control & 0x80;
-                d_id = acc->port_id[0] << 16 | acc->port_id[1] << 8 |
-                       acc->port_id[2];
+                last = acc->fp_flags & FC_NS_FID_LAST;
+                d_id = ntoh24(acc->fp_fid);
 
                 /* don't attach ports with a well known address */
-                if ((d_id & ZFCP_DID_WKA) == ZFCP_DID_WKA)
+                if (d_id >= FC_FID_WELL_KNOWN_BASE)
                         continue;
                 /* skip the adapter's port and known remote ports */
-                if (acc->wwpn == fc_host_port_name(adapter->scsi_host))
-                        continue;
-                port = zfcp_get_port_by_wwpn(adapter, acc->wwpn);
-                if (port)
+                if (acc->fp_wwpn == fc_host_port_name(adapter->scsi_host))
                         continue;
 
-                port = zfcp_port_enqueue(adapter, acc->wwpn,
+                port = zfcp_port_enqueue(adapter, acc->fp_wwpn,
                                          ZFCP_STATUS_COMMON_NOESC, d_id);
-                if (IS_ERR(port))
-                        ret = PTR_ERR(port);
-                else
+                if (!IS_ERR(port))
                         zfcp_erp_port_reopen(port, 0, "fcegpf1", NULL);
+                else if (PTR_ERR(port) != -EEXIST)
+                        ret = PTR_ERR(port);
         }
 
         zfcp_erp_wait(adapter);
-        list_for_each_entry_safe(port, tmp, &adapter->port_list_head, list)
-                zfcp_fc_validate_port(port);
-        mutex_unlock(&zfcp_data.config_mutex);
+        write_lock_irqsave(&adapter->port_list_lock, flags);
+        list_for_each_entry_safe(port, tmp, &adapter->port_list, list)
+                zfcp_fc_validate_port(port, &remove_lh);
+        write_unlock_irqrestore(&adapter->port_list_lock, flags);
+
+        list_for_each_entry_safe(port, tmp, &remove_lh, list) {
+                zfcp_erp_port_shutdown(port, 0, "fcegpf2", NULL);
+                zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs);
+        }
+
         return ret;
 }
 
 /**
  * zfcp_fc_scan_ports - scan remote ports and attach new ports
- * @adapter: pointer to struct zfcp_adapter
+ * @work: reference to scheduled work
  */
-int zfcp_fc_scan_ports(struct zfcp_adapter *adapter)
+void zfcp_fc_scan_ports(struct work_struct *work)
 {
+        struct zfcp_adapter *adapter = container_of(work, struct zfcp_adapter,
+                                                    scan_work);
         int ret, i;
-        struct zfcp_gpn_ft *gpn_ft;
+        struct zfcp_fc_gpn_ft *gpn_ft;
         int chain, max_entries, buf_num, max_bytes;
 
         chain = adapter->adapter_features & FSF_FEATURE_ELS_CT_CHAINED_SBALS;
-        buf_num = chain ? ZFCP_GPN_FT_BUFFERS : 1;
-        max_entries = chain ? ZFCP_GPN_FT_MAX_ENTRIES : ZFCP_GPN_FT_ENTRIES;
-        max_bytes = chain ? ZFCP_GPN_FT_MAX_SIZE : ZFCP_CT_SIZE_ONE_PAGE;
+        buf_num = chain ? ZFCP_FC_GPN_FT_NUM_BUFS : 1;
+        max_entries = chain ? ZFCP_FC_GPN_FT_MAX_ENT : ZFCP_FC_GPN_FT_ENT_PAGE;
+        max_bytes = chain ? ZFCP_FC_GPN_FT_MAX_SIZE : ZFCP_FC_CT_SIZE_PAGE;
 
         if (fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPORT &&
             fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPIV)
-                return 0;
+                return;
 
-        ret = zfcp_fc_wka_port_get(&adapter->gs->ds);
-        if (ret)
-                return ret;
+        if (zfcp_fc_wka_port_get(&adapter->gs->ds))
+                return;
 
         gpn_ft = zfcp_alloc_sg_env(buf_num);
-        if (!gpn_ft) {
-                ret = -ENOMEM;
+        if (!gpn_ft)
                 goto out;
-        }
 
         for (i = 0; i < 3; i++) {
                 ret = zfcp_fc_send_gpn_ft(gpn_ft, adapter, max_bytes);
                 if (!ret) {
-                        ret = zfcp_fc_eval_gpn_ft(gpn_ft, max_entries);
+                        ret = zfcp_fc_eval_gpn_ft(gpn_ft, adapter, max_entries);
                         if (ret == -EAGAIN)
                                 ssleep(1);
                         else
@@ -704,174 +665,142 @@ int zfcp_fc_scan_ports(struct zfcp_adapter *adapter)
         zfcp_free_sg_env(gpn_ft, buf_num);
 out:
         zfcp_fc_wka_port_put(&adapter->gs->ds);
-        return ret;
 }
 
-
-void _zfcp_fc_scan_ports_later(struct work_struct *work)
+static void zfcp_fc_ct_els_job_handler(void *data)
 {
-        zfcp_fc_scan_ports(container_of(work, struct zfcp_adapter, scan_work));
-}
+        struct fc_bsg_job *job = data;
+        struct zfcp_fsf_ct_els *zfcp_ct_els = job->dd_data;
+        struct fc_bsg_reply *jr = job->reply;
 
-struct zfcp_els_fc_job {
-        struct zfcp_send_els els;
-        struct fc_bsg_job *job;
-};
+        jr->reply_payload_rcv_len = job->reply_payload.payload_len;
+        jr->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
+        jr->result = zfcp_ct_els->status ? -EIO : 0;
+        job->job_done(job);
+}
 
-static void zfcp_fc_generic_els_handler(unsigned long data)
+static struct zfcp_fc_wka_port *zfcp_fc_job_wka_port(struct fc_bsg_job *job)
 {
-        struct zfcp_els_fc_job *els_fc_job = (struct zfcp_els_fc_job *) data;
-        struct fc_bsg_job *job = els_fc_job->job;
-        struct fc_bsg_reply *reply = job->reply;
+        u32 preamble_word1;
+        u8 gs_type;
+        struct zfcp_adapter *adapter;
 
-        if (els_fc_job->els.status) {
-                /* request rejected or timed out */
-                reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_REJECT;
-                goto out;
-        }
+        preamble_word1 = job->request->rqst_data.r_ct.preamble_word1;
+        gs_type = (preamble_word1 & 0xff000000) >> 24;
 
-        reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
-        reply->reply_payload_rcv_len = job->reply_payload.payload_len;
+        adapter = (struct zfcp_adapter *) job->shost->hostdata[0];
 
-out:
-        job->state_flags = FC_RQST_STATE_DONE;
-        job->job_done(job);
-        kfree(els_fc_job);
+        switch (gs_type) {
+        case FC_FST_ALIAS:
+                return &adapter->gs->as;
+        case FC_FST_MGMT:
+                return &adapter->gs->ms;
+        case FC_FST_TIME:
+                return &adapter->gs->ts;
+                break;
+        case FC_FST_DIR:
+                return &adapter->gs->ds;
+                break;
+        default:
+                return NULL;
+        }
 }
 
-int zfcp_fc_execute_els_fc_job(struct fc_bsg_job *job)
+static void zfcp_fc_ct_job_handler(void *data)
 {
-        struct zfcp_els_fc_job *els_fc_job;
-        struct fc_rport *rport = job->rport;
-        struct Scsi_Host *shost;
-        struct zfcp_adapter *adapter;
-        struct zfcp_port *port;
-        u8 *port_did;
+        struct fc_bsg_job *job = data;
+        struct zfcp_fc_wka_port *wka_port;
 
-        shost = rport ? rport_to_shost(rport) : job->shost;
-        adapter = (struct zfcp_adapter *)shost->hostdata[0];
+        wka_port = zfcp_fc_job_wka_port(job);
+        zfcp_fc_wka_port_put(wka_port);
 
-        if (!(atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN))
-                return -EINVAL;
+        zfcp_fc_ct_els_job_handler(data);
+}
 
-        els_fc_job = kzalloc(sizeof(struct zfcp_els_fc_job), GFP_KERNEL);
-        if (!els_fc_job)
-                return -ENOMEM;
+static int zfcp_fc_exec_els_job(struct fc_bsg_job *job,
+                                struct zfcp_adapter *adapter)
+{
+        struct zfcp_fsf_ct_els *els = job->dd_data;
+        struct fc_rport *rport = job->rport;
+        struct zfcp_port *port;
+        u32 d_id;
 
-        els_fc_job->els.adapter = adapter;
         if (rport) {
-                read_lock_irq(&zfcp_data.config_lock);
                 port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
-                if (port)
-                        els_fc_job->els.d_id = port->d_id;
-                read_unlock_irq(&zfcp_data.config_lock);
-                if (!port) {
-                        kfree(els_fc_job);
+                if (!port)
                         return -EINVAL;
-                }
-        } else {
-                port_did = job->request->rqst_data.h_els.port_id;
-                els_fc_job->els.d_id = (port_did[0] << 16) +
-                                        (port_did[1] << 8) + port_did[2];
-        }
 
-        els_fc_job->els.req = job->request_payload.sg_list;
-        els_fc_job->els.resp = job->reply_payload.sg_list;
-        els_fc_job->els.handler = zfcp_fc_generic_els_handler;
-        els_fc_job->els.handler_data = (unsigned long) els_fc_job;
-        els_fc_job->job = job;
+                d_id = port->d_id;
+                put_device(&port->dev);
+        } else
+                d_id = ntoh24(job->request->rqst_data.h_els.port_id);
 
-        return zfcp_fsf_send_els(&els_fc_job->els);
+        els->handler = zfcp_fc_ct_els_job_handler;
+        return zfcp_fsf_send_els(adapter, d_id, els, job->req->timeout / HZ);
 }
 
-struct zfcp_ct_fc_job {
-        struct zfcp_send_ct ct;
-        struct fc_bsg_job *job;
-};
-
-static void zfcp_fc_generic_ct_handler(unsigned long data)
+static int zfcp_fc_exec_ct_job(struct fc_bsg_job *job,
+                               struct zfcp_adapter *adapter)
 {
-        struct zfcp_ct_fc_job *ct_fc_job = (struct zfcp_ct_fc_job *) data;
-        struct fc_bsg_job *job = ct_fc_job->job;
+        int ret;
+        struct zfcp_fsf_ct_els *ct = job->dd_data;
+        struct zfcp_fc_wka_port *wka_port;
 
-        job->reply->reply_data.ctels_reply.status = ct_fc_job->ct.status ?
-                                FC_CTELS_STATUS_REJECT : FC_CTELS_STATUS_OK;
-        job->reply->reply_payload_rcv_len = job->reply_payload.payload_len;
-        job->state_flags = FC_RQST_STATE_DONE;
-        job->job_done(job);
+        wka_port = zfcp_fc_job_wka_port(job);
+        if (!wka_port)
+                return -EINVAL;
 
-        zfcp_fc_wka_port_put(ct_fc_job->ct.wka_port);
+        ret = zfcp_fc_wka_port_get(wka_port);
+        if (ret)
+                return ret;
 
-        kfree(ct_fc_job);
+        ct->handler = zfcp_fc_ct_job_handler;
+        ret = zfcp_fsf_send_ct(wka_port, ct, NULL, job->req->timeout / HZ);
+        if (ret)
+                zfcp_fc_wka_port_put(wka_port);
+
+        return ret;
 }
 
-int zfcp_fc_execute_ct_fc_job(struct fc_bsg_job *job)
+int zfcp_fc_exec_bsg_job(struct fc_bsg_job *job)
 {
-        int ret;
-        u8 gs_type;
-        struct fc_rport *rport = job->rport;
         struct Scsi_Host *shost;
         struct zfcp_adapter *adapter;
-        struct zfcp_ct_fc_job *ct_fc_job;
-        u32 preamble_word1;
-
-        shost = rport ? rport_to_shost(rport) : job->shost;
+        struct zfcp_fsf_ct_els *ct_els = job->dd_data;
 
+        shost = job->rport ? rport_to_shost(job->rport) : job->shost;
         adapter = (struct zfcp_adapter *)shost->hostdata[0];
+
         if (!(atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN))
                 return -EINVAL;
 
-        ct_fc_job = kzalloc(sizeof(struct zfcp_ct_fc_job), GFP_KERNEL);
-        if (!ct_fc_job)
-                return -ENOMEM;
-
-        preamble_word1 = job->request->rqst_data.r_ct.preamble_word1;
-        gs_type = (preamble_word1 & 0xff000000) >> 24;
-
-        switch (gs_type) {
-        case FC_FST_ALIAS:
-                ct_fc_job->ct.wka_port = &adapter->gs->as;
-                break;
-        case FC_FST_MGMT:
-                ct_fc_job->ct.wka_port = &adapter->gs->ms;
-                break;
-        case FC_FST_TIME:
-                ct_fc_job->ct.wka_port = &adapter->gs->ts;
-                break;
-        case FC_FST_DIR:
-                ct_fc_job->ct.wka_port = &adapter->gs->ds;
-                break;
+        ct_els->req = job->request_payload.sg_list;
+        ct_els->resp = job->reply_payload.sg_list;
+        ct_els->handler_data = job;
+
+        switch (job->request->msgcode) {
+        case FC_BSG_RPT_ELS:
+        case FC_BSG_HST_ELS_NOLOGIN:
+                return zfcp_fc_exec_els_job(job, adapter);
+        case FC_BSG_RPT_CT:
+        case FC_BSG_HST_CT:
+                return zfcp_fc_exec_ct_job(job, adapter);
         default:
-                kfree(ct_fc_job);
-                return -EINVAL; /* no such service */
-        }
-
-        ret = zfcp_fc_wka_port_get(ct_fc_job->ct.wka_port);
-        if (ret) {
-                kfree(ct_fc_job);
-                return ret;
+                return -EINVAL;
         }
+}
 
-        ct_fc_job->ct.req = job->request_payload.sg_list;
-        ct_fc_job->ct.resp = job->reply_payload.sg_list;
-        ct_fc_job->ct.handler = zfcp_fc_generic_ct_handler;
-        ct_fc_job->ct.handler_data = (unsigned long) ct_fc_job;
-        ct_fc_job->ct.completion = NULL;
-        ct_fc_job->job = job;
-
-        ret = zfcp_fsf_send_ct(&ct_fc_job->ct, NULL);
-        if (ret) {
-                kfree(ct_fc_job);
-                zfcp_fc_wka_port_put(ct_fc_job->ct.wka_port);
-        }
-        return ret;
+int zfcp_fc_timeout_bsg_job(struct fc_bsg_job *job)
+{
+        /* hardware tracks timeout, reset bsg timeout to not interfere */
+        return -EAGAIN;
 }
 
 int zfcp_fc_gs_setup(struct zfcp_adapter *adapter)
 {
-        struct zfcp_wka_ports *wka_ports;
+        struct zfcp_fc_wka_ports *wka_ports;
 
-        wka_ports = kzalloc(sizeof(struct zfcp_wka_ports), GFP_KERNEL);
+        wka_ports = kzalloc(sizeof(struct zfcp_fc_wka_ports), GFP_KERNEL);
         if (!wka_ports)
                 return -ENOMEM;
 
@@ -880,7 +809,6 @@ int zfcp_fc_gs_setup(struct zfcp_adapter *adapter)
         zfcp_fc_wka_port_init(&wka_ports->ts, FC_FID_TIME_SERV, adapter);
         zfcp_fc_wka_port_init(&wka_ports->ds, FC_FID_DIR_SERV, adapter);
         zfcp_fc_wka_port_init(&wka_ports->as, FC_FID_ALIASES, adapter);
-        zfcp_fc_wka_port_init(&wka_ports->ks, FC_FID_SEC_KEY, adapter);
 
         return 0;
 }
diff --git a/drivers/s390/scsi/zfcp_fc.h b/drivers/s390/scsi/zfcp_fc.h
new file mode 100644
index 000000000000..0747b087390d
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_fc.h
@@ -0,0 +1,262 @@
+/*
+ * zfcp device driver
+ *
+ * Fibre Channel related definitions and inline functions for the zfcp
+ * device driver
+ *
+ * Copyright IBM Corporation 2009
+ */
+
+#ifndef ZFCP_FC_H
+#define ZFCP_FC_H
+
+#include <scsi/fc/fc_els.h>
+#include <scsi/fc/fc_fcp.h>
+#include <scsi/fc/fc_ns.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_tcq.h>
+#include "zfcp_fsf.h"
+
+#define ZFCP_FC_CT_SIZE_PAGE      (PAGE_SIZE - sizeof(struct fc_ct_hdr))
+#define ZFCP_FC_GPN_FT_ENT_PAGE   (ZFCP_FC_CT_SIZE_PAGE \
+                                        / sizeof(struct fc_gpn_ft_resp))
+#define ZFCP_FC_GPN_FT_NUM_BUFS   4 /* memory pages */
+
+#define ZFCP_FC_GPN_FT_MAX_SIZE   (ZFCP_FC_GPN_FT_NUM_BUFS * PAGE_SIZE \
+                                        - sizeof(struct fc_ct_hdr))
+#define ZFCP_FC_GPN_FT_MAX_ENT    (ZFCP_FC_GPN_FT_NUM_BUFS * \
+                                        (ZFCP_FC_GPN_FT_ENT_PAGE + 1))
+
+#define ZFCP_FC_CTELS_TMO       (2 * FC_DEF_R_A_TOV / 1000)
+
+/**
+ * struct zfcp_fc_gid_pn_req - container for ct header plus gid_pn request
+ * @ct_hdr: FC GS common transport header
+ * @gid_pn: GID_PN request
+ */
+struct zfcp_fc_gid_pn_req {
+        struct fc_ct_hdr        ct_hdr;
+        struct fc_ns_gid_pn     gid_pn;
+} __packed;
+
+/**
+ * struct zfcp_fc_gid_pn_resp - container for ct header plus gid_pn response
+ * @ct_hdr: FC GS common transport header
+ * @gid_pn: GID_PN response
+ */
+struct zfcp_fc_gid_pn_resp {
+        struct fc_ct_hdr        ct_hdr;
+        struct fc_gid_pn_resp   gid_pn;
+} __packed;
+
+/**
+ * struct zfcp_fc_gid_pn - everything required in zfcp for gid_pn request
+ * @ct: data passed to zfcp_fsf for issuing fsf request
+ * @sg_req: scatterlist entry for request data
+ * @sg_resp: scatterlist entry for response data
+ * @gid_pn_req: GID_PN request data
+ * @gid_pn_resp: GID_PN response data
+ */
+struct zfcp_fc_gid_pn {
+        struct zfcp_fsf_ct_els ct;
+        struct scatterlist sg_req;
+        struct scatterlist sg_resp;
+        struct zfcp_fc_gid_pn_req gid_pn_req;
+        struct zfcp_fc_gid_pn_resp gid_pn_resp;
+        struct zfcp_port *port;
+};
+
+/**
+ * struct zfcp_fc_gpn_ft - container for ct header plus gpn_ft request
+ * @ct_hdr: FC GS common transport header
+ * @gpn_ft: GPN_FT request
+ */
+struct zfcp_fc_gpn_ft_req {
+        struct fc_ct_hdr        ct_hdr;
+        struct fc_ns_gid_ft     gpn_ft;
+} __packed;
+
+/**
+ * struct zfcp_fc_gpn_ft_resp - container for ct header plus gpn_ft response
+ * @ct_hdr: FC GS common transport header
+ * @gpn_ft: Array of gpn_ft response data to fill one memory page
+ */
+struct zfcp_fc_gpn_ft_resp {
+        struct fc_ct_hdr        ct_hdr;
+        struct fc_gpn_ft_resp   gpn_ft[ZFCP_FC_GPN_FT_ENT_PAGE];
+} __packed;
+
+/**
+ * struct zfcp_fc_gpn_ft - zfcp data for gpn_ft request
+ * @ct: data passed to zfcp_fsf for issuing fsf request
+ * @sg_req: scatter list entry for gpn_ft request
+ * @sg_resp: scatter list entries for gpn_ft responses (per memory page)
+ */
+struct zfcp_fc_gpn_ft {
+        struct zfcp_fsf_ct_els ct;
+        struct scatterlist sg_req;
+        struct scatterlist sg_resp[ZFCP_FC_GPN_FT_NUM_BUFS];
+};
+
+/**
+ * struct zfcp_fc_els_adisc - everything required in zfcp for issuing ELS ADISC
+ * @els: data required for issuing els fsf command
+ * @req: scatterlist entry for ELS ADISC request
+ * @resp: scatterlist entry for ELS ADISC response
+ * @adisc_req: ELS ADISC request data
+ * @adisc_resp: ELS ADISC response data
+ */
+struct zfcp_fc_els_adisc {
+        struct zfcp_fsf_ct_els els;
+        struct scatterlist req;
+        struct scatterlist resp;
+        struct fc_els_adisc adisc_req;
+        struct fc_els_adisc adisc_resp;
+};
+
+/**
+ * enum zfcp_fc_wka_status - FC WKA port status in zfcp
+ * @ZFCP_FC_WKA_PORT_OFFLINE: Port is closed and not in use
+ * @ZFCP_FC_WKA_PORT_CLOSING: The FSF "close port" request is pending
+ * @ZFCP_FC_WKA_PORT_OPENING: The FSF "open port" request is pending
+ * @ZFCP_FC_WKA_PORT_ONLINE: The port is open and the port handle is valid
+ */
+enum zfcp_fc_wka_status {
+        ZFCP_FC_WKA_PORT_OFFLINE,
+        ZFCP_FC_WKA_PORT_CLOSING,
+        ZFCP_FC_WKA_PORT_OPENING,
+        ZFCP_FC_WKA_PORT_ONLINE,
+};
+
+/**
+ * struct zfcp_fc_wka_port - representation of well-known-address (WKA) FC port
+ * @adapter: Pointer to adapter structure this WKA port belongs to
+ * @completion_wq: Wait for completion of open/close command
+ * @status: Current status of WKA port
+ * @refcount: Reference count to keep port open as long as it is in use
+ * @d_id: FC destination id or well-known-address
+ * @handle: FSF handle for the open WKA port
+ * @mutex: Mutex used during opening/closing state changes
+ * @work: For delaying the closing of the WKA port
+ */
+struct zfcp_fc_wka_port {
+        struct zfcp_adapter     *adapter;
+        wait_queue_head_t       completion_wq;
+        enum zfcp_fc_wka_status status;
+        atomic_t                refcount;
+        u32                     d_id;
+        u32                     handle;
+        struct mutex            mutex;
+        struct delayed_work     work;
+};
+
+/**
+ * struct zfcp_fc_wka_ports - Data structures for FC generic services
+ * @ms: FC Management service
+ * @ts: FC time service
+ * @ds: FC directory service
+ * @as: FC alias service
+ */
+struct zfcp_fc_wka_ports {
+        struct zfcp_fc_wka_port ms;
+        struct zfcp_fc_wka_port ts;
+        struct zfcp_fc_wka_port ds;
+        struct zfcp_fc_wka_port as;
+};
+
+/**
+ * zfcp_fc_scsi_to_fcp - setup FCP command with data from scsi_cmnd
+ * @fcp: fcp_cmnd to setup
+ * @scsi: scsi_cmnd where to get LUN, task attributes/flags and CDB
+ */
+static inline
+void zfcp_fc_scsi_to_fcp(struct fcp_cmnd *fcp, struct scsi_cmnd *scsi)
+{
+        char tag[2];
+
+        int_to_scsilun(scsi->device->lun, (struct scsi_lun *) &fcp->fc_lun);
+
+        if (scsi_populate_tag_msg(scsi, tag)) {
+                switch (tag[0]) {
+                case MSG_ORDERED_TAG:
+                        fcp->fc_pri_ta |= FCP_PTA_ORDERED;
+                        break;
+                case MSG_SIMPLE_TAG:
+                        fcp->fc_pri_ta |= FCP_PTA_SIMPLE;
+                        break;
+                };
+        } else
+                fcp->fc_pri_ta = FCP_PTA_SIMPLE;
+
+        if (scsi->sc_data_direction == DMA_FROM_DEVICE)
+                fcp->fc_flags |= FCP_CFL_RDDATA;
+        if (scsi->sc_data_direction == DMA_TO_DEVICE)
+                fcp->fc_flags |= FCP_CFL_WRDATA;
+
+        memcpy(fcp->fc_cdb, scsi->cmnd, scsi->cmd_len);
+
+        fcp->fc_dl = scsi_bufflen(scsi);
+}
+
+/**
+ * zfcp_fc_fcp_tm - setup FCP command as task management command
+ * @fcp: fcp_cmnd to setup
+ * @dev: scsi_device where to send the task management command
+ * @tm: task management flags to setup tm command
+ */
+static inline
+void zfcp_fc_fcp_tm(struct fcp_cmnd *fcp, struct scsi_device *dev, u8 tm_flags)
+{
+        int_to_scsilun(dev->lun, (struct scsi_lun *) &fcp->fc_lun);
+        fcp->fc_tm_flags |= tm_flags;
+}
+
+/**
+ * zfcp_fc_evap_fcp_rsp - evaluate FCP RSP IU and update scsi_cmnd accordingly
+ * @fcp_rsp: FCP RSP IU to evaluate
+ * @scsi: SCSI command where to update status and sense buffer
+ */
+static inline
+void zfcp_fc_eval_fcp_rsp(struct fcp_resp_with_ext *fcp_rsp,
+                          struct scsi_cmnd *scsi)
+{
+        struct fcp_resp_rsp_info *rsp_info;
+        char *sense;
+        u32 sense_len, resid;
+        u8 rsp_flags;
+
+        set_msg_byte(scsi, COMMAND_COMPLETE);
+        scsi->result |= fcp_rsp->resp.fr_status;
+
+        rsp_flags = fcp_rsp->resp.fr_flags;
+
+        if (unlikely(rsp_flags & FCP_RSP_LEN_VAL)) {
+                rsp_info = (struct fcp_resp_rsp_info *) &fcp_rsp[1];
+                if (rsp_info->rsp_code == FCP_TMF_CMPL)
+                        set_host_byte(scsi, DID_OK);
+                else {
+                        set_host_byte(scsi, DID_ERROR);
+                        return;
+                }
+        }
+
+        if (unlikely(rsp_flags & FCP_SNS_LEN_VAL)) {
+                sense = (char *) &fcp_rsp[1];
+                if (rsp_flags & FCP_RSP_LEN_VAL)
+                        sense += fcp_rsp->ext.fr_sns_len;
+                sense_len = min(fcp_rsp->ext.fr_sns_len,
+                                (u32) SCSI_SENSE_BUFFERSIZE);
+                memcpy(scsi->sense_buffer, sense, sense_len);
+        }
+
+        if (unlikely(rsp_flags & FCP_RESID_UNDER)) {
+                resid = fcp_rsp->ext.fr_resid;
+                scsi_set_resid(scsi, resid);
+                if (scsi_bufflen(scsi) - resid < scsi->underflow &&
+                     !(rsp_flags & FCP_SNS_LEN_VAL) &&
+                     fcp_rsp->resp.fr_status == SAM_STAT_GOOD)
+                        set_host_byte(scsi, DID_ERROR);
+        }
+}
+
+#endif
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
index 4e41baa0c141..b3b1d2f79398 100644
--- a/drivers/s390/scsi/zfcp_fsf.c
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -3,15 +3,20 @@
  *
  * Implementation of FSF commands.
  *
- * Copyright IBM Corporation 2002, 2009
+ * Copyright IBM Corporation 2002, 2010
  */
 
 #define KMSG_COMPONENT "zfcp"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include <linux/blktrace_api.h>
+#include <linux/slab.h>
+#include <scsi/fc/fc_els.h>
 #include "zfcp_ext.h"
+#include "zfcp_fc.h"
 #include "zfcp_dbf.h"
+#include "zfcp_qdio.h"
+#include "zfcp_reqlist.h"
 
 static void zfcp_fsf_request_timeout_handler(unsigned long data)
 {
@@ -122,36 +127,32 @@ void zfcp_fsf_req_free(struct zfcp_fsf_req *req)
 
 static void zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *req)
 {
+        unsigned long flags;
         struct fsf_status_read_buffer *sr_buf = req->data;
         struct zfcp_adapter *adapter = req->adapter;
         struct zfcp_port *port;
-        int d_id = sr_buf->d_id & ZFCP_DID_MASK;
-        unsigned long flags;
+        int d_id = ntoh24(sr_buf->d_id);
 
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
-        list_for_each_entry(port, &adapter->port_list_head, list)
+        read_lock_irqsave(&adapter->port_list_lock, flags);
+        list_for_each_entry(port, &adapter->port_list, list)
                 if (port->d_id == d_id) {
-                        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
                         zfcp_erp_port_reopen(port, 0, "fssrpc1", req);
-                        return;
+                        break;
                 }
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+        read_unlock_irqrestore(&adapter->port_list_lock, flags);
 }
 
 static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req *req, char *id,
                                          struct fsf_link_down_info *link_down)
 {
         struct zfcp_adapter *adapter = req->adapter;
-        unsigned long flags;
 
         if (atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)
                 return;
 
         atomic_set_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
 
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
         zfcp_scsi_schedule_rports_block(adapter);
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 
         if (!link_down)
                 goto out;
@@ -291,7 +292,7 @@ static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
                         zfcp_erp_adapter_access_changed(adapter, "fssrh_3",
                                                         req);
                 if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_INCOMING_ELS)
-                        schedule_work(&adapter->scan_work);
+                        queue_work(adapter->work_queue, &adapter->scan_work);
                 break;
         case FSF_STATUS_READ_CFDC_UPDATED:
                 zfcp_erp_adapter_access_changed(adapter, "fssrh_4", req);
@@ -317,7 +318,6 @@ static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *req)
         case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
                 return;
         case FSF_SQ_COMMAND_ABORTED:
-                req->status |= ZFCP_STATUS_FSFREQ_ABORTED;
                 break;
         case FSF_SQ_NO_RECOM:
                 dev_err(&req->adapter->ccw_device->dev,
@@ -358,8 +358,7 @@ static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
         zfcp_dbf_hba_fsf_response(req);
 
         if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR |
-                        ZFCP_STATUS_FSFREQ_RETRY; /* only for SCSI cmnds. */
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 return;
         }
 
@@ -377,7 +376,7 @@ static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
         case FSF_PROT_ERROR_STATE:
         case FSF_PROT_SEQ_NUMB_ERROR:
                 zfcp_erp_adapter_reopen(adapter, 0, "fspse_2", req);
-                req->status |= ZFCP_STATUS_FSFREQ_RETRY;
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_PROT_UNSUPP_QTCB_TYPE:
                 dev_err(&adapter->ccw_device->dev,
@@ -397,7 +396,7 @@ static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
         case FSF_PROT_LINK_DOWN:
                 zfcp_fsf_link_down_info_eval(req, "fspse_5",
                                              &psq->link_down_info);
-                /* FIXME: reopening adapter now? better wait for link up */
+                /* go through reopen to flush pending requests */
                 zfcp_erp_adapter_reopen(adapter, 0, "fspse_6", req);
                 break;
         case FSF_PROT_REEST_QUEUE:
@@ -461,15 +460,10 @@ static void zfcp_fsf_req_complete(struct zfcp_fsf_req *req)
 void zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter)
 {
         struct zfcp_fsf_req *req, *tmp;
-        unsigned long flags;
         LIST_HEAD(remove_queue);
-        unsigned int i;
 
         BUG_ON(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP);
-        spin_lock_irqsave(&adapter->req_list_lock, flags);
-        for (i = 0; i < REQUEST_LIST_SIZE; i++)
-                list_splice_init(&adapter->req_list[i], &remove_queue);
-        spin_unlock_irqrestore(&adapter->req_list_lock, flags);
+        zfcp_reqlist_move(adapter->req_list, &remove_queue);
 
         list_for_each_entry_safe(req, tmp, &remove_queue, list) {
                 list_del(&req->list);
@@ -480,18 +474,23 @@ void zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter)
 
 static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *req)
 {
-        struct fsf_qtcb_bottom_config *bottom;
+        struct fsf_qtcb_bottom_config *bottom = &req->qtcb->bottom.config;
         struct zfcp_adapter *adapter = req->adapter;
         struct Scsi_Host *shost = adapter->scsi_host;
+        struct fc_els_flogi *nsp, *plogi;
 
-        bottom = &req->qtcb->bottom.config;
+        /* adjust pointers for missing command code */
+        nsp = (struct fc_els_flogi *) ((u8 *)&bottom->nport_serv_param
+                                        - sizeof(u32));
+        plogi = (struct fc_els_flogi *) ((u8 *)&bottom->plogi_payload
+                                        - sizeof(u32));
 
         if (req->data)
                 memcpy(req->data, bottom, sizeof(*bottom));
 
-        fc_host_node_name(shost) = bottom->nport_serv_param.wwnn;
-        fc_host_port_name(shost) = bottom->nport_serv_param.wwpn;
-        fc_host_port_id(shost) = bottom->s_id & ZFCP_DID_MASK;
+        fc_host_port_name(shost) = nsp->fl_wwpn;
+        fc_host_node_name(shost) = nsp->fl_wwnn;
+        fc_host_port_id(shost) = ntoh24(bottom->s_id);
         fc_host_speed(shost) = bottom->fc_link_speed;
         fc_host_supported_classes(shost) = FC_COS_CLASS2 | FC_COS_CLASS3;
 
@@ -503,9 +502,9 @@ static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *req)
 
         switch (bottom->fc_topology) {
         case FSF_TOPO_P2P:
-                adapter->peer_d_id = bottom->peer_d_id & ZFCP_DID_MASK;
-                adapter->peer_wwpn = bottom->plogi_payload.wwpn;
-                adapter->peer_wwnn = bottom->plogi_payload.wwnn;
+                adapter->peer_d_id = ntoh24(bottom->peer_d_id);
+                adapter->peer_wwpn = plogi->fl_wwpn;
+                adapter->peer_wwnn = plogi->fl_wwnn;
                 fc_host_port_type(shost) = FC_PORTTYPE_PTP;
                 break;
         case FSF_TOPO_FABRIC:
@@ -616,6 +615,10 @@ static void zfcp_fsf_exchange_port_evaluate(struct zfcp_fsf_req *req)
                 fc_host_permanent_port_name(shost) = fc_host_port_name(shost);
         fc_host_maxframe_size(shost) = bottom->maximum_frame_size;
         fc_host_supported_speeds(shost) = bottom->supported_speed;
+        memcpy(fc_host_supported_fc4s(shost), bottom->supported_fc4_types,
+               FC_FC4_LIST_SIZE);
+        memcpy(fc_host_active_fc4s(shost), bottom->active_fc4_types,
+               FC_FC4_LIST_SIZE);
 }
 
 static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req)
@@ -722,12 +725,12 @@ static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_qdio *qdio,
         req->adapter = adapter;
         req->fsf_command = fsf_cmd;
         req->req_id = adapter->req_no;
-        req->queue_req.sbal_number = 1;
-        req->queue_req.sbal_first = req_q->first;
-        req->queue_req.sbal_last = req_q->first;
-        req->queue_req.sbale_curr = 1;
+        req->qdio_req.sbal_number = 1;
+        req->qdio_req.sbal_first = req_q->first;
+        req->qdio_req.sbal_last = req_q->first;
+        req->qdio_req.sbale_curr = 1;
 
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].addr = (void *) req->req_id;
         sbale[0].flags |= SBAL_FLAGS0_COMMAND;
 
@@ -742,6 +745,7 @@ static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_qdio *qdio,
                         return ERR_PTR(-ENOMEM);
                 }
 
+                req->seq_no = adapter->fsf_req_seq_no;
                 req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no;
                 req->qtcb->prefix.req_id = req->req_id;
                 req->qtcb->prefix.ulp_info = 26;
@@ -749,8 +753,6 @@ static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_qdio *qdio,
                 req->qtcb->prefix.qtcb_version = FSF_QTCB_CURRENT_VERSION;
                 req->qtcb->header.req_handle = req->req_id;
                 req->qtcb->header.fsf_command = req->fsf_command;
-                req->seq_no = adapter->fsf_req_seq_no;
-                req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no;
                 sbale[1].addr = (void *) req->qtcb;
                 sbale[1].length = sizeof(struct fsf_qtcb);
         }
@@ -767,25 +769,17 @@ static int zfcp_fsf_req_send(struct zfcp_fsf_req *req)
 {
         struct zfcp_adapter *adapter = req->adapter;
         struct zfcp_qdio *qdio = adapter->qdio;
-        unsigned long        flags;
-        int                  idx;
-        int                  with_qtcb = (req->qtcb != NULL);
+        int with_qtcb = (req->qtcb != NULL);
+        int req_id = req->req_id;
 
-        /* put allocated FSF request into hash table */
-        spin_lock_irqsave(&adapter->req_list_lock, flags);
-        idx = zfcp_reqlist_hash(req->req_id);
-        list_add_tail(&req->list, &adapter->req_list[idx]);
-        spin_unlock_irqrestore(&adapter->req_list_lock, flags);
+        zfcp_reqlist_add(adapter->req_list, req);
 
-        req->queue_req.qdio_outb_usage = atomic_read(&qdio->req_q.count);
+        req->qdio_req.qdio_outb_usage = atomic_read(&qdio->req_q.count);
         req->issued = get_clock();
-        if (zfcp_qdio_send(qdio, &req->queue_req)) {
+        if (zfcp_qdio_send(qdio, &req->qdio_req)) {
                 del_timer(&req->timer);
-                spin_lock_irqsave(&adapter->req_list_lock, flags);
                 /* lookup request again, list might have changed */
-                if (zfcp_reqlist_find_safe(adapter, req))
-                        zfcp_reqlist_remove(adapter, req);
-                spin_unlock_irqrestore(&adapter->req_list_lock, flags);
+                zfcp_reqlist_find_rm(adapter->req_list, req_id);
                 zfcp_erp_adapter_reopen(adapter, 0, "fsrs__1", req);
                 return -EIO;
         }
@@ -823,9 +817,9 @@ int zfcp_fsf_status_read(struct zfcp_qdio *qdio)
                 goto out;
         }
 
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[2].flags |= SBAL_FLAGS_LAST_ENTRY;
-        req->queue_req.sbale_curr = 2;
+        req->qdio_req.sbale_curr = 2;
 
         sr_buf = mempool_alloc(adapter->pool.status_read_data, GFP_ATOMIC);
         if (!sr_buf) {
@@ -834,7 +828,7 @@ int zfcp_fsf_status_read(struct zfcp_qdio *qdio)
         }
         memset(sr_buf, 0, sizeof(*sr_buf));
         req->data = sr_buf;
-        sbale = zfcp_qdio_sbale_curr(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_curr(qdio, &req->qdio_req);
         sbale->addr = (void *) sr_buf;
         sbale->length = sizeof(*sr_buf);
 
@@ -881,13 +875,11 @@ static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
                 break;
         case FSF_PORT_BOXED:
                 zfcp_erp_port_boxed(unit->port, "fsafch3", req);
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR |
-                               ZFCP_STATUS_FSFREQ_RETRY;
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_LUN_BOXED:
                 zfcp_erp_unit_boxed(unit, "fsafch4", req);
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR |
-                               ZFCP_STATUS_FSFREQ_RETRY;
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
                 switch (fsq->word[0]) {
@@ -933,7 +925,7 @@ struct zfcp_fsf_req *zfcp_fsf_abort_fcp_command(unsigned long old_req_id,
                        ZFCP_STATUS_COMMON_UNBLOCKED)))
                 goto out_error_free;
 
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -958,10 +950,10 @@ out:
 static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
 {
         struct zfcp_adapter *adapter = req->adapter;
-        struct zfcp_send_ct *send_ct = req->data;
+        struct zfcp_fsf_ct_els *ct = req->data;
         struct fsf_qtcb_header *header = &req->qtcb->header;
 
-        send_ct->status = -EINVAL;
+        ct->status = -EINVAL;
 
         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
                 goto skip_fsfstatus;
@@ -969,7 +961,7 @@ static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
         switch (header->fsf_status) {
         case FSF_GOOD:
                 zfcp_dbf_san_ct_response(req);
-                send_ct->status = 0;
+                ct->status = 0;
                 break;
         case FSF_SERVICE_CLASS_NOT_SUPPORTED:
                 zfcp_fsf_class_not_supp(req);
@@ -985,8 +977,7 @@ static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
         case FSF_ACCESS_DENIED:
                 break;
         case FSF_PORT_BOXED:
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR |
-                               ZFCP_STATUS_FSFREQ_RETRY;
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_PORT_HANDLE_NOT_VALID:
                 zfcp_erp_adapter_reopen(adapter, 0, "fsscth1", req);
@@ -1001,8 +992,8 @@ static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
         }
 
 skip_fsfstatus:
-        if (send_ct->handler)
-                send_ct->handler(send_ct->handler_data);
+        if (ct->handler)
+                ct->handler(ct->handler_data);
 }
 
 static void zfcp_fsf_setup_ct_els_unchained(struct qdio_buffer_element *sbale,
@@ -1029,7 +1020,7 @@ static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req *req,
 {
         struct zfcp_adapter *adapter = req->adapter;
         struct qdio_buffer_element *sbale = zfcp_qdio_sbale_req(adapter->qdio,
-                                                               &req->queue_req);
+                                                               &req->qdio_req);
         u32 feat = adapter->adapter_features;
         int bytes;
 
@@ -1047,15 +1038,15 @@ static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req *req,
                 return 0;
         }
 
-        bytes = zfcp_qdio_sbals_from_sg(adapter->qdio, &req->queue_req,
+        bytes = zfcp_qdio_sbals_from_sg(adapter->qdio, &req->qdio_req,
                                         SBAL_FLAGS0_TYPE_WRITE_READ,
                                         sg_req, max_sbals);
         if (bytes <= 0)
                 return -EIO;
         req->qtcb->bottom.support.req_buf_length = bytes;
-        req->queue_req.sbale_curr = ZFCP_LAST_SBALE_PER_SBAL;
+        req->qdio_req.sbale_curr = ZFCP_LAST_SBALE_PER_SBAL;
 
-        bytes = zfcp_qdio_sbals_from_sg(adapter->qdio, &req->queue_req,
+        bytes = zfcp_qdio_sbals_from_sg(adapter->qdio, &req->qdio_req,
                                         SBAL_FLAGS0_TYPE_WRITE_READ,
                                         sg_resp, max_sbals);
         req->qtcb->bottom.support.resp_buf_length = bytes;
@@ -1068,7 +1059,7 @@ static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req *req,
 static int zfcp_fsf_setup_ct_els(struct zfcp_fsf_req *req,
                                  struct scatterlist *sg_req,
                                  struct scatterlist *sg_resp,
-                                 int max_sbals)
+                                 int max_sbals, unsigned int timeout)
 {
         int ret;
 
@@ -1077,9 +1068,11 @@ static int zfcp_fsf_setup_ct_els(struct zfcp_fsf_req *req,
                 return ret;
 
         /* common settings for ct/gs and els requests */
+        if (timeout > 255)
+                timeout = 255; /* max value accepted by hardware */
         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) * HZ);
+        req->qtcb->bottom.support.timeout = timeout;
+        zfcp_fsf_start_timer(req, (timeout + 10) * HZ);
 
         return 0;
 }
@@ -1089,9 +1082,10 @@ static int zfcp_fsf_setup_ct_els(struct zfcp_fsf_req *req,
  * @ct: pointer to struct zfcp_send_ct with data for request
  * @pool: if non-null this mempool is used to allocate struct zfcp_fsf_req
  */
-int zfcp_fsf_send_ct(struct zfcp_send_ct *ct, mempool_t *pool)
+int zfcp_fsf_send_ct(struct zfcp_fc_wka_port *wka_port,
+                     struct zfcp_fsf_ct_els *ct, mempool_t *pool,
+                     unsigned int timeout)
 {
-        struct zfcp_wka_port *wka_port = ct->wka_port;
         struct zfcp_qdio *qdio = wka_port->adapter->qdio;
         struct zfcp_fsf_req *req;
         int ret = -EIO;
@@ -1109,7 +1103,7 @@ 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(req, ct->req, ct->resp,
-                                    FSF_MAX_SBALS_PER_REQ);
+                                    FSF_MAX_SBALS_PER_REQ, timeout);
         if (ret)
                 goto failed_send;
 
@@ -1117,7 +1111,7 @@ int zfcp_fsf_send_ct(struct zfcp_send_ct *ct, mempool_t *pool)
         req->qtcb->header.port_handle = wka_port->handle;
         req->data = ct;
 
-        zfcp_dbf_san_ct_request(req);
+        zfcp_dbf_san_ct_request(req, wka_port->d_id);
 
         ret = zfcp_fsf_req_send(req);
         if (ret)
@@ -1134,7 +1128,7 @@ out:
 
 static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req *req)
 {
-        struct zfcp_send_els *send_els = req->data;
+        struct zfcp_fsf_ct_els *send_els = req->data;
         struct zfcp_port *port = send_els->port;
         struct fsf_qtcb_header *header = &req->qtcb->header;
 
@@ -1154,9 +1148,6 @@ static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req *req)
         case FSF_ADAPTER_STATUS_AVAILABLE:
                 switch (header->fsf_status_qual.word[0]){
                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
-                        if (port && (send_els->ls_code != ZFCP_LS_ADISC))
-                                zfcp_fc_test_link(port);
-                        /*fall through */
                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
                 case FSF_SQ_RETRY_IF_POSSIBLE:
                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
@@ -1188,10 +1179,11 @@ skip_fsfstatus:
  * zfcp_fsf_send_els - initiate an ELS command (FC-FS)
  * @els: pointer to struct zfcp_send_els with data for the command
  */
-int zfcp_fsf_send_els(struct zfcp_send_els *els)
+int zfcp_fsf_send_els(struct zfcp_adapter *adapter, u32 d_id,
+                      struct zfcp_fsf_ct_els *els, unsigned int timeout)
 {
         struct zfcp_fsf_req *req;
-        struct zfcp_qdio *qdio = els->adapter->qdio;
+        struct zfcp_qdio *qdio = adapter->qdio;
         int ret = -EIO;
 
         spin_lock_bh(&qdio->req_q_lock);
@@ -1206,12 +1198,12 @@ int zfcp_fsf_send_els(struct zfcp_send_els *els)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        ret = zfcp_fsf_setup_ct_els(req, els->req, els->resp, 2);
+        ret = zfcp_fsf_setup_ct_els(req, els->req, els->resp, 2, timeout);
 
         if (ret)
                 goto failed_send;
 
-        req->qtcb->bottom.support.d_id = els->d_id;
+        hton24(req->qtcb->bottom.support.d_id, d_id);
         req->handler = zfcp_fsf_send_els_handler;
         req->data = els;
 
@@ -1250,7 +1242,7 @@ int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -1261,13 +1253,13 @@ int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
                         FSF_FEATURE_UPDATE_ALERT;
         req->erp_action = erp_action;
         req->handler = zfcp_fsf_exchange_config_data_handler;
-        erp_action->fsf_req = req;
+        erp_action->fsf_req_id = req->req_id;
 
         zfcp_fsf_start_erp_timer(req);
         retval = zfcp_fsf_req_send(req);
         if (retval) {
                 zfcp_fsf_req_free(req);
-                erp_action->fsf_req = NULL;
+                erp_action->fsf_req_id = 0;
         }
 out:
         spin_unlock_bh(&qdio->req_q_lock);
@@ -1292,7 +1284,7 @@ int zfcp_fsf_exchange_config_data_sync(struct zfcp_qdio *qdio,
                 goto out_unlock;
         }
 
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
         req->handler = zfcp_fsf_exchange_config_data_handler;
@@ -1348,19 +1340,19 @@ int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
         req->handler = zfcp_fsf_exchange_port_data_handler;
         req->erp_action = erp_action;
-        erp_action->fsf_req = req;
+        erp_action->fsf_req_id = req->req_id;
 
         zfcp_fsf_start_erp_timer(req);
         retval = zfcp_fsf_req_send(req);
         if (retval) {
                 zfcp_fsf_req_free(req);
-                erp_action->fsf_req = NULL;
+                erp_action->fsf_req_id = 0;
         }
 out:
         spin_unlock_bh(&qdio->req_q_lock);
@@ -1397,7 +1389,7 @@ int zfcp_fsf_exchange_port_data_sync(struct zfcp_qdio *qdio,
         if (data)
                 req->data = data;
 
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -1422,7 +1414,7 @@ static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req)
 {
         struct zfcp_port *port = req->data;
         struct fsf_qtcb_header *header = &req->qtcb->header;
-        struct fsf_plogi *plogi;
+        struct fc_els_flogi *plogi;
 
         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
                 goto out;
@@ -1472,23 +1464,10 @@ static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req)
                  * another GID_PN straight after a port has been opened.
                  * Alternately, an ADISC/PDISC ELS should suffice, as well.
                  */
-                plogi = (struct fsf_plogi *) req->qtcb->bottom.support.els;
+                plogi = (struct fc_els_flogi *) req->qtcb->bottom.support.els;
                 if (req->qtcb->bottom.support.els1_length >=
-                    FSF_PLOGI_MIN_LEN) {
-                        if (plogi->serv_param.wwpn != port->wwpn) {
-                                port->d_id = 0;
-                                dev_warn(&port->adapter->ccw_device->dev,
-                                         "A port opened with WWPN 0x%016Lx "
-                                         "returned data that identifies it as "
-                                         "WWPN 0x%016Lx\n",
-                                         (unsigned long long) port->wwpn,
-                                         (unsigned long long)
-                                          plogi->serv_param.wwpn);
-                        } else {
-                                port->wwnn = plogi->serv_param.wwnn;
+                    FSF_PLOGI_MIN_LEN)
                                 zfcp_fc_plogi_evaluate(port, plogi);
-                        }
-                }
                 break;
         case FSF_UNKNOWN_OP_SUBTYPE:
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
@@ -1496,7 +1475,7 @@ static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req)
         }
 
 out:
-        zfcp_port_put(port);
+        put_device(&port->dev);
 }
 
 /**
@@ -1525,23 +1504,23 @@ int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
         req->handler = zfcp_fsf_open_port_handler;
-        req->qtcb->bottom.support.d_id = port->d_id;
+        hton24(req->qtcb->bottom.support.d_id, port->d_id);
         req->data = port;
         req->erp_action = erp_action;
-        erp_action->fsf_req = req;
-        zfcp_port_get(port);
+        erp_action->fsf_req_id = req->req_id;
+        get_device(&port->dev);
 
         zfcp_fsf_start_erp_timer(req);
         retval = zfcp_fsf_req_send(req);
         if (retval) {
                 zfcp_fsf_req_free(req);
-                erp_action->fsf_req = NULL;
-                zfcp_port_put(port);
+                erp_action->fsf_req_id = 0;
+                put_device(&port->dev);
         }
 out:
         spin_unlock_bh(&qdio->req_q_lock);
@@ -1595,7 +1574,7 @@ int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -1603,13 +1582,13 @@ int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
         req->data = erp_action->port;
         req->erp_action = erp_action;
         req->qtcb->header.port_handle = erp_action->port->handle;
-        erp_action->fsf_req = req;
+        erp_action->fsf_req_id = req->req_id;
 
         zfcp_fsf_start_erp_timer(req);
         retval = zfcp_fsf_req_send(req);
         if (retval) {
                 zfcp_fsf_req_free(req);
-                erp_action->fsf_req = NULL;
+                erp_action->fsf_req_id = 0;
         }
 out:
         spin_unlock_bh(&qdio->req_q_lock);
@@ -1618,11 +1597,11 @@ out:
 
 static void zfcp_fsf_open_wka_port_handler(struct zfcp_fsf_req *req)
 {
-        struct zfcp_wka_port *wka_port = req->data;
+        struct zfcp_fc_wka_port *wka_port = req->data;
         struct fsf_qtcb_header *header = &req->qtcb->header;
 
         if (req->status & ZFCP_STATUS_FSFREQ_ERROR) {
-                wka_port->status = ZFCP_WKA_PORT_OFFLINE;
+                wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
                 goto out;
         }
 
@@ -1635,13 +1614,13 @@ static void zfcp_fsf_open_wka_port_handler(struct zfcp_fsf_req *req)
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 /* fall through */
         case FSF_ACCESS_DENIED:
-                wka_port->status = ZFCP_WKA_PORT_OFFLINE;
+                wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
                 break;
         case FSF_GOOD:
                 wka_port->handle = header->port_handle;
                 /* fall through */
         case FSF_PORT_ALREADY_OPEN:
-                wka_port->status = ZFCP_WKA_PORT_ONLINE;
+                wka_port->status = ZFCP_FC_WKA_PORT_ONLINE;
         }
 out:
         wake_up(&wka_port->completion_wq);
@@ -1649,10 +1628,10 @@ out:
 
 /**
  * zfcp_fsf_open_wka_port - create and send open wka-port request
- * @wka_port: pointer to struct zfcp_wka_port
+ * @wka_port: pointer to struct zfcp_fc_wka_port
  * Returns: 0 on success, error otherwise
  */
-int zfcp_fsf_open_wka_port(struct zfcp_wka_port *wka_port)
+int zfcp_fsf_open_wka_port(struct zfcp_fc_wka_port *wka_port)
 {
         struct qdio_buffer_element *sbale;
         struct zfcp_qdio *qdio = wka_port->adapter->qdio;
@@ -1672,12 +1651,12 @@ int zfcp_fsf_open_wka_port(struct zfcp_wka_port *wka_port)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
         req->handler = zfcp_fsf_open_wka_port_handler;
-        req->qtcb->bottom.support.d_id = wka_port->d_id;
+        hton24(req->qtcb->bottom.support.d_id, wka_port->d_id);
         req->data = wka_port;
 
         zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
@@ -1691,23 +1670,23 @@ out:
 
 static void zfcp_fsf_close_wka_port_handler(struct zfcp_fsf_req *req)
 {
-        struct zfcp_wka_port *wka_port = req->data;
+        struct zfcp_fc_wka_port *wka_port = req->data;
 
         if (req->qtcb->header.fsf_status == FSF_PORT_HANDLE_NOT_VALID) {
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 zfcp_erp_adapter_reopen(wka_port->adapter, 0, "fscwph1", req);
         }
 
-        wka_port->status = ZFCP_WKA_PORT_OFFLINE;
+        wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
         wake_up(&wka_port->completion_wq);
 }
 
 /**
  * zfcp_fsf_close_wka_port - create and send close wka port request
- * @erp_action: pointer to struct zfcp_erp_action
+ * @wka_port: WKA port to open
  * Returns: 0 on success, error otherwise
  */
-int zfcp_fsf_close_wka_port(struct zfcp_wka_port *wka_port)
+int zfcp_fsf_close_wka_port(struct zfcp_fc_wka_port *wka_port)
 {
         struct qdio_buffer_element *sbale;
         struct zfcp_qdio *qdio = wka_port->adapter->qdio;
@@ -1727,7 +1706,7 @@ int zfcp_fsf_close_wka_port(struct zfcp_wka_port *wka_port)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -1765,13 +1744,13 @@ static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
                 /* can't use generic zfcp_erp_modify_port_status because
                  * ZFCP_STATUS_COMMON_OPEN must not be reset for the port */
                 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
-                list_for_each_entry(unit, &port->unit_list_head, list)
+                read_lock(&port->unit_list_lock);
+                list_for_each_entry(unit, &port->unit_list, list)
                         atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
                                           &unit->status);
+                read_unlock(&port->unit_list_lock);
                 zfcp_erp_port_boxed(port, "fscpph2", req);
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR |
-                               ZFCP_STATUS_FSFREQ_RETRY;
-
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
                 switch (header->fsf_status_qual.word[0]) {
@@ -1787,9 +1766,11 @@ static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
                  * ZFCP_STATUS_COMMON_OPEN must not be reset for the port
                  */
                 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
-                list_for_each_entry(unit, &port->unit_list_head, list)
+                read_lock(&port->unit_list_lock);
+                list_for_each_entry(unit, &port->unit_list, list)
                         atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
                                           &unit->status);
+                read_unlock(&port->unit_list_lock);
                 break;
         }
 }
@@ -1819,7 +1800,7 @@ int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -1827,13 +1808,13 @@ int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
         req->qtcb->header.port_handle = erp_action->port->handle;
         req->erp_action = erp_action;
         req->handler = zfcp_fsf_close_physical_port_handler;
-        erp_action->fsf_req = req;
+        erp_action->fsf_req_id = req->req_id;
 
         zfcp_fsf_start_erp_timer(req);
         retval = zfcp_fsf_req_send(req);
         if (retval) {
                 zfcp_fsf_req_free(req);
-                erp_action->fsf_req = NULL;
+                erp_action->fsf_req_id = 0;
         }
 out:
         spin_unlock_bh(&qdio->req_q_lock);
@@ -1873,8 +1854,7 @@ static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
                 break;
         case FSF_PORT_BOXED:
                 zfcp_erp_port_boxed(unit->port, "fsouh_2", req);
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR |
-                               ZFCP_STATUS_FSFREQ_RETRY;
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_LUN_SHARING_VIOLATION:
                 if (header->fsf_status_qual.word[0])
@@ -1993,7 +1973,7 @@ int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -2002,7 +1982,7 @@ int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
         req->handler = zfcp_fsf_open_unit_handler;
         req->data = erp_action->unit;
         req->erp_action = erp_action;
-        erp_action->fsf_req = req;
+        erp_action->fsf_req_id = req->req_id;
 
         if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE))
                 req->qtcb->bottom.support.option = FSF_OPEN_LUN_SUPPRESS_BOXING;
@@ -2011,7 +1991,7 @@ int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
         retval = zfcp_fsf_req_send(req);
         if (retval) {
                 zfcp_fsf_req_free(req);
-                erp_action->fsf_req = NULL;
+                erp_action->fsf_req_id = 0;
         }
 out:
         spin_unlock_bh(&qdio->req_q_lock);
@@ -2036,8 +2016,7 @@ static void zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *req)
                 break;
         case FSF_PORT_BOXED:
                 zfcp_erp_port_boxed(unit->port, "fscuh_3", req);
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR |
-                               ZFCP_STATUS_FSFREQ_RETRY;
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
                 switch (req->qtcb->header.fsf_status_qual.word[0]) {
@@ -2080,7 +2059,7 @@ int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -2089,13 +2068,13 @@ int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
         req->handler = zfcp_fsf_close_unit_handler;
         req->data = erp_action->unit;
         req->erp_action = erp_action;
-        erp_action->fsf_req = req;
+        erp_action->fsf_req_id = req->req_id;
 
         zfcp_fsf_start_erp_timer(req);
         retval = zfcp_fsf_req_send(req);
         if (retval) {
                 zfcp_fsf_req_free(req);
-                erp_action->fsf_req = NULL;
+                erp_action->fsf_req_id = 0;
         }
 out:
         spin_unlock_bh(&qdio->req_q_lock);
@@ -2109,72 +2088,58 @@ static void zfcp_fsf_update_lat(struct fsf_latency_record *lat_rec, u32 lat)
         lat_rec->max = max(lat_rec->max, lat);
 }
 
-static void zfcp_fsf_req_latency(struct zfcp_fsf_req *req)
+static void zfcp_fsf_req_trace(struct zfcp_fsf_req *req, struct scsi_cmnd *scsi)
 {
-        struct fsf_qual_latency_info *lat_inf;
-        struct latency_cont *lat;
+        struct fsf_qual_latency_info *lat_in;
+        struct latency_cont *lat = NULL;
         struct zfcp_unit *unit = req->unit;
+        struct zfcp_blk_drv_data blktrc;
+        int ticks = req->adapter->timer_ticks;
 
-        lat_inf = &req->qtcb->prefix.prot_status_qual.latency_info;
+        lat_in = &req->qtcb->prefix.prot_status_qual.latency_info;
 
-        switch (req->qtcb->bottom.io.data_direction) {
-        case FSF_DATADIR_READ:
-                lat = &unit->latencies.read;
-                break;
-        case FSF_DATADIR_WRITE:
-                lat = &unit->latencies.write;
-                break;
-        case FSF_DATADIR_CMND:
-                lat = &unit->latencies.cmd;
-                break;
-        default:
-                return;
-        }
-
-        spin_lock(&unit->latencies.lock);
-        zfcp_fsf_update_lat(&lat->channel, lat_inf->channel_lat);
-        zfcp_fsf_update_lat(&lat->fabric, lat_inf->fabric_lat);
-        lat->counter++;
-        spin_unlock(&unit->latencies.lock);
-}
-
-#ifdef CONFIG_BLK_DEV_IO_TRACE
-static void zfcp_fsf_trace_latency(struct zfcp_fsf_req *fsf_req)
-{
-        struct fsf_qual_latency_info *lat_inf;
-        struct scsi_cmnd *scsi_cmnd = (struct scsi_cmnd *)fsf_req->data;
-        struct request *req = scsi_cmnd->request;
-        struct zfcp_blk_drv_data trace;
-        int ticks = fsf_req->adapter->timer_ticks;
+        blktrc.flags = 0;
+        blktrc.magic = ZFCP_BLK_DRV_DATA_MAGIC;
+        if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
+                blktrc.flags |= ZFCP_BLK_REQ_ERROR;
+        blktrc.inb_usage = req->qdio_req.qdio_inb_usage;
+        blktrc.outb_usage = req->qdio_req.qdio_outb_usage;
+
+        if (req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA &&
+            !(req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
+                blktrc.flags |= ZFCP_BLK_LAT_VALID;
+                blktrc.channel_lat = lat_in->channel_lat * ticks;
+                blktrc.fabric_lat = lat_in->fabric_lat * ticks;
+
+                switch (req->qtcb->bottom.io.data_direction) {
+                case FSF_DATADIR_READ:
+                        lat = &unit->latencies.read;
+                        break;
+                case FSF_DATADIR_WRITE:
+                        lat = &unit->latencies.write;
+                        break;
+                case FSF_DATADIR_CMND:
+                        lat = &unit->latencies.cmd;
+                        break;
+                }
 
-        trace.flags = 0;
-        trace.magic = ZFCP_BLK_DRV_DATA_MAGIC;
-        if (fsf_req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA) {
-                trace.flags |= ZFCP_BLK_LAT_VALID;
-                lat_inf = &fsf_req->qtcb->prefix.prot_status_qual.latency_info;
-                trace.channel_lat = lat_inf->channel_lat * ticks;
-                trace.fabric_lat = lat_inf->fabric_lat * ticks;
+                if (lat) {
+                        spin_lock(&unit->latencies.lock);
+                        zfcp_fsf_update_lat(&lat->channel, lat_in->channel_lat);
+                        zfcp_fsf_update_lat(&lat->fabric, lat_in->fabric_lat);
+                        lat->counter++;
+                        spin_unlock(&unit->latencies.lock);
+                }
         }
-        if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)
-                trace.flags |= ZFCP_BLK_REQ_ERROR;
-        trace.inb_usage = fsf_req->queue_req.qdio_inb_usage;
-        trace.outb_usage = fsf_req->queue_req.qdio_outb_usage;
 
-        blk_add_driver_data(req->q, req, &trace, sizeof(trace));
-}
-#else
-static inline void zfcp_fsf_trace_latency(struct zfcp_fsf_req *fsf_req)
-{
+        blk_add_driver_data(scsi->request->q, scsi->request, &blktrc,
+                            sizeof(blktrc));
 }
-#endif
 
 static void zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *req)
 {
         struct scsi_cmnd *scpnt;
-        struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *)
-            &(req->qtcb->bottom.io.fcp_rsp);
-        u32 sns_len;
-        char *fcp_rsp_info = (unsigned char *) &fcp_rsp_iu[1];
+        struct fcp_resp_with_ext *fcp_rsp;
         unsigned long flags;
 
         read_lock_irqsave(&req->adapter->abort_lock, flags);
@@ -2185,57 +2150,17 @@ static void zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *req)
                 return;
         }
 
-        if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ABORTED)) {
-                set_host_byte(scpnt, DID_SOFT_ERROR);
-                goto skip_fsfstatus;
-        }
-
         if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
-                set_host_byte(scpnt, DID_ERROR);
+                set_host_byte(scpnt, DID_TRANSPORT_DISRUPTED);
                 goto skip_fsfstatus;
         }
 
-        set_msg_byte(scpnt, COMMAND_COMPLETE);
-
-        scpnt->result |= fcp_rsp_iu->scsi_status;
-
-        if (req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA)
-                zfcp_fsf_req_latency(req);
-
-        zfcp_fsf_trace_latency(req);
-
-        if (unlikely(fcp_rsp_iu->validity.bits.fcp_rsp_len_valid)) {
-                if (fcp_rsp_info[3] == RSP_CODE_GOOD)
-                        set_host_byte(scpnt, DID_OK);
-                else {
-                        set_host_byte(scpnt, DID_ERROR);
-                        goto skip_fsfstatus;
-                }
-        }
-
-        if (unlikely(fcp_rsp_iu->validity.bits.fcp_sns_len_valid)) {
-                sns_len = FSF_FCP_RSP_SIZE - sizeof(struct fcp_rsp_iu) +
-                          fcp_rsp_iu->fcp_rsp_len;
-                sns_len = min(sns_len, (u32) SCSI_SENSE_BUFFERSIZE);
-                sns_len = min(sns_len, fcp_rsp_iu->fcp_sns_len);
-
-                memcpy(scpnt->sense_buffer,
-                       zfcp_get_fcp_sns_info_ptr(fcp_rsp_iu), sns_len);
-        }
+        fcp_rsp = (struct fcp_resp_with_ext *) &req->qtcb->bottom.io.fcp_rsp;
+        zfcp_fc_eval_fcp_rsp(fcp_rsp, scpnt);
 
-        if (unlikely(fcp_rsp_iu->validity.bits.fcp_resid_under)) {
-                scsi_set_resid(scpnt, fcp_rsp_iu->fcp_resid);
-                if (scsi_bufflen(scpnt) - scsi_get_resid(scpnt) <
-                    scpnt->underflow)
-                        set_host_byte(scpnt, DID_ERROR);
-        }
 skip_fsfstatus:
-        if (scpnt->result != 0)
-                zfcp_dbf_scsi_result("erro", 3, req->adapter->dbf, scpnt, req);
-        else if (scpnt->retries > 0)
-                zfcp_dbf_scsi_result("retr", 4, req->adapter->dbf, scpnt, req);
-        else
-                zfcp_dbf_scsi_result("norm", 6, req->adapter->dbf, scpnt, req);
+        zfcp_fsf_req_trace(req, scpnt);
+        zfcp_dbf_scsi_result(req->adapter->dbf, scpnt, req);
 
         scpnt->host_scribble = NULL;
         (scpnt->scsi_done) (scpnt);
@@ -2250,11 +2175,13 @@ skip_fsfstatus:
 
 static void zfcp_fsf_send_fcp_ctm_handler(struct zfcp_fsf_req *req)
 {
-        struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *)
-            &(req->qtcb->bottom.io.fcp_rsp);
-        char *fcp_rsp_info = (unsigned char *) &fcp_rsp_iu[1];
+        struct fcp_resp_with_ext *fcp_rsp;
+        struct fcp_resp_rsp_info *rsp_info;
+
+        fcp_rsp = (struct fcp_resp_with_ext *) &req->qtcb->bottom.io.fcp_rsp;
+        rsp_info = (struct fcp_resp_rsp_info *) &fcp_rsp[1];
 
-        if ((fcp_rsp_info[3] != RSP_CODE_GOOD) ||
+        if ((rsp_info->rsp_code != FCP_TMF_CMPL) ||
              (req->status & ZFCP_STATUS_FSFREQ_ERROR))
                 req->status |= ZFCP_STATUS_FSFREQ_TMFUNCFAILED;
 }
@@ -2314,13 +2241,11 @@ static void zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *req)
                 break;
         case FSF_PORT_BOXED:
                 zfcp_erp_port_boxed(unit->port, "fssfch5", req);
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR |
-                               ZFCP_STATUS_FSFREQ_RETRY;
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_LUN_BOXED:
                 zfcp_erp_unit_boxed(unit, "fssfch6", req);
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR |
-                               ZFCP_STATUS_FSFREQ_RETRY;
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
                 if (header->fsf_status_qual.word[0] ==
@@ -2335,24 +2260,10 @@ skip_fsfstatus:
         else {
                 zfcp_fsf_send_fcp_command_task_handler(req);
                 req->unit = NULL;
-                zfcp_unit_put(unit);
+                put_device(&unit->dev);
         }
 }
 
-static void zfcp_set_fcp_dl(struct fcp_cmnd_iu *fcp_cmd, u32 fcp_dl)
-{
-        u32 *fcp_dl_ptr;
-
-        /*
-         * fcp_dl_addr = start address of fcp_cmnd structure +
-         * size of fixed part + size of dynamically sized add_dcp_cdb field
-         * SEE FCP-2 documentation
-         */
-        fcp_dl_ptr = (u32 *) ((unsigned char *) &fcp_cmd[1] +
-                        (fcp_cmd->add_fcp_cdb_length << 2));
-        *fcp_dl_ptr = fcp_dl;
-}
-
 /**
  * zfcp_fsf_send_fcp_command_task - initiate an FCP command (for a SCSI command)
  * @unit: unit where command is sent to
@@ -2362,7 +2273,7 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
                                    struct scsi_cmnd *scsi_cmnd)
 {
         struct zfcp_fsf_req *req;
-        struct fcp_cmnd_iu *fcp_cmnd_iu;
+        struct fcp_cmnd *fcp_cmnd;
         unsigned int sbtype = SBAL_FLAGS0_TYPE_READ;
         int real_bytes, retval = -EIO;
         struct zfcp_adapter *adapter = unit->port->adapter;
@@ -2387,23 +2298,21 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        zfcp_unit_get(unit);
+        get_device(&unit->dev);
         req->unit = unit;
         req->data = scsi_cmnd;
         req->handler = zfcp_fsf_send_fcp_command_handler;
         req->qtcb->header.lun_handle = unit->handle;
         req->qtcb->header.port_handle = unit->port->handle;
         req->qtcb->bottom.io.service_class = FSF_CLASS_3;
+        req->qtcb->bottom.io.fcp_cmnd_length = FCP_CMND_LEN;
 
         scsi_cmnd->host_scribble = (unsigned char *) req->req_id;
 
-        fcp_cmnd_iu = (struct fcp_cmnd_iu *) &(req->qtcb->bottom.io.fcp_cmnd);
-        fcp_cmnd_iu->fcp_lun = unit->fcp_lun;
         /*
          * set depending on data direction:
          *      data direction bits in SBALE (SB Type)
          *      data direction bits in QTCB
-         *      data direction bits in FCP_CMND IU
          */
         switch (scsi_cmnd->sc_data_direction) {
         case DMA_NONE:
@@ -2411,38 +2320,23 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
                 break;
         case DMA_FROM_DEVICE:
                 req->qtcb->bottom.io.data_direction = FSF_DATADIR_READ;
-                fcp_cmnd_iu->rddata = 1;
                 break;
         case DMA_TO_DEVICE:
                 req->qtcb->bottom.io.data_direction = FSF_DATADIR_WRITE;
                 sbtype = SBAL_FLAGS0_TYPE_WRITE;
-                fcp_cmnd_iu->wddata = 1;
                 break;
         case DMA_BIDIRECTIONAL:
                 goto failed_scsi_cmnd;
         }
 
-        if (likely((scsi_cmnd->device->simple_tags) ||
-                   ((atomic_read(&unit->status) & ZFCP_STATUS_UNIT_READONLY) &&
-                    (atomic_read(&unit->status) & ZFCP_STATUS_UNIT_SHARED))))
-                fcp_cmnd_iu->task_attribute = SIMPLE_Q;
-        else
-                fcp_cmnd_iu->task_attribute = UNTAGGED;
-
-        if (unlikely(scsi_cmnd->cmd_len > FCP_CDB_LENGTH))
-                fcp_cmnd_iu->add_fcp_cdb_length =
-                        (scsi_cmnd->cmd_len - FCP_CDB_LENGTH) >> 2;
+        fcp_cmnd = (struct fcp_cmnd *) &req->qtcb->bottom.io.fcp_cmnd;
+        zfcp_fc_scsi_to_fcp(fcp_cmnd, scsi_cmnd);
 
-        memcpy(fcp_cmnd_iu->fcp_cdb, scsi_cmnd->cmnd, scsi_cmnd->cmd_len);
-
-        req->qtcb->bottom.io.fcp_cmnd_length = sizeof(struct fcp_cmnd_iu) +
-                fcp_cmnd_iu->add_fcp_cdb_length + sizeof(u32);
-
-        real_bytes = zfcp_qdio_sbals_from_sg(qdio, &req->queue_req, sbtype,
+        real_bytes = zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req, sbtype,
                                              scsi_sglist(scsi_cmnd),
                                              FSF_MAX_SBALS_PER_REQ);
         if (unlikely(real_bytes < 0)) {
-                if (req->queue_req.sbal_number >= FSF_MAX_SBALS_PER_REQ) {
+                if (req->qdio_req.sbal_number >= FSF_MAX_SBALS_PER_REQ) {
                         dev_err(&adapter->ccw_device->dev,
                                 "Oversize data package, unit 0x%016Lx "
                                 "on port 0x%016Lx closed\n",
@@ -2454,8 +2348,6 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
                 goto failed_scsi_cmnd;
         }
 
-        zfcp_set_fcp_dl(fcp_cmnd_iu, real_bytes);
-
         retval = zfcp_fsf_req_send(req);
         if (unlikely(retval))
                 goto failed_scsi_cmnd;
@@ -2463,7 +2355,7 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
         goto out;
 
 failed_scsi_cmnd:
-        zfcp_unit_put(unit);
+        put_device(&unit->dev);
         zfcp_fsf_req_free(req);
         scsi_cmnd->host_scribble = NULL;
 out:
@@ -2481,7 +2373,7 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_unit *unit, u8 tm_flags)
 {
         struct qdio_buffer_element *sbale;
         struct zfcp_fsf_req *req = NULL;
-        struct fcp_cmnd_iu *fcp_cmnd_iu;
+        struct fcp_cmnd *fcp_cmnd;
         struct zfcp_qdio *qdio = unit->port->adapter->qdio;
 
         if (unlikely(!(atomic_read(&unit->status) &
@@ -2507,16 +2399,14 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_unit *unit, u8 tm_flags)
         req->qtcb->header.port_handle = unit->port->handle;
         req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
         req->qtcb->bottom.io.service_class = FSF_CLASS_3;
-        req->qtcb->bottom.io.fcp_cmnd_length =  sizeof(struct fcp_cmnd_iu) +
-                                                sizeof(u32);
+        req->qtcb->bottom.io.fcp_cmnd_length = FCP_CMND_LEN;
 
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
-        fcp_cmnd_iu = (struct fcp_cmnd_iu *) &req->qtcb->bottom.io.fcp_cmnd;
-        fcp_cmnd_iu->fcp_lun = unit->fcp_lun;
-        fcp_cmnd_iu->task_management_flags = tm_flags;
+        fcp_cmnd = (struct fcp_cmnd *) &req->qtcb->bottom.io.fcp_cmnd;
+        zfcp_fc_fcp_tm(fcp_cmnd, unit->device, tm_flags);
 
         zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT);
         if (!zfcp_fsf_req_send(req))
@@ -2574,14 +2464,14 @@ struct zfcp_fsf_req *zfcp_fsf_control_file(struct zfcp_adapter *adapter,
 
         req->handler = zfcp_fsf_control_file_handler;
 
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= direction;
 
         bottom = &req->qtcb->bottom.support;
         bottom->operation_subtype = FSF_CFDC_OPERATION_SUBTYPE;
         bottom->option = fsf_cfdc->option;
 
-        bytes = zfcp_qdio_sbals_from_sg(qdio, &req->queue_req,
+        bytes = zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req,
                                         direction, fsf_cfdc->sg,
                                         FSF_MAX_SBALS_PER_REQ);
         if (bytes != ZFCP_CFDC_MAX_SIZE) {
@@ -2612,15 +2502,14 @@ void zfcp_fsf_reqid_check(struct zfcp_qdio *qdio, int sbal_idx)
         struct qdio_buffer *sbal = qdio->resp_q.sbal[sbal_idx];
         struct qdio_buffer_element *sbale;
         struct zfcp_fsf_req *fsf_req;
-        unsigned long flags, req_id;
+        unsigned long req_id;
         int idx;
 
         for (idx = 0; idx < QDIO_MAX_ELEMENTS_PER_BUFFER; idx++) {
 
                 sbale = &sbal->element[idx];
                 req_id = (unsigned long) sbale->addr;
-                spin_lock_irqsave(&adapter->req_list_lock, flags);
-                fsf_req = zfcp_reqlist_find(adapter, req_id);
+                fsf_req = zfcp_reqlist_find_rm(adapter->req_list, req_id);
 
                 if (!fsf_req)
                         /*
@@ -2630,11 +2519,8 @@ void zfcp_fsf_reqid_check(struct zfcp_qdio *qdio, int sbal_idx)
                         panic("error: unknown req_id (%lx) on adapter %s.\n",
                               req_id, dev_name(&adapter->ccw_device->dev));
 
-                list_del(&fsf_req->list);
-                spin_unlock_irqrestore(&adapter->req_list_lock, flags);
-
-                fsf_req->queue_req.sbal_response = sbal_idx;
-                fsf_req->queue_req.qdio_inb_usage =
+                fsf_req->qdio_req.sbal_response = sbal_idx;
+                fsf_req->qdio_req.qdio_inb_usage =
                         atomic_read(&qdio->resp_q.count);
                 zfcp_fsf_req_complete(fsf_req);
 
diff --git a/drivers/s390/scsi/zfcp_fsf.h b/drivers/s390/scsi/zfcp_fsf.h
index dcc7c1dbcf58..b3de682b64cf 100644
--- a/drivers/s390/scsi/zfcp_fsf.h
+++ b/drivers/s390/scsi/zfcp_fsf.h
@@ -11,6 +11,7 @@
 
 #include <linux/pfn.h>
 #include <linux/scatterlist.h>
+#include <scsi/libfc.h>
 
 #define FSF_QTCB_CURRENT_VERSION                0x00000001
 
@@ -228,7 +229,8 @@ struct fsf_status_read_buffer {
         u32 length;
         u32 res1;
         struct fsf_queue_designator queue_designator;
-        u32 d_id;
+        u8 res2;
+        u8 d_id[3];
         u32 class;
         u64 fcp_lun;
         u8  res3[24];
@@ -309,22 +311,7 @@ struct fsf_qtcb_header {
         u8  res4[16];
 } __attribute__ ((packed));
 
-struct fsf_nport_serv_param {
-        u8  common_serv_param[16];
-        u64 wwpn;
-        u64 wwnn;
-        u8  class1_serv_param[16];
-        u8  class2_serv_param[16];
-        u8  class3_serv_param[16];
-        u8  class4_serv_param[16];
-        u8  vendor_version_level[16];
-} __attribute__ ((packed));
-
 #define FSF_PLOGI_MIN_LEN       112
-struct fsf_plogi {
-        u32    code;
-        struct fsf_nport_serv_param serv_param;
-} __attribute__ ((packed));
 
 #define FSF_FCP_CMND_SIZE       288
 #define FSF_FCP_RSP_SIZE        128
@@ -342,8 +329,8 @@ struct fsf_qtcb_bottom_io {
 
 struct fsf_qtcb_bottom_support {
         u32 operation_subtype;
-        u8  res1[12];
-        u32 d_id;
+        u8  res1[13];
+        u8 d_id[3];
         u32 option;
         u64 fcp_lun;
         u64 res2;
@@ -372,18 +359,18 @@ struct fsf_qtcb_bottom_config {
         u32 fc_topology;
         u32 fc_link_speed;
         u32 adapter_type;
-        u32 peer_d_id;
+        u8 res0;
+        u8 peer_d_id[3];
         u8 res1[2];
         u16 timer_interval;
-        u8 res2[8];
-        u32 s_id;
-        struct fsf_nport_serv_param nport_serv_param;
-        u8 reserved_nport_serv_param[16];
+        u8 res2[9];
+        u8 s_id[3];
+        u8 nport_serv_param[128];
         u8 res3[8];
         u32 adapter_ports;
         u32 hardware_version;
         u8 serial_number[32];
-        struct fsf_nport_serv_param plogi_payload;
+        u8 plogi_payload[112];
         struct fsf_statistics_info stat_info;
         u8 res4[112];
 } __attribute__ ((packed));
@@ -450,4 +437,22 @@ struct zfcp_blk_drv_data {
         u64 fabric_lat;
 } __attribute__ ((packed));
 
+/**
+ * struct zfcp_fsf_ct_els - zfcp data for ct or els request
+ * @req: scatter-gather list for request
+ * @resp: scatter-gather list for response
+ * @handler: handler function (called for response to the request)
+ * @handler_data: data passed to handler function
+ * @port: Optional pointer to port for zfcp internal ELS (only test link ADISC)
+ * @status: used to pass error status to calling function
+ */
+struct zfcp_fsf_ct_els {
+        struct scatterlist *req;
+        struct scatterlist *resp;
+        void (*handler)(void *);
+        void *handler_data;
+        struct zfcp_port *port;
+        int status;
+};
+
 #endif                          /* FSF_H */
diff --git a/drivers/s390/scsi/zfcp_qdio.c b/drivers/s390/scsi/zfcp_qdio.c
index 6c5228b627fc..dbfa312a7f50 100644
--- a/drivers/s390/scsi/zfcp_qdio.c
+++ b/drivers/s390/scsi/zfcp_qdio.c
@@ -9,7 +9,9 @@
 #define KMSG_COMPONENT "zfcp"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
+#include <linux/slab.h>
 #include "zfcp_ext.h"
+#include "zfcp_qdio.h"
 
 #define QBUFF_PER_PAGE          (PAGE_SIZE / sizeof(struct qdio_buffer))
 
@@ -28,12 +30,6 @@ static int zfcp_qdio_buffers_enqueue(struct qdio_buffer **sbal)
         return 0;
 }
 
-static struct qdio_buffer_element *
-zfcp_qdio_sbale(struct zfcp_qdio_queue *q, int sbal_idx, int sbale_idx)
-{
-        return &q->sbal[sbal_idx]->element[sbale_idx];
-}
-
 static void zfcp_qdio_handler_error(struct zfcp_qdio *qdio, char *id)
 {
         struct zfcp_adapter *adapter = qdio->adapter;
@@ -106,7 +102,7 @@ static void zfcp_qdio_resp_put_back(struct zfcp_qdio *qdio, int processed)
 
         if (unlikely(retval)) {
                 atomic_set(&queue->count, count);
-                /* FIXME: Recover this with an adapter reopen? */
+                zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdrpb_1", NULL);
         } else {
                 queue->first += count;
                 queue->first %= QDIO_MAX_BUFFERS_PER_Q;
@@ -145,32 +141,8 @@ static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err,
         zfcp_qdio_resp_put_back(qdio, count);
 }
 
-/**
- * zfcp_qdio_sbale_req - return ptr to SBALE of req_q for a struct zfcp_fsf_req
- * @qdio: pointer to struct zfcp_qdio
- * @q_rec: pointer to struct zfcp_queue_rec
- * Returns: pointer to qdio_buffer_element (SBALE) structure
- */
-struct qdio_buffer_element *zfcp_qdio_sbale_req(struct zfcp_qdio *qdio,
-                                                struct zfcp_queue_req *q_req)
-{
-        return zfcp_qdio_sbale(&qdio->req_q, q_req->sbal_last, 0);
-}
-
-/**
- * zfcp_qdio_sbale_curr - return curr SBALE on req_q for a struct zfcp_fsf_req
- * @fsf_req: pointer to struct fsf_req
- * Returns: pointer to qdio_buffer_element (SBALE) structure
- */
-struct qdio_buffer_element *zfcp_qdio_sbale_curr(struct zfcp_qdio *qdio,
-                                                 struct zfcp_queue_req *q_req)
-{
-        return zfcp_qdio_sbale(&qdio->req_q, q_req->sbal_last,
-                               q_req->sbale_curr);
-}
-
 static void zfcp_qdio_sbal_limit(struct zfcp_qdio *qdio,
-                                 struct zfcp_queue_req *q_req, int max_sbals)
+                                 struct zfcp_qdio_req *q_req, int max_sbals)
 {
         int count = atomic_read(&qdio->req_q.count);
         count = min(count, max_sbals);
@@ -179,7 +151,7 @@ static void zfcp_qdio_sbal_limit(struct zfcp_qdio *qdio,
 }
 
 static struct qdio_buffer_element *
-zfcp_qdio_sbal_chain(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req,
+zfcp_qdio_sbal_chain(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req,
                      unsigned long sbtype)
 {
         struct qdio_buffer_element *sbale;
@@ -214,7 +186,7 @@ zfcp_qdio_sbal_chain(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req,
 }
 
 static struct qdio_buffer_element *
-zfcp_qdio_sbale_next(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req,
+zfcp_qdio_sbale_next(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req,
                      unsigned int sbtype)
 {
         if (q_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL)
@@ -224,7 +196,7 @@ zfcp_qdio_sbale_next(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req,
 }
 
 static void zfcp_qdio_undo_sbals(struct zfcp_qdio *qdio,
-                                 struct zfcp_queue_req *q_req)
+                                 struct zfcp_qdio_req *q_req)
 {
         struct qdio_buffer **sbal = qdio->req_q.sbal;
         int first = q_req->sbal_first;
@@ -235,7 +207,7 @@ static void zfcp_qdio_undo_sbals(struct zfcp_qdio *qdio,
 }
 
 static int zfcp_qdio_fill_sbals(struct zfcp_qdio *qdio,
-                                struct zfcp_queue_req *q_req,
+                                struct zfcp_qdio_req *q_req,
                                 unsigned int sbtype, void *start_addr,
                                 unsigned int total_length)
 {
@@ -271,8 +243,7 @@ static int zfcp_qdio_fill_sbals(struct zfcp_qdio *qdio,
  * @max_sbals: upper bound for number of SBALs to be used
  * Returns: number of bytes, or error (negativ)
  */
-int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *qdio,
-                            struct zfcp_queue_req *q_req,
+int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req,
                             unsigned long sbtype, struct scatterlist *sg,
                             int max_sbals)
 {
@@ -304,10 +275,10 @@ int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *qdio,
 /**
  * zfcp_qdio_send - set PCI flag in first SBALE and send req to QDIO
  * @qdio: pointer to struct zfcp_qdio
- * @q_req: pointer to struct zfcp_queue_req
+ * @q_req: pointer to struct zfcp_qdio_req
  * Returns: 0 on success, error otherwise
  */
-int zfcp_qdio_send(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req)
+int zfcp_qdio_send(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req)
 {
         struct zfcp_qdio_queue *req_q = &qdio->req_q;
         int first = q_req->sbal_first;
@@ -349,8 +320,6 @@ static void zfcp_qdio_setup_init_data(struct qdio_initialize *id,
         id->input_handler = zfcp_qdio_int_resp;
         id->output_handler = zfcp_qdio_int_req;
         id->int_parm = (unsigned long) qdio;
-        id->flags = QDIO_INBOUND_0COPY_SBALS |
-                    QDIO_OUTBOUND_0COPY_SBALS | QDIO_USE_OUTBOUND_PCIS;
         id->input_sbal_addr_array = (void **) (qdio->resp_q.sbal);
         id->output_sbal_addr_array = (void **) (qdio->req_q.sbal);
 
diff --git a/drivers/s390/scsi/zfcp_qdio.h b/drivers/s390/scsi/zfcp_qdio.h
new file mode 100644
index 000000000000..8cca54631e1e
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_qdio.h
@@ -0,0 +1,109 @@
+/*
+ * zfcp device driver
+ *
+ * Header file for zfcp qdio interface
+ *
+ * Copyright IBM Corporation 2010
+ */
+
+#ifndef ZFCP_QDIO_H
+#define ZFCP_QDIO_H
+
+#include <asm/qdio.h>
+
+/**
+ * struct zfcp_qdio_queue - qdio queue buffer, zfcp index and free count
+ * @sbal: qdio buffers
+ * @first: index of next free buffer in queue
+ * @count: number of free buffers in queue
+ */
+struct zfcp_qdio_queue {
+        struct qdio_buffer *sbal[QDIO_MAX_BUFFERS_PER_Q];
+        u8                 first;
+        atomic_t           count;
+};
+
+/**
+ * struct zfcp_qdio - basic qdio data structure
+ * @resp_q: response queue
+ * @req_q: request queue
+ * @stat_lock: lock to protect req_q_util and req_q_time
+ * @req_q_lock: lock to serialize access to request queue
+ * @req_q_time: time of last fill level change
+ * @req_q_util: used for accounting
+ * @req_q_full: queue full incidents
+ * @req_q_wq: used to wait for SBAL availability
+ * @adapter: adapter used in conjunction with this qdio structure
+ */
+struct zfcp_qdio {
+        struct zfcp_qdio_queue  resp_q;
+        struct zfcp_qdio_queue  req_q;
+        spinlock_t              stat_lock;
+        spinlock_t              req_q_lock;
+        unsigned long long      req_q_time;
+        u64                     req_q_util;
+        atomic_t                req_q_full;
+        wait_queue_head_t       req_q_wq;
+        struct zfcp_adapter     *adapter;
+};
+
+/**
+ * struct zfcp_qdio_req - qdio queue related values for a request
+ * @sbal_number: number of free sbals
+ * @sbal_first: first sbal for this request
+ * @sbal_last: last sbal for this request
+ * @sbal_limit: last possible sbal for this request
+ * @sbale_curr: current sbale at creation of this request
+ * @sbal_response: sbal used in interrupt
+ * @qdio_outb_usage: usage of outbound queue
+ * @qdio_inb_usage: usage of inbound queue
+ */
+struct zfcp_qdio_req {
+        u8      sbal_number;
+        u8      sbal_first;
+        u8      sbal_last;
+        u8      sbal_limit;
+        u8      sbale_curr;
+        u8      sbal_response;
+        u16     qdio_outb_usage;
+        u16     qdio_inb_usage;
+};
+
+/**
+ * zfcp_qdio_sbale - return pointer to sbale in qdio queue
+ * @q: queue where to find sbal
+ * @sbal_idx: sbal index in queue
+ * @sbale_idx: sbale index in sbal
+ */
+static inline struct qdio_buffer_element *
+zfcp_qdio_sbale(struct zfcp_qdio_queue *q, int sbal_idx, int sbale_idx)
+{
+        return &q->sbal[sbal_idx]->element[sbale_idx];
+}
+
+/**
+ * zfcp_qdio_sbale_req - return pointer to sbale on req_q for a request
+ * @qdio: pointer to struct zfcp_qdio
+ * @q_rec: pointer to struct zfcp_qdio_req
+ * Returns: pointer to qdio_buffer_element (sbale) structure
+ */
+static inline struct qdio_buffer_element *
+zfcp_qdio_sbale_req(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req)
+{
+        return zfcp_qdio_sbale(&qdio->req_q, q_req->sbal_last, 0);
+}
+
+/**
+ * zfcp_qdio_sbale_curr - return current sbale on req_q for a request
+ * @qdio: pointer to struct zfcp_qdio
+ * @fsf_req: pointer to struct zfcp_fsf_req
+ * Returns: pointer to qdio_buffer_element (sbale) structure
+ */
+static inline struct qdio_buffer_element *
+zfcp_qdio_sbale_curr(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req)
+{
+        return zfcp_qdio_sbale(&qdio->req_q, q_req->sbal_last,
+                               q_req->sbale_curr);
+}
+
+#endif /* ZFCP_QDIO_H */
diff --git a/drivers/s390/scsi/zfcp_reqlist.h b/drivers/s390/scsi/zfcp_reqlist.h
new file mode 100644
index 000000000000..a72d1b730aba
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_reqlist.h
@@ -0,0 +1,183 @@
+/*
+ * zfcp device driver
+ *
+ * Data structure and helper functions for tracking pending FSF
+ * requests.
+ *
+ * Copyright IBM Corporation 2009
+ */
+
+#ifndef ZFCP_REQLIST_H
+#define ZFCP_REQLIST_H
+
+/* number of hash buckets */
+#define ZFCP_REQ_LIST_BUCKETS 128
+
+/**
+ * struct zfcp_reqlist - Container for request list (reqlist)
+ * @lock: Spinlock for protecting the hash list
+ * @list: Array of hashbuckets, each is a list of requests in this bucket
+ */
+struct zfcp_reqlist {
+        spinlock_t lock;
+        struct list_head buckets[ZFCP_REQ_LIST_BUCKETS];
+};
+
+static inline int zfcp_reqlist_hash(unsigned long req_id)
+{
+        return req_id % ZFCP_REQ_LIST_BUCKETS;
+}
+
+/**
+ * zfcp_reqlist_alloc - Allocate and initialize reqlist
+ *
+ * Returns pointer to allocated reqlist on success, or NULL on
+ * allocation failure.
+ */
+static inline struct zfcp_reqlist *zfcp_reqlist_alloc(void)
+{
+        unsigned int i;
+        struct zfcp_reqlist *rl;
+
+        rl = kzalloc(sizeof(struct zfcp_reqlist), GFP_KERNEL);
+        if (!rl)
+                return NULL;
+
+        spin_lock_init(&rl->lock);
+
+        for (i = 0; i < ZFCP_REQ_LIST_BUCKETS; i++)
+                INIT_LIST_HEAD(&rl->buckets[i]);
+
+        return rl;
+}
+
+/**
+ * zfcp_reqlist_isempty - Check whether the request list empty
+ * @rl: pointer to reqlist
+ *
+ * Returns: 1 if list is empty, 0 if not
+ */
+static inline int zfcp_reqlist_isempty(struct zfcp_reqlist *rl)
+{
+        unsigned int i;
+
+        for (i = 0; i < ZFCP_REQ_LIST_BUCKETS; i++)
+                if (!list_empty(&rl->buckets[i]))
+                        return 0;
+        return 1;
+}
+
+/**
+ * zfcp_reqlist_free - Free allocated memory for reqlist
+ * @rl: The reqlist where to free memory
+ */
+static inline void zfcp_reqlist_free(struct zfcp_reqlist *rl)
+{
+        /* sanity check */
+        BUG_ON(!zfcp_reqlist_isempty(rl));
+
+        kfree(rl);
+}
+
+static inline struct zfcp_fsf_req *
+_zfcp_reqlist_find(struct zfcp_reqlist *rl, unsigned long req_id)
+{
+        struct zfcp_fsf_req *req;
+        unsigned int i;
+
+        i = zfcp_reqlist_hash(req_id);
+        list_for_each_entry(req, &rl->buckets[i], list)
+                if (req->req_id == req_id)
+                        return req;
+        return NULL;
+}
+
+/**
+ * zfcp_reqlist_find - Lookup FSF request by its request id
+ * @rl: The reqlist where to lookup the FSF request
+ * @req_id: The request id to look for
+ *
+ * Returns a pointer to the FSF request with the specified request id
+ * or NULL if there is no known FSF request with this id.
+ */
+static inline struct zfcp_fsf_req *
+zfcp_reqlist_find(struct zfcp_reqlist *rl, unsigned long req_id)
+{
+        unsigned long flags;
+        struct zfcp_fsf_req *req;
+
+        spin_lock_irqsave(&rl->lock, flags);
+        req = _zfcp_reqlist_find(rl, req_id);
+        spin_unlock_irqrestore(&rl->lock, flags);
+
+        return req;
+}
+
+/**
+ * zfcp_reqlist_find_rm - Lookup request by id and remove it from reqlist
+ * @rl: reqlist where to search and remove entry
+ * @req_id: The request id of the request to look for
+ *
+ * This functions tries to find the FSF request with the specified
+ * id and then removes it from the reqlist. The reqlist lock is held
+ * during both steps of the operation.
+ *
+ * Returns: Pointer to the FSF request if the request has been found,
+ * NULL if it has not been found.
+ */
+static inline struct zfcp_fsf_req *
+zfcp_reqlist_find_rm(struct zfcp_reqlist *rl, unsigned long req_id)
+{
+        unsigned long flags;
+        struct zfcp_fsf_req *req;
+
+        spin_lock_irqsave(&rl->lock, flags);
+        req = _zfcp_reqlist_find(rl, req_id);
+        if (req)
+                list_del(&req->list);
+        spin_unlock_irqrestore(&rl->lock, flags);
+
+        return req;
+}
+
+/**
+ * zfcp_reqlist_add - Add entry to reqlist
+ * @rl: reqlist where to add the entry
+ * @req: The entry to add
+ *
+ * The request id always increases. As an optimization new requests
+ * are added here with list_add_tail at the end of the bucket lists
+ * while old requests are looked up starting at the beginning of the
+ * lists.
+ */
+static inline void zfcp_reqlist_add(struct zfcp_reqlist *rl,
+                                    struct zfcp_fsf_req *req)
+{
+        unsigned int i;
+        unsigned long flags;
+
+        i = zfcp_reqlist_hash(req->req_id);
+
+        spin_lock_irqsave(&rl->lock, flags);
+        list_add_tail(&req->list, &rl->buckets[i]);
+        spin_unlock_irqrestore(&rl->lock, flags);
+}
+
+/**
+ * zfcp_reqlist_move - Move all entries from reqlist to simple list
+ * @rl: The zfcp_reqlist where to remove all entries
+ * @list: The list where to move all entries
+ */
+static inline void zfcp_reqlist_move(struct zfcp_reqlist *rl,
+                                     struct list_head *list)
+{
+        unsigned int i;
+        unsigned long flags;
+
+        spin_lock_irqsave(&rl->lock, flags);
+        for (i = 0; i < ZFCP_REQ_LIST_BUCKETS; i++)
+                list_splice_init(&rl->buckets[i], list);
+        spin_unlock_irqrestore(&rl->lock, flags);
+}
+
+#endif /* ZFCP_REQLIST_H */
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
index 0e1a34627a2e..174b6d57d576 100644
--- a/drivers/s390/scsi/zfcp_scsi.c
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -3,35 +3,41 @@
  *
  * Interface to Linux SCSI midlayer.
  *
- * Copyright IBM Corporation 2002, 2009
+ * Copyright IBM Corporation 2002, 2010
  */
 
 #define KMSG_COMPONENT "zfcp"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <scsi/fc/fc_fcp.h>
 #include <asm/atomic.h>
 #include "zfcp_ext.h"
 #include "zfcp_dbf.h"
+#include "zfcp_fc.h"
+#include "zfcp_reqlist.h"
 
 static unsigned int default_depth = 32;
 module_param_named(queue_depth, default_depth, uint, 0600);
 MODULE_PARM_DESC(queue_depth, "Default queue depth for new SCSI devices");
 
-/* Find start of Sense Information in FCP response unit*/
-char *zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *fcp_rsp_iu)
+static int zfcp_scsi_change_queue_depth(struct scsi_device *sdev, int depth,
+                                        int reason)
 {
-        char *fcp_sns_info_ptr;
-
-        fcp_sns_info_ptr = (unsigned char *) &fcp_rsp_iu[1];
-        if (fcp_rsp_iu->validity.bits.fcp_rsp_len_valid)
-                fcp_sns_info_ptr += fcp_rsp_iu->fcp_rsp_len;
-
-        return fcp_sns_info_ptr;
-}
-
-static int zfcp_scsi_change_queue_depth(struct scsi_device *sdev, int depth)
-{
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
+        switch (reason) {
+        case SCSI_QDEPTH_DEFAULT:
+                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
+                break;
+        case SCSI_QDEPTH_QFULL:
+                scsi_track_queue_full(sdev, depth);
+                break;
+        case SCSI_QDEPTH_RAMP_UP:
+                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
+                break;
+        default:
+                return -EOPNOTSUPP;
+        }
         return sdev->queue_depth;
 }
 
@@ -39,7 +45,7 @@ static void zfcp_scsi_slave_destroy(struct scsi_device *sdpnt)
 {
         struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata;
         unit->device = NULL;
-        zfcp_unit_put(unit);
+        put_device(&unit->dev);
 }
 
 static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
@@ -55,10 +61,9 @@ static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result)
 {
         struct zfcp_adapter *adapter =
                 (struct zfcp_adapter *) scpnt->device->host->hostdata[0];
+
         set_host_byte(scpnt, result);
-        if ((scpnt->device != NULL) && (scpnt->device->host != NULL))
-                zfcp_dbf_scsi_result("fail", 4, adapter->dbf, scpnt, NULL);
-        /* return directly */
+        zfcp_dbf_scsi_fail_send(adapter->dbf, scpnt);
         scpnt->scsi_done(scpnt);
 }
 
@@ -82,29 +87,35 @@ static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
         adapter = (struct zfcp_adapter *) scpnt->device->host->hostdata[0];
         unit = scpnt->device->hostdata;
 
-        BUG_ON(!adapter || (adapter != unit->port->adapter));
-        BUG_ON(!scpnt->scsi_done);
-
-        if (unlikely(!unit)) {
-                zfcp_scsi_command_fail(scpnt, DID_NO_CONNECT);
-                return 0;
-        }
-
         scsi_result = fc_remote_port_chkready(rport);
         if (unlikely(scsi_result)) {
                 scpnt->result = scsi_result;
-                zfcp_dbf_scsi_result("fail", 4, adapter->dbf, scpnt, NULL);
+                zfcp_dbf_scsi_fail_send(adapter->dbf, scpnt);
                 scpnt->scsi_done(scpnt);
                 return 0;
         }
 
         status = atomic_read(&unit->status);
-        if (unlikely((status & ZFCP_STATUS_COMMON_ERP_FAILED) ||
-                     !(status & ZFCP_STATUS_COMMON_RUNNING))) {
+        if (unlikely(status & ZFCP_STATUS_COMMON_ERP_FAILED) &&
+                     !(atomic_read(&unit->port->status) &
+                       ZFCP_STATUS_COMMON_ERP_FAILED)) {
+                /* only unit access denied, but port is good
+                 * not covered by FC transport, have to fail here */
                 zfcp_scsi_command_fail(scpnt, DID_ERROR);
                 return 0;
         }
 
+        if (unlikely(!(status & ZFCP_STATUS_COMMON_UNBLOCKED))) {
+                /* This could be either
+                 * open unit pending: this is temporary, will result in
+                 *      open unit or ERP_FAILED, so retry command
+                 * call to rport_delete pending: mimic retry from
+                 *      fc_remote_port_chkready until rport is BLOCKED
+                 */
+                zfcp_scsi_command_fail(scpnt, DID_IMM_RETRY);
+                return 0;
+        }
+
         ret = zfcp_fsf_send_fcp_command_task(unit, scpnt);
         if (unlikely(ret == -EBUSY))
                 return SCSI_MLQUEUE_DEVICE_BUSY;
@@ -115,49 +126,44 @@ static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
 }
 
 static struct zfcp_unit *zfcp_unit_lookup(struct zfcp_adapter *adapter,
-                                          int channel, unsigned int id,
-                                          unsigned int lun)
+                                          unsigned int id, u64 lun)
 {
+        unsigned long flags;
         struct zfcp_port *port;
-        struct zfcp_unit *unit;
-        int scsi_lun;
+        struct zfcp_unit *unit = NULL;
 
-        list_for_each_entry(port, &adapter->port_list_head, list) {
+        read_lock_irqsave(&adapter->port_list_lock, flags);
+        list_for_each_entry(port, &adapter->port_list, list) {
                 if (!port->rport || (id != port->rport->scsi_target_id))
                         continue;
-                list_for_each_entry(unit, &port->unit_list_head, list) {
-                        scsi_lun = scsilun_to_int(
-                                (struct scsi_lun *)&unit->fcp_lun);
-                        if (lun == scsi_lun)
-                                return unit;
-                }
+                unit = zfcp_get_unit_by_lun(port, lun);
+                if (unit)
+                        break;
         }
+        read_unlock_irqrestore(&adapter->port_list_lock, flags);
 
-        return NULL;
+        return unit;
 }
 
 static int zfcp_scsi_slave_alloc(struct scsi_device *sdp)
 {
         struct zfcp_adapter *adapter;
         struct zfcp_unit *unit;
-        unsigned long flags;
-        int retval = -ENXIO;
+        u64 lun;
 
         adapter = (struct zfcp_adapter *) sdp->host->hostdata[0];
         if (!adapter)
                 goto out;
 
-        read_lock_irqsave(&zfcp_data.config_lock, flags);
-        unit = zfcp_unit_lookup(adapter, sdp->channel, sdp->id, sdp->lun);
+        int_to_scsilun(sdp->lun, (struct scsi_lun *)&lun);
+        unit = zfcp_unit_lookup(adapter, sdp->id, lun);
         if (unit) {
                 sdp->hostdata = unit;
                 unit->device = sdp;
-                zfcp_unit_get(unit);
-                retval = 0;
+                return 0;
         }
-        read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 out:
-        return retval;
+        return -ENXIO;
 }
 
 static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
@@ -176,9 +182,7 @@ static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
         /* avoid race condition between late normal completion and abort */
         write_lock_irqsave(&adapter->abort_lock, flags);
 
-        spin_lock(&adapter->req_list_lock);
-        old_req = zfcp_reqlist_find(adapter, old_reqid);
-        spin_unlock(&adapter->req_list_lock);
+        old_req = zfcp_reqlist_find(adapter->req_list, old_reqid);
         if (!old_req) {
                 write_unlock_irqrestore(&adapter->abort_lock, flags);
                 zfcp_dbf_scsi_abort("lte1", adapter->dbf, scpnt, NULL,
@@ -196,6 +200,7 @@ static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
                         break;
 
                 zfcp_erp_wait(adapter);
+                fc_block_scsi_eh(scpnt);
                 if (!(atomic_read(&adapter->status) &
                       ZFCP_STATUS_COMMON_RUNNING)) {
                         zfcp_dbf_scsi_abort("nres", adapter->dbf, scpnt, NULL,
@@ -235,6 +240,7 @@ static int zfcp_task_mgmt_function(struct scsi_cmnd *scpnt, u8 tm_flags)
                         break;
 
                 zfcp_erp_wait(adapter);
+                fc_block_scsi_eh(scpnt);
                 if (!(atomic_read(&adapter->status) &
                       ZFCP_STATUS_COMMON_RUNNING)) {
                         zfcp_dbf_scsi_devreset("nres", tm_flags, unit, scpnt);
@@ -249,9 +255,6 @@ static int zfcp_task_mgmt_function(struct scsi_cmnd *scpnt, u8 tm_flags)
         if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCFAILED) {
                 zfcp_dbf_scsi_devreset("fail", tm_flags, unit, scpnt);
                 retval = FAILED;
-        } else if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP) {
-                zfcp_dbf_scsi_devreset("nsup", tm_flags, unit, scpnt);
-                retval = FAILED;
         } else
                 zfcp_dbf_scsi_devreset("okay", tm_flags, unit, scpnt);
 
@@ -261,12 +264,12 @@ static int zfcp_task_mgmt_function(struct scsi_cmnd *scpnt, u8 tm_flags)
 
 static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt)
 {
-        return zfcp_task_mgmt_function(scpnt, FCP_LOGICAL_UNIT_RESET);
+        return zfcp_task_mgmt_function(scpnt, FCP_TMF_LUN_RESET);
 }
 
 static int zfcp_scsi_eh_target_reset_handler(struct scsi_cmnd *scpnt)
 {
-        return zfcp_task_mgmt_function(scpnt, FCP_TARGET_RESET);
+        return zfcp_task_mgmt_function(scpnt, FCP_TMF_TGT_RESET);
 }
 
 static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
@@ -276,6 +279,7 @@ static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
 
         zfcp_erp_adapter_reopen(adapter, 0, "schrh_1", scpnt);
         zfcp_erp_wait(adapter);
+        fc_block_scsi_eh(scpnt);
 
         return SUCCESS;
 }
@@ -303,7 +307,7 @@ int zfcp_adapter_scsi_register(struct zfcp_adapter *adapter)
         adapter->scsi_host->max_lun = 1;
         adapter->scsi_host->max_channel = 0;
         adapter->scsi_host->unique_id = dev_id.devno;
-        adapter->scsi_host->max_cmd_len = 255;
+        adapter->scsi_host->max_cmd_len = 16; /* in struct fcp_cmnd */
         adapter->scsi_host->transportt = zfcp_data.scsi_transport_template;
 
         adapter->scsi_host->hostdata[0] = (unsigned long) adapter;
@@ -325,12 +329,11 @@ void zfcp_adapter_scsi_unregister(struct zfcp_adapter *adapter)
         if (!shost)
                 return;
 
-        read_lock_irq(&zfcp_data.config_lock);
-        list_for_each_entry(port, &adapter->port_list_head, list)
-                if (port->rport)
-                        port->rport = NULL;
+        read_lock_irq(&adapter->port_list_lock);
+        list_for_each_entry(port, &adapter->port_list, list)
+                port->rport = NULL;
+        read_unlock_irq(&adapter->port_list_lock);
 
-        read_unlock_irq(&zfcp_data.config_lock);
         fc_remove_host(shost);
         scsi_remove_host(shost);
         scsi_host_put(shost);
@@ -348,7 +351,7 @@ zfcp_init_fc_host_stats(struct zfcp_adapter *adapter)
                 fc_stats = kmalloc(sizeof(*fc_stats), GFP_KERNEL);
                 if (!fc_stats)
                         return NULL;
-                adapter->fc_stats = fc_stats; /* freed in adater_dequeue */
+                adapter->fc_stats = fc_stats; /* freed in adapter_release */
         }
         memset(adapter->fc_stats, 0, sizeof(*adapter->fc_stats));
         return adapter->fc_stats;
@@ -464,7 +467,7 @@ static void zfcp_reset_fc_host_stats(struct Scsi_Host *shost)
                 adapter->stats_reset = jiffies/HZ;
                 kfree(adapter->stats_reset_data);
                 adapter->stats_reset_data = data; /* finally freed in
-                                                     adapter_dequeue */
+                                                     adapter_release */
         }
 }
 
@@ -495,7 +498,7 @@ static void zfcp_set_rport_dev_loss_tmo(struct fc_rport *rport, u32 timeout)
  * @rport: The FC rport where to teminate I/O
  *
  * Abort all pending SCSI commands for a port by closing the
- * port. Using a reopen for avoids a conflict with a shutdown
+ * port. Using a reopen avoiding a conflict with a shutdown
  * overwriting a reopen.
  */
 static void zfcp_scsi_terminate_rport_io(struct fc_rport *rport)
@@ -505,15 +508,11 @@ static void zfcp_scsi_terminate_rport_io(struct fc_rport *rport)
         struct zfcp_adapter *adapter =
                 (struct zfcp_adapter *)shost->hostdata[0];
 
-        write_lock_irq(&zfcp_data.config_lock);
         port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
-        if (port)
-                zfcp_port_get(port);
-        write_unlock_irq(&zfcp_data.config_lock);
 
         if (port) {
                 zfcp_erp_port_reopen(port, 0, "sctrpi1", NULL);
-                zfcp_port_put(port);
+                put_device(&port->dev);
         }
 }
 
@@ -555,31 +554,34 @@ static void zfcp_scsi_rport_block(struct zfcp_port *port)
 
 void zfcp_scsi_schedule_rport_register(struct zfcp_port *port)
 {
-        zfcp_port_get(port);
+        get_device(&port->dev);
         port->rport_task = RPORT_ADD;
 
         if (!queue_work(port->adapter->work_queue, &port->rport_work))
-                zfcp_port_put(port);
+                put_device(&port->dev);
 }
 
 void zfcp_scsi_schedule_rport_block(struct zfcp_port *port)
 {
-        zfcp_port_get(port);
+        get_device(&port->dev);
         port->rport_task = RPORT_DEL;
 
         if (port->rport && queue_work(port->adapter->work_queue,
                                       &port->rport_work))
                 return;
 
-        zfcp_port_put(port);
+        put_device(&port->dev);
 }
 
 void zfcp_scsi_schedule_rports_block(struct zfcp_adapter *adapter)
 {
+        unsigned long flags;
         struct zfcp_port *port;
 
-        list_for_each_entry(port, &adapter->port_list_head, list)
+        read_lock_irqsave(&adapter->port_list_lock, flags);
+        list_for_each_entry(port, &adapter->port_list, list)
                 zfcp_scsi_schedule_rport_block(port);
+        read_unlock_irqrestore(&adapter->port_list_lock, flags);
 }
 
 void zfcp_scsi_rport_work(struct work_struct *work)
@@ -597,7 +599,7 @@ void zfcp_scsi_rport_work(struct work_struct *work)
                 }
         }
 
-        zfcp_port_put(port);
+        put_device(&port->dev);
 }
 
 
@@ -615,21 +617,7 @@ void zfcp_scsi_scan(struct work_struct *work)
                                  scsilun_to_int((struct scsi_lun *)
                                                 &unit->fcp_lun), 0);
 
-        zfcp_unit_put(unit);
-}
-
-static int zfcp_execute_fc_job(struct fc_bsg_job *job)
-{
-        switch (job->request->msgcode) {
-        case FC_BSG_RPT_ELS:
-        case FC_BSG_HST_ELS_NOLOGIN:
-                return zfcp_fc_execute_els_fc_job(job);
-        case FC_BSG_RPT_CT:
-        case FC_BSG_HST_CT:
-                return zfcp_fc_execute_ct_fc_job(job);
-        default:
-                return -EINVAL;
-        }
+        put_device(&unit->dev);
 }
 
 struct fc_function_template zfcp_transport_functions = {
@@ -643,6 +631,7 @@ struct fc_function_template zfcp_transport_functions = {
         .show_host_port_name = 1,
         .show_host_permanent_port_name = 1,
         .show_host_supported_classes = 1,
+        .show_host_supported_fc4s = 1,
         .show_host_supported_speeds = 1,
         .show_host_maxframe_size = 1,
         .show_host_serial_number = 1,
@@ -652,13 +641,16 @@ struct fc_function_template zfcp_transport_functions = {
         .get_host_port_state = zfcp_get_host_port_state,
         .terminate_rport_io = zfcp_scsi_terminate_rport_io,
         .show_host_port_state = 1,
-        .bsg_request = zfcp_execute_fc_job,
+        .show_host_active_fc4s = 1,
+        .bsg_request = zfcp_fc_exec_bsg_job,
+        .bsg_timeout = zfcp_fc_timeout_bsg_job,
         /* no functions registered for following dynamic attributes but
            directly set by LLDD */
         .show_host_port_type = 1,
         .show_host_speed = 1,
         .show_host_port_id = 1,
         .disable_target_scan = 1,
+        .dd_bsg_size = sizeof(struct zfcp_fsf_ct_els),
 };
 
 struct zfcp_data zfcp_data = {
diff --git a/drivers/s390/scsi/zfcp_sysfs.c b/drivers/s390/scsi/zfcp_sysfs.c
index d31000886ca8..f5f60698dc4c 100644
--- a/drivers/s390/scsi/zfcp_sysfs.c
+++ b/drivers/s390/scsi/zfcp_sysfs.c
@@ -3,12 +3,13 @@
  *
  * sysfs attributes.
  *
- * Copyright IBM Corporation 2008
+ * Copyright IBM Corporation 2008, 2010
  */
 
 #define KMSG_COMPONENT "zfcp"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
+#include <linux/slab.h>
 #include "zfcp_ext.h"
 
 #define ZFCP_DEV_ATTR(_feat, _name, _mode, _show, _store) \
@@ -19,30 +20,43 @@ static ssize_t zfcp_sysfs_##_feat##_##_name##_show(struct device *dev,	       \
                                                    struct device_attribute *at,\
                                                    char *buf)                  \
 {                                                                              \
-        struct _feat_def *_feat = dev_get_drvdata(dev);                        \
+        struct _feat_def *_feat = container_of(dev, struct _feat_def, dev);    \
                                                                                \
         return sprintf(buf, _format, _value);                                  \
 }                                                                              \
 static ZFCP_DEV_ATTR(_feat, _name, S_IRUGO,                                    \
                      zfcp_sysfs_##_feat##_##_name##_show, NULL);
 
-ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, status, "0x%08x\n",
-                 atomic_read(&adapter->status));
-ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, peer_wwnn, "0x%016llx\n",
-                 (unsigned long long) adapter->peer_wwnn);
-ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, peer_wwpn, "0x%016llx\n",
-                 (unsigned long long) adapter->peer_wwpn);
-ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, peer_d_id, "0x%06x\n",
-                 adapter->peer_d_id);
-ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, card_version, "0x%04x\n",
-                 adapter->hydra_version);
-ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, lic_version, "0x%08x\n",
-                 adapter->fsf_lic_version);
-ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, hardware_version, "0x%08x\n",
-                 adapter->hardware_version);
-ZFCP_DEFINE_ATTR(zfcp_adapter, adapter, in_recovery, "%d\n",
-                 (atomic_read(&adapter->status) &
-                  ZFCP_STATUS_COMMON_ERP_INUSE) != 0);
+#define ZFCP_DEFINE_A_ATTR(_name, _format, _value)                           \
+static ssize_t zfcp_sysfs_adapter_##_name##_show(struct device *dev,         \
+                                                 struct device_attribute *at,\
+                                                 char *buf)                  \
+{                                                                            \
+        struct ccw_device *cdev = to_ccwdev(dev);                            \
+        struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);       \
+        int i;                                                               \
+                                                                             \
+        if (!adapter)                                                        \
+                return -ENODEV;                                              \
+                                                                             \
+        i = sprintf(buf, _format, _value);                                   \
+        zfcp_ccw_adapter_put(adapter);                                       \
+        return i;                                                            \
+}                                                                            \
+static ZFCP_DEV_ATTR(adapter, _name, S_IRUGO,                                \
+                     zfcp_sysfs_adapter_##_name##_show, NULL);
+
+ZFCP_DEFINE_A_ATTR(status, "0x%08x\n", atomic_read(&adapter->status));
+ZFCP_DEFINE_A_ATTR(peer_wwnn, "0x%016llx\n",
+                   (unsigned long long) adapter->peer_wwnn);
+ZFCP_DEFINE_A_ATTR(peer_wwpn, "0x%016llx\n",
+                   (unsigned long long) adapter->peer_wwpn);
+ZFCP_DEFINE_A_ATTR(peer_d_id, "0x%06x\n", adapter->peer_d_id);
+ZFCP_DEFINE_A_ATTR(card_version, "0x%04x\n", adapter->hydra_version);
+ZFCP_DEFINE_A_ATTR(lic_version, "0x%08x\n", adapter->fsf_lic_version);
+ZFCP_DEFINE_A_ATTR(hardware_version, "0x%08x\n", adapter->hardware_version);
+ZFCP_DEFINE_A_ATTR(in_recovery, "%d\n", (atomic_read(&adapter->status) &
+                                         ZFCP_STATUS_COMMON_ERP_INUSE) != 0);
 
 ZFCP_DEFINE_ATTR(zfcp_port, port, status, "0x%08x\n",
                  atomic_read(&port->status));
@@ -73,7 +87,7 @@ static ssize_t zfcp_sysfs_##_feat##_failed_show(struct device *dev,	       \
                                                 struct device_attribute *attr, \
                                                 char *buf)                     \
 {                                                                              \
-        struct _feat_def *_feat = dev_get_drvdata(dev);                        \
+        struct _feat_def *_feat = container_of(dev, struct _feat_def, dev);    \
                                                                                \
         if (atomic_read(&_feat->status) & ZFCP_STATUS_COMMON_ERP_FAILED)       \
                 return sprintf(buf, "1\n");                                    \
@@ -84,15 +98,12 @@ static ssize_t zfcp_sysfs_##_feat##_failed_store(struct device *dev,	       \
                                                  struct device_attribute *attr,\
                                                  const char *buf, size_t count)\
 {                                                                              \
-        struct _feat_def *_feat = dev_get_drvdata(dev);                        \
+        struct _feat_def *_feat = container_of(dev, struct _feat_def, dev);    \
         unsigned long val;                                                     \
         int retval = 0;                                                        \
                                                                                \
-        mutex_lock(&zfcp_data.config_mutex);                                   \
-        if (atomic_read(&_feat->status) & ZFCP_STATUS_COMMON_REMOVE) {         \
-                retval = -EBUSY;                                               \
-                goto out;                                                      \
-        }                                                                      \
+        if (!(_feat && get_device(&_feat->dev)))                               \
+                return -EBUSY;                                                 \
                                                                                \
         if (strict_strtoul(buf, 0, &val) || val != 0) {                        \
                 retval = -EINVAL;                                              \
@@ -105,29 +116,82 @@ static ssize_t zfcp_sysfs_##_feat##_failed_store(struct device *dev,	       \
                                   _reopen_id, NULL);                           \
         zfcp_erp_wait(_adapter);                                               \
 out:                                                                           \
-        mutex_unlock(&zfcp_data.config_mutex);                                 \
+        put_device(&_feat->dev);                                               \
         return retval ? retval : (ssize_t) count;                              \
 }                                                                              \
 static ZFCP_DEV_ATTR(_feat, failed, S_IWUSR | S_IRUGO,                         \
                      zfcp_sysfs_##_feat##_failed_show,                         \
                      zfcp_sysfs_##_feat##_failed_store);
 
-ZFCP_SYSFS_FAILED(zfcp_adapter, adapter, adapter, "syafai1", "syafai2");
 ZFCP_SYSFS_FAILED(zfcp_port, port, port->adapter, "sypfai1", "sypfai2");
 ZFCP_SYSFS_FAILED(zfcp_unit, unit, unit->port->adapter, "syufai1", "syufai2");
 
+static ssize_t zfcp_sysfs_adapter_failed_show(struct device *dev,
+                                              struct device_attribute *attr,
+                                              char *buf)
+{
+        struct ccw_device *cdev = to_ccwdev(dev);
+        struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
+        int i;
+
+        if (!adapter)
+                return -ENODEV;
+
+        if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
+                i = sprintf(buf, "1\n");
+        else
+                i = sprintf(buf, "0\n");
+
+        zfcp_ccw_adapter_put(adapter);
+        return i;
+}
+
+static ssize_t zfcp_sysfs_adapter_failed_store(struct device *dev,
+                                               struct device_attribute *attr,
+                                               const char *buf, size_t count)
+{
+        struct ccw_device *cdev = to_ccwdev(dev);
+        struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
+        unsigned long val;
+        int retval = 0;
+
+        if (!adapter)
+                return -ENODEV;
+
+        if (strict_strtoul(buf, 0, &val) || val != 0) {
+                retval = -EINVAL;
+                goto out;
+        }
+
+        zfcp_erp_modify_adapter_status(adapter, "syafai1", NULL,
+                                       ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
+        zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
+                                "syafai2", NULL);
+        zfcp_erp_wait(adapter);
+out:
+        zfcp_ccw_adapter_put(adapter);
+        return retval ? retval : (ssize_t) count;
+}
+static ZFCP_DEV_ATTR(adapter, failed, S_IWUSR | S_IRUGO,
+                     zfcp_sysfs_adapter_failed_show,
+                     zfcp_sysfs_adapter_failed_store);
+
 static ssize_t zfcp_sysfs_port_rescan_store(struct device *dev,
                                             struct device_attribute *attr,
                                             const char *buf, size_t count)
 {
-        struct zfcp_adapter *adapter = dev_get_drvdata(dev);
-        int ret;
+        struct ccw_device *cdev = to_ccwdev(dev);
+        struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
 
-        if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_REMOVE)
-                return -EBUSY;
+        if (!adapter)
+                return -ENODEV;
 
-        ret = zfcp_fc_scan_ports(adapter);
-        return ret ? ret : (ssize_t) count;
+        /* sync the user-space- with the kernel-invocation of scan_work */
+        queue_work(adapter->work_queue, &adapter->scan_work);
+        flush_work(&adapter->scan_work);
+        zfcp_ccw_adapter_put(adapter);
+
+        return (ssize_t) count;
 }
 static ZFCP_DEV_ATTR(adapter, port_rescan, S_IWUSR, NULL,
                      zfcp_sysfs_port_rescan_store);
@@ -136,44 +200,34 @@ static ssize_t zfcp_sysfs_port_remove_store(struct device *dev,
                                             struct device_attribute *attr,
                                             const char *buf, size_t count)
 {
-        struct zfcp_adapter *adapter = dev_get_drvdata(dev);
+        struct ccw_device *cdev = to_ccwdev(dev);
+        struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
         struct zfcp_port *port;
         u64 wwpn;
-        int retval = 0;
-        LIST_HEAD(port_remove_lh);
+        int retval = -EINVAL;
 
-        mutex_lock(&zfcp_data.config_mutex);
-        if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_REMOVE) {
-                retval = -EBUSY;
-                goto out;
-        }
+        if (!adapter)
+                return -ENODEV;
 
-        if (strict_strtoull(buf, 0, (unsigned long long *) &wwpn)) {
-                retval = -EINVAL;
+        if (strict_strtoull(buf, 0, (unsigned long long *) &wwpn))
                 goto out;
-        }
 
-        write_lock_irq(&zfcp_data.config_lock);
         port = zfcp_get_port_by_wwpn(adapter, wwpn);
-        if (port && (atomic_read(&port->refcount) == 0)) {
-                zfcp_port_get(port);
-                atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
-                list_move(&port->list, &port_remove_lh);
-        } else
-                port = NULL;
-        write_unlock_irq(&zfcp_data.config_lock);
-
-        if (!port) {
-                retval = -ENXIO;
+        if (!port)
                 goto out;
-        }
+        else
+                retval = 0;
+
+        write_lock_irq(&adapter->port_list_lock);
+        list_del(&port->list);
+        write_unlock_irq(&adapter->port_list_lock);
+
+        put_device(&port->dev);
 
         zfcp_erp_port_shutdown(port, 0, "syprs_1", NULL);
-        zfcp_erp_wait(adapter);
-        zfcp_port_put(port);
-        zfcp_port_dequeue(port);
+        zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs);
  out:
-        mutex_unlock(&zfcp_data.config_mutex);
+        zfcp_ccw_adapter_put(adapter);
         return retval ? retval : (ssize_t) count;
 }
 static ZFCP_DEV_ATTR(adapter, port_remove, S_IWUSR, NULL,
@@ -202,16 +256,13 @@ static ssize_t zfcp_sysfs_unit_add_store(struct device *dev,
                                          struct device_attribute *attr,
                                          const char *buf, size_t count)
 {
-        struct zfcp_port *port = dev_get_drvdata(dev);
+        struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
         struct zfcp_unit *unit;
         u64 fcp_lun;
         int retval = -EINVAL;
 
-        mutex_lock(&zfcp_data.config_mutex);
-        if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_REMOVE) {
-                retval = -EBUSY;
-                goto out;
-        }
+        if (!(port && get_device(&port->dev)))
+                return -EBUSY;
 
         if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun))
                 goto out;
@@ -219,15 +270,14 @@ static ssize_t zfcp_sysfs_unit_add_store(struct device *dev,
         unit = zfcp_unit_enqueue(port, fcp_lun);
         if (IS_ERR(unit))
                 goto out;
-
-        retval = 0;
+        else
+                retval = 0;
 
         zfcp_erp_unit_reopen(unit, 0, "syuas_1", NULL);
         zfcp_erp_wait(unit->port->adapter);
         flush_work(&unit->scsi_work);
-        zfcp_unit_put(unit);
 out:
-        mutex_unlock(&zfcp_data.config_mutex);
+        put_device(&port->dev);
         return retval ? retval : (ssize_t) count;
 }
 static DEVICE_ATTR(unit_add, S_IWUSR, NULL, zfcp_sysfs_unit_add_store);
@@ -236,54 +286,36 @@ static ssize_t zfcp_sysfs_unit_remove_store(struct device *dev,
                                             struct device_attribute *attr,
                                             const char *buf, size_t count)
 {
-        struct zfcp_port *port = dev_get_drvdata(dev);
+        struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
         struct zfcp_unit *unit;
         u64 fcp_lun;
-        int retval = 0;
-        LIST_HEAD(unit_remove_lh);
+        int retval = -EINVAL;
 
-        mutex_lock(&zfcp_data.config_mutex);
-        if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_REMOVE) {
-                retval = -EBUSY;
-                goto out;
-        }
+        if (!(port && get_device(&port->dev)))
+                return -EBUSY;
 
-        if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun)) {
-                retval = -EINVAL;
+        if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun))
                 goto out;
-        }
 
-        write_lock_irq(&zfcp_data.config_lock);
         unit = zfcp_get_unit_by_lun(port, fcp_lun);
-        if (unit) {
-                write_unlock_irq(&zfcp_data.config_lock);
-                /* wait for possible timeout during SCSI probe */
-                flush_work(&unit->scsi_work);
-                write_lock_irq(&zfcp_data.config_lock);
-
-                if (atomic_read(&unit->refcount) == 0) {
-                        zfcp_unit_get(unit);
-                        atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE,
-                                        &unit->status);
-                        list_move(&unit->list, &unit_remove_lh);
-                } else {
-                        unit = NULL;
-                }
-        }
+        if (!unit)
+                goto out;
+        else
+                retval = 0;
 
-        write_unlock_irq(&zfcp_data.config_lock);
+        /* wait for possible timeout during SCSI probe */
+        flush_work(&unit->scsi_work);
 
-        if (!unit) {
-                retval = -ENXIO;
-                goto out;
-        }
+        write_lock_irq(&port->unit_list_lock);
+        list_del(&unit->list);
+        write_unlock_irq(&port->unit_list_lock);
+
+        put_device(&unit->dev);
 
         zfcp_erp_unit_shutdown(unit, 0, "syurs_1", NULL);
-        zfcp_erp_wait(unit->port->adapter);
-        zfcp_unit_put(unit);
-        zfcp_unit_dequeue(unit);
+        zfcp_device_unregister(&unit->dev, &zfcp_sysfs_unit_attrs);
 out:
-        mutex_unlock(&zfcp_data.config_mutex);
+        put_device(&port->dev);
         return retval ? retval : (ssize_t) count;
 }
 static DEVICE_ATTR(unit_remove, S_IWUSR, NULL, zfcp_sysfs_unit_remove_store);