116 files changed, 6640 insertions, 5511 deletions

diff --git a/drivers/s390/block/Kconfig b/drivers/s390/block/Kconfig
index 07883197f474..8e477bb1f3f6 100644
--- a/drivers/s390/block/Kconfig
+++ b/drivers/s390/block/Kconfig
@@ -2,7 +2,8 @@ comment "S/390 block device drivers"
         depends on S390 && BLOCK
 
 config BLK_DEV_XPRAM
-        tristate "XPRAM disk support"
+        def_tristate m
+        prompt "XPRAM disk support"
         depends on S390 && BLOCK
         help
           Select this option if you want to use your expanded storage on S/390
@@ -12,13 +13,15 @@ config BLK_DEV_XPRAM
           xpram.  If unsure, say "N".
 
 config DCSSBLK
-        tristate "DCSSBLK support"
+        def_tristate m
+        prompt "DCSSBLK support"
         depends on S390 && BLOCK
         help
           Support for dcss block device
 
 config DASD
-        tristate "Support for DASD devices"
+        def_tristate y
+        prompt "Support for DASD devices"
         depends on CCW && BLOCK
         select IOSCHED_DEADLINE
         help
@@ -27,28 +30,32 @@ config DASD
           natively on a single image or an LPAR.
 
 config DASD_PROFILE
-        bool "Profiling support for dasd devices"
+        def_bool y
+        prompt "Profiling support for dasd devices"
         depends on DASD
         help
           Enable this option if you want to see profiling information
           in /proc/dasd/statistics.
 
 config DASD_ECKD
-        tristate "Support for ECKD Disks"
+        def_tristate y
+        prompt "Support for ECKD Disks"
         depends on DASD
         help
           ECKD devices are the most commonly used devices. You should enable
           this option unless you are very sure to have no ECKD device.
 
 config DASD_FBA
-        tristate "Support for FBA  Disks"
+        def_tristate y
+        prompt "Support for FBA  Disks"
         depends on DASD
         help
           Select this option to be able to access FBA devices. It is safe to
           say "Y".
 
 config DASD_DIAG
-        tristate "Support for DIAG access to Disks"
+        def_tristate y
+        prompt "Support for DIAG access to Disks"
         depends on DASD
         help
           Select this option if you want to use Diagnose250 command to access
@@ -56,7 +63,8 @@ config DASD_DIAG
           say "N".
 
 config DASD_EER
-        bool "Extended error reporting (EER)"
+        def_bool y
+        prompt "Extended error reporting (EER)"
         depends on DASD
         help
           This driver provides a character device interface to the
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 8373ca0de8e0..86b6f1cc1b10 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -11,6 +11,7 @@
 #define KMSG_COMPONENT "dasd"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
+#include <linux/kernel_stat.h>
 #include <linux/kmod.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
@@ -21,7 +22,6 @@
 #include <linux/hdreg.h>
 #include <linux/async.h>
 #include <linux/mutex.h>
-#include <linux/smp_lock.h>
 
 #include <asm/ccwdev.h>
 #include <asm/ebcdic.h>
@@ -369,6 +369,11 @@ dasd_state_ready_to_online(struct dasd_device * device)
         device->state = DASD_STATE_ONLINE;
         if (device->block) {
                 dasd_schedule_block_bh(device->block);
+                if ((device->features & DASD_FEATURE_USERAW)) {
+                        disk = device->block->gdp;
+                        kobject_uevent(&disk_to_dev(disk)->kobj, KOBJ_CHANGE);
+                        return 0;
+                }
                 disk = device->block->bdev->bd_disk;
                 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
                 while ((part = disk_part_iter_next(&piter)))
@@ -394,7 +399,7 @@ static int dasd_state_online_to_ready(struct dasd_device *device)
                         return rc;
         }
         device->state = DASD_STATE_READY;
-        if (device->block) {
+        if (device->block && !(device->features & DASD_FEATURE_USERAW)) {
                 disk = device->block->bdev->bd_disk;
                 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
                 while ((part = disk_part_iter_next(&piter)))
@@ -745,10 +750,6 @@ struct dasd_ccw_req *dasd_smalloc_request(int magic, int cplength,
         char *data;
         int size;
 
-        /* Sanity checks */
-        BUG_ON(datasize > PAGE_SIZE ||
-             (cplength*sizeof(struct ccw1)) > PAGE_SIZE);
-
         size = (sizeof(struct dasd_ccw_req) + 7L) & -8L;
         if (cplength > 0)
                 size += cplength * sizeof(struct ccw1);
@@ -854,7 +855,6 @@ int dasd_term_IO(struct dasd_ccw_req *cqr)
                 rc = ccw_device_clear(device->cdev, (long) cqr);
                 switch (rc) {
                 case 0: /* termination successful */
-                        cqr->retries--;
                         cqr->status = DASD_CQR_CLEAR_PENDING;
                         cqr->stopclk = get_clock();
                         cqr->starttime = 0;
@@ -906,6 +906,16 @@ int dasd_start_IO(struct dasd_ccw_req *cqr)
                 return rc;
         }
         device = (struct dasd_device *) cqr->startdev;
+        if (((cqr->block &&
+              test_bit(DASD_FLAG_LOCK_STOLEN, &cqr->block->base->flags)) ||
+             test_bit(DASD_FLAG_LOCK_STOLEN, &device->flags)) &&
+            !test_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags)) {
+                DBF_DEV_EVENT(DBF_DEBUG, device, "start_IO: return request %p "
+                              "because of stolen lock", cqr);
+                cqr->status = DASD_CQR_ERROR;
+                cqr->intrc = -EPERM;
+                return -EPERM;
+        }
         if (cqr->retries < 0) {
                 /* internal error 14 - start_IO run out of retries */
                 sprintf(errorstring, "14 %p", cqr);
@@ -917,6 +927,11 @@ int dasd_start_IO(struct dasd_ccw_req *cqr)
         cqr->startclk = get_clock();
         cqr->starttime = jiffies;
         cqr->retries--;
+        if (!test_bit(DASD_CQR_VERIFY_PATH, &cqr->flags)) {
+                cqr->lpm &= device->path_data.opm;
+                if (!cqr->lpm)
+                        cqr->lpm = device->path_data.opm;
+        }
         if (cqr->cpmode == 1) {
                 rc = ccw_device_tm_start(device->cdev, cqr->cpaddr,
                                          (long) cqr, cqr->lpm);
@@ -929,35 +944,53 @@ int dasd_start_IO(struct dasd_ccw_req *cqr)
                 cqr->status = DASD_CQR_IN_IO;
                 break;
         case -EBUSY:
-                DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
+                DBF_DEV_EVENT(DBF_WARNING, device, "%s",
                               "start_IO: device busy, retry later");
                 break;
         case -ETIMEDOUT:
-                DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
+                DBF_DEV_EVENT(DBF_WARNING, device, "%s",
                               "start_IO: request timeout, retry later");
                 break;
         case -EACCES:
-                /* -EACCES indicates that the request used only a
-                 * subset of the available pathes and all these
-                 * pathes are gone.
-                 * Do a retry with all available pathes.
+                /* -EACCES indicates that the request used only a subset of the
+                 * available paths and all these paths are gone. If the lpm of
+                 * this request was only a subset of the opm (e.g. the ppm) then
+                 * we just do a retry with all available paths.
+                 * If we already use the full opm, something is amiss, and we
+                 * need a full path verification.
                  */
-                cqr->lpm = LPM_ANYPATH;
-                DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
-                              "start_IO: selected pathes gone,"
-                              " retry on all pathes");
+                if (test_bit(DASD_CQR_VERIFY_PATH, &cqr->flags)) {
+                        DBF_DEV_EVENT(DBF_WARNING, device,
+                                      "start_IO: selected paths gone (%x)",
+                                      cqr->lpm);
+                } else if (cqr->lpm != device->path_data.opm) {
+                        cqr->lpm = device->path_data.opm;
+                        DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
+                                      "start_IO: selected paths gone,"
+                                      " retry on all paths");
+                } else {
+                        DBF_DEV_EVENT(DBF_WARNING, device, "%s",
+                                      "start_IO: all paths in opm gone,"
+                                      " do path verification");
+                        dasd_generic_last_path_gone(device);
+                        device->path_data.opm = 0;
+                        device->path_data.ppm = 0;
+                        device->path_data.npm = 0;
+                        device->path_data.tbvpm =
+                                ccw_device_get_path_mask(device->cdev);
+                }
                 break;
         case -ENODEV:
-                DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
+                DBF_DEV_EVENT(DBF_WARNING, device, "%s",
                               "start_IO: -ENODEV device gone, retry");
                 break;
         case -EIO:
-                DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
+                DBF_DEV_EVENT(DBF_WARNING, device, "%s",
                               "start_IO: -EIO device gone, retry");
                 break;
         case -EINVAL:
                 /* most likely caused in power management context */
-                DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
+                DBF_DEV_EVENT(DBF_WARNING, device, "%s",
                               "start_IO: -EINVAL device currently "
                               "not accessible");
                 break;
@@ -1077,6 +1110,7 @@ void dasd_int_handler(struct ccw_device *cdev, unsigned long intparm,
         unsigned long long now;
         int expires;
 
+        kstat_cpu(smp_processor_id()).irqs[IOINT_DAS]++;
         if (IS_ERR(irb)) {
                 switch (PTR_ERR(irb)) {
                 case -EIO:
@@ -1095,23 +1129,29 @@ void dasd_int_handler(struct ccw_device *cdev, unsigned long intparm,
         }
 
         now = get_clock();
-
-        /* check for unsolicited interrupts */
         cqr = (struct dasd_ccw_req *) intparm;
-        if (!cqr || ((scsw_cc(&irb->scsw) == 1) &&
-                     (scsw_fctl(&irb->scsw) & SCSW_FCTL_START_FUNC) &&
-                     (scsw_stctl(&irb->scsw) & SCSW_STCTL_STATUS_PEND))) {
-                if (cqr && cqr->status == DASD_CQR_IN_IO)
-                        cqr->status = DASD_CQR_QUEUED;
+        /* check for conditions that should be handled immediately */
+        if (!cqr ||
+            !(scsw_dstat(&irb->scsw) == (DEV_STAT_CHN_END | DEV_STAT_DEV_END) &&
+              scsw_cstat(&irb->scsw) == 0)) {
+                if (cqr)
+                        memcpy(&cqr->irb, irb, sizeof(*irb));
                 device = dasd_device_from_cdev_locked(cdev);
-                if (!IS_ERR(device)) {
-                        dasd_device_clear_timer(device);
-                        device->discipline->handle_unsolicited_interrupt(device,
-                                                                         irb);
+                if (IS_ERR(device))
+                        return;
+                /* ignore unsolicited interrupts for DIAG discipline */
+                if (device->discipline == dasd_diag_discipline_pointer) {
                         dasd_put_device(device);
+                        return;
                 }
-                return;
+                device->discipline->dump_sense_dbf(device, irb, "int");
+                if (device->features & DASD_FEATURE_ERPLOG)
+                        device->discipline->dump_sense(device, cqr, irb);
+                device->discipline->check_for_device_change(device, cqr, irb);
+                dasd_put_device(device);
         }
+        if (!cqr)
+                return;
 
         device = (struct dasd_device *) cqr->startdev;
         if (!device ||
@@ -1151,25 +1191,19 @@ void dasd_int_handler(struct ccw_device *cdev, unsigned long intparm,
                                           struct dasd_ccw_req, devlist);
                 }
         } else {  /* error */
-                memcpy(&cqr->irb, irb, sizeof(struct irb));
-                /* log sense for every failed I/O to s390 debugfeature */
-                dasd_log_sense_dbf(cqr, irb);
-                if (device->features & DASD_FEATURE_ERPLOG) {
-                        dasd_log_sense(cqr, irb);
-                }
-
                 /*
                  * If we don't want complex ERP for this request, then just
                  * reset this and retry it in the fastpath
                  */
                 if (!test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags) &&
                     cqr->retries > 0) {
-                        if (cqr->lpm == LPM_ANYPATH)
+                        if (cqr->lpm == device->path_data.opm)
                                 DBF_DEV_EVENT(DBF_DEBUG, device,
                                               "default ERP in fastpath "
                                               "(%i retries left)",
                                               cqr->retries);
-                        cqr->lpm    = LPM_ANYPATH;
+                        if (!test_bit(DASD_CQR_VERIFY_PATH, &cqr->flags))
+                                cqr->lpm = device->path_data.opm;
                         cqr->status = DASD_CQR_QUEUED;
                         next = cqr;
                 } else
@@ -1197,13 +1231,13 @@ enum uc_todo dasd_generic_uc_handler(struct ccw_device *cdev, struct irb *irb)
                 goto out;
         if (test_bit(DASD_FLAG_OFFLINE, &device->flags) ||
            device->state != device->target ||
-           !device->discipline->handle_unsolicited_interrupt){
+           !device->discipline->check_for_device_change){
                 dasd_put_device(device);
                 goto out;
         }
-
-        dasd_device_clear_timer(device);
-        device->discipline->handle_unsolicited_interrupt(device, irb);
+        if (device->discipline->dump_sense_dbf)
+                device->discipline->dump_sense_dbf(device, irb, "uc");
+        device->discipline->check_for_device_change(device, NULL, irb);
         dasd_put_device(device);
 out:
         return UC_TODO_RETRY;
@@ -1353,8 +1387,14 @@ static void __dasd_device_start_head(struct dasd_device *device)
         cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, devlist);
         if (cqr->status != DASD_CQR_QUEUED)
                 return;
-        /* when device is stopped, return request to previous layer */
-        if (device->stopped) {
+        /* when device is stopped, return request to previous layer
+         * exception: only the disconnect or unresumed bits are set and the
+         * cqr is a path verification request
+         */
+        if (device->stopped &&
+            !(!(device->stopped & ~(DASD_STOPPED_DC_WAIT | DASD_UNRESUMED_PM))
+              && test_bit(DASD_CQR_VERIFY_PATH, &cqr->flags))) {
+                cqr->intrc = -EAGAIN;
                 cqr->status = DASD_CQR_CLEARED;
                 dasd_schedule_device_bh(device);
                 return;
@@ -1370,6 +1410,23 @@ static void __dasd_device_start_head(struct dasd_device *device)
                 dasd_device_set_timer(device, 50);
 }
 
+static void __dasd_device_check_path_events(struct dasd_device *device)
+{
+        int rc;
+
+        if (device->path_data.tbvpm) {
+                if (device->stopped & ~(DASD_STOPPED_DC_WAIT |
+                                        DASD_UNRESUMED_PM))
+                        return;
+                rc = device->discipline->verify_path(
+                        device, device->path_data.tbvpm);
+                if (rc)
+                        dasd_device_set_timer(device, 50);
+                else
+                        device->path_data.tbvpm = 0;
+        }
+};
+
 /*
  * Go through all request on the dasd_device request queue,
  * terminate them on the cdev if necessary, and return them to the
@@ -1444,6 +1501,7 @@ static void dasd_device_tasklet(struct dasd_device *device)
         __dasd_device_check_expire(device);
         /* find final requests on ccw queue */
         __dasd_device_process_ccw_queue(device, &final_queue);
+        __dasd_device_check_path_events(device);
         spin_unlock_irq(get_ccwdev_lock(device->cdev));
         /* Now call the callback function of requests with final status */
         __dasd_device_process_final_queue(device, &final_queue);
@@ -1600,7 +1658,12 @@ static int _dasd_sleep_on(struct dasd_ccw_req *maincqr, int interruptible)
                         continue;
                 if (cqr->status != DASD_CQR_FILLED) /* could be failed */
                         continue;
-
+                if (test_bit(DASD_FLAG_LOCK_STOLEN, &device->flags) &&
+                    !test_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags)) {
+                        cqr->status = DASD_CQR_FAILED;
+                        cqr->intrc = -EPERM;
+                        continue;
+                }
                 /* Non-temporary stop condition will trigger fail fast */
                 if (device->stopped & ~DASD_STOPPED_PENDING &&
                     test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) &&
@@ -1608,7 +1671,6 @@ static int _dasd_sleep_on(struct dasd_ccw_req *maincqr, int interruptible)
                         cqr->status = DASD_CQR_FAILED;
                         continue;
                 }
-
                 /* Don't try to start requests if device is stopped */
                 if (interruptible) {
                         rc = wait_event_interruptible(
@@ -1680,11 +1742,20 @@ int dasd_sleep_on_interruptible(struct dasd_ccw_req *cqr)
 static inline int _dasd_term_running_cqr(struct dasd_device *device)
 {
         struct dasd_ccw_req *cqr;
+        int rc;
 
         if (list_empty(&device->ccw_queue))
                 return 0;
         cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, devlist);
-        return device->discipline->term_IO(cqr);
+        rc = device->discipline->term_IO(cqr);
+        if (!rc)
+                /*
+                 * CQR terminated because a more important request is pending.
+                 * Undo decreasing of retry counter because this is
+                 * not an error case.
+                 */
+                cqr->retries++;
+        return rc;
 }
 
 int dasd_sleep_on_immediatly(struct dasd_ccw_req *cqr)
@@ -1693,13 +1764,18 @@ int dasd_sleep_on_immediatly(struct dasd_ccw_req *cqr)
         int rc;
 
         device = cqr->startdev;
+        if (test_bit(DASD_FLAG_LOCK_STOLEN, &device->flags) &&
+            !test_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags)) {
+                cqr->status = DASD_CQR_FAILED;
+                cqr->intrc = -EPERM;
+                return -EIO;
+        }
         spin_lock_irq(get_ccwdev_lock(device->cdev));
         rc = _dasd_term_running_cqr(device);
         if (rc) {
                 spin_unlock_irq(get_ccwdev_lock(device->cdev));
                 return rc;
         }
-
         cqr->callback = dasd_wakeup_cb;
         cqr->callback_data = DASD_SLEEPON_START_TAG;
         cqr->status = DASD_CQR_QUEUED;
@@ -1850,7 +1926,7 @@ static void __dasd_process_request_queue(struct dasd_block *block)
                 return;
         }
         /* Now we try to fetch requests from the request queue */
-        while (!blk_queue_plugged(queue) && (req = blk_peek_request(queue))) {
+        while ((req = blk_peek_request(queue))) {
                 if (basedev->features & DASD_FEATURE_READONLY &&
                     rq_data_dir(req) == WRITE) {
                         DBF_DEV_EVENT(DBF_ERR, basedev,
@@ -2003,6 +2079,13 @@ static void __dasd_block_start_head(struct dasd_block *block)
         list_for_each_entry(cqr, &block->ccw_queue, blocklist) {
                 if (cqr->status != DASD_CQR_FILLED)
                         continue;
+                if (test_bit(DASD_FLAG_LOCK_STOLEN, &block->base->flags) &&
+                    !test_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags)) {
+                        cqr->status = DASD_CQR_FAILED;
+                        cqr->intrc = -EPERM;
+                        dasd_schedule_block_bh(block);
+                        continue;
+                }
                 /* Non-temporary stop condition will trigger fail fast */
                 if (block->base->stopped & ~DASD_STOPPED_PENDING &&
                     test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) &&
@@ -2188,8 +2271,20 @@ static void dasd_setup_queue(struct dasd_block *block)
 {
         int max;
 
-        blk_queue_logical_block_size(block->request_queue, block->bp_block);
-        max = block->base->discipline->max_blocks << block->s2b_shift;
+        if (block->base->features & DASD_FEATURE_USERAW) {
+                /*
+                 * the max_blocks value for raw_track access is 256
+                 * it is higher than the native ECKD value because we
+                 * only need one ccw per track
+                 * so the max_hw_sectors are
+                 * 2048 x 512B = 1024kB = 16 tracks
+                 */
+                max = 2048;
+        } else {
+                max = block->base->discipline->max_blocks << block->s2b_shift;
+        }
+        blk_queue_logical_block_size(block->request_queue,
+                                     block->bp_block);
         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
@@ -2197,7 +2292,6 @@ static void dasd_setup_queue(struct dasd_block *block)
          */
         blk_queue_max_segment_size(block->request_queue, PAGE_SIZE);
         blk_queue_segment_boundary(block->request_queue, PAGE_SIZE - 1);
-        blk_queue_ordered(block->request_queue, QUEUE_ORDERED_DRAIN);
 }
 
 /*
@@ -2229,16 +2323,14 @@ 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;
         int rc;
 
-        if (!block)
+        base = dasd_device_from_gendisk(bdev->bd_disk);
+        if (!base)
                 return -ENODEV;
 
-        lock_kernel();
-        base = block->base;
-        atomic_inc(&block->open_count);
+        atomic_inc(&base->block->open_count);
         if (test_bit(DASD_FLAG_OFFLINE, &base->flags)) {
                 rc = -ENODEV;
                 goto unlock;
@@ -2271,25 +2363,28 @@ static int dasd_open(struct block_device *bdev, fmode_t mode)
                 goto out;
         }
 
-        unlock_kernel();
+        dasd_put_device(base);
         return 0;
 
 out:
         module_put(base->discipline->owner);
 unlock:
-        atomic_dec(&block->open_count);
-        unlock_kernel();
+        atomic_dec(&base->block->open_count);
+        dasd_put_device(base);
         return rc;
 }
 
 static int dasd_release(struct gendisk *disk, fmode_t mode)
 {
-        struct dasd_block *block = disk->private_data;
+        struct dasd_device *base;
+
+        base = dasd_device_from_gendisk(disk);
+        if (!base)
+                return -ENODEV;
 
-        lock_kernel();
-        atomic_dec(&block->open_count);
-        module_put(block->base->discipline->owner);
-        unlock_kernel();
+        atomic_dec(&base->block->open_count);
+        module_put(base->discipline->owner);
+        dasd_put_device(base);
         return 0;
 }
 
@@ -2298,20 +2393,20 @@ static int dasd_release(struct gendisk *disk, fmode_t mode)
  */
 static int dasd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 {
-        struct dasd_block *block;
         struct dasd_device *base;
 
-        block = bdev->bd_disk->private_data;
-        if (!block)
+        base = dasd_device_from_gendisk(bdev->bd_disk);
+        if (!base)
                 return -ENODEV;
-        base = block->base;
 
         if (!base->discipline ||
-            !base->discipline->fill_geometry)
+            !base->discipline->fill_geometry) {
+                dasd_put_device(base);
                 return -EINVAL;
-
-        base->discipline->fill_geometry(block, geo);
-        geo->start = get_start_sect(bdev) >> block->s2b_shift;
+        }
+        base->discipline->fill_geometry(base->block, geo);
+        geo->start = get_start_sect(bdev) >> base->block->s2b_shift;
+        dasd_put_device(base);
         return 0;
 }
 
@@ -2448,7 +2543,6 @@ void dasd_generic_remove(struct ccw_device *cdev)
         dasd_set_target_state(device, DASD_STATE_NEW);
         /* dasd_delete_device destroys the device reference. */
         block = device->block;
-        device->block = NULL;
         dasd_delete_device(device);
         /*
          * life cycle of block is bound to device, so delete it after
@@ -2570,7 +2664,6 @@ int dasd_generic_set_offline(struct ccw_device *cdev)
         dasd_set_target_state(device, DASD_STATE_NEW);
         /* dasd_delete_device destroys the device reference. */
         block = device->block;
-        device->block = NULL;
         dasd_delete_device(device);
         /*
          * life cycle of block is bound to device, so delete it after
@@ -2581,10 +2674,53 @@ int dasd_generic_set_offline(struct ccw_device *cdev)
         return 0;
 }
 
+int dasd_generic_last_path_gone(struct dasd_device *device)
+{
+        struct dasd_ccw_req *cqr;
+
+        dev_warn(&device->cdev->dev, "No operational channel path is left "
+                 "for the device\n");
+        DBF_DEV_EVENT(DBF_WARNING, device, "%s", "last path gone");
+        /* First of all call extended error reporting. */
+        dasd_eer_write(device, NULL, DASD_EER_NOPATH);
+
+        if (device->state < DASD_STATE_BASIC)
+                return 0;
+        /* Device is active. We want to keep it. */
+        list_for_each_entry(cqr, &device->ccw_queue, devlist)
+                if ((cqr->status == DASD_CQR_IN_IO) ||
+                    (cqr->status == DASD_CQR_CLEAR_PENDING)) {
+                        cqr->status = DASD_CQR_QUEUED;
+                        cqr->retries++;
+                }
+        dasd_device_set_stop_bits(device, DASD_STOPPED_DC_WAIT);
+        dasd_device_clear_timer(device);
+        dasd_schedule_device_bh(device);
+        return 1;
+}
+EXPORT_SYMBOL_GPL(dasd_generic_last_path_gone);
+
+int dasd_generic_path_operational(struct dasd_device *device)
+{
+        dev_info(&device->cdev->dev, "A channel path to the device has become "
+                 "operational\n");
+        DBF_DEV_EVENT(DBF_WARNING, device, "%s", "path operational");
+        dasd_device_remove_stop_bits(device, DASD_STOPPED_DC_WAIT);
+        if (device->stopped & DASD_UNRESUMED_PM) {
+                dasd_device_remove_stop_bits(device, DASD_UNRESUMED_PM);
+                dasd_restore_device(device);
+                return 1;
+        }
+        dasd_schedule_device_bh(device);
+        if (device->block)
+                dasd_schedule_block_bh(device->block);
+        return 1;
+}
+EXPORT_SYMBOL_GPL(dasd_generic_path_operational);
+
 int dasd_generic_notify(struct ccw_device *cdev, int event)
 {
         struct dasd_device *device;
-        struct dasd_ccw_req *cqr;
         int ret;
 
         device = dasd_device_from_cdev_locked(cdev);
@@ -2595,41 +2731,64 @@ int dasd_generic_notify(struct ccw_device *cdev, int event)
         case CIO_GONE:
         case CIO_BOXED:
         case CIO_NO_PATH:
-                /* First of all call extended error reporting. */
-                dasd_eer_write(device, NULL, DASD_EER_NOPATH);
-
-                if (device->state < DASD_STATE_BASIC)
-                        break;
-                /* Device is active. We want to keep it. */
-                list_for_each_entry(cqr, &device->ccw_queue, devlist)
-                        if (cqr->status == DASD_CQR_IN_IO) {
-                                cqr->status = DASD_CQR_QUEUED;
-                                cqr->retries++;
-                        }
-                dasd_device_set_stop_bits(device, DASD_STOPPED_DC_WAIT);
-                dasd_device_clear_timer(device);
-                dasd_schedule_device_bh(device);
-                ret = 1;
+                device->path_data.opm = 0;
+                device->path_data.ppm = 0;
+                device->path_data.npm = 0;
+                ret = dasd_generic_last_path_gone(device);
                 break;
         case CIO_OPER:
-                /* FIXME: add a sanity check. */
-                dasd_device_remove_stop_bits(device, DASD_STOPPED_DC_WAIT);
-                if (device->stopped & DASD_UNRESUMED_PM) {
-                        dasd_device_remove_stop_bits(device, DASD_UNRESUMED_PM);
-                        dasd_restore_device(device);
-                        ret = 1;
-                        break;
-                }
-                dasd_schedule_device_bh(device);
-                if (device->block)
-                        dasd_schedule_block_bh(device->block);
                 ret = 1;
+                if (device->path_data.opm)
+                        ret = dasd_generic_path_operational(device);
                 break;
         }
         dasd_put_device(device);
         return ret;
 }
 
+void dasd_generic_path_event(struct ccw_device *cdev, int *path_event)
+{
+        int chp;
+        __u8 oldopm, eventlpm;
+        struct dasd_device *device;
+
+        device = dasd_device_from_cdev_locked(cdev);
+        if (IS_ERR(device))
+                return;
+        for (chp = 0; chp < 8; chp++) {
+                eventlpm = 0x80 >> chp;
+                if (path_event[chp] & PE_PATH_GONE) {
+                        oldopm = device->path_data.opm;
+                        device->path_data.opm &= ~eventlpm;
+                        device->path_data.ppm &= ~eventlpm;
+                        device->path_data.npm &= ~eventlpm;
+                        if (oldopm && !device->path_data.opm)
+                                dasd_generic_last_path_gone(device);
+                }
+                if (path_event[chp] & PE_PATH_AVAILABLE) {
+                        device->path_data.opm &= ~eventlpm;
+                        device->path_data.ppm &= ~eventlpm;
+                        device->path_data.npm &= ~eventlpm;
+                        device->path_data.tbvpm |= eventlpm;
+                        dasd_schedule_device_bh(device);
+                }
+        }
+        dasd_put_device(device);
+}
+EXPORT_SYMBOL_GPL(dasd_generic_path_event);
+
+int dasd_generic_verify_path(struct dasd_device *device, __u8 lpm)
+{
+        if (!device->path_data.opm && lpm) {
+                device->path_data.opm = lpm;
+                dasd_generic_path_operational(device);
+        } else
+                device->path_data.opm |= lpm;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(dasd_generic_verify_path);
+
+
 int dasd_generic_pm_freeze(struct ccw_device *cdev)
 {
         struct dasd_ccw_req *cqr, *n;
@@ -2639,6 +2798,10 @@ int dasd_generic_pm_freeze(struct ccw_device *cdev)
 
         if (IS_ERR(device))
                 return PTR_ERR(device);
+
+        if (device->discipline->freeze)
+                rc = device->discipline->freeze(device);
+
         /* disallow new I/O  */
         dasd_device_set_stop_bits(device, DASD_STOPPED_PM);
         /* clear active requests */
@@ -2675,9 +2838,6 @@ int dasd_generic_pm_freeze(struct ccw_device *cdev)
         list_splice_tail(&freeze_queue, &device->ccw_queue);
         spin_unlock_irq(get_ccwdev_lock(cdev));
 
-        if (device->discipline->freeze)
-                rc = device->discipline->freeze(device);
-
         dasd_put_device(device);
         return rc;
 }
diff --git a/drivers/s390/block/dasd_3990_erp.c b/drivers/s390/block/dasd_3990_erp.c
index 85bfd8794856..87a0cf160fe5 100644
--- a/drivers/s390/block/dasd_3990_erp.c
+++ b/drivers/s390/block/dasd_3990_erp.c
@@ -152,9 +152,9 @@ dasd_3990_erp_alternate_path(struct dasd_ccw_req * erp)
         spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
         opm = ccw_device_get_path_mask(device->cdev);
         spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
-        //FIXME: start with get_opm ?
         if (erp->lpm == 0)
-                erp->lpm = LPM_ANYPATH & ~(erp->irb.esw.esw0.sublog.lpum);
+                erp->lpm = device->path_data.opm &
+                        ~(erp->irb.esw.esw0.sublog.lpum);
         else
                 erp->lpm &= ~(erp->irb.esw.esw0.sublog.lpum);
 
@@ -221,6 +221,7 @@ dasd_3990_erp_DCTL(struct dasd_ccw_req * erp, char modifier)
         ccw->cmd_code = CCW_CMD_DCTL;
         ccw->count = 4;
         ccw->cda = (__u32)(addr_t) DCTL_data;
+        dctl_cqr->flags = erp->flags;
         dctl_cqr->function = dasd_3990_erp_DCTL;
         dctl_cqr->refers = erp;
         dctl_cqr->startdev = device;
@@ -269,10 +270,11 @@ 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) {
+        if (erp->status == DASD_CQR_FAILED &&
+            !test_bit(DASD_CQR_VERIFY_PATH, &erp->flags)) {
                 erp->status = DASD_CQR_FILLED;
                 erp->retries = 10;
-                erp->lpm = LPM_ANYPATH;
+                erp->lpm = erp->startdev->path_data.opm;
                 erp->function = dasd_3990_erp_action_1_sec;
         }
         return erp;
@@ -1710,6 +1712,7 @@ dasd_3990_erp_action_1B_32(struct dasd_ccw_req * default_erp, char *sense)
         ccw->cda = cpa;
 
         /* fill erp related fields */
+        erp->flags = default_erp->flags;
         erp->function = dasd_3990_erp_action_1B_32;
         erp->refers = default_erp->refers;
         erp->startdev = device;
@@ -1905,15 +1908,14 @@ dasd_3990_erp_compound_retry(struct dasd_ccw_req * erp, char *sense)
 static void
 dasd_3990_erp_compound_path(struct dasd_ccw_req * erp, char *sense)
 {
-
         if (sense[25] & DASD_SENSE_BIT_3) {
                 dasd_3990_erp_alternate_path(erp);
 
-                if (erp->status == DASD_CQR_FAILED) {
+                if (erp->status == DASD_CQR_FAILED &&
+                    !test_bit(DASD_CQR_VERIFY_PATH, &erp->flags)) {
                         /* reset the lpm and the status to be able to
                          * try further actions. */
-
-                        erp->lpm = 0;
+                        erp->lpm = erp->startdev->path_data.opm;
                         erp->status = DASD_CQR_NEED_ERP;
                 }
         }
@@ -2197,7 +2199,7 @@ dasd_3990_erp_inspect_32(struct dasd_ccw_req * erp, char *sense)
 
 /*
  *****************************************************************************
- * main ERP control fuctions (24 and 32 byte sense)
+ * main ERP control functions (24 and 32 byte sense)
  *****************************************************************************
  */
 
@@ -2205,7 +2207,7 @@ dasd_3990_erp_inspect_32(struct dasd_ccw_req * erp, char *sense)
  * DASD_3990_ERP_CONTROL_CHECK
  *
  * DESCRIPTION
- *   Does a generic inspection if a control check occured and sets up
+ *   Does a generic inspection if a control check occurred and sets up
  *   the related error recovery procedure
  *
  * PARAMETER
@@ -2248,7 +2250,7 @@ dasd_3990_erp_inspect(struct dasd_ccw_req *erp)
         struct dasd_ccw_req *erp_new = NULL;
         char *sense;
 
-        /* if this problem occured on an alias retry on base */
+        /* if this problem occurred on an alias retry on base */
         erp_new = dasd_3990_erp_inspect_alias(erp);
         if (erp_new)
                 return erp_new;
@@ -2280,7 +2282,7 @@ dasd_3990_erp_inspect(struct dasd_ccw_req *erp)
  * DASD_3990_ERP_ADD_ERP
  *
  * DESCRIPTION
- *   This funtion adds an additional request block (ERP) to the head of
+ *   This function adds an additional request block (ERP) to the head of
  *   the given cqr (or erp).
  *   For a command mode cqr the erp is initialized as an default erp
  *   (retry TIC).
@@ -2354,6 +2356,7 @@ static struct dasd_ccw_req *dasd_3990_erp_add_erp(struct dasd_ccw_req *cqr)
                 ccw->cda      = (long)(cqr->cpaddr);
         }
 
+        erp->flags = cqr->flags;
         erp->function = dasd_3990_erp_add_erp;
         erp->refers   = cqr;
         erp->startdev = device;
diff --git a/drivers/s390/block/dasd_alias.c b/drivers/s390/block/dasd_alias.c
index 4155805dcdff..c388eda1e2b1 100644
--- a/drivers/s390/block/dasd_alias.c
+++ b/drivers/s390/block/dasd_alias.c
@@ -253,13 +253,11 @@ int dasd_alias_make_device_known_to_lcu(struct dasd_device *device)
  */
 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;
         device->discipline->get_uid(device, &uid);
         lcu = NULL;
         spin_lock_irqsave(&aliastree.lock, flags);
@@ -279,13 +277,11 @@ void dasd_alias_lcu_setup_complete(struct dasd_device *device)
 
 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;
         device->discipline->get_uid(device, &uid);
         lcu = NULL;
         spin_lock_irqsave(&aliastree.lock, flags);
@@ -319,6 +315,9 @@ void dasd_alias_disconnect_device_from_lcu(struct dasd_device *device)
 
         private = (struct dasd_eckd_private *) device->private;
         lcu = private->lcu;
+        /* nothing to do if already disconnected */
+        if (!lcu)
+                return;
         device->discipline->get_uid(device, &uid);
         spin_lock_irqsave(&lcu->lock, flags);
         list_del_init(&device->alias_list);
@@ -680,6 +679,9 @@ int dasd_alias_remove_device(struct dasd_device *device)
 
         private = (struct dasd_eckd_private *) device->private;
         lcu = private->lcu;
+        /* nothing to do if already removed */
+        if (!lcu)
+                return 0;
         spin_lock_irqsave(&lcu->lock, flags);
         _remove_device_from_lcu(lcu, device);
         spin_unlock_irqrestore(&lcu->lock, flags);
diff --git a/drivers/s390/block/dasd_devmap.c b/drivers/s390/block/dasd_devmap.c
index 8d41f3ed38d7..d71511c7850a 100644
--- a/drivers/s390/block/dasd_devmap.c
+++ b/drivers/s390/block/dasd_devmap.c
@@ -208,6 +208,8 @@ dasd_feature_list(char *str, char **endp)
                         features |= DASD_FEATURE_READONLY;
                 else if (len == 4 && !strncmp(str, "diag", 4))
                         features |= DASD_FEATURE_USEDIAG;
+                else if (len == 3 && !strncmp(str, "raw", 3))
+                        features |= DASD_FEATURE_USERAW;
                 else if (len == 6 && !strncmp(str, "erplog", 6))
                         features |= DASD_FEATURE_ERPLOG;
                 else if (len == 8 && !strncmp(str, "failfast", 8))
@@ -300,7 +302,7 @@ dasd_parse_keyword( char *parsestring ) {
 /*
  * Try to interprete the first element on the comma separated parse string
  * as a device number or a range of devices. If the interpretation is
- * successfull, create the matching dasd_devmap entries and return a pointer
+ * successful, create the matching dasd_devmap entries and return a pointer
  * to the residual string.
  * If interpretation fails or in case of an error, return an error code.
  */
@@ -639,6 +641,7 @@ dasd_put_device_wake(struct dasd_device *device)
 {
         wake_up(&dasd_delete_wq);
 }
+EXPORT_SYMBOL_GPL(dasd_put_device_wake);
 
 /*
  * Return dasd_device structure associated with cdev.
@@ -671,6 +674,36 @@ dasd_device_from_cdev(struct ccw_device *cdev)
         return device;
 }
 
+void dasd_add_link_to_gendisk(struct gendisk *gdp, struct dasd_device *device)
+{
+        struct dasd_devmap *devmap;
+
+        devmap = dasd_find_busid(dev_name(&device->cdev->dev));
+        if (IS_ERR(devmap))
+                return;
+        spin_lock(&dasd_devmap_lock);
+        gdp->private_data = devmap;
+        spin_unlock(&dasd_devmap_lock);
+}
+
+struct dasd_device *dasd_device_from_gendisk(struct gendisk *gdp)
+{
+        struct dasd_device *device;
+        struct dasd_devmap *devmap;
+
+        if (!gdp->private_data)
+                return NULL;
+        device = NULL;
+        spin_lock(&dasd_devmap_lock);
+        devmap = gdp->private_data;
+        if (devmap && devmap->device) {
+                device = devmap->device;
+                dasd_get_device(device);
+        }
+        spin_unlock(&dasd_devmap_lock);
+        return device;
+}
+
 /*
  * SECTION: files in sysfs
  */
@@ -856,7 +889,7 @@ dasd_use_diag_store(struct device *dev, struct device_attribute *attr,
         spin_lock(&dasd_devmap_lock);
         /* Changing diag discipline flag is only allowed in offline state. */
         rc = count;
-        if (!devmap->device) {
+        if (!devmap->device && !(devmap->features & DASD_FEATURE_USERAW)) {
                 if (val)
                         devmap->features |= DASD_FEATURE_USEDIAG;
                 else
@@ -869,6 +902,56 @@ dasd_use_diag_store(struct device *dev, struct device_attribute *attr,
 
 static DEVICE_ATTR(use_diag, 0644, dasd_use_diag_show, dasd_use_diag_store);
 
+/*
+ * use_raw controls whether the driver should give access to raw eckd data or
+ * operate in standard mode
+ */
+static ssize_t
+dasd_use_raw_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct dasd_devmap *devmap;
+        int use_raw;
+
+        devmap = dasd_find_busid(dev_name(dev));
+        if (!IS_ERR(devmap))
+                use_raw = (devmap->features & DASD_FEATURE_USERAW) != 0;
+        else
+                use_raw = (DASD_FEATURE_DEFAULT & DASD_FEATURE_USERAW) != 0;
+        return sprintf(buf, use_raw ? "1\n" : "0\n");
+}
+
+static ssize_t
+dasd_use_raw_store(struct device *dev, struct device_attribute *attr,
+                    const char *buf, size_t count)
+{
+        struct dasd_devmap *devmap;
+        ssize_t rc;
+        unsigned long val;
+
+        devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
+        if (IS_ERR(devmap))
+                return PTR_ERR(devmap);
+
+        if ((strict_strtoul(buf, 10, &val) != 0) || val > 1)
+                return -EINVAL;
+
+        spin_lock(&dasd_devmap_lock);
+        /* Changing diag discipline flag is only allowed in offline state. */
+        rc = count;
+        if (!devmap->device && !(devmap->features & DASD_FEATURE_USEDIAG)) {
+                if (val)
+                        devmap->features |= DASD_FEATURE_USERAW;
+                else
+                        devmap->features &= ~DASD_FEATURE_USERAW;
+        } else
+                rc = -EPERM;
+        spin_unlock(&dasd_devmap_lock);
+        return rc;
+}
+
+static DEVICE_ATTR(raw_track_access, 0644, dasd_use_raw_show,
+                   dasd_use_raw_store);
+
 static ssize_t
 dasd_discipline_show(struct device *dev, struct device_attribute *attr,
                      char *buf)
@@ -1126,6 +1209,103 @@ dasd_expires_store(struct device *dev, struct device_attribute *attr,
 
 static DEVICE_ATTR(expires, 0644, dasd_expires_show, dasd_expires_store);
 
+static ssize_t dasd_reservation_policy_show(struct device *dev,
+                                            struct device_attribute *attr,
+                                            char *buf)
+{
+        struct dasd_devmap *devmap;
+        int rc = 0;
+
+        devmap = dasd_find_busid(dev_name(dev));
+        if (IS_ERR(devmap)) {
+                rc = snprintf(buf, PAGE_SIZE, "ignore\n");
+        } else {
+                spin_lock(&dasd_devmap_lock);
+                if (devmap->features & DASD_FEATURE_FAILONSLCK)
+                        rc = snprintf(buf, PAGE_SIZE, "fail\n");
+                else
+                        rc = snprintf(buf, PAGE_SIZE, "ignore\n");
+                spin_unlock(&dasd_devmap_lock);
+        }
+        return rc;
+}
+
+static ssize_t dasd_reservation_policy_store(struct device *dev,
+                                             struct device_attribute *attr,
+                                             const char *buf, size_t count)
+{
+        struct dasd_devmap *devmap;
+        int rc;
+
+        devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
+        if (IS_ERR(devmap))
+                return PTR_ERR(devmap);
+        rc = 0;
+        spin_lock(&dasd_devmap_lock);
+        if (sysfs_streq("ignore", buf))
+                devmap->features &= ~DASD_FEATURE_FAILONSLCK;
+        else if (sysfs_streq("fail", buf))
+                devmap->features |= DASD_FEATURE_FAILONSLCK;
+        else
+                rc = -EINVAL;
+        if (devmap->device)
+                devmap->device->features = devmap->features;
+        spin_unlock(&dasd_devmap_lock);
+        if (rc)
+                return rc;
+        else
+                return count;
+}
+
+static DEVICE_ATTR(reservation_policy, 0644,
+                   dasd_reservation_policy_show, dasd_reservation_policy_store);
+
+static ssize_t dasd_reservation_state_show(struct device *dev,
+                                           struct device_attribute *attr,
+                                           char *buf)
+{
+        struct dasd_device *device;
+        int rc = 0;
+
+        device = dasd_device_from_cdev(to_ccwdev(dev));
+        if (IS_ERR(device))
+                return snprintf(buf, PAGE_SIZE, "none\n");
+
+        if (test_bit(DASD_FLAG_IS_RESERVED, &device->flags))
+                rc = snprintf(buf, PAGE_SIZE, "reserved\n");
+        else if (test_bit(DASD_FLAG_LOCK_STOLEN, &device->flags))
+                rc = snprintf(buf, PAGE_SIZE, "lost\n");
+        else
+                rc = snprintf(buf, PAGE_SIZE, "none\n");
+        dasd_put_device(device);
+        return rc;
+}
+
+static ssize_t dasd_reservation_state_store(struct device *dev,
+                                            struct device_attribute *attr,
+                                            const char *buf, size_t count)
+{
+        struct dasd_device *device;
+        int rc = 0;
+
+        device = dasd_device_from_cdev(to_ccwdev(dev));
+        if (IS_ERR(device))
+                return -ENODEV;
+        if (sysfs_streq("reset", buf))
+                clear_bit(DASD_FLAG_LOCK_STOLEN, &device->flags);
+        else
+                rc = -EINVAL;
+        dasd_put_device(device);
+
+        if (rc)
+                return rc;
+        else
+                return count;
+}
+
+static DEVICE_ATTR(last_known_reservation_state, 0644,
+                   dasd_reservation_state_show, dasd_reservation_state_store);
+
 static struct attribute * dasd_attrs[] = {
         &dev_attr_readonly.attr,
         &dev_attr_discipline.attr,
@@ -1134,10 +1314,13 @@ static struct attribute * dasd_attrs[] = {
         &dev_attr_vendor.attr,
         &dev_attr_uid.attr,
         &dev_attr_use_diag.attr,
+        &dev_attr_raw_track_access.attr,
         &dev_attr_eer_enabled.attr,
         &dev_attr_erplog.attr,
         &dev_attr_failfast.attr,
         &dev_attr_expires.attr,
+        &dev_attr_reservation_policy.attr,
+        &dev_attr_last_known_reservation_state.attr,
         NULL,
 };
 
diff --git a/drivers/s390/block/dasd_diag.c b/drivers/s390/block/dasd_diag.c
index 2b3bc3ec0541..46784b83c5c4 100644
--- a/drivers/s390/block/dasd_diag.c
+++ b/drivers/s390/block/dasd_diag.c
@@ -10,6 +10,7 @@
 
 #define KMSG_COMPONENT "dasd"
 
+#include <linux/kernel_stat.h>
 #include <linux/stddef.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
@@ -23,7 +24,7 @@
 #include <asm/debug.h>
 #include <asm/ebcdic.h>
 #include <asm/io.h>
-#include <asm/s390_ext.h>
+#include <asm/irq.h>
 #include <asm/vtoc.h>
 #include <asm/diag.h>
 
@@ -228,29 +229,27 @@ dasd_diag_term_IO(struct dasd_ccw_req * cqr)
 }
 
 /* Handle external interruption. */
-static void
-dasd_ext_handler(__u16 code)
+static void dasd_ext_handler(unsigned int ext_int_code,
+                             unsigned int param32, unsigned long param64)
 {
         struct dasd_ccw_req *cqr, *next;
         struct dasd_device *device;
         unsigned long long expires;
         unsigned long flags;
-        u8 int_code, status;
         addr_t ip;
         int rc;
 
-        int_code = *((u8 *) DASD_DIAG_LC_INT_CODE);
-        status = *((u8 *) DASD_DIAG_LC_INT_STATUS);
-        switch (int_code) {
+        switch (ext_int_code >> 24) {
         case DASD_DIAG_CODE_31BIT:
-                ip = (addr_t) *((u32 *) DASD_DIAG_LC_INT_PARM_31BIT);
+                ip = (addr_t) param32;
                 break;
         case DASD_DIAG_CODE_64BIT:
-                ip = (addr_t) *((u64 *) DASD_DIAG_LC_INT_PARM_64BIT);
+                ip = (addr_t) param64;
                 break;
         default:
                 return;
         }
+        kstat_cpu(smp_processor_id()).irqs[EXTINT_DSD]++;
         if (!ip) {              /* no intparm: unsolicited interrupt */
                 DBF_EVENT(DBF_NOTICE, "%s", "caught unsolicited "
                               "interrupt");
@@ -281,7 +280,7 @@ dasd_ext_handler(__u16 code)
         cqr->stopclk = get_clock();
 
         expires = 0;
-        if (status == 0) {
+        if ((ext_int_code & 0xff0000) == 0) {
                 cqr->status = DASD_CQR_SUCCESS;
                 /* Start first request on queue if possible -> fast_io. */
                 if (!list_empty(&device->ccw_queue)) {
@@ -296,8 +295,8 @@ dasd_ext_handler(__u16 code)
         } else {
                 cqr->status = DASD_CQR_QUEUED;
                 DBF_DEV_EVENT(DBF_DEBUG, device, "interrupt status for "
-                            "request %p was %d (%d retries left)", cqr, status,
-                            cqr->retries);
+                              "request %p was %d (%d retries left)", cqr,
+                              (ext_int_code >> 16) & 0xff, cqr->retries);
                 dasd_diag_erp(device);
         }
 
@@ -620,6 +619,7 @@ static struct dasd_discipline dasd_diag_discipline = {
         .ebcname = "DIAG",
         .max_blocks = DIAG_MAX_BLOCKS,
         .check_device = dasd_diag_check_device,
+        .verify_path = dasd_generic_verify_path,
         .fill_geometry = dasd_diag_fill_geometry,
         .start_IO = dasd_start_diag,
         .term_IO = dasd_diag_term_IO,
@@ -642,7 +642,7 @@ dasd_diag_init(void)
         }
         ASCEBC(dasd_diag_discipline.ebcname, 4);
 
-        ctl_set_bit(0, 9);
+        service_subclass_irq_register();
         register_external_interrupt(0x2603, dasd_ext_handler);
         dasd_diag_discipline_pointer = &dasd_diag_discipline;
         return 0;
@@ -652,7 +652,7 @@ static void __exit
 dasd_diag_cleanup(void)
 {
         unregister_external_interrupt(0x2603, dasd_ext_handler);
-        ctl_clear_bit(0, 9);
+        service_subclass_irq_unregister();
         dasd_diag_discipline_pointer = NULL;
 }
 
diff --git a/drivers/s390/block/dasd_diag.h b/drivers/s390/block/dasd_diag.h
index b8c78267ff3e..4f71fbe60c82 100644
--- a/drivers/s390/block/dasd_diag.h
+++ b/drivers/s390/block/dasd_diag.h
@@ -18,10 +18,6 @@
 #define DEV_CLASS_FBA   0x01
 #define DEV_CLASS_ECKD  0x04
 
-#define DASD_DIAG_LC_INT_CODE           132
-#define DASD_DIAG_LC_INT_STATUS         133
-#define DASD_DIAG_LC_INT_PARM_31BIT     128
-#define DASD_DIAG_LC_INT_PARM_64BIT     4536
 #define DASD_DIAG_CODE_31BIT            0x03
 #define DASD_DIAG_CODE_64BIT            0x07
 
diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index 66360c24bd48..30fb979d684d 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -54,6 +54,15 @@
 #define ECKD_F7(i) (i->factor7)
 #define ECKD_F8(i) (i->factor8)
 
+/*
+ * raw track access always map to 64k in memory
+ * so it maps to 16 blocks of 4k per track
+ */
+#define DASD_RAW_BLOCK_PER_TRACK 16
+#define DASD_RAW_BLOCKSIZE 4096
+/* 64k are 128 x 512 byte sectors  */
+#define DASD_RAW_SECTORS_PER_TRACK 128
+
 MODULE_LICENSE("GPL");
 
 static struct dasd_discipline dasd_eckd_discipline;
@@ -63,7 +72,7 @@ static struct dasd_discipline dasd_eckd_discipline;
 static struct ccw_device_id dasd_eckd_ids[] = {
         { CCW_DEVICE_DEVTYPE (0x3990, 0, 0x3390, 0), .driver_info = 0x1},
         { CCW_DEVICE_DEVTYPE (0x2105, 0, 0x3390, 0), .driver_info = 0x2},
-        { CCW_DEVICE_DEVTYPE (0x3880, 0, 0x3390, 0), .driver_info = 0x3},
+        { CCW_DEVICE_DEVTYPE (0x3880, 0, 0x3380, 0), .driver_info = 0x3},
         { CCW_DEVICE_DEVTYPE (0x3990, 0, 0x3380, 0), .driver_info = 0x4},
         { CCW_DEVICE_DEVTYPE (0x2105, 0, 0x3380, 0), .driver_info = 0x5},
         { CCW_DEVICE_DEVTYPE (0x9343, 0, 0x9345, 0), .driver_info = 0x6},
@@ -90,6 +99,18 @@ static struct {
 } *dasd_reserve_req;
 static DEFINE_MUTEX(dasd_reserve_mutex);
 
+/* definitions for the path verification worker */
+struct path_verification_work_data {
+        struct work_struct worker;
+        struct dasd_device *device;
+        struct dasd_ccw_req cqr;
+        struct ccw1 ccw;
+        __u8 rcd_buffer[DASD_ECKD_RCD_DATA_SIZE];
+        int isglobal;
+        __u8 tbvpm;
+};
+static struct path_verification_work_data *path_verification_worker;
+static DEFINE_MUTEX(dasd_path_verification_mutex);
 
 /* initial attempt at a probe function. this can be simplified once
  * the other detection code is gone */
@@ -373,6 +394,23 @@ static void fill_LRE_data(struct LRE_eckd_data *data, unsigned int trk,
                 data->length = reclen;
                 data->operation.operation = 0x03;
                 break;
+        case DASD_ECKD_CCW_WRITE_FULL_TRACK:
+                data->operation.orientation = 0x0;
+                data->operation.operation = 0x3F;
+                data->extended_operation = 0x11;
+                data->length = 0;
+                data->extended_parameter_length = 0x02;
+                if (data->count > 8) {
+                        data->extended_parameter[0] = 0xFF;
+                        data->extended_parameter[1] = 0xFF;
+                        data->extended_parameter[1] <<= (16 - count);
+                } else {
+                        data->extended_parameter[0] = 0xFF;
+                        data->extended_parameter[0] <<= (8 - count);
+                        data->extended_parameter[1] = 0x00;
+                }
+                data->sector = 0xFF;
+                break;
         case DASD_ECKD_CCW_WRITE_TRACK_DATA:
                 data->auxiliary.length_valid = 0x1;
                 data->length = reclen;  /* not tlf, as one might think */
@@ -396,6 +434,12 @@ static void fill_LRE_data(struct LRE_eckd_data *data, unsigned int trk,
         case DASD_ECKD_CCW_READ_COUNT:
                 data->operation.operation = 0x06;
                 break;
+        case DASD_ECKD_CCW_READ_TRACK:
+                data->operation.orientation = 0x1;
+                data->operation.operation = 0x0C;
+                data->extended_parameter_length = 0;
+                data->sector = 0xFF;
+                break;
         case DASD_ECKD_CCW_READ_TRACK_DATA:
                 data->auxiliary.length_valid = 0x1;
                 data->length = tlf;
@@ -439,10 +483,16 @@ static int prefix_LRE(struct ccw1 *ccw, struct PFX_eckd_data *pfxdata,
 
         ccw->cmd_code = DASD_ECKD_CCW_PFX;
         ccw->flags = 0;
-        ccw->count = sizeof(*pfxdata);
-        ccw->cda = (__u32) __pa(pfxdata);
+        if (cmd == DASD_ECKD_CCW_WRITE_FULL_TRACK) {
+                ccw->count = sizeof(*pfxdata) + 2;
+                ccw->cda = (__u32) __pa(pfxdata);
+                memset(pfxdata, 0, sizeof(*pfxdata) + 2);
+        } else {
+                ccw->count = sizeof(*pfxdata);
+                ccw->cda = (__u32) __pa(pfxdata);
+                memset(pfxdata, 0, sizeof(*pfxdata));
+        }
 
-        memset(pfxdata, 0, sizeof(*pfxdata));
         /* prefix data */
         if (format > 1) {
                 DBF_DEV_EVENT(DBF_ERR, basedev,
@@ -476,6 +526,7 @@ static int prefix_LRE(struct ccw1 *ccw, struct PFX_eckd_data *pfxdata,
                 dedata->mask.perm = 0x1;
                 dedata->attributes.operation = basepriv->attrib.operation;
                 break;
+        case DASD_ECKD_CCW_READ_TRACK:
         case DASD_ECKD_CCW_READ_TRACK_DATA:
                 dedata->mask.perm = 0x1;
                 dedata->attributes.operation = basepriv->attrib.operation;
@@ -502,6 +553,11 @@ static int prefix_LRE(struct ccw1 *ccw, struct PFX_eckd_data *pfxdata,
                 dedata->attributes.operation = DASD_BYPASS_CACHE;
                 rc = check_XRC_on_prefix(pfxdata, basedev);
                 break;
+        case DASD_ECKD_CCW_WRITE_FULL_TRACK:
+                dedata->mask.perm = 0x03;
+                dedata->attributes.operation = basepriv->attrib.operation;
+                dedata->blk_size = 0;
+                break;
         case DASD_ECKD_CCW_WRITE_TRACK_DATA:
                 dedata->mask.perm = 0x02;
                 dedata->attributes.operation = basepriv->attrib.operation;
@@ -755,26 +811,27 @@ static int dasd_eckd_get_uid(struct dasd_device *device, struct dasd_uid *uid)
         return -EINVAL;
 }
 
-static struct dasd_ccw_req *dasd_eckd_build_rcd_lpm(struct dasd_device *device,
-                                                    void *rcd_buffer,
-                                                    struct ciw *ciw, __u8 lpm)
+static void dasd_eckd_fill_rcd_cqr(struct dasd_device *device,
+                                   struct dasd_ccw_req *cqr,
+                                   __u8 *rcd_buffer,
+                                   __u8 lpm)
 {
-        struct dasd_ccw_req *cqr;
         struct ccw1 *ccw;
-
-        cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* RCD */, ciw->count,
-                                   device);
-
-        if (IS_ERR(cqr)) {
-                DBF_DEV_EVENT(DBF_WARNING, device, "%s",
-                              "Could not allocate RCD request");
-                return cqr;
-        }
+        /*
+         * buffer has to start with EBCDIC "V1.0" to show
+         * support for virtual device SNEQ
+         */
+        rcd_buffer[0] = 0xE5;
+        rcd_buffer[1] = 0xF1;
+        rcd_buffer[2] = 0x4B;
+        rcd_buffer[3] = 0xF0;
 
         ccw = cqr->cpaddr;
-        ccw->cmd_code = ciw->cmd;
+        ccw->cmd_code = DASD_ECKD_CCW_RCD;
+        ccw->flags = 0;
         ccw->cda = (__u32)(addr_t)rcd_buffer;
-        ccw->count = ciw->count;
+        ccw->count = DASD_ECKD_RCD_DATA_SIZE;
+        cqr->magic = DASD_ECKD_MAGIC;
 
         cqr->startdev = device;
         cqr->memdev = device;
@@ -784,7 +841,30 @@ static struct dasd_ccw_req *dasd_eckd_build_rcd_lpm(struct dasd_device *device,
         cqr->retries = 256;
         cqr->buildclk = get_clock();
         cqr->status = DASD_CQR_FILLED;
-        return cqr;
+        set_bit(DASD_CQR_VERIFY_PATH, &cqr->flags);
+}
+
+static int dasd_eckd_read_conf_immediately(struct dasd_device *device,
+                                           struct dasd_ccw_req *cqr,
+                                           __u8 *rcd_buffer,
+                                           __u8 lpm)
+{
+        struct ciw *ciw;
+        int rc;
+        /*
+         * sanity check: scan for RCD command in extended SenseID data
+         * some devices do not support RCD
+         */
+        ciw = ccw_device_get_ciw(device->cdev, CIW_TYPE_RCD);
+        if (!ciw || ciw->cmd != DASD_ECKD_CCW_RCD)
+                return -EOPNOTSUPP;
+
+        dasd_eckd_fill_rcd_cqr(device, cqr, rcd_buffer, lpm);
+        clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
+        set_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags);
+        cqr->retries = 5;
+        rc = dasd_sleep_on_immediatly(cqr);
+        return rc;
 }
 
 static int dasd_eckd_read_conf_lpm(struct dasd_device *device,
@@ -797,32 +877,29 @@ static int dasd_eckd_read_conf_lpm(struct dasd_device *device,
         struct dasd_ccw_req *cqr;
 
         /*
-         * scan for RCD command in extended SenseID data
+         * sanity check: scan for RCD command in extended SenseID data
+         * some devices do not support RCD
          */
         ciw = ccw_device_get_ciw(device->cdev, CIW_TYPE_RCD);
-        if (!ciw || ciw->cmd == 0) {
+        if (!ciw || ciw->cmd != DASD_ECKD_CCW_RCD) {
                 ret = -EOPNOTSUPP;
                 goto out_error;
         }
-        rcd_buf = kzalloc(ciw->count, GFP_KERNEL | GFP_DMA);
+        rcd_buf = kzalloc(DASD_ECKD_RCD_DATA_SIZE, GFP_KERNEL | GFP_DMA);
         if (!rcd_buf) {
                 ret = -ENOMEM;
                 goto out_error;
         }
-
-        /*
-         * buffer has to start with EBCDIC "V1.0" to show
-         * support for virtual device SNEQ
-         */
-        rcd_buf[0] = 0xE5;
-        rcd_buf[1] = 0xF1;
-        rcd_buf[2] = 0x4B;
-        rcd_buf[3] = 0xF0;
-        cqr = dasd_eckd_build_rcd_lpm(device, rcd_buf, ciw, lpm);
+        cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* RCD */,
+                                   0, /* use rcd_buf as data ara */
+                                   device);
         if (IS_ERR(cqr)) {
-                ret =  PTR_ERR(cqr);
+                DBF_DEV_EVENT(DBF_WARNING, device, "%s",
+                              "Could not allocate RCD request");
+                ret = -ENOMEM;
                 goto out_error;
         }
+        dasd_eckd_fill_rcd_cqr(device, cqr, rcd_buf, lpm);
         ret = dasd_sleep_on(cqr);
         /*
          * on success we update the user input parms
@@ -831,7 +908,7 @@ static int dasd_eckd_read_conf_lpm(struct dasd_device *device,
         if (ret)
                 goto out_error;
 
-        *rcd_buffer_size = ciw->count;
+        *rcd_buffer_size = DASD_ECKD_RCD_DATA_SIZE;
         *rcd_buffer = rcd_buf;
         return 0;
 out_error:
@@ -901,18 +978,18 @@ static int dasd_eckd_read_conf(struct dasd_device *device)
         void *conf_data;
         int conf_len, conf_data_saved;
         int rc;
-        __u8 lpm;
+        __u8 lpm, opm;
         struct dasd_eckd_private *private;
-        struct dasd_eckd_path *path_data;
+        struct dasd_path *path_data;
 
         private = (struct dasd_eckd_private *) device->private;
-        path_data = (struct dasd_eckd_path *) &private->path_data;
-        path_data->opm = ccw_device_get_path_mask(device->cdev);
+        path_data = &device->path_data;
+        opm = ccw_device_get_path_mask(device->cdev);
         lpm = 0x80;
         conf_data_saved = 0;
         /* get configuration data per operational path */
         for (lpm = 0x80; lpm; lpm>>= 1) {
-                if (lpm & path_data->opm){
+                if (lpm & opm) {
                         rc = dasd_eckd_read_conf_lpm(device, &conf_data,
                                                      &conf_len, lpm);
                         if (rc && rc != -EOPNOTSUPP) {  /* -EOPNOTSUPP is ok */
@@ -925,6 +1002,8 @@ static int dasd_eckd_read_conf(struct dasd_device *device)
                                 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
                                                 "No configuration data "
                                                 "retrieved");
+                                /* no further analysis possible */
+                                path_data->opm |= lpm;
                                 continue;       /* no error */
                         }
                         /* save first valid configuration data */
@@ -948,6 +1027,7 @@ static int dasd_eckd_read_conf(struct dasd_device *device)
                                 path_data->ppm |= lpm;
                                 break;
                         }
+                        path_data->opm |= lpm;
                         if (conf_data != private->conf_data)
                                 kfree(conf_data);
                 }
@@ -955,6 +1035,140 @@ static int dasd_eckd_read_conf(struct dasd_device *device)
         return 0;
 }
 
+static int verify_fcx_max_data(struct dasd_device *device, __u8 lpm)
+{
+        struct dasd_eckd_private *private;
+        int mdc;
+        u32 fcx_max_data;
+
+        private = (struct dasd_eckd_private *) device->private;
+        if (private->fcx_max_data) {
+                mdc = ccw_device_get_mdc(device->cdev, lpm);
+                if ((mdc < 0)) {
+                        dev_warn(&device->cdev->dev,
+                                 "Detecting the maximum data size for zHPF "
+                                 "requests failed (rc=%d) for a new path %x\n",
+                                 mdc, lpm);
+                        return mdc;
+                }
+                fcx_max_data = mdc * FCX_MAX_DATA_FACTOR;
+                if (fcx_max_data < private->fcx_max_data) {
+                        dev_warn(&device->cdev->dev,
+                                 "The maximum data size for zHPF requests %u "
+                                 "on a new path %x is below the active maximum "
+                                 "%u\n", fcx_max_data, lpm,
+                                 private->fcx_max_data);
+                        return -EACCES;
+                }
+        }
+        return 0;
+}
+
+static void do_path_verification_work(struct work_struct *work)
+{
+        struct path_verification_work_data *data;
+        struct dasd_device *device;
+        __u8 lpm, opm, npm, ppm, epm;
+        unsigned long flags;
+        int rc;
+
+        data = container_of(work, struct path_verification_work_data, worker);
+        device = data->device;
+
+        opm = 0;
+        npm = 0;
+        ppm = 0;
+        epm = 0;
+        for (lpm = 0x80; lpm; lpm >>= 1) {
+                if (lpm & data->tbvpm) {
+                        memset(data->rcd_buffer, 0, sizeof(data->rcd_buffer));
+                        memset(&data->cqr, 0, sizeof(data->cqr));
+                        data->cqr.cpaddr = &data->ccw;
+                        rc = dasd_eckd_read_conf_immediately(device, &data->cqr,
+                                                             data->rcd_buffer,
+                                                             lpm);
+                        if (!rc) {
+                                switch (dasd_eckd_path_access(data->rcd_buffer,
+                                                     DASD_ECKD_RCD_DATA_SIZE)) {
+                                case 0x02:
+                                        npm |= lpm;
+                                        break;
+                                case 0x03:
+                                        ppm |= lpm;
+                                        break;
+                                }
+                                opm |= lpm;
+                        } else if (rc == -EOPNOTSUPP) {
+                                DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
+                                       "path verification: No configuration "
+                                       "data retrieved");
+                                opm |= lpm;
+                        } else if (rc == -EAGAIN) {
+                                DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
+                                        "path verification: device is stopped,"
+                                        " try again later");
+                                epm |= lpm;
+                        } else {
+                                dev_warn(&device->cdev->dev,
+                                         "Reading device feature codes failed "
+                                         "(rc=%d) for new path %x\n", rc, lpm);
+                                continue;
+                        }
+                        if (verify_fcx_max_data(device, lpm)) {
+                                opm &= ~lpm;
+                                npm &= ~lpm;
+                                ppm &= ~lpm;
+                        }
+                }
+        }
+        /*
+         * There is a small chance that a path is lost again between
+         * above path verification and the following modification of
+         * the device opm mask. We could avoid that race here by using
+         * yet another path mask, but we rather deal with this unlikely
+         * situation in dasd_start_IO.
+         */
+        spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
+        if (!device->path_data.opm && opm) {
+                device->path_data.opm = opm;
+                dasd_generic_path_operational(device);
+        } else
+                device->path_data.opm |= opm;
+        device->path_data.npm |= npm;
+        device->path_data.ppm |= ppm;
+        device->path_data.tbvpm |= epm;
+        spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
+
+        dasd_put_device(device);
+        if (data->isglobal)
+                mutex_unlock(&dasd_path_verification_mutex);
+        else
+                kfree(data);
+}
+
+static int dasd_eckd_verify_path(struct dasd_device *device, __u8 lpm)
+{
+        struct path_verification_work_data *data;
+
+        data = kmalloc(sizeof(*data), GFP_ATOMIC | GFP_DMA);
+        if (!data) {
+                if (mutex_trylock(&dasd_path_verification_mutex)) {
+                        data = path_verification_worker;
+                        data->isglobal = 1;
+                } else
+                        return -ENOMEM;
+        } else {
+                memset(data, 0, sizeof(*data));
+                data->isglobal = 0;
+        }
+        INIT_WORK(&data->worker, do_path_verification_work);
+        dasd_get_device(device);
+        data->device = device;
+        data->tbvpm = lpm;
+        schedule_work(&data->worker);
+        return 0;
+}
+
 static int dasd_eckd_read_features(struct dasd_device *device)
 {
         struct dasd_psf_prssd_data *prssdp;
@@ -1105,6 +1319,37 @@ static void dasd_eckd_validate_server(struct dasd_device *device)
                         "returned rc=%d", private->uid.ssid, rc);
 }
 
+static u32 get_fcx_max_data(struct dasd_device *device)
+{
+#if defined(CONFIG_64BIT)
+        int tpm, mdc;
+        int fcx_in_css, fcx_in_gneq, fcx_in_features;
+        struct dasd_eckd_private *private;
+
+        if (dasd_nofcx)
+                return 0;
+        /* is transport mode supported? */
+        private = (struct dasd_eckd_private *) device->private;
+        fcx_in_css = css_general_characteristics.fcx;
+        fcx_in_gneq = private->gneq->reserved2[7] & 0x04;
+        fcx_in_features = private->features.feature[40] & 0x80;
+        tpm = fcx_in_css && fcx_in_gneq && fcx_in_features;
+
+        if (!tpm)
+                return 0;
+
+        mdc = ccw_device_get_mdc(device->cdev, 0);
+        if (mdc < 0) {
+                dev_warn(&device->cdev->dev, "Detecting the maximum supported"
+                         " data size for zHPF requests failed\n");
+                return 0;
+        } else
+                return mdc * FCX_MAX_DATA_FACTOR;
+#else
+        return 0;
+#endif
+}
+
 /*
  * Check device characteristics.
  * If the device is accessible using ECKD discipline, the device is enabled.
@@ -1190,7 +1435,7 @@ dasd_eckd_check_characteristics(struct dasd_device *device)
                 goto out_err2;
         }
         /*
-         * dasd_eckd_vaildate_server is done on the first device that
+         * dasd_eckd_validate_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.
          */
@@ -1216,13 +1461,15 @@ dasd_eckd_check_characteristics(struct dasd_device *device)
                                 "Read device characteristic failed, rc=%d", rc);
                 goto out_err3;
         }
-        /* find the vaild cylinder size */
+        /* find the valid cylinder size */
         if (private->rdc_data.no_cyl == LV_COMPAT_CYL &&
             private->rdc_data.long_no_cyl)
                 private->real_cyl = private->rdc_data.long_no_cyl;
         else
                 private->real_cyl = private->rdc_data.no_cyl;
 
+        private->fcx_max_data = get_fcx_max_data(device);
+
         readonly = dasd_device_is_ro(device);
         if (readonly)
                 set_bit(DASD_FLAG_DEVICE_RO, &device->flags);
@@ -1364,10 +1611,8 @@ static void dasd_eckd_analysis_callback(struct dasd_ccw_req *init_cqr,
 
 static int dasd_eckd_start_analysis(struct dasd_block *block)
 {
-        struct dasd_eckd_private *private;
         struct dasd_ccw_req *init_cqr;
 
-        private = (struct dasd_eckd_private *) block->base->private;
         init_cqr = dasd_eckd_analysis_ccw(block->base);
         if (IS_ERR(init_cqr))
                 return PTR_ERR(init_cqr);
@@ -1404,6 +1649,13 @@ static int dasd_eckd_end_analysis(struct dasd_block *block)
                 dasd_sfree_request(init_cqr, device);
         }
 
+        if (device->features & DASD_FEATURE_USERAW) {
+                block->bp_block = DASD_RAW_BLOCKSIZE;
+                blk_per_trk = DASD_RAW_BLOCK_PER_TRACK;
+                block->s2b_shift = 3;
+                goto raw;
+        }
+
         if (status == INIT_CQR_UNFORMATTED) {
                 dev_warn(&device->cdev->dev, "The DASD is not formatted\n");
                 return -EMEDIUMTYPE;
@@ -1441,6 +1693,7 @@ static int dasd_eckd_end_analysis(struct dasd_block *block)
                         dev_warn(&device->cdev->dev,
                                  "Track 0 has no records following the VTOC\n");
         }
+
         if (count_area != NULL && count_area->kl == 0) {
                 /* we found notthing violating our disk layout */
                 if (dasd_check_blocksize(count_area->dl) == 0)
@@ -1456,6 +1709,8 @@ static int dasd_eckd_end_analysis(struct dasd_block *block)
                 block->s2b_shift++;
 
         blk_per_trk = recs_per_track(&private->rdc_data, 0, block->bp_block);
+
+raw:
         block->blocks = (private->real_cyl *
                           private->rdc_data.trk_per_cyl *
                           blk_per_trk);
@@ -1716,6 +1971,7 @@ static void dasd_eckd_handle_terminated_request(struct dasd_ccw_req *cqr)
         if (cqr->block && (cqr->startdev != cqr->block->base)) {
                 dasd_eckd_reset_ccw_to_base_io(cqr);
                 cqr->startdev = cqr->block->base;
+                cqr->lpm = cqr->block->base->path_data.opm;
         }
 };
 
@@ -1744,9 +2000,9 @@ dasd_eckd_erp_postaction(struct dasd_ccw_req * cqr)
         return dasd_default_erp_postaction;
 }
 
-
-static void dasd_eckd_handle_unsolicited_interrupt(struct dasd_device *device,
-                                                   struct irb *irb)
+static void dasd_eckd_check_for_device_change(struct dasd_device *device,
+                                              struct dasd_ccw_req *cqr,
+                                              struct irb *irb)
 {
         char mask;
         char *sense = NULL;
@@ -1770,51 +2026,42 @@ static void dasd_eckd_handle_unsolicited_interrupt(struct dasd_device *device,
                         /* schedule worker to reload device */
                         dasd_reload_device(device);
                 }
-
                 dasd_generic_handle_state_change(device);
                 return;
         }
 
+        sense = dasd_get_sense(irb);
+        if (!sense)
+                return;
+
         /* summary unit check */
-        if ((scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK) &&
-            (irb->ecw[7] == 0x0D)) {
+        if ((sense[27] & DASD_SENSE_BIT_0) && (sense[7] == 0x0D) &&
+            (scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK)) {
                 dasd_alias_handle_summary_unit_check(device, irb);
                 return;
         }
 
-        sense = dasd_get_sense(irb);
         /* service information message SIM */
-        if (sense && !(sense[27] & DASD_SENSE_BIT_0) &&
+        if (!cqr && !(sense[27] & DASD_SENSE_BIT_0) &&
             ((sense[6] & DASD_SIM_SENSE) == DASD_SIM_SENSE)) {
                 dasd_3990_erp_handle_sim(device, sense);
-                dasd_schedule_device_bh(device);
                 return;
         }
 
-        if ((scsw_cc(&irb->scsw) == 1) &&
-            (scsw_fctl(&irb->scsw) & SCSW_FCTL_START_FUNC) &&
-            (scsw_actl(&irb->scsw) & SCSW_ACTL_START_PEND) &&
-            (scsw_stctl(&irb->scsw) & SCSW_STCTL_STATUS_PEND)) {
-                /* fake irb do nothing, they are handled elsewhere */
-                dasd_schedule_device_bh(device);
-                return;
-        }
-
-        if (!sense) {
-                /* just report other unsolicited interrupts */
-                DBF_DEV_EVENT(DBF_ERR, device, "%s",
-                            "unsolicited interrupt received");
-        } else {
-                DBF_DEV_EVENT(DBF_ERR, device, "%s",
-                            "unsolicited interrupt received "
-                            "(sense available)");
-                device->discipline->dump_sense_dbf(device, irb, "unsolicited");
+        /* loss of device reservation is handled via base devices only
+         * as alias devices may be used with several bases
+         */
+        if (device->block && (sense[27] & DASD_SENSE_BIT_0) &&
+            (sense[7] == 0x3F) &&
+            (scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK) &&
+            test_bit(DASD_FLAG_IS_RESERVED, &device->flags)) {
+                if (device->features & DASD_FEATURE_FAILONSLCK)
+                        set_bit(DASD_FLAG_LOCK_STOLEN, &device->flags);
+                clear_bit(DASD_FLAG_IS_RESERVED, &device->flags);
+                dev_err(&device->cdev->dev,
+                        "The device reservation was lost\n");
         }
-
-        dasd_schedule_device_bh(device);
-        return;
-};
-
+}
 
 static struct dasd_ccw_req *dasd_eckd_build_cp_cmd_single(
                                                struct dasd_device *startdev,
@@ -1995,7 +2242,7 @@ static struct dasd_ccw_req *dasd_eckd_build_cp_cmd_single(
         cqr->memdev = startdev;
         cqr->block = block;
         cqr->expires = startdev->default_expires * HZ;  /* default 5 minutes */
-        cqr->lpm = private->path_data.ppm;
+        cqr->lpm = startdev->path_data.ppm;
         cqr->retries = 256;
         cqr->buildclk = get_clock();
         cqr->status = DASD_CQR_FILLED;
@@ -2015,7 +2262,6 @@ static struct dasd_ccw_req *dasd_eckd_build_cp_cmd_track(
                                                unsigned int blk_per_trk,
                                                unsigned int blksize)
 {
-        struct dasd_eckd_private *private;
         unsigned long *idaws;
         struct dasd_ccw_req *cqr;
         struct ccw1 *ccw;
@@ -2034,7 +2280,6 @@ static struct dasd_ccw_req *dasd_eckd_build_cp_cmd_track(
         unsigned int recoffs;
 
         basedev = block->base;
-        private = (struct dasd_eckd_private *) basedev->private;
         if (rq_data_dir(req) == READ)
                 cmd = DASD_ECKD_CCW_READ_TRACK_DATA;
         else if (rq_data_dir(req) == WRITE)
@@ -2172,7 +2417,7 @@ static struct dasd_ccw_req *dasd_eckd_build_cp_cmd_track(
         cqr->memdev = startdev;
         cqr->block = block;
         cqr->expires = startdev->default_expires * HZ;  /* default 5 minutes */
-        cqr->lpm = private->path_data.ppm;
+        cqr->lpm = startdev->path_data.ppm;
         cqr->retries = 256;
         cqr->buildclk = get_clock();
         cqr->status = DASD_CQR_FILLED;
@@ -2307,8 +2552,7 @@ static int prepare_itcw(struct itcw *itcw,
 
         dcw = itcw_add_dcw(itcw, pfx_cmd, 0,
                      &pfxdata, sizeof(pfxdata), total_data_size);
-
-        return rc;
+        return IS_ERR(dcw) ? PTR_ERR(dcw) : 0;
 }
 
 static struct dasd_ccw_req *dasd_eckd_build_cp_tpm_track(
@@ -2324,7 +2568,6 @@ static struct dasd_ccw_req *dasd_eckd_build_cp_tpm_track(
                                                unsigned int blk_per_trk,
                                                unsigned int blksize)
 {
-        struct dasd_eckd_private *private;
         struct dasd_ccw_req *cqr;
         struct req_iterator iter;
         struct bio_vec *bv;
@@ -2337,9 +2580,14 @@ static struct dasd_ccw_req *dasd_eckd_build_cp_tpm_track(
         struct tidaw *last_tidaw = NULL;
         int itcw_op;
         size_t itcw_size;
+        u8 tidaw_flags;
+        unsigned int seg_len, part_len, len_to_track_end;
+        unsigned char new_track;
+        sector_t recid, trkid;
+        unsigned int offs;
+        unsigned int count, count_to_trk_end;
 
         basedev = block->base;
-        private = (struct dasd_eckd_private *) basedev->private;
         if (rq_data_dir(req) == READ) {
                 cmd = DASD_ECKD_CCW_READ_TRACK_DATA;
                 itcw_op = ITCW_OP_READ;
@@ -2352,12 +2600,16 @@ static struct dasd_ccw_req *dasd_eckd_build_cp_tpm_track(
         /* trackbased I/O needs address all memory via TIDAWs,
          * not just for 64 bit addresses. This allows us to map
          * each segment directly to one tidaw.
+         * In the case of write requests, additional tidaws may
+         * be needed when a segment crosses a track boundary.
          */
         trkcount = last_trk - first_trk + 1;
         ctidaw = 0;
         rq_for_each_segment(bv, req, iter) {
                 ++ctidaw;
         }
+        if (rq_data_dir(req) == WRITE)
+                ctidaw += (last_trk - first_trk);
 
         /* Allocate the ccw request. */
         itcw_size = itcw_calc_size(0, ctidaw, 0);
@@ -2365,15 +2617,6 @@ static struct dasd_ccw_req *dasd_eckd_build_cp_tpm_track(
         if (IS_ERR(cqr))
                 return cqr;
 
-        cqr->cpmode = 1;
-        cqr->startdev = startdev;
-        cqr->memdev = startdev;
-        cqr->block = block;
-        cqr->expires = 100*HZ;
-        cqr->buildclk = get_clock();
-        cqr->status = DASD_CQR_FILLED;
-        cqr->retries = 10;
-
         /* transfer length factor: how many bytes to read from the last track */
         if (first_trk == last_trk)
                 tlf = last_offs - first_offs + 1;
@@ -2382,8 +2625,11 @@ static struct dasd_ccw_req *dasd_eckd_build_cp_tpm_track(
         tlf *= blksize;
 
         itcw = itcw_init(cqr->data, itcw_size, itcw_op, 0, ctidaw, 0);
+        if (IS_ERR(itcw)) {
+                dasd_sfree_request(cqr, startdev);
+                return ERR_PTR(-EINVAL);
+        }
         cqr->cpaddr = itcw_get_tcw(itcw);
-
         if (prepare_itcw(itcw, first_trk, last_trk,
                          cmd, basedev, startdev,
                          first_offs + 1,
@@ -2396,31 +2642,70 @@ static struct dasd_ccw_req *dasd_eckd_build_cp_tpm_track(
                 dasd_sfree_request(cqr, startdev);
                 return ERR_PTR(-EAGAIN);
         }
-
+        len_to_track_end = 0;
         /*
          * A tidaw can address 4k of memory, but must not cross page boundaries
          * We can let the block layer handle this by setting
          * blk_queue_segment_boundary to page boundaries and
          * blk_max_segment_size to page size when setting up the request queue.
+         * For write requests, a TIDAW must not cross track boundaries, because
+         * we have to set the CBC flag on the last tidaw for each track.
          */
-        rq_for_each_segment(bv, req, iter) {
-                dst = page_address(bv->bv_page) + bv->bv_offset;
-                last_tidaw = itcw_add_tidaw(itcw, 0x00, dst, bv->bv_len);
-                if (IS_ERR(last_tidaw))
-                        return (struct dasd_ccw_req *)last_tidaw;
+        if (rq_data_dir(req) == WRITE) {
+                new_track = 1;
+                recid = first_rec;
+                rq_for_each_segment(bv, req, iter) {
+                        dst = page_address(bv->bv_page) + bv->bv_offset;
+                        seg_len = bv->bv_len;
+                        while (seg_len) {
+                                if (new_track) {
+                                        trkid = recid;
+                                        offs = sector_div(trkid, blk_per_trk);
+                                        count_to_trk_end = blk_per_trk - offs;
+                                        count = min((last_rec - recid + 1),
+                                                    (sector_t)count_to_trk_end);
+                                        len_to_track_end = count * blksize;
+                                        recid += count;
+                                        new_track = 0;
+                                }
+                                part_len = min(seg_len, len_to_track_end);
+                                seg_len -= part_len;
+                                len_to_track_end -= part_len;
+                                /* We need to end the tidaw at track end */
+                                if (!len_to_track_end) {
+                                        new_track = 1;
+                                        tidaw_flags = TIDAW_FLAGS_INSERT_CBC;
+                                } else
+                                        tidaw_flags = 0;
+                                last_tidaw = itcw_add_tidaw(itcw, tidaw_flags,
+                                                            dst, part_len);
+                                if (IS_ERR(last_tidaw))
+                                        return ERR_PTR(-EINVAL);
+                                dst += part_len;
+                        }
+                }
+        } else {
+                rq_for_each_segment(bv, req, iter) {
+                        dst = page_address(bv->bv_page) + bv->bv_offset;
+                        last_tidaw = itcw_add_tidaw(itcw, 0x00,
+                                                    dst, bv->bv_len);
+                        if (IS_ERR(last_tidaw))
+                                return ERR_PTR(-EINVAL);
+                }
         }
-
-        last_tidaw->flags |= 0x80;
+        last_tidaw->flags |= TIDAW_FLAGS_LAST;
+        last_tidaw->flags &= ~TIDAW_FLAGS_INSERT_CBC;
         itcw_finalize(itcw);
 
         if (blk_noretry_request(req) ||
             block->base->features & DASD_FEATURE_FAILFAST)
                 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
+        cqr->cpmode = 1;
         cqr->startdev = startdev;
         cqr->memdev = startdev;
         cqr->block = block;
         cqr->expires = startdev->default_expires * HZ;  /* default 5 minutes */
-        cqr->lpm = private->path_data.ppm;
+        cqr->lpm = startdev->path_data.ppm;
         cqr->retries = 256;
         cqr->buildclk = get_clock();
         cqr->status = DASD_CQR_FILLED;
@@ -2431,11 +2716,9 @@ static struct dasd_ccw_req *dasd_eckd_build_cp(struct dasd_device *startdev,
                                                struct dasd_block *block,
                                                struct request *req)
 {
-        int tpm, cmdrtd, cmdwtd;
+        int cmdrtd, cmdwtd;
         int use_prefix;
-#if defined(CONFIG_64BIT)
-        int fcx_in_css, fcx_in_gneq, fcx_in_features;
-#endif
+        int fcx_multitrack;
         struct dasd_eckd_private *private;
         struct dasd_device *basedev;
         sector_t first_rec, last_rec;
@@ -2443,6 +2726,7 @@ static struct dasd_ccw_req *dasd_eckd_build_cp(struct dasd_device *startdev,
         unsigned int first_offs, last_offs;
         unsigned int blk_per_trk, blksize;
         int cdlspecial;
+        unsigned int data_size;
         struct dasd_ccw_req *cqr;
 
         basedev = block->base;
@@ -2461,15 +2745,11 @@ static struct dasd_ccw_req *dasd_eckd_build_cp(struct dasd_device *startdev,
         last_offs = sector_div(last_trk, blk_per_trk);
         cdlspecial = (private->uses_cdl && first_rec < 2*blk_per_trk);
 
-        /* is transport mode supported? */
-#if defined(CONFIG_64BIT)
-        fcx_in_css = css_general_characteristics.fcx;
-        fcx_in_gneq = private->gneq->reserved2[7] & 0x04;
-        fcx_in_features = private->features.feature[40] & 0x80;
-        tpm = fcx_in_css && fcx_in_gneq && fcx_in_features;
-#else
-        tpm = 0;
-#endif
+        fcx_multitrack = private->features.feature[40] & 0x20;
+        data_size = blk_rq_bytes(req);
+        /* tpm write request add CBC data on each track boundary */
+        if (rq_data_dir(req) == WRITE)
+                data_size += (last_trk - first_trk) * 4;
 
         /* is read track data and write track data in command mode supported? */
         cmdrtd = private->features.feature[9] & 0x20;
@@ -2479,13 +2759,15 @@ static struct dasd_ccw_req *dasd_eckd_build_cp(struct dasd_device *startdev,
         cqr = NULL;
         if (cdlspecial || dasd_page_cache) {
                 /* do nothing, just fall through to the cmd mode single case */
-        } else if (!dasd_nofcx && tpm && (first_trk == last_trk)) {
+        } else if ((data_size <= private->fcx_max_data)
+                   && (fcx_multitrack || (first_trk == last_trk))) {
                 cqr = dasd_eckd_build_cp_tpm_track(startdev, block, req,
                                                     first_rec, last_rec,
                                                     first_trk, last_trk,
                                                     first_offs, last_offs,
                                                     blk_per_trk, blksize);
-                if (IS_ERR(cqr) && PTR_ERR(cqr) != -EAGAIN)
+                if (IS_ERR(cqr) && (PTR_ERR(cqr) != -EAGAIN) &&
+                    (PTR_ERR(cqr) != -ENOMEM))
                         cqr = NULL;
         } else if (use_prefix &&
                    (((rq_data_dir(req) == READ) && cmdrtd) ||
@@ -2495,7 +2777,8 @@ static struct dasd_ccw_req *dasd_eckd_build_cp(struct dasd_device *startdev,
                                                    first_trk, last_trk,
                                                    first_offs, last_offs,
                                                    blk_per_trk, blksize);
-                if (IS_ERR(cqr) && PTR_ERR(cqr) != -EAGAIN)
+                if (IS_ERR(cqr) && (PTR_ERR(cqr) != -EAGAIN) &&
+                    (PTR_ERR(cqr) != -ENOMEM))
                         cqr = NULL;
         }
         if (!cqr)
@@ -2507,6 +2790,133 @@ static struct dasd_ccw_req *dasd_eckd_build_cp(struct dasd_device *startdev,
         return cqr;
 }
 
+static struct dasd_ccw_req *dasd_raw_build_cp(struct dasd_device *startdev,
+                                               struct dasd_block *block,
+                                               struct request *req)
+{
+        unsigned long *idaws;
+        struct dasd_device *basedev;
+        struct dasd_ccw_req *cqr;
+        struct ccw1 *ccw;
+        struct req_iterator iter;
+        struct bio_vec *bv;
+        char *dst;
+        unsigned char cmd;
+        unsigned int trkcount;
+        unsigned int seg_len, len_to_track_end;
+        unsigned int first_offs;
+        unsigned int cidaw, cplength, datasize;
+        sector_t first_trk, last_trk;
+        unsigned int pfx_datasize;
+
+        /*
+         * raw track access needs to be mutiple of 64k and on 64k boundary
+         */
+        if ((blk_rq_pos(req) % DASD_RAW_SECTORS_PER_TRACK) != 0) {
+                cqr = ERR_PTR(-EINVAL);
+                goto out;
+        }
+        if (((blk_rq_pos(req) + blk_rq_sectors(req)) %
+             DASD_RAW_SECTORS_PER_TRACK) != 0) {
+                cqr = ERR_PTR(-EINVAL);
+                goto out;
+        }
+
+        first_trk = blk_rq_pos(req) / DASD_RAW_SECTORS_PER_TRACK;
+        last_trk = (blk_rq_pos(req) + blk_rq_sectors(req) - 1) /
+                DASD_RAW_SECTORS_PER_TRACK;
+        trkcount = last_trk - first_trk + 1;
+        first_offs = 0;
+        basedev = block->base;
+
+        if (rq_data_dir(req) == READ)
+                cmd = DASD_ECKD_CCW_READ_TRACK;
+        else if (rq_data_dir(req) == WRITE)
+                cmd = DASD_ECKD_CCW_WRITE_FULL_TRACK;
+        else {
+                cqr = ERR_PTR(-EINVAL);
+                goto out;
+        }
+
+        /*
+         * Raw track based I/O needs IDAWs for each page,
+         * and not just for 64 bit addresses.
+         */
+        cidaw = trkcount * DASD_RAW_BLOCK_PER_TRACK;
+
+        /* 1x prefix + one read/write ccw per track */
+        cplength = 1 + trkcount;
+
+        /*
+         * struct PFX_eckd_data has up to 2 byte as extended parameter
+         * this is needed for write full track and has to be mentioned
+         * separately
+         * add 8 instead of 2 to keep 8 byte boundary
+         */
+        pfx_datasize = sizeof(struct PFX_eckd_data) + 8;
+
+        datasize = pfx_datasize + cidaw * sizeof(unsigned long long);
+
+        /* Allocate the ccw request. */
+        cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength,
+                                   datasize, startdev);
+        if (IS_ERR(cqr))
+                goto out;
+        ccw = cqr->cpaddr;
+
+        if (prefix_LRE(ccw++, cqr->data, first_trk, last_trk, cmd,
+                       basedev, startdev, 1 /* format */, first_offs + 1,
+                       trkcount, 0, 0) == -EAGAIN) {
+                /* Clock not in sync and XRC is enabled.
+                 * Try again later.
+                 */
+                dasd_sfree_request(cqr, startdev);
+                cqr = ERR_PTR(-EAGAIN);
+                goto out;
+        }
+
+        idaws = (unsigned long *)(cqr->data + pfx_datasize);
+
+        len_to_track_end = 0;
+
+        rq_for_each_segment(bv, req, iter) {
+                dst = page_address(bv->bv_page) + bv->bv_offset;
+                seg_len = bv->bv_len;
+                if (!len_to_track_end) {
+                        ccw[-1].flags |= CCW_FLAG_CC;
+                        ccw->cmd_code = cmd;
+                        /* maximum 3390 track size */
+                        ccw->count = 57326;
+                        /* 64k map to one track */
+                        len_to_track_end = 65536;
+                        ccw->cda = (__u32)(addr_t)idaws;
+                        ccw->flags |= CCW_FLAG_IDA;
+                        ccw->flags |= CCW_FLAG_SLI;
+                        ccw++;
+                }
+                len_to_track_end -= seg_len;
+                idaws = idal_create_words(idaws, dst, seg_len);
+        }
+
+        if (blk_noretry_request(req) ||
+            block->base->features & DASD_FEATURE_FAILFAST)
+                set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
+        cqr->startdev = startdev;
+        cqr->memdev = startdev;
+        cqr->block = block;
+        cqr->expires = startdev->default_expires * HZ;
+        cqr->lpm = startdev->path_data.ppm;
+        cqr->retries = 256;
+        cqr->buildclk = get_clock();
+        cqr->status = DASD_CQR_FILLED;
+
+        if (IS_ERR(cqr) && PTR_ERR(cqr) != -EAGAIN)
+                cqr = NULL;
+out:
+        return cqr;
+}
+
+
 static int
 dasd_eckd_free_cp(struct dasd_ccw_req *cqr, struct request *req)
 {
@@ -2611,7 +3021,10 @@ static struct dasd_ccw_req *dasd_eckd_build_alias_cp(struct dasd_device *base,
 
         spin_lock_irqsave(get_ccwdev_lock(startdev->cdev), flags);
         private->count++;
-        cqr = dasd_eckd_build_cp(startdev, block, req);
+        if ((base->features & DASD_FEATURE_USERAW))
+                cqr = dasd_raw_build_cp(startdev, block, req);
+        else
+                cqr = dasd_eckd_build_cp(startdev, block, req);
         if (IS_ERR(cqr))
                 private->count--;
         spin_unlock_irqrestore(get_ccwdev_lock(startdev->cdev), flags);
@@ -2699,6 +3112,8 @@ dasd_eckd_release(struct dasd_device *device)
         cqr->status = DASD_CQR_FILLED;
 
         rc = dasd_sleep_on_immediatly(cqr);
+        if (!rc)
+                clear_bit(DASD_FLAG_IS_RESERVED, &device->flags);
 
         if (useglobal)
                 mutex_unlock(&dasd_reserve_mutex);
@@ -2752,6 +3167,8 @@ dasd_eckd_reserve(struct dasd_device *device)
         cqr->status = DASD_CQR_FILLED;
 
         rc = dasd_sleep_on_immediatly(cqr);
+        if (!rc)
+                set_bit(DASD_FLAG_IS_RESERVED, &device->flags);
 
         if (useglobal)
                 mutex_unlock(&dasd_reserve_mutex);
@@ -2804,6 +3221,76 @@ dasd_eckd_steal_lock(struct dasd_device *device)
         cqr->status = DASD_CQR_FILLED;
 
         rc = dasd_sleep_on_immediatly(cqr);
+        if (!rc)
+                set_bit(DASD_FLAG_IS_RESERVED, &device->flags);
+
+        if (useglobal)
+                mutex_unlock(&dasd_reserve_mutex);
+        else
+                dasd_sfree_request(cqr, cqr->memdev);
+        return rc;
+}
+
+/*
+ * SNID - Sense Path Group ID
+ * This ioctl may be used in situations where I/O is stalled due to
+ * a reserve, so if the normal dasd_smalloc_request fails, we use the
+ * preallocated dasd_reserve_req.
+ */
+static int dasd_eckd_snid(struct dasd_device *device,
+                          void __user *argp)
+{
+        struct dasd_ccw_req *cqr;
+        int rc;
+        struct ccw1 *ccw;
+        int useglobal;
+        struct dasd_snid_ioctl_data usrparm;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+
+        if (copy_from_user(&usrparm, argp, sizeof(usrparm)))
+                return -EFAULT;
+
+        useglobal = 0;
+        cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1,
+                                   sizeof(struct dasd_snid_data), device);
+        if (IS_ERR(cqr)) {
+                mutex_lock(&dasd_reserve_mutex);
+                useglobal = 1;
+                cqr = &dasd_reserve_req->cqr;
+                memset(cqr, 0, sizeof(*cqr));
+                memset(&dasd_reserve_req->ccw, 0,
+                       sizeof(dasd_reserve_req->ccw));
+                cqr->cpaddr = &dasd_reserve_req->ccw;
+                cqr->data = &dasd_reserve_req->data;
+                cqr->magic = DASD_ECKD_MAGIC;
+        }
+        ccw = cqr->cpaddr;
+        ccw->cmd_code = DASD_ECKD_CCW_SNID;
+        ccw->flags |= CCW_FLAG_SLI;
+        ccw->count = 12;
+        ccw->cda = (__u32)(addr_t) cqr->data;
+        cqr->startdev = device;
+        cqr->memdev = device;
+        clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
+        set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
+        set_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags);
+        cqr->retries = 5;
+        cqr->expires = 10 * HZ;
+        cqr->buildclk = get_clock();
+        cqr->status = DASD_CQR_FILLED;
+        cqr->lpm = usrparm.path_mask;
+
+        rc = dasd_sleep_on_immediatly(cqr);
+        /* verify that I/O processing didn't modify the path mask */
+        if (!rc && usrparm.path_mask && (cqr->lpm != usrparm.path_mask))
+                rc = -EIO;
+        if (!rc) {
+                usrparm.data = *((struct dasd_snid_data *)cqr->data);
+                if (copy_to_user(argp, &usrparm, sizeof(usrparm)))
+                        rc = -EFAULT;
+        }
 
         if (useglobal)
                 mutex_unlock(&dasd_reserve_mutex);
@@ -3047,6 +3534,8 @@ dasd_eckd_ioctl(struct dasd_block *block, unsigned int cmd, void __user *argp)
                 return dasd_eckd_reserve(device);
         case BIODASDSLCK:
                 return dasd_eckd_steal_lock(device);
+        case BIODASDSNID:
+                return dasd_eckd_snid(device, argp);
         case BIODASDSYMMIO:
                 return dasd_symm_io(device, argp);
         default:
@@ -3093,19 +3582,19 @@ dasd_eckd_dump_sense_dbf(struct dasd_device *device, struct irb *irb,
                          char *reason)
 {
         u64 *sense;
+        u64 *stat;
 
         sense = (u64 *) dasd_get_sense(irb);
+        stat = (u64 *) &irb->scsw;
         if (sense) {
-                DBF_DEV_EVENT(DBF_EMERG, device,
-                              "%s: %s %02x%02x%02x %016llx %016llx %016llx "
-                              "%016llx", reason,
-                              scsw_is_tm(&irb->scsw) ? "t" : "c",
-                              scsw_cc(&irb->scsw), scsw_cstat(&irb->scsw),
-                              scsw_dstat(&irb->scsw), sense[0], sense[1],
-                              sense[2], sense[3]);
+                DBF_DEV_EVENT(DBF_EMERG, device, "%s: %016llx %08x : "
+                              "%016llx %016llx %016llx %016llx",
+                              reason, *stat, *((u32 *) (stat + 1)),
+                              sense[0], sense[1], sense[2], sense[3]);
         } else {
-                DBF_DEV_EVENT(DBF_EMERG, device, "%s",
-                              "SORRY - NO VALID SENSE AVAILABLE\n");
+                DBF_DEV_EVENT(DBF_EMERG, device, "%s: %016llx %08x : %s",
+                              reason, *stat, *((u32 *) (stat + 1)),
+                              "NO VALID SENSE");
         }
 }
 
@@ -3131,9 +3620,12 @@ static void dasd_eckd_dump_sense_ccw(struct dasd_device *device,
                       " I/O status report for device %s:\n",
                       dev_name(&device->cdev->dev));
         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 ? req->intrc : 0);
+                       " in req: %p CC:%02X FC:%02X AC:%02X SC:%02X DS:%02X "
+                       "CS:%02X RC:%d\n",
+                       req, scsw_cc(&irb->scsw), scsw_fctl(&irb->scsw),
+                       scsw_actl(&irb->scsw), scsw_stctl(&irb->scsw),
+                       scsw_dstat(&irb->scsw), scsw_cstat(&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),
@@ -3218,10 +3710,8 @@ static void dasd_eckd_dump_sense_tcw(struct dasd_device *device,
 {
         char *page;
         int len, sl, sct, residual;
-
         struct tsb *tsb;
-        u8 *sense;
-
+        u8 *sense, *rcq;
 
         page = (char *) get_zeroed_page(GFP_ATOMIC);
         if (page == NULL) {
@@ -3234,11 +3724,13 @@ static void dasd_eckd_dump_sense_tcw(struct dasd_device *device,
                       " I/O status report for device %s:\n",
                       dev_name(&device->cdev->dev));
         len += sprintf(page + len, KERN_ERR PRINTK_HEADER
-                       " in req: %p CS: 0x%02X DS: 0x%02X CC: 0x%02X RC: %d "
-                       "fcxs: 0x%02X schxs: 0x%02X\n", req,
-                       scsw_cstat(&irb->scsw), scsw_dstat(&irb->scsw),
-                       scsw_cc(&irb->scsw), req->intrc,
-                       irb->scsw.tm.fcxs, irb->scsw.tm.schxs);
+                       " in req: %p CC:%02X FC:%02X AC:%02X SC:%02X DS:%02X "
+                       "CS:%02X fcxs:%02X schxs:%02X RC:%d\n",
+                       req, scsw_cc(&irb->scsw), scsw_fctl(&irb->scsw),
+                       scsw_actl(&irb->scsw), scsw_stctl(&irb->scsw),
+                       scsw_dstat(&irb->scsw), scsw_cstat(&irb->scsw),
+                       irb->scsw.tm.fcxs, irb->scsw.tm.schxs,
+                       req ? req->intrc : 0);
         len += sprintf(page + len, KERN_ERR PRINTK_HEADER
                        " device %s: Failing TCW: %p\n",
                        dev_name(&device->cdev->dev),
@@ -3246,7 +3738,7 @@ static void dasd_eckd_dump_sense_tcw(struct dasd_device *device,
 
         tsb = NULL;
         sense = NULL;
-        if (irb->scsw.tm.tcw && (irb->scsw.tm.fcxs == 0x01))
+        if (irb->scsw.tm.tcw && (irb->scsw.tm.fcxs & 0x01))
                 tsb = tcw_get_tsb(
                         (struct tcw *)(unsigned long)irb->scsw.tm.tcw);
 
@@ -3285,12 +3777,15 @@ static void dasd_eckd_dump_sense_tcw(struct dasd_device *device,
                 case 2: /* ts_ddpc */
                         len += sprintf(page + len, KERN_ERR PRINTK_HEADER
                                " tsb->tsa.ddpc.rc %d\n", tsb->tsa.ddpc.rc);
-                        len += sprintf(page + len, KERN_ERR PRINTK_HEADER
-                               " tsb->tsa.ddpc.rcq:  ");
-                        for (sl = 0; sl < 16; sl++) {
+                        for (sl = 0; sl < 2; sl++) {
+                                len += sprintf(page + len,
+                                               KERN_ERR PRINTK_HEADER
+                                               " tsb->tsa.ddpc.rcq %2d-%2d: ",
+                                               (8 * sl), ((8 * sl) + 7));
+                                rcq = tsb->tsa.ddpc.rcq;
                                 for (sct = 0; sct < 8; sct++) {
                                         len += sprintf(page + len, " %02x",
-                                                       tsb->tsa.ddpc.rcq[sl]);
+                                                       rcq[8 * sl + sct]);
                                 }
                                 len += sprintf(page + len, "\n");
                         }
@@ -3344,7 +3839,7 @@ static void dasd_eckd_dump_sense_tcw(struct dasd_device *device,
 static void dasd_eckd_dump_sense(struct dasd_device *device,
                                  struct dasd_ccw_req *req, struct irb *irb)
 {
-        if (req && scsw_is_tm(&req->irb.scsw))
+        if (scsw_is_tm(&irb->scsw))
                 dasd_eckd_dump_sense_tcw(device, req, irb);
         else
                 dasd_eckd_dump_sense_ccw(device, req, irb);
@@ -3479,14 +3974,17 @@ out_err:
 }
 
 static struct ccw_driver dasd_eckd_driver = {
-        .name        = "dasd-eckd",
-        .owner       = THIS_MODULE,
+        .driver = {
+                .name   = "dasd-eckd",
+                .owner  = THIS_MODULE,
+        },
         .ids         = dasd_eckd_ids,
         .probe       = dasd_eckd_probe,
         .remove      = dasd_generic_remove,
         .set_offline = dasd_generic_set_offline,
         .set_online  = dasd_eckd_set_online,
         .notify      = dasd_generic_notify,
+        .path_event  = dasd_generic_path_event,
         .freeze      = dasd_generic_pm_freeze,
         .thaw        = dasd_generic_restore_device,
         .restore     = dasd_generic_restore_device,
@@ -3510,10 +4008,11 @@ static struct dasd_discipline dasd_eckd_discipline = {
         .owner = THIS_MODULE,
         .name = "ECKD",
         .ebcname = "ECKD",
-        .max_blocks = 240,
+        .max_blocks = 190,
         .check_device = dasd_eckd_check_characteristics,
         .uncheck_device = dasd_eckd_uncheck_device,
         .do_analysis = dasd_eckd_do_analysis,
+        .verify_path = dasd_eckd_verify_path,
         .ready_to_online = dasd_eckd_ready_to_online,
         .online_to_ready = dasd_eckd_online_to_ready,
         .fill_geometry = dasd_eckd_fill_geometry,
@@ -3523,7 +4022,7 @@ static struct dasd_discipline dasd_eckd_discipline = {
         .format_device = dasd_eckd_format_device,
         .erp_action = dasd_eckd_erp_action,
         .erp_postaction = dasd_eckd_erp_postaction,
-        .handle_unsolicited_interrupt = dasd_eckd_handle_unsolicited_interrupt,
+        .check_for_device_change = dasd_eckd_check_for_device_change,
         .build_cp = dasd_eckd_build_alias_cp,
         .free_cp = dasd_eckd_free_alias_cp,
         .dump_sense = dasd_eckd_dump_sense,
@@ -3546,11 +4045,19 @@ dasd_eckd_init(void)
                                    GFP_KERNEL | GFP_DMA);
         if (!dasd_reserve_req)
                 return -ENOMEM;
+        path_verification_worker = kmalloc(sizeof(*path_verification_worker),
+                                   GFP_KERNEL | GFP_DMA);
+        if (!path_verification_worker) {
+                kfree(dasd_reserve_req);
+                return -ENOMEM;
+        }
         ret = ccw_driver_register(&dasd_eckd_driver);
         if (!ret)
                 wait_for_device_probe();
-        else
+        else {
+                kfree(path_verification_worker);
                 kfree(dasd_reserve_req);
+        }
         return ret;
 }
 
@@ -3558,6 +4065,7 @@ static void __exit
 dasd_eckd_cleanup(void)
 {
         ccw_driver_unregister(&dasd_eckd_driver);
+        kfree(path_verification_worker);
         kfree(dasd_reserve_req);
 }
 
diff --git a/drivers/s390/block/dasd_eckd.h b/drivers/s390/block/dasd_eckd.h
index 0eb49655a6cd..4a688a873a77 100644
--- a/drivers/s390/block/dasd_eckd.h
+++ b/drivers/s390/block/dasd_eckd.h
@@ -27,6 +27,7 @@
 #define DASD_ECKD_CCW_WRITE_CKD          0x1d
 #define DASD_ECKD_CCW_READ_CKD           0x1e
 #define DASD_ECKD_CCW_PSF                0x27
+#define DASD_ECKD_CCW_SNID               0x34
 #define DASD_ECKD_CCW_RSSD               0x3e
 #define DASD_ECKD_CCW_LOCATE_RECORD      0x47
 #define DASD_ECKD_CCW_SNSS               0x54
@@ -36,14 +37,17 @@
 #define DASD_ECKD_CCW_WRITE_KD_MT        0x8d
 #define DASD_ECKD_CCW_READ_KD_MT         0x8e
 #define DASD_ECKD_CCW_RELEASE            0x94
+#define DASD_ECKD_CCW_WRITE_FULL_TRACK   0x95
 #define DASD_ECKD_CCW_READ_CKD_MT        0x9e
 #define DASD_ECKD_CCW_WRITE_CKD_MT       0x9d
 #define DASD_ECKD_CCW_WRITE_TRACK_DATA   0xA5
 #define DASD_ECKD_CCW_READ_TRACK_DATA    0xA6
 #define DASD_ECKD_CCW_RESERVE            0xB4
+#define DASD_ECKD_CCW_READ_TRACK         0xDE
 #define DASD_ECKD_CCW_PFX                0xE7
 #define DASD_ECKD_CCW_PFX_READ           0xEA
 #define DASD_ECKD_CCW_RSCK               0xF9
+#define DASD_ECKD_CCW_RCD                0xFA
 
 /*
  * Perform Subsystem Function / Sub-Orders
@@ -56,6 +60,11 @@
  */
 #define LV_COMPAT_CYL 0xFFFE
 
+
+#define FCX_MAX_DATA_FACTOR 65536
+#define DASD_ECKD_RCD_DATA_SIZE 256
+
+
 /*****************************************************************************
  * SECTION: Type Definitions
  ****************************************************************************/
@@ -330,12 +339,6 @@ struct dasd_gneq {
         __u8 reserved2[22];
 } __attribute__ ((packed));
 
-struct dasd_eckd_path {
-        __u8 opm;
-        __u8 ppm;
-        __u8 npm;
-};
-
 struct dasd_rssd_features {
         char feature[256];
 } __attribute__((packed));
@@ -441,7 +444,6 @@ struct dasd_eckd_private {
         struct vd_sneq *vdsneq;
         struct dasd_gneq *gneq;
 
-        struct dasd_eckd_path path_data;
         struct eckd_count count_area[5];
         int init_cqr_status;
         int uses_cdl;
@@ -454,6 +456,8 @@ struct dasd_eckd_private {
         struct alias_pav_group *pavgroup;
         struct alias_lcu *lcu;
         int count;
+
+        u32 fcx_max_data;
 };
 
 
diff --git a/drivers/s390/block/dasd_eer.c b/drivers/s390/block/dasd_eer.c
index 7158f9528ecc..77f778b7b070 100644
--- a/drivers/s390/block/dasd_eer.c
+++ b/drivers/s390/block/dasd_eer.c
@@ -17,7 +17,6 @@
 #include <linux/device.h>
 #include <linux/poll.h>
 #include <linux/mutex.h>
-#include <linux/smp_lock.h>
 #include <linux/err.h>
 #include <linux/slab.h>
 
@@ -474,6 +473,7 @@ int dasd_eer_enable(struct dasd_device *device)
         cqr->retries = 255;
         cqr->expires = 10 * HZ;
         clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
+        set_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags);
 
         ccw = cqr->cpaddr;
         ccw->cmd_code = DASD_ECKD_CCW_SNSS;
@@ -670,6 +670,7 @@ static const struct file_operations dasd_eer_fops = {
         .read           = &dasd_eer_read,
         .poll           = &dasd_eer_poll,
         .owner          = THIS_MODULE,
+        .llseek         = noop_llseek,
 };
 
 static struct miscdevice *dasd_eer_dev = NULL;
diff --git a/drivers/s390/block/dasd_erp.c b/drivers/s390/block/dasd_erp.c
index 7656384a811d..0eafe2e421e7 100644
--- a/drivers/s390/block/dasd_erp.c
+++ b/drivers/s390/block/dasd_erp.c
@@ -96,7 +96,8 @@ dasd_default_erp_action(struct dasd_ccw_req *cqr)
                 DBF_DEV_EVENT(DBF_DEBUG, device,
                              "default ERP called (%i retries left)",
                              cqr->retries);
-                cqr->lpm    = LPM_ANYPATH;
+                if (!test_bit(DASD_CQR_VERIFY_PATH, &cqr->flags))
+                        cqr->lpm = device->path_data.opm;
                 cqr->status = DASD_CQR_FILLED;
         } else {
                 pr_err("%s: default ERP has run out of retries and failed\n",
diff --git a/drivers/s390/block/dasd_fba.c b/drivers/s390/block/dasd_fba.c
index bec5486e0e6d..4b71b1164868 100644
--- a/drivers/s390/block/dasd_fba.c
+++ b/drivers/s390/block/dasd_fba.c
@@ -65,14 +65,17 @@ dasd_fba_set_online(struct ccw_device *cdev)
 }
 
 static struct ccw_driver dasd_fba_driver = {
-        .name        = "dasd-fba",
-        .owner       = THIS_MODULE,
+        .driver = {
+                .name   = "dasd-fba",
+                .owner  = THIS_MODULE,
+        },
         .ids         = dasd_fba_ids,
         .probe       = dasd_fba_probe,
         .remove      = dasd_generic_remove,
         .set_offline = dasd_generic_set_offline,
         .set_online  = dasd_fba_set_online,
         .notify      = dasd_generic_notify,
+        .path_event  = dasd_generic_path_event,
         .freeze      = dasd_generic_pm_freeze,
         .thaw        = dasd_generic_restore_device,
         .restore     = dasd_generic_restore_device,
@@ -164,6 +167,7 @@ dasd_fba_check_characteristics(struct dasd_device *device)
         }
 
         device->default_expires = DASD_EXPIRES;
+        device->path_data.opm = LPM_ANYPATH;
 
         readonly = dasd_device_is_ro(device);
         if (readonly)
@@ -231,24 +235,16 @@ dasd_fba_erp_postaction(struct dasd_ccw_req * cqr)
         return NULL;
 }
 
-static void dasd_fba_handle_unsolicited_interrupt(struct dasd_device *device,
-                                                   struct irb *irb)
+static void dasd_fba_check_for_device_change(struct dasd_device *device,
+                                             struct dasd_ccw_req *cqr,
+                                             struct irb *irb)
 {
         char mask;
 
         /* first of all check for state change pending interrupt */
         mask = DEV_STAT_ATTENTION | DEV_STAT_DEV_END | DEV_STAT_UNIT_EXCEP;
-        if ((irb->scsw.cmd.dstat & mask) == mask) {
+        if ((irb->scsw.cmd.dstat & mask) == mask)
                 dasd_generic_handle_state_change(device);
-                return;
-        }
-
-        /* check for unsolicited interrupts */
-        DBF_DEV_EVENT(DBF_WARNING, device, "%s",
-                    "unsolicited interrupt received");
-        device->discipline->dump_sense_dbf(device, irb, "unsolicited");
-        dasd_schedule_device_bh(device);
-        return;
 };
 
 static struct dasd_ccw_req *dasd_fba_build_cp(struct dasd_device * memdev,
@@ -596,13 +592,14 @@ static struct dasd_discipline dasd_fba_discipline = {
         .max_blocks = 96,
         .check_device = dasd_fba_check_characteristics,
         .do_analysis = dasd_fba_do_analysis,
+        .verify_path = dasd_generic_verify_path,
         .fill_geometry = dasd_fba_fill_geometry,
         .start_IO = dasd_start_IO,
         .term_IO = dasd_term_IO,
         .handle_terminated_request = dasd_fba_handle_terminated_request,
         .erp_action = dasd_fba_erp_action,
         .erp_postaction = dasd_fba_erp_postaction,
-        .handle_unsolicited_interrupt = dasd_fba_handle_unsolicited_interrupt,
+        .check_for_device_change = dasd_fba_check_for_device_change,
         .build_cp = dasd_fba_build_cp,
         .free_cp = dasd_fba_free_cp,
         .dump_sense = dasd_fba_dump_sense,
diff --git a/drivers/s390/block/dasd_genhd.c b/drivers/s390/block/dasd_genhd.c
index 30a1ca3d08b7..19a1ff03d65e 100644
--- a/drivers/s390/block/dasd_genhd.c
+++ b/drivers/s390/block/dasd_genhd.c
@@ -73,7 +73,7 @@ int dasd_gendisk_alloc(struct dasd_block *block)
         if (base->features & DASD_FEATURE_READONLY ||
             test_bit(DASD_FLAG_DEVICE_RO, &base->flags))
                 set_disk_ro(gdp, 1);
-        gdp->private_data = block;
+        dasd_add_link_to_gendisk(gdp, base);
         gdp->queue = block->request_queue;
         block->gdp = gdp;
         set_capacity(block->gdp, 0);
@@ -103,7 +103,7 @@ int dasd_scan_partitions(struct dasd_block *block)
         struct block_device *bdev;
 
         bdev = bdget_disk(block->gdp, 0);
-        if (!bdev || blkdev_get(bdev, FMODE_READ) < 0)
+        if (!bdev || blkdev_get(bdev, FMODE_READ, NULL) < 0)
                 return -ENODEV;
         /*
          * See fs/partition/check.c:register_disk,rescan_partitions
diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
index 500678d7116c..d1e4f2c1264c 100644
--- a/drivers/s390/block/dasd_int.h
+++ b/drivers/s390/block/dasd_int.h
@@ -231,6 +231,11 @@ struct dasd_ccw_req {
 /* per dasd_ccw_req flags */
 #define DASD_CQR_FLAGS_USE_ERP   0      /* use ERP for this request */
 #define DASD_CQR_FLAGS_FAILFAST  1      /* FAILFAST */
+#define DASD_CQR_VERIFY_PATH     2      /* path verification request */
+#define DASD_CQR_ALLOW_SLOCK     3      /* Try this request even when lock was
+                                         * stolen. Should not be combined with
+                                         * DASD_CQR_FLAGS_USE_ERP
+                                         */
 
 /* Signature for error recovery functions. */
 typedef struct dasd_ccw_req *(*dasd_erp_fn_t) (struct dasd_ccw_req *);
@@ -287,6 +292,14 @@ struct dasd_discipline {
         int (*do_analysis) (struct dasd_block *);
 
         /*
+         * This function is called, when new paths become available.
+         * Disciplins may use this callback to do necessary setup work,
+         * e.g. verify that new path is compatible with the current
+         * configuration.
+         */
+        int (*verify_path)(struct dasd_device *, __u8);
+
+        /*
          * Last things to do when a device is set online, and first things
          * when it is set offline.
          */
@@ -325,9 +338,9 @@ struct dasd_discipline {
         void (*dump_sense) (struct dasd_device *, struct dasd_ccw_req *,
                             struct irb *);
         void (*dump_sense_dbf) (struct dasd_device *, struct irb *, char *);
-
-        void (*handle_unsolicited_interrupt) (struct dasd_device *,
-                                              struct irb *);
+        void (*check_for_device_change) (struct dasd_device *,
+                                         struct dasd_ccw_req *,
+                                         struct irb *);
 
         /* i/o control functions. */
         int (*fill_geometry) (struct dasd_block *, struct hd_geometry *);
@@ -362,6 +375,13 @@ extern struct dasd_discipline *dasd_diag_discipline_pointer;
 #define DASD_EER_STATECHANGE 3
 #define DASD_EER_PPRCSUSPEND 4
 
+struct dasd_path {
+        __u8 opm;
+        __u8 tbvpm;
+        __u8 ppm;
+        __u8 npm;
+};
+
 struct dasd_device {
         /* Block device stuff. */
         struct dasd_block *block;
@@ -377,6 +397,7 @@ struct dasd_device {
         struct dasd_discipline *discipline;
         struct dasd_discipline *base_discipline;
         char *private;
+        struct dasd_path path_data;
 
         /* Device state and target state. */
         int state, target;
@@ -456,6 +477,9 @@ struct dasd_block {
                                          * confuse this with the user specified
                                          * read-only feature.
                                          */
+#define DASD_FLAG_IS_RESERVED   7       /* The device is reserved */
+#define DASD_FLAG_LOCK_STOLEN   8       /* The device lock was stolen */
+
 
 void dasd_put_device_wake(struct dasd_device *);
 
@@ -620,10 +644,15 @@ void dasd_generic_remove (struct ccw_device *cdev);
 int dasd_generic_set_online(struct ccw_device *, struct dasd_discipline *);
 int dasd_generic_set_offline (struct ccw_device *cdev);
 int dasd_generic_notify(struct ccw_device *, int);
+int dasd_generic_last_path_gone(struct dasd_device *);
+int dasd_generic_path_operational(struct dasd_device *);
+
 void dasd_generic_handle_state_change(struct dasd_device *);
 int dasd_generic_pm_freeze(struct ccw_device *);
 int dasd_generic_restore_device(struct ccw_device *);
 enum uc_todo dasd_generic_uc_handler(struct ccw_device *, struct irb *);
+void dasd_generic_path_event(struct ccw_device *, int *);
+int dasd_generic_verify_path(struct dasd_device *, __u8);
 
 int dasd_generic_read_dev_chars(struct dasd_device *, int, void *, int);
 char *dasd_get_sense(struct irb *);
@@ -657,6 +686,9 @@ struct dasd_device *dasd_device_from_cdev(struct ccw_device *);
 struct dasd_device *dasd_device_from_cdev_locked(struct ccw_device *);
 struct dasd_device *dasd_device_from_devindex(int);
 
+void dasd_add_link_to_gendisk(struct gendisk *, struct dasd_device *);
+struct dasd_device *dasd_device_from_gendisk(struct gendisk *);
+
 int dasd_parse(void);
 int dasd_busid_known(const char *);
 
diff --git a/drivers/s390/block/dasd_ioctl.c b/drivers/s390/block/dasd_ioctl.c
index 1557214944f7..72261e4c516d 100644
--- a/drivers/s390/block/dasd_ioctl.c
+++ b/drivers/s390/block/dasd_ioctl.c
@@ -16,7 +16,6 @@
 #include <linux/major.h>
 #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>
@@ -43,16 +42,22 @@ dasd_ioctl_api_version(void __user *argp)
 static int
 dasd_ioctl_enable(struct block_device *bdev)
 {
-        struct dasd_block *block = bdev->bd_disk->private_data;
+        struct dasd_device *base;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
 
-        dasd_enable_device(block->base);
+        base = dasd_device_from_gendisk(bdev->bd_disk);
+        if (!base)
+                return -ENODEV;
+
+        dasd_enable_device(base);
         /* Formatting the dasd device can change the capacity. */
         mutex_lock(&bdev->bd_mutex);
-        i_size_write(bdev->bd_inode, (loff_t)get_capacity(block->gdp) << 9);
+        i_size_write(bdev->bd_inode,
+                     (loff_t)get_capacity(base->block->gdp) << 9);
         mutex_unlock(&bdev->bd_mutex);
+        dasd_put_device(base);
         return 0;
 }
 
@@ -63,11 +68,14 @@ dasd_ioctl_enable(struct block_device *bdev)
 static int
 dasd_ioctl_disable(struct block_device *bdev)
 {
-        struct dasd_block *block = bdev->bd_disk->private_data;
+        struct dasd_device *base;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
 
+        base = dasd_device_from_gendisk(bdev->bd_disk);
+        if (!base)
+                return -ENODEV;
         /*
          * Man this is sick. We don't do a real disable but only downgrade
          * the device to DASD_STATE_BASIC. The reason is that dasdfmt uses
@@ -76,7 +84,7 @@ dasd_ioctl_disable(struct block_device *bdev)
          * using the BIODASDFMT ioctl. Therefore the correct state for the
          * device is DASD_STATE_BASIC that allows to do basic i/o.
          */
-        dasd_set_target_state(block->base, DASD_STATE_BASIC);
+        dasd_set_target_state(base, DASD_STATE_BASIC);
         /*
          * Set i_size to zero, since read, write, etc. check against this
          * value.
@@ -84,6 +92,7 @@ dasd_ioctl_disable(struct block_device *bdev)
         mutex_lock(&bdev->bd_mutex);
         i_size_write(bdev->bd_inode, 0);
         mutex_unlock(&bdev->bd_mutex);
+        dasd_put_device(base);
         return 0;
 }
 
@@ -192,26 +201,36 @@ static int dasd_format(struct dasd_block *block, struct format_data_t *fdata)
 static int
 dasd_ioctl_format(struct block_device *bdev, void __user *argp)
 {
-        struct dasd_block *block = bdev->bd_disk->private_data;
+        struct dasd_device *base;
         struct format_data_t fdata;
+        int rc;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
         if (!argp)
                 return -EINVAL;
-
-        if (block->base->features & DASD_FEATURE_READONLY ||
-            test_bit(DASD_FLAG_DEVICE_RO, &block->base->flags))
+        base = dasd_device_from_gendisk(bdev->bd_disk);
+        if (!base)
+                return -ENODEV;
+        if (base->features & DASD_FEATURE_READONLY ||
+            test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) {
+                dasd_put_device(base);
                 return -EROFS;
-        if (copy_from_user(&fdata, argp, sizeof(struct format_data_t)))
+        }
+        if (copy_from_user(&fdata, argp, sizeof(struct format_data_t))) {
+                dasd_put_device(base);
                 return -EFAULT;
+        }
         if (bdev != bdev->bd_contains) {
                 pr_warning("%s: The specified DASD is a partition and cannot "
                            "be formatted\n",
-                           dev_name(&block->base->cdev->dev));
+                           dev_name(&base->cdev->dev));
+                dasd_put_device(base);
                 return -EINVAL;
         }
-        return dasd_format(block, &fdata);
+        rc = dasd_format(base->block, &fdata);
+        dasd_put_device(base);
+        return rc;
 }
 
 #ifdef CONFIG_DASD_PROFILE
@@ -341,8 +360,8 @@ static int dasd_ioctl_information(struct dasd_block *block,
 static int
 dasd_ioctl_set_ro(struct block_device *bdev, void __user *argp)
 {
-        struct dasd_block *block =  bdev->bd_disk->private_data;
-        int intval;
+        struct dasd_device *base;
+        int intval, rc;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
@@ -351,10 +370,17 @@ 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))
+        base = dasd_device_from_gendisk(bdev->bd_disk);
+        if (!base)
+                return -ENODEV;
+        if (!intval && test_bit(DASD_FLAG_DEVICE_RO, &base->flags)) {
+                dasd_put_device(base);
                 return -EROFS;
+        }
         set_disk_ro(bdev->bd_disk, intval);
-        return dasd_set_feature(block->base->cdev, DASD_FEATURE_READONLY, intval);
+        rc = dasd_set_feature(base->cdev, DASD_FEATURE_READONLY, intval);
+        dasd_put_device(base);
+        return rc;
 }
 
 static int dasd_ioctl_readall_cmb(struct dasd_block *block, unsigned int cmd,
@@ -370,74 +396,81 @@ static int dasd_ioctl_readall_cmb(struct dasd_block *block, unsigned int cmd,
         return ret;
 }
 
-static int
-dasd_do_ioctl(struct block_device *bdev, fmode_t mode,
-              unsigned int cmd, unsigned long arg)
+int dasd_ioctl(struct block_device *bdev, fmode_t mode,
+               unsigned int cmd, unsigned long arg)
 {
-        struct dasd_block *block = bdev->bd_disk->private_data;
+        struct dasd_block *block;
+        struct dasd_device *base;
         void __user *argp;
+        int rc;
 
         if (is_compat_task())
                 argp = compat_ptr(arg);
         else
                 argp = (void __user *)arg;
 
-        if (!block)
-                return -ENODEV;
-
         if ((_IOC_DIR(cmd) != _IOC_NONE) && !arg) {
                 PRINT_DEBUG("empty data ptr");
                 return -EINVAL;
         }
 
+        base = dasd_device_from_gendisk(bdev->bd_disk);
+        if (!base)
+                return -ENODEV;
+        block = base->block;
+        rc = 0;
         switch (cmd) {
         case BIODASDDISABLE:
-                return dasd_ioctl_disable(bdev);
+                rc = dasd_ioctl_disable(bdev);
+                break;
         case BIODASDENABLE:
-                return dasd_ioctl_enable(bdev);
+                rc = dasd_ioctl_enable(bdev);
+                break;
         case BIODASDQUIESCE:
-                return dasd_ioctl_quiesce(block);
+                rc = dasd_ioctl_quiesce(block);
+                break;
         case BIODASDRESUME:
-                return dasd_ioctl_resume(block);
+                rc = dasd_ioctl_resume(block);
+                break;
         case BIODASDFMT:
-                return dasd_ioctl_format(bdev, argp);
+                rc = dasd_ioctl_format(bdev, argp);
+                break;
         case BIODASDINFO:
-                return dasd_ioctl_information(block, cmd, argp);
+                rc = dasd_ioctl_information(block, cmd, argp);
+                break;
         case BIODASDINFO2:
-                return dasd_ioctl_information(block, cmd, argp);
+                rc = dasd_ioctl_information(block, cmd, argp);
+                break;
         case BIODASDPRRD:
-                return dasd_ioctl_read_profile(block, argp);
+                rc = dasd_ioctl_read_profile(block, argp);
+                break;
         case BIODASDPRRST:
-                return dasd_ioctl_reset_profile(block);
+                rc = dasd_ioctl_reset_profile(block);
+                break;
         case BLKROSET:
-                return dasd_ioctl_set_ro(bdev, argp);
+                rc = dasd_ioctl_set_ro(bdev, argp);
+                break;
         case DASDAPIVER:
-                return dasd_ioctl_api_version(argp);
+                rc = dasd_ioctl_api_version(argp);
+                break;
         case BIODASDCMFENABLE:
-                return enable_cmf(block->base->cdev);
+                rc = enable_cmf(base->cdev);
+                break;
         case BIODASDCMFDISABLE:
-                return disable_cmf(block->base->cdev);
+                rc = disable_cmf(base->cdev);
+                break;
         case BIODASDREADALLCMB:
-                return dasd_ioctl_readall_cmb(block, cmd, argp);
+                rc = dasd_ioctl_readall_cmb(block, cmd, argp);
+                break;
         default:
                 /* if the discipline has an ioctl method try it. */
-                if (block->base->discipline->ioctl) {
-                        int rval = block->base->discipline->ioctl(block, cmd, argp);
-                        if (rval != -ENOIOCTLCMD)
-                                return rval;
-                }
-
-                return -EINVAL;
+                if (base->discipline->ioctl) {
+                        rc = base->discipline->ioctl(block, cmd, argp);
+                        if (rc == -ENOIOCTLCMD)
+                                rc = -EINVAL;
+                } else
+                        rc = -EINVAL;
         }
-}
-
-int dasd_ioctl(struct block_device *bdev, fmode_t mode,
-               unsigned int cmd, unsigned long arg)
-{
-        int rc;
-
-        lock_kernel();
-        rc = dasd_do_ioctl(bdev, mode, cmd, arg);
-        unlock_kernel();
+        dasd_put_device(base);
         return rc;
 }
diff --git a/drivers/s390/block/dasd_proc.c b/drivers/s390/block/dasd_proc.c
index 2eb025592809..c4a6a31bd9cd 100644
--- a/drivers/s390/block/dasd_proc.c
+++ b/drivers/s390/block/dasd_proc.c
@@ -251,7 +251,6 @@ static ssize_t dasd_stats_proc_write(struct file *file,
         buffer = dasd_get_user_string(user_buf, user_len);
         if (IS_ERR(buffer))
                 return PTR_ERR(buffer);
-        DBF_EVENT(DBF_DEBUG, "/proc/dasd/statictics: '%s'\n", buffer);
 
         /* check for valid verbs */
         str = skip_spaces(buffer);
diff --git a/drivers/s390/block/dcssblk.c b/drivers/s390/block/dcssblk.c
index 2bd72aa34c59..9b43ae94beba 100644
--- a/drivers/s390/block/dcssblk.c
+++ b/drivers/s390/block/dcssblk.c
@@ -14,7 +14,6 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/blkdev.h>
-#include <linux/smp_lock.h>
 #include <linux/completion.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
@@ -776,7 +775,6 @@ dcssblk_open(struct block_device *bdev, fmode_t mode)
         struct dcssblk_dev_info *dev_info;
         int rc;
 
-        lock_kernel();
         dev_info = bdev->bd_disk->private_data;
         if (NULL == dev_info) {
                 rc = -ENODEV;
@@ -786,7 +784,6 @@ dcssblk_open(struct block_device *bdev, fmode_t mode)
         bdev->bd_block_size = 4096;
         rc = 0;
 out:
-        unlock_kernel();
         return rc;
 }
 
@@ -797,7 +794,6 @@ dcssblk_release(struct gendisk *disk, fmode_t mode)
         struct segment_info *entry;
         int rc;
 
-        lock_kernel();
         if (!dev_info) {
                 rc = -ENODEV;
                 goto out;
@@ -815,7 +811,6 @@ dcssblk_release(struct gendisk *disk, fmode_t mode)
         up_write(&dcssblk_devices_sem);
         rc = 0;
 out:
-        unlock_kernel();
         return rc;
 }
 
diff --git a/drivers/s390/block/xpram.c b/drivers/s390/block/xpram.c
index c881a14fa5dd..1f6a4d894e73 100644
--- a/drivers/s390/block/xpram.c
+++ b/drivers/s390/block/xpram.c
@@ -62,8 +62,8 @@ static int xpram_devs;
 /*
  * Parameter parsing functions.
  */
-static int __initdata devs = XPRAM_DEVS;
-static char __initdata *sizes[XPRAM_MAX_DEVS];
+static int devs = XPRAM_DEVS;
+static char *sizes[XPRAM_MAX_DEVS];
 
 module_param(devs, int, 0);
 module_param_array(sizes, charp, NULL, 0);
diff --git a/drivers/s390/char/Kconfig b/drivers/s390/char/Kconfig
index 40834f18754c..a4f117d9fdc6 100644
--- a/drivers/s390/char/Kconfig
+++ b/drivers/s390/char/Kconfig
@@ -2,76 +2,85 @@ comment "S/390 character device drivers"
         depends on S390
 
 config TN3270
-        tristate "Support for locally attached 3270 terminals"
+        def_tristate y
+        prompt "Support for locally attached 3270 terminals"
         depends on CCW
         help
           Include support for IBM 3270 terminals.
 
 config TN3270_TTY
-        tristate "Support for tty input/output on 3270 terminals"
+        def_tristate y
+        prompt "Support for tty input/output on 3270 terminals"
         depends on TN3270
         help
           Include support for using an IBM 3270 terminal as a Linux tty.
 
 config TN3270_FS
-        tristate "Support for fullscreen applications on 3270 terminals"
+        def_tristate m
+        prompt "Support for fullscreen applications on 3270 terminals"
         depends on TN3270
         help
           Include support for fullscreen applications on an IBM 3270 terminal.
 
 config TN3270_CONSOLE
-        bool "Support for console on 3270 terminal"
+        def_bool y
+        prompt "Support for console on 3270 terminal"
         depends on TN3270=y && TN3270_TTY=y
         help
           Include support for using an IBM 3270 terminal as a Linux system
           console.  Available only if 3270 support is compiled in statically.
 
 config TN3215
-        bool "Support for 3215 line mode terminal"
+        def_bool y
+        prompt "Support for 3215 line mode terminal"
         depends on CCW
         help
           Include support for IBM 3215 line-mode terminals.
 
 config TN3215_CONSOLE
-        bool "Support for console on 3215 line mode terminal"
+        def_bool y
+        prompt "Support for console on 3215 line mode terminal"
         depends on TN3215
         help
           Include support for using an IBM 3215 line-mode terminal as a
           Linux system console.
 
 config CCW_CONSOLE
-        bool
-        depends on TN3215_CONSOLE || TN3270_CONSOLE
-        default y
+        def_bool y if TN3215_CONSOLE || TN3270_CONSOLE
 
 config SCLP_TTY
-        bool "Support for SCLP line mode terminal"
+        def_bool y
+        prompt "Support for SCLP line mode terminal"
         depends on S390
         help
           Include support for IBM SCLP line-mode terminals.
 
 config SCLP_CONSOLE
-        bool "Support for console on SCLP line mode terminal"
+        def_bool y
+        prompt "Support for console on SCLP line mode terminal"
         depends on SCLP_TTY
         help
           Include support for using an IBM HWC line-mode terminal as the Linux
           system console.
 
 config SCLP_VT220_TTY
-        bool "Support for SCLP VT220-compatible terminal"
+        def_bool y
+        prompt "Support for SCLP VT220-compatible terminal"
         depends on S390
         help
           Include support for an IBM SCLP VT220-compatible terminal.
 
 config SCLP_VT220_CONSOLE
-        bool "Support for console on SCLP VT220-compatible terminal"
+        def_bool y
+        prompt "Support for console on SCLP VT220-compatible terminal"
         depends on SCLP_VT220_TTY
         help
           Include support for using an IBM SCLP VT220-compatible terminal as a
           Linux system console.
 
 config SCLP_CPI
-        tristate "Control-Program Identification"
+        def_tristate m
+        prompt "Control-Program Identification"
         depends on S390
         help
           This option enables the hardware console interface for system
@@ -83,7 +92,8 @@ config SCLP_CPI
           need this feature and intend to run your kernel in LPAR.
 
 config SCLP_ASYNC
-        tristate "Support for Call Home via Asynchronous SCLP Records"
+        def_tristate m
+        prompt "Support for Call Home via Asynchronous SCLP Records"
         depends on S390
         help
           This option enables the call home function, which is able to inform
@@ -93,7 +103,8 @@ config SCLP_ASYNC
           need this feature and intend to run your kernel in LPAR.
 
 config S390_TAPE
-        tristate "S/390 tape device support"
+        def_tristate m
+        prompt "S/390 tape device support"
         depends on CCW
         help
           Select this option if you want to access channel-attached tape
@@ -108,22 +119,12 @@ config S390_TAPE
 comment "S/390 tape interface support"
         depends on S390_TAPE
 
-config S390_TAPE_BLOCK
-        bool "Support for tape block devices"
-        depends on S390_TAPE && BLOCK
-        help
-          Select this option if you want to access your channel-attached tape
-          devices using the block device interface.  This interface is similar
-          to CD-ROM devices on other platforms.  The tapes can only be
-          accessed read-only when using this interface.  Have a look at
-          <file:Documentation/s390/TAPE> for further information about creating
-          volumes for and using this interface.  It is safe to say "Y" here.
-
 comment "S/390 tape hardware support"
         depends on S390_TAPE
 
 config S390_TAPE_34XX
-        tristate "Support for 3480/3490 tape hardware"
+        def_tristate m
+        prompt "Support for 3480/3490 tape hardware"
         depends on S390_TAPE
         help
           Select this option if you want to access IBM 3480/3490 magnetic
@@ -131,7 +132,8 @@ config S390_TAPE_34XX
           It is safe to say "Y" here.
 
 config S390_TAPE_3590
-        tristate "Support for 3590 tape hardware"
+        def_tristate m
+        prompt "Support for 3590 tape hardware"
         depends on S390_TAPE
         help
           Select this option if you want to access IBM 3590 magnetic
@@ -139,7 +141,8 @@ config S390_TAPE_3590
           It is safe to say "Y" here.
 
 config VMLOGRDR
-        tristate "Support for the z/VM recording system services (VM only)"
+        def_tristate m
+        prompt "Support for the z/VM recording system services (VM only)"
         depends on IUCV
         help
           Select this option if you want to be able to receive records collected
@@ -148,29 +151,31 @@ config VMLOGRDR
           This driver depends on the IUCV support driver.
 
 config VMCP
-        bool "Support for the z/VM CP interface"
+        def_bool y
+        prompt "Support for the z/VM CP interface"
         depends on S390
         help
           Select this option if you want to be able to interact with the control
           program on z/VM
 
 config MONREADER
-        tristate "API for reading z/VM monitor service records"
+        def_tristate m
+        prompt "API for reading z/VM monitor service records"
         depends on IUCV
         help
           Character device driver for reading z/VM monitor service records
 
 config MONWRITER
-        tristate "API for writing z/VM monitor service records"
+        def_tristate m
+        prompt "API for writing z/VM monitor service records"
         depends on S390
-        default "m"
         help
           Character device driver for writing z/VM monitor service records
 
 config S390_VMUR
-        tristate "z/VM unit record device driver"
+        def_tristate m
+        prompt "z/VM unit record device driver"
         depends on S390
-        default "m"
         help
           Character device driver for z/VM reader, puncher and printer.
 
diff --git a/drivers/s390/char/Makefile b/drivers/s390/char/Makefile
index efb500ab66c0..f3c325207445 100644
--- a/drivers/s390/char/Makefile
+++ b/drivers/s390/char/Makefile
@@ -3,7 +3,7 @@
 #
 
 obj-y += ctrlchar.o keyboard.o defkeymap.o sclp.o sclp_rw.o sclp_quiesce.o \
-         sclp_cmd.o sclp_config.o sclp_cpi_sys.o
+         sclp_cmd.o sclp_config.o sclp_cpi_sys.o sclp_ocf.o
 
 obj-$(CONFIG_TN3270) += raw3270.o
 obj-$(CONFIG_TN3270_CONSOLE) += con3270.o
@@ -22,7 +22,6 @@ obj-$(CONFIG_ZVM_WATCHDOG) += vmwatchdog.o
 obj-$(CONFIG_VMLOGRDR) += vmlogrdr.o
 obj-$(CONFIG_VMCP) += vmcp.o
 
-tape-$(CONFIG_S390_TAPE_BLOCK) += tape_block.o
 tape-$(CONFIG_PROC_FS) += tape_proc.o
 tape-objs := tape_core.o tape_std.o tape_char.o $(tape-y)
 obj-$(CONFIG_S390_TAPE) += tape.o tape_class.o
diff --git a/drivers/s390/char/con3215.c b/drivers/s390/char/con3215.c
index 59ec073724bf..694464c65fcd 100644
--- a/drivers/s390/char/con3215.c
+++ b/drivers/s390/char/con3215.c
@@ -9,6 +9,7 @@
  *            Dan Morrison, IBM Corporation <dmorriso@cse.buffalo.edu>
  */
 
+#include <linux/kernel_stat.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kdev_t.h>
@@ -361,6 +362,7 @@ static void raw3215_irq(struct ccw_device *cdev, unsigned long intparm,
         int cstat, dstat;
         int count;
 
+        kstat_cpu(smp_processor_id()).irqs[IOINT_C15]++;
         raw = dev_get_drvdata(&cdev->dev);
         req = (struct raw3215_req *) intparm;
         cstat = irb->scsw.cmd.cstat;
@@ -762,8 +764,10 @@ static struct ccw_device_id raw3215_id[] = {
 };
 
 static struct ccw_driver raw3215_ccw_driver = {
-        .name           = "3215",
-        .owner          = THIS_MODULE,
+        .driver = {
+                .name   = "3215",
+                .owner  = THIS_MODULE,
+        },
         .ids            = raw3215_id,
         .probe          = &raw3215_probe,
         .remove         = &raw3215_remove,
diff --git a/drivers/s390/char/fs3270.c b/drivers/s390/char/fs3270.c
index 857dfcb7b359..f6489eb7e976 100644
--- a/drivers/s390/char/fs3270.c
+++ b/drivers/s390/char/fs3270.c
@@ -14,7 +14,6 @@
 #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>
@@ -520,6 +519,7 @@ static const struct file_operations fs3270_fops = {
         .compat_ioctl    = fs3270_ioctl,        /* ioctl */
         .open            = fs3270_open,         /* open */
         .release         = fs3270_close,        /* release */
+        .llseek         = no_llseek,
 };
 
 /*
diff --git a/drivers/s390/char/keyboard.c b/drivers/s390/char/keyboard.c
index 8cd58e412b5e..806588192483 100644
--- a/drivers/s390/char/keyboard.c
+++ b/drivers/s390/char/keyboard.c
@@ -455,12 +455,11 @@ do_kdgkb_ioctl(struct kbd_data *kbd, struct kbsentry __user *u_kbs,
         return 0;
 }
 
-int
-kbd_ioctl(struct kbd_data *kbd, struct file *file,
-          unsigned int cmd, unsigned long arg)
+int kbd_ioctl(struct kbd_data *kbd, unsigned int cmd, unsigned long arg)
 {
         void __user *argp;
-        int ct, perm;
+        unsigned int ct;
+        int perm;
 
         argp = (void __user *)arg;
 
diff --git a/drivers/s390/char/keyboard.h b/drivers/s390/char/keyboard.h
index 5ccfe9cf126d..7e736aaeae6e 100644
--- a/drivers/s390/char/keyboard.h
+++ b/drivers/s390/char/keyboard.h
@@ -36,7 +36,7 @@ void kbd_free(struct kbd_data *);
 void kbd_ascebc(struct kbd_data *, unsigned char *);
 
 void kbd_keycode(struct kbd_data *, unsigned int);
-int kbd_ioctl(struct kbd_data *, struct file *, unsigned int, unsigned long);
+int kbd_ioctl(struct kbd_data *, unsigned int, unsigned long);
 
 /*
  * Helper Functions.
diff --git a/drivers/s390/char/monreader.c b/drivers/s390/char/monreader.c
index e021ec663ef9..5b8b8592d311 100644
--- a/drivers/s390/char/monreader.c
+++ b/drivers/s390/char/monreader.c
@@ -447,6 +447,7 @@ static const struct file_operations mon_fops = {
         .release = &mon_close,
         .read    = &mon_read,
         .poll    = &mon_poll,
+        .llseek  = noop_llseek,
 };
 
 static struct miscdevice mon_dev = {
diff --git a/drivers/s390/char/monwriter.c b/drivers/s390/char/monwriter.c
index 572a1e7fd099..4600aa10a1c6 100644
--- a/drivers/s390/char/monwriter.c
+++ b/drivers/s390/char/monwriter.c
@@ -97,7 +97,7 @@ static int monwrite_new_hdr(struct mon_private *monpriv)
 {
         struct monwrite_hdr *monhdr = &monpriv->hdr;
         struct mon_buf *monbuf;
-        int rc;
+        int rc = 0;
 
         if (monhdr->datalen > MONWRITE_MAX_DATALEN ||
             monhdr->mon_function > MONWRITE_START_CONFIG ||
@@ -135,7 +135,7 @@ static int monwrite_new_hdr(struct mon_private *monpriv)
                         mon_buf_count++;
         }
         monpriv->current_buf = monbuf;
-        return 0;
+        return rc;
 }
 
 static int monwrite_new_data(struct mon_private *monpriv)
@@ -274,6 +274,7 @@ static const struct file_operations monwrite_fops = {
         .open    = &monwrite_open,
         .release = &monwrite_close,
         .write   = &monwrite_write,
+        .llseek  = noop_llseek,
 };
 
 static struct miscdevice mon_dev = {
diff --git a/drivers/s390/char/raw3270.c b/drivers/s390/char/raw3270.c
index 2a4c566456e7..810ac38631c3 100644
--- a/drivers/s390/char/raw3270.c
+++ b/drivers/s390/char/raw3270.c
@@ -7,6 +7,7 @@
  *     Copyright IBM Corp. 2003, 2009
  */
 
+#include <linux/kernel_stat.h>
 #include <linux/module.h>
 #include <linux/err.h>
 #include <linux/init.h>
@@ -329,6 +330,7 @@ raw3270_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
         struct raw3270_request *rq;
         int rc;
 
+        kstat_cpu(smp_processor_id()).irqs[IOINT_C70]++;
         rp = dev_get_drvdata(&cdev->dev);
         if (!rp)
                 return;
@@ -596,13 +598,12 @@ __raw3270_size_device(struct raw3270 *rp)
         static const unsigned char wbuf[] =
                 { 0x00, 0x07, 0x01, 0xff, 0x03, 0x00, 0x81 };
         struct raw3270_ua *uap;
-        unsigned short count;
         int rc;
 
         /*
          * To determine the size of the 3270 device we need to do:
          * 1) send a 'read partition' data stream to the device
-         * 2) wait for the attn interrupt that preceeds the query reply
+         * 2) wait for the attn interrupt that precedes the query reply
          * 3) do a read modified to get the query reply
          * To make things worse we have to cope with intervention
          * required (3270 device switched to 'stand-by') and command
@@ -651,7 +652,6 @@ __raw3270_size_device(struct raw3270 *rp)
         if (rc)
                 return rc;
         /* Got a Query Reply */
-        count = sizeof(rp->init_data) - rp->init_request.rescnt;
         uap = (struct raw3270_ua *) (rp->init_data + 1);
         /* Paranoia check. */
         if (rp->init_data[0] != 0x88 || uap->uab.qcode != 0x81)
@@ -1386,8 +1386,10 @@ static struct ccw_device_id raw3270_id[] = {
 };
 
 static struct ccw_driver raw3270_ccw_driver = {
-        .name           = "3270",
-        .owner          = THIS_MODULE,
+        .driver = {
+                .name   = "3270",
+                .owner  = THIS_MODULE,
+        },
         .ids            = raw3270_id,
         .probe          = &raw3270_probe,
         .remove         = &raw3270_remove,
diff --git a/drivers/s390/char/sclp.c b/drivers/s390/char/sclp.c
index f6d72e1f2a38..eaa7e78186f9 100644
--- a/drivers/s390/char/sclp.c
+++ b/drivers/s390/char/sclp.c
@@ -7,6 +7,7 @@
  *            Martin Schwidefsky <schwidefsky@de.ibm.com>
  */
 
+#include <linux/kernel_stat.h>
 #include <linux/module.h>
 #include <linux/err.h>
 #include <linux/spinlock.h>
@@ -19,15 +20,12 @@
 #include <linux/completion.h>
 #include <linux/platform_device.h>
 #include <asm/types.h>
-#include <asm/s390_ext.h>
+#include <asm/irq.h>
 
 #include "sclp.h"
 
 #define SCLP_HEADER             "sclp: "
 
-/* Structure for register_early_external_interrupt. */
-static ext_int_info_t ext_int_info_hwc;
-
 /* Lock to protect internal data consistency. */
 static DEFINE_SPINLOCK(sclp_lock);
 
@@ -395,16 +393,17 @@ __sclp_find_req(u32 sccb)
 /* Handler for external interruption. Perform request post-processing.
  * Prepare read event data request if necessary. Start processing of next
  * request on queue. */
-static void
-sclp_interrupt_handler(__u16 code)
+static void sclp_interrupt_handler(unsigned int ext_int_code,
+                                   unsigned int param32, unsigned long param64)
 {
         struct sclp_req *req;
         u32 finished_sccb;
         u32 evbuf_pending;
 
+        kstat_cpu(smp_processor_id()).irqs[EXTINT_SCP]++;
         spin_lock(&sclp_lock);
-        finished_sccb = S390_lowcore.ext_params & 0xfffffff8;
-        evbuf_pending = S390_lowcore.ext_params & 0x3;
+        finished_sccb = param32 & 0xfffffff8;
+        evbuf_pending = param32 & 0x3;
         if (finished_sccb) {
                 del_timer(&sclp_request_timer);
                 sclp_running_state = sclp_running_state_reset_pending;
@@ -468,7 +467,7 @@ sclp_sync_wait(void)
         cr0_sync &= 0xffff00a0;
         cr0_sync |= 0x00000200;
         __ctl_load(cr0_sync, 0, 0);
-        __raw_local_irq_stosm(0x01);
+        __arch_local_irq_stosm(0x01);
         /* Loop until driver state indicates finished request */
         while (sclp_running_state != sclp_running_state_idle) {
                 /* Check for expired request timer */
@@ -819,12 +818,13 @@ EXPORT_SYMBOL(sclp_reactivate);
 
 /* Handler for external interruption used during initialization. Modify
  * request state to done. */
-static void
-sclp_check_handler(__u16 code)
+static void sclp_check_handler(unsigned int ext_int_code,
+                               unsigned int param32, unsigned long param64)
 {
         u32 finished_sccb;
 
-        finished_sccb = S390_lowcore.ext_params & 0xfffffff8;
+        kstat_cpu(smp_processor_id()).irqs[EXTINT_SCP]++;
+        finished_sccb = param32 & 0xfffffff8;
         /* Is this the interrupt we are waiting for? */
         if (finished_sccb == 0)
                 return;
@@ -866,8 +866,7 @@ sclp_check_interface(void)
 
         spin_lock_irqsave(&sclp_lock, flags);
         /* Prepare init mask command */
-        rc = register_early_external_interrupt(0x2401, sclp_check_handler,
-                                               &ext_int_info_hwc);
+        rc = register_external_interrupt(0x2401, sclp_check_handler);
         if (rc) {
                 spin_unlock_irqrestore(&sclp_lock, flags);
                 return rc;
@@ -885,12 +884,12 @@ sclp_check_interface(void)
                 spin_unlock_irqrestore(&sclp_lock, flags);
                 /* Enable service-signal interruption - needs to happen
                  * with IRQs enabled. */
-                ctl_set_bit(0, 9);
+                service_subclass_irq_register();
                 /* Wait for signal from interrupt or timeout */
                 sclp_sync_wait();
                 /* Disable service-signal interruption - needs to happen
                  * with IRQs enabled. */
-                ctl_clear_bit(0,9);
+                service_subclass_irq_unregister();
                 spin_lock_irqsave(&sclp_lock, flags);
                 del_timer(&sclp_request_timer);
                 if (sclp_init_req.status == SCLP_REQ_DONE &&
@@ -900,8 +899,7 @@ sclp_check_interface(void)
                 } else
                         rc = -EBUSY;
         }
-        unregister_early_external_interrupt(0x2401, sclp_check_handler,
-                                            &ext_int_info_hwc);
+        unregister_external_interrupt(0x2401, sclp_check_handler);
         spin_unlock_irqrestore(&sclp_lock, flags);
         return rc;
 }
@@ -1064,15 +1062,14 @@ sclp_init(void)
         if (rc)
                 goto fail_init_state_uninitialized;
         /* Register interrupt handler */
-        rc = register_early_external_interrupt(0x2401, sclp_interrupt_handler,
-                                               &ext_int_info_hwc);
+        rc = register_external_interrupt(0x2401, sclp_interrupt_handler);
         if (rc)
                 goto fail_unregister_reboot_notifier;
         sclp_init_state = sclp_init_state_initialized;
         spin_unlock_irqrestore(&sclp_lock, flags);
         /* Enable service-signal external interruption - needs to happen with
          * IRQs enabled. */
-        ctl_set_bit(0, 9);
+        service_subclass_irq_register();
         sclp_init_mask(1);
         return 0;
 
diff --git a/drivers/s390/char/sclp.h b/drivers/s390/char/sclp.h
index 6bb5a6bdfab5..49a1bb52bc87 100644
--- a/drivers/s390/char/sclp.h
+++ b/drivers/s390/char/sclp.h
@@ -28,6 +28,7 @@
 #define EVTYP_CONFMGMDATA       0x04
 #define EVTYP_SDIAS             0x1C
 #define EVTYP_ASYNC             0x0A
+#define EVTYP_OCF               0x1E
 
 #define EVTYP_OPCMD_MASK        0x80000000
 #define EVTYP_MSG_MASK          0x40000000
@@ -40,6 +41,7 @@
 #define EVTYP_CONFMGMDATA_MASK  0x10000000
 #define EVTYP_SDIAS_MASK        0x00000010
 #define EVTYP_ASYNC_MASK        0x00400000
+#define EVTYP_OCF_MASK          0x00000004
 
 #define GNRLMSGFLGS_DOM         0x8000
 #define GNRLMSGFLGS_SNDALRM     0x4000
@@ -186,4 +188,26 @@ sclp_ascebc_str(unsigned char *str, int nr)
         (MACHINE_IS_VM) ? ASCEBC(str, nr) : ASCEBC_500(str, nr);
 }
 
+static inline struct gds_vector *
+sclp_find_gds_vector(void *start, void *end, u16 id)
+{
+        struct gds_vector *v;
+
+        for (v = start; (void *) v < end; v = (void *) v + v->length)
+                if (v->gds_id == id)
+                        return v;
+        return NULL;
+}
+
+static inline struct gds_subvector *
+sclp_find_gds_subvector(void *start, void *end, u8 key)
+{
+        struct gds_subvector *sv;
+
+        for (sv = start; (void *) sv < end; sv = (void *) sv + sv->length)
+                if (sv->key == key)
+                        return sv;
+        return NULL;
+}
+
 #endif   /* __SCLP_H__ */
diff --git a/drivers/s390/char/sclp_cmd.c b/drivers/s390/char/sclp_cmd.c
index 4b60ede07f0e..be55fb2b1b1c 100644
--- a/drivers/s390/char/sclp_cmd.c
+++ b/drivers/s390/char/sclp_cmd.c
@@ -518,6 +518,8 @@ static void __init insert_increment(u16 rn, int standby, int assigned)
                 return;
         new_incr->rn = rn;
         new_incr->standby = standby;
+        if (!standby)
+                new_incr->usecount = 1;
         last_rn = 0;
         prev = &sclp_mem_list;
         list_for_each_entry(incr, &sclp_mem_list, list) {
diff --git a/drivers/s390/char/sclp_config.c b/drivers/s390/char/sclp_config.c
index b497afe061cc..95b909ac2b73 100644
--- a/drivers/s390/char/sclp_config.c
+++ b/drivers/s390/char/sclp_config.c
@@ -33,6 +33,7 @@ static void sclp_cpu_capability_notify(struct work_struct *work)
         int cpu;
         struct sys_device *sysdev;
 
+        s390_adjust_jiffies();
         pr_warning("cpu capability changed.\n");
         get_online_cpus();
         for_each_online_cpu(cpu) {
@@ -70,21 +71,9 @@ static struct sclp_register sclp_conf_register =
 
 static int __init sclp_conf_init(void)
 {
-        int rc;
-
         INIT_WORK(&sclp_cpu_capability_work, sclp_cpu_capability_notify);
         INIT_WORK(&sclp_cpu_change_work, sclp_cpu_change_notify);
-
-        rc = sclp_register(&sclp_conf_register);
-        if (rc)
-                return rc;
-
-        if (!(sclp_conf_register.sclp_send_mask & EVTYP_CONFMGMDATA_MASK)) {
-                pr_warning("no configuration management.\n");
-                sclp_unregister(&sclp_conf_register);
-                rc = -ENOSYS;
-        }
-        return rc;
+        return sclp_register(&sclp_conf_register);
 }
 
 __initcall(sclp_conf_init);
diff --git a/drivers/s390/char/sclp_ocf.c b/drivers/s390/char/sclp_ocf.c
new file mode 100644
index 000000000000..ab294d5a534e
--- /dev/null
+++ b/drivers/s390/char/sclp_ocf.c
@@ -0,0 +1,145 @@
+/*
+ *  drivers/s390/char/sclp_ocf.c
+ *    SCLP OCF communication parameters sysfs interface
+ *
+ *    Copyright IBM Corp. 2011
+ *    Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>
+ */
+
+#define KMSG_COMPONENT "sclp_ocf"
+#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/stat.h>
+#include <linux/device.h>
+#include <linux/string.h>
+#include <linux/ctype.h>
+#include <linux/kmod.h>
+#include <linux/timer.h>
+#include <linux/err.h>
+#include <asm/ebcdic.h>
+#include <asm/sclp.h>
+
+#include "sclp.h"
+
+#define OCF_LENGTH_HMC_NETWORK 8UL
+#define OCF_LENGTH_CPC_NAME 8UL
+
+static char hmc_network[OCF_LENGTH_HMC_NETWORK + 1];
+static char cpc_name[OCF_LENGTH_CPC_NAME + 1];
+
+static DEFINE_SPINLOCK(sclp_ocf_lock);
+static struct work_struct sclp_ocf_change_work;
+
+static struct kset *ocf_kset;
+
+static void sclp_ocf_change_notify(struct work_struct *work)
+{
+        kobject_uevent(&ocf_kset->kobj, KOBJ_CHANGE);
+}
+
+/* Handler for OCF event. Look for the CPC image name. */
+static void sclp_ocf_handler(struct evbuf_header *evbuf)
+{
+        struct gds_vector *v;
+        struct gds_subvector *sv, *netid, *cpc;
+        size_t size;
+
+        /* Find the 0x9f00 block. */
+        v = sclp_find_gds_vector(evbuf + 1, (void *) evbuf + evbuf->length,
+                                 0x9f00);
+        if (!v)
+                return;
+        /* Find the 0x9f22 block inside the 0x9f00 block. */
+        v = sclp_find_gds_vector(v + 1, (void *) v + v->length, 0x9f22);
+        if (!v)
+                return;
+        /* Find the 0x81 block inside the 0x9f22 block. */
+        sv = sclp_find_gds_subvector(v + 1, (void *) v + v->length, 0x81);
+        if (!sv)
+                return;
+        /* Find the 0x01 block inside the 0x81 block. */
+        netid = sclp_find_gds_subvector(sv + 1, (void *) sv + sv->length, 1);
+        /* Find the 0x02 block inside the 0x81 block. */
+        cpc = sclp_find_gds_subvector(sv + 1, (void *) sv + sv->length, 2);
+        /* Copy network name and cpc name. */
+        spin_lock(&sclp_ocf_lock);
+        if (netid) {
+                size = min(OCF_LENGTH_HMC_NETWORK, (size_t) netid->length);
+                memcpy(hmc_network, netid + 1, size);
+                EBCASC(hmc_network, size);
+                hmc_network[size] = 0;
+        }
+        if (cpc) {
+                size = min(OCF_LENGTH_CPC_NAME, (size_t) cpc->length);
+                memcpy(cpc_name, cpc + 1, size);
+                EBCASC(cpc_name, size);
+                cpc_name[size] = 0;
+        }
+        spin_unlock(&sclp_ocf_lock);
+        schedule_work(&sclp_ocf_change_work);
+}
+
+static struct sclp_register sclp_ocf_event = {
+        .receive_mask = EVTYP_OCF_MASK,
+        .receiver_fn = sclp_ocf_handler,
+};
+
+static ssize_t cpc_name_show(struct kobject *kobj,
+                             struct kobj_attribute *attr, char *page)
+{
+        int rc;
+
+        spin_lock_irq(&sclp_ocf_lock);
+        rc = snprintf(page, PAGE_SIZE, "%s\n", cpc_name);
+        spin_unlock_irq(&sclp_ocf_lock);
+        return rc;
+}
+
+static struct kobj_attribute cpc_name_attr =
+        __ATTR(cpc_name, 0444, cpc_name_show, NULL);
+
+static ssize_t hmc_network_show(struct kobject *kobj,
+                                struct kobj_attribute *attr, char *page)
+{
+        int rc;
+
+        spin_lock_irq(&sclp_ocf_lock);
+        rc = snprintf(page, PAGE_SIZE, "%s\n", hmc_network);
+        spin_unlock_irq(&sclp_ocf_lock);
+        return rc;
+}
+
+static struct kobj_attribute hmc_network_attr =
+        __ATTR(hmc_network, 0444, hmc_network_show, NULL);
+
+static struct attribute *ocf_attrs[] = {
+        &cpc_name_attr.attr,
+        &hmc_network_attr.attr,
+        NULL,
+};
+
+static struct attribute_group ocf_attr_group = {
+        .attrs = ocf_attrs,
+};
+
+static int __init ocf_init(void)
+{
+        int rc;
+
+        INIT_WORK(&sclp_ocf_change_work, sclp_ocf_change_notify);
+        ocf_kset = kset_create_and_add("ocf", NULL, firmware_kobj);
+        if (!ocf_kset)
+                return -ENOMEM;
+
+        rc = sysfs_create_group(&ocf_kset->kobj, &ocf_attr_group);
+        if (rc) {
+                kset_unregister(ocf_kset);
+                return rc;
+        }
+
+        return sclp_register(&sclp_ocf_event);
+}
+
+device_initcall(ocf_init);
diff --git a/drivers/s390/char/sclp_sdias.c b/drivers/s390/char/sclp_sdias.c
index 6a1c58dc61a7..fa733ecd3d70 100644
--- a/drivers/s390/char/sclp_sdias.c
+++ b/drivers/s390/char/sclp_sdias.c
@@ -69,9 +69,6 @@ static DEFINE_MUTEX(sdias_mutex);
 
 static void sdias_callback(struct sclp_req *request, void *data)
 {
-        struct sdias_sccb *cbsccb;
-
-        cbsccb = (struct sdias_sccb *) request->sccb;
         sclp_req_done = 1;
         wake_up(&sdias_wq); /* Inform caller, that request is complete */
         TRACE("callback done\n");
diff --git a/drivers/s390/char/sclp_tty.c b/drivers/s390/char/sclp_tty.c
index 8258d590505f..a879c139926a 100644
--- a/drivers/s390/char/sclp_tty.c
+++ b/drivers/s390/char/sclp_tty.c
@@ -408,118 +408,72 @@ static int sclp_switch_cases(unsigned char *buf, int count)
         return op - buf;
 }
 
-static void
-sclp_get_input(unsigned char *start, unsigned char *end)
+static void sclp_get_input(struct gds_subvector *sv)
 {
+        unsigned char *str;
         int count;
 
-        count = end - start;
+        str = (unsigned char *) (sv + 1);
+        count = sv->length - sizeof(*sv);
         if (sclp_tty_tolower)
-                EBC_TOLOWER(start, count);
-        count = sclp_switch_cases(start, count);
+                EBC_TOLOWER(str, count);
+        count = sclp_switch_cases(str, count);
         /* convert EBCDIC to ASCII (modify original input in SCCB) */
-        sclp_ebcasc_str(start, count);
+        sclp_ebcasc_str(str, count);
 
         /* transfer input to high level driver */
-        sclp_tty_input(start, count);
-}
-
-static inline struct gds_vector *
-find_gds_vector(struct gds_vector *start, struct gds_vector *end, u16 id)
-{
-        struct gds_vector *vec;
-
-        for (vec = start; vec < end; vec = (void *) vec + vec->length)
-                if (vec->gds_id == id)
-                        return vec;
-        return NULL;
+        sclp_tty_input(str, count);
 }
 
-static inline struct gds_subvector *
-find_gds_subvector(struct gds_subvector *start,
-                   struct gds_subvector *end, u8 key)
+static inline void sclp_eval_selfdeftextmsg(struct gds_subvector *sv)
 {
-        struct gds_subvector *subvec;
+        void *end;
 
-        for (subvec = start; subvec < end;
-             subvec = (void *) subvec + subvec->length)
-                if (subvec->key == key)
-                        return subvec;
-        return NULL;
+        end = (void *) sv + sv->length;
+        for (sv = sv + 1; (void *) sv < end; sv = (void *) sv + sv->length)
+                if (sv->key == 0x30)
+                        sclp_get_input(sv);
 }
 
-static inline void
-sclp_eval_selfdeftextmsg(struct gds_subvector *start,
-                         struct gds_subvector *end)
+static inline void sclp_eval_textcmd(struct gds_vector *v)
 {
-        struct gds_subvector *subvec;
-
-        subvec = start;
-        while (subvec < end) {
-                subvec = find_gds_subvector(subvec, end, 0x30);
-                if (!subvec)
-                        break;
-                sclp_get_input((unsigned char *)(subvec + 1),
-                               (unsigned char *) subvec + subvec->length);
-                subvec = (void *) subvec + subvec->length;
-        }
-}
+        struct gds_subvector *sv;
+        void *end;
 
-static inline void
-sclp_eval_textcmd(struct gds_subvector *start,
-                  struct gds_subvector *end)
-{
-        struct gds_subvector *subvec;
+        end = (void *) v + v->length;
+        for (sv = (struct gds_subvector *) (v + 1);
+             (void *) sv < end; sv = (void *) sv + sv->length)
+                if (sv->key == GDS_KEY_SELFDEFTEXTMSG)
+                        sclp_eval_selfdeftextmsg(sv);
 
-        subvec = start;
-        while (subvec < end) {
-                subvec = find_gds_subvector(subvec, end,
-                                            GDS_KEY_SELFDEFTEXTMSG);
-                if (!subvec)
-                        break;
-                sclp_eval_selfdeftextmsg((struct gds_subvector *)(subvec + 1),
-                                         (void *)subvec + subvec->length);
-                subvec = (void *) subvec + subvec->length;
-        }
 }
 
-static inline void
-sclp_eval_cpmsu(struct gds_vector *start, struct gds_vector *end)
+static inline void sclp_eval_cpmsu(struct gds_vector *v)
 {
-        struct gds_vector *vec;
+        void *end;
 
-        vec = start;
-        while (vec < end) {
-                vec = find_gds_vector(vec, end, GDS_ID_TEXTCMD);
-                if (!vec)
-                        break;
-                sclp_eval_textcmd((struct gds_subvector *)(vec + 1),
-                                  (void *) vec + vec->length);
-                vec = (void *) vec + vec->length;
-        }
+        end = (void *) v + v->length;
+        for (v = v + 1; (void *) v < end; v = (void *) v + v->length)
+                if (v->gds_id == GDS_ID_TEXTCMD)
+                        sclp_eval_textcmd(v);
 }
 
 
-static inline void
-sclp_eval_mdsmu(struct gds_vector *start, void *end)
+static inline void sclp_eval_mdsmu(struct gds_vector *v)
 {
-        struct gds_vector *vec;
-
-        vec = find_gds_vector(start, end, GDS_ID_CPMSU);
-        if (vec)
-                sclp_eval_cpmsu(vec + 1, (void *) vec + vec->length);
+        v = sclp_find_gds_vector(v + 1, (void *) v + v->length, GDS_ID_CPMSU);
+        if (v)
+                sclp_eval_cpmsu(v);
 }
 
-static void
-sclp_tty_receiver(struct evbuf_header *evbuf)
+static void sclp_tty_receiver(struct evbuf_header *evbuf)
 {
-        struct gds_vector *start, *end, *vec;
+        struct gds_vector *v;
 
-        start = (struct gds_vector *)(evbuf + 1);
-        end = (void *) evbuf + evbuf->length;
-        vec = find_gds_vector(start, end, GDS_ID_MDSMU);
-        if (vec)
-                sclp_eval_mdsmu(vec + 1, (void *) vec + vec->length);
+        v = sclp_find_gds_vector(evbuf + 1, (void *) evbuf + evbuf->length,
+                                 GDS_ID_MDSMU);
+        if (v)
+                sclp_eval_mdsmu(v);
 }
 
 static void
diff --git a/drivers/s390/char/tape.h b/drivers/s390/char/tape.h
index 7a242f073632..267b54e8ff5a 100644
--- a/drivers/s390/char/tape.h
+++ b/drivers/s390/char/tape.h
@@ -280,6 +280,14 @@ tape_do_io_free(struct tape_device *device, struct tape_request *request)
         return rc;
 }
 
+static inline void
+tape_do_io_async_free(struct tape_device *device, struct tape_request *request)
+{
+        request->callback = (void *) tape_free_request;
+        request->callback_data = NULL;
+        tape_do_io_async(device, request);
+}
+
 extern int tape_oper_handler(int irq, int status);
 extern void tape_noper_handler(int irq, int status);
 extern int tape_open(struct tape_device *);
diff --git a/drivers/s390/char/tape_34xx.c b/drivers/s390/char/tape_34xx.c
index c17f35b6136a..9eff2df70ddb 100644
--- a/drivers/s390/char/tape_34xx.c
+++ b/drivers/s390/char/tape_34xx.c
@@ -53,23 +53,11 @@ static void tape_34xx_delete_sbid_from(struct tape_device *, int);
  * Medium sense for 34xx tapes. There is no 'real' medium sense call.
  * So we just do a normal sense.
  */
-static int
-tape_34xx_medium_sense(struct tape_device *device)
+static void __tape_34xx_medium_sense(struct tape_request *request)
 {
-        struct tape_request *request;
-        unsigned char       *sense;
-        int                  rc;
-
-        request = tape_alloc_request(1, 32);
-        if (IS_ERR(request)) {
-                DBF_EXCEPTION(6, "MSEN fail\n");
-                return PTR_ERR(request);
-        }
-
-        request->op = TO_MSEN;
-        tape_ccw_end(request->cpaddr, SENSE, 32, request->cpdata);
+        struct tape_device *device = request->device;
+        unsigned char *sense;
 
-        rc = tape_do_io_interruptible(device, request);
         if (request->rc == 0) {
                 sense = request->cpdata;
 
@@ -88,15 +76,47 @@ tape_34xx_medium_sense(struct tape_device *device)
                         device->tape_generic_status |= GMT_WR_PROT(~0);
                 else
                         device->tape_generic_status &= ~GMT_WR_PROT(~0);
-        } else {
+        } else
                 DBF_EVENT(4, "tape_34xx: medium sense failed with rc=%d\n",
                         request->rc);
-        }
         tape_free_request(request);
+}
 
+static int tape_34xx_medium_sense(struct tape_device *device)
+{
+        struct tape_request *request;
+        int rc;
+
+        request = tape_alloc_request(1, 32);
+        if (IS_ERR(request)) {
+                DBF_EXCEPTION(6, "MSEN fail\n");
+                return PTR_ERR(request);
+        }
+
+        request->op = TO_MSEN;
+        tape_ccw_end(request->cpaddr, SENSE, 32, request->cpdata);
+        rc = tape_do_io_interruptible(device, request);
+        __tape_34xx_medium_sense(request);
         return rc;
 }
 
+static void tape_34xx_medium_sense_async(struct tape_device *device)
+{
+        struct tape_request *request;
+
+        request = tape_alloc_request(1, 32);
+        if (IS_ERR(request)) {
+                DBF_EXCEPTION(6, "MSEN fail\n");
+                return;
+        }
+
+        request->op = TO_MSEN;
+        tape_ccw_end(request->cpaddr, SENSE, 32, request->cpdata);
+        request->callback = (void *) __tape_34xx_medium_sense;
+        request->callback_data = NULL;
+        tape_do_io_async(device, request);
+}
+
 struct tape_34xx_work {
         struct tape_device      *device;
         enum tape_op             op;
@@ -109,6 +129,9 @@ struct tape_34xx_work {
  * is inserted but cannot call tape_do_io* from an interrupt context.
  * Maybe that's useful for other actions we want to start from the
  * interrupt handler.
+ * Note: the work handler is called by the system work queue. The tape
+ * commands started by the handler need to be asynchrounous, otherwise
+ * a deadlock can occur e.g. in case of a deferred cc=1 (see __tape_do_irq).
  */
 static void
 tape_34xx_work_handler(struct work_struct *work)
@@ -119,7 +142,7 @@ tape_34xx_work_handler(struct work_struct *work)
 
         switch(p->op) {
                 case TO_MSEN:
-                        tape_34xx_medium_sense(device);
+                        tape_34xx_medium_sense_async(device);
                         break;
                 default:
                         DBF_EVENT(3, "T34XX: internal error: unknown work\n");
@@ -1297,8 +1320,10 @@ tape_34xx_online(struct ccw_device *cdev)
 }
 
 static struct ccw_driver tape_34xx_driver = {
-        .name = "tape_34xx",
-        .owner = THIS_MODULE,
+        .driver = {
+                .name = "tape_34xx",
+                .owner = THIS_MODULE,
+        },
         .ids = tape_34xx_ids,
         .probe = tape_generic_probe,
         .remove = tape_generic_remove,
diff --git a/drivers/s390/char/tape_3590.c b/drivers/s390/char/tape_3590.c
index fc993acf99b6..a7d570728882 100644
--- a/drivers/s390/char/tape_3590.c
+++ b/drivers/s390/char/tape_3590.c
@@ -24,6 +24,8 @@
 #include "tape_std.h"
 #include "tape_3590.h"
 
+static struct workqueue_struct *tape_3590_wq;
+
 /*
  * Pointer to debug area.
  */
@@ -31,7 +33,7 @@ debug_info_t *TAPE_DBF_AREA = NULL;
 EXPORT_SYMBOL(TAPE_DBF_AREA);
 
 /*******************************************************************
- * Error Recovery fuctions:
+ * Error Recovery functions:
  * - Read Opposite:              implemented
  * - Read Device (buffered) log: BRA
  * - Read Library log:           BRA
@@ -327,17 +329,17 @@ out:
 /*
  * Enable encryption
  */
-static int tape_3592_enable_crypt(struct tape_device *device)
+static struct tape_request *__tape_3592_enable_crypt(struct tape_device *device)
 {
         struct tape_request *request;
         char *data;
 
         DBF_EVENT(6, "tape_3592_enable_crypt\n");
         if (!crypt_supported(device))
-                return -ENOSYS;
+                return ERR_PTR(-ENOSYS);
         request = tape_alloc_request(2, 72);
         if (IS_ERR(request))
-                return PTR_ERR(request);
+                return request;
         data = request->cpdata;
         memset(data,0,72);
 
@@ -352,23 +354,42 @@ static int tape_3592_enable_crypt(struct tape_device *device)
         request->op = TO_CRYPT_ON;
         tape_ccw_cc(request->cpaddr, MODE_SET_CB, 36, data);
         tape_ccw_end(request->cpaddr + 1, MODE_SET_CB, 36, data + 36);
+        return request;
+}
+
+static int tape_3592_enable_crypt(struct tape_device *device)
+{
+        struct tape_request *request;
+
+        request = __tape_3592_enable_crypt(device);
+        if (IS_ERR(request))
+                return PTR_ERR(request);
         return tape_do_io_free(device, request);
 }
 
+static void tape_3592_enable_crypt_async(struct tape_device *device)
+{
+        struct tape_request *request;
+
+        request = __tape_3592_enable_crypt(device);
+        if (!IS_ERR(request))
+                tape_do_io_async_free(device, request);
+}
+
 /*
  * Disable encryption
  */
-static int tape_3592_disable_crypt(struct tape_device *device)
+static struct tape_request *__tape_3592_disable_crypt(struct tape_device *device)
 {
         struct tape_request *request;
         char *data;
 
         DBF_EVENT(6, "tape_3592_disable_crypt\n");
         if (!crypt_supported(device))
-                return -ENOSYS;
+                return ERR_PTR(-ENOSYS);
         request = tape_alloc_request(2, 72);
         if (IS_ERR(request))
-                return PTR_ERR(request);
+                return request;
         data = request->cpdata;
         memset(data,0,72);
 
@@ -381,9 +402,28 @@ static int tape_3592_disable_crypt(struct tape_device *device)
         tape_ccw_cc(request->cpaddr, MODE_SET_CB, 36, data);
         tape_ccw_end(request->cpaddr + 1, MODE_SET_CB, 36, data + 36);
 
+        return request;
+}
+
+static int tape_3592_disable_crypt(struct tape_device *device)
+{
+        struct tape_request *request;
+
+        request = __tape_3592_disable_crypt(device);
+        if (IS_ERR(request))
+                return PTR_ERR(request);
         return tape_do_io_free(device, request);
 }
 
+static void tape_3592_disable_crypt_async(struct tape_device *device)
+{
+        struct tape_request *request;
+
+        request = __tape_3592_disable_crypt(device);
+        if (!IS_ERR(request))
+                tape_do_io_async_free(device, request);
+}
+
 /*
  * IOCTL: Set encryption status
  */
@@ -455,8 +495,7 @@ tape_3590_ioctl(struct tape_device *device, unsigned int cmd, unsigned long arg)
 /*
  * SENSE Medium: Get Sense data about medium state
  */
-static int
-tape_3590_sense_medium(struct tape_device *device)
+static int tape_3590_sense_medium(struct tape_device *device)
 {
         struct tape_request *request;
 
@@ -468,6 +507,18 @@ tape_3590_sense_medium(struct tape_device *device)
         return tape_do_io_free(device, request);
 }
 
+static void tape_3590_sense_medium_async(struct tape_device *device)
+{
+        struct tape_request *request;
+
+        request = tape_alloc_request(1, 128);
+        if (IS_ERR(request))
+                return;
+        request->op = TO_MSEN;
+        tape_ccw_end(request->cpaddr, MEDIUM_SENSE, 128, request->cpdata);
+        tape_do_io_async_free(device, request);
+}
+
 /*
  * MTTELL: Tell block. Return the number of block relative to current file.
  */
@@ -544,15 +595,14 @@ tape_3590_read_opposite(struct tape_device *device,
  * 2. The attention msg is written to the "read subsystem data" buffer.
  * In this case we probably should print it to the console.
  */
-static int
-tape_3590_read_attmsg(struct tape_device *device)
+static void tape_3590_read_attmsg_async(struct tape_device *device)
 {
         struct tape_request *request;
         char *buf;
 
         request = tape_alloc_request(3, 4096);
         if (IS_ERR(request))
-                return PTR_ERR(request);
+                return;
         request->op = TO_READ_ATTMSG;
         buf = request->cpdata;
         buf[0] = PREP_RD_SS_DATA;
@@ -560,12 +610,15 @@ tape_3590_read_attmsg(struct tape_device *device)
         tape_ccw_cc(request->cpaddr, PERFORM_SS_FUNC, 12, buf);
         tape_ccw_cc(request->cpaddr + 1, READ_SS_DATA, 4096 - 12, buf + 12);
         tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
-        return tape_do_io_free(device, request);
+        tape_do_io_async_free(device, request);
 }
 
 /*
  * These functions are used to schedule follow-up actions from within an
  * interrupt context (like unsolicited interrupts).
+ * Note: the work handler is called by the system work queue. The tape
+ * commands started by the handler need to be asynchrounous, otherwise
+ * a deadlock can occur e.g. in case of a deferred cc=1 (see __tape_do_irq).
  */
 struct work_handler_data {
         struct tape_device *device;
@@ -581,16 +634,16 @@ tape_3590_work_handler(struct work_struct *work)
 
         switch (p->op) {
         case TO_MSEN:
-                tape_3590_sense_medium(p->device);
+                tape_3590_sense_medium_async(p->device);
                 break;
         case TO_READ_ATTMSG:
-                tape_3590_read_attmsg(p->device);
+                tape_3590_read_attmsg_async(p->device);
                 break;
         case TO_CRYPT_ON:
-                tape_3592_enable_crypt(p->device);
+                tape_3592_enable_crypt_async(p->device);
                 break;
         case TO_CRYPT_OFF:
-                tape_3592_disable_crypt(p->device);
+                tape_3592_disable_crypt_async(p->device);
                 break;
         default:
                 DBF_EVENT(3, "T3590: work handler undefined for "
@@ -613,7 +666,7 @@ tape_3590_schedule_work(struct tape_device *device, enum tape_op op)
         p->device = tape_get_device(device);
         p->op = op;
 
-        schedule_work(&p->work);
+        queue_work(tape_3590_wq, &p->work);
         return 0;
 }
 
@@ -743,10 +796,8 @@ static void tape_3590_med_state_set(struct tape_device *device,
 static int
 tape_3590_done(struct tape_device *device, struct tape_request *request)
 {
-        struct tape_3590_disc_data *disc_data;
 
         DBF_EVENT(6, "%s done\n", tape_op_verbose[request->op]);
-        disc_data = device->discdata;
 
         switch (request->op) {
         case TO_BSB:
@@ -798,7 +849,7 @@ tape_3590_done(struct tape_device *device, struct tape_request *request)
 }
 
 /*
- * This fuction is called, when error recovery was successfull
+ * This function is called, when error recovery was successful
  */
 static inline int
 tape_3590_erp_succeded(struct tape_device *device, struct tape_request *request)
@@ -809,7 +860,7 @@ tape_3590_erp_succeded(struct tape_device *device, struct tape_request *request)
 }
 
 /*
- * This fuction is called, when error recovery was not successfull
+ * This function is called, when error recovery was not successful
  */
 static inline int
 tape_3590_erp_failed(struct tape_device *device, struct tape_request *request,
@@ -1341,17 +1392,12 @@ tape_3590_print_era_msg(struct tape_device *device, struct irb *irb)
 static int tape_3590_crypt_error(struct tape_device *device,
                                  struct tape_request *request, struct irb *irb)
 {
-        u8 cu_rc, ekm_rc1;
+        u8 cu_rc;
         u16 ekm_rc2;
-        u32 drv_rc;
-        const char *bus_id;
         char *sense;
 
         sense = ((struct tape_3590_sense *) irb->ecw)->fmt.data;
-        bus_id = dev_name(&device->cdev->dev);
         cu_rc = sense[0];
-        drv_rc = *((u32*) &sense[5]) & 0xffffff;
-        ekm_rc1 = sense[9];
         ekm_rc2 = *((u16*) &sense[10]);
         if ((cu_rc == 0) && (ekm_rc2 == 0xee31))
                 /* key not defined on EKM */
@@ -1376,7 +1422,6 @@ tape_3590_unit_check(struct tape_device *device, struct tape_request *request,
                      struct irb *irb)
 {
         struct tape_3590_sense *sense;
-        int rc;
 
 #ifdef CONFIG_S390_TAPE_BLOCK
         if (request->op == TO_BLOCK) {
@@ -1401,7 +1446,6 @@ tape_3590_unit_check(struct tape_device *device, struct tape_request *request,
          *   - "break":     basic error recovery is done
          *   - "goto out:": just print error message if available
          */
-        rc = -EIO;
         switch (sense->rc_rqc) {
 
         case 0x1110:
@@ -1629,7 +1673,7 @@ fail_kmalloc:
 static void
 tape_3590_cleanup_device(struct tape_device *device)
 {
-        flush_scheduled_work();
+        flush_workqueue(tape_3590_wq);
         tape_std_unassign(device);
 
         kfree(device->discdata);
@@ -1708,8 +1752,10 @@ tape_3590_online(struct ccw_device *cdev)
 }
 
 static struct ccw_driver tape_3590_driver = {
-        .name = "tape_3590",
-        .owner = THIS_MODULE,
+        .driver = {
+                .name = "tape_3590",
+                .owner = THIS_MODULE,
+        },
         .ids = tape_3590_ids,
         .probe = tape_generic_probe,
         .remove = tape_generic_remove,
@@ -1733,11 +1779,17 @@ tape_3590_init(void)
 #endif
 
         DBF_EVENT(3, "3590 init\n");
+
+        tape_3590_wq = alloc_workqueue("tape_3590", 0, 0);
+        if (!tape_3590_wq)
+                return -ENOMEM;
+
         /* Register driver for 3590 tapes. */
         rc = ccw_driver_register(&tape_3590_driver);
-        if (rc)
+        if (rc) {
+                destroy_workqueue(tape_3590_wq);
                 DBF_EVENT(3, "3590 init failed\n");
-        else
+        } else
                 DBF_EVENT(3, "3590 registered\n");
         return rc;
 }
@@ -1746,7 +1798,7 @@ static void
 tape_3590_exit(void)
 {
         ccw_driver_unregister(&tape_3590_driver);
-
+        destroy_workqueue(tape_3590_wq);
         debug_unregister(TAPE_DBF_AREA);
 }
 
diff --git a/drivers/s390/char/tape_block.c b/drivers/s390/char/tape_block.c
deleted file mode 100644
index 85cf607fc78f..000000000000
--- a/drivers/s390/char/tape_block.c
+++ /dev/null
@@ -1,444 +0,0 @@
-/*
- *  drivers/s390/char/tape_block.c
- *    block device frontend for tape device driver
- *
- *  S390 and zSeries version
- *    Copyright (C) 2001,2003 IBM Deutschland Entwicklung GmbH, IBM Corporation
- *    Author(s): Carsten Otte <cotte@de.ibm.com>
- *               Tuan Ngo-Anh <ngoanh@de.ibm.com>
- *               Martin Schwidefsky <schwidefsky@de.ibm.com>
- *               Stefan Bader <shbader@de.ibm.com>
- */
-
-#define KMSG_COMPONENT "tape"
-#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
-
-#include <linux/fs.h>
-#include <linux/module.h>
-#include <linux/blkdev.h>
-#include <linux/smp_lock.h>
-#include <linux/interrupt.h>
-#include <linux/buffer_head.h>
-#include <linux/kernel.h>
-
-#include <asm/debug.h>
-
-#define TAPE_DBF_AREA   tape_core_dbf
-
-#include "tape.h"
-
-#define TAPEBLOCK_MAX_SEC       100
-#define TAPEBLOCK_MIN_REQUEUE   3
-
-/*
- * 2003/11/25  Stefan Bader <shbader@de.ibm.com>
- *
- * In 2.5/2.6 the block device request function is very likely to be called
- * with disabled interrupts (e.g. generic_unplug_device). So the driver can't
- * just call any function that tries to allocate CCW requests from that con-
- * text since it might sleep. There are two choices to work around this:
- *      a) do not allocate with kmalloc but use its own memory pool
- *      b) take requests from the queue outside that context, knowing that
- *         allocation might sleep
- */
-
-/*
- * file operation structure for tape block frontend
- */
-static int tapeblock_open(struct block_device *, fmode_t);
-static int tapeblock_release(struct gendisk *, fmode_t);
-static int tapeblock_medium_changed(struct gendisk *);
-static int tapeblock_revalidate_disk(struct gendisk *);
-
-static const struct block_device_operations tapeblock_fops = {
-        .owner           = THIS_MODULE,
-        .open            = tapeblock_open,
-        .release         = tapeblock_release,
-        .media_changed   = tapeblock_medium_changed,
-        .revalidate_disk = tapeblock_revalidate_disk,
-};
-
-static int tapeblock_major = 0;
-
-static void
-tapeblock_trigger_requeue(struct tape_device *device)
-{
-        /* Protect against rescheduling. */
-        if (atomic_cmpxchg(&device->blk_data.requeue_scheduled, 0, 1) != 0)
-                return;
-        schedule_work(&device->blk_data.requeue_task);
-}
-
-/*
- * Post finished request.
- */
-static void
-__tapeblock_end_request(struct tape_request *ccw_req, void *data)
-{
-        struct tape_device *device;
-        struct request *req;
-
-        DBF_LH(6, "__tapeblock_end_request()\n");
-
-        device = ccw_req->device;
-        req = (struct request *) data;
-        blk_end_request_all(req, (ccw_req->rc == 0) ? 0 : -EIO);
-        if (ccw_req->rc == 0)
-                /* Update position. */
-                device->blk_data.block_position =
-                  (blk_rq_pos(req) + blk_rq_sectors(req)) >> TAPEBLOCK_HSEC_S2B;
-        else
-                /* We lost the position information due to an error. */
-                device->blk_data.block_position = -1;
-        device->discipline->free_bread(ccw_req);
-        if (!list_empty(&device->req_queue) ||
-            blk_peek_request(device->blk_data.request_queue))
-                tapeblock_trigger_requeue(device);
-}
-
-/*
- * Feed the tape device CCW queue with requests supplied in a list.
- */
-static int
-tapeblock_start_request(struct tape_device *device, struct request *req)
-{
-        struct tape_request *   ccw_req;
-        int                     rc;
-
-        DBF_LH(6, "tapeblock_start_request(%p, %p)\n", device, req);
-
-        ccw_req = device->discipline->bread(device, req);
-        if (IS_ERR(ccw_req)) {
-                DBF_EVENT(1, "TBLOCK: bread failed\n");
-                blk_end_request_all(req, -EIO);
-                return PTR_ERR(ccw_req);
-        }
-        ccw_req->callback = __tapeblock_end_request;
-        ccw_req->callback_data = (void *) req;
-        ccw_req->retries = TAPEBLOCK_RETRIES;
-
-        rc = tape_do_io_async(device, ccw_req);
-        if (rc) {
-                /*
-                 * Start/enqueueing failed. No retries in
-                 * this case.
-                 */
-                blk_end_request_all(req, -EIO);
-                device->discipline->free_bread(ccw_req);
-        }
-
-        return rc;
-}
-
-/*
- * Move requests from the block device request queue to the tape device ccw
- * queue.
- */
-static void
-tapeblock_requeue(struct work_struct *work) {
-        struct tape_blk_data *  blkdat;
-        struct tape_device *    device;
-        struct request_queue *  queue;
-        int                     nr_queued;
-        struct request *        req;
-        struct list_head *      l;
-        int                     rc;
-
-        blkdat = container_of(work, struct tape_blk_data, requeue_task);
-        device = blkdat->device;
-        if (!device)
-                return;
-
-        spin_lock_irq(get_ccwdev_lock(device->cdev));
-        queue  = device->blk_data.request_queue;
-
-        /* Count number of requests on ccw queue. */
-        nr_queued = 0;
-        list_for_each(l, &device->req_queue)
-                nr_queued++;
-        spin_unlock(get_ccwdev_lock(device->cdev));
-
-        spin_lock_irq(&device->blk_data.request_queue_lock);
-        while (
-                !blk_queue_plugged(queue) &&
-                blk_peek_request(queue) &&
-                nr_queued < TAPEBLOCK_MIN_REQUEUE
-        ) {
-                req = blk_fetch_request(queue);
-                if (rq_data_dir(req) == WRITE) {
-                        DBF_EVENT(1, "TBLOCK: Rejecting write request\n");
-                        spin_unlock_irq(&device->blk_data.request_queue_lock);
-                        blk_end_request_all(req, -EIO);
-                        spin_lock_irq(&device->blk_data.request_queue_lock);
-                        continue;
-                }
-                nr_queued++;
-                spin_unlock_irq(&device->blk_data.request_queue_lock);
-                rc = tapeblock_start_request(device, req);
-                spin_lock_irq(&device->blk_data.request_queue_lock);
-        }
-        spin_unlock_irq(&device->blk_data.request_queue_lock);
-        atomic_set(&device->blk_data.requeue_scheduled, 0);
-}
-
-/*
- * Tape request queue function. Called from ll_rw_blk.c
- */
-static void
-tapeblock_request_fn(struct request_queue *queue)
-{
-        struct tape_device *device;
-
-        device = (struct tape_device *) queue->queuedata;
-        DBF_LH(6, "tapeblock_request_fn(device=%p)\n", device);
-        BUG_ON(device == NULL);
-        tapeblock_trigger_requeue(device);
-}
-
-/*
- * This function is called for every new tapedevice
- */
-int
-tapeblock_setup_device(struct tape_device * device)
-{
-        struct tape_blk_data *  blkdat;
-        struct gendisk *        disk;
-        int                     rc;
-
-        blkdat = &device->blk_data;
-        blkdat->device = device;
-        spin_lock_init(&blkdat->request_queue_lock);
-        atomic_set(&blkdat->requeue_scheduled, 0);
-
-        blkdat->request_queue = blk_init_queue(
-                tapeblock_request_fn,
-                &blkdat->request_queue_lock
-        );
-        if (!blkdat->request_queue)
-                return -ENOMEM;
-
-        rc = elevator_change(blkdat->request_queue, "noop");
-        if (rc)
-                goto cleanup_queue;
-
-        blk_queue_logical_block_size(blkdat->request_queue, TAPEBLOCK_HSEC_SIZE);
-        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);
-
-        disk = alloc_disk(1);
-        if (!disk) {
-                rc = -ENOMEM;
-                goto cleanup_queue;
-        }
-
-        disk->major = tapeblock_major;
-        disk->first_minor = device->first_minor;
-        disk->fops = &tapeblock_fops;
-        disk->private_data = tape_get_device(device);
-        disk->queue = blkdat->request_queue;
-        set_capacity(disk, 0);
-        sprintf(disk->disk_name, "btibm%d",
-                device->first_minor / TAPE_MINORS_PER_DEV);
-
-        blkdat->disk = disk;
-        blkdat->medium_changed = 1;
-        blkdat->request_queue->queuedata = tape_get_device(device);
-
-        add_disk(disk);
-
-        tape_get_device(device);
-        INIT_WORK(&blkdat->requeue_task, tapeblock_requeue);
-
-        return 0;
-
-cleanup_queue:
-        blk_cleanup_queue(blkdat->request_queue);
-        blkdat->request_queue = NULL;
-
-        return rc;
-}
-
-void
-tapeblock_cleanup_device(struct tape_device *device)
-{
-        flush_scheduled_work();
-        tape_put_device(device);
-
-        if (!device->blk_data.disk) {
-                goto cleanup_queue;
-        }
-
-        del_gendisk(device->blk_data.disk);
-        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 = NULL;
-        tape_put_device(device);
-
-        blk_cleanup_queue(device->blk_data.request_queue);
-        device->blk_data.request_queue = NULL;
-}
-
-/*
- * Detect number of blocks of the tape.
- * FIXME: can we extent this to detect the blocks size as well ?
- */
-static int
-tapeblock_revalidate_disk(struct gendisk *disk)
-{
-        struct tape_device *    device;
-        unsigned int            nr_of_blks;
-        int                     rc;
-
-        device = (struct tape_device *) disk->private_data;
-        BUG_ON(!device);
-
-        if (!device->blk_data.medium_changed)
-                return 0;
-
-        rc = tape_mtop(device, MTFSFM, 1);
-        if (rc)
-                return rc;
-
-        rc = tape_mtop(device, MTTELL, 1);
-        if (rc < 0)
-                return rc;
-
-        pr_info("%s: Determining the size of the recorded area...\n",
-                dev_name(&device->cdev->dev));
-        DBF_LH(3, "Image file ends at %d\n", rc);
-        nr_of_blks = rc;
-
-        /* This will fail for the first file. Catch the error by checking the
-         * position. */
-        tape_mtop(device, MTBSF, 1);
-
-        rc = tape_mtop(device, MTTELL, 1);
-        if (rc < 0)
-                return rc;
-
-        if (rc > nr_of_blks)
-                return -EINVAL;
-
-        DBF_LH(3, "Image file starts at %d\n", rc);
-        device->bof = rc;
-        nr_of_blks -= rc;
-
-        pr_info("%s: The size of the recorded area is %i blocks\n",
-                dev_name(&device->cdev->dev), nr_of_blks);
-        set_capacity(device->blk_data.disk,
-                nr_of_blks*(TAPEBLOCK_HSEC_SIZE/512));
-
-        device->blk_data.block_position = 0;
-        device->blk_data.medium_changed = 0;
-        return 0;
-}
-
-static int
-tapeblock_medium_changed(struct gendisk *disk)
-{
-        struct tape_device *device;
-
-        device = (struct tape_device *) disk->private_data;
-        DBF_LH(6, "tapeblock_medium_changed(%p) = %d\n",
-                device, device->blk_data.medium_changed);
-
-        return device->blk_data.medium_changed;
-}
-
-/*
- * Block frontend tape device open function.
- */
-static int
-tapeblock_open(struct block_device *bdev, fmode_t mode)
-{
-        struct gendisk *        disk = bdev->bd_disk;
-        struct tape_device *    device;
-        int                     rc;
-
-        lock_kernel();
-        device = tape_get_device(disk->private_data);
-
-        if (device->required_tapemarks) {
-                DBF_EVENT(2, "TBLOCK: missing tapemarks\n");
-                pr_warning("%s: Opening the tape failed because of missing "
-                           "end-of-file marks\n", dev_name(&device->cdev->dev));
-                rc = -EPERM;
-                goto put_device;
-        }
-
-        rc = tape_open(device);
-        if (rc)
-                goto put_device;
-
-        rc = tapeblock_revalidate_disk(disk);
-        if (rc)
-                goto release;
-
-        /*
-         * Note: The reference to <device> is hold until the release function
-         *       is called.
-         */
-        tape_state_set(device, TS_BLKUSE);
-        unlock_kernel();
-        return 0;
-
-release:
-        tape_release(device);
- put_device:
-        tape_put_device(device);
-        unlock_kernel();
-        return rc;
-}
-
-/*
- * Block frontend tape device release function.
- *
- * Note: One reference to the tape device was made by the open function. So
- *       we just get the pointer here and release the reference.
- */
-static int
-tapeblock_release(struct gendisk *disk, fmode_t mode)
-{
-        struct tape_device *device = disk->private_data;
- 
-        lock_kernel();
-        tape_state_set(device, TS_IN_USE);
-        tape_release(device);
-        tape_put_device(device);
-        unlock_kernel();
-
-        return 0;
-}
-
-/*
- * Initialize block device frontend.
- */
-int
-tapeblock_init(void)
-{
-        int rc;
-
-        /* Register the tape major number to the kernel */
-        rc = register_blkdev(tapeblock_major, "tBLK");
-        if (rc < 0)
-                return rc;
-
-        if (tapeblock_major == 0)
-                tapeblock_major = rc;
-        return 0;
-}
-
-/*
- * Deregister major for block device frontend
- */
-void
-tapeblock_exit(void)
-{
-        unregister_blkdev(tapeblock_major, "tBLK");
-}
diff --git a/drivers/s390/char/tape_char.c b/drivers/s390/char/tape_char.c
index 539045acaad4..87cd0ab242de 100644
--- a/drivers/s390/char/tape_char.c
+++ b/drivers/s390/char/tape_char.c
@@ -17,7 +17,6 @@
 #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>
@@ -53,6 +52,7 @@ static const struct file_operations tape_fops =
 #endif
         .open = tapechar_open,
         .release = tapechar_release,
+        .llseek = no_llseek,
 };
 
 static int tapechar_major = TAPECHAR_MAJOR;
@@ -139,7 +139,7 @@ tapechar_read(struct file *filp, char __user *data, size_t count, loff_t *ppos)
         /*
          * If the tape isn't terminated yet, do it now. And since we then
          * are at the end of the tape there wouldn't be anything to read
-         * anyways. So we return immediatly.
+         * anyways. So we return immediately.
          */
         if(device->required_tapemarks) {
                 return tape_std_terminate_write(device);
diff --git a/drivers/s390/char/tape_class.h b/drivers/s390/char/tape_class.h
index 707b7f48c232..9e32780c317f 100644
--- a/drivers/s390/char/tape_class.h
+++ b/drivers/s390/char/tape_class.h
@@ -14,7 +14,6 @@
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/major.h>
-#include <linux/kobject.h>
 #include <linux/kobj_map.h>
 #include <linux/cdev.h>
 
diff --git a/drivers/s390/char/tape_core.c b/drivers/s390/char/tape_core.c
index 29c2d73d719d..7978a0adeaf3 100644
--- a/drivers/s390/char/tape_core.c
+++ b/drivers/s390/char/tape_core.c
@@ -14,6 +14,7 @@
 #define KMSG_COMPONENT "tape"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
+#include <linux/kernel_stat.h>
 #include <linux/module.h>
 #include <linux/init.h>      // for kernel parameters
 #include <linux/kmod.h>      // for requesting modules
@@ -209,29 +210,79 @@ tape_state_set(struct tape_device *device, enum tape_state newstate)
         wake_up(&device->state_change_wq);
 }
 
+struct tape_med_state_work_data {
+        struct tape_device *device;
+        enum tape_medium_state state;
+        struct work_struct  work;
+};
+
+static void
+tape_med_state_work_handler(struct work_struct *work)
+{
+        static char env_state_loaded[] = "MEDIUM_STATE=LOADED";
+        static char env_state_unloaded[] = "MEDIUM_STATE=UNLOADED";
+        struct tape_med_state_work_data *p =
+                container_of(work, struct tape_med_state_work_data, work);
+        struct tape_device *device = p->device;
+        char *envp[] = { NULL, NULL };
+
+        switch (p->state) {
+        case MS_UNLOADED:
+                pr_info("%s: The tape cartridge has been successfully "
+                        "unloaded\n", dev_name(&device->cdev->dev));
+                envp[0] = env_state_unloaded;
+                kobject_uevent_env(&device->cdev->dev.kobj, KOBJ_CHANGE, envp);
+                break;
+        case MS_LOADED:
+                pr_info("%s: A tape cartridge has been mounted\n",
+                        dev_name(&device->cdev->dev));
+                envp[0] = env_state_loaded;
+                kobject_uevent_env(&device->cdev->dev.kobj, KOBJ_CHANGE, envp);
+                break;
+        default:
+                break;
+        }
+        tape_put_device(device);
+        kfree(p);
+}
+
+static void
+tape_med_state_work(struct tape_device *device, enum tape_medium_state state)
+{
+        struct tape_med_state_work_data *p;
+
+        p = kzalloc(sizeof(*p), GFP_ATOMIC);
+        if (p) {
+                INIT_WORK(&p->work, tape_med_state_work_handler);
+                p->device = tape_get_device(device);
+                p->state = state;
+                schedule_work(&p->work);
+        }
+}
+
 void
 tape_med_state_set(struct tape_device *device, enum tape_medium_state newstate)
 {
-        if (device->medium_state == newstate)
+        enum tape_medium_state oldstate;
+
+        oldstate = device->medium_state;
+        if (oldstate == newstate)
                 return;
+        device->medium_state = newstate;
         switch(newstate){
         case MS_UNLOADED:
                 device->tape_generic_status |= GMT_DR_OPEN(~0);
-                if (device->medium_state == MS_LOADED)
-                        pr_info("%s: The tape cartridge has been successfully "
-                                "unloaded\n", dev_name(&device->cdev->dev));
+                if (oldstate == MS_LOADED)
+                        tape_med_state_work(device, MS_UNLOADED);
                 break;
         case MS_LOADED:
                 device->tape_generic_status &= ~GMT_DR_OPEN(~0);
-                if (device->medium_state == MS_UNLOADED)
-                        pr_info("%s: A tape cartridge has been mounted\n",
-                                dev_name(&device->cdev->dev));
+                if (oldstate == MS_UNLOADED)
+                        tape_med_state_work(device, MS_LOADED);
                 break;
         default:
-                // print nothing
                 break;
         }
-        device->medium_state = newstate;
         wake_up(&device->state_change_wq);
 }
 
@@ -1064,6 +1115,7 @@ __tape_do_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
         struct tape_request *request;
         int rc;
 
+        kstat_cpu(smp_processor_id()).irqs[IOINT_TAP]++;
         device = dev_get_drvdata(&cdev->dev);
         if (device == NULL) {
                 return;
@@ -1077,15 +1129,14 @@ __tape_do_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
                 /* FIXME: What to do with the request? */
                 switch (PTR_ERR(irb)) {
                         case -ETIMEDOUT:
-                                DBF_LH(1, "(%s): Request timed out\n",
-                                        dev_name(&cdev->dev));
+                                DBF_LH(1, "(%08x): Request timed out\n",
+                                       device->cdev_id);
                         case -EIO:
                                 __tape_end_request(device, request, -EIO);
                                 break;
                         default:
-                                DBF_LH(1, "(%s): Unexpected i/o error %li\n",
-                                        dev_name(&cdev->dev),
-                                        PTR_ERR(irb));
+                                DBF_LH(1, "(%08x): Unexpected i/o error %li\n",
+                                       device->cdev_id, PTR_ERR(irb));
                 }
                 return;
         }
diff --git a/drivers/s390/char/tape_std.c b/drivers/s390/char/tape_std.c
index 03f07e5dd6e9..e7650170274a 100644
--- a/drivers/s390/char/tape_std.c
+++ b/drivers/s390/char/tape_std.c
@@ -47,8 +47,8 @@ tape_std_assign_timeout(unsigned long data)
                         device->cdev_id);
         rc = tape_cancel_io(device, request);
         if(rc)
-                DBF_EVENT(3, "(%s): Assign timeout: Cancel failed with rc = %i\n",
-                        dev_name(&device->cdev->dev), rc);
+                DBF_EVENT(3, "(%08x): Assign timeout: Cancel failed with rc = "
+                          "%i\n", device->cdev_id, rc);
 }
 
 int
@@ -564,7 +564,6 @@ int
 tape_std_mtreten(struct tape_device *device, int mt_count)
 {
         struct tape_request *request;
-        int rc;
 
         request = tape_alloc_request(4, 0);
         if (IS_ERR(request))
@@ -576,7 +575,7 @@ tape_std_mtreten(struct tape_device *device, int mt_count)
         tape_ccw_cc(request->cpaddr + 2, NOP, 0, NULL);
         tape_ccw_end(request->cpaddr + 3, CCW_CMD_TIC, 0, request->cpaddr);
         /* execute it, MTRETEN rc gets ignored */
-        rc = tape_do_io_interruptible(device, request);
+        tape_do_io_interruptible(device, request);
         tape_free_request(request);
         return tape_mtop(device, MTREW, 1);
 }
diff --git a/drivers/s390/char/tty3270.c b/drivers/s390/char/tty3270.c
index 911822db614d..2db1482b406e 100644
--- a/drivers/s390/char/tty3270.c
+++ b/drivers/s390/char/tty3270.c
@@ -328,7 +328,7 @@ tty3270_write_callback(struct raw3270_request *rq, void *data)
 
         tp = (struct tty3270 *) rq->view;
         if (rq->rc != 0) {
-                /* Write wasn't successfull. Refresh all. */
+                /* Write wasn't successful. Refresh all. */
                 tp->update_flags = TTY_UPDATE_ALL;
                 tty3270_set_timer(tp, 1);
         }
@@ -1718,9 +1718,8 @@ tty3270_wait_until_sent(struct tty_struct *tty, int timeout)
 {
 }
 
-static int
-tty3270_ioctl(struct tty_struct *tty, struct file *file,
-              unsigned int cmd, unsigned long arg)
+static int tty3270_ioctl(struct tty_struct *tty, unsigned int cmd,
+                         unsigned long arg)
 {
         struct tty3270 *tp;
 
@@ -1729,13 +1728,12 @@ tty3270_ioctl(struct tty_struct *tty, struct file *file,
                 return -ENODEV;
         if (tty->flags & (1 << TTY_IO_ERROR))
                 return -EIO;
-        return kbd_ioctl(tp->kbd, file, cmd, arg);
+        return kbd_ioctl(tp->kbd, cmd, arg);
 }
 
 #ifdef CONFIG_COMPAT
-static long
-tty3270_compat_ioctl(struct tty_struct *tty, struct file *file,
-              unsigned int cmd, unsigned long arg)
+static long tty3270_compat_ioctl(struct tty_struct *tty,
+                                 unsigned int cmd, unsigned long arg)
 {
         struct tty3270 *tp;
 
@@ -1744,7 +1742,7 @@ tty3270_compat_ioctl(struct tty_struct *tty, struct file *file,
                 return -ENODEV;
         if (tty->flags & (1 << TTY_IO_ERROR))
                 return -EIO;
-        return kbd_ioctl(tp->kbd, file, cmd, (unsigned long)compat_ptr(arg));
+        return kbd_ioctl(tp->kbd, cmd, (unsigned long)compat_ptr(arg));
 }
 #endif
 
diff --git a/drivers/s390/char/vmcp.c b/drivers/s390/char/vmcp.c
index 04e532eec032..31a3ccbb6495 100644
--- a/drivers/s390/char/vmcp.c
+++ b/drivers/s390/char/vmcp.c
@@ -47,7 +47,7 @@ static int vmcp_release(struct inode *inode, struct file *file)
 {
         struct vmcp_session *session;
 
-        session = (struct vmcp_session *)file->private_data;
+        session = file->private_data;
         file->private_data = NULL;
         free_pages((unsigned long)session->response, get_order(session->bufsize));
         kfree(session);
@@ -94,7 +94,7 @@ vmcp_write(struct file *file, const char __user *buff, size_t count,
                 return -EFAULT;
         }
         cmd[count] = '\0';
-        session = (struct vmcp_session *)file->private_data;
+        session = file->private_data;
         if (mutex_lock_interruptible(&session->mutex)) {
                 kfree(cmd);
                 return -ERESTARTSYS;
@@ -136,7 +136,7 @@ static long vmcp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         int __user *argp;
         int temp;
 
-        session = (struct vmcp_session *)file->private_data;
+        session = file->private_data;
         if (is_compat_task())
                 argp = compat_ptr(arg);
         else
@@ -177,6 +177,7 @@ static const struct file_operations vmcp_fops = {
         .write          = vmcp_write,
         .unlocked_ioctl = vmcp_ioctl,
         .compat_ioctl   = vmcp_ioctl,
+        .llseek         = no_llseek,
 };
 
 static struct miscdevice vmcp_dev = {
diff --git a/drivers/s390/char/vmlogrdr.c b/drivers/s390/char/vmlogrdr.c
index e40a1b892866..c837d7419a6a 100644
--- a/drivers/s390/char/vmlogrdr.c
+++ b/drivers/s390/char/vmlogrdr.c
@@ -30,7 +30,6 @@
 #include <linux/kmod.h>
 #include <linux/cdev.h>
 #include <linux/device.h>
-#include <linux/smp_lock.h>
 #include <linux/string.h>
 
 MODULE_AUTHOR
@@ -97,6 +96,7 @@ static const struct file_operations vmlogrdr_fops = {
         .open    = vmlogrdr_open,
         .release = vmlogrdr_release,
         .read    = vmlogrdr_read,
+        .llseek  = no_llseek,
 };
 
 
@@ -214,7 +214,7 @@ static void vmlogrdr_iucv_message_pending(struct iucv_path *path,
 
 static int vmlogrdr_get_recording_class_AB(void)
 {
-        char cp_command[]="QUERY COMMAND RECORDING ";
+        static const char cp_command[] = "QUERY COMMAND RECORDING ";
         char cp_response[80];
         char *tail;
         int len,i;
@@ -248,27 +248,25 @@ static int vmlogrdr_recording(struct vmlogrdr_priv_t * logptr,
         char cp_command[80];
         char cp_response[160];
         char *onoff, *qid_string;
+        int rc;
 
-        memset(cp_command, 0x00, sizeof(cp_command));
-        memset(cp_response, 0x00, sizeof(cp_response));
-
-        onoff = ((action == 1) ? "ON" : "OFF");
+        onoff = ((action == 1) ? "ON" : "OFF");
         qid_string = ((recording_class_AB == 1) ? " QID * " : "");
 
-        /*
+        /*
          * The recording commands needs to be called with option QID
          * for guests that have previlege classes A or B.
          * Purging has to be done as separate step, because recording
          * can't be switched on as long as records are on the queue.
          * Doing both at the same time doesn't work.
          */
-
-        if (purge) {
+        if (purge && (action == 1)) {
+                memset(cp_command, 0x00, sizeof(cp_command));
+                memset(cp_response, 0x00, sizeof(cp_response));
                 snprintf(cp_command, sizeof(cp_command),
                          "RECORDING %s PURGE %s",
                          logptr->recording_name,
                          qid_string);
-
                 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
         }
 
@@ -278,19 +276,33 @@ static int vmlogrdr_recording(struct vmlogrdr_priv_t * logptr,
                 logptr->recording_name,
                 onoff,
                 qid_string);
-
         cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
         /* The recording command will usually answer with 'Command complete'
          * on success, but when the specific service was never connected
          * before then there might be an additional informational message
          * 'HCPCRC8072I Recording entry not found' before the
-         * 'Command complete'. So I use strstr rather then the strncmp.
+         * 'Command complete'. So I use strstr rather then the strncmp.
          */
         if (strstr(cp_response,"Command complete"))
-                return 0;
+                rc = 0;
         else
-                return -EIO;
+                rc = -EIO;
+        /*
+         * If we turn recording off, we have to purge any remaining records
+         * afterwards, as a large number of queued records may impact z/VM
+         * performance.
+         */
+        if (purge && (action == 0)) {
+                memset(cp_command, 0x00, sizeof(cp_command));
+                memset(cp_response, 0x00, sizeof(cp_response));
+                snprintf(cp_command, sizeof(cp_command),
+                         "RECORDING %s PURGE %s",
+                         logptr->recording_name,
+                         qid_string);
+                cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
+        }
 
+        return rc;
 }
 
 
@@ -637,7 +649,7 @@ static ssize_t vmlogrdr_recording_status_show(struct device_driver *driver,
                                               char *buf)
 {
 
-        char cp_command[] = "QUERY RECORDING ";
+        static const char cp_command[] = "QUERY RECORDING ";
         int len;
 
         cpcmd(cp_command, buf, 4096, NULL);
diff --git a/drivers/s390/char/vmur.c b/drivers/s390/char/vmur.c
index 1de672f21037..f6b00c3df425 100644
--- a/drivers/s390/char/vmur.c
+++ b/drivers/s390/char/vmur.c
@@ -11,9 +11,9 @@
 #define KMSG_COMPONENT "vmur"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
+#include <linux/kernel_stat.h>
 #include <linux/cdev.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 
 #include <asm/uaccess.h>
 #include <asm/cio.h>
@@ -64,8 +64,10 @@ static int ur_set_offline(struct ccw_device *cdev);
 static int ur_pm_suspend(struct ccw_device *cdev);
 
 static struct ccw_driver ur_driver = {
-        .name           = "vmur",
-        .owner          = THIS_MODULE,
+        .driver = {
+                .name   = "vmur",
+                .owner  = THIS_MODULE,
+        },
         .ids            = ur_ids,
         .probe          = ur_probe,
         .remove         = ur_remove,
@@ -303,6 +305,7 @@ static void ur_int_handler(struct ccw_device *cdev, unsigned long intparm,
 {
         struct urdev *urd;
 
+        kstat_cpu(smp_processor_id()).irqs[IOINT_VMR]++;
         TRACE("ur_int_handler: intparm=0x%lx cstat=%02x dstat=%02x res=%u\n",
               intparm, irb->scsw.cmd.cstat, irb->scsw.cmd.dstat,
               irb->scsw.cmd.count);
diff --git a/drivers/s390/char/vmwatchdog.c b/drivers/s390/char/vmwatchdog.c
index e13508c98b1a..12ef9121d4f0 100644
--- a/drivers/s390/char/vmwatchdog.c
+++ b/drivers/s390/char/vmwatchdog.c
@@ -297,6 +297,7 @@ static const struct file_operations vmwdt_fops = {
         .unlocked_ioctl = &vmwdt_ioctl,
         .write   = &vmwdt_write,
         .owner   = THIS_MODULE,
+        .llseek  = noop_llseek,
 };
 
 static struct miscdevice vmwdt_dev = {
diff --git a/drivers/s390/char/zcore.c b/drivers/s390/char/zcore.c
index f5ea3384a4b9..3b94044027c2 100644
--- a/drivers/s390/char/zcore.c
+++ b/drivers/s390/char/zcore.c
@@ -459,6 +459,7 @@ static const struct file_operations zcore_memmap_fops = {
         .read           = zcore_memmap_read,
         .open           = zcore_memmap_open,
         .release        = zcore_memmap_release,
+        .llseek         = no_llseek,
 };
 
 static ssize_t zcore_reipl_write(struct file *filp, const char __user *buf,
@@ -486,6 +487,7 @@ static const struct file_operations zcore_reipl_fops = {
         .write          = zcore_reipl_write,
         .open           = zcore_reipl_open,
         .release        = zcore_reipl_release,
+        .llseek         = no_llseek,
 };
 
 #ifdef CONFIG_32BIT
diff --git a/drivers/s390/cio/blacklist.c b/drivers/s390/cio/blacklist.c
index 13cb60162e42..76058a5166ed 100644
--- a/drivers/s390/cio/blacklist.c
+++ b/drivers/s390/cio/blacklist.c
@@ -79,17 +79,15 @@ static int pure_hex(char **cp, unsigned int *val, int min_digit,
                     int max_digit, int max_val)
 {
         int diff;
-        unsigned int value;
 
         diff = 0;
         *val = 0;
 
-        while (isxdigit(**cp) && (diff <= max_digit)) {
+        while (diff <= max_digit) {
+                int value = hex_to_bin(**cp);
 
-                if (isdigit(**cp))
-                        value = **cp - '0';
-                else
-                        value = tolower(**cp) - 'a' + 10;
+                if (value < 0)
+                        break;
                 *val = *val * 16 + value;
                 (*cp)++;
                 diff++;
diff --git a/drivers/s390/cio/ccwgroup.c b/drivers/s390/cio/ccwgroup.c
index 97b25d68e3e7..5c567414c4bb 100644
--- a/drivers/s390/cio/ccwgroup.c
+++ b/drivers/s390/cio/ccwgroup.c
@@ -67,6 +67,27 @@ __ccwgroup_remove_symlinks(struct ccwgroup_device *gdev)
 }
 
 /*
+ * Remove references from ccw devices to ccw group device and from
+ * ccw group device to ccw devices.
+ */
+static void __ccwgroup_remove_cdev_refs(struct ccwgroup_device *gdev)
+{
+        struct ccw_device *cdev;
+        int i;
+
+        for (i = 0; i < gdev->count; i++) {
+                cdev = gdev->cdev[i];
+                if (!cdev)
+                        continue;
+                spin_lock_irq(cdev->ccwlock);
+                dev_set_drvdata(&cdev->dev, NULL);
+                spin_unlock_irq(cdev->ccwlock);
+                gdev->cdev[i] = NULL;
+                put_device(&cdev->dev);
+        }
+}
+
+/*
  * Provide an 'ungroup' attribute so the user can remove group devices no
  * longer needed or accidentially created. Saves memory :)
  */
@@ -78,6 +99,7 @@ static void ccwgroup_ungroup_callback(struct device *dev)
         if (device_is_registered(&gdev->dev)) {
                 __ccwgroup_remove_symlinks(gdev);
                 device_unregister(dev);
+                __ccwgroup_remove_cdev_refs(gdev);
         }
         mutex_unlock(&gdev->reg_mutex);
 }
@@ -116,21 +138,7 @@ static DEVICE_ATTR(ungroup, 0200, NULL, ccwgroup_ungroup_store);
 static void
 ccwgroup_release (struct device *dev)
 {
-        struct ccwgroup_device *gdev;
-        int i;
-
-        gdev = to_ccwgroupdev(dev);
-
-        for (i = 0; i < gdev->count; i++) {
-                if (gdev->cdev[i]) {
-                        spin_lock_irq(gdev->cdev[i]->ccwlock);
-                        if (dev_get_drvdata(&gdev->cdev[i]->dev) == gdev)
-                                dev_set_drvdata(&gdev->cdev[i]->dev, NULL);
-                        spin_unlock_irq(gdev->cdev[i]->ccwlock);
-                        put_device(&gdev->cdev[i]->dev);
-                }
-        }
-        kfree(gdev);
+        kfree(to_ccwgroupdev(dev));
 }
 
 static int
@@ -420,7 +428,7 @@ ccwgroup_online_store (struct device *dev, struct device_attribute *attr, const
         gdev = to_ccwgroupdev(dev);
         gdrv = to_ccwgroupdrv(dev->driver);
 
-        if (!try_module_get(gdrv->owner))
+        if (!try_module_get(gdrv->driver.owner))
                 return -EINVAL;
 
         ret = strict_strtoul(buf, 0, &value);
@@ -434,7 +442,7 @@ ccwgroup_online_store (struct device *dev, struct device_attribute *attr, const
         else
                 ret = -EINVAL;
 out:
-        module_put(gdrv->owner);
+        module_put(gdrv->driver.owner);
         return (ret == 0) ? count : ret;
 }
 
@@ -608,8 +616,6 @@ int ccwgroup_driver_register(struct ccwgroup_driver *cdriver)
 {
         /* register our new driver with the core */
         cdriver->driver.bus = &ccwgroup_bus_type;
-        cdriver->driver.name = cdriver->name;
-        cdriver->driver.owner = cdriver->owner;
 
         return driver_register(&cdriver->driver);
 }
@@ -639,6 +645,7 @@ void ccwgroup_driver_unregister(struct ccwgroup_driver *cdriver)
                 mutex_lock(&gdev->reg_mutex);
                 __ccwgroup_remove_symlinks(gdev);
                 device_unregister(dev);
+                __ccwgroup_remove_cdev_refs(gdev);
                 mutex_unlock(&gdev->reg_mutex);
                 put_device(dev);
         }
@@ -660,25 +667,6 @@ int ccwgroup_probe_ccwdev(struct ccw_device *cdev)
         return 0;
 }
 
-static struct ccwgroup_device *
-__ccwgroup_get_gdev_by_cdev(struct ccw_device *cdev)
-{
-        struct ccwgroup_device *gdev;
-
-        gdev = dev_get_drvdata(&cdev->dev);
-        if (gdev) {
-                if (get_device(&gdev->dev)) {
-                        mutex_lock(&gdev->reg_mutex);
-                        if (device_is_registered(&gdev->dev))
-                                return gdev;
-                        mutex_unlock(&gdev->reg_mutex);
-                        put_device(&gdev->dev);
-                }
-                return NULL;
-        }
-        return NULL;
-}
-
 /**
  * ccwgroup_remove_ccwdev() - remove function for slave devices
  * @cdev: ccw device to be removed
@@ -694,13 +682,25 @@ void ccwgroup_remove_ccwdev(struct ccw_device *cdev)
         /* Ignore offlining errors, device is gone anyway. */
         ccw_device_set_offline(cdev);
         /* If one of its devices is gone, the whole group is done for. */
-        gdev = __ccwgroup_get_gdev_by_cdev(cdev);
-        if (gdev) {
+        spin_lock_irq(cdev->ccwlock);
+        gdev = dev_get_drvdata(&cdev->dev);
+        if (!gdev) {
+                spin_unlock_irq(cdev->ccwlock);
+                return;
+        }
+        /* Get ccwgroup device reference for local processing. */
+        get_device(&gdev->dev);
+        spin_unlock_irq(cdev->ccwlock);
+        /* Unregister group device. */
+        mutex_lock(&gdev->reg_mutex);
+        if (device_is_registered(&gdev->dev)) {
                 __ccwgroup_remove_symlinks(gdev);
                 device_unregister(&gdev->dev);
-                mutex_unlock(&gdev->reg_mutex);
-                put_device(&gdev->dev);
+                __ccwgroup_remove_cdev_refs(gdev);
         }
+        mutex_unlock(&gdev->reg_mutex);
+        /* Release ccwgroup device reference for local processing. */
+        put_device(&gdev->dev);
 }
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/s390/cio/chp.c b/drivers/s390/cio/chp.c
index 6c9fa15aac7b..2d32233943a9 100644
--- a/drivers/s390/cio/chp.c
+++ b/drivers/s390/cio/chp.c
@@ -1,7 +1,7 @@
 /*
  *  drivers/s390/cio/chp.c
  *
- *    Copyright IBM Corp. 1999,2007
+ *    Copyright IBM Corp. 1999,2010
  *    Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
  *               Arnd Bergmann (arndb@de.ibm.com)
  *               Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
@@ -54,12 +54,6 @@ static struct work_struct cfg_work;
 /* Wait queue for configure completion events. */
 static wait_queue_head_t cfg_wait_queue;
 
-/* Return channel_path struct for given chpid. */
-static inline struct channel_path *chpid_to_chp(struct chp_id chpid)
-{
-        return channel_subsystems[chpid.cssid]->chps[chpid.id];
-}
-
 /* Set vary state for given chpid. */
 static void set_chp_logically_online(struct chp_id chpid, int onoff)
 {
@@ -241,11 +235,13 @@ static ssize_t chp_status_show(struct device *dev,
                                struct device_attribute *attr, char *buf)
 {
         struct channel_path *chp = to_channelpath(dev);
+        int status;
 
-        if (!chp)
-                return 0;
-        return (chp_get_status(chp->chpid) ? sprintf(buf, "online\n") :
-                sprintf(buf, "offline\n"));
+        mutex_lock(&chp->lock);
+        status = chp->state;
+        mutex_unlock(&chp->lock);
+
+        return status ? sprintf(buf, "online\n") : sprintf(buf, "offline\n");
 }
 
 static ssize_t chp_status_write(struct device *dev,
@@ -261,15 +257,18 @@ static ssize_t chp_status_write(struct device *dev,
         if (!num_args)
                 return count;
 
-        if (!strnicmp(cmd, "on", 2) || !strcmp(cmd, "1"))
+        if (!strnicmp(cmd, "on", 2) || !strcmp(cmd, "1")) {
+                mutex_lock(&cp->lock);
                 error = s390_vary_chpid(cp->chpid, 1);
-        else if (!strnicmp(cmd, "off", 3) || !strcmp(cmd, "0"))
+                mutex_unlock(&cp->lock);
+        } else if (!strnicmp(cmd, "off", 3) || !strcmp(cmd, "0")) {
+                mutex_lock(&cp->lock);
                 error = s390_vary_chpid(cp->chpid, 0);
-        else
+                mutex_unlock(&cp->lock);
+        } else
                 error = -EINVAL;
 
         return error < 0 ? error : count;
-
 }
 
 static DEVICE_ATTR(status, 0644, chp_status_show, chp_status_write);
@@ -315,10 +314,12 @@ static ssize_t chp_type_show(struct device *dev, struct device_attribute *attr,
                              char *buf)
 {
         struct channel_path *chp = to_channelpath(dev);
+        u8 type;
 
-        if (!chp)
-                return 0;
-        return sprintf(buf, "%x\n", chp->desc.desc);
+        mutex_lock(&chp->lock);
+        type = chp->desc.desc;
+        mutex_unlock(&chp->lock);
+        return sprintf(buf, "%x\n", type);
 }
 
 static DEVICE_ATTR(type, 0444, chp_type_show, NULL);
@@ -395,6 +396,7 @@ int chp_new(struct chp_id chpid)
         chp->state = 1;
         chp->dev.parent = &channel_subsystems[chpid.cssid]->device;
         chp->dev.release = chp_release;
+        mutex_init(&chp->lock);
 
         /* Obtain channel path description and fill it in. */
         ret = chsc_determine_base_channel_path_desc(chpid, &chp->desc);
@@ -464,7 +466,10 @@ void *chp_get_chp_desc(struct chp_id chpid)
         desc = kmalloc(sizeof(struct channel_path_desc), GFP_KERNEL);
         if (!desc)
                 return NULL;
+
+        mutex_lock(&chp->lock);
         memcpy(desc, &chp->desc, sizeof(struct channel_path_desc));
+        mutex_unlock(&chp->lock);
         return desc;
 }
 
diff --git a/drivers/s390/cio/chp.h b/drivers/s390/cio/chp.h
index 26c3d2246176..12b4903d6fe3 100644
--- a/drivers/s390/cio/chp.h
+++ b/drivers/s390/cio/chp.h
@@ -1,7 +1,7 @@
 /*
  *  drivers/s390/cio/chp.h
  *
- *    Copyright IBM Corp. 2007
+ *    Copyright IBM Corp. 2007,2010
  *    Author(s): Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
  */
 
@@ -10,6 +10,7 @@
 
 #include <linux/types.h>
 #include <linux/device.h>
+#include <linux/mutex.h>
 #include <asm/chpid.h>
 #include "chsc.h"
 #include "css.h"
@@ -40,16 +41,23 @@ static inline int chp_test_bit(u8 *bitmap, int num)
 
 
 struct channel_path {
+        struct device dev;
         struct chp_id chpid;
+        struct mutex lock; /* Serialize access to below members. */
         int state;
         struct channel_path_desc desc;
         /* Channel-measurement related stuff: */
         int cmg;
         int shared;
         void *cmg_chars;
-        struct device dev;
 };
 
+/* Return channel_path struct for given chpid. */
+static inline struct channel_path *chpid_to_chp(struct chp_id chpid)
+{
+        return channel_subsystems[chpid.cssid]->chps[chpid.id];
+}
+
 int chp_get_status(struct chp_id chpid);
 u8 chp_get_sch_opm(struct subchannel *sch);
 int chp_is_registered(struct chp_id chpid);
diff --git a/drivers/s390/cio/chsc.c b/drivers/s390/cio/chsc.c
index 4cbb1a6ca33c..75c3f1f8fd43 100644
--- a/drivers/s390/cio/chsc.c
+++ b/drivers/s390/cio/chsc.c
@@ -2,7 +2,7 @@
  *  drivers/s390/cio/chsc.c
  *   S/390 common I/O routines -- channel subsystem call
  *
- *    Copyright IBM Corp. 1999,2008
+ *    Copyright IBM Corp. 1999,2010
  *    Author(s): Ingo Adlung (adlung@de.ibm.com)
  *               Cornelia Huck (cornelia.huck@de.ibm.com)
  *               Arnd Bergmann (arndb@de.ibm.com)
@@ -29,8 +29,8 @@
 #include "chsc.h"
 
 static void *sei_page;
-static DEFINE_SPINLOCK(siosl_lock);
-static DEFINE_SPINLOCK(sda_lock);
+static void *chsc_page;
+static DEFINE_SPINLOCK(chsc_page_lock);
 
 /**
  * chsc_error_from_response() - convert a chsc response to an error
@@ -85,17 +85,15 @@ struct chsc_ssd_area {
 
 int chsc_get_ssd_info(struct subchannel_id schid, struct chsc_ssd_info *ssd)
 {
-        unsigned long page;
         struct chsc_ssd_area *ssd_area;
         int ccode;
         int ret;
         int i;
         int mask;
 
-        page = get_zeroed_page(GFP_KERNEL | GFP_DMA);
-        if (!page)
-                return -ENOMEM;
-        ssd_area = (struct chsc_ssd_area *) page;
+        spin_lock_irq(&chsc_page_lock);
+        memset(chsc_page, 0, PAGE_SIZE);
+        ssd_area = chsc_page;
         ssd_area->request.length = 0x0010;
         ssd_area->request.code = 0x0004;
         ssd_area->ssid = schid.ssid;
@@ -106,25 +104,25 @@ int chsc_get_ssd_info(struct subchannel_id schid, struct chsc_ssd_info *ssd)
         /* Check response. */
         if (ccode > 0) {
                 ret = (ccode == 3) ? -ENODEV : -EBUSY;
-                goto out_free;
+                goto out;
         }
         ret = chsc_error_from_response(ssd_area->response.code);
         if (ret != 0) {
                 CIO_MSG_EVENT(2, "chsc: ssd failed for 0.%x.%04x (rc=%04x)\n",
                               schid.ssid, schid.sch_no,
                               ssd_area->response.code);
-                goto out_free;
+                goto out;
         }
         if (!ssd_area->sch_valid) {
                 ret = -ENODEV;
-                goto out_free;
+                goto out;
         }
         /* Copy data */
         ret = 0;
         memset(ssd, 0, sizeof(struct chsc_ssd_info));
         if ((ssd_area->st != SUBCHANNEL_TYPE_IO) &&
             (ssd_area->st != SUBCHANNEL_TYPE_MSG))
-                goto out_free;
+                goto out;
         ssd->path_mask = ssd_area->path_mask;
         ssd->fla_valid_mask = ssd_area->fla_valid_mask;
         for (i = 0; i < 8; i++) {
@@ -136,8 +134,8 @@ int chsc_get_ssd_info(struct subchannel_id schid, struct chsc_ssd_info *ssd)
                 if (ssd_area->fla_valid_mask & mask)
                         ssd->fla[i] = ssd_area->fla[i];
         }
-out_free:
-        free_page(page);
+out:
+        spin_unlock_irq(&chsc_page_lock);
         return ret;
 }
 
@@ -328,6 +326,36 @@ static void chsc_process_sei_res_acc(struct chsc_sei_area *sei_area)
         s390_process_res_acc(&link);
 }
 
+static void chsc_process_sei_chp_avail(struct chsc_sei_area *sei_area)
+{
+        struct channel_path *chp;
+        struct chp_id chpid;
+        u8 *data;
+        int num;
+
+        CIO_CRW_EVENT(4, "chsc: channel path availability information\n");
+        if (sei_area->rs != 0)
+                return;
+        data = sei_area->ccdf;
+        chp_id_init(&chpid);
+        for (num = 0; num <= __MAX_CHPID; num++) {
+                if (!chp_test_bit(data, num))
+                        continue;
+                chpid.id = num;
+
+                CIO_CRW_EVENT(4, "Update information for channel path "
+                              "%x.%02x\n", chpid.cssid, chpid.id);
+                chp = chpid_to_chp(chpid);
+                if (!chp) {
+                        chp_new(chpid);
+                        continue;
+                }
+                mutex_lock(&chp->lock);
+                chsc_determine_base_channel_path_desc(chpid, &chp->desc);
+                mutex_unlock(&chp->lock);
+        }
+}
+
 struct chp_config_data {
         u8 map[32];
         u8 op;
@@ -378,9 +406,12 @@ static void chsc_process_sei(struct chsc_sei_area *sei_area)
         case 1: /* link incident*/
                 chsc_process_sei_link_incident(sei_area);
                 break;
-        case 2: /* i/o resource accessibiliy */
+        case 2: /* i/o resource accessibility */
                 chsc_process_sei_res_acc(sei_area);
                 break;
+        case 7: /* channel-path-availability information */
+                chsc_process_sei_chp_avail(sei_area);
+                break;
         case 8: /* channel-path-configuration notification */
                 chsc_process_sei_chp_config(sei_area);
                 break;
@@ -497,6 +528,7 @@ __s390_vary_chpid_on(struct subchannel_id schid, void *data)
  */
 int chsc_chp_vary(struct chp_id chpid, int on)
 {
+        struct channel_path *chp = chpid_to_chp(chpid);
         struct chp_link link;
 
         memset(&link, 0, sizeof(struct chp_link));
@@ -506,11 +538,12 @@ int chsc_chp_vary(struct chp_id chpid, int on)
         /*
          * Redo PathVerification on the devices the chpid connects to
          */
-
-        if (on)
+        if (on) {
+                /* Try to update the channel path descritor. */
+                chsc_determine_base_channel_path_desc(chpid, &chp->desc);
                 for_each_subchannel_staged(s390_subchannel_vary_chpid_on,
                                            __s390_vary_chpid_on, &link);
-        else
+        } else
                 for_each_subchannel_staged(s390_subchannel_vary_chpid_off,
                                            NULL, &link);
 
@@ -552,7 +585,7 @@ cleanup:
         return ret;
 }
 
-int __chsc_do_secm(struct channel_subsystem *css, int enable, void *page)
+int __chsc_do_secm(struct channel_subsystem *css, int enable)
 {
         struct {
                 struct chsc_header request;
@@ -573,7 +606,9 @@ int __chsc_do_secm(struct channel_subsystem *css, int enable, void *page)
         } __attribute__ ((packed)) *secm_area;
         int ret, ccode;
 
-        secm_area = page;
+        spin_lock_irq(&chsc_page_lock);
+        memset(chsc_page, 0, PAGE_SIZE);
+        secm_area = chsc_page;
         secm_area->request.length = 0x0050;
         secm_area->request.code = 0x0016;
 
@@ -584,8 +619,10 @@ int __chsc_do_secm(struct channel_subsystem *css, int enable, void *page)
         secm_area->operation_code = enable ? 0 : 1;
 
         ccode = chsc(secm_area);
-        if (ccode > 0)
-                return (ccode == 3) ? -ENODEV : -EBUSY;
+        if (ccode > 0) {
+                ret = (ccode == 3) ? -ENODEV : -EBUSY;
+                goto out;
+        }
 
         switch (secm_area->response.code) {
         case 0x0102:
@@ -598,37 +635,32 @@ int __chsc_do_secm(struct channel_subsystem *css, int enable, void *page)
         if (ret != 0)
                 CIO_CRW_EVENT(2, "chsc: secm failed (rc=%04x)\n",
                               secm_area->response.code);
+out:
+        spin_unlock_irq(&chsc_page_lock);
         return ret;
 }
 
 int
 chsc_secm(struct channel_subsystem *css, int enable)
 {
-        void  *secm_area;
         int ret;
 
-        secm_area = (void *)get_zeroed_page(GFP_KERNEL |  GFP_DMA);
-        if (!secm_area)
-                return -ENOMEM;
-
         if (enable && !css->cm_enabled) {
                 css->cub_addr1 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
                 css->cub_addr2 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
                 if (!css->cub_addr1 || !css->cub_addr2) {
                         free_page((unsigned long)css->cub_addr1);
                         free_page((unsigned long)css->cub_addr2);
-                        free_page((unsigned long)secm_area);
                         return -ENOMEM;
                 }
         }
-        ret = __chsc_do_secm(css, enable, secm_area);
+        ret = __chsc_do_secm(css, enable);
         if (!ret) {
                 css->cm_enabled = enable;
                 if (css->cm_enabled) {
                         ret = chsc_add_cmg_attr(css);
                         if (ret) {
-                                memset(secm_area, 0, PAGE_SIZE);
-                                __chsc_do_secm(css, 0, secm_area);
+                                __chsc_do_secm(css, 0);
                                 css->cm_enabled = 0;
                         }
                 } else
@@ -638,44 +670,24 @@ chsc_secm(struct channel_subsystem *css, int enable)
                 free_page((unsigned long)css->cub_addr1);
                 free_page((unsigned long)css->cub_addr2);
         }
-        free_page((unsigned long)secm_area);
         return ret;
 }
 
 int chsc_determine_channel_path_desc(struct chp_id chpid, int fmt, int rfmt,
-                                     int c, int m,
-                                     struct chsc_response_struct *resp)
+                                     int c, int m, void *page)
 {
+        struct chsc_scpd *scpd_area;
         int ccode, ret;
 
-        struct {
-                struct chsc_header request;
-                u32 : 2;
-                u32 m : 1;
-                u32 c : 1;
-                u32 fmt : 4;
-                u32 cssid : 8;
-                u32 : 4;
-                u32 rfmt : 4;
-                u32 first_chpid : 8;
-                u32 : 24;
-                u32 last_chpid : 8;
-                u32 zeroes1;
-                struct chsc_header response;
-                u8 data[PAGE_SIZE - 20];
-        } __attribute__ ((packed)) *scpd_area;
-
         if ((rfmt == 1) && !css_general_characteristics.fcs)
                 return -EINVAL;
         if ((rfmt == 2) && !css_general_characteristics.cib)
                 return -EINVAL;
-        scpd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
-        if (!scpd_area)
-                return -ENOMEM;
 
+        memset(page, 0, PAGE_SIZE);
+        scpd_area = page;
         scpd_area->request.length = 0x0010;
         scpd_area->request.code = 0x0002;
-
         scpd_area->cssid = chpid.cssid;
         scpd_area->first_chpid = chpid.id;
         scpd_area->last_chpid = chpid.id;
@@ -685,20 +697,13 @@ int chsc_determine_channel_path_desc(struct chp_id chpid, int fmt, int rfmt,
         scpd_area->rfmt = rfmt;
 
         ccode = chsc(scpd_area);
-        if (ccode > 0) {
-                ret = (ccode == 3) ? -ENODEV : -EBUSY;
-                goto out;
-        }
+        if (ccode > 0)
+                return (ccode == 3) ? -ENODEV : -EBUSY;
 
         ret = chsc_error_from_response(scpd_area->response.code);
-        if (ret == 0)
-                /* Success. */
-                memcpy(resp, &scpd_area->response, scpd_area->response.length);
-        else
+        if (ret)
                 CIO_CRW_EVENT(2, "chsc: scpd failed (rc=%04x)\n",
                               scpd_area->response.code);
-out:
-        free_page((unsigned long)scpd_area);
         return ret;
 }
 EXPORT_SYMBOL_GPL(chsc_determine_channel_path_desc);
@@ -707,17 +712,38 @@ int chsc_determine_base_channel_path_desc(struct chp_id chpid,
                                           struct channel_path_desc *desc)
 {
         struct chsc_response_struct *chsc_resp;
+        struct chsc_scpd *scpd_area;
+        unsigned long flags;
         int ret;
 
-        chsc_resp = kzalloc(sizeof(*chsc_resp), GFP_KERNEL);
-        if (!chsc_resp)
-                return -ENOMEM;
-        ret = chsc_determine_channel_path_desc(chpid, 0, 0, 0, 0, chsc_resp);
+        spin_lock_irqsave(&chsc_page_lock, flags);
+        scpd_area = chsc_page;
+        ret = chsc_determine_channel_path_desc(chpid, 0, 0, 0, 0, scpd_area);
+        if (ret)
+                goto out;
+        chsc_resp = (void *)&scpd_area->response;
+        memcpy(desc, &chsc_resp->data, sizeof(*desc));
+out:
+        spin_unlock_irqrestore(&chsc_page_lock, flags);
+        return ret;
+}
+
+int chsc_determine_fmt1_channel_path_desc(struct chp_id chpid,
+                                          struct channel_path_desc_fmt1 *desc)
+{
+        struct chsc_response_struct *chsc_resp;
+        struct chsc_scpd *scpd_area;
+        int ret;
+
+        spin_lock_irq(&chsc_page_lock);
+        scpd_area = chsc_page;
+        ret = chsc_determine_channel_path_desc(chpid, 0, 0, 1, 0, scpd_area);
         if (ret)
-                goto out_free;
+                goto out;
+        chsc_resp = (void *)&scpd_area->response;
         memcpy(desc, &chsc_resp->data, sizeof(*desc));
-out_free:
-        kfree(chsc_resp);
+out:
+        spin_unlock_irq(&chsc_page_lock);
         return ret;
 }
 
@@ -725,33 +751,22 @@ static void
 chsc_initialize_cmg_chars(struct channel_path *chp, u8 cmcv,
                           struct cmg_chars *chars)
 {
-        switch (chp->cmg) {
-        case 2:
-        case 3:
-                chp->cmg_chars = kmalloc(sizeof(struct cmg_chars),
-                                         GFP_KERNEL);
-                if (chp->cmg_chars) {
-                        int i, mask;
-                        struct cmg_chars *cmg_chars;
-
-                        cmg_chars = chp->cmg_chars;
-                        for (i = 0; i < NR_MEASUREMENT_CHARS; i++) {
-                                mask = 0x80 >> (i + 3);
-                                if (cmcv & mask)
-                                        cmg_chars->values[i] = chars->values[i];
-                                else
-                                        cmg_chars->values[i] = 0;
-                        }
-                }
-                break;
-        default:
-                /* No cmg-dependent data. */
-                break;
+        struct cmg_chars *cmg_chars;
+        int i, mask;
+
+        cmg_chars = chp->cmg_chars;
+        for (i = 0; i < NR_MEASUREMENT_CHARS; i++) {
+                mask = 0x80 >> (i + 3);
+                if (cmcv & mask)
+                        cmg_chars->values[i] = chars->values[i];
+                else
+                        cmg_chars->values[i] = 0;
         }
 }
 
 int chsc_get_channel_measurement_chars(struct channel_path *chp)
 {
+        struct cmg_chars *cmg_chars;
         int ccode, ret;
 
         struct {
@@ -775,13 +790,16 @@ int chsc_get_channel_measurement_chars(struct channel_path *chp)
                 u32 data[NR_MEASUREMENT_CHARS];
         } __attribute__ ((packed)) *scmc_area;
 
-        scmc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
-        if (!scmc_area)
+        chp->cmg_chars = NULL;
+        cmg_chars = kmalloc(sizeof(*cmg_chars), GFP_KERNEL);
+        if (!cmg_chars)
                 return -ENOMEM;
 
+        spin_lock_irq(&chsc_page_lock);
+        memset(chsc_page, 0, PAGE_SIZE);
+        scmc_area = chsc_page;
         scmc_area->request.length = 0x0010;
         scmc_area->request.code = 0x0022;
-
         scmc_area->first_chpid = chp->chpid.id;
         scmc_area->last_chpid = chp->chpid.id;
 
@@ -792,53 +810,65 @@ int chsc_get_channel_measurement_chars(struct channel_path *chp)
         }
 
         ret = chsc_error_from_response(scmc_area->response.code);
-        if (ret == 0) {
-                /* Success. */
-                if (!scmc_area->not_valid) {
-                        chp->cmg = scmc_area->cmg;
-                        chp->shared = scmc_area->shared;
-                        chsc_initialize_cmg_chars(chp, scmc_area->cmcv,
-                                                  (struct cmg_chars *)
-                                                  &scmc_area->data);
-                } else {
-                        chp->cmg = -1;
-                        chp->shared = -1;
-                }
-        } else {
+        if (ret) {
                 CIO_CRW_EVENT(2, "chsc: scmc failed (rc=%04x)\n",
                               scmc_area->response.code);
+                goto out;
+        }
+        if (scmc_area->not_valid) {
+                chp->cmg = -1;
+                chp->shared = -1;
+                goto out;
         }
+        chp->cmg = scmc_area->cmg;
+        chp->shared = scmc_area->shared;
+        if (chp->cmg != 2 && chp->cmg != 3) {
+                /* No cmg-dependent data. */
+                goto out;
+        }
+        chp->cmg_chars = cmg_chars;
+        chsc_initialize_cmg_chars(chp, scmc_area->cmcv,
+                                  (struct cmg_chars *) &scmc_area->data);
 out:
-        free_page((unsigned long)scmc_area);
+        spin_unlock_irq(&chsc_page_lock);
+        if (!chp->cmg_chars)
+                kfree(cmg_chars);
+
         return ret;
 }
 
-int __init chsc_alloc_sei_area(void)
+int __init chsc_init(void)
 {
         int ret;
 
         sei_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
-        if (!sei_page) {
-                CIO_MSG_EVENT(0, "Can't allocate page for processing of "
-                              "chsc machine checks!\n");
-                return -ENOMEM;
+        chsc_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
+        if (!sei_page || !chsc_page) {
+                ret = -ENOMEM;
+                goto out_err;
         }
         ret = crw_register_handler(CRW_RSC_CSS, chsc_process_crw);
         if (ret)
-                kfree(sei_page);
+                goto out_err;
+        return ret;
+out_err:
+        free_page((unsigned long)chsc_page);
+        free_page((unsigned long)sei_page);
         return ret;
 }
 
-void __init chsc_free_sei_area(void)
+void __init chsc_init_cleanup(void)
 {
         crw_unregister_handler(CRW_RSC_CSS);
-        kfree(sei_page);
+        free_page((unsigned long)chsc_page);
+        free_page((unsigned long)sei_page);
 }
 
 int chsc_enable_facility(int operation_code)
 {
+        unsigned long flags;
         int ret;
-        static struct {
+        struct {
                 struct chsc_header request;
                 u8 reserved1:4;
                 u8 format:4;
@@ -851,32 +881,33 @@ int chsc_enable_facility(int operation_code)
                 u32 reserved5:4;
                 u32 format2:4;
                 u32 reserved6:24;
-        } __attribute__ ((packed, aligned(4096))) sda_area;
+        } __attribute__ ((packed)) *sda_area;
 
-        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;
+        spin_lock_irqsave(&chsc_page_lock, flags);
+        memset(chsc_page, 0, PAGE_SIZE);
+        sda_area = chsc_page;
+        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);
- out:
-        spin_unlock(&sda_lock);
+                              operation_code, sda_area->response.code);
+out:
+        spin_unlock_irqrestore(&chsc_page_lock, flags);
         return ret;
 }
 
@@ -895,13 +926,12 @@ chsc_determine_css_characteristics(void)
                 struct chsc_header response;
                 u32 reserved4;
                 u32 general_char[510];
-                u32 chsc_char[518];
+                u32 chsc_char[508];
         } __attribute__ ((packed)) *scsc_area;
 
-        scsc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
-        if (!scsc_area)
-                return -ENOMEM;
-
+        spin_lock_irq(&chsc_page_lock);
+        memset(chsc_page, 0, PAGE_SIZE);
+        scsc_area = chsc_page;
         scsc_area->request.length = 0x0010;
         scsc_area->request.code = 0x0010;
 
@@ -921,7 +951,7 @@ chsc_determine_css_characteristics(void)
                 CIO_CRW_EVENT(2, "chsc: scsc failed (rc=%04x)\n",
                               scsc_area->response.code);
 exit:
-        free_page ((unsigned long) scsc_area);
+        spin_unlock_irq(&chsc_page_lock);
         return result;
 }
 
@@ -976,29 +1006,29 @@ int chsc_sstpi(void *page, void *result, size_t size)
         return (rr->response.code == 0x0001) ? 0 : -EIO;
 }
 
-static struct {
-        struct chsc_header request;
-        u32 word1;
-        struct subchannel_id sid;
-        u32 word3;
-        struct chsc_header response;
-        u32 word[11];
-} __attribute__ ((packed)) siosl_area __attribute__ ((__aligned__(PAGE_SIZE)));
-
 int chsc_siosl(struct subchannel_id schid)
 {
+        struct {
+                struct chsc_header request;
+                u32 word1;
+                struct subchannel_id sid;
+                u32 word3;
+                struct chsc_header response;
+                u32 word[11];
+        } __attribute__ ((packed)) *siosl_area;
         unsigned long flags;
         int ccode;
         int rc;
 
-        spin_lock_irqsave(&siosl_lock, flags);
-        memset(&siosl_area, 0, sizeof(siosl_area));
-        siosl_area.request.length = 0x0010;
-        siosl_area.request.code = 0x0046;
-        siosl_area.word1 = 0x80000000;
-        siosl_area.sid = schid;
+        spin_lock_irqsave(&chsc_page_lock, flags);
+        memset(chsc_page, 0, PAGE_SIZE);
+        siosl_area = chsc_page;
+        siosl_area->request.length = 0x0010;
+        siosl_area->request.code = 0x0046;
+        siosl_area->word1 = 0x80000000;
+        siosl_area->sid = schid;
 
-        ccode = chsc(&siosl_area);
+        ccode = chsc(siosl_area);
         if (ccode > 0) {
                 if (ccode == 3)
                         rc = -ENODEV;
@@ -1008,17 +1038,16 @@ int chsc_siosl(struct subchannel_id schid)
                               schid.ssid, schid.sch_no, ccode);
                 goto out;
         }
-        rc = chsc_error_from_response(siosl_area.response.code);
+        rc = chsc_error_from_response(siosl_area->response.code);
         if (rc)
                 CIO_MSG_EVENT(2, "chsc: siosl failed for 0.%x.%04x (rc=%04x)\n",
                               schid.ssid, schid.sch_no,
-                              siosl_area.response.code);
+                              siosl_area->response.code);
         else
                 CIO_MSG_EVENT(4, "chsc: siosl succeeded for 0.%x.%04x\n",
                               schid.ssid, schid.sch_no);
 out:
-        spin_unlock_irqrestore(&siosl_lock, flags);
-
+        spin_unlock_irqrestore(&chsc_page_lock, flags);
         return rc;
 }
 EXPORT_SYMBOL_GPL(chsc_siosl);
diff --git a/drivers/s390/cio/chsc.h b/drivers/s390/cio/chsc.h
index 5453013f094b..3f15b2aaeaea 100644
--- a/drivers/s390/cio/chsc.h
+++ b/drivers/s390/cio/chsc.h
@@ -35,6 +35,22 @@ struct channel_path_desc {
         u8 chpp;
 } __attribute__ ((packed));
 
+struct channel_path_desc_fmt1 {
+        u8 flags;
+        u8 lsn;
+        u8 desc;
+        u8 chpid;
+        u32:24;
+        u8 chpp;
+        u32 unused[3];
+        u16 mdc;
+        u16:13;
+        u8 r:1;
+        u8 s:1;
+        u8 f:1;
+        u32 zeros[2];
+} __attribute__ ((packed));
+
 struct channel_path;
 
 struct css_chsc_char {
@@ -57,23 +73,43 @@ struct chsc_ssd_info {
         struct chp_id chpid[8];
         u16 fla[8];
 };
+
+struct chsc_scpd {
+        struct chsc_header request;
+        u32:2;
+        u32 m:1;
+        u32 c:1;
+        u32 fmt:4;
+        u32 cssid:8;
+        u32:4;
+        u32 rfmt:4;
+        u32 first_chpid:8;
+        u32:24;
+        u32 last_chpid:8;
+        u32 zeroes1;
+        struct chsc_header response;
+        u8 data[PAGE_SIZE - 20];
+} __attribute__ ((packed));
+
+
 extern int chsc_get_ssd_info(struct subchannel_id schid,
                              struct chsc_ssd_info *ssd);
 extern int chsc_determine_css_characteristics(void);
-extern int chsc_alloc_sei_area(void);
-extern void chsc_free_sei_area(void);
+extern int chsc_init(void);
+extern void chsc_init_cleanup(void);
 
 extern int chsc_enable_facility(int);
 struct channel_subsystem;
 extern int chsc_secm(struct channel_subsystem *, int);
-int __chsc_do_secm(struct channel_subsystem *css, int enable, void *page);
+int __chsc_do_secm(struct channel_subsystem *css, int enable);
 
 int chsc_chp_vary(struct chp_id chpid, int on);
 int chsc_determine_channel_path_desc(struct chp_id chpid, int fmt, int rfmt,
-                                     int c, int m,
-                                     struct chsc_response_struct *resp);
+                                     int c, int m, void *page);
 int chsc_determine_base_channel_path_desc(struct chp_id chpid,
                                           struct channel_path_desc *desc);
+int chsc_determine_fmt1_channel_path_desc(struct chp_id chpid,
+                                          struct channel_path_desc_fmt1 *desc);
 void chsc_chp_online(struct chp_id chpid);
 void chsc_chp_offline(struct chp_id chpid);
 int chsc_get_channel_measurement_chars(struct channel_path *chp);
diff --git a/drivers/s390/cio/chsc_sch.c b/drivers/s390/cio/chsc_sch.c
index a83877c664a6..e950f1ad4dd1 100644
--- a/drivers/s390/cio/chsc_sch.c
+++ b/drivers/s390/cio/chsc_sch.c
@@ -50,7 +50,7 @@ MODULE_LICENSE("GPL");
 
 static void chsc_subchannel_irq(struct subchannel *sch)
 {
-        struct chsc_private *private = sch->private;
+        struct chsc_private *private = dev_get_drvdata(&sch->dev);
         struct chsc_request *request = private->request;
         struct irb *irb = (struct irb *)&S390_lowcore.irb;
 
@@ -80,13 +80,14 @@ static int chsc_subchannel_probe(struct subchannel *sch)
         private = kzalloc(sizeof(*private), GFP_KERNEL);
         if (!private)
                 return -ENOMEM;
+        dev_set_drvdata(&sch->dev, private);
         ret = cio_enable_subchannel(sch, (u32)(unsigned long)sch);
         if (ret) {
                 CHSC_MSG(0, "Failed to enable 0.%x.%04x: %d\n",
                          sch->schid.ssid, sch->schid.sch_no, ret);
+                dev_set_drvdata(&sch->dev, NULL);
                 kfree(private);
         } else {
-                sch->private = private;
                 if (dev_get_uevent_suppress(&sch->dev)) {
                         dev_set_uevent_suppress(&sch->dev, 0);
                         kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
@@ -100,8 +101,8 @@ static int chsc_subchannel_remove(struct subchannel *sch)
         struct chsc_private *private;
 
         cio_disable_subchannel(sch);
-        private = sch->private;
-        sch->private = NULL;
+        private = dev_get_drvdata(&sch->dev);
+        dev_set_drvdata(&sch->dev, NULL);
         if (private->request) {
                 complete(&private->request->completion);
                 put_device(&sch->dev);
@@ -147,7 +148,10 @@ static struct css_device_id chsc_subchannel_ids[] = {
 MODULE_DEVICE_TABLE(css, chsc_subchannel_ids);
 
 static struct css_driver chsc_subchannel_driver = {
-        .owner = THIS_MODULE,
+        .drv = {
+                .owner = THIS_MODULE,
+                .name = "chsc_subchannel",
+        },
         .subchannel_type = chsc_subchannel_ids,
         .irq = chsc_subchannel_irq,
         .probe = chsc_subchannel_probe,
@@ -157,7 +161,6 @@ static struct css_driver chsc_subchannel_driver = {
         .freeze = chsc_subchannel_freeze,
         .thaw = chsc_subchannel_restore,
         .restore = chsc_subchannel_restore,
-        .name = "chsc_subchannel",
 };
 
 static int __init chsc_init_dbfs(void)
@@ -241,7 +244,7 @@ static int chsc_async(struct chsc_async_area *chsc_area,
         chsc_area->header.key = PAGE_DEFAULT_KEY >> 4;
         while ((sch = chsc_get_next_subchannel(sch))) {
                 spin_lock(sch->lock);
-                private = sch->private;
+                private = dev_get_drvdata(&sch->dev);
                 if (private->request) {
                         spin_unlock(sch->lock);
                         ret = -EBUSY;
@@ -688,25 +691,31 @@ out_free:
 
 static int chsc_ioctl_chpd(void __user *user_chpd)
 {
+        struct chsc_scpd *scpd_area;
         struct chsc_cpd_info *chpd;
         int ret;
 
         chpd = kzalloc(sizeof(*chpd), GFP_KERNEL);
-        if (!chpd)
-                return -ENOMEM;
+        scpd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
+        if (!scpd_area || !chpd) {
+                ret = -ENOMEM;
+                goto out_free;
+        }
         if (copy_from_user(chpd, user_chpd, sizeof(*chpd))) {
                 ret = -EFAULT;
                 goto out_free;
         }
         ret = chsc_determine_channel_path_desc(chpd->chpid, chpd->fmt,
                                                chpd->rfmt, chpd->c, chpd->m,
-                                               &chpd->chpdb);
+                                               scpd_area);
         if (ret)
                 goto out_free;
+        memcpy(&chpd->chpdb, &scpd_area->response, scpd_area->response.length);
         if (copy_to_user(user_chpd, chpd, sizeof(*chpd)))
                 ret = -EFAULT;
 out_free:
         kfree(chpd);
+        free_page((unsigned long)scpd_area);
         return ret;
 }
 
@@ -806,6 +815,7 @@ static const struct file_operations chsc_fops = {
         .open = nonseekable_open,
         .unlocked_ioctl = chsc_ioctl,
         .compat_ioctl = chsc_ioctl,
+        .llseek = no_llseek,
 };
 
 static struct miscdevice chsc_misc_device = {
diff --git a/drivers/s390/cio/cio.c b/drivers/s390/cio/cio.c
index f4e6cf3aceb8..cbde448f9947 100644
--- a/drivers/s390/cio/cio.c
+++ b/drivers/s390/cio/cio.c
@@ -84,29 +84,14 @@ out_unregister:
 
 arch_initcall (cio_debug_init);
 
-int
-cio_set_options (struct subchannel *sch, int flags)
+int cio_set_options(struct subchannel *sch, int flags)
 {
-       sch->options.suspend = (flags & DOIO_ALLOW_SUSPEND) != 0;
-       sch->options.prefetch = (flags & DOIO_DENY_PREFETCH) != 0;
-       sch->options.inter = (flags & DOIO_SUPPRESS_INTER) != 0;
-       return 0;
-}
+        struct io_subchannel_private *priv = to_io_private(sch);
 
-/* FIXME: who wants to use this? */
-int
-cio_get_options (struct subchannel *sch)
-{
-       int flags;
-
-       flags = 0;
-       if (sch->options.suspend)
-                flags |= DOIO_ALLOW_SUSPEND;
-       if (sch->options.prefetch)
-                flags |= DOIO_DENY_PREFETCH;
-       if (sch->options.inter)
-                flags |= DOIO_SUPPRESS_INTER;
-       return flags;
+        priv->options.suspend = (flags & DOIO_ALLOW_SUSPEND) != 0;
+        priv->options.prefetch = (flags & DOIO_DENY_PREFETCH) != 0;
+        priv->options.inter = (flags & DOIO_SUPPRESS_INTER) != 0;
+        return 0;
 }
 
 static int
@@ -139,21 +124,21 @@ cio_start_key (struct subchannel *sch,	/* subchannel structure */
                __u8 lpm,                /* logical path mask */
                __u8 key)                /* storage key */
 {
+        struct io_subchannel_private *priv = to_io_private(sch);
+        union orb *orb = &priv->orb;
         int ccode;
-        union orb *orb;
 
         CIO_TRACE_EVENT(5, "stIO");
         CIO_TRACE_EVENT(5, dev_name(&sch->dev));
 
-        orb = &to_io_private(sch)->orb;
         memset(orb, 0, sizeof(union orb));
         /* sch is always under 2G. */
         orb->cmd.intparm = (u32)(addr_t)sch;
         orb->cmd.fmt = 1;
 
-        orb->cmd.pfch = sch->options.prefetch == 0;
-        orb->cmd.spnd = sch->options.suspend;
-        orb->cmd.ssic = sch->options.suspend && sch->options.inter;
+        orb->cmd.pfch = priv->options.prefetch == 0;
+        orb->cmd.spnd = priv->options.suspend;
+        orb->cmd.ssic = priv->options.suspend && priv->options.inter;
         orb->cmd.lpm = (lpm != 0) ? lpm : sch->lpm;
 #ifdef CONFIG_64BIT
         /*
@@ -619,7 +604,7 @@ void __irq_entry do_IRQ(struct pt_regs *regs)
         s390_idle_check(regs, S390_lowcore.int_clock,
                         S390_lowcore.async_enter_timer);
         irq_enter();
-        __get_cpu_var(s390_idle).nohz_delay = 1;
+        __this_cpu_write(s390_idle.nohz_delay, 1);
         if (S390_lowcore.int_clock >= S390_lowcore.clock_comparator)
                 /* Serve timer interrupts first. */
                 clock_comparator_work();
@@ -630,11 +615,7 @@ void __irq_entry do_IRQ(struct pt_regs *regs)
         irb = (struct irb *)&S390_lowcore.irb;
         do {
                 kstat_cpu(smp_processor_id()).irqs[IO_INTERRUPT]++;
-                /*
-                 * Non I/O-subchannel thin interrupts are processed differently
-                 */
-                if (tpi_info->adapter_IO == 1 &&
-                    tpi_info->int_type == IO_INTERRUPT_TYPE) {
+                if (tpi_info->adapter_IO) {
                         do_adapter_IO(tpi_info->isc);
                         continue;
                 }
diff --git a/drivers/s390/cio/cio.h b/drivers/s390/cio/cio.h
index bf7f80f5a330..155a82bcb9e5 100644
--- a/drivers/s390/cio/cio.h
+++ b/drivers/s390/cio/cio.h
@@ -84,13 +84,6 @@ struct subchannel {
                 SUBCHANNEL_TYPE_MSG = 2,
                 SUBCHANNEL_TYPE_ADM = 3,
         } st;                   /* subchannel type */
-
-        struct {
-                unsigned int suspend:1; /* allow suspend */
-                unsigned int prefetch:1;/* deny prefetch */
-                unsigned int inter:1;   /* suppress intermediate interrupts */
-        } __attribute__ ((packed)) options;
-
         __u8 vpm;               /* verified path mask */
         __u8 lpm;               /* logical path mask */
         __u8 opm;               /* operational path mask */
@@ -99,14 +92,11 @@ struct subchannel {
         struct chsc_ssd_info ssd_info;  /* subchannel description */
         struct device dev;      /* entry in device tree */
         struct css_driver *driver;
-        void *private; /* private per subchannel type data */
         enum sch_todo todo;
         struct work_struct todo_work;
         struct schib_config config;
 } __attribute__ ((aligned(8)));
 
-#define IO_INTERRUPT_TYPE          0 /* I/O interrupt type */
-
 #define to_subchannel(n) container_of(n, struct subchannel, dev)
 
 extern int cio_validate_subchannel (struct subchannel *, struct subchannel_id);
@@ -120,7 +110,6 @@ extern int cio_start (struct subchannel *, struct ccw1 *, __u8);
 extern int cio_start_key (struct subchannel *, struct ccw1 *, __u8, __u8);
 extern int cio_cancel (struct subchannel *);
 extern int cio_set_options (struct subchannel *, int);
-extern int cio_get_options (struct subchannel *);
 extern int cio_update_schib(struct subchannel *sch);
 extern int cio_commit_config(struct subchannel *sch);
 
diff --git a/drivers/s390/cio/css.c b/drivers/s390/cio/css.c
index ac94ac751459..c47b25fd3f43 100644
--- a/drivers/s390/cio/css.c
+++ b/drivers/s390/cio/css.c
@@ -1,7 +1,7 @@
 /*
  * driver for channel subsystem
  *
- * Copyright IBM Corp. 2002, 2009
+ * Copyright IBM Corp. 2002, 2010
  *
  * Author(s): Arnd Bergmann (arndb@de.ibm.com)
  *            Cornelia Huck (cornelia.huck@de.ibm.com)
@@ -35,6 +35,7 @@ int css_init_done = 0;
 int max_ssid;
 
 struct channel_subsystem *channel_subsystems[__MAX_CSSID + 1];
+static struct bus_type css_bus_type;
 
 int
 for_each_subchannel(int(*fn)(struct subchannel_id, void *), void *data)
@@ -577,7 +578,7 @@ static int __unset_registered(struct device *dev, void *data)
         return 0;
 }
 
-void css_schedule_eval_all_unreg(void)
+static void css_schedule_eval_all_unreg(void)
 {
         unsigned long flags;
         struct idset *unreg_set;
@@ -618,6 +619,7 @@ EXPORT_SYMBOL_GPL(css_schedule_reprobe);
 static void css_process_crw(struct crw *crw0, struct crw *crw1, int overflow)
 {
         struct subchannel_id mchk_schid;
+        struct subchannel *sch;
 
         if (overflow) {
                 css_schedule_eval_all();
@@ -635,8 +637,15 @@ static void css_process_crw(struct crw *crw0, struct crw *crw1, int overflow)
         init_subchannel_id(&mchk_schid);
         mchk_schid.sch_no = crw0->rsid;
         if (crw1)
-                mchk_schid.ssid = (crw1->rsid >> 8) & 3;
+                mchk_schid.ssid = (crw1->rsid >> 4) & 3;
 
+        if (crw0->erc == CRW_ERC_PMOD) {
+                sch = get_subchannel_by_schid(mchk_schid);
+                if (sch) {
+                        css_update_ssd_info(sch);
+                        put_device(&sch->dev);
+                }
+        }
         /*
          * Since we are always presented with IPI in the CRW, we have to
          * use stsch() to find out if the subchannel in question has come
@@ -790,7 +799,6 @@ static struct notifier_block css_reboot_notifier = {
 static int css_power_event(struct notifier_block *this, unsigned long event,
                            void *ptr)
 {
-        void *secm_area;
         int ret, i;
 
         switch (event) {
@@ -806,15 +814,8 @@ static int css_power_event(struct notifier_block *this, unsigned long event,
                                 mutex_unlock(&css->mutex);
                                 continue;
                         }
-                        secm_area = (void *)get_zeroed_page(GFP_KERNEL |
-                                                            GFP_DMA);
-                        if (secm_area) {
-                                if (__chsc_do_secm(css, 0, secm_area))
-                                        ret = NOTIFY_BAD;
-                                free_page((unsigned long)secm_area);
-                        } else
+                        if (__chsc_do_secm(css, 0))
                                 ret = NOTIFY_BAD;
-
                         mutex_unlock(&css->mutex);
                 }
                 break;
@@ -830,15 +831,8 @@ static int css_power_event(struct notifier_block *this, unsigned long event,
                                 mutex_unlock(&css->mutex);
                                 continue;
                         }
-                        secm_area = (void *)get_zeroed_page(GFP_KERNEL |
-                                                            GFP_DMA);
-                        if (secm_area) {
-                                if (__chsc_do_secm(css, 1, secm_area))
-                                        ret = NOTIFY_BAD;
-                                free_page((unsigned long)secm_area);
-                        } else
+                        if (__chsc_do_secm(css, 1))
                                 ret = NOTIFY_BAD;
-
                         mutex_unlock(&css->mutex);
                 }
                 /* search for subchannels, which appeared during hibernation */
@@ -863,14 +857,11 @@ static int __init css_bus_init(void)
 {
         int ret, i;
 
-        ret = chsc_determine_css_characteristics();
-        if (ret == -ENOMEM)
-                goto out;
-
-        ret = chsc_alloc_sei_area();
+        ret = chsc_init();
         if (ret)
-                goto out;
+                return ret;
 
+        chsc_determine_css_characteristics();
         /* Try to enable MSS. */
         ret = chsc_enable_facility(CHSC_SDA_OC_MSS);
         if (ret)
@@ -956,9 +947,9 @@ out_unregister:
         }
         bus_unregister(&css_bus_type);
 out:
-        crw_unregister_handler(CRW_RSC_CSS);
-        chsc_free_sei_area();
+        crw_unregister_handler(CRW_RSC_SCH);
         idset_free(slow_subchannel_set);
+        chsc_init_cleanup();
         pr_alert("The CSS device driver initialization failed with "
                  "errno=%d\n", ret);
         return ret;
@@ -978,9 +969,9 @@ static void __init css_bus_cleanup(void)
                 device_unregister(&css->device);
         }
         bus_unregister(&css_bus_type);
-        crw_unregister_handler(CRW_RSC_CSS);
-        chsc_free_sei_area();
+        crw_unregister_handler(CRW_RSC_SCH);
         idset_free(slow_subchannel_set);
+        chsc_init_cleanup();
         isc_unregister(IO_SCH_ISC);
 }
 
@@ -1048,7 +1039,16 @@ subsys_initcall_sync(channel_subsystem_init_sync);
 
 void channel_subsystem_reinit(void)
 {
+        struct channel_path *chp;
+        struct chp_id chpid;
+
         chsc_enable_facility(CHSC_SDA_OC_MSS);
+        chp_id_for_each(&chpid) {
+                chp = chpid_to_chp(chpid);
+                if (!chp)
+                        continue;
+                chsc_determine_base_channel_path_desc(chpid, &chp->desc);
+        }
 }
 
 #ifdef CONFIG_PROC_FS
@@ -1067,6 +1067,7 @@ static ssize_t cio_settle_write(struct file *file, const char __user *buf,
 static const struct file_operations cio_settle_proc_fops = {
         .open = nonseekable_open,
         .write = cio_settle_write,
+        .llseek = no_llseek,
 };
 
 static int __init cio_settle_init(void)
@@ -1199,6 +1200,7 @@ static int css_pm_restore(struct device *dev)
         struct subchannel *sch = to_subchannel(dev);
         struct css_driver *drv;
 
+        css_update_ssd_info(sch);
         if (!sch->dev.driver)
                 return 0;
         drv = to_cssdriver(sch->dev.driver);
@@ -1213,7 +1215,7 @@ static const struct dev_pm_ops css_pm_ops = {
         .restore = css_pm_restore,
 };
 
-struct bus_type css_bus_type = {
+static struct bus_type css_bus_type = {
         .name     = "css",
         .match    = css_bus_match,
         .probe    = css_probe,
@@ -1232,9 +1234,7 @@ struct bus_type css_bus_type = {
  */
 int css_driver_register(struct css_driver *cdrv)
 {
-        cdrv->drv.name = cdrv->name;
         cdrv->drv.bus = &css_bus_type;
-        cdrv->drv.owner = cdrv->owner;
         return driver_register(&cdrv->drv);
 }
 EXPORT_SYMBOL_GPL(css_driver_register);
@@ -1252,4 +1252,3 @@ void css_driver_unregister(struct css_driver *cdrv)
 EXPORT_SYMBOL_GPL(css_driver_unregister);
 
 MODULE_LICENSE("GPL");
-EXPORT_SYMBOL(css_bus_type);
diff --git a/drivers/s390/cio/css.h b/drivers/s390/cio/css.h
index 7e37886de231..80ebdddf7747 100644
--- a/drivers/s390/cio/css.h
+++ b/drivers/s390/cio/css.h
@@ -63,7 +63,6 @@ struct subchannel;
 struct chp_link;
 /**
  * struct css_driver - device driver for subchannels
- * @owner: owning module
  * @subchannel_type: subchannel type supported by this driver
  * @drv: embedded device driver structure
  * @irq: called on interrupts
@@ -78,10 +77,8 @@ struct chp_link;
  * @thaw: undo work done in @freeze
  * @restore: callback for restoring after hibernation
  * @settle: wait for asynchronous work to finish
- * @name: name of the device driver
  */
 struct css_driver {
-        struct module *owner;
         struct css_device_id *subchannel_type;
         struct device_driver drv;
         void (*irq)(struct subchannel *);
@@ -96,16 +93,10 @@ struct css_driver {
         int (*thaw) (struct subchannel *);
         int (*restore)(struct subchannel *);
         int (*settle)(void);
-        const char *name;
 };
 
 #define to_cssdriver(n) container_of(n, struct css_driver, drv)
 
-/*
- * all css_drivers have the css_bus_type
- */
-extern struct bus_type css_bus_type;
-
 extern int css_driver_register(struct css_driver *);
 extern void css_driver_unregister(struct css_driver *);
 
@@ -140,7 +131,6 @@ struct channel_subsystem {
 };
 #define to_css(dev) container_of(dev, struct channel_subsystem, device)
 
-extern struct bus_type css_bus_type;
 extern struct channel_subsystem *channel_subsystems[];
 
 /* Helper functions to build lists for the slow path. */
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index 51bd3687d163..8e04c00cf0ad 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -127,7 +127,7 @@ static int ccw_uevent(struct device *dev, struct kobj_uevent_env *env)
         return ret;
 }
 
-struct bus_type ccw_bus_type;
+static struct bus_type ccw_bus_type;
 
 static void io_subchannel_irq(struct subchannel *);
 static int io_subchannel_probe(struct subchannel *);
@@ -172,9 +172,11 @@ static int io_subchannel_settle(void)
 }
 
 static struct css_driver io_subchannel_driver = {
-        .owner = THIS_MODULE,
+        .drv = {
+                .owner = THIS_MODULE,
+                .name = "io_subchannel",
+        },
         .subchannel_type = io_subchannel_ids,
-        .name = "io_subchannel",
         .irq = io_subchannel_irq,
         .sch_event = io_subchannel_sch_event,
         .chp_event = io_subchannel_chp_event,
@@ -539,15 +541,24 @@ static ssize_t online_store (struct device *dev, struct device_attribute *attr,
         int force, ret;
         unsigned long i;
 
-        if (!dev_fsm_final_state(cdev) &&
-            cdev->private->state != DEV_STATE_DISCONNECTED)
-                return -EAGAIN;
+        /* Prevent conflict between multiple on-/offline processing requests. */
         if (atomic_cmpxchg(&cdev->private->onoff, 0, 1) != 0)
                 return -EAGAIN;
+        /* Prevent conflict between internal I/Os and on-/offline processing. */
+        if (!dev_fsm_final_state(cdev) &&
+            cdev->private->state != DEV_STATE_DISCONNECTED) {
+                ret = -EAGAIN;
+                goto out_onoff;
+        }
+        /* Prevent conflict between pending work and on-/offline processing.*/
+        if (work_pending(&cdev->private->todo_work)) {
+                ret = -EAGAIN;
+                goto out_onoff;
+        }
 
-        if (cdev->drv && !try_module_get(cdev->drv->owner)) {
-                atomic_set(&cdev->private->onoff, 0);
-                return -EINVAL;
+        if (cdev->drv && !try_module_get(cdev->drv->driver.owner)) {
+                ret = -EINVAL;
+                goto out_onoff;
         }
         if (!strncmp(buf, "force\n", count)) {
                 force = 1;
@@ -571,7 +582,8 @@ static ssize_t online_store (struct device *dev, struct device_attribute *attr,
         }
 out:
         if (cdev->drv)
-                module_put(cdev->drv->owner);
+                module_put(cdev->drv->driver.owner);
+out_onoff:
         atomic_set(&cdev->private->onoff, 0);
         return (ret < 0) ? ret : count;
 }
@@ -1030,6 +1042,7 @@ static void io_subchannel_init_fields(struct subchannel *sch)
  */
 static int io_subchannel_probe(struct subchannel *sch)
 {
+        struct io_subchannel_private *io_priv;
         struct ccw_device *cdev;
         int rc;
 
@@ -1073,10 +1086,11 @@ static int io_subchannel_probe(struct subchannel *sch)
         if (rc)
                 goto out_schedule;
         /* Allocate I/O subchannel private data. */
-        sch->private = kzalloc(sizeof(struct io_subchannel_private),
-                               GFP_KERNEL | GFP_DMA);
-        if (!sch->private)
+        io_priv = kzalloc(sizeof(*io_priv), GFP_KERNEL | GFP_DMA);
+        if (!io_priv)
                 goto out_schedule;
+
+        set_io_private(sch, io_priv);
         css_schedule_eval(sch->schid);
         return 0;
 
@@ -1090,6 +1104,7 @@ out_schedule:
 static int
 io_subchannel_remove (struct subchannel *sch)
 {
+        struct io_subchannel_private *io_priv = to_io_private(sch);
         struct ccw_device *cdev;
 
         cdev = sch_get_cdev(sch);
@@ -1099,11 +1114,12 @@ io_subchannel_remove (struct subchannel *sch)
         /* Set ccw device to not operational and drop reference. */
         spin_lock_irq(cdev->ccwlock);
         sch_set_cdev(sch, NULL);
+        set_io_private(sch, NULL);
         cdev->private->state = DEV_STATE_NOT_OPER;
         spin_unlock_irq(cdev->ccwlock);
         ccw_device_unregister(cdev);
 out_free:
-        kfree(sch->private);
+        kfree(io_priv);
         sysfs_remove_group(&sch->dev.kobj, &io_subchannel_attr_group);
         return 0;
 }
@@ -1147,6 +1163,7 @@ err:
 static int io_subchannel_chp_event(struct subchannel *sch,
                                    struct chp_link *link, int event)
 {
+        struct ccw_device *cdev = sch_get_cdev(sch);
         int mask;
 
         mask = chp_ssd_get_mask(&sch->ssd_info, link);
@@ -1156,22 +1173,30 @@ static int io_subchannel_chp_event(struct subchannel *sch,
         case CHP_VARY_OFF:
                 sch->opm &= ~mask;
                 sch->lpm &= ~mask;
+                if (cdev)
+                        cdev->private->path_gone_mask |= mask;
                 io_subchannel_terminate_path(sch, mask);
                 break;
         case CHP_VARY_ON:
                 sch->opm |= mask;
                 sch->lpm |= mask;
+                if (cdev)
+                        cdev->private->path_new_mask |= mask;
                 io_subchannel_verify(sch);
                 break;
         case CHP_OFFLINE:
                 if (cio_update_schib(sch))
                         return -ENODEV;
+                if (cdev)
+                        cdev->private->path_gone_mask |= mask;
                 io_subchannel_terminate_path(sch, mask);
                 break;
         case CHP_ONLINE:
                 if (cio_update_schib(sch))
                         return -ENODEV;
                 sch->lpm |= mask & sch->opm;
+                if (cdev)
+                        cdev->private->path_new_mask |= mask;
                 io_subchannel_verify(sch);
                 break;
         }
@@ -1196,6 +1221,7 @@ static void io_subchannel_quiesce(struct subchannel *sch)
                 cdev->handler(cdev, cdev->private->intparm, ERR_PTR(-EIO));
         while (ret == -EBUSY) {
                 cdev->private->state = DEV_STATE_QUIESCE;
+                cdev->private->iretry = 255;
                 ret = ccw_device_cancel_halt_clear(cdev);
                 if (ret == -EBUSY) {
                         ccw_device_set_timeout(cdev, HZ/10);
@@ -1295,10 +1321,12 @@ static int purge_fn(struct device *dev, void *data)
 
         spin_lock_irq(cdev->ccwlock);
         if (is_blacklisted(id->ssid, id->devno) &&
-            (cdev->private->state == DEV_STATE_OFFLINE)) {
+            (cdev->private->state == DEV_STATE_OFFLINE) &&
+            (atomic_cmpxchg(&cdev->private->onoff, 0, 1) == 0)) {
                 CIO_MSG_EVENT(3, "ccw: purging 0.%x.%04x\n", id->ssid,
                               id->devno);
                 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
+                atomic_set(&cdev->private->onoff, 0);
         }
         spin_unlock_irq(cdev->ccwlock);
         /* Abort loop in case of pending signal. */
@@ -1445,7 +1473,16 @@ static int io_subchannel_sch_event(struct subchannel *sch, int process)
                 break;
         case IO_SCH_UNREG_ATTACH:
         case IO_SCH_UNREG:
-                if (cdev)
+                if (!cdev)
+                        break;
+                if (cdev->private->state == DEV_STATE_SENSE_ID) {
+                        /*
+                         * Note: delayed work triggered by this event
+                         * and repeated calls to sch_event are synchronized
+                         * by the above check for work_pending(cdev).
+                         */
+                        dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
+                } else
                         ccw_device_set_notoper(cdev);
                 break;
         case IO_SCH_NOP:
@@ -1468,9 +1505,13 @@ static int io_subchannel_sch_event(struct subchannel *sch, int process)
                         goto out;
                 break;
         case IO_SCH_UNREG_ATTACH:
+                if (cdev->private->flags.resuming) {
+                        /* Device will be handled later. */
+                        rc = 0;
+                        goto out;
+                }
                 /* Unregister ccw device. */
-                if (!cdev->private->flags.resuming)
-                        ccw_device_unregister(cdev);
+                ccw_device_unregister(cdev);
                 break;
         default:
                 break;
@@ -1530,11 +1571,12 @@ spinlock_t * cio_get_console_lock(void)
 static int ccw_device_console_enable(struct ccw_device *cdev,
                                      struct subchannel *sch)
 {
+        struct io_subchannel_private *io_priv = cio_get_console_priv();
         int rc;
 
         /* Attach subchannel private data. */
-        sch->private = cio_get_console_priv();
-        memset(sch->private, 0, sizeof(struct io_subchannel_private));
+        memset(io_priv, 0, sizeof(*io_priv));
+        set_io_private(sch, io_priv);
         io_subchannel_init_fields(sch);
         rc = cio_commit_config(sch);
         if (rc)
@@ -1812,6 +1854,7 @@ static void __ccw_device_pm_restore(struct ccw_device *cdev)
          * available again. Kick re-detection.
          */
         cdev->private->flags.resuming = 1;
+        cdev->private->path_new_mask = LPM_ANYPATH;
         css_schedule_eval(sch->schid);
         spin_unlock_irq(sch->lock);
         css_complete_work();
@@ -1939,7 +1982,7 @@ static const struct dev_pm_ops ccw_pm_ops = {
         .restore = ccw_device_pm_restore,
 };
 
-struct bus_type ccw_bus_type = {
+static struct bus_type ccw_bus_type = {
         .name   = "ccw",
         .match  = ccw_bus_match,
         .uevent = ccw_uevent,
@@ -1962,8 +2005,6 @@ int ccw_driver_register(struct ccw_driver *cdriver)
         struct device_driver *drv = &cdriver->driver;
 
         drv->bus = &ccw_bus_type;
-        drv->name = cdriver->name;
-        drv->owner = cdriver->owner;
 
         return driver_register(drv);
 }
@@ -2081,5 +2122,4 @@ EXPORT_SYMBOL(ccw_device_set_offline);
 EXPORT_SYMBOL(ccw_driver_register);
 EXPORT_SYMBOL(ccw_driver_unregister);
 EXPORT_SYMBOL(get_ccwdev_by_busid);
-EXPORT_SYMBOL(ccw_bus_type);
 EXPORT_SYMBOL_GPL(ccw_device_get_subchannel_id);
diff --git a/drivers/s390/cio/device.h b/drivers/s390/cio/device.h
index 379de2d1ec49..7e297c7bb5ff 100644
--- a/drivers/s390/cio/device.h
+++ b/drivers/s390/cio/device.h
@@ -133,7 +133,6 @@ void ccw_device_set_notoper(struct ccw_device *cdev);
 /* qdio needs this. */
 void ccw_device_set_timeout(struct ccw_device *, int);
 extern struct subchannel_id ccw_device_get_subchannel_id(struct ccw_device *);
-extern struct bus_type ccw_bus_type;
 
 /* Channel measurement facility related */
 void retry_set_schib(struct ccw_device *cdev);
diff --git a/drivers/s390/cio/device_fsm.c b/drivers/s390/cio/device_fsm.c
index c9b852647f01..52c233fa2b12 100644
--- a/drivers/s390/cio/device_fsm.c
+++ b/drivers/s390/cio/device_fsm.c
@@ -174,7 +174,10 @@ ccw_device_cancel_halt_clear(struct ccw_device *cdev)
                 ret = cio_clear (sch);
                 return (ret == 0) ? -EBUSY : ret;
         }
-        panic("Can't stop i/o on subchannel.\n");
+        /* Function was unsuccessful */
+        CIO_MSG_EVENT(0, "0.%x.%04x: could not stop I/O\n",
+                      cdev->private->dev_id.ssid, cdev->private->dev_id.devno);
+        return -EIO;
 }
 
 void ccw_device_update_sense_data(struct ccw_device *cdev)
@@ -315,7 +318,7 @@ 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
+  * @cdev: device for which an event occurred
   * @event: event that occurred
   *
   * Returns:
@@ -349,9 +352,13 @@ out:
 
 static void ccw_device_oper_notify(struct ccw_device *cdev)
 {
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+
         if (ccw_device_notify(cdev, CIO_OPER) == NOTIFY_OK) {
                 /* Reenable channel measurements, if needed. */
                 ccw_device_sched_todo(cdev, CDEV_TODO_ENABLE_CMF);
+                /* Save indication for new paths. */
+                cdev->private->path_new_mask = sch->vpm;
                 return;
         }
         /* Driver doesn't want device back. */
@@ -401,9 +408,10 @@ 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) != NOTIFY_OK)
+                if (ccw_device_notify(cdev, CIO_NO_PATH) != NOTIFY_OK) {
+                        cdev->private->state = DEV_STATE_NOT_OPER;
                         ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
-                else
+                } else
                         ccw_device_set_disconnected(cdev);
                 cdev->private->flags.donotify = 0;
                 break;
@@ -462,6 +470,32 @@ static void ccw_device_request_event(struct ccw_device *cdev, enum dev_event e)
         }
 }
 
+static void ccw_device_report_path_events(struct ccw_device *cdev)
+{
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        int path_event[8];
+        int chp, mask;
+
+        for (chp = 0, mask = 0x80; chp < 8; chp++, mask >>= 1) {
+                path_event[chp] = PE_NONE;
+                if (mask & cdev->private->path_gone_mask & ~(sch->vpm))
+                        path_event[chp] |= PE_PATH_GONE;
+                if (mask & cdev->private->path_new_mask & sch->vpm)
+                        path_event[chp] |= PE_PATH_AVAILABLE;
+                if (mask & cdev->private->pgid_reset_mask & sch->vpm)
+                        path_event[chp] |= PE_PATHGROUP_ESTABLISHED;
+        }
+        if (cdev->online && cdev->drv->path_event)
+                cdev->drv->path_event(cdev, path_event);
+}
+
+static void ccw_device_reset_path_events(struct ccw_device *cdev)
+{
+        cdev->private->path_gone_mask = 0;
+        cdev->private->path_new_mask = 0;
+        cdev->private->pgid_reset_mask = 0;
+}
+
 void
 ccw_device_verify_done(struct ccw_device *cdev, int err)
 {
@@ -498,6 +532,7 @@ callback:
                                               &cdev->private->irb);
                         memset(&cdev->private->irb, 0, sizeof(struct irb));
                 }
+                ccw_device_report_path_events(cdev);
                 break;
         case -ETIME:
         case -EUSERS:
@@ -516,6 +551,7 @@ callback:
                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
                 break;
         }
+        ccw_device_reset_path_events(cdev);
 }
 
 /*
@@ -653,7 +689,7 @@ ccw_device_online_verify(struct ccw_device *cdev, enum dev_event dev_event)
             (scsw_stctl(&cdev->private->irb.scsw) & SCSW_STCTL_STATUS_PEND)) {
                 /*
                  * No final status yet or final status not yet delivered
-                 * to the device driver. Can't do path verfication now,
+                 * to the device driver. Can't do path verification now,
                  * delay until final status was delivered.
                  */
                 cdev->private->flags.doverify = 1;
@@ -734,13 +770,14 @@ ccw_device_online_timeout(struct ccw_device *cdev, enum dev_event dev_event)
         int ret;
 
         ccw_device_set_timeout(cdev, 0);
+        cdev->private->iretry = 255;
         ret = ccw_device_cancel_halt_clear(cdev);
         if (ret == -EBUSY) {
                 ccw_device_set_timeout(cdev, 3*HZ);
                 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
                 return;
         }
-        if (ret == -ENODEV)
+        if (ret)
                 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
         else if (cdev->handler)
                 cdev->handler(cdev, cdev->private->intparm,
@@ -804,9 +841,6 @@ call_handler:
 static void
 ccw_device_killing_irq(struct ccw_device *cdev, enum dev_event dev_event)
 {
-        struct subchannel *sch;
-
-        sch = to_subchannel(cdev->dev.parent);
         ccw_device_set_timeout(cdev, 0);
         /* Start delayed path verification. */
         ccw_device_online_verify(cdev, 0);
@@ -837,6 +871,7 @@ void ccw_device_kill_io(struct ccw_device *cdev)
 {
         int ret;
 
+        cdev->private->iretry = 255;
         ret = ccw_device_cancel_halt_clear(cdev);
         if (ret == -EBUSY) {
                 ccw_device_set_timeout(cdev, 3*HZ);
diff --git a/drivers/s390/cio/device_ops.c b/drivers/s390/cio/device_ops.c
index 6da84543dfe9..f98698d5735e 100644
--- a/drivers/s390/cio/device_ops.c
+++ b/drivers/s390/cio/device_ops.c
@@ -418,12 +418,9 @@ int ccw_device_resume(struct ccw_device *cdev)
 int
 ccw_device_call_handler(struct ccw_device *cdev)
 {
-        struct subchannel *sch;
         unsigned int stctl;
         int ending_status;
 
-        sch = to_subchannel(cdev->dev.parent);
-
         /*
          * we allow for the device action handler if .
          *  - we received ending status
@@ -687,6 +684,46 @@ int ccw_device_tm_start_timeout(struct ccw_device *cdev, struct tcw *tcw,
 EXPORT_SYMBOL(ccw_device_tm_start_timeout);
 
 /**
+ * ccw_device_get_mdc - accumulate max data count
+ * @cdev: ccw device for which the max data count is accumulated
+ * @mask: mask of paths to use
+ *
+ * Return the number of 64K-bytes blocks all paths at least support
+ * for a transport command. Return values <= 0 indicate failures.
+ */
+int ccw_device_get_mdc(struct ccw_device *cdev, u8 mask)
+{
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+        struct channel_path_desc_fmt1 desc;
+        struct chp_id chpid;
+        int mdc = 0, ret, i;
+
+        /* Adjust requested path mask to excluded varied off paths. */
+        if (mask)
+                mask &= sch->lpm;
+        else
+                mask = sch->lpm;
+
+        chp_id_init(&chpid);
+        for (i = 0; i < 8; i++) {
+                if (!(mask & (0x80 >> i)))
+                        continue;
+                chpid.id = sch->schib.pmcw.chpid[i];
+                ret = chsc_determine_fmt1_channel_path_desc(chpid, &desc);
+                if (ret)
+                        return ret;
+                if (!desc.f)
+                        return 0;
+                if (!desc.r)
+                        mdc = 1;
+                mdc = mdc ? min(mdc, (int)desc.mdc) : desc.mdc;
+        }
+
+        return mdc;
+}
+EXPORT_SYMBOL(ccw_device_get_mdc);
+
+/**
  * ccw_device_tm_intrg - perform interrogate function
  * @cdev: ccw device on which to perform the interrogate function
  *
diff --git a/drivers/s390/cio/device_pgid.c b/drivers/s390/cio/device_pgid.c
index 82a5ad0d63f6..07a4fd29f096 100644
--- a/drivers/s390/cio/device_pgid.c
+++ b/drivers/s390/cio/device_pgid.c
@@ -213,6 +213,17 @@ static void spid_start(struct ccw_device *cdev)
         spid_do(cdev);
 }
 
+static int pgid_is_reset(struct pgid *p)
+{
+        char *c;
+
+        for (c = (char *)p + 1; c < (char *)(p + 1); c++) {
+                if (*c != 0)
+                        return 0;
+        }
+        return 1;
+}
+
 static int pgid_cmp(struct pgid *p1, struct pgid *p2)
 {
         return memcmp((char *) p1 + 1, (char *) p2 + 1,
@@ -223,7 +234,7 @@ static int pgid_cmp(struct pgid *p1, struct pgid *p2)
  * Determine pathgroup state from PGID data.
  */
 static void pgid_analyze(struct ccw_device *cdev, struct pgid **p,
-                         int *mismatch, int *reserved, int *reset)
+                         int *mismatch, int *reserved, u8 *reset)
 {
         struct pgid *pgid = &cdev->private->pgid[0];
         struct pgid *first = NULL;
@@ -238,9 +249,8 @@ static void pgid_analyze(struct ccw_device *cdev, struct pgid **p,
                         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;
+                if (pgid_is_reset(pgid)) {
+                        *reset |= lpm;
                         continue;
                 }
                 if (!first) {
@@ -307,7 +317,7 @@ static void snid_done(struct ccw_device *cdev, int rc)
         struct pgid *pgid;
         int mismatch = 0;
         int reserved = 0;
-        int reset = 0;
+        u8 reset = 0;
         u8 donepm;
 
         if (rc)
@@ -321,11 +331,12 @@ static void snid_done(struct ccw_device *cdev, int rc)
                 donepm = pgid_to_donepm(cdev);
                 sch->vpm = donepm & sch->opm;
                 cdev->private->pgid_todo_mask &= ~donepm;
+                cdev->private->pgid_reset_mask |= reset;
                 pgid_fill(cdev, pgid);
         }
 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,
+                      "todo=%02x mism=%d rsvd=%d reset=%02x\n", id->ssid,
                       id->devno, rc, cdev->private->pgid_valid_mask, sch->vpm,
                       cdev->private->pgid_todo_mask, mismatch, reserved, reset);
         switch (rc) {
diff --git a/drivers/s390/cio/io_sch.h b/drivers/s390/cio/io_sch.h
index 469ef93f2302..ba31ad88f4f7 100644
--- a/drivers/s390/cio/io_sch.h
+++ b/drivers/s390/cio/io_sch.h
@@ -5,68 +5,36 @@
 #include <asm/schid.h>
 #include <asm/ccwdev.h>
 #include "css.h"
-
-/*
- * command-mode operation request block
- */
-struct cmd_orb {
-        u32 intparm;    /* interruption parameter */
-        u32 key  : 4;   /* flags, like key, suspend control, etc. */
-        u32 spnd : 1;   /* suspend control */
-        u32 res1 : 1;   /* reserved */
-        u32 mod  : 1;   /* modification control */
-        u32 sync : 1;   /* synchronize control */
-        u32 fmt  : 1;   /* format control */
-        u32 pfch : 1;   /* prefetch control */
-        u32 isic : 1;   /* initial-status-interruption control */
-        u32 alcc : 1;   /* address-limit-checking control */
-        u32 ssic : 1;   /* suppress-suspended-interr. control */
-        u32 res2 : 1;   /* reserved */
-        u32 c64  : 1;   /* IDAW/QDIO 64 bit control  */
-        u32 i2k  : 1;   /* IDAW 2/4kB block size control */
-        u32 lpm  : 8;   /* logical path mask */
-        u32 ils  : 1;   /* incorrect length */
-        u32 zero : 6;   /* reserved zeros */
-        u32 orbx : 1;   /* ORB extension control */
-        u32 cpa;        /* channel program address */
-}  __attribute__ ((packed, aligned(4)));
-
-/*
- * transport-mode operation request block
- */
-struct tm_orb {
-        u32 intparm;
-        u32 key:4;
-        u32 :9;
-        u32 b:1;
-        u32 :2;
-        u32 lpm:8;
-        u32 :7;
-        u32 x:1;
-        u32 tcw;
-        u32 prio:8;
-        u32 :8;
-        u32 rsvpgm:8;
-        u32 :8;
-        u32 :32;
-        u32 :32;
-        u32 :32;
-        u32 :32;
-}  __attribute__ ((packed, aligned(4)));
-
-union orb {
-        struct cmd_orb cmd;
-        struct tm_orb tm;
-}  __attribute__ ((packed, aligned(4)));
+#include "orb.h"
 
 struct io_subchannel_private {
         union orb orb;          /* operation request block */
         struct ccw1 sense_ccw;  /* static ccw for sense command */
-} __attribute__ ((aligned(8)));
+        struct ccw_device *cdev;/* pointer to the child ccw device */
+        struct {
+                unsigned int suspend:1; /* allow suspend */
+                unsigned int prefetch:1;/* deny prefetch */
+                unsigned int inter:1;   /* suppress intermediate interrupts */
+        } __packed options;
+} __aligned(8);
 
-#define to_io_private(n) ((struct io_subchannel_private *)n->private)
-#define sch_get_cdev(n) (dev_get_drvdata(&n->dev))
-#define sch_set_cdev(n, c) (dev_set_drvdata(&n->dev, c))
+#define to_io_private(n) ((struct io_subchannel_private *) \
+                          dev_get_drvdata(&(n)->dev))
+#define set_io_private(n, p) (dev_set_drvdata(&(n)->dev, p))
+
+static inline struct ccw_device *sch_get_cdev(struct subchannel *sch)
+{
+        struct io_subchannel_private *priv = to_io_private(sch);
+        return priv ? priv->cdev : NULL;
+}
+
+static inline void sch_set_cdev(struct subchannel *sch,
+                                struct ccw_device *cdev)
+{
+        struct io_subchannel_private *priv = to_io_private(sch);
+        if (priv)
+                priv->cdev = cdev;
+}
 
 #define MAX_CIWS 8
 
@@ -151,8 +119,11 @@ struct ccw_device_private {
         struct subchannel_id schid;     /* subchannel number */
         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 */
+        u8 pgid_valid_mask;     /* mask of valid PGIDs */
+        u8 pgid_todo_mask;      /* mask of PGIDs to be adjusted */
+        u8 pgid_reset_mask;     /* mask of PGIDs which were reset */
+        u8 path_gone_mask;      /* mask of paths, that became unavailable */
+        u8 path_new_mask;       /* mask of paths, that became available */
         struct {
                 unsigned int fast:1;    /* post with "channel end" */
                 unsigned int repall:1;  /* report every interrupt status */
@@ -188,23 +159,6 @@ struct ccw_device_private {
         void *cmb_wait;                 /* deferred cmb enable/disable */
 };
 
-static inline int ssch(struct subchannel_id schid, union orb *addr)
-{
-        register struct subchannel_id reg1 asm("1") = schid;
-        int ccode = -EIO;
-
-        asm volatile(
-                "       ssch    0(%2)\n"
-                "0:     ipm     %0\n"
-                "       srl     %0,28\n"
-                "1:\n"
-                EX_TABLE(0b, 1b)
-                : "+d" (ccode)
-                : "d" (reg1), "a" (addr), "m" (*addr)
-                : "cc", "memory");
-        return ccode;
-}
-
 static inline int rsch(struct subchannel_id schid)
 {
         register struct subchannel_id reg1 asm("1") = schid;
@@ -220,21 +174,6 @@ static inline int rsch(struct subchannel_id schid)
         return ccode;
 }
 
-static inline int csch(struct subchannel_id schid)
-{
-        register struct subchannel_id reg1 asm("1") = schid;
-        int ccode;
-
-        asm volatile(
-                "       csch\n"
-                "       ipm     %0\n"
-                "       srl     %0,28"
-                : "=d" (ccode)
-                : "d" (reg1)
-                : "cc");
-        return ccode;
-}
-
 static inline int hsch(struct subchannel_id schid)
 {
         register struct subchannel_id reg1 asm("1") = schid;
diff --git a/drivers/s390/cio/ioasm.h b/drivers/s390/cio/ioasm.h
index fac06155773f..4d80fc67a06b 100644
--- a/drivers/s390/cio/ioasm.h
+++ b/drivers/s390/cio/ioasm.h
@@ -3,6 +3,8 @@
 
 #include <asm/chpid.h>
 #include <asm/schid.h>
+#include "orb.h"
+#include "cio.h"
 
 /*
  * TPI info structure
@@ -87,6 +89,38 @@ static inline int tsch(struct subchannel_id schid, struct irb *addr)
         return ccode;
 }
 
+static inline int ssch(struct subchannel_id schid, union orb *addr)
+{
+        register struct subchannel_id reg1 asm("1") = schid;
+        int ccode = -EIO;
+
+        asm volatile(
+                "       ssch    0(%2)\n"
+                "0:     ipm     %0\n"
+                "       srl     %0,28\n"
+                "1:\n"
+                EX_TABLE(0b, 1b)
+                : "+d" (ccode)
+                : "d" (reg1), "a" (addr), "m" (*addr)
+                : "cc", "memory");
+        return ccode;
+}
+
+static inline int csch(struct subchannel_id schid)
+{
+        register struct subchannel_id reg1 asm("1") = schid;
+        int ccode;
+
+        asm volatile(
+                "       csch\n"
+                "       ipm     %0\n"
+                "       srl     %0,28"
+                : "=d" (ccode)
+                : "d" (reg1)
+                : "cc");
+        return ccode;
+}
+
 static inline int tpi(struct tpi_info *addr)
 {
         int ccode;
diff --git a/drivers/s390/cio/itcw.c b/drivers/s390/cio/itcw.c
index a0ae29564774..358ee16d10a2 100644
--- a/drivers/s390/cio/itcw.c
+++ b/drivers/s390/cio/itcw.c
@@ -93,6 +93,7 @@ EXPORT_SYMBOL(itcw_get_tcw);
 size_t itcw_calc_size(int intrg, int max_tidaws, int intrg_max_tidaws)
 {
         size_t len;
+        int cross_count;
 
         /* Main data. */
         len = sizeof(struct itcw);
@@ -105,12 +106,27 @@ size_t itcw_calc_size(int intrg, int max_tidaws, int intrg_max_tidaws)
                        /* TSB */ sizeof(struct tsb) +
                        /* TIDAL */ intrg_max_tidaws * sizeof(struct tidaw);
         }
+
         /* Maximum required alignment padding. */
         len += /* Initial TCW */ 63 + /* Interrogate TCCB */ 7;
-        /* Maximum padding for structures that may not cross 4k boundary. */
-        if ((max_tidaws > 0) || (intrg_max_tidaws > 0))
-                len += max(max_tidaws, intrg_max_tidaws) *
-                       sizeof(struct tidaw) - 1;
+
+        /* TIDAW lists may not cross a 4k boundary. To cross a
+         * boundary we need to add a TTIC TIDAW. We need to reserve
+         * one additional TIDAW for a TTIC that we may need to add due
+         * to the placement of the data chunk in memory, and a further
+         * TIDAW for each page boundary that the TIDAW list may cross
+         * due to it's own size.
+         */
+        if (max_tidaws) {
+                cross_count = 1 + ((max_tidaws * sizeof(struct tidaw) - 1)
+                                   >> PAGE_SHIFT);
+                len += cross_count * sizeof(struct tidaw);
+        }
+        if (intrg_max_tidaws) {
+                cross_count = 1 + ((intrg_max_tidaws * sizeof(struct tidaw) - 1)
+                                   >> PAGE_SHIFT);
+                len += cross_count * sizeof(struct tidaw);
+        }
         return len;
 }
 EXPORT_SYMBOL(itcw_calc_size);
@@ -165,6 +181,7 @@ struct itcw *itcw_init(void *buffer, size_t size, int op, int intrg,
         void *chunk;
         addr_t start;
         addr_t end;
+        int cross_count;
 
         /* Check for 2G limit. */
         start = (addr_t) buffer;
@@ -177,8 +194,17 @@ struct itcw *itcw_init(void *buffer, size_t size, int op, int intrg,
         if (IS_ERR(chunk))
                 return chunk;
         itcw = chunk;
-        itcw->max_tidaws = max_tidaws;
-        itcw->intrg_max_tidaws = intrg_max_tidaws;
+        /* allow for TTIC tidaws that may be needed to cross a page boundary */
+        cross_count = 0;
+        if (max_tidaws)
+                cross_count = 1 + ((max_tidaws * sizeof(struct tidaw) - 1)
+                                   >> PAGE_SHIFT);
+        itcw->max_tidaws = max_tidaws + cross_count;
+        cross_count = 0;
+        if (intrg_max_tidaws)
+                cross_count = 1 + ((intrg_max_tidaws * sizeof(struct tidaw) - 1)
+                                   >> PAGE_SHIFT);
+        itcw->intrg_max_tidaws = intrg_max_tidaws + cross_count;
         /* Main TCW. */
         chunk = fit_chunk(&start, end, sizeof(struct tcw), 64, 0);
         if (IS_ERR(chunk))
@@ -198,7 +224,7 @@ struct itcw *itcw_init(void *buffer, size_t size, int op, int intrg,
         /* Data TIDAL. */
         if (max_tidaws > 0) {
                 chunk = fit_chunk(&start, end, sizeof(struct tidaw) *
-                                  max_tidaws, 16, 1);
+                                  itcw->max_tidaws, 16, 0);
                 if (IS_ERR(chunk))
                         return chunk;
                 tcw_set_data(itcw->tcw, chunk, 1);
@@ -206,7 +232,7 @@ struct itcw *itcw_init(void *buffer, size_t size, int op, int intrg,
         /* Interrogate data TIDAL. */
         if (intrg && (intrg_max_tidaws > 0)) {
                 chunk = fit_chunk(&start, end, sizeof(struct tidaw) *
-                                  intrg_max_tidaws, 16, 1);
+                                  itcw->intrg_max_tidaws, 16, 0);
                 if (IS_ERR(chunk))
                         return chunk;
                 tcw_set_data(itcw->intrg_tcw, chunk, 1);
@@ -283,13 +309,29 @@ EXPORT_SYMBOL(itcw_add_dcw);
  * the new tidaw on success or -%ENOSPC if the new tidaw would exceed the
  * available space.
  *
- * Note: the tidaw-list is assumed to be contiguous with no ttics. The
- * last-tidaw flag for the last tidaw in the list will be set by itcw_finalize.
+ * Note: TTIC tidaws are automatically added when needed, so explicitly calling
+ * this interface with the TTIC flag is not supported. The last-tidaw flag
+ * for the last tidaw in the list will be set by itcw_finalize.
  */
 struct tidaw *itcw_add_tidaw(struct itcw *itcw, u8 flags, void *addr, u32 count)
 {
+        struct tidaw *following;
+
         if (itcw->num_tidaws >= itcw->max_tidaws)
                 return ERR_PTR(-ENOSPC);
+        /*
+         * Is the tidaw, which follows the one we are about to fill, on the next
+         * page? Then we have to insert a TTIC tidaw first, that points to the
+         * tidaw on the new page.
+         */
+        following = ((struct tidaw *) tcw_get_data(itcw->tcw))
+                + itcw->num_tidaws + 1;
+        if (itcw->num_tidaws && !((unsigned long) following & ~PAGE_MASK)) {
+                tcw_add_tidaw(itcw->tcw, itcw->num_tidaws++,
+                              TIDAW_FLAGS_TTIC, following, 0);
+                if (itcw->num_tidaws >= itcw->max_tidaws)
+                        return ERR_PTR(-ENOSPC);
+        }
         return tcw_add_tidaw(itcw->tcw, itcw->num_tidaws++, flags, addr, count);
 }
 EXPORT_SYMBOL(itcw_add_tidaw);
diff --git a/drivers/s390/cio/orb.h b/drivers/s390/cio/orb.h
new file mode 100644
index 000000000000..45a9865c2b36
--- /dev/null
+++ b/drivers/s390/cio/orb.h
@@ -0,0 +1,67 @@
+/*
+ * Orb related data structures.
+ *
+ * Copyright IBM Corp. 2007, 2011
+ *
+ * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
+ *            Peter Oberparleiter <peter.oberparleiter@de.ibm.com>
+ *            Sebastian Ott <sebott@linux.vnet.ibm.com>
+ */
+
+#ifndef S390_ORB_H
+#define S390_ORB_H
+
+/*
+ * Command-mode operation request block
+ */
+struct cmd_orb {
+        u32 intparm;    /* interruption parameter */
+        u32 key:4;      /* flags, like key, suspend control, etc. */
+        u32 spnd:1;     /* suspend control */
+        u32 res1:1;     /* reserved */
+        u32 mod:1;      /* modification control */
+        u32 sync:1;     /* synchronize control */
+        u32 fmt:1;      /* format control */
+        u32 pfch:1;     /* prefetch control */
+        u32 isic:1;     /* initial-status-interruption control */
+        u32 alcc:1;     /* address-limit-checking control */
+        u32 ssic:1;     /* suppress-suspended-interr. control */
+        u32 res2:1;     /* reserved */
+        u32 c64:1;      /* IDAW/QDIO 64 bit control  */
+        u32 i2k:1;      /* IDAW 2/4kB block size control */
+        u32 lpm:8;      /* logical path mask */
+        u32 ils:1;      /* incorrect length */
+        u32 zero:6;     /* reserved zeros */
+        u32 orbx:1;     /* ORB extension control */
+        u32 cpa;        /* channel program address */
+}  __packed __aligned(4);
+
+/*
+ * Transport-mode operation request block
+ */
+struct tm_orb {
+        u32 intparm;
+        u32 key:4;
+        u32:9;
+        u32 b:1;
+        u32:2;
+        u32 lpm:8;
+        u32:7;
+        u32 x:1;
+        u32 tcw;
+        u32 prio:8;
+        u32:8;
+        u32 rsvpgm:8;
+        u32:8;
+        u32:32;
+        u32:32;
+        u32:32;
+        u32:32;
+}  __packed __aligned(4);
+
+union orb {
+        struct cmd_orb cmd;
+        struct tm_orb tm;
+}  __packed __aligned(4);
+
+#endif /* S390_ORB_H */
diff --git a/drivers/s390/cio/qdio.h b/drivers/s390/cio/qdio.h
index f0037eefd44e..7bc643f3f5ab 100644
--- a/drivers/s390/cio/qdio.h
+++ b/drivers/s390/cio/qdio.h
@@ -91,6 +91,12 @@ enum qdio_irq_states {
 #define AC1_SC_QEBSM_AVAILABLE          0x02    /* available for subchannel */
 #define AC1_SC_QEBSM_ENABLED            0x01    /* enabled for subchannel */
 
+/* SIGA flags */
+#define QDIO_SIGA_WRITE         0x00
+#define QDIO_SIGA_READ          0x01
+#define QDIO_SIGA_SYNC          0x02
+#define QDIO_SIGA_QEBSM_FLAG    0x80
+
 #ifdef CONFIG_64BIT
 static inline int do_sqbs(u64 token, unsigned char state, int queue,
                           int *start, int *count)
@@ -142,10 +148,9 @@ struct siga_flag {
         u8 input:1;
         u8 output:1;
         u8 sync:1;
-        u8 no_sync_ti:1;
-        u8 no_sync_out_ti:1;
-        u8 no_sync_out_pci:1;
-        u8:2;
+        u8 sync_after_ai:1;
+        u8 sync_out_after_pci:1;
+        u8:3;
 } __attribute__ ((packed));
 
 struct chsc_ssqd_area {
@@ -202,12 +207,14 @@ struct qdio_dev_perf_stat {
         unsigned int inbound_queue_full;
         unsigned int outbound_call;
         unsigned int outbound_handler;
+        unsigned int outbound_queue_full;
         unsigned int fast_requeue;
         unsigned int target_full;
         unsigned int eqbs;
         unsigned int eqbs_partial;
         unsigned int sqbs;
         unsigned int sqbs_partial;
+        unsigned int int_discarded;
 } ____cacheline_aligned;
 
 struct qdio_queue_perf_stat {
@@ -222,6 +229,10 @@ struct qdio_queue_perf_stat {
         unsigned int nr_sbal_total;
 };
 
+enum qdio_queue_irq_states {
+        QDIO_QUEUE_IRQS_DISABLED,
+};
+
 struct qdio_input_q {
         /* input buffer acknowledgement flag */
         int polling;
@@ -231,15 +242,19 @@ struct qdio_input_q {
         int ack_count;
         /* last time of noticing incoming data */
         u64 timestamp;
+        /* upper-layer polling flag */
+        unsigned long queue_irq_state;
+        /* callback to start upper-layer polling */
+        void (*queue_start_poll) (struct ccw_device *, int, unsigned long);
 };
 
 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;
+        /* used SBALs before tasklet schedule */
+        int scan_threshold;
 };
 
 /*
@@ -374,12 +389,13 @@ static inline int multicast_outbound(struct qdio_q *q)
         (q->irq_ptr->qib.ac & QIB_AC_OUTBOUND_PCI_SUPPORTED)
 #define is_qebsm(q)                     (q->irq_ptr->sch_token != 0)
 
-#define need_siga_sync_thinint(q)       (!q->irq_ptr->siga_flag.no_sync_ti)
-#define need_siga_sync_out_thinint(q)   (!q->irq_ptr->siga_flag.no_sync_out_ti)
 #define need_siga_in(q)                 (q->irq_ptr->siga_flag.input)
 #define need_siga_out(q)                (q->irq_ptr->siga_flag.output)
-#define need_siga_sync(q)               (q->irq_ptr->siga_flag.sync)
-#define siga_syncs_out_pci(q)           (q->irq_ptr->siga_flag.no_sync_out_pci)
+#define need_siga_sync(q)               (unlikely(q->irq_ptr->siga_flag.sync))
+#define need_siga_sync_after_ai(q)      \
+        (unlikely(q->irq_ptr->siga_flag.sync_after_ai))
+#define need_siga_sync_out_after_pci(q) \
+        (unlikely(q->irq_ptr->siga_flag.sync_out_after_pci))
 
 #define for_each_input_queue(irq_ptr, q, i)     \
         for (i = 0, q = irq_ptr->input_qs[0];   \
@@ -399,6 +415,26 @@ static inline int multicast_outbound(struct qdio_q *q)
 #define sub_buf(bufnr, dec) \
         ((bufnr - dec) & QDIO_MAX_BUFFERS_MASK)
 
+#define queue_irqs_enabled(q)                   \
+        (test_bit(QDIO_QUEUE_IRQS_DISABLED, &q->u.in.queue_irq_state) == 0)
+#define queue_irqs_disabled(q)                  \
+        (test_bit(QDIO_QUEUE_IRQS_DISABLED, &q->u.in.queue_irq_state) != 0)
+
+#define TIQDIO_SHARED_IND               63
+
+/* device state change indicators */
+struct indicator_t {
+        u32 ind;        /* u32 because of compare-and-swap performance */
+        atomic_t count; /* use count, 0 or 1 for non-shared indicators */
+};
+
+extern struct indicator_t *q_indicators;
+
+static inline int shared_ind(u32 *dsci)
+{
+        return dsci == &q_indicators[TIQDIO_SHARED_IND].ind;
+}
+
 /* prototypes for thin interrupt */
 void qdio_setup_thinint(struct qdio_irq *irq_ptr);
 int qdio_establish_thinint(struct qdio_irq *irq_ptr);
diff --git a/drivers/s390/cio/qdio_debug.c b/drivers/s390/cio/qdio_debug.c
index 6ce83f56d537..f8b03a636e49 100644
--- a/drivers/s390/cio/qdio_debug.c
+++ b/drivers/s390/cio/qdio_debug.c
@@ -56,9 +56,16 @@ static int qstat_show(struct seq_file *m, void *v)
 
         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, "ftc: %d  last_move: %d\n",
+                   q->first_to_check, q->last_move);
+        if (q->is_input_q) {
+                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, "IRQs disabled: %u\n",
+                           test_bit(QDIO_QUEUE_IRQS_DISABLED,
+                           &q->u.in.queue_irq_state));
+        }
         seq_printf(m, "SBAL states:\n");
         seq_printf(m, "|0      |8      |16     |24     |32     |40     |48     |56  63|\n");
 
@@ -113,22 +120,6 @@ static int qstat_show(struct seq_file *m, void *v)
         return 0;
 }
 
-static ssize_t qstat_seq_write(struct file *file, const char __user *buf,
-                               size_t count, loff_t *off)
-{
-        struct seq_file *seq = file->private_data;
-        struct qdio_q *q = seq->private;
-
-        if (!q)
-                return 0;
-        if (q->is_input_q)
-                xchg(q->irq_ptr->dsci, 1);
-        local_bh_disable();
-        tasklet_schedule(&q->tasklet);
-        local_bh_enable();
-        return count;
-}
-
 static int qstat_seq_open(struct inode *inode, struct file *filp)
 {
         return single_open(filp, qstat_show,
@@ -139,7 +130,6 @@ static const struct file_operations debugfs_fops = {
         .owner   = THIS_MODULE,
         .open    = qstat_seq_open,
         .read    = seq_read,
-        .write   = qstat_seq_write,
         .llseek  = seq_lseek,
         .release = single_release,
 };
@@ -161,12 +151,14 @@ static char *qperf_names[] = {
         "Inbound queue full",
         "Outbound calls",
         "Outbound handler",
+        "Outbound queue full",
         "Outbound fast_requeue",
         "Outbound target_full",
         "QEBSM eqbs",
         "QEBSM eqbs partial",
         "QEBSM sqbs",
-        "QEBSM sqbs partial"
+        "QEBSM sqbs partial",
+        "Discarded interrupts"
 };
 
 static int qperf_show(struct seq_file *m, void *v)
diff --git a/drivers/s390/cio/qdio_main.c b/drivers/s390/cio/qdio_main.c
index 00520f9a7a8e..570d4da10696 100644
--- a/drivers/s390/cio/qdio_main.c
+++ b/drivers/s390/cio/qdio_main.c
@@ -14,6 +14,7 @@
 #include <linux/timer.h>
 #include <linux/delay.h>
 #include <linux/gfp.h>
+#include <linux/kernel_stat.h>
 #include <asm/atomic.h>
 #include <asm/debug.h>
 #include <asm/qdio.h>
@@ -29,11 +30,12 @@ MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com>,"\
 MODULE_DESCRIPTION("QDIO base support");
 MODULE_LICENSE("GPL");
 
-static inline int do_siga_sync(struct subchannel_id schid,
-                               unsigned int out_mask, unsigned int in_mask)
+static inline int do_siga_sync(unsigned long schid,
+                               unsigned int out_mask, unsigned int in_mask,
+                               unsigned int fc)
 {
-        register unsigned long __fc asm ("0") = 2;
-        register struct subchannel_id __schid asm ("1") = schid;
+        register unsigned long __fc asm ("0") = fc;
+        register unsigned long __schid asm ("1") = schid;
         register unsigned long out asm ("2") = out_mask;
         register unsigned long in asm ("3") = in_mask;
         int cc;
@@ -47,10 +49,11 @@ static inline int do_siga_sync(struct subchannel_id schid,
         return cc;
 }
 
-static inline int do_siga_input(struct subchannel_id schid, unsigned int mask)
+static inline int do_siga_input(unsigned long schid, unsigned int mask,
+                                unsigned int fc)
 {
-        register unsigned long __fc asm ("0") = 1;
-        register struct subchannel_id __schid asm ("1") = schid;
+        register unsigned long __fc asm ("0") = fc;
+        register unsigned long __schid asm ("1") = schid;
         register unsigned long __mask asm ("2") = mask;
         int cc;
 
@@ -279,16 +282,20 @@ void qdio_init_buf_states(struct qdio_irq *irq_ptr)
 static inline int qdio_siga_sync(struct qdio_q *q, unsigned int output,
                           unsigned int input)
 {
+        unsigned long schid = *((u32 *) &q->irq_ptr->schid);
+        unsigned int fc = QDIO_SIGA_SYNC;
         int cc;
 
-        if (!need_siga_sync(q))
-                return 0;
-
         DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "siga-s:%1d", q->nr);
         qperf_inc(q, siga_sync);
 
-        cc = do_siga_sync(q->irq_ptr->schid, output, input);
-        if (cc)
+        if (is_qebsm(q)) {
+                schid = q->irq_ptr->sch_token;
+                fc |= QDIO_SIGA_QEBSM_FLAG;
+        }
+
+        cc = do_siga_sync(schid, output, input, fc);
+        if (unlikely(cc))
                 DBF_ERROR("%4x SIGA-S:%2d", SCH_NO(q), cc);
         return cc;
 }
@@ -301,38 +308,22 @@ static inline int qdio_siga_sync_q(struct qdio_q *q)
                 return qdio_siga_sync(q, q->mask, 0);
 }
 
-static inline int qdio_siga_sync_out(struct qdio_q *q)
-{
-        return qdio_siga_sync(q, ~0U, 0);
-}
-
-static inline int qdio_siga_sync_all(struct qdio_q *q)
-{
-        return qdio_siga_sync(q, ~0U, ~0U);
-}
-
 static int qdio_siga_output(struct qdio_q *q, unsigned int *busy_bit)
 {
-        unsigned long schid;
-        unsigned int fc = 0;
+        unsigned long schid = *((u32 *) &q->irq_ptr->schid);
+        unsigned int fc = QDIO_SIGA_WRITE;
         u64 start_time = 0;
         int cc;
 
-        if (q->u.out.use_enh_siga)
-                fc = 3;
-
         if (is_qebsm(q)) {
                 schid = q->irq_ptr->sch_token;
-                fc |= 0x80;
+                fc |= QDIO_SIGA_QEBSM_FLAG;
         }
-        else
-                schid = *((u32 *)&q->irq_ptr->schid);
-
 again:
         cc = do_siga_output(schid, q->mask, busy_bit, fc);
 
         /* hipersocket busy condition */
-        if (*busy_bit) {
+        if (unlikely(*busy_bit)) {
                 WARN_ON(queue_type(q) != QDIO_IQDIO_QFMT || cc != 2);
 
                 if (!start_time) {
@@ -347,32 +338,41 @@ again:
 
 static inline int qdio_siga_input(struct qdio_q *q)
 {
+        unsigned long schid = *((u32 *) &q->irq_ptr->schid);
+        unsigned int fc = QDIO_SIGA_READ;
         int cc;
 
         DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "siga-r:%1d", q->nr);
         qperf_inc(q, siga_read);
 
-        cc = do_siga_input(q->irq_ptr->schid, q->mask);
-        if (cc)
+        if (is_qebsm(q)) {
+                schid = q->irq_ptr->sch_token;
+                fc |= QDIO_SIGA_QEBSM_FLAG;
+        }
+
+        cc = do_siga_input(schid, q->mask, fc);
+        if (unlikely(cc))
                 DBF_ERROR("%4x SIGA-R:%2d", SCH_NO(q), cc);
         return cc;
 }
 
-static inline void qdio_sync_after_thinint(struct qdio_q *q)
+#define qdio_siga_sync_out(q) qdio_siga_sync(q, ~0U, 0)
+#define qdio_siga_sync_all(q) qdio_siga_sync(q, ~0U, ~0U)
+
+static inline void qdio_sync_queues(struct qdio_q *q)
 {
-        if (pci_out_supported(q)) {
-                if (need_siga_sync_thinint(q))
-                        qdio_siga_sync_all(q);
-                else if (need_siga_sync_out_thinint(q))
-                        qdio_siga_sync_out(q);
-        } else
+        /* PCI capable outbound queues will also be scanned so sync them too */
+        if (pci_out_supported(q))
+                qdio_siga_sync_all(q);
+        else
                 qdio_siga_sync_q(q);
 }
 
 int debug_get_buf_state(struct qdio_q *q, unsigned int bufnr,
                         unsigned char *state)
 {
-        qdio_siga_sync_q(q);
+        if (need_siga_sync(q))
+                qdio_siga_sync_q(q);
         return get_buf_states(q, bufnr, state, 1, 0);
 }
 
@@ -407,13 +407,16 @@ static inline void account_sbals(struct qdio_q *q, int count)
         q->q_stats.nr_sbals[pos]++;
 }
 
-static void announce_buffer_error(struct qdio_q *q, int count)
+static void process_buffer_error(struct qdio_q *q, int count)
 {
+        unsigned char state = (q->is_input_q) ? SLSB_P_INPUT_NOT_INIT :
+                                        SLSB_P_OUTPUT_NOT_INIT;
+
         q->qdio_error |= QDIO_ERROR_SLSB_STATE;
 
         /* special handling for no target buffer empty */
         if ((!q->is_input_q &&
-            (q->sbal[q->first_to_check]->element[15].flags & 0xff) == 0x10)) {
+            (q->sbal[q->first_to_check]->element[15].sflags) == 0x10)) {
                 qperf_inc(q, target_full);
                 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "OUTFULL FTC:%02x",
                               q->first_to_check);
@@ -424,8 +427,14 @@ static void announce_buffer_error(struct qdio_q *q, int count)
         DBF_ERROR((q->is_input_q) ? "IN:%2d" : "OUT:%2d", q->nr);
         DBF_ERROR("FTC:%3d C:%3d", q->first_to_check, count);
         DBF_ERROR("F14:%2x F15:%2x",
-                  q->sbal[q->first_to_check]->element[14].flags & 0xff,
-                  q->sbal[q->first_to_check]->element[15].flags & 0xff);
+                  q->sbal[q->first_to_check]->element[14].sflags,
+                  q->sbal[q->first_to_check]->element[15].sflags);
+
+        /*
+         * Interrupts may be avoided as long as the error is present
+         * so change the buffer state immediately to avoid starvation.
+         */
+        set_buf_states(q, q->first_to_check, state, count);
 }
 
 static inline void inbound_primed(struct qdio_q *q, int count)
@@ -476,7 +485,7 @@ static inline void inbound_primed(struct qdio_q *q, int count)
 static int get_inbound_buffer_frontier(struct qdio_q *q)
 {
         int count, stop;
-        unsigned char state;
+        unsigned char state = 0;
 
         /*
          * Don't check 128 buffers, as otherwise qdio_inbound_q_moved
@@ -506,8 +515,7 @@ static int get_inbound_buffer_frontier(struct qdio_q *q)
                         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 */
+                process_buffer_error(q, count);
                 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)
@@ -549,7 +557,8 @@ static inline int qdio_inbound_q_done(struct qdio_q *q)
         if (!atomic_read(&q->nr_buf_used))
                 return 1;
 
-        qdio_siga_sync_q(q);
+        if (need_siga_sync(q))
+                qdio_siga_sync_q(q);
         get_buf_state(q, q->first_to_check, &state, 0);
 
         if (state == SLSB_P_INPUT_PRIMED || state == SLSB_P_INPUT_ERROR)
@@ -642,11 +651,14 @@ void qdio_inbound_processing(unsigned long data)
 static int get_outbound_buffer_frontier(struct qdio_q *q)
 {
         int count, stop;
-        unsigned char state;
+        unsigned char state = 0;
 
-        if (((queue_type(q) != QDIO_IQDIO_QFMT) && !pci_out_supported(q)) ||
-            (queue_type(q) == QDIO_IQDIO_QFMT && multicast_outbound(q)))
-                qdio_siga_sync_q(q);
+        if (need_siga_sync(q))
+                if (((queue_type(q) != QDIO_IQDIO_QFMT) &&
+                    !pci_out_supported(q)) ||
+                    (queue_type(q) == QDIO_IQDIO_QFMT &&
+                    multicast_outbound(q)))
+                        qdio_siga_sync_q(q);
 
         /*
          * Don't check 128 buffers, as otherwise qdio_inbound_q_moved
@@ -673,8 +685,7 @@ static int get_outbound_buffer_frontier(struct qdio_q *q)
                         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 */
+                process_buffer_error(q, count);
                 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)
@@ -818,7 +829,8 @@ static inline void qdio_check_outbound_after_thinint(struct qdio_q *q)
 static void __tiqdio_inbound_processing(struct qdio_q *q)
 {
         qperf_inc(q, tasklet_inbound);
-        qdio_sync_after_thinint(q);
+        if (need_siga_sync(q) && need_siga_sync_after_ai(q))
+                qdio_sync_queues(q);
 
         /*
          * The interrupt could be caused by a PCI request. Check the
@@ -884,19 +896,28 @@ static void qdio_int_handler_pci(struct qdio_irq *irq_ptr)
         if (unlikely(irq_ptr->state == QDIO_IRQ_STATE_STOPPED))
                 return;
 
-        for_each_input_queue(irq_ptr, q, i)
-                tasklet_schedule(&q->tasklet);
+        for_each_input_queue(irq_ptr, q, i) {
+                if (q->u.in.queue_start_poll) {
+                        /* skip if polling is enabled or already in work */
+                        if (test_and_set_bit(QDIO_QUEUE_IRQS_DISABLED,
+                                     &q->u.in.queue_irq_state)) {
+                                qperf_inc(q, int_discarded);
+                                continue;
+                        }
+                        q->u.in.queue_start_poll(q->irq_ptr->cdev, q->nr,
+                                                 q->irq_ptr->int_parm);
+                } else
+                        tasklet_schedule(&q->tasklet);
+        }
 
-        if (!(irq_ptr->qib.ac & QIB_AC_OUTBOUND_PCI_SUPPORTED))
+        if (!pci_out_supported(q))
                 return;
 
         for_each_output_queue(irq_ptr, q, i) {
                 if (qdio_outbound_q_done(q))
                         continue;
-
-                if (!siga_syncs_out_pci(q))
+                if (need_siga_sync(q) && need_siga_sync_out_after_pci(q))
                         qdio_siga_sync_q(q);
-
                 tasklet_schedule(&q->tasklet);
         }
 }
@@ -959,6 +980,7 @@ void qdio_int_handler(struct ccw_device *cdev, unsigned long intparm,
                 return;
         }
 
+        kstat_cpu(smp_processor_id()).irqs[IOINT_QDI]++;
         if (irq_ptr->perf_stat_enabled)
                 irq_ptr->perf_stat.qdio_int++;
 
@@ -1262,7 +1284,6 @@ int qdio_establish(struct qdio_initialize *init_data)
         }
 
         qdio_setup_ssqd_info(irq_ptr);
-        DBF_EVENT("qDmmwc:%2x", irq_ptr->ssqd_desc.mmwc);
         DBF_EVENT("qib ac:%4x", irq_ptr->qib.ac);
 
         /* qebsm is now setup if available, initialize buffer states */
@@ -1425,7 +1446,7 @@ set:
 static int handle_outbound(struct qdio_q *q, unsigned int callflags,
                            int bufnr, int count)
 {
-        unsigned char state;
+        unsigned char state = 0;
         int used, rc = 0;
 
         qperf_inc(q, outbound_call);
@@ -1434,52 +1455,38 @@ static int handle_outbound(struct qdio_q *q, unsigned int callflags,
         used = atomic_add_return(count, &q->nr_buf_used);
         BUG_ON(used > QDIO_MAX_BUFFERS_PER_Q);
 
+        if (used == QDIO_MAX_BUFFERS_PER_Q)
+                qperf_inc(q, outbound_queue_full);
+
         if (callflags & QDIO_FLAG_PCI_OUT) {
                 q->u.out.pci_out_enabled = 1;
                 qperf_inc(q, pci_request_int);
-        }
-        else
+        } else
                 q->u.out.pci_out_enabled = 0;
 
         if (queue_type(q) == QDIO_IQDIO_QFMT) {
-                if (multicast_outbound(q))
+                /* One SIGA-W per buffer required for unicast HiperSockets. */
+                WARN_ON_ONCE(count > 1 && !multicast_outbound(q));
+
+                rc = qdio_kick_outbound_q(q);
+        } else if (need_siga_sync(q)) {
+                rc = qdio_siga_sync_q(q);
+        } else {
+                /* try to fast requeue buffers */
+                get_buf_state(q, prev_buf(bufnr), &state, 0);
+                if (state != SLSB_CU_OUTPUT_PRIMED)
                         rc = qdio_kick_outbound_q(q);
                 else
-                        if ((q->irq_ptr->ssqd_desc.mmwc > 1) &&
-                            (count > 1) &&
-                            (count <= q->irq_ptr->ssqd_desc.mmwc)) {
-                                /* exploit enhanced SIGA */
-                                q->u.out.use_enh_siga = 1;
-                                rc = qdio_kick_outbound_q(q);
-                        } else {
-                                /*
-                                * One siga-w per buffer required for unicast
-                                * HiperSockets.
-                                */
-                                q->u.out.use_enh_siga = 0;
-                                while (count--) {
-                                        rc = qdio_kick_outbound_q(q);
-                                        if (rc)
-                                                goto out;
-                                }
-                        }
-                goto out;
+                        qperf_inc(q, fast_requeue);
         }
 
-        if (need_siga_sync(q)) {
-                qdio_siga_sync_q(q);
-                goto out;
-        }
-
-        /* try to fast requeue buffers */
-        get_buf_state(q, prev_buf(bufnr), &state, 0);
-        if (state != SLSB_CU_OUTPUT_PRIMED)
-                rc = qdio_kick_outbound_q(q);
+        /* in case of SIGA errors we must process the error immediately */
+        if (used >= q->u.out.scan_threshold || rc)
+                tasklet_schedule(&q->tasklet);
         else
-                qperf_inc(q, fast_requeue);
-
-out:
-        tasklet_schedule(&q->tasklet);
+                /* free the SBALs in case of no further traffic */
+                if (!timer_pending(&q->u.out.timer))
+                        mod_timer(&q->u.out.timer, jiffies + HZ);
         return rc;
 }
 
@@ -1508,7 +1515,8 @@ int do_QDIO(struct ccw_device *cdev, unsigned int callflags,
 
         if (irq_ptr->state != QDIO_IRQ_STATE_ACTIVE)
                 return -EBUSY;
-
+        if (!count)
+                return 0;
         if (callflags & QDIO_FLAG_SYNC_INPUT)
                 return handle_inbound(irq_ptr->input_qs[q_nr],
                                       callflags, bufnr, count);
@@ -1519,30 +1527,155 @@ int do_QDIO(struct ccw_device *cdev, unsigned int callflags,
 }
 EXPORT_SYMBOL_GPL(do_QDIO);
 
+/**
+ * qdio_start_irq - process input buffers
+ * @cdev: associated ccw_device for the qdio subchannel
+ * @nr: input queue number
+ *
+ * Return codes
+ *   0 - success
+ *   1 - irqs not started since new data is available
+ */
+int qdio_start_irq(struct ccw_device *cdev, int nr)
+{
+        struct qdio_q *q;
+        struct qdio_irq *irq_ptr = cdev->private->qdio_data;
+
+        if (!irq_ptr)
+                return -ENODEV;
+        q = irq_ptr->input_qs[nr];
+
+        WARN_ON(queue_irqs_enabled(q));
+
+        if (!shared_ind(q->irq_ptr->dsci))
+                xchg(q->irq_ptr->dsci, 0);
+
+        qdio_stop_polling(q);
+        clear_bit(QDIO_QUEUE_IRQS_DISABLED, &q->u.in.queue_irq_state);
+
+        /*
+         * We need to check again to not lose initiative after
+         * resetting the ACK state.
+         */
+        if (!shared_ind(q->irq_ptr->dsci) && *q->irq_ptr->dsci)
+                goto rescan;
+        if (!qdio_inbound_q_done(q))
+                goto rescan;
+        return 0;
+
+rescan:
+        if (test_and_set_bit(QDIO_QUEUE_IRQS_DISABLED,
+                             &q->u.in.queue_irq_state))
+                return 0;
+        else
+                return 1;
+
+}
+EXPORT_SYMBOL(qdio_start_irq);
+
+/**
+ * qdio_get_next_buffers - process input buffers
+ * @cdev: associated ccw_device for the qdio subchannel
+ * @nr: input queue number
+ * @bufnr: first filled buffer number
+ * @error: buffers are in error state
+ *
+ * Return codes
+ *   < 0 - error
+ *   = 0 - no new buffers found
+ *   > 0 - number of processed buffers
+ */
+int qdio_get_next_buffers(struct ccw_device *cdev, int nr, int *bufnr,
+                          int *error)
+{
+        struct qdio_q *q;
+        int start, end;
+        struct qdio_irq *irq_ptr = cdev->private->qdio_data;
+
+        if (!irq_ptr)
+                return -ENODEV;
+        q = irq_ptr->input_qs[nr];
+        WARN_ON(queue_irqs_enabled(q));
+
+        /*
+         * Cannot rely on automatic sync after interrupt since queues may
+         * also be examined without interrupt.
+         */
+        if (need_siga_sync(q))
+                qdio_sync_queues(q);
+
+        /* check the PCI capable outbound queues. */
+        qdio_check_outbound_after_thinint(q);
+
+        if (!qdio_inbound_q_moved(q))
+                return 0;
+
+        /* Note: upper-layer MUST stop processing immediately here ... */
+        if (unlikely(q->irq_ptr->state != QDIO_IRQ_STATE_ACTIVE))
+                return -EIO;
+
+        start = q->first_to_kick;
+        end = q->first_to_check;
+        *bufnr = start;
+        *error = q->qdio_error;
+
+        /* for the next time */
+        q->first_to_kick = end;
+        q->qdio_error = 0;
+        return sub_buf(end, start);
+}
+EXPORT_SYMBOL(qdio_get_next_buffers);
+
+/**
+ * qdio_stop_irq - disable interrupt processing for the device
+ * @cdev: associated ccw_device for the qdio subchannel
+ * @nr: input queue number
+ *
+ * Return codes
+ *   0 - interrupts were already disabled
+ *   1 - interrupts successfully disabled
+ */
+int qdio_stop_irq(struct ccw_device *cdev, int nr)
+{
+        struct qdio_q *q;
+        struct qdio_irq *irq_ptr = cdev->private->qdio_data;
+
+        if (!irq_ptr)
+                return -ENODEV;
+        q = irq_ptr->input_qs[nr];
+
+        if (test_and_set_bit(QDIO_QUEUE_IRQS_DISABLED,
+                             &q->u.in.queue_irq_state))
+                return 0;
+        else
+                return 1;
+}
+EXPORT_SYMBOL(qdio_stop_irq);
+
 static int __init init_QDIO(void)
 {
         int rc;
 
-        rc = qdio_setup_init();
+        rc = qdio_debug_init();
         if (rc)
                 return rc;
+        rc = qdio_setup_init();
+        if (rc)
+                goto out_debug;
         rc = tiqdio_allocate_memory();
         if (rc)
                 goto out_cache;
-        rc = qdio_debug_init();
-        if (rc)
-                goto out_ti;
         rc = tiqdio_register_thinints();
         if (rc)
-                goto out_debug;
+                goto out_ti;
         return 0;
 
-out_debug:
-        qdio_debug_exit();
 out_ti:
         tiqdio_free_memory();
 out_cache:
         qdio_setup_exit();
+out_debug:
+        qdio_debug_exit();
         return rc;
 }
 
@@ -1550,8 +1683,8 @@ static void __exit exit_QDIO(void)
 {
         tiqdio_unregister_thinints();
         tiqdio_free_memory();
-        qdio_debug_exit();
         qdio_setup_exit();
+        qdio_debug_exit();
 }
 
 module_init(init_QDIO);
diff --git a/drivers/s390/cio/qdio_setup.c b/drivers/s390/cio/qdio_setup.c
index 34c7e4046df4..89107d0938c4 100644
--- a/drivers/s390/cio/qdio_setup.c
+++ b/drivers/s390/cio/qdio_setup.c
@@ -161,6 +161,7 @@ static void setup_queues(struct qdio_irq *irq_ptr,
                 setup_queues_misc(q, irq_ptr, qdio_init->input_handler, i);
 
                 q->is_input_q = 1;
+                q->u.in.queue_start_poll = qdio_init->queue_start_poll;
                 setup_storage_lists(q, irq_ptr, input_sbal_array, i);
                 input_sbal_array += QDIO_MAX_BUFFERS_PER_Q;
 
@@ -177,6 +178,7 @@ static void setup_queues(struct qdio_irq *irq_ptr,
                 setup_queues_misc(q, irq_ptr, qdio_init->output_handler, i);
 
                 q->is_input_q = 0;
+                q->u.out.scan_threshold = qdio_init->scan_threshold;
                 setup_storage_lists(q, irq_ptr, output_sbal_array, i);
                 output_sbal_array += QDIO_MAX_BUFFERS_PER_Q;
 
@@ -195,14 +197,10 @@ static void process_ac_flags(struct qdio_irq *irq_ptr, unsigned char qdioac)
                 irq_ptr->siga_flag.output = 1;
         if (qdioac & AC1_SIGA_SYNC_NEEDED)
                 irq_ptr->siga_flag.sync = 1;
-        if (qdioac & AC1_AUTOMATIC_SYNC_ON_THININT)
-                irq_ptr->siga_flag.no_sync_ti = 1;
-        if (qdioac & AC1_AUTOMATIC_SYNC_ON_OUT_PCI)
-                irq_ptr->siga_flag.no_sync_out_pci = 1;
-
-        if (irq_ptr->siga_flag.no_sync_out_pci &&
-            irq_ptr->siga_flag.no_sync_ti)
-                irq_ptr->siga_flag.no_sync_out_ti = 1;
+        if (!(qdioac & AC1_AUTOMATIC_SYNC_ON_THININT))
+                irq_ptr->siga_flag.sync_after_ai = 1;
+        if (!(qdioac & AC1_AUTOMATIC_SYNC_ON_OUT_PCI))
+                irq_ptr->siga_flag.sync_out_after_pci = 1;
 }
 
 static void check_and_setup_qebsm(struct qdio_irq *irq_ptr,
@@ -450,7 +448,7 @@ void qdio_print_subchannel_info(struct qdio_irq *irq_ptr,
         char s[80];
 
         snprintf(s, 80, "qdio: %s %s on SC %x using "
-                 "AI:%d QEBSM:%d PCI:%d TDD:%d SIGA:%s%s%s%s%s%s\n",
+                 "AI:%d QEBSM:%d PCI:%d TDD:%d SIGA:%s%s%s%s%s\n",
                  dev_name(&cdev->dev),
                  (irq_ptr->qib.qfmt == QDIO_QETH_QFMT) ? "OSA" :
                         ((irq_ptr->qib.qfmt == QDIO_ZFCP_QFMT) ? "ZFCP" : "HS"),
@@ -462,9 +460,8 @@ void qdio_print_subchannel_info(struct qdio_irq *irq_ptr,
                  (irq_ptr->siga_flag.input) ? "R" : " ",
                  (irq_ptr->siga_flag.output) ? "W" : " ",
                  (irq_ptr->siga_flag.sync) ? "S" : " ",
-                 (!irq_ptr->siga_flag.no_sync_ti) ? "A" : " ",
-                 (!irq_ptr->siga_flag.no_sync_out_ti) ? "O" : " ",
-                 (!irq_ptr->siga_flag.no_sync_out_pci) ? "P" : " ");
+                 (irq_ptr->siga_flag.sync_after_ai) ? "A" : " ",
+                 (irq_ptr->siga_flag.sync_out_after_pci) ? "P" : " ");
         printk(KERN_INFO "%s", s);
 }
 
diff --git a/drivers/s390/cio/qdio_thinint.c b/drivers/s390/cio/qdio_thinint.c
index 8daf1b99f153..5c4e741d8221 100644
--- a/drivers/s390/cio/qdio_thinint.c
+++ b/drivers/s390/cio/qdio_thinint.c
@@ -8,6 +8,7 @@
  */
 #include <linux/io.h>
 #include <linux/slab.h>
+#include <linux/kernel_stat.h>
 #include <asm/atomic.h>
 #include <asm/debug.h>
 #include <asm/qdio.h>
@@ -25,35 +26,17 @@
  */
 #define TIQDIO_NR_NONSHARED_IND         63
 #define TIQDIO_NR_INDICATORS            (TIQDIO_NR_NONSHARED_IND + 1)
-#define TIQDIO_SHARED_IND               63
 
 /* list of thin interrupt input queues */
 static LIST_HEAD(tiq_list);
 DEFINE_MUTEX(tiq_list_lock);
 
 /* adapter local summary indicator */
-static unsigned char *tiqdio_alsi;
+static u8 *tiqdio_alsi;
 
-/* device state change indicators */
-struct indicator_t {
-        u32 ind;        /* u32 because of compare-and-swap performance */
-        atomic_t count; /* use count, 0 or 1 for non-shared indicators */
-};
-static struct indicator_t *q_indicators;
+struct indicator_t *q_indicators;
 
-static int css_qdio_omit_svs;
-
-static inline unsigned long do_clear_global_summary(void)
-{
-        register unsigned long __fn asm("1") = 3;
-        register unsigned long __tmp asm("2");
-        register unsigned long __time asm("3");
-
-        asm volatile(
-                "       .insn   rre,0xb2650000,2,0"
-                : "+d" (__fn), "=d" (__tmp), "=d" (__time));
-        return __time;
-}
+static u64 last_ai_time;
 
 /* returns addr for the device state change indicator */
 static u32 *get_indicator(void)
@@ -87,10 +70,6 @@ void tiqdio_add_input_queues(struct qdio_irq *irq_ptr)
         struct qdio_q *q;
         int i;
 
-        /* No TDD facility? If we must use SIGA-s we can also omit SVS. */
-        if (!css_qdio_omit_svs && irq_ptr->siga_flag.sync)
-                css_qdio_omit_svs = 1;
-
         mutex_lock(&tiq_list_lock);
         for_each_input_queue(irq_ptr, q, i)
                 list_add_rcu(&q->entry, &tiq_list);
@@ -116,65 +95,68 @@ void tiqdio_remove_input_queues(struct qdio_irq *irq_ptr)
         }
 }
 
-static inline int shared_ind(struct qdio_irq *irq_ptr)
+static inline u32 shared_ind_set(void)
 {
-        return irq_ptr->dsci == &q_indicators[TIQDIO_SHARED_IND].ind;
+        return q_indicators[TIQDIO_SHARED_IND].ind;
 }
 
 /**
  * tiqdio_thinint_handler - thin interrupt handler for qdio
- * @ind: pointer to adapter local summary indicator
- * @drv_data: NULL
+ * @alsi: pointer to adapter local summary indicator
+ * @data: NULL
  */
-static void tiqdio_thinint_handler(void *ind, void *drv_data)
+static void tiqdio_thinint_handler(void *alsi, void *data)
 {
+        u32 si_used = shared_ind_set();
         struct qdio_q *q;
 
-        /*
-         * SVS only when needed: issue SVS to benefit from iqdio interrupt
-         * avoidance (SVS clears adapter interrupt suppression overwrite)
-         */
-        if (!css_qdio_omit_svs)
-                do_clear_global_summary();
-
-        /*
-         * reset local summary indicator (tiqdio_alsi) to stop adapter
-         * interrupts for now
-         */
-        xchg((u8 *)ind, 0);
+        last_ai_time = S390_lowcore.int_clock;
+        kstat_cpu(smp_processor_id()).irqs[IOINT_QAI]++;
 
         /* protect tiq_list entries, only changed in activate or shutdown */
         rcu_read_lock();
 
         /* check for work on all inbound thinint queues */
-        list_for_each_entry_rcu(q, &tiq_list, entry)
+        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);
+                if (unlikely(shared_ind(q->irq_ptr->dsci))) {
+                        if (!si_used)
+                                continue;
+                } else if (!*q->irq_ptr->dsci)
+                        continue;
 
+                if (q->u.in.queue_start_poll) {
+                        /* skip if polling is enabled or already in work */
+                        if (test_and_set_bit(QDIO_QUEUE_IRQS_DISABLED,
+                                             &q->u.in.queue_irq_state)) {
+                                qperf_inc(q, int_discarded);
+                                continue;
+                        }
+
+                        /* avoid dsci clear here, done after processing */
+                        q->u.in.queue_start_poll(q->irq_ptr->cdev, q->nr,
+                                                 q->irq_ptr->int_parm);
+                } else {
                         /* only clear it if the indicator is non-shared */
-                        if (!shared_ind(q->irq_ptr))
+                        if (!shared_ind(q->irq_ptr->dsci))
                                 xchg(q->irq_ptr->dsci, 0);
                         /*
-                         * don't call inbound processing directly since
-                         * that could starve other thinint queues
+                         * Call inbound processing but not directly
+                         * since that could starve other thinint queues.
                          */
                         tasklet_schedule(&q->tasklet);
                 }
-
+                qperf_inc(q, adapter_int);
+        }
         rcu_read_unlock();
 
         /*
-         * if we used the shared indicator clear it now after all queues
-         * were processed
+         * If the shared indicator was used clear it now after all queues
+         * were processed.
          */
-        if (atomic_read(&q_indicators[TIQDIO_SHARED_IND].count)) {
+        if (si_used && shared_ind_set())
                 xchg(&q_indicators[TIQDIO_SHARED_IND].ind, 0);
-
-                /* prevent racing */
-                if (*tiqdio_alsi)
-                        xchg(&q_indicators[TIQDIO_SHARED_IND].ind, 1 << 7);
-        }
 }
 
 static int set_subchannel_ind(struct qdio_irq *irq_ptr, int reset)
@@ -259,12 +241,6 @@ int qdio_establish_thinint(struct qdio_irq *irq_ptr)
 {
         if (!is_thinint_irq(irq_ptr))
                 return 0;
-
-        /* Check for aif time delay disablement. If installed,
-         * omit SVS even under LPAR
-         */
-        if (css_general_characteristics.aif_tdd)
-                css_qdio_omit_svs = 1;
         return set_subchannel_ind(irq_ptr, 0);
 }
 
@@ -282,8 +258,8 @@ void qdio_shutdown_thinint(struct qdio_irq *irq_ptr)
                 return;
 
         /* reset adapter interrupt indicators */
-        put_indicator(irq_ptr->dsci);
         set_subchannel_ind(irq_ptr, 1);
+        put_indicator(irq_ptr->dsci);
 }
 
 void __exit tiqdio_unregister_thinints(void)
diff --git a/drivers/s390/crypto/ap_bus.c b/drivers/s390/crypto/ap_bus.c
index 91c6028d7b74..16e4a25596e7 100644
--- a/drivers/s390/crypto/ap_bus.c
+++ b/drivers/s390/crypto/ap_bus.c
@@ -27,6 +27,7 @@
 #define KMSG_COMPONENT "ap"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
+#include <linux/kernel_stat.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/delay.h>
@@ -154,14 +155,7 @@ static inline int ap_instructions_available(void)
  */
 static int ap_interrupts_available(void)
 {
-        unsigned long long facility_bits[2];
-
-        if (stfle(facility_bits, 2) <= 1)
-                return 0;
-        if (!(facility_bits[0] & (1ULL << 61)) ||
-            !(facility_bits[1] & (1ULL << 62)))
-                return 0;
-        return 1;
+        return test_facility(2) && test_facility(65);
 }
 
 /**
@@ -228,6 +222,69 @@ ap_queue_interruption_control(ap_qid_t qid, void *ind)
 }
 #endif
 
+static inline struct ap_queue_status __ap_4096_commands_available(ap_qid_t qid,
+                                                                  int *support)
+{
+        register unsigned long reg0 asm ("0") = 0UL | qid | (1UL << 23);
+        register struct ap_queue_status reg1 asm ("1");
+        register unsigned long reg2 asm ("2") = 0UL;
+
+        asm volatile(
+                ".long 0xb2af0000\n"
+                "0: la    %1,0\n"
+                "1:\n"
+                EX_TABLE(0b, 1b)
+                : "+d" (reg0), "=d" (reg1), "=d" (reg2)
+                :
+                : "cc");
+
+        if (reg2 & 0x6000000000000000ULL)
+                *support = 1;
+        else
+                *support = 0;
+
+        return reg1;
+}
+
+/**
+ * ap_4096_commands_availablen(): Check for availability of 4096 bit RSA
+ * support.
+ * @qid: The AP queue number
+ *
+ * Returns 1 if 4096 bit RSA keys are support fo the AP, returns 0 if not.
+ */
+int ap_4096_commands_available(ap_qid_t qid)
+{
+        struct ap_queue_status status;
+        int i, support = 0;
+        status = __ap_4096_commands_available(qid, &support);
+
+        for (i = 0; i < AP_MAX_RESET; i++) {
+                switch (status.response_code) {
+                case AP_RESPONSE_NORMAL:
+                        return support;
+                case AP_RESPONSE_RESET_IN_PROGRESS:
+                case AP_RESPONSE_BUSY:
+                        break;
+                case AP_RESPONSE_Q_NOT_AVAIL:
+                case AP_RESPONSE_DECONFIGURED:
+                case AP_RESPONSE_CHECKSTOPPED:
+                case AP_RESPONSE_INVALID_ADDRESS:
+                        return 0;
+                case AP_RESPONSE_OTHERWISE_CHANGED:
+                        break;
+                default:
+                        break;
+                }
+                if (i < AP_MAX_RESET - 1) {
+                        udelay(5);
+                        status = __ap_4096_commands_available(qid, &support);
+                }
+        }
+        return support;
+}
+EXPORT_SYMBOL(ap_4096_commands_available);
+
 /**
  * ap_queue_enable_interruption(): Enable interruption on an AP.
  * @qid: The AP queue number
@@ -1049,6 +1106,7 @@ out:
 
 static void ap_interrupt_handler(void *unused1, void *unused2)
 {
+        kstat_cpu(smp_processor_id()).irqs[IOINT_APB]++;
         tasklet_schedule(&ap_tasklet);
 }
 
@@ -1125,8 +1183,12 @@ static void ap_scan_bus(struct work_struct *unused)
                 INIT_LIST_HEAD(&ap_dev->list);
                 setup_timer(&ap_dev->timeout, ap_request_timeout,
                             (unsigned long) ap_dev);
-                if (device_type == 0)
-                        ap_probe_device_type(ap_dev);
+                if (device_type == 0) {
+                        if (ap_probe_device_type(ap_dev)) {
+                                kfree(ap_dev);
+                                continue;
+                        }
+                }
                 else
                         ap_dev->device_type = device_type;
 
diff --git a/drivers/s390/crypto/ap_bus.h b/drivers/s390/crypto/ap_bus.h
index 4785d07cd447..08b9738285b4 100644
--- a/drivers/s390/crypto/ap_bus.h
+++ b/drivers/s390/crypto/ap_bus.h
@@ -196,4 +196,6 @@ void ap_flush_queue(struct ap_device *ap_dev);
 int ap_module_init(void);
 void ap_module_exit(void);
 
+int ap_4096_commands_available(ap_qid_t qid);
+
 #endif /* _AP_BUS_H_ */
diff --git a/drivers/s390/crypto/zcrypt_api.c b/drivers/s390/crypto/zcrypt_api.c
index 41e0aaefafd5..8e65447f76b7 100644
--- a/drivers/s390/crypto/zcrypt_api.c
+++ b/drivers/s390/crypto/zcrypt_api.c
@@ -35,7 +35,6 @@
 #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>
@@ -397,8 +396,15 @@ static long zcrypt_rsa_crt(struct ica_rsa_modexpo_crt *crt)
                         if (copied == 0) {
                                 unsigned int len;
                                 spin_unlock_bh(&zcrypt_device_lock);
-                                /* len is max 256 / 2 - 120 = 8 */
-                                len = crt->inputdatalength / 2 - 120;
+                                /* len is max 256 / 2 - 120 = 8
+                                 * For bigger device just assume len of leading
+                                 * 0s is 8 as stated in the requirements for
+                                 * ica_rsa_modexpo_crt struct in zcrypt.h.
+                                 */
+                                if (crt->inputdatalength <= 256)
+                                        len = crt->inputdatalength / 2 - 120;
+                                else
+                                        len = 8;
                                 if (len > sizeof(z1))
                                         return -EFAULT;
                                 z1 = z2 = z3 = 0;
@@ -406,6 +412,7 @@ static long zcrypt_rsa_crt(struct ica_rsa_modexpo_crt *crt)
                                     copy_from_user(&z2, crt->bp_key, len) ||
                                     copy_from_user(&z3, crt->u_mult_inv, len))
                                         return -EFAULT;
+                                z1 = z2 = z3 = 0;
                                 copied = 1;
                                 /*
                                  * We have to restart device lookup -
@@ -897,7 +904,8 @@ static const struct file_operations zcrypt_fops = {
         .compat_ioctl   = zcrypt_compat_ioctl,
 #endif
         .open           = zcrypt_open,
-        .release        = zcrypt_release
+        .release        = zcrypt_release,
+        .llseek         = no_llseek,
 };
 
 /*
diff --git a/drivers/s390/crypto/zcrypt_api.h b/drivers/s390/crypto/zcrypt_api.h
index 8e7ffbf2466c..9688f3985b07 100644
--- a/drivers/s390/crypto/zcrypt_api.h
+++ b/drivers/s390/crypto/zcrypt_api.h
@@ -76,7 +76,7 @@ struct ica_z90_status {
 
 /**
  * Large random numbers are pulled in 4096 byte chunks from the crypto cards
- * and stored in a page. Be carefull when increasing this buffer due to size
+ * and stored in a page. Be careful when increasing this buffer due to size
  * limitations for AP requests.
  */
 #define ZCRYPT_RNG_BUFFER_SIZE  4096
@@ -109,6 +109,7 @@ struct zcrypt_device {
         int request_count;              /* # current requests. */
 
         struct ap_message reply;        /* Per-device reply structure. */
+        int max_exp_bit_length;
 };
 
 struct zcrypt_device *zcrypt_device_alloc(size_t);
diff --git a/drivers/s390/crypto/zcrypt_cex2a.c b/drivers/s390/crypto/zcrypt_cex2a.c
index 9c409efa1ecf..2176d00b395e 100644
--- a/drivers/s390/crypto/zcrypt_cex2a.c
+++ b/drivers/s390/crypto/zcrypt_cex2a.c
@@ -41,7 +41,7 @@
 #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 CEX3A_MAX_MOD_SIZE      512     /* 4096 bits    */
 
 #define CEX2A_SPEED_RATING      970
 #define CEX3A_SPEED_RATING      900 /* Fixme: Needs finetuning */
@@ -49,8 +49,10 @@
 #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 CEX3A_MAX_RESPONSE_SIZE 0x210   /* 512 bit modulus
+                                         * (max outputdatalength) +
+                                         * type80_hdr*/
+#define CEX3A_MAX_MESSAGE_SIZE  sizeof(struct type50_crb3_msg)
 
 #define CEX2A_CLEANUP_TIME      (15*HZ)
 #define CEX3A_CLEANUP_TIME      CEX2A_CLEANUP_TIME
@@ -110,7 +112,7 @@ static int ICAMEX_msg_to_type50MEX_msg(struct zcrypt_device *zdev,
                 mod = meb1->modulus + sizeof(meb1->modulus) - mod_len;
                 exp = meb1->exponent + sizeof(meb1->exponent) - mod_len;
                 inp = meb1->message + sizeof(meb1->message) - mod_len;
-        } else {
+        } else if (mod_len <= 256) {
                 struct type50_meb2_msg *meb2 = ap_msg->message;
                 memset(meb2, 0, sizeof(*meb2));
                 ap_msg->length = sizeof(*meb2);
@@ -120,6 +122,17 @@ static int ICAMEX_msg_to_type50MEX_msg(struct zcrypt_device *zdev,
                 mod = meb2->modulus + sizeof(meb2->modulus) - mod_len;
                 exp = meb2->exponent + sizeof(meb2->exponent) - mod_len;
                 inp = meb2->message + sizeof(meb2->message) - mod_len;
+        } else {
+                /* mod_len > 256 = 4096 bit RSA Key */
+                struct type50_meb3_msg *meb3 = ap_msg->message;
+                memset(meb3, 0, sizeof(*meb3));
+                ap_msg->length = sizeof(*meb3);
+                meb3->header.msg_type_code = TYPE50_TYPE_CODE;
+                meb3->header.msg_len = sizeof(*meb3);
+                meb3->keyblock_type = TYPE50_MEB3_FMT;
+                mod = meb3->modulus + sizeof(meb3->modulus) - mod_len;
+                exp = meb3->exponent + sizeof(meb3->exponent) - mod_len;
+                inp = meb3->message + sizeof(meb3->message) - mod_len;
         }
 
         if (copy_from_user(mod, mex->n_modulus, mod_len) ||
@@ -142,7 +155,7 @@ static int ICACRT_msg_to_type50CRT_msg(struct zcrypt_device *zdev,
                                        struct ap_message *ap_msg,
                                        struct ica_rsa_modexpo_crt *crt)
 {
-        int mod_len, short_len, long_len, long_offset;
+        int mod_len, short_len, long_len, long_offset, limit;
         unsigned char *p, *q, *dp, *dq, *u, *inp;
 
         mod_len = crt->inputdatalength;
@@ -152,14 +165,20 @@ static int ICACRT_msg_to_type50CRT_msg(struct zcrypt_device *zdev,
         /*
          * CEX2A cannot handle p, dp, or U > 128 bytes.
          * If we have one of these, we need to do extra checking.
+         * For CEX3A the limit is 256 bytes.
          */
-        if (long_len > 128) {
+        if (zdev->max_mod_size == CEX3A_MAX_MOD_SIZE)
+                limit = 256;
+        else
+                limit = 128;
+
+        if (long_len > limit) {
                 /*
                  * zcrypt_rsa_crt already checked for the leading
                  * zeroes of np_prime, bp_key and u_mult_inc.
                  */
-                long_offset = long_len - 128;
-                long_len = 128;
+                long_offset = long_len - limit;
+                long_len = limit;
         } else
                 long_offset = 0;
 
@@ -180,7 +199,7 @@ static int ICACRT_msg_to_type50CRT_msg(struct zcrypt_device *zdev,
                 dq = crb1->dq + sizeof(crb1->dq) - short_len;
                 u = crb1->u + sizeof(crb1->u) - long_len;
                 inp = crb1->message + sizeof(crb1->message) - mod_len;
-        } else {
+        } else if (long_len <= 128) {
                 struct type50_crb2_msg *crb2 = ap_msg->message;
                 memset(crb2, 0, sizeof(*crb2));
                 ap_msg->length = sizeof(*crb2);
@@ -193,6 +212,20 @@ static int ICACRT_msg_to_type50CRT_msg(struct zcrypt_device *zdev,
                 dq = crb2->dq + sizeof(crb2->dq) - short_len;
                 u = crb2->u + sizeof(crb2->u) - long_len;
                 inp = crb2->message + sizeof(crb2->message) - mod_len;
+        } else {
+                /* long_len >= 256 */
+                struct type50_crb3_msg *crb3 = ap_msg->message;
+                memset(crb3, 0, sizeof(*crb3));
+                ap_msg->length = sizeof(*crb3);
+                crb3->header.msg_type_code = TYPE50_TYPE_CODE;
+                crb3->header.msg_len = sizeof(*crb3);
+                crb3->keyblock_type = TYPE50_CRB3_FMT;
+                p = crb3->p + sizeof(crb3->p) - long_len;
+                q = crb3->q + sizeof(crb3->q) - short_len;
+                dp = crb3->dp + sizeof(crb3->dp) - long_len;
+                dq = crb3->dq + sizeof(crb3->dq) - short_len;
+                u = crb3->u + sizeof(crb3->u) - long_len;
+                inp = crb3->message + sizeof(crb3->message) - mod_len;
         }
 
         if (copy_from_user(p, crt->np_prime + long_offset, long_len) ||
@@ -203,7 +236,6 @@ static int ICACRT_msg_to_type50CRT_msg(struct zcrypt_device *zdev,
             copy_from_user(inp, crt->inputdata, mod_len))
                 return -EFAULT;
 
-
         return 0;
 }
 
@@ -230,7 +262,10 @@ static int convert_type80(struct zcrypt_device *zdev,
                 zdev->online = 0;
                 return -EAGAIN; /* repeat the request on a different device. */
         }
-        BUG_ON(t80h->len > CEX2A_MAX_RESPONSE_SIZE);
+        if (zdev->user_space_type == ZCRYPT_CEX2A)
+                BUG_ON(t80h->len > CEX2A_MAX_RESPONSE_SIZE);
+        else
+                BUG_ON(t80h->len > CEX3A_MAX_RESPONSE_SIZE);
         data = reply->message + t80h->len - outputdatalength;
         if (copy_to_user(outputdata, data, outputdatalength))
                 return -EFAULT;
@@ -282,7 +317,10 @@ static void zcrypt_cex2a_receive(struct ap_device *ap_dev,
         }
         t80h = reply->message;
         if (t80h->type == TYPE80_RSP_CODE) {
-                length = min(CEX2A_MAX_RESPONSE_SIZE, (int) t80h->len);
+                if (ap_dev->device_type == AP_DEVICE_TYPE_CEX2A)
+                        length = min(CEX2A_MAX_RESPONSE_SIZE, (int) t80h->len);
+                else
+                        length = min(CEX3A_MAX_RESPONSE_SIZE, (int) t80h->len);
                 memcpy(msg->message, reply->message, length);
         } else
                 memcpy(msg->message, reply->message, sizeof error_reply);
@@ -307,7 +345,10 @@ static long zcrypt_cex2a_modexpo(struct zcrypt_device *zdev,
         int rc;
 
         ap_init_message(&ap_msg);
-        ap_msg.message = kmalloc(CEX2A_MAX_MESSAGE_SIZE, GFP_KERNEL);
+        if (zdev->user_space_type == ZCRYPT_CEX2A)
+                ap_msg.message = kmalloc(CEX2A_MAX_MESSAGE_SIZE, GFP_KERNEL);
+        else
+                ap_msg.message = kmalloc(CEX3A_MAX_MESSAGE_SIZE, GFP_KERNEL);
         if (!ap_msg.message)
                 return -ENOMEM;
         ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
@@ -345,7 +386,10 @@ static long zcrypt_cex2a_modexpo_crt(struct zcrypt_device *zdev,
         int rc;
 
         ap_init_message(&ap_msg);
-        ap_msg.message = kmalloc(CEX2A_MAX_MESSAGE_SIZE, GFP_KERNEL);
+        if (zdev->user_space_type == ZCRYPT_CEX2A)
+                ap_msg.message = kmalloc(CEX2A_MAX_MESSAGE_SIZE, GFP_KERNEL);
+        else
+                ap_msg.message = kmalloc(CEX3A_MAX_MESSAGE_SIZE, GFP_KERNEL);
         if (!ap_msg.message)
                 return -ENOMEM;
         ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
@@ -397,6 +441,7 @@ static int zcrypt_cex2a_probe(struct ap_device *ap_dev)
                 zdev->max_mod_size = CEX2A_MAX_MOD_SIZE;
                 zdev->short_crt = 1;
                 zdev->speed_rating = CEX2A_SPEED_RATING;
+                zdev->max_exp_bit_length = CEX2A_MAX_MOD_SIZE;
                 break;
         case AP_DEVICE_TYPE_CEX3A:
                 zdev = zcrypt_device_alloc(CEX3A_MAX_RESPONSE_SIZE);
@@ -404,8 +449,13 @@ static int zcrypt_cex2a_probe(struct ap_device *ap_dev)
                         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->min_mod_size = CEX2A_MIN_MOD_SIZE;
+                zdev->max_mod_size = CEX2A_MAX_MOD_SIZE;
+                zdev->max_exp_bit_length = CEX2A_MAX_MOD_SIZE;
+                if (ap_4096_commands_available(ap_dev->qid)) {
+                        zdev->max_mod_size = CEX3A_MAX_MOD_SIZE;
+                        zdev->max_exp_bit_length = CEX3A_MAX_MOD_SIZE;
+                }
                 zdev->short_crt = 1;
                 zdev->speed_rating = CEX3A_SPEED_RATING;
                 break;
diff --git a/drivers/s390/crypto/zcrypt_cex2a.h b/drivers/s390/crypto/zcrypt_cex2a.h
index 8f69d1dacab8..0350665810cf 100644
--- a/drivers/s390/crypto/zcrypt_cex2a.h
+++ b/drivers/s390/crypto/zcrypt_cex2a.h
@@ -51,8 +51,10 @@ struct type50_hdr {
 
 #define TYPE50_MEB1_FMT         0x0001
 #define TYPE50_MEB2_FMT         0x0002
+#define TYPE50_MEB3_FMT         0x0003
 #define TYPE50_CRB1_FMT         0x0011
 #define TYPE50_CRB2_FMT         0x0012
+#define TYPE50_CRB3_FMT         0x0013
 
 /* Mod-Exp, with a small modulus */
 struct type50_meb1_msg {
@@ -74,6 +76,16 @@ struct type50_meb2_msg {
         unsigned char   message[256];
 } __attribute__((packed));
 
+/* Mod-Exp, with a larger modulus */
+struct type50_meb3_msg {
+        struct type50_hdr header;
+        unsigned short  keyblock_type;  /* 0x0003 */
+        unsigned char   reserved[6];
+        unsigned char   exponent[512];
+        unsigned char   modulus[512];
+        unsigned char   message[512];
+} __attribute__((packed));
+
 /* CRT, with a small modulus */
 struct type50_crb1_msg {
         struct type50_hdr header;
@@ -100,6 +112,19 @@ struct type50_crb2_msg {
         unsigned char   message[256];
 } __attribute__((packed));
 
+/* CRT, with a larger modulus */
+struct type50_crb3_msg {
+        struct type50_hdr header;
+        unsigned short  keyblock_type;  /* 0x0013 */
+        unsigned char   reserved[6];
+        unsigned char   p[256];
+        unsigned char   q[256];
+        unsigned char   dp[256];
+        unsigned char   dq[256];
+        unsigned char   u[256];
+        unsigned char   message[512];
+} __attribute__((packed));
+
 /**
  * The type 80 response family is associated with a CEX2A card.
  *
diff --git a/drivers/s390/crypto/zcrypt_pcica.c b/drivers/s390/crypto/zcrypt_pcica.c
index 09e934b295a0..1afb69c75fea 100644
--- a/drivers/s390/crypto/zcrypt_pcica.c
+++ b/drivers/s390/crypto/zcrypt_pcica.c
@@ -373,6 +373,7 @@ static int zcrypt_pcica_probe(struct ap_device *ap_dev)
         zdev->min_mod_size = PCICA_MIN_MOD_SIZE;
         zdev->max_mod_size = PCICA_MAX_MOD_SIZE;
         zdev->speed_rating = PCICA_SPEED_RATING;
+        zdev->max_exp_bit_length = PCICA_MAX_MOD_SIZE;
         ap_dev->reply = &zdev->reply;
         ap_dev->private = zdev;
         rc = zcrypt_device_register(zdev);
diff --git a/drivers/s390/crypto/zcrypt_pcicc.c b/drivers/s390/crypto/zcrypt_pcicc.c
index 9dec5c77cff4..aa4c050a5694 100644
--- a/drivers/s390/crypto/zcrypt_pcicc.c
+++ b/drivers/s390/crypto/zcrypt_pcicc.c
@@ -579,6 +579,7 @@ static int zcrypt_pcicc_probe(struct ap_device *ap_dev)
         zdev->min_mod_size = PCICC_MIN_MOD_SIZE;
         zdev->max_mod_size = PCICC_MAX_MOD_SIZE;
         zdev->speed_rating = PCICC_SPEED_RATING;
+        zdev->max_exp_bit_length = PCICC_MAX_MOD_SIZE;
         ap_dev->reply = &zdev->reply;
         ap_dev->private = zdev;
         rc = zcrypt_device_register(zdev);
diff --git a/drivers/s390/crypto/zcrypt_pcixcc.c b/drivers/s390/crypto/zcrypt_pcixcc.c
index 510fab4577d4..4f85eb725f4f 100644
--- a/drivers/s390/crypto/zcrypt_pcixcc.c
+++ b/drivers/s390/crypto/zcrypt_pcixcc.c
@@ -45,12 +45,12 @@
 #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 CEX3C_MAX_MOD_SIZE      512     /* 4096 bits    */
 
 #define PCIXCC_MCL2_SPEED_RATING        7870
 #define PCIXCC_MCL3_SPEED_RATING        7870
 #define CEX2C_SPEED_RATING              7000
-#define CEX3C_SPEED_RATING              6500    /* FIXME: needs finetuning */
+#define CEX3C_SPEED_RATING              6500
 
 #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      */
@@ -567,6 +567,15 @@ static int convert_response_ica(struct zcrypt_device *zdev,
         case TYPE88_RSP_CODE:
                 return convert_error(zdev, reply);
         case TYPE86_RSP_CODE:
+                if (msg->cprbx.ccp_rtcode &&
+                   (msg->cprbx.ccp_rscode == 0x14f) &&
+                   (outputdatalength > 256)) {
+                        if (zdev->max_exp_bit_length <= 17) {
+                                zdev->max_exp_bit_length = 17;
+                                return -EAGAIN;
+                        } else
+                                return -EINVAL;
+                }
                 if (msg->hdr.reply_code)
                         return convert_error(zdev, reply);
                 if (msg->cprbx.cprb_ver_id == 0x02)
@@ -1052,11 +1061,13 @@ static int zcrypt_pcixcc_probe(struct ap_device *ap_dev)
                         zdev->speed_rating = PCIXCC_MCL2_SPEED_RATING;
                         zdev->min_mod_size = PCIXCC_MIN_MOD_SIZE_OLD;
                         zdev->max_mod_size = PCIXCC_MAX_MOD_SIZE;
+                        zdev->max_exp_bit_length = PCIXCC_MAX_MOD_SIZE;
                 } else {
                         zdev->type_string = "PCIXCC_MCL3";
                         zdev->speed_rating = PCIXCC_MCL3_SPEED_RATING;
                         zdev->min_mod_size = PCIXCC_MIN_MOD_SIZE;
                         zdev->max_mod_size = PCIXCC_MAX_MOD_SIZE;
+                        zdev->max_exp_bit_length = PCIXCC_MAX_MOD_SIZE;
                 }
                 break;
         case AP_DEVICE_TYPE_CEX2C:
@@ -1065,6 +1076,7 @@ static int zcrypt_pcixcc_probe(struct ap_device *ap_dev)
                 zdev->speed_rating = CEX2C_SPEED_RATING;
                 zdev->min_mod_size = PCIXCC_MIN_MOD_SIZE;
                 zdev->max_mod_size = PCIXCC_MAX_MOD_SIZE;
+                zdev->max_exp_bit_length = PCIXCC_MAX_MOD_SIZE;
                 break;
         case AP_DEVICE_TYPE_CEX3C:
                 zdev->user_space_type = ZCRYPT_CEX3C;
@@ -1072,6 +1084,7 @@ static int zcrypt_pcixcc_probe(struct ap_device *ap_dev)
                 zdev->speed_rating = CEX3C_SPEED_RATING;
                 zdev->min_mod_size = CEX3C_MIN_MOD_SIZE;
                 zdev->max_mod_size = CEX3C_MAX_MOD_SIZE;
+                zdev->max_exp_bit_length = CEX3C_MAX_MOD_SIZE;
                 break;
         default:
                 goto out_free;
diff --git a/drivers/s390/kvm/kvm_virtio.c b/drivers/s390/kvm/kvm_virtio.c
index 4e298bc8949d..aec60d55b10d 100644
--- a/drivers/s390/kvm/kvm_virtio.c
+++ b/drivers/s390/kvm/kvm_virtio.c
@@ -10,6 +10,7 @@
  *    Author(s): Christian Borntraeger <borntraeger@de.ibm.com>
  */
 
+#include <linux/kernel_stat.h>
 #include <linux/init.h>
 #include <linux/bootmem.h>
 #include <linux/err.h>
@@ -24,7 +25,7 @@
 #include <asm/kvm_para.h>
 #include <asm/kvm_virtio.h>
 #include <asm/setup.h>
-#include <asm/s390_ext.h>
+#include <asm/irq.h>
 
 #define VIRTIO_SUBCODE_64 0x0D00
 
@@ -32,6 +33,7 @@
  * The pointer to our (page) of device descriptions.
  */
 static void *kvm_devices;
+struct work_struct hotplug_work;
 
 struct kvm_device {
         struct virtio_device vdev;
@@ -328,33 +330,86 @@ static void scan_devices(void)
 }
 
 /*
+ * match for a kvm device with a specific desc pointer
+ */
+static int match_desc(struct device *dev, void *data)
+{
+        if ((ulong)to_kvmdev(dev_to_virtio(dev))->desc == (ulong)data)
+                return 1;
+
+        return 0;
+}
+
+/*
+ * hotplug_device tries to find changes in the device page.
+ */
+static void hotplug_devices(struct work_struct *dummy)
+{
+        unsigned int i;
+        struct kvm_device_desc *d;
+        struct device *dev;
+
+        for (i = 0; i < PAGE_SIZE; i += desc_size(d)) {
+                d = kvm_devices + i;
+
+                /* end of list */
+                if (d->type == 0)
+                        break;
+
+                /* device already exists */
+                dev = device_find_child(kvm_root, d, match_desc);
+                if (dev) {
+                        /* XXX check for hotplug remove */
+                        put_device(dev);
+                        continue;
+                }
+
+                /* new device */
+                printk(KERN_INFO "Adding new virtio device %p\n", d);
+                add_kvm_device(d, i);
+        }
+}
+
+/*
  * we emulate the request_irq behaviour on top of s390 extints
  */
-static void kvm_extint_handler(u16 code)
+static void kvm_extint_handler(unsigned int ext_int_code,
+                               unsigned int param32, unsigned long param64)
 {
         struct virtqueue *vq;
         u16 subcode;
-        int config_changed;
+        u32 param;
 
-        subcode = S390_lowcore.cpu_addr;
+        subcode = ext_int_code >> 16;
         if ((subcode & 0xff00) != VIRTIO_SUBCODE_64)
                 return;
+        kstat_cpu(smp_processor_id()).irqs[EXTINT_VRT]++;
 
         /* The LSB might be overloaded, we have to mask it */
-        vq = (struct virtqueue *)(S390_lowcore.ext_params2 & ~1UL);
+        vq = (struct virtqueue *)(param64 & ~1UL);
 
-        /* We use the LSB of extparam, to decide, if this interrupt is a config
-         * change or a "standard" interrupt */
-        config_changed = S390_lowcore.ext_params & 1;
+        /* We use ext_params to decide what this interrupt means */
+        param = param32 & VIRTIO_PARAM_MASK;
 
-        if (config_changed) {
+        switch (param) {
+        case VIRTIO_PARAM_CONFIG_CHANGED:
+        {
                 struct virtio_driver *drv;
                 drv = container_of(vq->vdev->dev.driver,
                                    struct virtio_driver, driver);
                 if (drv->config_changed)
                         drv->config_changed(vq->vdev);
-        } else
+
+                break;
+        }
+        case VIRTIO_PARAM_DEV_ADD:
+                schedule_work(&hotplug_work);
+                break;
+        case VIRTIO_PARAM_VRING_INTERRUPT:
+        default:
                 vring_interrupt(0, vq);
+                break;
+        }
 }
 
 /*
@@ -383,7 +438,9 @@ static int __init kvm_devices_init(void)
 
         kvm_devices = (void *) real_memory_size;
 
-        ctl_set_bit(0, 9);
+        INIT_WORK(&hotplug_work, hotplug_devices);
+
+        service_subclass_irq_register();
         register_external_interrupt(0x2603, kvm_extint_handler);
 
         scan_devices();
diff --git a/drivers/s390/net/Kconfig b/drivers/s390/net/Kconfig
index 977bb4d4ed15..fa80ba1f0344 100644
--- a/drivers/s390/net/Kconfig
+++ b/drivers/s390/net/Kconfig
@@ -2,7 +2,8 @@ menu "S/390 network device drivers"
         depends on NETDEVICES && S390
 
 config LCS
-        tristate "Lan Channel Station Interface"
+        def_tristate m
+        prompt "Lan Channel Station Interface"
         depends on CCW && NETDEVICES && (NET_ETHERNET || TR || FDDI)
         help
            Select this option if you want to use LCS networking on IBM System z.
@@ -12,7 +13,8 @@ config LCS
            If you do not know what it is, it's safe to choose Y.
 
 config CTCM
-        tristate "CTC and MPC SNA device support"
+        def_tristate m
+        prompt "CTC and MPC SNA device support"
         depends on CCW && NETDEVICES
         help
           Select this option if you want to use channel-to-channel
@@ -26,7 +28,8 @@ config CTCM
           If you do not need any channel-to-channel connection, choose N.
 
 config NETIUCV
-        tristate "IUCV network device support (VM only)"
+        def_tristate m
+        prompt "IUCV network device support (VM only)"
         depends on IUCV && NETDEVICES
         help
           Select this option if you want to use inter-user communication
@@ -37,14 +40,16 @@ config NETIUCV
           The module name is netiucv. If unsure, choose Y.
 
 config SMSGIUCV
-        tristate "IUCV special message support (VM only)"
+        def_tristate m
+        prompt "IUCV special message support (VM only)"
         depends on IUCV
         help
           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)"
+        def_tristate m
+        prompt "Deliver IUCV special messages as uevents (VM only)"
         depends on SMSGIUCV
         help
           Select this option to deliver CP special messages (SMSGs) as
@@ -54,7 +59,8 @@ config SMSGIUCV_EVENT
           To compile as a module, choose M. The module name is "smsgiucv_app".
 
 config CLAW
-        tristate "CLAW device support"
+        def_tristate m
+        prompt "CLAW device support"
         depends on CCW && NETDEVICES
         help
           This driver supports channel attached CLAW devices.
@@ -64,7 +70,8 @@ config CLAW
           To compile into the kernel, choose Y.
 
 config QETH
-        tristate "Gigabit Ethernet device support"
+        def_tristate y
+        prompt "Gigabit Ethernet device support"
         depends on CCW && NETDEVICES && IP_MULTICAST && QDIO
         help
           This driver supports the IBM System z OSA Express adapters
@@ -78,28 +85,28 @@ config QETH
           The module name is qeth.
 
 config QETH_L2
-        tristate "qeth layer 2 device support"
-        depends on QETH
-        help
-          Select this option to be able to run qeth devices in layer 2 mode.
-          To compile as a module, choose M. The module name is qeth_l2.
-          If unsure, choose y.
+        def_tristate y
+        prompt "qeth layer 2 device support"
+        depends on QETH
+        help
+          Select this option to be able to run qeth devices in layer 2 mode.
+          To compile as a module, choose M. The module name is qeth_l2.
+          If unsure, choose y.
 
 config QETH_L3
-        tristate "qeth layer 3 device support"
-        depends on QETH
-        help
-          Select this option to be able to run qeth devices in layer 3 mode.
-          To compile as a module choose M. The module name is qeth_l3.
-          If unsure, choose Y.
+        def_tristate y
+        prompt "qeth layer 3 device support"
+        depends on QETH
+        help
+          Select this option to be able to run qeth devices in layer 3 mode.
+          To compile as a module choose M. The module name is qeth_l3.
+          If unsure, choose Y.
 
 config QETH_IPV6
-        bool
-        depends on (QETH_L3 = IPV6) || (QETH_L3 && IPV6 = 'y')
-        default y
+        def_bool y if (QETH_L3 = IPV6) || (QETH_L3 && IPV6 = 'y')
 
 config CCWGROUP
         tristate
-        default (LCS || CTCM || QETH)
+        default (LCS || CTCM || QETH || CLAW)
 
 endmenu
diff --git a/drivers/s390/net/claw.c b/drivers/s390/net/claw.c
index 8e4153d740f3..f1fa2483ae6b 100644
--- a/drivers/s390/net/claw.c
+++ b/drivers/s390/net/claw.c
@@ -63,6 +63,7 @@
 
 #define KMSG_COMPONENT "claw"
 
+#include <linux/kernel_stat.h>
 #include <asm/ccwdev.h>
 #include <asm/ccwgroup.h>
 #include <asm/debug.h>
@@ -263,8 +264,10 @@ static struct device *claw_root_dev;
 /* ccwgroup table  */
 
 static struct ccwgroup_driver claw_group_driver = {
-        .owner       = THIS_MODULE,
-        .name        = "claw",
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "claw",
+        },
         .max_slaves  = 2,
         .driver_id   = 0xC3D3C1E6,
         .probe       = claw_probe,
@@ -281,8 +284,10 @@ static struct ccw_device_id claw_ids[] = {
 MODULE_DEVICE_TABLE(ccw, claw_ids);
 
 static struct ccw_driver claw_ccw_driver = {
-        .owner  = THIS_MODULE,
-        .name   = "claw",
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "claw",
+        },
         .ids    = claw_ids,
         .probe  = ccwgroup_probe_ccwdev,
         .remove = ccwgroup_remove_ccwdev,
@@ -640,6 +645,7 @@ claw_irq_handler(struct ccw_device *cdev,
         struct claw_env  *p_env;
         struct chbk *p_ch_r=NULL;
 
+        kstat_cpu(smp_processor_id()).irqs[IOINT_CLW]++;
         CLAW_DBF_TEXT(4, trace, "clawirq");
         /* Bypass all 'unsolicited interrupts' */
         privptr = dev_get_drvdata(&cdev->dev);
@@ -773,7 +779,7 @@ claw_irq_handler(struct ccw_device *cdev,
         case CLAW_START_WRITE:
                 if (p_ch->irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) {
                         dev_info(&cdev->dev,
-                                "%s: Unit Check Occured in "
+                                "%s: Unit Check Occurred in "
                                 "write channel\n", dev->name);
                         clear_bit(0, (void *)&p_ch->IO_active);
                         if (p_ch->irb->ecw[0] & 0x80) {
@@ -839,12 +845,10 @@ claw_irq_tasklet ( unsigned long data )
 {
         struct chbk * p_ch;
         struct net_device  *dev;
-        struct claw_privbk *       privptr;
 
         p_ch = (struct chbk *) data;
         dev = (struct net_device *)p_ch->ndev;
         CLAW_DBF_TEXT(4, trace, "IRQtask");
-        privptr = (struct claw_privbk *)dev->ml_priv;
         unpack_read(dev);
         clear_bit(CLAW_BH_ACTIVE, (void *)&p_ch->flag_a);
         CLAW_DBF_TEXT(4, trace, "TskletXt");
@@ -1020,7 +1024,6 @@ claw_write_next ( struct chbk * p_ch )
         struct net_device  *dev;
         struct claw_privbk *privptr=NULL;
         struct sk_buff *pk_skb;
-        int     rc;
 
         CLAW_DBF_TEXT(4, trace, "claw_wrt");
         if (p_ch->claw_state == CLAW_STOP)
@@ -1032,7 +1035,7 @@ claw_write_next ( struct chbk * p_ch )
             !skb_queue_empty(&p_ch->collect_queue)) {
                 pk_skb = claw_pack_skb(privptr);
                 while (pk_skb != NULL) {
-                        rc = claw_hw_tx( pk_skb, dev,1);
+                        claw_hw_tx(pk_skb, dev, 1);
                         if (privptr->write_free_count > 0) {
                                 pk_skb = claw_pack_skb(privptr);
                         } else
@@ -1316,15 +1319,12 @@ claw_hw_tx(struct sk_buff *skb, struct net_device *dev, long linkid)
         unsigned char                   *pDataAddress;
         struct endccw                   *pEnd;
         struct ccw1                     tempCCW;
-        struct chbk                     *p_ch;
         struct claw_env                 *p_env;
-        int                             lock;
         struct clawph                   *pk_head;
         struct chbk                     *ch;
 
         CLAW_DBF_TEXT(4, trace, "hw_tx");
         privptr = (struct claw_privbk *)(dev->ml_priv);
-        p_ch = (struct chbk *)&privptr->channel[WRITE_CHANNEL];
         p_env =privptr->p_env;
         claw_free_wrt_buf(dev); /* Clean up free chain if posible */
         /*  scan the write queue to free any completed write packets   */
@@ -1505,12 +1505,6 @@ claw_hw_tx(struct sk_buff *skb, struct net_device *dev, long linkid)
 
         } /* endif (p_first_ccw!=NULL)  */
         dev_kfree_skb_any(skb);
-        if (linkid==0) {
-                lock=LOCK_NO;
-        }
-        else  {
-                lock=LOCK_YES;
-        }
         claw_strt_out_IO(dev );
         /*      if write free count is zero , set NOBUFFER       */
         if (privptr->write_free_count==0) {
@@ -2815,15 +2809,11 @@ claw_free_wrt_buf( struct net_device *dev )
 {
 
         struct claw_privbk *privptr = (struct claw_privbk *)dev->ml_priv;
-        struct ccwbk*p_first_ccw;
-        struct ccwbk*p_last_ccw;
         struct ccwbk*p_this_ccw;
         struct ccwbk*p_next_ccw;
 
         CLAW_DBF_TEXT(4, trace, "freewrtb");
         /*  scan the write queue to free any completed write packets   */
-        p_first_ccw=NULL;
-        p_last_ccw=NULL;
         p_this_ccw=privptr->p_write_active_first;
         while ( (p_this_ccw!=NULL) && (p_this_ccw->header.flag!=CLAW_PENDING))
         {
@@ -3066,7 +3056,7 @@ claw_shutdown_device(struct ccwgroup_device *cgdev)
 {
         struct claw_privbk *priv;
         struct net_device *ndev;
-        int     ret;
+        int ret = 0;
 
         CLAW_DBF_TEXT_(2, setup, "%s", dev_name(&cgdev->dev));
         priv = dev_get_drvdata(&cgdev->dev);
@@ -3089,7 +3079,7 @@ claw_shutdown_device(struct ccwgroup_device *cgdev)
         }
         ccw_device_set_offline(cgdev->cdev[1]);
         ccw_device_set_offline(cgdev->cdev[0]);
-        return 0;
+        return ret;
 }
 
 static void
diff --git a/drivers/s390/net/ctcm_fsms.c b/drivers/s390/net/ctcm_fsms.c
index 8c921fc3511a..2d602207541b 100644
--- a/drivers/s390/net/ctcm_fsms.c
+++ b/drivers/s390/net/ctcm_fsms.c
@@ -184,7 +184,7 @@ static void ctcmpc_chx_resend(fsm_instance *, int, void *);
 static void ctcmpc_chx_send_sweep(fsm_instance *fsm, int event, void *arg);
 
 /**
- * Check return code of a preceeding ccw_device call, halt_IO etc...
+ * Check return code of a preceding ccw_device call, halt_IO etc...
  *
  * ch   :       The channel, the error belongs to.
  * Returns the error code (!= 0) to inspect.
diff --git a/drivers/s390/net/ctcm_main.c b/drivers/s390/net/ctcm_main.c
index 2c7d2d9be4d0..426787efc492 100644
--- a/drivers/s390/net/ctcm_main.c
+++ b/drivers/s390/net/ctcm_main.c
@@ -24,6 +24,7 @@
 #define KMSG_COMPONENT "ctcm"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
+#include <linux/kernel_stat.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
@@ -671,7 +672,6 @@ static int ctcmpc_transmit_skb(struct channel *ch, struct sk_buff *skb)
         int ccw_idx;
         unsigned long hi;
         unsigned long saveflags = 0;    /* avoids compiler warning */
-        __u16 block_len;
 
         CTCM_PR_DEBUG("Enter %s: %s, cp=%i ch=0x%p id=%s state=%s\n",
                         __func__, dev->name, smp_processor_id(), ch,
@@ -718,7 +718,6 @@ static int ctcmpc_transmit_skb(struct channel *ch, struct sk_buff *skb)
          */
         atomic_inc(&skb->users);
 
-        block_len = skb->len + TH_HEADER_LENGTH + PDU_HEADER_LENGTH;
         /*
          * IDAL support in CTCM is broken, so we have to
          * care about skb's above 2G ourselves.
@@ -1204,6 +1203,7 @@ static void ctcm_irq_handler(struct ccw_device *cdev,
         int cstat;
         int dstat;
 
+        kstat_cpu(smp_processor_id()).irqs[IOINT_CTC]++;
         CTCM_DBF_TEXT_(TRACE, CTC_DBF_DEBUG,
                 "Enter %s(%s)", CTCM_FUNTAIL, dev_name(&cdev->dev));
 
@@ -1762,16 +1762,20 @@ static struct ccw_device_id ctcm_ids[] = {
 MODULE_DEVICE_TABLE(ccw, ctcm_ids);
 
 static struct ccw_driver ctcm_ccw_driver = {
-        .owner  = THIS_MODULE,
-        .name   = "ctcm",
+        .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,
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = CTC_DRIVER_NAME,
+        },
         .max_slaves  = 2,
         .driver_id   = 0xC3E3C3D4,      /* CTCM */
         .probe       = ctcm_probe_device,
diff --git a/drivers/s390/net/ctcm_mpc.c b/drivers/s390/net/ctcm_mpc.c
index 2861e78773cb..da4c747335e7 100644
--- a/drivers/s390/net/ctcm_mpc.c
+++ b/drivers/s390/net/ctcm_mpc.c
@@ -540,7 +540,7 @@ void ctc_mpc_dealloc_ch(int port_num)
 
         CTCM_DBF_TEXT_(MPC_SETUP, CTC_DBF_DEBUG,
                         "%s: %s: refcount = %d\n",
-                        CTCM_FUNTAIL, dev->name, atomic_read(&dev->refcnt));
+                        CTCM_FUNTAIL, dev->name, netdev_refcnt_read(dev));
 
         fsm_deltimer(&priv->restart_timer);
         grp->channels_terminating = 0;
@@ -653,7 +653,6 @@ static void ctcmpc_send_sweep_resp(struct channel *rch)
         struct net_device *dev = rch->netdev;
         struct ctcm_priv *priv = dev->ml_priv;
         struct mpc_group *grp = priv->mpcg;
-        int rc = 0;
         struct th_sweep *header;
         struct sk_buff *sweep_skb;
         struct channel *ch  = priv->channel[CTCM_WRITE];
@@ -665,16 +664,14 @@ static void ctcmpc_send_sweep_resp(struct channel *rch)
                 CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,
                         "%s(%s): sweep_skb allocation ERROR\n",
                         CTCM_FUNTAIL, rch->id);
-                rc = -ENOMEM;
-                                goto done;
+                goto done;
         }
 
         header = kmalloc(sizeof(struct th_sweep), gfp_type());
 
         if (!header) {
                 dev_kfree_skb_any(sweep_skb);
-                rc = -ENOMEM;
-                                goto done;
+                goto done;
         }
 
         header->th.th_seg       = 0x00 ;
@@ -1370,8 +1367,7 @@ static void mpc_action_go_inop(fsm_instance *fi, int event, void *arg)
         struct net_device  *dev = arg;
         struct ctcm_priv    *priv;
         struct mpc_group *grp;
-        int rc = 0;
-        struct channel *wch, *rch;
+        struct channel *wch;
 
         BUG_ON(dev == NULL);
         CTCM_PR_DEBUG("Enter %s: %s\n", __func__, dev->name);
@@ -1396,7 +1392,6 @@ static void mpc_action_go_inop(fsm_instance *fi, int event, void *arg)
                 fsm_deltimer(&priv->restart_timer);
 
         wch = priv->channel[CTCM_WRITE];
-        rch = priv->channel[CTCM_READ];
 
         switch (grp->saved_state) {
         case MPCG_STATE_RESET:
@@ -1435,7 +1430,7 @@ static void mpc_action_go_inop(fsm_instance *fi, int event, void *arg)
 
         if (grp->send_qllc_disc == 1) {
                 grp->send_qllc_disc = 0;
-                rc = mpc_send_qllc_discontact(dev);
+                mpc_send_qllc_discontact(dev);
         }
 
         /* DO NOT issue DEV_EVENT_STOP directly out of this code */
diff --git a/drivers/s390/net/lcs.c b/drivers/s390/net/lcs.c
index 0f19d540b655..c3b8064a102d 100644
--- a/drivers/s390/net/lcs.c
+++ b/drivers/s390/net/lcs.c
@@ -26,6 +26,7 @@
 #define KMSG_COMPONENT          "lcs"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
+#include <linux/kernel_stat.h>
 #include <linux/module.h>
 #include <linux/if.h>
 #include <linux/netdevice.h>
@@ -840,7 +841,7 @@ lcs_notify_lancmd_waiters(struct lcs_card *card, struct lcs_cmd *cmd)
 }
 
 /**
- * Emit buffer of a lan comand.
+ * Emit buffer of a lan command.
  */
 static void
 lcs_lancmd_timeout(unsigned long data)
@@ -1122,7 +1123,7 @@ list_modified:
         list_for_each_entry_safe(ipm, tmp, &card->ipm_list, list){
                 switch (ipm->ipm_state) {
                 case LCS_IPM_STATE_SET_REQUIRED:
-                        /* del from ipm_list so noone else can tamper with
+                        /* del from ipm_list so no one else can tamper with
                          * this entry */
                         list_del_init(&ipm->list);
                         spin_unlock_irqrestore(&card->ipm_lock, flags);
@@ -1188,7 +1189,8 @@ lcs_remove_mc_addresses(struct lcs_card *card, struct in_device *in4_dev)
         spin_lock_irqsave(&card->ipm_lock, flags);
         list_for_each(l, &card->ipm_list) {
                 ipm = list_entry(l, struct lcs_ipm_list, list);
-                for (im4 = in4_dev->mc_list; im4 != NULL; im4 = im4->next) {
+                for (im4 = rcu_dereference(in4_dev->mc_list);
+                     im4 != NULL; im4 = rcu_dereference(im4->next_rcu)) {
                         lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
                         if ( (ipm->ipm.ip_addr == im4->multiaddr) &&
                              (memcmp(buf, &ipm->ipm.mac_addr,
@@ -1233,7 +1235,8 @@ lcs_set_mc_addresses(struct lcs_card *card, struct in_device *in4_dev)
         unsigned long flags;
 
         LCS_DBF_TEXT(4, trace, "setmclst");
-        for (im4 = in4_dev->mc_list; im4; im4 = im4->next) {
+        for (im4 = rcu_dereference(in4_dev->mc_list); im4 != NULL;
+             im4 = rcu_dereference(im4->next_rcu)) {
                 lcs_get_mac_for_ipm(im4->multiaddr, buf, card->dev);
                 ipm = lcs_check_addr_entry(card, im4, buf);
                 if (ipm != NULL)
@@ -1269,10 +1272,10 @@ lcs_register_mc_addresses(void *data)
         in4_dev = in_dev_get(card->dev);
         if (in4_dev == NULL)
                 goto out;
-        read_lock(&in4_dev->mc_list_lock);
+        rcu_read_lock();
         lcs_remove_mc_addresses(card,in4_dev);
         lcs_set_mc_addresses(card, in4_dev);
-        read_unlock(&in4_dev->mc_list_lock);
+        rcu_read_unlock();
         in_dev_put(in4_dev);
 
         netif_carrier_off(card->dev);
@@ -1396,6 +1399,7 @@ lcs_irq(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
         int rc, index;
         int cstat, dstat;
 
+        kstat_cpu(smp_processor_id()).irqs[IOINT_LCS]++;
         if (lcs_check_irb_error(cdev, irb))
                 return;
 
@@ -1479,7 +1483,6 @@ lcs_tasklet(unsigned long data)
         struct lcs_channel *channel;
         struct lcs_buffer *iob;
         int buf_idx;
-        int rc;
 
         channel = (struct lcs_channel *) data;
         LCS_DBF_TEXT_(5, trace, "tlet%s", dev_name(&channel->ccwdev->dev));
@@ -1496,14 +1499,11 @@ lcs_tasklet(unsigned long data)
         channel->buf_idx = buf_idx;
 
         if (channel->state == LCS_CH_STATE_STOPPED)
-                // FIXME: what if rc != 0 ??
-                rc = lcs_start_channel(channel);
+                lcs_start_channel(channel);
         spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags);
         if (channel->state == LCS_CH_STATE_SUSPENDED &&
-            channel->iob[channel->io_idx].state == LCS_BUF_STATE_READY) {
-                // FIXME: what if rc != 0 ??
-                rc = __lcs_resume_channel(channel);
-        }
+            channel->iob[channel->io_idx].state == LCS_BUF_STATE_READY)
+                __lcs_resume_channel(channel);
         spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags);
 
         /* Something happened on the channel. Wake up waiters. */
@@ -2392,8 +2392,10 @@ static struct ccw_device_id lcs_ids[] = {
 MODULE_DEVICE_TABLE(ccw, lcs_ids);
 
 static struct ccw_driver lcs_ccw_driver = {
-        .owner  = THIS_MODULE,
-        .name   = "lcs",
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "lcs",
+        },
         .ids    = lcs_ids,
         .probe  = ccwgroup_probe_ccwdev,
         .remove = ccwgroup_remove_ccwdev,
@@ -2403,8 +2405,10 @@ static struct ccw_driver lcs_ccw_driver = {
  * LCS ccwgroup driver registration
  */
 static struct ccwgroup_driver lcs_group_driver = {
-        .owner       = THIS_MODULE,
-        .name        = "lcs",
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "lcs",
+        },
         .max_slaves  = 2,
         .driver_id   = 0xD3C3E2,
         .probe       = lcs_probe_device,
diff --git a/drivers/s390/net/netiucv.c b/drivers/s390/net/netiucv.c
index 65ebee0a3266..3251333a23df 100644
--- a/drivers/s390/net/netiucv.c
+++ b/drivers/s390/net/netiucv.c
@@ -565,7 +565,7 @@ static int netiucv_callback_connreq(struct iucv_path *path,
         struct iucv_event ev;
         int rc;
 
-        if (memcmp(iucvMagic, ipuser, sizeof(ipuser)))
+        if (memcmp(iucvMagic, ipuser, 16))
                 /* ipuser must match iucvMagic. */
                 return -EINVAL;
         rc = -EINVAL;
@@ -1994,8 +1994,6 @@ static struct net_device *netiucv_init_netdevice(char *username)
                            netiucv_setup_netdevice);
         if (!dev)
                 return NULL;
-        if (dev_alloc_name(dev, dev->name) < 0)
-                goto out_netdev;
 
         privptr = netdev_priv(dev);
         privptr->fsm = init_fsm("netiucvdev", dev_state_names,
diff --git a/drivers/s390/net/qeth_core.h b/drivers/s390/net/qeth_core.h
index d1257768be90..d3cee33e554c 100644
--- a/drivers/s390/net/qeth_core.h
+++ b/drivers/s390/net/qeth_core.h
@@ -225,7 +225,8 @@ static inline int qeth_is_ipa_enabled(struct qeth_ipa_info *ipa,
 /*****************************************************************************/
 #define QETH_MAX_QUEUES 4
 #define QETH_IN_BUF_SIZE_DEFAULT 65536
-#define QETH_IN_BUF_COUNT_DEFAULT 16
+#define QETH_IN_BUF_COUNT_DEFAULT 64
+#define QETH_IN_BUF_COUNT_HSDEFAULT 128
 #define QETH_IN_BUF_COUNT_MIN 8
 #define QETH_IN_BUF_COUNT_MAX 128
 #define QETH_MAX_BUFFER_ELEMENTS(card) ((card)->qdio.in_buf_size >> 12)
@@ -360,7 +361,7 @@ enum qeth_header_ids {
 
 static inline int qeth_is_last_sbale(struct qdio_buffer_element *sbale)
 {
-        return (sbale->flags & SBAL_FLAGS_LAST_ENTRY);
+        return (sbale->eflags & SBAL_EFLAGS_LAST_ENTRY);
 }
 
 enum qeth_qdio_buffer_states {
@@ -406,12 +407,6 @@ struct qeth_qdio_q {
         int next_buf_to_init;
 } __attribute__ ((aligned(256)));
 
-/* possible types of qeth large_send support */
-enum qeth_large_send_types {
-        QETH_LARGE_SEND_NO,
-        QETH_LARGE_SEND_TSO,
-};
-
 struct qeth_qdio_out_buffer {
         struct qdio_buffer *buffer;
         atomic_t state;
@@ -440,7 +435,6 @@ struct qeth_qdio_out_q {
          * index of buffer to be filled by driver; state EMPTY or PACKING
          */
         int next_buf_to_fill;
-        int sync_iqdio_error;
         /*
          * number of buffers that are currently filled (PRIMED)
          * -> these buffers are hardware-owned
@@ -637,6 +631,8 @@ struct qeth_card_info {
         __u32 csum_mask;
         __u32 tx_csum_mask;
         enum qeth_ipa_promisc_modes promisc_mode;
+        __u32 diagass_support;
+        __u32 hwtrap;
 };
 
 struct qeth_card_options {
@@ -645,13 +641,11 @@ struct qeth_card_options {
         struct qeth_ipa_info adp; /*Adapter parameters*/
         struct qeth_routing_info route6;
         struct qeth_ipa_info ipa6;
-        enum qeth_checksum_types checksum_type;
         int broadcast_mode;
         int macaddr_mode;
         int fake_broadcast;
         int add_hhlen;
         int layer2;
-        enum qeth_large_send_types large_send;
         int performance_stats;
         int rx_sg_cb;
         enum qeth_ipa_isolation_modes isolation;
@@ -676,6 +670,7 @@ enum qeth_discipline_id {
 };
 
 struct qeth_discipline {
+        void (*start_poll)(struct ccw_device *, int, unsigned long);
         qdio_handler_t *input_handler;
         qdio_handler_t *output_handler;
         int (*recover)(void *ptr);
@@ -694,13 +689,15 @@ struct qeth_mc_mac {
         int is_vmac;
 };
 
-struct qeth_skb_data {
-        __u32 magic;
-        int count;
+struct qeth_rx {
+        int b_count;
+        int b_index;
+        struct qdio_buffer_element *b_element;
+        int e_offset;
+        int qdio_err;
 };
 
-#define QETH_SKB_MAGIC 0x71657468
-#define QETH_SIGA_CC2_RETRIES 3
+#define QETH_NAPI_WEIGHT 128
 
 struct qeth_card {
         struct list_head list;
@@ -739,7 +736,6 @@ struct qeth_card {
         /* QDIO buffer handling */
         struct qeth_qdio_info qdio;
         struct qeth_perf_stats perf_stats;
-        int use_hard_stop;
         int read_or_write_problem;
         struct qeth_osn_info osn_info;
         struct qeth_discipline discipline;
@@ -749,6 +745,8 @@ struct qeth_card {
         debug_info_t *debug;
         struct mutex conf_mutex;
         struct mutex discipline_mutex;
+        struct napi_struct napi;
+        struct qeth_rx rx;
 };
 
 struct qeth_card_list_struct {
@@ -756,6 +754,14 @@ struct qeth_card_list_struct {
         rwlock_t rwlock;
 };
 
+struct qeth_trap_id {
+        __u16 lparnr;
+        char vmname[8];
+        __u8 chpid;
+        __u8 ssid;
+        __u16 devno;
+} __packed;
+
 /*some helper functions*/
 #define QETH_CARD_IFNAME(card) (((card)->dev)? (card)->dev->name : "")
 
@@ -790,6 +796,12 @@ static inline void qeth_put_buffer_pool_entry(struct qeth_card *card,
         list_add_tail(&entry->list, &card->qdio.in_buf_pool.entry_list);
 }
 
+static inline int qeth_is_diagass_supported(struct qeth_card *card,
+                enum qeth_diags_cmds cmd)
+{
+        return card->info.diagass_support & (__u32)cmd;
+}
+
 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 *);
@@ -831,6 +843,10 @@ struct sk_buff *qeth_core_get_next_skb(struct qeth_card *,
                 struct qdio_buffer *, struct qdio_buffer_element **, int *,
                 struct qeth_hdr **);
 void qeth_schedule_recovery(struct qeth_card *);
+void qeth_qdio_start_poll(struct ccw_device *, int, unsigned long);
+void qeth_qdio_input_handler(struct ccw_device *,
+                unsigned int, unsigned int, int,
+                int, unsigned long);
 void qeth_qdio_output_handler(struct ccw_device *, unsigned int,
                         int, int, int, unsigned long);
 void qeth_clear_ipacmd_list(struct qeth_card *);
@@ -871,6 +887,8 @@ void qeth_dbf_longtext(debug_info_t *id, 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);
 int qeth_hdr_chk_and_bounce(struct sk_buff *, int);
+int qeth_hw_trap(struct qeth_card *, enum qeth_diags_trap_action);
+int qeth_query_ipassists(struct qeth_card *, enum qeth_prot_versions prot);
 
 /* 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 3a5a18a0fc28..dd08f7b42fb8 100644
--- a/drivers/s390/net/qeth_core_main.c
+++ b/drivers/s390/net/qeth_core_main.c
@@ -24,6 +24,7 @@
 
 #include <asm/ebcdic.h>
 #include <asm/io.h>
+#include <asm/sysinfo.h>
 
 #include "qeth_core.h"
 
@@ -302,12 +303,15 @@ static void qeth_issue_ipa_msg(struct qeth_ipa_cmd *cmd, int rc,
         int com = cmd->hdr.command;
         ipa_name = qeth_get_ipa_cmd_name(com);
         if (rc)
-                QETH_DBF_MESSAGE(2, "IPA: %s(x%X) for %s returned x%X \"%s\"\n",
-                                ipa_name, com, QETH_CARD_IFNAME(card),
-                                        rc, qeth_get_ipa_msg(rc));
+                QETH_DBF_MESSAGE(2, "IPA: %s(x%X) for %s/%s returned "
+                                "x%X \"%s\"\n",
+                                ipa_name, com, dev_name(&card->gdev->dev),
+                                QETH_CARD_IFNAME(card), rc,
+                                qeth_get_ipa_msg(rc));
         else
-                QETH_DBF_MESSAGE(5, "IPA: %s(x%X) for %s succeeded\n",
-                                ipa_name, com, QETH_CARD_IFNAME(card));
+                QETH_DBF_MESSAGE(5, "IPA: %s(x%X) for %s/%s succeeded\n",
+                                ipa_name, com, dev_name(&card->gdev->dev),
+                                QETH_CARD_IFNAME(card));
 }
 
 static struct qeth_ipa_cmd *qeth_check_ipa_data(struct qeth_card *card,
@@ -346,6 +350,8 @@ static struct qeth_ipa_cmd *qeth_check_ipa_data(struct qeth_card *card,
                                            card->info.chpid);
                                 netif_carrier_on(card->dev);
                                 card->lan_online = 1;
+                                if (card->info.hwtrap)
+                                        card->info.hwtrap = 2;
                                 qeth_schedule_recovery(card);
                                 return NULL;
                         case IPA_CMD_MODCCID:
@@ -877,23 +883,21 @@ out:
         return;
 }
 
-static void __qeth_clear_output_buffer(struct qeth_qdio_out_q *queue,
-                 struct qeth_qdio_out_buffer *buf, unsigned int qeth_skip_skb)
+static void qeth_clear_output_buffer(struct qeth_qdio_out_q *queue,
+                struct qeth_qdio_out_buffer *buf)
 {
         int i;
         struct sk_buff *skb;
 
         /* is PCI flag set on buffer? */
-        if (buf->buffer->element[0].flags & 0x40)
+        if (buf->buffer->element[0].sflags & SBAL_SFLAGS0_PCI_REQ)
                 atomic_dec(&queue->set_pci_flags_count);
 
-        if (!qeth_skip_skb) {
+        skb = skb_dequeue(&buf->skb_list);
+        while (skb) {
+                atomic_dec(&skb->users);
+                dev_kfree_skb_any(skb);
                 skb = skb_dequeue(&buf->skb_list);
-                while (skb) {
-                        atomic_dec(&skb->users);
-                        dev_kfree_skb_any(skb);
-                        skb = skb_dequeue(&buf->skb_list);
-                }
         }
         for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(queue->card); ++i) {
                 if (buf->buffer->element[i].addr && buf->is_header[i])
@@ -902,19 +906,15 @@ static void __qeth_clear_output_buffer(struct qeth_qdio_out_q *queue,
                 buf->is_header[i] = 0;
                 buf->buffer->element[i].length = 0;
                 buf->buffer->element[i].addr = NULL;
-                buf->buffer->element[i].flags = 0;
+                buf->buffer->element[i].eflags = 0;
+                buf->buffer->element[i].sflags = 0;
         }
-        buf->buffer->element[15].flags = 0;
+        buf->buffer->element[15].eflags = 0;
+        buf->buffer->element[15].sflags = 0;
         buf->next_element_to_fill = 0;
         atomic_set(&buf->state, QETH_QDIO_BUF_EMPTY);
 }
 
-static void qeth_clear_output_buffer(struct qeth_qdio_out_q *queue,
-                struct qeth_qdio_out_buffer *buf)
-{
-        __qeth_clear_output_buffer(queue, buf, 0);
-}
-
 void qeth_clear_qdio_buffers(struct qeth_card *card)
 {
         int i, j;
@@ -996,16 +996,30 @@ static void qeth_get_channel_path_desc(struct qeth_card *card)
         chp_dsc = (struct channelPath_dsc *)ccw_device_get_chp_desc(ccwdev, 0);
         if (chp_dsc != NULL) {
                 /* CHPP field bit 6 == 1 -> single queue */
-                if ((chp_dsc->chpp & 0x02) == 0x02)
+                if ((chp_dsc->chpp & 0x02) == 0x02) {
+                        if ((atomic_read(&card->qdio.state) !=
+                                QETH_QDIO_UNINITIALIZED) &&
+                            (card->qdio.no_out_queues == 4))
+                                /* change from 4 to 1 outbound queues */
+                                qeth_free_qdio_buffers(card);
                         card->qdio.no_out_queues = 1;
+                        if (card->qdio.default_out_queue != 0)
+                                dev_info(&card->gdev->dev,
+                                        "Priority Queueing not supported\n");
+                        card->qdio.default_out_queue = 0;
+                } else {
+                        if ((atomic_read(&card->qdio.state) !=
+                                QETH_QDIO_UNINITIALIZED) &&
+                            (card->qdio.no_out_queues == 1)) {
+                                /* change from 1 to 4 outbound queues */
+                                qeth_free_qdio_buffers(card);
+                                card->qdio.default_out_queue = 2;
+                        }
+                        card->qdio.no_out_queues = 4;
+                }
                 card->info.func_level = 0x4100 + chp_dsc->desc;
                 kfree(chp_dsc);
         }
-        if (card->qdio.no_out_queues == 1) {
-                card->qdio.default_out_queue = 0;
-                dev_info(&card->gdev->dev,
-                        "Priority Queueing not supported\n");
-        }
         QETH_DBF_TEXT_(SETUP, 2, "nr:%x", card->qdio.no_out_queues);
         QETH_DBF_TEXT_(SETUP, 2, "lvl:%02x", card->info.func_level);
         return;
@@ -1017,7 +1031,10 @@ static void qeth_init_qdio_info(struct qeth_card *card)
         atomic_set(&card->qdio.state, QETH_QDIO_UNINITIALIZED);
         /* inbound */
         card->qdio.in_buf_size = QETH_IN_BUF_SIZE_DEFAULT;
-        card->qdio.init_pool.buf_count = QETH_IN_BUF_COUNT_DEFAULT;
+        if (card->info.type == QETH_CARD_TYPE_IQD)
+                card->qdio.init_pool.buf_count = QETH_IN_BUF_COUNT_HSDEFAULT;
+        else
+                card->qdio.init_pool.buf_count = QETH_IN_BUF_COUNT_DEFAULT;
         card->qdio.in_buf_pool.buf_count = card->qdio.init_pool.buf_count;
         INIT_LIST_HEAD(&card->qdio.in_buf_pool.entry_list);
         INIT_LIST_HEAD(&card->qdio.init_pool.entry_list);
@@ -1027,7 +1044,6 @@ static void qeth_set_intial_options(struct qeth_card *card)
 {
         card->options.route4.type = NO_ROUTER;
         card->options.route6.type = NO_ROUTER;
-        card->options.checksum_type = QETH_CHECKSUM_DEFAULT;
         card->options.broadcast_mode = QETH_TR_BROADCAST_ALLRINGS;
         card->options.macaddr_mode = QETH_TR_MACADDR_NONCANONICAL;
         card->options.fake_broadcast = 0;
@@ -1077,7 +1093,6 @@ static int qeth_setup_card(struct qeth_card *card)
         card->data.state  = CH_STATE_DOWN;
         card->state = CARD_STATE_DOWN;
         card->lan_online = 0;
-        card->use_hard_stop = 0;
         card->read_or_write_problem = 0;
         card->dev = NULL;
         spin_lock_init(&card->vlanlock);
@@ -1096,7 +1111,7 @@ static int qeth_setup_card(struct qeth_card *card)
         INIT_LIST_HEAD(card->ip_tbd_list);
         INIT_LIST_HEAD(&card->cmd_waiter_list);
         init_waitqueue_head(&card->wait_q);
-        /* intial options */
+        /* initial options */
         qeth_set_intial_options(card);
         /* IP address takeover */
         INIT_LIST_HEAD(&card->ipato.entries);
@@ -1726,20 +1741,22 @@ int qeth_send_control_data(struct qeth_card *card, int len,
                 };
         }
 
+        if (reply->rc == -EIO)
+                goto error;
         rc = reply->rc;
         qeth_put_reply(reply);
         return rc;
 
 time_err:
+        reply->rc = -ETIME;
         spin_lock_irqsave(&reply->card->lock, flags);
         list_del_init(&reply->list);
         spin_unlock_irqrestore(&reply->card->lock, flags);
-        reply->rc = -ETIME;
         atomic_inc(&reply->received);
+error:
         atomic_set(&card->write.irq_pending, 0);
         qeth_release_buffer(iob->channel, iob);
         card->write.buf_no = (card->write.buf_no + 1) % QETH_CMD_BUFFER_NO;
-        wake_up(&reply->wait_q);
         rc = reply->rc;
         qeth_put_reply(reply);
         return rc;
@@ -1840,33 +1857,6 @@ static inline int qeth_get_initial_mtu_for_card(struct qeth_card *card)
         }
 }
 
-static inline int qeth_get_max_mtu_for_card(int cardtype)
-{
-        switch (cardtype) {
-
-        case QETH_CARD_TYPE_UNKNOWN:
-        case QETH_CARD_TYPE_OSD:
-        case QETH_CARD_TYPE_OSN:
-        case QETH_CARD_TYPE_OSM:
-        case QETH_CARD_TYPE_OSX:
-                return 61440;
-        case QETH_CARD_TYPE_IQD:
-                return 57344;
-        default:
-                return 1500;
-        }
-}
-
-static inline int qeth_get_mtu_out_of_mpc(int cardtype)
-{
-        switch (cardtype) {
-        case QETH_CARD_TYPE_IQD:
-                return 1;
-        default:
-                return 0;
-        }
-}
-
 static inline int qeth_get_mtu_outof_framesize(int framesize)
 {
         switch (framesize) {
@@ -1889,10 +1879,9 @@ static inline int qeth_mtu_is_valid(struct qeth_card *card, int mtu)
         case QETH_CARD_TYPE_OSD:
         case QETH_CARD_TYPE_OSM:
         case QETH_CARD_TYPE_OSX:
-                return ((mtu >= 576) && (mtu <= 61440));
         case QETH_CARD_TYPE_IQD:
                 return ((mtu >= 576) &&
-                        (mtu <= card->info.max_mtu + 4096 - 32));
+                        (mtu <= card->info.max_mtu));
         case QETH_CARD_TYPE_OSN:
         case QETH_CARD_TYPE_UNKNOWN:
         default:
@@ -1915,7 +1904,7 @@ static int qeth_ulp_enable_cb(struct qeth_card *card, struct qeth_reply *reply,
         memcpy(&card->token.ulp_filter_r,
                QETH_ULP_ENABLE_RESP_FILTER_TOKEN(iob->data),
                QETH_MPC_TOKEN_LENGTH);
-        if (qeth_get_mtu_out_of_mpc(card->info.type)) {
+        if (card->info.type == QETH_CARD_TYPE_IQD) {
                 memcpy(&framesize, QETH_ULP_ENABLE_RESP_MAX_MTU(iob->data), 2);
                 mtu = qeth_get_mtu_outof_framesize(framesize);
                 if (!mtu) {
@@ -1923,12 +1912,21 @@ static int qeth_ulp_enable_cb(struct qeth_card *card, struct qeth_reply *reply,
                         QETH_DBF_TEXT_(SETUP, 2, "  rc%d", iob->rc);
                         return 0;
                 }
-                card->info.max_mtu = mtu;
+                if (card->info.initial_mtu && (card->info.initial_mtu != mtu)) {
+                        /* frame size has changed */
+                        if (card->dev &&
+                            ((card->dev->mtu == card->info.initial_mtu) ||
+                             (card->dev->mtu > mtu)))
+                                card->dev->mtu = mtu;
+                        qeth_free_qdio_buffers(card);
+                }
                 card->info.initial_mtu = mtu;
+                card->info.max_mtu = mtu;
                 card->qdio.in_buf_size = mtu + 2 * PAGE_SIZE;
         } else {
                 card->info.initial_mtu = qeth_get_initial_mtu_for_card(card);
-                card->info.max_mtu = qeth_get_max_mtu_for_card(card->info.type);
+                card->info.max_mtu = *(__u16 *)QETH_ULP_ENABLE_RESP_MAX_MTU(
+                        iob->data);
                 card->qdio.in_buf_size = QETH_IN_BUF_SIZE_DEFAULT;
         }
 
@@ -2372,9 +2370,10 @@ static int qeth_init_input_buffer(struct qeth_card *card,
                 buf->buffer->element[i].length = PAGE_SIZE;
                 buf->buffer->element[i].addr =  pool_entry->elements[i];
                 if (i == QETH_MAX_BUFFER_ELEMENTS(card) - 1)
-                        buf->buffer->element[i].flags = SBAL_FLAGS_LAST_ENTRY;
+                        buf->buffer->element[i].eflags = SBAL_EFLAGS_LAST_ENTRY;
                 else
-                        buf->buffer->element[i].flags = 0;
+                        buf->buffer->element[i].eflags = 0;
+                buf->buffer->element[i].sflags = 0;
         }
         return 0;
 }
@@ -2503,45 +2502,19 @@ int qeth_send_ipa_cmd(struct qeth_card *card, struct qeth_cmd_buffer *iob,
 }
 EXPORT_SYMBOL_GPL(qeth_send_ipa_cmd);
 
-static int qeth_send_startstoplan(struct qeth_card *card,
-                enum qeth_ipa_cmds ipacmd, enum qeth_prot_versions prot)
-{
-        int rc;
-        struct qeth_cmd_buffer *iob;
-
-        iob = qeth_get_ipacmd_buffer(card, ipacmd, prot);
-        rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
-
-        return rc;
-}
-
 int qeth_send_startlan(struct qeth_card *card)
 {
         int rc;
+        struct qeth_cmd_buffer *iob;
 
         QETH_DBF_TEXT(SETUP, 2, "strtlan");
 
-        rc = qeth_send_startstoplan(card, IPA_CMD_STARTLAN, 0);
+        iob = qeth_get_ipacmd_buffer(card, IPA_CMD_STARTLAN, 0);
+        rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
         return rc;
 }
 EXPORT_SYMBOL_GPL(qeth_send_startlan);
 
-int qeth_send_stoplan(struct qeth_card *card)
-{
-        int rc = 0;
-
-        /*
-         * TODO: according to the IPA format document page 14,
-         * TCP/IP (we!) never issue a STOPLAN
-         * is this right ?!?
-         */
-        QETH_DBF_TEXT(SETUP, 2, "stoplan");
-
-        rc = qeth_send_startstoplan(card, IPA_CMD_STOPLAN, 0);
-        return rc;
-}
-EXPORT_SYMBOL_GPL(qeth_send_stoplan);
-
 int qeth_default_setadapterparms_cb(struct qeth_card *card,
                 struct qeth_reply *reply, unsigned long data)
 {
@@ -2606,17 +2579,153 @@ int qeth_query_setadapterparms(struct qeth_card *card)
 }
 EXPORT_SYMBOL_GPL(qeth_query_setadapterparms);
 
+static int qeth_query_ipassists_cb(struct qeth_card *card,
+                struct qeth_reply *reply, unsigned long data)
+{
+        struct qeth_ipa_cmd *cmd;
+
+        QETH_DBF_TEXT(SETUP, 2, "qipasscb");
+
+        cmd = (struct qeth_ipa_cmd *) data;
+        if (cmd->hdr.prot_version == QETH_PROT_IPV4) {
+                card->options.ipa4.supported_funcs = cmd->hdr.ipa_supported;
+                card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled;
+        } else {
+                card->options.ipa6.supported_funcs = cmd->hdr.ipa_supported;
+                card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled;
+        }
+        QETH_DBF_TEXT(SETUP, 2, "suppenbl");
+        QETH_DBF_TEXT_(SETUP, 2, "%x", cmd->hdr.ipa_supported);
+        QETH_DBF_TEXT_(SETUP, 2, "%x", cmd->hdr.ipa_enabled);
+        return 0;
+}
+
+int qeth_query_ipassists(struct qeth_card *card, enum qeth_prot_versions prot)
+{
+        int rc;
+        struct qeth_cmd_buffer *iob;
+
+        QETH_DBF_TEXT_(SETUP, 2, "qipassi%i", prot);
+        iob = qeth_get_ipacmd_buffer(card, IPA_CMD_QIPASSIST, prot);
+        rc = qeth_send_ipa_cmd(card, iob, qeth_query_ipassists_cb, NULL);
+        return rc;
+}
+EXPORT_SYMBOL_GPL(qeth_query_ipassists);
+
+static int qeth_query_setdiagass_cb(struct qeth_card *card,
+                struct qeth_reply *reply, unsigned long data)
+{
+        struct qeth_ipa_cmd *cmd;
+        __u16 rc;
+
+        cmd = (struct qeth_ipa_cmd *)data;
+        rc = cmd->hdr.return_code;
+        if (rc)
+                QETH_CARD_TEXT_(card, 2, "diagq:%x", rc);
+        else
+                card->info.diagass_support = cmd->data.diagass.ext;
+        return 0;
+}
+
+static int qeth_query_setdiagass(struct qeth_card *card)
+{
+        struct qeth_cmd_buffer *iob;
+        struct qeth_ipa_cmd    *cmd;
+
+        QETH_DBF_TEXT(SETUP, 2, "qdiagass");
+        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_QUERY;
+        return qeth_send_ipa_cmd(card, iob, qeth_query_setdiagass_cb, NULL);
+}
+
+static void qeth_get_trap_id(struct qeth_card *card, struct qeth_trap_id *tid)
+{
+        unsigned long info = get_zeroed_page(GFP_KERNEL);
+        struct sysinfo_2_2_2 *info222 = (struct sysinfo_2_2_2 *)info;
+        struct sysinfo_3_2_2 *info322 = (struct sysinfo_3_2_2 *)info;
+        struct ccw_dev_id ccwid;
+        int level, rc;
+
+        tid->chpid = card->info.chpid;
+        ccw_device_get_id(CARD_RDEV(card), &ccwid);
+        tid->ssid = ccwid.ssid;
+        tid->devno = ccwid.devno;
+        if (!info)
+                return;
+
+        rc = stsi(NULL, 0, 0, 0);
+        if (rc == -ENOSYS)
+                level = rc;
+        else
+                level = (((unsigned int) rc) >> 28);
+
+        if ((level >= 2) && (stsi(info222, 2, 2, 2) != -ENOSYS))
+                tid->lparnr = info222->lpar_number;
+
+        if ((level >= 3) && (stsi(info322, 3, 2, 2) != -ENOSYS)) {
+                EBCASC(info322->vm[0].name, sizeof(info322->vm[0].name));
+                memcpy(tid->vmname, info322->vm[0].name, sizeof(tid->vmname));
+        }
+        free_page(info);
+        return;
+}
+
+static int qeth_hw_trap_cb(struct qeth_card *card,
+                struct qeth_reply *reply, unsigned long data)
+{
+        struct qeth_ipa_cmd *cmd;
+        __u16 rc;
+
+        cmd = (struct qeth_ipa_cmd *)data;
+        rc = cmd->hdr.return_code;
+        if (rc)
+                QETH_CARD_TEXT_(card, 2, "trapc:%x", rc);
+        return 0;
+}
+
+int qeth_hw_trap(struct qeth_card *card, enum qeth_diags_trap_action action)
+{
+        struct qeth_cmd_buffer *iob;
+        struct qeth_ipa_cmd *cmd;
+
+        QETH_DBF_TEXT(SETUP, 2, "diagtrap");
+        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 = 80;
+        cmd->data.diagass.subcmd = QETH_DIAGS_CMD_TRAP;
+        cmd->data.diagass.type = 1;
+        cmd->data.diagass.action = action;
+        switch (action) {
+        case QETH_DIAGS_TRAP_ARM:
+                cmd->data.diagass.options = 0x0003;
+                cmd->data.diagass.ext = 0x00010000 +
+                        sizeof(struct qeth_trap_id);
+                qeth_get_trap_id(card,
+                        (struct qeth_trap_id *)cmd->data.diagass.cdata);
+                break;
+        case QETH_DIAGS_TRAP_DISARM:
+                cmd->data.diagass.options = 0x0001;
+                break;
+        case QETH_DIAGS_TRAP_CAPTURE:
+                break;
+        }
+        return qeth_send_ipa_cmd(card, iob, qeth_hw_trap_cb, NULL);
+}
+EXPORT_SYMBOL_GPL(qeth_hw_trap);
+
 int qeth_check_qdio_errors(struct qeth_card *card, struct qdio_buffer *buf,
                 unsigned int qdio_error, const char *dbftext)
 {
         if (qdio_error) {
                 QETH_CARD_TEXT(card, 2, dbftext);
                 QETH_CARD_TEXT_(card, 2, " F15=%02X",
-                               buf->element[15].flags & 0xff);
+                               buf->element[15].sflags);
                 QETH_CARD_TEXT_(card, 2, " F14=%02X",
-                               buf->element[14].flags & 0xff);
+                               buf->element[14].sflags);
                 QETH_CARD_TEXT_(card, 2, " qerr=%X", qdio_error);
-                if ((buf->element[15].flags & 0xff) == 0x12) {
+                if ((buf->element[15].sflags) == 0x12) {
                         card->stats.rx_dropped++;
                         return 0;
                 } else
@@ -2692,7 +2801,7 @@ EXPORT_SYMBOL_GPL(qeth_queue_input_buffer);
 static int qeth_handle_send_error(struct qeth_card *card,
                 struct qeth_qdio_out_buffer *buffer, unsigned int qdio_err)
 {
-        int sbalf15 = buffer->buffer->element[15].flags & 0xff;
+        int sbalf15 = buffer->buffer->element[15].sflags;
 
         QETH_CARD_TEXT(card, 6, "hdsnderr");
         if (card->info.type == QETH_CARD_TYPE_IQD) {
@@ -2801,8 +2910,8 @@ static void qeth_flush_buffers(struct qeth_qdio_out_q *queue, int index,
 
         for (i = index; i < index + count; ++i) {
                 buf = &queue->bufs[i % QDIO_MAX_BUFFERS_PER_Q];
-                buf->buffer->element[buf->next_element_to_fill - 1].flags |=
-                                SBAL_FLAGS_LAST_ENTRY;
+                buf->buffer->element[buf->next_element_to_fill - 1].eflags |=
+                                SBAL_EFLAGS_LAST_ENTRY;
 
                 if (queue->card->info.type == QETH_CARD_TYPE_IQD)
                         continue;
@@ -2815,7 +2924,7 @@ static void qeth_flush_buffers(struct qeth_qdio_out_q *queue, int index,
                                 /* it's likely that we'll go to packing
                                  * mode soon */
                                 atomic_inc(&queue->set_pci_flags_count);
-                                buf->buffer->element[0].flags |= 0x40;
+                                buf->buffer->element[0].sflags |= SBAL_SFLAGS0_PCI_REQ;
                         }
                 } else {
                         if (!atomic_read(&queue->set_pci_flags_count)) {
@@ -2828,12 +2937,11 @@ static void qeth_flush_buffers(struct qeth_qdio_out_q *queue, int index,
                                  * further send was requested by the stack
                                  */
                                 atomic_inc(&queue->set_pci_flags_count);
-                                buf->buffer->element[0].flags |= 0x40;
+                                buf->buffer->element[0].sflags |= SBAL_SFLAGS0_PCI_REQ;
                         }
                 }
         }
 
-        queue->sync_iqdio_error = 0;
         queue->card->dev->trans_start = jiffies;
         if (queue->card->options.performance_stats) {
                 queue->card->perf_stats.outbound_do_qdio_cnt++;
@@ -2849,10 +2957,7 @@ static void qeth_flush_buffers(struct qeth_qdio_out_q *queue, int index,
                 queue->card->perf_stats.outbound_do_qdio_time +=
                         qeth_get_micros() -
                         queue->card->perf_stats.outbound_do_qdio_start_time;
-        if (rc > 0) {
-                if (!(rc & QDIO_ERROR_SIGA_BUSY))
-                        queue->sync_iqdio_error = rc & 3;
-        }
+        atomic_add(count, &queue->used_buffers);
         if (rc) {
                 queue->card->stats.tx_errors += count;
                 /* ignore temporary SIGA errors without busy condition */
@@ -2866,7 +2971,6 @@ static void qeth_flush_buffers(struct qeth_qdio_out_q *queue, int index,
                 qeth_schedule_recovery(queue->card);
                 return;
         }
-        atomic_add(count, &queue->used_buffers);
         if (queue->card->options.performance_stats)
                 queue->card->perf_stats.bufs_sent += count;
 }
@@ -2911,6 +3015,27 @@ static void qeth_check_outbound_queue(struct qeth_qdio_out_q *queue)
         }
 }
 
+void qeth_qdio_start_poll(struct ccw_device *ccwdev, int queue,
+                unsigned long card_ptr)
+{
+        struct qeth_card *card = (struct qeth_card *)card_ptr;
+
+        if (card->dev && (card->dev->flags & IFF_UP))
+                napi_schedule(&card->napi);
+}
+EXPORT_SYMBOL_GPL(qeth_qdio_start_poll);
+
+void qeth_qdio_input_handler(struct ccw_device *ccwdev, unsigned int qdio_err,
+                unsigned int queue, int first_element, int count,
+                unsigned long card_ptr)
+{
+        struct qeth_card *card = (struct qeth_card *)card_ptr;
+
+        if (qdio_err)
+                qeth_schedule_recovery(card);
+}
+EXPORT_SYMBOL_GPL(qeth_qdio_input_handler);
+
 void qeth_qdio_output_handler(struct ccw_device *ccwdev,
                 unsigned int qdio_error, int __queue, int first_element,
                 int count, unsigned long card_ptr)
@@ -2919,7 +3044,6 @@ void qeth_qdio_output_handler(struct ccw_device *ccwdev,
         struct qeth_qdio_out_q *queue = card->qdio.out_qs[__queue];
         struct qeth_qdio_out_buffer *buffer;
         int i;
-        unsigned qeth_send_err;
 
         QETH_CARD_TEXT(card, 6, "qdouhdl");
         if (qdio_error & QDIO_ERROR_ACTIVATE_CHECK_CONDITION) {
@@ -2935,9 +3059,8 @@ void qeth_qdio_output_handler(struct ccw_device *ccwdev,
         }
         for (i = first_element; i < (first_element + count); ++i) {
                 buffer = &queue->bufs[i % QDIO_MAX_BUFFERS_PER_Q];
-                qeth_send_err = qeth_handle_send_error(card, buffer, qdio_error);
-                __qeth_clear_output_buffer(queue, buffer,
-                        (qeth_send_err == QETH_SEND_ERROR_RETRY) ? 1 : 0);
+                qeth_handle_send_error(card, buffer, qdio_error);
+                qeth_clear_output_buffer(queue, buffer);
         }
         atomic_sub(count, &queue->used_buffers);
         /* check if we need to do something on this outbound queue */
@@ -3060,20 +3183,20 @@ static inline void __qeth_fill_buffer(struct sk_buff *skb,
                 if (!length) {
                         if (first_lap)
                                 if (skb_shinfo(skb)->nr_frags)
-                                        buffer->element[element].flags =
-                                                SBAL_FLAGS_FIRST_FRAG;
+                                        buffer->element[element].eflags =
+                                                SBAL_EFLAGS_FIRST_FRAG;
                                 else
-                                        buffer->element[element].flags = 0;
+                                        buffer->element[element].eflags = 0;
                         else
-                                buffer->element[element].flags =
-                                    SBAL_FLAGS_MIDDLE_FRAG;
+                                buffer->element[element].eflags =
+                                    SBAL_EFLAGS_MIDDLE_FRAG;
                 } else {
                         if (first_lap)
-                                buffer->element[element].flags =
-                                    SBAL_FLAGS_FIRST_FRAG;
+                                buffer->element[element].eflags =
+                                    SBAL_EFLAGS_FIRST_FRAG;
                         else
-                                buffer->element[element].flags =
-                                    SBAL_FLAGS_MIDDLE_FRAG;
+                                buffer->element[element].eflags =
+                                    SBAL_EFLAGS_MIDDLE_FRAG;
                 }
                 data += length_here;
                 element++;
@@ -3085,12 +3208,12 @@ static inline void __qeth_fill_buffer(struct sk_buff *skb,
                 buffer->element[element].addr = (char *)page_to_phys(frag->page)
                         + frag->page_offset;
                 buffer->element[element].length = frag->size;
-                buffer->element[element].flags = SBAL_FLAGS_MIDDLE_FRAG;
+                buffer->element[element].eflags = SBAL_EFLAGS_MIDDLE_FRAG;
                 element++;
         }
 
-        if (buffer->element[element - 1].flags)
-                buffer->element[element - 1].flags = SBAL_FLAGS_LAST_FRAG;
+        if (buffer->element[element - 1].eflags)
+                buffer->element[element - 1].eflags = SBAL_EFLAGS_LAST_FRAG;
         *next_element_to_fill = element;
 }
 
@@ -3114,7 +3237,7 @@ static inline int qeth_fill_buffer(struct qeth_qdio_out_q *queue,
                 /*fill first buffer entry only with header information */
                 buffer->element[element].addr = skb->data;
                 buffer->element[element].length = hdr_len;
-                buffer->element[element].flags = SBAL_FLAGS_FIRST_FRAG;
+                buffer->element[element].eflags = SBAL_EFLAGS_FIRST_FRAG;
                 buf->next_element_to_fill++;
                 skb->data += hdr_len;
                 skb->len  -= hdr_len;
@@ -3126,7 +3249,7 @@ static inline int qeth_fill_buffer(struct qeth_qdio_out_q *queue,
                 buffer->element[element].addr = hdr;
                 buffer->element[element].length = sizeof(struct qeth_hdr) +
                                                         hd_len;
-                buffer->element[element].flags = SBAL_FLAGS_FIRST_FRAG;
+                buffer->element[element].eflags = SBAL_EFLAGS_FIRST_FRAG;
                 buf->is_header[element] = 1;
                 buf->next_element_to_fill++;
         }
@@ -3162,10 +3285,7 @@ int qeth_do_send_packet_fast(struct qeth_card *card,
                 int offset, int hd_len)
 {
         struct qeth_qdio_out_buffer *buffer;
-        struct sk_buff *skb1;
-        struct qeth_skb_data *retry_ctrl;
         int index;
-        int rc;
 
         /* spin until we get the queue ... */
         while (atomic_cmpxchg(&queue->state, QETH_OUT_Q_UNLOCKED,
@@ -3184,25 +3304,6 @@ int qeth_do_send_packet_fast(struct qeth_card *card,
         atomic_set(&queue->state, QETH_OUT_Q_UNLOCKED);
         qeth_fill_buffer(queue, buffer, skb, hdr, offset, hd_len);
         qeth_flush_buffers(queue, index, 1);
-        if (queue->sync_iqdio_error == 2) {
-                skb1 = skb_dequeue(&buffer->skb_list);
-                while (skb1) {
-                        atomic_dec(&skb1->users);
-                        skb1 = skb_dequeue(&buffer->skb_list);
-                }
-                retry_ctrl = (struct qeth_skb_data *) &skb->cb[16];
-                if (retry_ctrl->magic != QETH_SKB_MAGIC) {
-                        retry_ctrl->magic = QETH_SKB_MAGIC;
-                        retry_ctrl->count = 0;
-                }
-                if (retry_ctrl->count < QETH_SIGA_CC2_RETRIES) {
-                        retry_ctrl->count++;
-                        rc = dev_queue_xmit(skb);
-                } else {
-                        dev_kfree_skb_any(skb);
-                        QETH_CARD_TEXT(card, 2, "qrdrop");
-                }
-        }
         return 0;
 out:
         atomic_set(&queue->state, QETH_OUT_Q_UNLOCKED);
@@ -3791,6 +3892,47 @@ static inline int qeth_get_qdio_q_format(struct qeth_card *card)
         }
 }
 
+static void qeth_determine_capabilities(struct qeth_card *card)
+{
+        int rc;
+        int length;
+        char *prcd;
+        struct ccw_device *ddev;
+        int ddev_offline = 0;
+
+        QETH_DBF_TEXT(SETUP, 2, "detcapab");
+        ddev = CARD_DDEV(card);
+        if (!ddev->online) {
+                ddev_offline = 1;
+                rc = ccw_device_set_online(ddev);
+                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(ddev, &card->ssqd);
+        if (rc)
+                QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
+
+out_offline:
+        if (ddev_offline == 1)
+                ccw_device_set_offline(ddev);
+out:
+        return;
+}
+
 static int qeth_qdio_establish(struct qeth_card *card)
 {
         struct qdio_initialize init_data;
@@ -3843,9 +3985,12 @@ static int qeth_qdio_establish(struct qeth_card *card)
         init_data.no_output_qs           = card->qdio.no_out_queues;
         init_data.input_handler          = card->discipline.input_handler;
         init_data.output_handler         = card->discipline.output_handler;
+        init_data.queue_start_poll       = card->discipline.start_poll;
         init_data.int_parm               = (unsigned long) card;
         init_data.input_sbal_addr_array  = (void **) in_sbal_ptrs;
         init_data.output_sbal_addr_array = (void **) out_sbal_ptrs;
+        init_data.scan_threshold =
+                (card->info.type == QETH_CARD_TYPE_IQD) ? 8 : 32;
 
         if (atomic_cmpxchg(&card->qdio.state, QETH_QDIO_ALLOCATED,
                 QETH_QDIO_ESTABLISHED) == QETH_QDIO_ALLOCATED) {
@@ -3898,7 +4043,10 @@ static struct ccw_device_id qeth_ids[] = {
 MODULE_DEVICE_TABLE(ccw, qeth_ids);
 
 static struct ccw_driver qeth_ccw_driver = {
-        .name = "qeth",
+        .driver = {
+                .owner = THIS_MODULE,
+                .name = "qeth",
+        },
         .ids = qeth_ids,
         .probe = ccwgroup_probe_ccwdev,
         .remove = ccwgroup_remove_ccwdev,
@@ -3918,6 +4066,7 @@ int qeth_core_hardsetup_card(struct qeth_card *card)
 
         QETH_DBF_TEXT(SETUP, 2, "hrdsetup");
         atomic_set(&card->force_alloc_skb, 0);
+        qeth_get_channel_path_desc(card);
 retry:
         if (retries)
                 QETH_DBF_MESSAGE(2, "%s Retrying to do IDX activates.\n",
@@ -3946,6 +4095,7 @@ retriable:
                 else
                         goto retry;
         }
+        qeth_determine_capabilities(card);
         qeth_init_tokens(card);
         qeth_init_func_level(card);
         rc = qeth_idx_activate_channel(&card->read, qeth_idx_read_cb);
@@ -3976,6 +4126,15 @@ retriable:
                 QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc);
                 goto out;
         }
+
+        card->options.ipa4.supported_funcs = 0;
+        card->options.adp.supported_funcs = 0;
+        card->info.diagass_support = 0;
+        qeth_query_ipassists(card, QETH_PROT_IPV4);
+        if (qeth_is_supported(card, IPA_SETADAPTERPARMS))
+                qeth_query_setadapterparms(card);
+        if (qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST))
+                qeth_query_setdiagass(card);
         return 0;
 out:
         dev_warn(&card->gdev->dev, "The qeth device driver failed to recover "
@@ -4215,41 +4374,6 @@ 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;
@@ -4457,8 +4581,10 @@ static int qeth_core_restore(struct ccwgroup_device *gdev)
 }
 
 static struct ccwgroup_driver qeth_core_ccwgroup_driver = {
-        .owner = THIS_MODULE,
-        .name = "qeth",
+        .driver = {
+                .owner = THIS_MODULE,
+                .name = "qeth",
+        },
         .driver_id = 0xD8C5E3C8,
         .probe = qeth_core_probe_device,
         .remove = qeth_core_remove_device,
@@ -4513,8 +4639,8 @@ static struct {
 /* 20 */{"queue 1 buffer usage"},
         {"queue 2 buffer usage"},
         {"queue 3 buffer usage"},
-        {"rx handler time"},
-        {"rx handler count"},
+        {"rx poll time"},
+        {"rx poll count"},
         {"rx do_QDIO time"},
         {"rx do_QDIO count"},
         {"tx handler time"},
diff --git a/drivers/s390/net/qeth_core_mpc.h b/drivers/s390/net/qeth_core_mpc.h
index e37dd8c4bf4e..e5a9d1c03839 100644
--- a/drivers/s390/net/qeth_core_mpc.h
+++ b/drivers/s390/net/qeth_core_mpc.h
@@ -80,14 +80,6 @@ enum qeth_tr_broadcast_modes {
         QETH_TR_BROADCAST_LOCAL    = 1,
 };
 
-/* these values match CHECKSUM_* in include/linux/skbuff.h */
-enum qeth_checksum_types {
-        SW_CHECKSUMMING = 0, /* TODO: set to bit flag used in IPA Command */
-        HW_CHECKSUMMING = 1,
-        NO_CHECKSUMMING = 2,
-};
-#define QETH_CHECKSUM_DEFAULT SW_CHECKSUMMING
-
 /*
  * Routing stuff
  */
@@ -333,7 +325,7 @@ struct qeth_arp_query_data {
         __u16 request_bits;
         __u16 reply_bits;
         __u32 no_entries;
-        char data;
+        char data; /* only for replies */
 } __attribute__((packed));
 
 /* used as parameter for arp_query reply */
@@ -456,6 +448,12 @@ enum qeth_diags_trace_cmds {
         QETH_DIAGS_CMD_TRACE_QUERY      = 0x0010,
 };
 
+enum qeth_diags_trap_action {
+        QETH_DIAGS_TRAP_ARM     = 0x01,
+        QETH_DIAGS_TRAP_DISARM  = 0x02,
+        QETH_DIAGS_TRAP_CAPTURE = 0x04,
+};
+
 struct qeth_ipacmd_diagass {
         __u32  host_tod2;
         __u32:32;
@@ -465,7 +463,8 @@ struct qeth_ipacmd_diagass {
         __u8   type;
         __u8   action;
         __u16  options;
-        __u32:32;
+        __u32  ext;
+        __u8   cdata[64];
 } __attribute__ ((packed));
 
 /* Header for each IPA command */
diff --git a/drivers/s390/net/qeth_core_sys.c b/drivers/s390/net/qeth_core_sys.c
index 42fa783a70c8..0a8e86c1b0ea 100644
--- a/drivers/s390/net/qeth_core_sys.c
+++ b/drivers/s390/net/qeth_core_sys.c
@@ -372,7 +372,7 @@ static ssize_t qeth_dev_performance_stats_store(struct device *dev,
         i = simple_strtoul(buf, &tmp, 16);
         if ((i == 0) || (i == 1)) {
                 if (i == card->options.performance_stats)
-                        goto out;;
+                        goto out;
                 card->options.performance_stats = i;
                 if (i == 0)
                         memset(&card->perf_stats, 0,
@@ -530,6 +530,66 @@ out:
 static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show,
                    qeth_dev_isolation_store);
 
+static ssize_t qeth_hw_trap_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct qeth_card *card = dev_get_drvdata(dev);
+
+        if (!card)
+                return -EINVAL;
+        if (card->info.hwtrap)
+                return snprintf(buf, 5, "arm\n");
+        else
+                return snprintf(buf, 8, "disarm\n");
+}
+
+static ssize_t qeth_hw_trap_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct qeth_card *card = dev_get_drvdata(dev);
+        int rc = 0;
+        char *tmp, *curtoken;
+        int state = 0;
+        curtoken = (char *)buf;
+
+        if (!card)
+                return -EINVAL;
+
+        mutex_lock(&card->conf_mutex);
+        if (card->state == CARD_STATE_SOFTSETUP || card->state == CARD_STATE_UP)
+                state = 1;
+        tmp = strsep(&curtoken, "\n");
+
+        if (!strcmp(tmp, "arm") && !card->info.hwtrap) {
+                if (state) {
+                        if (qeth_is_diagass_supported(card,
+                            QETH_DIAGS_CMD_TRAP)) {
+                                rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM);
+                                if (!rc)
+                                        card->info.hwtrap = 1;
+                        } else
+                                rc = -EINVAL;
+                } else
+                        card->info.hwtrap = 1;
+        } else if (!strcmp(tmp, "disarm") && card->info.hwtrap) {
+                if (state) {
+                        rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
+                        if (!rc)
+                                card->info.hwtrap = 0;
+                } else
+                        card->info.hwtrap = 0;
+        } else if (!strcmp(tmp, "trap") && state && card->info.hwtrap)
+                rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_CAPTURE);
+        else
+                rc = -EINVAL;
+
+        mutex_unlock(&card->conf_mutex);
+        return rc ? rc : count;
+}
+
+static DEVICE_ATTR(hw_trap, 0644, qeth_hw_trap_show,
+                   qeth_hw_trap_store);
+
 static ssize_t qeth_dev_blkt_show(char *buf, struct qeth_card *card, int value)
 {
 
@@ -653,6 +713,7 @@ static struct attribute *qeth_device_attrs[] = {
         &dev_attr_performance_stats.attr,
         &dev_attr_layer2.attr,
         &dev_attr_isolation.attr,
+        &dev_attr_hw_trap.attr,
         NULL,
 };
 
diff --git a/drivers/s390/net/qeth_l2_main.c b/drivers/s390/net/qeth_l2_main.c
index 830d63524d61..b70b47fbd6cd 100644
--- a/drivers/s390/net/qeth_l2_main.c
+++ b/drivers/s390/net/qeth_l2_main.c
@@ -202,17 +202,19 @@ static void qeth_l2_add_mc(struct qeth_card *card, __u8 *mac, int vmac)
                 kfree(mc);
 }
 
-static void qeth_l2_del_all_mc(struct qeth_card *card)
+static void qeth_l2_del_all_mc(struct qeth_card *card, int del)
 {
         struct qeth_mc_mac *mc, *tmp;
 
         spin_lock_bh(&card->mclock);
         list_for_each_entry_safe(mc, tmp, &card->mc_list, list) {
-                if (mc->is_vmac)
-                        qeth_l2_send_setdelmac(card, mc->mc_addr,
+                if (del) {
+                        if (mc->is_vmac)
+                                qeth_l2_send_setdelmac(card, mc->mc_addr,
                                         IPA_CMD_DELVMAC, NULL);
-                else
-                        qeth_l2_send_delgroupmac(card, mc->mc_addr);
+                        else
+                                qeth_l2_send_delgroupmac(card, mc->mc_addr);
+                }
                 list_del(&mc->list);
                 kfree(mc);
         }
@@ -288,18 +290,13 @@ static int qeth_l2_send_setdelvlan(struct qeth_card *card, __u16 i,
                                  qeth_l2_send_setdelvlan_cb, NULL);
 }
 
-static void qeth_l2_process_vlans(struct qeth_card *card, int clear)
+static void qeth_l2_process_vlans(struct qeth_card *card)
 {
         struct qeth_vlan_vid *id;
         QETH_CARD_TEXT(card, 3, "L2prcvln");
         spin_lock_bh(&card->vlanlock);
         list_for_each_entry(id, &card->vid_list, list) {
-                if (clear)
-                        qeth_l2_send_setdelvlan(card, id->vid,
-                                IPA_CMD_DELVLAN);
-                else
-                        qeth_l2_send_setdelvlan(card, id->vid,
-                                IPA_CMD_SETVLAN);
+                qeth_l2_send_setdelvlan(card, id->vid, IPA_CMD_SETVLAN);
         }
         spin_unlock_bh(&card->vlanlock);
 }
@@ -310,6 +307,8 @@ static void qeth_l2_vlan_rx_add_vid(struct net_device *dev, unsigned short vid)
         struct qeth_vlan_vid *id;
 
         QETH_CARD_TEXT_(card, 4, "aid:%d", vid);
+        if (!vid)
+                return;
         if (card->info.type == QETH_CARD_TYPE_OSM) {
                 QETH_CARD_TEXT(card, 3, "aidOSM");
                 return;
@@ -377,19 +376,11 @@ static int qeth_l2_stop_card(struct qeth_card *card, int recovery_mode)
                         dev_close(card->dev);
                         rtnl_unlock();
                 }
-                if (!card->use_hard_stop ||
-                        recovery_mode) {
-                        __u8 *mac = &card->dev->dev_addr[0];
-                        rc = qeth_l2_send_delmac(card, mac);
-                        QETH_DBF_TEXT_(SETUP, 2, "Lerr%d", rc);
-                }
+                card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED;
                 card->state = CARD_STATE_SOFTSETUP;
         }
         if (card->state == CARD_STATE_SOFTSETUP) {
-                qeth_l2_process_vlans(card, 1);
-                if (!card->use_hard_stop ||
-                        recovery_mode)
-                        qeth_l2_del_all_mc(card);
+                qeth_l2_del_all_mc(card, 0);
                 qeth_clear_ipacmd_list(card);
                 card->state = CARD_STATE_HARDSETUP;
         }
@@ -403,45 +394,37 @@ static int qeth_l2_stop_card(struct qeth_card *card, int recovery_mode)
                 qeth_clear_cmd_buffers(&card->read);
                 qeth_clear_cmd_buffers(&card->write);
         }
-        card->use_hard_stop = 0;
         return rc;
 }
 
-static void qeth_l2_process_inbound_buffer(struct qeth_card *card,
-                            struct qeth_qdio_buffer *buf, int index)
+static int qeth_l2_process_inbound_buffer(struct qeth_card *card,
+                                int budget, int *done)
 {
-        struct qdio_buffer_element *element;
+        int work_done = 0;
         struct sk_buff *skb;
         struct qeth_hdr *hdr;
-        int offset;
         unsigned int len;
 
-        /* get first element of current buffer */
-        element = (struct qdio_buffer_element *)&buf->buffer->element[0];
-        offset = 0;
-        if (card->options.performance_stats)
-                card->perf_stats.bufs_rec++;
-        while ((skb = qeth_core_get_next_skb(card, buf->buffer, &element,
-                                       &offset, &hdr))) {
-                skb->dev = card->dev;
-                /* is device UP ? */
-                if (!(card->dev->flags & IFF_UP)) {
-                        dev_kfree_skb_any(skb);
-                        continue;
+        *done = 0;
+        BUG_ON(!budget);
+        while (budget) {
+                skb = qeth_core_get_next_skb(card,
+                        card->qdio.in_q->bufs[card->rx.b_index].buffer,
+                        &card->rx.b_element, &card->rx.e_offset, &hdr);
+                if (!skb) {
+                        *done = 1;
+                        break;
                 }
-
+                skb->dev = card->dev;
                 switch (hdr->hdr.l2.id) {
                 case QETH_HEADER_TYPE_LAYER2:
                         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;
+                        skb->ip_summed = CHECKSUM_NONE;
                         if (skb->protocol == htons(ETH_P_802_2))
                                 *((__u32 *)skb->cb) = ++card->seqno.pkt_seqno;
                         len = skb->len;
-                        netif_rx(skb);
+                        netif_receive_skb(skb);
                         break;
                 case QETH_HEADER_TYPE_OSN:
                         if (card->info.type == QETH_CARD_TYPE_OSN) {
@@ -459,9 +442,87 @@ static void qeth_l2_process_inbound_buffer(struct qeth_card *card,
                         QETH_DBF_HEX(CTRL, 3, hdr, QETH_DBF_CTRL_LEN);
                         continue;
                 }
+                work_done++;
+                budget--;
                 card->stats.rx_packets++;
                 card->stats.rx_bytes += len;
         }
+        return work_done;
+}
+
+static int qeth_l2_poll(struct napi_struct *napi, int budget)
+{
+        struct qeth_card *card = container_of(napi, struct qeth_card, napi);
+        int work_done = 0;
+        struct qeth_qdio_buffer *buffer;
+        int done;
+        int new_budget = budget;
+
+        if (card->options.performance_stats) {
+                card->perf_stats.inbound_cnt++;
+                card->perf_stats.inbound_start_time = qeth_get_micros();
+        }
+
+        while (1) {
+                if (!card->rx.b_count) {
+                        card->rx.qdio_err = 0;
+                        card->rx.b_count = qdio_get_next_buffers(
+                                card->data.ccwdev, 0, &card->rx.b_index,
+                                &card->rx.qdio_err);
+                        if (card->rx.b_count <= 0) {
+                                card->rx.b_count = 0;
+                                break;
+                        }
+                        card->rx.b_element =
+                                &card->qdio.in_q->bufs[card->rx.b_index]
+                                .buffer->element[0];
+                        card->rx.e_offset = 0;
+                }
+
+                while (card->rx.b_count) {
+                        buffer = &card->qdio.in_q->bufs[card->rx.b_index];
+                        if (!(card->rx.qdio_err &&
+                            qeth_check_qdio_errors(card, buffer->buffer,
+                            card->rx.qdio_err, "qinerr")))
+                                work_done += qeth_l2_process_inbound_buffer(
+                                        card, new_budget, &done);
+                        else
+                                done = 1;
+
+                        if (done) {
+                                if (card->options.performance_stats)
+                                        card->perf_stats.bufs_rec++;
+                                qeth_put_buffer_pool_entry(card,
+                                        buffer->pool_entry);
+                                qeth_queue_input_buffer(card, card->rx.b_index);
+                                card->rx.b_count--;
+                                if (card->rx.b_count) {
+                                        card->rx.b_index =
+                                                (card->rx.b_index + 1) %
+                                                QDIO_MAX_BUFFERS_PER_Q;
+                                        card->rx.b_element =
+                                                &card->qdio.in_q
+                                                ->bufs[card->rx.b_index]
+                                                .buffer->element[0];
+                                        card->rx.e_offset = 0;
+                                }
+                        }
+
+                        if (work_done >= budget)
+                                goto out;
+                        else
+                                new_budget = budget - work_done;
+                }
+        }
+
+        napi_complete(napi);
+        if (qdio_start_irq(card->data.ccwdev, 0))
+                napi_schedule(&card->napi);
+out:
+        if (card->options.performance_stats)
+                card->perf_stats.inbound_time += qeth_get_micros() -
+                        card->perf_stats.inbound_start_time;
+        return work_done;
 }
 
 static int qeth_l2_send_setdelmac(struct qeth_card *card, __u8 *mac,
@@ -497,13 +558,13 @@ static int qeth_l2_send_setmac_cb(struct qeth_card *card,
                 case IPA_RC_L2_DUP_LAYER3_MAC:
                         dev_warn(&card->gdev->dev,
                                 "MAC address %pM already exists\n",
-                                card->dev->dev_addr);
+                                cmd->data.setdelmac.mac);
                         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 %pM is not authorized\n",
-                                card->dev->dev_addr);
+                                cmd->data.setdelmac.mac);
                         break;
                 default:
                         break;
@@ -629,7 +690,7 @@ static void qeth_l2_set_multicast_list(struct net_device *dev)
         if (qeth_threads_running(card, QETH_RECOVER_THREAD) &&
             (card->state != CARD_STATE_UP))
                 return;
-        qeth_l2_del_all_mc(card);
+        qeth_l2_del_all_mc(card, 1);
         spin_lock_bh(&card->mclock);
         netdev_for_each_mc_addr(ha, dev)
                 qeth_l2_add_mc(card, ha->addr, 0);
@@ -755,51 +816,14 @@ tx_drop:
         return NETDEV_TX_OK;
 }
 
-static void qeth_l2_qdio_input_handler(struct ccw_device *ccwdev,
-                        unsigned int qdio_err, unsigned int queue,
-                        int first_element, int count, unsigned long card_ptr)
-{
-        struct net_device *net_dev;
-        struct qeth_card *card;
-        struct qeth_qdio_buffer *buffer;
-        int index;
-        int i;
-
-        card = (struct qeth_card *) card_ptr;
-        net_dev = card->dev;
-        if (card->options.performance_stats) {
-                card->perf_stats.inbound_cnt++;
-                card->perf_stats.inbound_start_time = qeth_get_micros();
-        }
-        if (qdio_err & QDIO_ERROR_ACTIVATE_CHECK_CONDITION) {
-                QETH_CARD_TEXT(card, 1, "qdinchk");
-                QETH_CARD_TEXT_(card, 1, "%04X%04X", first_element,
-                                count);
-                QETH_CARD_TEXT_(card, 1, "%04X", queue);
-                qeth_schedule_recovery(card);
-                return;
-        }
-        for (i = first_element; i < (first_element + count); ++i) {
-                index = i % QDIO_MAX_BUFFERS_PER_Q;
-                buffer = &card->qdio.in_q->bufs[index];
-                if (!(qdio_err &&
-                      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);
-                qeth_queue_input_buffer(card, index);
-        }
-        if (card->options.performance_stats)
-                card->perf_stats.inbound_time += qeth_get_micros() -
-                        card->perf_stats.inbound_start_time;
-}
-
-static int qeth_l2_open(struct net_device *dev)
+static int __qeth_l2_open(struct net_device *dev)
 {
         struct qeth_card *card = dev->ml_priv;
+        int rc = 0;
 
         QETH_CARD_TEXT(card, 4, "qethopen");
+        if (card->state == CARD_STATE_UP)
+                return rc;
         if (card->state != CARD_STATE_SOFTSETUP)
                 return -ENODEV;
 
@@ -812,11 +836,25 @@ static int qeth_l2_open(struct net_device *dev)
         card->state = CARD_STATE_UP;
         netif_start_queue(dev);
 
-        if (!card->lan_online && netif_carrier_ok(dev))
-                netif_carrier_off(dev);
-        return 0;
+        if (qdio_stop_irq(card->data.ccwdev, 0) >= 0) {
+                napi_enable(&card->napi);
+                napi_schedule(&card->napi);
+        } else
+                rc = -EIO;
+        return rc;
 }
 
+static int qeth_l2_open(struct net_device *dev)
+{
+        struct qeth_card *card = dev->ml_priv;
+
+        QETH_CARD_TEXT(card, 5, "qethope_");
+        if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
+                QETH_CARD_TEXT(card, 3, "openREC");
+                return -ERESTARTSYS;
+        }
+        return __qeth_l2_open(dev);
+}
 
 static int qeth_l2_stop(struct net_device *dev)
 {
@@ -824,8 +862,10 @@ static int qeth_l2_stop(struct net_device *dev)
 
         QETH_CARD_TEXT(card, 4, "qethstop");
         netif_tx_disable(dev);
-        if (card->state == CARD_STATE_UP)
+        if (card->state == CARD_STATE_UP) {
                 card->state = CARD_STATE_SOFTSETUP;
+                napi_disable(&card->napi);
+        }
         return 0;
 }
 
@@ -836,8 +876,10 @@ static int qeth_l2_probe_device(struct ccwgroup_device *gdev)
         INIT_LIST_HEAD(&card->vid_list);
         INIT_LIST_HEAD(&card->mc_list);
         card->options.layer2 = 1;
+        card->info.hwtrap = 0;
+        card->discipline.start_poll = qeth_qdio_start_poll;
         card->discipline.input_handler = (qdio_handler_t *)
-                qeth_l2_qdio_input_handler;
+                qeth_qdio_input_handler;
         card->discipline.output_handler = (qdio_handler_t *)
                 qeth_qdio_output_handler;
         card->discipline.recover = qeth_l2_recover;
@@ -851,10 +893,8 @@ static void qeth_l2_remove_device(struct ccwgroup_device *cgdev)
         qeth_set_allowed_threads(card, 0, 1);
         wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
 
-        if (cgdev->state == CCWGROUP_ONLINE) {
-                card->use_hard_stop = 1;
+        if (cgdev->state == CCWGROUP_ONLINE)
                 qeth_l2_set_offline(cgdev);
-        }
 
         if (card->dev) {
                 unregister_netdev(card->dev);
@@ -923,6 +963,7 @@ static int qeth_l2_setup_netdev(struct qeth_card *card)
         card->info.broadcast_capable = 1;
         qeth_l2_request_initial_mac(card);
         SET_NETDEV_DEV(card->dev, &card->gdev->dev);
+        netif_napi_add(card->dev, &card->napi, qeth_l2_poll, QETH_NAPI_WEIGHT);
         return register_netdev(card->dev);
 }
 
@@ -954,7 +995,15 @@ static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode)
         if (card->info.type != QETH_CARD_TYPE_OSN)
                 qeth_l2_send_setmac(card, &card->dev->dev_addr[0]);
 
+        if (qeth_is_diagass_supported(card, QETH_DIAGS_CMD_TRAP)) {
+                if (card->info.hwtrap &&
+                    qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM))
+                        card->info.hwtrap = 0;
+        } else
+                card->info.hwtrap = 0;
+
         card->state = CARD_STATE_HARDSETUP;
+        memset(&card->rx, 0, sizeof(struct qeth_rx));
         qeth_print_status_message(card);
 
         /* softsetup */
@@ -967,13 +1016,14 @@ static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode)
                         dev_warn(&card->gdev->dev,
                                 "The LAN is offline\n");
                         card->lan_online = 0;
-                        goto out;
+                        goto contin;
                 }
                 rc = -ENODEV;
                 goto out_remove;
         } else
                 card->lan_online = 1;
 
+contin:
         if ((card->info.type == QETH_CARD_TYPE_OSD) ||
             (card->info.type == QETH_CARD_TYPE_OSX))
                 /* configure isolation level */
@@ -981,7 +1031,7 @@ static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode)
 
         if (card->info.type != QETH_CARD_TYPE_OSN &&
             card->info.type != QETH_CARD_TYPE_OSM)
-                qeth_l2_process_vlans(card, 0);
+                qeth_l2_process_vlans(card);
 
         netif_tx_disable(card->dev);
 
@@ -992,13 +1042,16 @@ static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode)
                 goto out_remove;
         }
         card->state = CARD_STATE_SOFTSETUP;
-        netif_carrier_on(card->dev);
+        if (card->lan_online)
+                netif_carrier_on(card->dev);
+        else
+                netif_carrier_off(card->dev);
 
         qeth_set_allowed_threads(card, 0xffffffff, 0);
         if (recover_flag == CARD_STATE_RECOVER) {
                 if (recovery_mode &&
                     card->info.type != QETH_CARD_TYPE_OSN) {
-                        qeth_l2_open(card->dev);
+                        __qeth_l2_open(card->dev);
                 } else {
                         rtnl_lock();
                         dev_open(card->dev);
@@ -1009,13 +1062,11 @@ 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);
-out:
         mutex_unlock(&card->conf_mutex);
         mutex_unlock(&card->discipline_mutex);
         return 0;
 
 out_remove:
-        card->use_hard_stop = 1;
         qeth_l2_stop_card(card, 0);
         ccw_device_set_offline(CARD_DDEV(card));
         ccw_device_set_offline(CARD_WDEV(card));
@@ -1049,6 +1100,10 @@ static int __qeth_l2_set_offline(struct ccwgroup_device *cgdev,
         if (card->dev && netif_carrier_ok(card->dev))
                 netif_carrier_off(card->dev);
         recover_flag = card->state;
+        if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) {
+                qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
+                card->info.hwtrap = 1;
+        }
         qeth_l2_stop_card(card, recovery_mode);
         rc  = ccw_device_set_offline(CARD_DDEV(card));
         rc2 = ccw_device_set_offline(CARD_WDEV(card));
@@ -1083,12 +1138,8 @@ static int qeth_l2_recover(void *ptr)
         QETH_CARD_TEXT(card, 2, "recover2");
         dev_warn(&card->gdev->dev,
                 "A recovery process has been started for the device\n");
-        card->use_hard_stop = 1;
         __qeth_l2_set_offline(card->gdev, 1);
         rc = __qeth_l2_set_online(card->gdev, 1);
-        /* don't run another scheduled recovery */
-        qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
-        qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
         if (!rc)
                 dev_info(&card->gdev->dev,
                         "Device successfully recovered!\n");
@@ -1099,6 +1150,8 @@ static int qeth_l2_recover(void *ptr)
                 dev_warn(&card->gdev->dev, "The qeth device driver "
                         "failed to recover an error on the device\n");
         }
+        qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
+        qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
         return 0;
 }
 
@@ -1116,6 +1169,8 @@ static void __exit qeth_l2_exit(void)
 static void qeth_l2_shutdown(struct ccwgroup_device *gdev)
 {
         struct qeth_card *card = dev_get_drvdata(&gdev->dev);
+        if ((gdev->state == CCWGROUP_ONLINE) && card->info.hwtrap)
+                qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
         qeth_qdio_clear_card(card, 0);
         qeth_clear_qdio_buffers(card);
 }
@@ -1131,7 +1186,8 @@ static int qeth_l2_pm_suspend(struct ccwgroup_device *gdev)
         if (gdev->state == CCWGROUP_OFFLINE)
                 return 0;
         if (card->state == CARD_STATE_UP) {
-                card->use_hard_stop = 1;
+                if (card->info.hwtrap)
+                        qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
                 __qeth_l2_set_offline(card->gdev, 1);
         } else
                 __qeth_l2_set_offline(card->gdev, 0);
diff --git a/drivers/s390/net/qeth_l3.h b/drivers/s390/net/qeth_l3.h
index e705b27ec7dc..14a43aeb0c2a 100644
--- a/drivers/s390/net/qeth_l3.h
+++ b/drivers/s390/net/qeth_l3.h
@@ -62,8 +62,6 @@ 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);
 int qeth_l3_is_addr_covered_by_ipato(struct qeth_card *, struct qeth_ipaddr *);
 
 #endif /* __QETH_L3_H__ */
diff --git a/drivers/s390/net/qeth_l3_main.c b/drivers/s390/net/qeth_l3_main.c
index e22ae248f613..fd69da3fa6b4 100644
--- a/drivers/s390/net/qeth_l3_main.c
+++ b/drivers/s390/net/qeth_l3_main.c
@@ -30,6 +30,7 @@
 
 #include "qeth_l3.h"
 
+
 static int qeth_l3_set_offline(struct ccwgroup_device *);
 static int qeth_l3_recover(void *);
 static int qeth_l3_stop(struct net_device *);
@@ -42,33 +43,6 @@ 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_IP_CSUM;
-                } else {
-                        card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
-                                        NETIF_F_IP_CSUM);
-                        card->options.large_send = QETH_LARGE_SEND_NO;
-                        rc = -EOPNOTSUPP;
-                }
-        } else {
-                card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
-                                        NETIF_F_IP_CSUM);
-                card->options.large_send = QETH_LARGE_SEND_NO;
-        }
-        return rc;
-}
-
 static int qeth_l3_isxdigit(char *buf)
 {
         while (*buf) {
@@ -103,12 +77,7 @@ int qeth_l3_string_to_ipaddr4(const char *buf, __u8 *addr)
 
 void qeth_l3_ipaddr6_to_string(const __u8 *addr, char *buf)
 {
-        sprintf(buf, "%02x%02x:%02x%02x:%02x%02x:%02x%02x"
-                     ":%02x%02x:%02x%02x:%02x%02x:%02x%02x",
-                     addr[0], addr[1], addr[2], addr[3],
-                     addr[4], addr[5], addr[6], addr[7],
-                     addr[8], addr[9], addr[10], addr[11],
-                     addr[12], addr[13], addr[14], addr[15]);
+        sprintf(buf, "%pI6", addr);
 }
 
 int qeth_l3_string_to_ipaddr6(const char *buf, __u8 *addr)
@@ -460,8 +429,11 @@ static void qeth_l3_set_ip_addr_list(struct qeth_card *card)
         QETH_CARD_TEXT(card, 2, "sdiplist");
         QETH_CARD_HEX(card, 2, &card, sizeof(void *));
 
-        if (card->options.sniffer)
+        if ((card->state != CARD_STATE_UP &&
+             card->state != CARD_STATE_SOFTSETUP) || 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);
@@ -511,8 +483,7 @@ static void qeth_l3_set_ip_addr_list(struct qeth_card *card)
         kfree(tbd_list);
 }
 
-static void qeth_l3_clear_ip_list(struct qeth_card *card, int clean,
-                                        int recover)
+static void qeth_l3_clear_ip_list(struct qeth_card *card, int recover)
 {
         struct qeth_ipaddr *addr, *tmp;
         unsigned long flags;
@@ -531,11 +502,6 @@ static void qeth_l3_clear_ip_list(struct qeth_card *card, int clean,
                 addr = list_entry(card->ip_list.next,
                                   struct qeth_ipaddr, entry);
                 list_del_init(&addr->entry);
-                if (clean) {
-                        spin_unlock_irqrestore(&card->ip_lock, flags);
-                        qeth_l3_deregister_addr_entry(card, addr);
-                        spin_lock_irqsave(&card->ip_lock, flags);
-                }
                 if (!recover || addr->is_multicast) {
                         kfree(addr);
                         continue;
@@ -1311,39 +1277,6 @@ static int qeth_l3_start_ipa_multicast(struct qeth_card *card)
         return rc;
 }
 
-static int qeth_l3_query_ipassists_cb(struct qeth_card *card,
-                struct qeth_reply *reply, unsigned long data)
-{
-        struct qeth_ipa_cmd *cmd;
-
-        QETH_DBF_TEXT(SETUP, 2, "qipasscb");
-
-        cmd = (struct qeth_ipa_cmd *) data;
-        if (cmd->hdr.prot_version == QETH_PROT_IPV4) {
-                card->options.ipa4.supported_funcs = cmd->hdr.ipa_supported;
-                card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled;
-        } else {
-                card->options.ipa6.supported_funcs = cmd->hdr.ipa_supported;
-                card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled;
-        }
-        QETH_DBF_TEXT(SETUP, 2, "suppenbl");
-        QETH_DBF_TEXT_(SETUP, 2, "%x", cmd->hdr.ipa_supported);
-        QETH_DBF_TEXT_(SETUP, 2, "%x", cmd->hdr.ipa_enabled);
-        return 0;
-}
-
-static int qeth_l3_query_ipassists(struct qeth_card *card,
-                                enum qeth_prot_versions prot)
-{
-        int rc;
-        struct qeth_cmd_buffer *iob;
-
-        QETH_DBF_TEXT_(SETUP, 2, "qipassi%i", prot);
-        iob = qeth_get_ipacmd_buffer(card, IPA_CMD_QIPASSIST, prot);
-        rc = qeth_send_ipa_cmd(card, iob, qeth_l3_query_ipassists_cb, NULL);
-        return rc;
-}
-
 #ifdef CONFIG_QETH_IPV6
 static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
 {
@@ -1354,7 +1287,7 @@ static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
         if (card->info.type == QETH_CARD_TYPE_IQD)
                 goto out;
 
-        rc = qeth_l3_query_ipassists(card, QETH_PROT_IPV6);
+        rc = qeth_query_ipassists(card, QETH_PROT_IPV6);
         if (rc) {
                 dev_err(&card->gdev->dev,
                         "Activating IPv6 support for %s failed\n",
@@ -1479,68 +1412,38 @@ 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 qeth_l3_set_rx_csum(struct qeth_card *card, int on)
 {
         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;
-                }
+        if (on) {
+                rc = qeth_l3_send_checksum_command(card);
+                if (rc)
+                        return -EIO;
+                dev_info(&card->gdev->dev,
+                        "HW Checksumming (inbound) enabled\n");
         } 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;
-                        }
-                }
+                rc = qeth_l3_send_simple_setassparms(card,
+                        IPA_INBOUND_CHECKSUM, IPA_CMD_ASS_STOP, 0);
+                if (rc)
+                        return -EIO;
         }
-        card->options.checksum_type = csum_type;
-        return rc;
+
+        return 0;
 }
 
 static int qeth_l3_start_ipa_checksum(struct qeth_card *card)
 {
-        int rc = 0;
-
         QETH_CARD_TEXT(card, 3, "strtcsum");
 
-        if (card->options.checksum_type == NO_CHECKSUMMING) {
-                dev_info(&card->gdev->dev,
-                        "Using no checksumming on %s.\n",
-                        QETH_CARD_IFNAME(card));
-                return 0;
-        }
-        if (card->options.checksum_type == SW_CHECKSUMMING) {
-                dev_info(&card->gdev->dev,
-                        "Using SW checksumming on %s.\n",
-                        QETH_CARD_IFNAME(card));
-                return 0;
-        }
-        if (!qeth_is_supported(card, IPA_INBOUND_CHECKSUM)) {
-                dev_info(&card->gdev->dev,
-                        "Inbound HW Checksumming not "
-                        "supported on %s,\ncontinuing "
-                        "using Inbound SW Checksumming\n",
-                        QETH_CARD_IFNAME(card));
-                card->options.checksum_type = SW_CHECKSUMMING;
-                return 0;
+        if (card->dev->features & NETIF_F_RXCSUM) {
+                rtnl_lock();
+                /* force set_features call */
+                card->dev->features &= ~NETIF_F_RXCSUM;
+                netdev_update_features(card->dev);
+                rtnl_unlock();
         }
-        rc = qeth_l3_send_checksum_command(card);
-        if (!rc)
-                dev_info(&card->gdev->dev,
-                        "HW Checksumming (inbound) enabled\n");
-
-        return rc;
+        return 0;
 }
 
 static int qeth_l3_start_ipa_tx_checksum(struct qeth_card *card)
@@ -1587,10 +1490,8 @@ static int qeth_l3_start_ipa_tso(struct qeth_card *card)
                         dev_info(&card->gdev->dev,
                                 "Outbound TSO enabled\n");
         }
-        if (rc && (card->options.large_send == QETH_LARGE_SEND_TSO)) {
-                card->options.large_send = QETH_LARGE_SEND_NO;
-                card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG);
-        }
+        if (rc)
+                card->dev->features &= ~NETIF_F_TSO;
         return rc;
 }
 
@@ -1612,29 +1513,6 @@ static int qeth_l3_start_ipassists(struct qeth_card *card)
         return 0;
 }
 
-static int qeth_l3_put_unique_id(struct qeth_card *card)
-{
-
-        int rc = 0;
-        struct qeth_cmd_buffer *iob;
-        struct qeth_ipa_cmd *cmd;
-
-        QETH_CARD_TEXT(card, 2, "puniqeid");
-
-        if ((card->info.unique_id & UNIQUE_ID_NOT_BY_CARD) ==
-                UNIQUE_ID_NOT_BY_CARD)
-                return -1;
-        iob = qeth_get_ipacmd_buffer(card, IPA_CMD_DESTROY_ADDR,
-                                     QETH_PROT_IPV6);
-        cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
-        *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
-                                card->info.unique_id;
-        memcpy(&cmd->data.create_destroy_addr.unique_id[0],
-               card->dev->dev_addr, OSA_ADDR_LEN);
-        rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
-        return rc;
-}
-
 static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card *card,
                 struct qeth_reply *reply, unsigned long data)
 {
@@ -1801,7 +1679,8 @@ static void qeth_l3_add_mc(struct qeth_card *card, struct in_device *in4_dev)
         char buf[MAX_ADDR_LEN];
 
         QETH_CARD_TEXT(card, 4, "addmc");
-        for (im4 = in4_dev->mc_list; im4; im4 = im4->next) {
+        for (im4 = rcu_dereference(in4_dev->mc_list); im4 != NULL;
+             im4 = rcu_dereference(im4->next_rcu)) {
                 qeth_l3_get_mac_for_ipm(im4->multiaddr, buf, in4_dev->dev);
                 ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
                 if (!ipm)
@@ -1825,7 +1704,7 @@ static void qeth_l3_add_vlan_mc(struct qeth_card *card)
                 return;
 
         vg = card->vlangrp;
-        for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
+        for (i = 0; i < VLAN_N_VID; i++) {
                 struct net_device *netdev = vlan_group_get_device(vg, i);
                 if (netdev == NULL ||
                     !(netdev->flags & IFF_UP))
@@ -1833,9 +1712,9 @@ static void qeth_l3_add_vlan_mc(struct qeth_card *card)
                 in_dev = in_dev_get(netdev);
                 if (!in_dev)
                         continue;
-                read_lock(&in_dev->mc_list_lock);
+                rcu_read_lock();
                 qeth_l3_add_mc(card, in_dev);
-                read_unlock(&in_dev->mc_list_lock);
+                rcu_read_unlock();
                 in_dev_put(in_dev);
         }
 }
@@ -1848,10 +1727,10 @@ static void qeth_l3_add_multicast_ipv4(struct qeth_card *card)
         in4_dev = in_dev_get(card->dev);
         if (in4_dev == NULL)
                 return;
-        read_lock(&in4_dev->mc_list_lock);
+        rcu_read_lock();
         qeth_l3_add_mc(card, in4_dev);
         qeth_l3_add_vlan_mc(card);
-        read_unlock(&in4_dev->mc_list_lock);
+        rcu_read_unlock();
         in_dev_put(in4_dev);
 }
 
@@ -1888,7 +1767,7 @@ static void qeth_l3_add_vlan_mc6(struct qeth_card *card)
                 return;
 
         vg = card->vlangrp;
-        for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
+        for (i = 0; i < VLAN_N_VID; i++) {
                 struct net_device *netdev = vlan_group_get_device(vg, i);
                 if (netdev == NULL ||
                     !(netdev->flags & IFF_UP))
@@ -2018,13 +1897,14 @@ static void qeth_l3_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
         qeth_l3_set_multicast_list(card->dev);
 }
 
-static inline __u16 qeth_l3_rebuild_skb(struct qeth_card *card,
-                        struct sk_buff *skb, struct qeth_hdr *hdr)
+static inline int qeth_l3_rebuild_skb(struct qeth_card *card,
+                        struct sk_buff *skb, struct qeth_hdr *hdr,
+                        unsigned short *vlan_id)
 {
-        unsigned short vlan_id = 0;
         __be16 prot;
         struct iphdr *ip_hdr;
         unsigned char tg_addr[MAX_ADDR_LEN];
+        int is_vlan = 0;
 
         if (!(hdr->hdr.l3.flags & QETH_HDR_PASSTHRU)) {
                 prot = htons((hdr->hdr.l3.flags & QETH_HDR_IPV6)? ETH_P_IPV6 :
@@ -2087,18 +1967,12 @@ static inline __u16 qeth_l3_rebuild_skb(struct qeth_card *card,
 
         if (hdr->hdr.l3.ext_flags &
             (QETH_HDR_EXT_VLAN_FRAME | QETH_HDR_EXT_INCLUDE_VLAN_TAG)) {
-                vlan_id = (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_VLAN_FRAME)?
+                *vlan_id = (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_VLAN_FRAME) ?
                  hdr->hdr.l3.vlan_id : *((u16 *)&hdr->hdr.l3.dest_addr[12]);
+                is_vlan = 1;
         }
 
-        switch (card->options.checksum_type) {
-        case SW_CHECKSUMMING:
-                skb->ip_summed = CHECKSUM_NONE;
-                break;
-        case NO_CHECKSUMMING:
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
-                break;
-        case HW_CHECKSUMMING:
+        if (card->dev->features & NETIF_F_RXCSUM) {
                 if ((hdr->hdr.l3.ext_flags &
                     (QETH_HDR_EXT_CSUM_HDR_REQ |
                      QETH_HDR_EXT_CSUM_TRANSP_REQ)) ==
@@ -2107,56 +1981,47 @@ static inline __u16 qeth_l3_rebuild_skb(struct qeth_card *card,
                         skb->ip_summed = CHECKSUM_UNNECESSARY;
                 else
                         skb->ip_summed = CHECKSUM_NONE;
-        }
+        } else
+                skb->ip_summed = CHECKSUM_NONE;
 
-        return vlan_id;
+        return is_vlan;
 }
 
-static void qeth_l3_process_inbound_buffer(struct qeth_card *card,
-                            struct qeth_qdio_buffer *buf, int index)
+static int qeth_l3_process_inbound_buffer(struct qeth_card *card,
+                                int budget, int *done)
 {
-        struct qdio_buffer_element *element;
+        int work_done = 0;
         struct sk_buff *skb;
         struct qeth_hdr *hdr;
-        int offset;
         __u16 vlan_tag = 0;
+        int is_vlan;
         unsigned int len;
-        /* get first element of current buffer */
-        element = (struct qdio_buffer_element *)&buf->buffer->element[0];
-        offset = 0;
-        if (card->options.performance_stats)
-                card->perf_stats.bufs_rec++;
-        while ((skb = qeth_core_get_next_skb(card, buf->buffer, &element,
-                                       &offset, &hdr))) {
-                skb->dev = card->dev;
-                /* is device UP ? */
-                if (!(card->dev->flags & IFF_UP)) {
-                        dev_kfree_skb_any(skb);
-                        continue;
-                }
 
+        *done = 0;
+        BUG_ON(!budget);
+        while (budget) {
+                skb = qeth_core_get_next_skb(card,
+                        card->qdio.in_q->bufs[card->rx.b_index].buffer,
+                        &card->rx.b_element, &card->rx.e_offset, &hdr);
+                if (!skb) {
+                        *done = 1;
+                        break;
+                }
+                skb->dev = card->dev;
                 switch (hdr->hdr.l3.id) {
                 case QETH_HEADER_TYPE_LAYER3:
-                        vlan_tag = qeth_l3_rebuild_skb(card, skb, hdr);
+                        is_vlan = qeth_l3_rebuild_skb(card, skb, hdr,
+                                                      &vlan_tag);
                         len = skb->len;
-                        if (vlan_tag && !card->options.sniffer)
-                                if (card->vlangrp)
-                                        vlan_hwaccel_rx(skb, card->vlangrp,
-                                                vlan_tag);
-                                else {
-                                        dev_kfree_skb_any(skb);
-                                        continue;
-                                }
+                        if (is_vlan && !card->options.sniffer)
+                                vlan_gro_receive(&card->napi, card->vlangrp,
+                                        vlan_tag, skb);
                         else
-                                netif_rx(skb);
+                                napi_gro_receive(&card->napi, 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;
@@ -2166,10 +2031,87 @@ static void qeth_l3_process_inbound_buffer(struct qeth_card *card,
                         QETH_DBF_HEX(CTRL, 3, hdr, QETH_DBF_CTRL_LEN);
                         continue;
                 }
-
+                work_done++;
+                budget--;
                 card->stats.rx_packets++;
                 card->stats.rx_bytes += len;
         }
+        return work_done;
+}
+
+static int qeth_l3_poll(struct napi_struct *napi, int budget)
+{
+        struct qeth_card *card = container_of(napi, struct qeth_card, napi);
+        int work_done = 0;
+        struct qeth_qdio_buffer *buffer;
+        int done;
+        int new_budget = budget;
+
+        if (card->options.performance_stats) {
+                card->perf_stats.inbound_cnt++;
+                card->perf_stats.inbound_start_time = qeth_get_micros();
+        }
+
+        while (1) {
+                if (!card->rx.b_count) {
+                        card->rx.qdio_err = 0;
+                        card->rx.b_count = qdio_get_next_buffers(
+                                card->data.ccwdev, 0, &card->rx.b_index,
+                                &card->rx.qdio_err);
+                        if (card->rx.b_count <= 0) {
+                                card->rx.b_count = 0;
+                                break;
+                        }
+                        card->rx.b_element =
+                                &card->qdio.in_q->bufs[card->rx.b_index]
+                                .buffer->element[0];
+                        card->rx.e_offset = 0;
+                }
+
+                while (card->rx.b_count) {
+                        buffer = &card->qdio.in_q->bufs[card->rx.b_index];
+                        if (!(card->rx.qdio_err &&
+                            qeth_check_qdio_errors(card, buffer->buffer,
+                            card->rx.qdio_err, "qinerr")))
+                                work_done += qeth_l3_process_inbound_buffer(
+                                        card, new_budget, &done);
+                        else
+                                done = 1;
+
+                        if (done) {
+                                if (card->options.performance_stats)
+                                        card->perf_stats.bufs_rec++;
+                                qeth_put_buffer_pool_entry(card,
+                                        buffer->pool_entry);
+                                qeth_queue_input_buffer(card, card->rx.b_index);
+                                card->rx.b_count--;
+                                if (card->rx.b_count) {
+                                        card->rx.b_index =
+                                                (card->rx.b_index + 1) %
+                                                QDIO_MAX_BUFFERS_PER_Q;
+                                        card->rx.b_element =
+                                                &card->qdio.in_q
+                                                ->bufs[card->rx.b_index]
+                                                .buffer->element[0];
+                                        card->rx.e_offset = 0;
+                                }
+                        }
+
+                        if (work_done >= budget)
+                                goto out;
+                        else
+                                new_budget = budget - work_done;
+                }
+        }
+
+        napi_complete(napi);
+        if (qdio_start_irq(card->data.ccwdev, 0))
+                napi_schedule(&card->napi);
+out:
+        if (card->options.performance_stats)
+                card->perf_stats.inbound_time += qeth_get_micros() -
+                        card->perf_stats.inbound_start_time;
+        return work_done;
 }
 
 static int qeth_l3_verify_vlan_dev(struct net_device *dev,
@@ -2183,7 +2125,7 @@ static int qeth_l3_verify_vlan_dev(struct net_device *dev,
         if (!vg)
                 return rc;
 
-        for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
+        for (i = 0; i < VLAN_N_VID; i++) {
                 if (vlan_group_get_device(vg, i) == dev) {
                         rc = QETH_VLAN_CARD;
                         break;
@@ -2255,25 +2197,14 @@ static int qeth_l3_stop_card(struct qeth_card *card, int recovery_mode)
                         dev_close(card->dev);
                         rtnl_unlock();
                 }
-                if (!card->use_hard_stop) {
-                        rc = qeth_send_stoplan(card);
-                        if (rc)
-                                QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
-                }
                 card->state = CARD_STATE_SOFTSETUP;
         }
         if (card->state == CARD_STATE_SOFTSETUP) {
-                qeth_l3_clear_ip_list(card, !card->use_hard_stop, 1);
+                qeth_l3_clear_ip_list(card, 1);
                 qeth_clear_ipacmd_list(card);
                 card->state = CARD_STATE_HARDSETUP;
         }
         if (card->state == CARD_STATE_HARDSETUP) {
-                if (!card->use_hard_stop &&
-                    (card->info.type != QETH_CARD_TYPE_IQD)) {
-                        rc = qeth_l3_put_unique_id(card);
-                        if (rc)
-                                QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
-                }
                 qeth_qdio_clear_card(card, 0);
                 qeth_clear_qdio_buffers(card);
                 qeth_clear_working_pool_list(card);
@@ -2283,7 +2214,6 @@ static int qeth_l3_stop_card(struct qeth_card *card, int recovery_mode)
                 qeth_clear_cmd_buffers(&card->read);
                 qeth_clear_cmd_buffers(&card->write);
         }
-        card->use_hard_stop = 0;
         return rc;
 }
 
@@ -2390,22 +2320,46 @@ static int qeth_l3_arp_set_no_entries(struct qeth_card *card, int no_entries)
         return rc;
 }
 
-static void qeth_l3_copy_arp_entries_stripped(struct qeth_arp_query_info *qinfo,
-                struct qeth_arp_query_data *qdata, int entry_size,
-                int uentry_size)
+static __u32 get_arp_entry_size(struct qeth_card *card,
+                        struct qeth_arp_query_data *qdata,
+                        struct qeth_arp_entrytype *type, __u8 strip_entries)
 {
-        char *entry_ptr;
-        char *uentry_ptr;
-        int i;
+        __u32 rc;
+        __u8 is_hsi;
 
-        entry_ptr = (char *)&qdata->data;
-        uentry_ptr = (char *)(qinfo->udata + qinfo->udata_offset);
-        for (i = 0; i < qdata->no_entries; ++i) {
-                /* strip off 32 bytes "media specific information" */
-                memcpy(uentry_ptr, (entry_ptr + 32), entry_size - 32);
-                entry_ptr += entry_size;
-                uentry_ptr += uentry_size;
+        is_hsi = qdata->reply_bits == 5;
+        if (type->ip == QETHARP_IP_ADDR_V4) {
+                QETH_CARD_TEXT(card, 4, "arpev4");
+                if (strip_entries) {
+                        rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5_short) :
+                                sizeof(struct qeth_arp_qi_entry7_short);
+                } else {
+                        rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5) :
+                                sizeof(struct qeth_arp_qi_entry7);
+                }
+        } else if (type->ip == QETHARP_IP_ADDR_V6) {
+                QETH_CARD_TEXT(card, 4, "arpev6");
+                if (strip_entries) {
+                        rc = is_hsi ?
+                                sizeof(struct qeth_arp_qi_entry5_short_ipv6) :
+                                sizeof(struct qeth_arp_qi_entry7_short_ipv6);
+                } else {
+                        rc = is_hsi ?
+                                sizeof(struct qeth_arp_qi_entry5_ipv6) :
+                                sizeof(struct qeth_arp_qi_entry7_ipv6);
+                }
+        } else {
+                QETH_CARD_TEXT(card, 4, "arpinv");
+                rc = 0;
         }
+
+        return rc;
+}
+
+static int arpentry_matches_prot(struct qeth_arp_entrytype *type, __u16 prot)
+{
+        return (type->ip == QETHARP_IP_ADDR_V4 && prot == QETH_PROT_IPV4) ||
+                (type->ip == QETHARP_IP_ADDR_V6 && prot == QETH_PROT_IPV6);
 }
 
 static int qeth_l3_arp_query_cb(struct qeth_card *card,
@@ -2414,72 +2368,77 @@ static int qeth_l3_arp_query_cb(struct qeth_card *card,
         struct qeth_ipa_cmd *cmd;
         struct qeth_arp_query_data *qdata;
         struct qeth_arp_query_info *qinfo;
-        int entry_size;
-        int uentry_size;
         int i;
+        int e;
+        int entrybytes_done;
+        int stripped_bytes;
+        __u8 do_strip_entries;
 
-        QETH_CARD_TEXT(card, 4, "arpquecb");
+        QETH_CARD_TEXT(card, 3, "arpquecb");
 
         qinfo = (struct qeth_arp_query_info *) reply->param;
         cmd = (struct qeth_ipa_cmd *) data;
+        QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.prot_version);
         if (cmd->hdr.return_code) {
-                QETH_CARD_TEXT_(card, 4, "qaer1%i", cmd->hdr.return_code);
+                QETH_CARD_TEXT(card, 4, "arpcberr");
+                QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
                 return 0;
         }
         if (cmd->data.setassparms.hdr.return_code) {
                 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
-                QETH_CARD_TEXT_(card, 4, "qaer2%i", cmd->hdr.return_code);
+                QETH_CARD_TEXT(card, 4, "setaperr");
+                QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
                 return 0;
         }
         qdata = &cmd->data.setassparms.data.query_arp;
-        switch (qdata->reply_bits) {
-        case 5:
-                uentry_size = entry_size = sizeof(struct qeth_arp_qi_entry5);
-                if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
-                        uentry_size = sizeof(struct qeth_arp_qi_entry5_short);
-                break;
-        case 7:
-                /* fall through to default */
-        default:
-                /* tr is the same as eth -> entry7 */
-                uentry_size = entry_size = sizeof(struct qeth_arp_qi_entry7);
-                if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
-                        uentry_size = sizeof(struct qeth_arp_qi_entry7_short);
-                break;
-        }
-        /* check if there is enough room in userspace */
-        if ((qinfo->udata_len - qinfo->udata_offset) <
-                        qdata->no_entries * uentry_size){
-                QETH_CARD_TEXT_(card, 4, "qaer3%i", -ENOMEM);
-                cmd->hdr.return_code = -ENOMEM;
-                goto out_error;
-        }
-        QETH_CARD_TEXT_(card, 4, "anore%i",
-                       cmd->data.setassparms.hdr.number_of_replies);
-        QETH_CARD_TEXT_(card, 4, "aseqn%i", cmd->data.setassparms.hdr.seq_no);
         QETH_CARD_TEXT_(card, 4, "anoen%i", qdata->no_entries);
 
-        if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) {
-                /* strip off "media specific information" */
-                qeth_l3_copy_arp_entries_stripped(qinfo, qdata, entry_size,
-                                               uentry_size);
-        } else
-                /*copy entries to user buffer*/
-                memcpy(qinfo->udata + qinfo->udata_offset,
-                       (char *)&qdata->data, qdata->no_entries*uentry_size);
+        do_strip_entries = (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) > 0;
+        stripped_bytes = do_strip_entries ? QETH_QARP_MEDIASPECIFIC_BYTES : 0;
+        entrybytes_done = 0;
+        for (e = 0; e < qdata->no_entries; ++e) {
+                char *cur_entry;
+                __u32 esize;
+                struct qeth_arp_entrytype *etype;
+
+                cur_entry = &qdata->data + entrybytes_done;
+                etype = &((struct qeth_arp_qi_entry5 *) cur_entry)->type;
+                if (!arpentry_matches_prot(etype, cmd->hdr.prot_version)) {
+                        QETH_CARD_TEXT(card, 4, "pmis");
+                        QETH_CARD_TEXT_(card, 4, "%i", etype->ip);
+                        break;
+                }
+                esize = get_arp_entry_size(card, qdata, etype,
+                        do_strip_entries);
+                QETH_CARD_TEXT_(card, 5, "esz%i", esize);
+                if (!esize)
+                        break;
+
+                if ((qinfo->udata_len - qinfo->udata_offset) < esize) {
+                        QETH_CARD_TEXT_(card, 4, "qaer3%i", -ENOMEM);
+                        cmd->hdr.return_code = -ENOMEM;
+                        goto out_error;
+                }
 
-        qinfo->no_entries += qdata->no_entries;
-        qinfo->udata_offset += (qdata->no_entries*uentry_size);
+                memcpy(qinfo->udata + qinfo->udata_offset,
+                        &qdata->data + entrybytes_done + stripped_bytes,
+                        esize);
+                entrybytes_done += esize + stripped_bytes;
+                qinfo->udata_offset += esize;
+                ++qinfo->no_entries;
+        }
         /* check if all replies received ... */
         if (cmd->data.setassparms.hdr.seq_no <
             cmd->data.setassparms.hdr.number_of_replies)
                 return 1;
+        QETH_CARD_TEXT_(card, 4, "nove%i", qinfo->no_entries);
         memcpy(qinfo->udata, &qinfo->no_entries, 4);
         /* keep STRIP_ENTRIES flag so the user program can distinguish
          * stripped entries from normal ones */
         if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
                 qdata->reply_bits |= QETH_QARP_STRIP_ENTRIES;
         memcpy(qinfo->udata + QETH_QARP_MASK_OFFSET, &qdata->reply_bits, 2);
+        QETH_CARD_TEXT_(card, 4, "rc%i", 0);
         return 0;
 out_error:
         i = 0;
@@ -2502,45 +2461,86 @@ static int qeth_l3_send_ipa_arp_cmd(struct qeth_card *card,
                                       reply_cb, reply_param);
 }
 
-static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata)
+static int qeth_l3_query_arp_cache_info(struct qeth_card *card,
+        enum qeth_prot_versions prot,
+        struct qeth_arp_query_info *qinfo)
 {
         struct qeth_cmd_buffer *iob;
-        struct qeth_arp_query_info qinfo = {0, };
+        struct qeth_ipa_cmd *cmd;
         int tmp;
         int rc;
 
+        QETH_CARD_TEXT_(card, 3, "qarpipv%i", prot);
+
+        iob = qeth_l3_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
+                        IPA_CMD_ASS_ARP_QUERY_INFO,
+                        sizeof(struct qeth_arp_query_data) - sizeof(char),
+                        prot);
+        cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
+        cmd->data.setassparms.data.query_arp.request_bits = 0x000F;
+        cmd->data.setassparms.data.query_arp.reply_bits = 0;
+        cmd->data.setassparms.data.query_arp.no_entries = 0;
+        rc = qeth_l3_send_ipa_arp_cmd(card, iob,
+                           QETH_SETASS_BASE_LEN+QETH_ARP_CMD_LEN,
+                           qeth_l3_arp_query_cb, (void *)qinfo);
+        if (rc) {
+                tmp = rc;
+                QETH_DBF_MESSAGE(2,
+                        "Error while querying ARP cache on %s: %s "
+                        "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
+                        qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
+        }
+
+        return rc;
+}
+
+static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata)
+{
+        struct qeth_arp_query_info qinfo = {0, };
+        int rc;
+
         QETH_CARD_TEXT(card, 3, "arpquery");
 
         if (!qeth_is_supported(card,/*IPA_QUERY_ARP_ADDR_INFO*/
                                IPA_ARP_PROCESSING)) {
-                return -EOPNOTSUPP;
+                QETH_CARD_TEXT(card, 3, "arpqnsup");
+                rc = -EOPNOTSUPP;
+                goto out;
         }
         /* get size of userspace buffer and mask_bits -> 6 bytes */
-        if (copy_from_user(&qinfo, udata, 6))
-                return -EFAULT;
+        if (copy_from_user(&qinfo, udata, 6)) {
+                rc = -EFAULT;
+                goto out;
+        }
         qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL);
-        if (!qinfo.udata)
-                return -ENOMEM;
+        if (!qinfo.udata) {
+                rc = -ENOMEM;
+                goto out;
+        }
         qinfo.udata_offset = QETH_QARP_ENTRIES_OFFSET;
-        iob = qeth_l3_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
-                                       IPA_CMD_ASS_ARP_QUERY_INFO,
-                                       sizeof(int), QETH_PROT_IPV4);
-
-        rc = qeth_l3_send_ipa_arp_cmd(card, iob,
-                                   QETH_SETASS_BASE_LEN+QETH_ARP_CMD_LEN,
-                                   qeth_l3_arp_query_cb, (void *)&qinfo);
+        rc = qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV4, &qinfo);
         if (rc) {
-                tmp = rc;
-                QETH_DBF_MESSAGE(2, "Error while querying ARP cache on %s: %s "
-                        "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
-                        qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
                 if (copy_to_user(udata, qinfo.udata, 4))
                         rc = -EFAULT;
+                        goto free_and_out;
         } else {
-                if (copy_to_user(udata, qinfo.udata, qinfo.udata_len))
+#ifdef CONFIG_QETH_IPV6
+                if (qinfo.mask_bits & QETH_QARP_WITH_IPV6) {
+                        /* fails in case of GuestLAN QDIO mode */
+                        qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV6,
+                                &qinfo);
+                }
+#endif
+                if (copy_to_user(udata, qinfo.udata, qinfo.udata_len)) {
+                        QETH_CARD_TEXT(card, 4, "qactf");
                         rc = -EFAULT;
+                        goto free_and_out;
+                }
+                QETH_CARD_TEXT_(card, 4, "qacts");
         }
+free_and_out:
         kfree(qinfo.udata);
+out:
         return rc;
 }
 
@@ -2859,7 +2859,9 @@ static inline void qeth_l3_hdr_csum(struct qeth_card *card,
          */
         if (iph->protocol == IPPROTO_UDP)
                 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_UDP;
-        hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_CSUM_TRANSP_REQ;
+        hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_CSUM_TRANSP_REQ |
+                QETH_HDR_EXT_CSUM_HDR_REQ;
+        iph->check = 0;
         if (card->options.performance_stats)
                 card->perf_stats.tx_csum++;
 }
@@ -2874,6 +2876,7 @@ static void qeth_tso_fill_header(struct qeth_card *card,
 
         /*fix header to TSO values ...*/
         hdr->hdr.hdr.l3.id = QETH_HEADER_TYPE_TSO;
+        hdr->hdr.hdr.l3.length = skb->len - sizeof(struct qeth_hdr_tso);
         /*set values which are fix for the first approach ...*/
         hdr->ext.hdr_tot_len = (__u16) sizeof(struct qeth_hdr_ext_tso);
         hdr->ext.imb_hdr_no  = 1;
@@ -2923,7 +2926,7 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
         struct qeth_qdio_out_q *queue = card->qdio.out_qs
                 [qeth_get_priority_queue(card, skb, ipv, cast_type)];
         int tx_bytes = skb->len;
-        enum qeth_large_send_types large_send = QETH_LARGE_SEND_NO;
+        bool large_send;
         int data_offset = -1;
         int nr_frags;
 
@@ -2945,8 +2948,7 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 card->perf_stats.outbound_start_time = qeth_get_micros();
         }
 
-        if (skb_is_gso(skb))
-                large_send = card->options.large_send;
+        large_send = skb_is_gso(skb);
 
         if ((card->info.type == QETH_CARD_TYPE_IQD) && (!large_send) &&
             (skb_shinfo(skb)->nr_frags == 0)) {
@@ -2975,7 +2977,7 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                                 skb_pull(new_skb, ETH_HLEN);
                 }
 
-                if (ipv == 6 && card->vlangrp &&
+                if (ipv != 4 && 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);
@@ -2995,7 +2997,7 @@ 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) {
+        if (large_send) {
                 if (qeth_l3_tso_elements(new_skb) + 1 > 16) {
                         if (skb_linearize(new_skb))
                                 goto tx_drop;
@@ -3004,8 +3006,7 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 }
         }
 
-        if ((large_send == QETH_LARGE_SEND_TSO) &&
-            (cast_type == RTN_UNSPEC)) {
+        if (large_send && (cast_type == RTN_UNSPEC)) {
                 hdr = (struct qeth_hdr *)skb_push(new_skb,
                                                 sizeof(struct qeth_hdr_tso));
                 memset(hdr, 0, sizeof(struct qeth_hdr_tso));
@@ -3040,7 +3041,7 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
         if (card->info.type != QETH_CARD_TYPE_IQD) {
                 int len;
-                if (large_send == QETH_LARGE_SEND_TSO)
+                if (large_send)
                         len = ((unsigned long)tcp_hdr(new_skb) +
                                 tcp_hdr(new_skb)->doff * 4) -
                                 (unsigned long)new_skb->data;
@@ -3061,7 +3062,7 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 if (new_skb != skb)
                         dev_kfree_skb_any(skb);
                 if (card->options.performance_stats) {
-                        if (large_send != QETH_LARGE_SEND_NO) {
+                        if (large_send) {
                                 card->perf_stats.large_send_bytes += tx_bytes;
                                 card->perf_stats.large_send_cnt++;
                         }
@@ -3100,92 +3101,89 @@ tx_drop:
         return NETDEV_TX_OK;
 }
 
-static int qeth_l3_open(struct net_device *dev)
+static int __qeth_l3_open(struct net_device *dev)
 {
         struct qeth_card *card = dev->ml_priv;
+        int rc = 0;
 
         QETH_CARD_TEXT(card, 4, "qethopen");
+        if (card->state == CARD_STATE_UP)
+                return rc;
         if (card->state != CARD_STATE_SOFTSETUP)
                 return -ENODEV;
         card->data.state = CH_STATE_UP;
         card->state = CARD_STATE_UP;
         netif_start_queue(dev);
 
-        if (!card->lan_online && netif_carrier_ok(dev))
-                netif_carrier_off(dev);
-        return 0;
+        if (qdio_stop_irq(card->data.ccwdev, 0) >= 0) {
+                napi_enable(&card->napi);
+                napi_schedule(&card->napi);
+        } else
+                rc = -EIO;
+        return rc;
 }
 
-static int qeth_l3_stop(struct net_device *dev)
+static int qeth_l3_open(struct net_device *dev)
 {
         struct qeth_card *card = dev->ml_priv;
 
-        QETH_CARD_TEXT(card, 4, "qethstop");
-        netif_tx_disable(dev);
-        if (card->state == CARD_STATE_UP)
-                card->state = CARD_STATE_SOFTSETUP;
-        return 0;
+        QETH_CARD_TEXT(card, 5, "qethope_");
+        if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
+                QETH_CARD_TEXT(card, 3, "openREC");
+                return -ERESTARTSYS;
+        }
+        return __qeth_l3_open(dev);
 }
 
-static u32 qeth_l3_ethtool_get_rx_csum(struct net_device *dev)
+static int qeth_l3_stop(struct net_device *dev)
 {
         struct qeth_card *card = dev->ml_priv;
 
-        return (card->options.checksum_type == HW_CHECKSUMMING);
+        QETH_CARD_TEXT(card, 4, "qethstop");
+        netif_tx_disable(dev);
+        if (card->state == CARD_STATE_UP) {
+                card->state = CARD_STATE_SOFTSETUP;
+                napi_disable(&card->napi);
+        }
+        return 0;
 }
 
-static int qeth_l3_ethtool_set_rx_csum(struct net_device *dev, u32 data)
+static u32 qeth_l3_fix_features(struct net_device *dev, u32 features)
 {
         struct qeth_card *card = dev->ml_priv;
-        enum qeth_checksum_types csum_type;
 
-        if (data)
-                csum_type = HW_CHECKSUMMING;
-        else
-                csum_type = SW_CHECKSUMMING;
+        if (!qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM))
+                features &= ~NETIF_F_IP_CSUM;
+        if (!qeth_is_supported(card, IPA_OUTBOUND_TSO))
+                features &= ~NETIF_F_TSO;
+        if (!qeth_is_supported(card, IPA_INBOUND_CHECKSUM))
+                features &= ~NETIF_F_RXCSUM;
 
-        return qeth_l3_set_rx_csum(card, csum_type);
+        return features;
 }
 
-static int qeth_l3_ethtool_set_tso(struct net_device *dev, u32 data)
+static int qeth_l3_set_features(struct net_device *dev, u32 features)
 {
         struct qeth_card *card = dev->ml_priv;
-        int rc = 0;
+        u32 changed = dev->features ^ features;
+        int err;
 
-        if (data) {
-                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 rc;
-}
+        if (!(changed & NETIF_F_RXCSUM))
+                return 0;
 
-static int qeth_l3_ethtool_set_tx_csum(struct net_device *dev, u32 data)
-{
-        struct qeth_card *card = dev->ml_priv;
+        if (card->state == CARD_STATE_DOWN ||
+            card->state == CARD_STATE_RECOVER)
+                return 0;
 
-        if (data) {
-                if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM))
-                        dev->features |= NETIF_F_IP_CSUM;
-                else
-                        return -EPERM;
-        } else
-                dev->features &= ~NETIF_F_IP_CSUM;
+        err = qeth_l3_set_rx_csum(card, features & NETIF_F_RXCSUM);
+        if (err)
+                dev->features = features ^ NETIF_F_RXCSUM;
 
-        return 0;
+        return err;
 }
 
 static const struct ethtool_ops qeth_l3_ethtool_ops = {
         .get_link = ethtool_op_get_link,
-        .get_tx_csum = ethtool_op_get_tx_csum,
-        .set_tx_csum = qeth_l3_ethtool_set_tx_csum,
-        .get_rx_csum = qeth_l3_ethtool_get_rx_csum,
-        .set_rx_csum = qeth_l3_ethtool_set_rx_csum,
-        .get_sg      = ethtool_op_get_sg,
-        .set_sg      = ethtool_op_set_sg,
-        .get_tso     = ethtool_op_get_tso,
-        .set_tso     = qeth_l3_ethtool_set_tso,
         .get_strings = qeth_core_get_strings,
         .get_ethtool_stats = qeth_core_get_ethtool_stats,
         .get_sset_count = qeth_core_get_sset_count,
@@ -3226,6 +3224,8 @@ static const struct net_device_ops qeth_l3_netdev_ops = {
         .ndo_set_multicast_list = qeth_l3_set_multicast_list,
         .ndo_do_ioctl           = qeth_l3_do_ioctl,
         .ndo_change_mtu         = qeth_change_mtu,
+        .ndo_fix_features       = qeth_l3_fix_features,
+        .ndo_set_features       = qeth_l3_set_features,
         .ndo_vlan_rx_register   = qeth_l3_vlan_rx_register,
         .ndo_vlan_rx_add_vid    = qeth_l3_vlan_rx_add_vid,
         .ndo_vlan_rx_kill_vid   = qeth_l3_vlan_rx_kill_vid,
@@ -3241,6 +3241,8 @@ static const struct net_device_ops qeth_l3_osa_netdev_ops = {
         .ndo_set_multicast_list = qeth_l3_set_multicast_list,
         .ndo_do_ioctl           = qeth_l3_do_ioctl,
         .ndo_change_mtu         = qeth_change_mtu,
+        .ndo_fix_features       = qeth_l3_fix_features,
+        .ndo_set_features       = qeth_l3_set_features,
         .ndo_vlan_rx_register   = qeth_l3_vlan_rx_register,
         .ndo_vlan_rx_add_vid    = qeth_l3_vlan_rx_add_vid,
         .ndo_vlan_rx_kill_vid   = qeth_l3_vlan_rx_kill_vid,
@@ -3271,6 +3273,12 @@ static int qeth_l3_setup_netdev(struct qeth_card *card)
                         if (!(card->info.unique_id & UNIQUE_ID_NOT_BY_CARD))
                                 card->dev->dev_id = card->info.unique_id &
                                                          0xffff;
+                        if (!card->info.guestlan) {
+                                card->dev->hw_features = NETIF_F_SG |
+                                        NETIF_F_RXCSUM | NETIF_F_IP_CSUM |
+                                        NETIF_F_TSO;
+                                card->dev->features = NETIF_F_RXCSUM;
+                        }
                 }
         } else if (card->info.type == QETH_CARD_TYPE_IQD) {
                 card->dev = alloc_netdev(0, "hsi%d", ether_setup);
@@ -3293,57 +3301,20 @@ static int qeth_l3_setup_netdev(struct qeth_card *card)
         card->dev->gso_max_size = 15 * PAGE_SIZE;
 
         SET_NETDEV_DEV(card->dev, &card->gdev->dev);
+        netif_napi_add(card->dev, &card->napi, qeth_l3_poll, QETH_NAPI_WEIGHT);
         return register_netdev(card->dev);
 }
 
-static void qeth_l3_qdio_input_handler(struct ccw_device *ccwdev,
-                unsigned int qdio_err, unsigned int queue, int first_element,
-                int count, unsigned long card_ptr)
-{
-        struct net_device *net_dev;
-        struct qeth_card *card;
-        struct qeth_qdio_buffer *buffer;
-        int index;
-        int i;
-
-        card = (struct qeth_card *) card_ptr;
-        net_dev = card->dev;
-        if (card->options.performance_stats) {
-                card->perf_stats.inbound_cnt++;
-                card->perf_stats.inbound_start_time = qeth_get_micros();
-        }
-        if (qdio_err & QDIO_ERROR_ACTIVATE_CHECK_CONDITION) {
-                QETH_CARD_TEXT(card, 1, "qdinchk");
-                QETH_CARD_TEXT_(card, 1, "%04X%04X",
-                                first_element, count);
-                QETH_CARD_TEXT_(card, 1, "%04X", queue);
-                qeth_schedule_recovery(card);
-                return;
-        }
-        for (i = first_element; i < (first_element + count); ++i) {
-                index = i % QDIO_MAX_BUFFERS_PER_Q;
-                buffer = &card->qdio.in_q->bufs[index];
-                if (!(qdio_err &&
-                      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 */
-                qeth_put_buffer_pool_entry(card, buffer->pool_entry);
-                qeth_queue_input_buffer(card, index);
-        }
-        if (card->options.performance_stats)
-                card->perf_stats.inbound_time += qeth_get_micros() -
-                        card->perf_stats.inbound_start_time;
-}
-
 static int qeth_l3_probe_device(struct ccwgroup_device *gdev)
 {
         struct qeth_card *card = dev_get_drvdata(&gdev->dev);
 
         qeth_l3_create_device_attributes(&gdev->dev);
         card->options.layer2 = 0;
+        card->info.hwtrap = 0;
+        card->discipline.start_poll = qeth_qdio_start_poll;
         card->discipline.input_handler = (qdio_handler_t *)
-                qeth_l3_qdio_input_handler;
+                qeth_qdio_input_handler;
         card->discipline.output_handler = (qdio_handler_t *)
                 qeth_qdio_output_handler;
         card->discipline.recover = qeth_l3_recover;
@@ -3359,17 +3330,15 @@ static void qeth_l3_remove_device(struct ccwgroup_device *cgdev)
         qeth_set_allowed_threads(card, 0, 1);
         wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
 
-        if (cgdev->state == CCWGROUP_ONLINE) {
-                card->use_hard_stop = 1;
+        if (cgdev->state == CCWGROUP_ONLINE)
                 qeth_l3_set_offline(cgdev);
-        }
 
         if (card->dev) {
                 unregister_netdev(card->dev);
                 card->dev = NULL;
         }
 
-        qeth_l3_clear_ip_list(card, 0, 0);
+        qeth_l3_clear_ip_list(card, 0);
         qeth_l3_clear_ipato_list(card);
         return;
 }
@@ -3394,14 +3363,20 @@ static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
                 goto out_remove;
         }
 
-        qeth_l3_query_ipassists(card, QETH_PROT_IPV4);
-
         if (!card->dev && qeth_l3_setup_netdev(card)) {
                 rc = -ENODEV;
                 goto out_remove;
         }
 
+        if (qeth_is_diagass_supported(card, QETH_DIAGS_CMD_TRAP)) {
+                if (card->info.hwtrap &&
+                    qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM))
+                        card->info.hwtrap = 0;
+        } else
+                card->info.hwtrap = 0;
+
         card->state = CARD_STATE_HARDSETUP;
+        memset(&card->rx, 0, sizeof(struct qeth_rx));
         qeth_print_status_message(card);
 
         /* softsetup */
@@ -3414,13 +3389,14 @@ static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
                         dev_warn(&card->gdev->dev,
                                 "The LAN is offline\n");
                         card->lan_online = 0;
-                        goto out;
+                        goto contin;
                 }
                 rc = -ENODEV;
                 goto out_remove;
         } else
                 card->lan_online = 1;
 
+contin:
         rc = qeth_l3_setadapter_parms(card);
         if (rc)
                 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
@@ -3428,7 +3404,6 @@ static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
                 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);
@@ -3445,13 +3420,16 @@ static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
                 goto out_remove;
         }
         card->state = CARD_STATE_SOFTSETUP;
-        netif_carrier_on(card->dev);
 
         qeth_set_allowed_threads(card, 0xffffffff, 0);
         qeth_l3_set_ip_addr_list(card);
+        if (card->lan_online)
+                netif_carrier_on(card->dev);
+        else
+                netif_carrier_off(card->dev);
         if (recover_flag == CARD_STATE_RECOVER) {
                 if (recovery_mode)
-                        qeth_l3_open(card->dev);
+                        __qeth_l3_open(card->dev);
                 else {
                         rtnl_lock();
                         dev_open(card->dev);
@@ -3461,12 +3439,10 @@ static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
         }
         /* let user_space know that device is online */
         kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
-out:
         mutex_unlock(&card->conf_mutex);
         mutex_unlock(&card->discipline_mutex);
         return 0;
 out_remove:
-        card->use_hard_stop = 1;
         qeth_l3_stop_card(card, 0);
         ccw_device_set_offline(CARD_DDEV(card));
         ccw_device_set_offline(CARD_WDEV(card));
@@ -3500,6 +3476,10 @@ static int __qeth_l3_set_offline(struct ccwgroup_device *cgdev,
         if (card->dev && netif_carrier_ok(card->dev))
                 netif_carrier_off(card->dev);
         recover_flag = card->state;
+        if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) {
+                qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
+                card->info.hwtrap = 1;
+        }
         qeth_l3_stop_card(card, recovery_mode);
         rc  = ccw_device_set_offline(CARD_DDEV(card));
         rc2 = ccw_device_set_offline(CARD_WDEV(card));
@@ -3535,12 +3515,8 @@ static int qeth_l3_recover(void *ptr)
         QETH_CARD_TEXT(card, 2, "recover2");
         dev_warn(&card->gdev->dev,
                 "A recovery process has been started for the device\n");
-        card->use_hard_stop = 1;
         __qeth_l3_set_offline(card->gdev, 1);
         rc = __qeth_l3_set_online(card->gdev, 1);
-        /* don't run another scheduled recovery */
-        qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
-        qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
         if (!rc)
                 dev_info(&card->gdev->dev,
                         "Device successfully recovered!\n");
@@ -3551,13 +3527,16 @@ static int qeth_l3_recover(void *ptr)
                 dev_warn(&card->gdev->dev, "The qeth device driver "
                         "failed to recover an error on the device\n");
         }
+        qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
+        qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
         return 0;
 }
 
 static void qeth_l3_shutdown(struct ccwgroup_device *gdev)
 {
         struct qeth_card *card = dev_get_drvdata(&gdev->dev);
-        qeth_l3_clear_ip_list(card, 0, 0);
+        if ((gdev->state == CCWGROUP_ONLINE) && card->info.hwtrap)
+                qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
         qeth_qdio_clear_card(card, 0);
         qeth_clear_qdio_buffers(card);
 }
@@ -3573,7 +3552,8 @@ static int qeth_l3_pm_suspend(struct ccwgroup_device *gdev)
         if (gdev->state == CCWGROUP_OFFLINE)
                 return 0;
         if (card->state == CARD_STATE_UP) {
-                card->use_hard_stop = 1;
+                if (card->info.hwtrap)
+                        qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
                 __qeth_l3_set_offline(card->gdev, 1);
         } else
                 __qeth_l3_set_offline(card->gdev, 0);
diff --git a/drivers/s390/net/qeth_l3_sys.c b/drivers/s390/net/qeth_l3_sys.c
index 67cfa68dcf1b..cd99210296e2 100644
--- a/drivers/s390/net/qeth_l3_sys.c
+++ b/drivers/s390/net/qeth_l3_sys.c
@@ -15,16 +15,6 @@
 #define QETH_DEVICE_ATTR(_id, _name, _mode, _show, _store) \
 struct device_attribute dev_attr_##_id = __ATTR(_name, _mode, _show, _store)
 
-static const char *qeth_l3_get_checksum_str(struct qeth_card *card)
-{
-        if (card->options.checksum_type == SW_CHECKSUMMING)
-                return "sw";
-        else if (card->options.checksum_type == HW_CHECKSUMMING)
-                return "hw";
-        else
-                return "no";
-}
-
 static ssize_t qeth_l3_dev_route_show(struct qeth_card *card,
                         struct qeth_routing_info *route, char *buf)
 {
@@ -295,51 +285,6 @@ out:
 static DEVICE_ATTR(canonical_macaddr, 0644, qeth_l3_dev_canonical_macaddr_show,
                    qeth_l3_dev_canonical_macaddr_store);
 
-static ssize_t qeth_l3_dev_checksum_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, "%s checksumming\n",
-                        qeth_l3_get_checksum_str(card));
-}
-
-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 = 0;
-
-        if (!card)
-                return -EINVAL;
-
-        mutex_lock(&card->conf_mutex);
-        tmp = strsep((char **) &buf, "\n");
-        if (!strcmp(tmp, "sw_checksumming"))
-                csum_type = SW_CHECKSUMMING;
-        else if (!strcmp(tmp, "hw_checksumming"))
-                csum_type = HW_CHECKSUMMING;
-        else if (!strcmp(tmp, "no_checksumming"))
-                csum_type = NO_CHECKSUMMING;
-        else {
-                rc = -EINVAL;
-                goto out;
-        }
-
-        rc = qeth_l3_set_rx_csum(card, csum_type);
-out:
-        mutex_unlock(&card->conf_mutex);
-        return rc ? rc : 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)
 {
@@ -402,61 +347,13 @@ out:
 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;
-
-        mutex_lock(&card->conf_mutex);
-        if (card->options.large_send != type)
-                rc = qeth_l3_set_large_send(card, type);
-        mutex_unlock(&card->conf_mutex);
-        return rc ? rc : 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,
         &dev_attr_fake_broadcast.attr,
         &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 65e1cf104943..207b7d742443 100644
--- a/drivers/s390/net/smsgiucv.c
+++ b/drivers/s390/net/smsgiucv.c
@@ -60,7 +60,7 @@ static struct iucv_handler smsg_handler = {
 static int smsg_path_pending(struct iucv_path *path, u8 ipvmid[8],
                              u8 ipuser[16])
 {
-        if (strncmp(ipvmid, "*MSG    ", sizeof(ipvmid)) != 0)
+        if (strncmp(ipvmid, "*MSG    ", 8) != 0)
                 return -EINVAL;
         /* Path pending from *MSG. */
         return iucv_path_accept(path, &smsg_handler, "SMSGIUCV        ", NULL);
diff --git a/drivers/s390/scsi/Makefile b/drivers/s390/scsi/Makefile
index cb301cc6178c..c454ffebb63e 100644
--- a/drivers/s390/scsi/Makefile
+++ b/drivers/s390/scsi/Makefile
@@ -2,7 +2,8 @@
 # Makefile for the S/390 specific device drivers
 #
 
-zfcp-objs := zfcp_aux.o zfcp_ccw.o zfcp_scsi.o zfcp_erp.o zfcp_qdio.o \
-             zfcp_fsf.o zfcp_dbf.o zfcp_sysfs.o zfcp_fc.o zfcp_cfdc.o
+zfcp-objs := zfcp_aux.o zfcp_ccw.o zfcp_cfdc.o zfcp_dbf.o zfcp_erp.o \
+             zfcp_fc.o zfcp_fsf.o zfcp_qdio.o zfcp_scsi.o zfcp_sysfs.o \
+             zfcp_unit.o
 
 obj-$(CONFIG_ZFCP) += zfcp.o
diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c
index 96fa1f536394..645b0fcbb370 100644
--- a/drivers/s390/scsi/zfcp_aux.c
+++ b/drivers/s390/scsi/zfcp_aux.c
@@ -45,8 +45,8 @@ static char *init_device;
 module_param_named(device, init_device, charp, 0400);
 MODULE_PARM_DESC(device, "specify initial device");
 
-static struct kmem_cache *zfcp_cache_hw_align(const char *name,
-                                              unsigned long size)
+static struct kmem_cache * __init zfcp_cache_hw_align(const char *name,
+                                                      unsigned long size)
 {
         return kmem_cache_create(name, size, roundup_pow_of_two(size), 0, NULL);
 }
@@ -56,7 +56,6 @@ static void __init zfcp_init_device_configure(char *busid, u64 wwpn, u64 lun)
         struct ccw_device *cdev;
         struct zfcp_adapter *adapter;
         struct zfcp_port *port;
-        struct zfcp_unit *unit;
 
         cdev = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
         if (!cdev)
@@ -72,17 +71,11 @@ static void __init zfcp_init_device_configure(char *busid, u64 wwpn, u64 lun)
         port = zfcp_get_port_by_wwpn(adapter, wwpn);
         if (!port)
                 goto out_port;
+        flush_work(&port->rport_work);
 
-        unit = zfcp_unit_enqueue(port, lun);
-        if (IS_ERR(unit))
-                goto out_unit;
-
-        zfcp_erp_unit_reopen(unit, 0, "auidc_1", NULL);
-        zfcp_erp_wait(adapter);
-        flush_work(&unit->scsi_work);
-
-out_unit:
+        zfcp_unit_add(port, lun);
         put_device(&port->dev);
+
 out_port:
         zfcp_ccw_adapter_put(adapter);
 out_ccw_device:
@@ -129,35 +122,23 @@ static int __init zfcp_module_init(void)
 {
         int retval = -ENOMEM;
 
-        zfcp_data.gpn_ft_cache = zfcp_cache_hw_align("zfcp_gpn",
-                                        sizeof(struct zfcp_fc_gpn_ft_req));
-        if (!zfcp_data.gpn_ft_cache)
-                goto out;
-
-        zfcp_data.qtcb_cache = zfcp_cache_hw_align("zfcp_qtcb",
-                                        sizeof(struct fsf_qtcb));
-        if (!zfcp_data.qtcb_cache)
+        zfcp_fsf_qtcb_cache = zfcp_cache_hw_align("zfcp_fsf_qtcb",
+                                                  sizeof(struct fsf_qtcb));
+        if (!zfcp_fsf_qtcb_cache)
                 goto out_qtcb_cache;
 
-        zfcp_data.sr_buffer_cache = zfcp_cache_hw_align("zfcp_sr",
-                                        sizeof(struct fsf_status_read_buffer));
-        if (!zfcp_data.sr_buffer_cache)
-                goto out_sr_cache;
+        zfcp_fc_req_cache = zfcp_cache_hw_align("zfcp_fc_req",
+                                                sizeof(struct zfcp_fc_req));
+        if (!zfcp_fc_req_cache)
+                goto out_fc_cache;
 
-        zfcp_data.gid_pn_cache = zfcp_cache_hw_align("zfcp_gid",
-                                        sizeof(struct zfcp_fc_gid_pn));
-        if (!zfcp_data.gid_pn_cache)
-                goto out_gid_cache;
-
-        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 =
+        zfcp_scsi_transport_template =
                 fc_attach_transport(&zfcp_transport_functions);
-        if (!zfcp_data.scsi_transport_template)
+        if (!zfcp_scsi_transport_template)
                 goto out_transport;
+        scsi_transport_reserve_device(zfcp_scsi_transport_template,
+                                      sizeof(struct zfcp_scsi_dev));
+
 
         retval = misc_register(&zfcp_cfdc_misc);
         if (retval) {
@@ -179,18 +160,12 @@ static int __init zfcp_module_init(void)
 out_ccw_register:
         misc_deregister(&zfcp_cfdc_misc);
 out_misc:
-        fc_release_transport(zfcp_data.scsi_transport_template);
+        fc_release_transport(zfcp_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);
-out_sr_cache:
-        kmem_cache_destroy(zfcp_data.qtcb_cache);
+        kmem_cache_destroy(zfcp_fc_req_cache);
+out_fc_cache:
+        kmem_cache_destroy(zfcp_fsf_qtcb_cache);
 out_qtcb_cache:
-        kmem_cache_destroy(zfcp_data.gpn_ft_cache);
-out:
         return retval;
 }
 
@@ -200,41 +175,14 @@ 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);
+        fc_release_transport(zfcp_scsi_transport_template);
+        kmem_cache_destroy(zfcp_fc_req_cache);
+        kmem_cache_destroy(zfcp_fsf_qtcb_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
- * @fcp_lun: FCP LUN to search for
- *
- * Returns: pointer to zfcp_unit or NULL
- */
-struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *port, u64 fcp_lun)
-{
-        unsigned long flags;
-        struct zfcp_unit *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;
-}
-
-/**
  * zfcp_get_port_by_wwpn - find port in port list of adapter by wwpn
  * @adapter: pointer to adapter to search for port
  * @wwpn: wwpn to search for
@@ -259,92 +207,6 @@ struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter,
         return NULL;
 }
 
-/**
- * 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)
-{
-        struct zfcp_unit *unit = container_of(dev, struct zfcp_unit, dev);
-
-        put_device(&unit->port->dev);
-        kfree(unit);
-}
-
-/**
- * zfcp_unit_enqueue - enqueue unit to unit list of a port.
- * @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
- *
- * 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);
-
-        unit = zfcp_get_unit_by_lun(port, fcp_lun);
-        if (unit) {
-                put_device(&unit->dev);
-                retval = -EEXIST;
-                goto err_out;
-        }
-
-        unit = kzalloc(sizeof(struct zfcp_unit), GFP_KERNEL);
-        if (!unit)
-                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->dev, "0x%016llx",
-                         (unsigned long long) fcp_lun)) {
-                kfree(unit);
-                goto err_out;
-        }
-        retval = -EINVAL;
-
-        INIT_WORK(&unit->scsi_work, zfcp_scsi_scan_work);
-
-        spin_lock_init(&unit->latencies.lock);
-        unit->latencies.write.channel.min = 0xFFFFFFFF;
-        unit->latencies.write.fabric.min = 0xFFFFFFFF;
-        unit->latencies.read.channel.min = 0xFFFFFFFF;
-        unit->latencies.read.fabric.min = 0xFFFFFFFF;
-        unit->latencies.cmd.channel.min = 0xFFFFFFFF;
-        unit->latencies.cmd.fabric.min = 0xFFFFFFFF;
-
-        if (device_register(&unit->dev)) {
-                put_device(&unit->dev);
-                goto err_out;
-        }
-
-        if (sysfs_create_group(&unit->dev.kobj, &zfcp_sysfs_unit_attrs))
-                goto err_out_put;
-
-        write_lock_irq(&port->unit_list_lock);
-        list_add_tail(&unit->list, &port->unit_list);
-        write_unlock_irq(&port->unit_list_lock);
-
-        atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &unit->status);
-
-        return unit;
-
-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)
 {
         adapter->pool.erp_req =
@@ -374,18 +236,18 @@ static int zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter)
                 return -ENOMEM;
 
         adapter->pool.qtcb_pool =
-                mempool_create_slab_pool(4, zfcp_data.qtcb_cache);
+                mempool_create_slab_pool(4, zfcp_fsf_qtcb_cache);
         if (!adapter->pool.qtcb_pool)
                 return -ENOMEM;
 
-        adapter->pool.status_read_data =
-                mempool_create_slab_pool(FSF_STATUS_READS_RECOM,
-                                         zfcp_data.sr_buffer_cache);
-        if (!adapter->pool.status_read_data)
+        BUILD_BUG_ON(sizeof(struct fsf_status_read_buffer) > PAGE_SIZE);
+        adapter->pool.sr_data =
+                mempool_create_page_pool(FSF_STATUS_READS_RECOM, 0);
+        if (!adapter->pool.sr_data)
                 return -ENOMEM;
 
         adapter->pool.gid_pn =
-                mempool_create_slab_pool(1, zfcp_data.gid_pn_cache);
+                mempool_create_slab_pool(1, zfcp_fc_req_cache);
         if (!adapter->pool.gid_pn)
                 return -ENOMEM;
 
@@ -404,8 +266,8 @@ static void zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter)
                 mempool_destroy(adapter->pool.qtcb_pool);
         if (adapter->pool.status_read_req)
                 mempool_destroy(adapter->pool.status_read_req);
-        if (adapter->pool.status_read_data)
-                mempool_destroy(adapter->pool.status_read_data);
+        if (adapter->pool.sr_data)
+                mempool_destroy(adapter->pool.sr_data);
         if (adapter->pool.gid_pn)
                 mempool_destroy(adapter->pool.gid_pn);
 }
@@ -425,8 +287,7 @@ int zfcp_status_read_refill(struct zfcp_adapter *adapter)
                 if (zfcp_fsf_status_read(adapter->qdio)) {
                         if (atomic_read(&adapter->stat_miss) >=
                             adapter->stat_read_buf_num) {
-                                zfcp_erp_adapter_reopen(adapter, 0, "axsref1",
-                                                        NULL);
+                                zfcp_erp_adapter_reopen(adapter, 0, "axsref1");
                                 return 1;
                         }
                         break;
@@ -501,6 +362,7 @@ struct zfcp_adapter *zfcp_adapter_enqueue(struct ccw_device *ccw_device)
 
         INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler);
         INIT_WORK(&adapter->scan_work, zfcp_fc_scan_ports);
+        INIT_WORK(&adapter->ns_up_work, zfcp_fc_sym_name_update);
 
         if (zfcp_qdio_setup(adapter))
                 goto failed;
@@ -552,7 +414,7 @@ struct zfcp_adapter *zfcp_adapter_enqueue(struct ccw_device *ccw_device)
         adapter->dma_parms.max_segment_size = ZFCP_QDIO_SBALE_LEN;
         adapter->ccw_device->dev.dma_parms = &adapter->dma_parms;
 
-        if (!zfcp_adapter_scsi_register(adapter))
+        if (!zfcp_scsi_adapter_register(adapter))
                 return adapter;
 
 failed:
@@ -566,14 +428,15 @@ void zfcp_adapter_unregister(struct zfcp_adapter *adapter)
 
         cancel_work_sync(&adapter->scan_work);
         cancel_work_sync(&adapter->stat_work);
+        cancel_work_sync(&adapter->ns_up_work);
         zfcp_destroy_adapter_work_queue(adapter);
 
         zfcp_fc_wka_ports_force_offline(adapter->gs);
-        zfcp_adapter_scsi_unregister(adapter);
+        zfcp_scsi_adapter_unregister(adapter);
         sysfs_remove_group(&cdev->dev.kobj, &zfcp_sysfs_adapter_attrs);
 
         zfcp_erp_thread_kill(adapter);
-        zfcp_dbf_adapter_unregister(adapter->dbf);
+        zfcp_dbf_adapter_unregister(adapter);
         zfcp_qdio_destroy(adapter->qdio);
 
         zfcp_ccw_adapter_put(adapter); /* final put to release */
diff --git a/drivers/s390/scsi/zfcp_ccw.c b/drivers/s390/scsi/zfcp_ccw.c
index ce1cc7a11fb4..e8b7cee62046 100644
--- a/drivers/s390/scsi/zfcp_ccw.c
+++ b/drivers/s390/scsi/zfcp_ccw.c
@@ -46,10 +46,9 @@ static int zfcp_ccw_activate(struct ccw_device *cdev)
         if (!adapter)
                 return 0;
 
-        zfcp_erp_modify_adapter_status(adapter, "ccresu1", NULL,
-                                       ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
+        zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                "ccresu2", NULL);
+                                "ccresu2");
         zfcp_erp_wait(adapter);
         flush_work(&adapter->scan_work);
 
@@ -164,14 +163,7 @@ static int zfcp_ccw_set_online(struct ccw_device *cdev)
         BUG_ON(!zfcp_reqlist_isempty(adapter->req_list));
         adapter->req_no = 0;
 
-        zfcp_erp_modify_adapter_status(adapter, "ccsonl1", NULL,
-                                       ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
-        zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                "ccsonl2", NULL);
-        zfcp_erp_wait(adapter);
-
-        flush_work(&adapter->scan_work);
-
+        zfcp_ccw_activate(cdev);
         zfcp_ccw_adapter_put(adapter);
         return 0;
 }
@@ -190,7 +182,7 @@ static int zfcp_ccw_set_offline(struct ccw_device *cdev)
         if (!adapter)
                 return 0;
 
-        zfcp_erp_adapter_shutdown(adapter, 0, "ccsoff1", NULL);
+        zfcp_erp_adapter_shutdown(adapter, 0, "ccsoff1");
         zfcp_erp_wait(adapter);
 
         zfcp_ccw_adapter_put(adapter);
@@ -215,25 +207,24 @@ static int zfcp_ccw_notify(struct ccw_device *cdev, int event)
         switch (event) {
         case CIO_GONE:
                 dev_warn(&cdev->dev, "The FCP device has been detached\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1", NULL);
+                zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti1");
                 break;
         case CIO_NO_PATH:
                 dev_warn(&cdev->dev,
                          "The CHPID for the FCP device is offline\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2", NULL);
+                zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti2");
                 break;
         case CIO_OPER:
                 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);
+                zfcp_erp_set_adapter_status(adapter,
+                                            ZFCP_STATUS_COMMON_RUNNING);
                 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                        "ccnoti4", NULL);
+                                        "ccnoti4");
                 break;
         case CIO_BOXED:
                 dev_warn(&cdev->dev, "The FCP device did not respond within "
                                      "the specified time\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5", NULL);
+                zfcp_erp_adapter_shutdown(adapter, 0, "ccnoti5");
                 break;
         }
 
@@ -252,7 +243,7 @@ static void zfcp_ccw_shutdown(struct ccw_device *cdev)
         if (!adapter)
                 return;
 
-        zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1", NULL);
+        zfcp_erp_adapter_shutdown(adapter, 0, "ccshut1");
         zfcp_erp_wait(adapter);
         zfcp_erp_thread_kill(adapter);
 
@@ -260,8 +251,10 @@ static void zfcp_ccw_shutdown(struct ccw_device *cdev)
 }
 
 struct ccw_driver zfcp_ccw_driver = {
-        .owner       = THIS_MODULE,
-        .name        = "zfcp",
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "zfcp",
+        },
         .ids         = zfcp_ccw_device_id,
         .probe       = zfcp_ccw_probe,
         .remove      = zfcp_ccw_remove,
diff --git a/drivers/s390/scsi/zfcp_cfdc.c b/drivers/s390/scsi/zfcp_cfdc.c
index fcbd2b756da4..303dde09d294 100644
--- a/drivers/s390/scsi/zfcp_cfdc.c
+++ b/drivers/s390/scsi/zfcp_cfdc.c
@@ -2,9 +2,10 @@
  * zfcp device driver
  *
  * Userspace interface for accessing the
- * Access Control Lists / Control File Data Channel
+ * Access Control Lists / Control File Data Channel;
+ * handling of response code and states for ports and LUNs.
  *
- * Copyright IBM Corporation 2008, 2009
+ * Copyright IBM Corporation 2008, 2010
  */
 
 #define KMSG_COMPONENT "zfcp"
@@ -251,8 +252,9 @@ static const struct file_operations zfcp_cfdc_fops = {
         .open = nonseekable_open,
         .unlocked_ioctl = zfcp_cfdc_dev_ioctl,
 #ifdef CONFIG_COMPAT
-        .compat_ioctl = zfcp_cfdc_dev_ioctl
+        .compat_ioctl = zfcp_cfdc_dev_ioctl,
 #endif
+        .llseek = no_llseek,
 };
 
 struct miscdevice zfcp_cfdc_misc = {
@@ -260,3 +262,184 @@ struct miscdevice zfcp_cfdc_misc = {
         .name = "zfcp_cfdc",
         .fops = &zfcp_cfdc_fops,
 };
+
+/**
+ * zfcp_cfdc_adapter_access_changed - Process change in adapter ACT
+ * @adapter: Adapter where the Access Control Table (ACT) changed
+ *
+ * After a change in the adapter ACT, check if access to any
+ * previously denied resources is now possible.
+ */
+void zfcp_cfdc_adapter_access_changed(struct zfcp_adapter *adapter)
+{
+        unsigned long flags;
+        struct zfcp_port *port;
+        struct scsi_device *sdev;
+        struct zfcp_scsi_dev *zfcp_sdev;
+        int status;
+
+        if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
+                return;
+
+        read_lock_irqsave(&adapter->port_list_lock, flags);
+        list_for_each_entry(port, &adapter->port_list, list) {
+                status = atomic_read(&port->status);
+                if ((status & ZFCP_STATUS_COMMON_ACCESS_DENIED) ||
+                    (status & ZFCP_STATUS_COMMON_ACCESS_BOXED))
+                        zfcp_erp_port_reopen(port,
+                                             ZFCP_STATUS_COMMON_ERP_FAILED,
+                                             "cfaac_1");
+        }
+        read_unlock_irqrestore(&adapter->port_list_lock, flags);
+
+        shost_for_each_device(sdev, port->adapter->scsi_host) {
+                zfcp_sdev = sdev_to_zfcp(sdev);
+                status = atomic_read(&zfcp_sdev->status);
+                if ((status & ZFCP_STATUS_COMMON_ACCESS_DENIED) ||
+                    (status & ZFCP_STATUS_COMMON_ACCESS_BOXED))
+                        zfcp_erp_lun_reopen(sdev,
+                                            ZFCP_STATUS_COMMON_ERP_FAILED,
+                                            "cfaac_2");
+        }
+}
+
+static void zfcp_act_eval_err(struct zfcp_adapter *adapter, u32 table)
+{
+        u16 subtable = table >> 16;
+        u16 rule = table & 0xffff;
+        const char *act_type[] = { "unknown", "OS", "WWPN", "DID", "LUN" };
+
+        if (subtable && subtable < ARRAY_SIZE(act_type))
+                dev_warn(&adapter->ccw_device->dev,
+                         "Access denied according to ACT rule type %s, "
+                         "rule %d\n", act_type[subtable], rule);
+}
+
+/**
+ * zfcp_cfdc_port_denied - Process "access denied" for port
+ * @port: The port where the access has been denied
+ * @qual: The FSF status qualifier for the access denied FSF status
+ */
+void zfcp_cfdc_port_denied(struct zfcp_port *port,
+                           union fsf_status_qual *qual)
+{
+        dev_warn(&port->adapter->ccw_device->dev,
+                 "Access denied to port 0x%016Lx\n",
+                 (unsigned long long)port->wwpn);
+
+        zfcp_act_eval_err(port->adapter, qual->halfword[0]);
+        zfcp_act_eval_err(port->adapter, qual->halfword[1]);
+        zfcp_erp_set_port_status(port,
+                                 ZFCP_STATUS_COMMON_ERP_FAILED |
+                                 ZFCP_STATUS_COMMON_ACCESS_DENIED);
+}
+
+/**
+ * zfcp_cfdc_lun_denied - Process "access denied" for LUN
+ * @sdev: The SCSI device / LUN where the access has been denied
+ * @qual: The FSF status qualifier for the access denied FSF status
+ */
+void zfcp_cfdc_lun_denied(struct scsi_device *sdev,
+                          union fsf_status_qual *qual)
+{
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+
+        dev_warn(&zfcp_sdev->port->adapter->ccw_device->dev,
+                 "Access denied to LUN 0x%016Lx on port 0x%016Lx\n",
+                 zfcp_scsi_dev_lun(sdev),
+                 (unsigned long long)zfcp_sdev->port->wwpn);
+        zfcp_act_eval_err(zfcp_sdev->port->adapter, qual->halfword[0]);
+        zfcp_act_eval_err(zfcp_sdev->port->adapter, qual->halfword[1]);
+        zfcp_erp_set_lun_status(sdev,
+                                ZFCP_STATUS_COMMON_ERP_FAILED |
+                                ZFCP_STATUS_COMMON_ACCESS_DENIED);
+
+        atomic_clear_mask(ZFCP_STATUS_LUN_SHARED, &zfcp_sdev->status);
+        atomic_clear_mask(ZFCP_STATUS_LUN_READONLY, &zfcp_sdev->status);
+}
+
+/**
+ * zfcp_cfdc_lun_shrng_vltn - Evaluate LUN sharing violation status
+ * @sdev: The LUN / SCSI device where sharing violation occurred
+ * @qual: The FSF status qualifier from the LUN sharing violation
+ */
+void zfcp_cfdc_lun_shrng_vltn(struct scsi_device *sdev,
+                              union fsf_status_qual *qual)
+{
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+
+        if (qual->word[0])
+                dev_warn(&zfcp_sdev->port->adapter->ccw_device->dev,
+                         "LUN 0x%Lx on port 0x%Lx is already in "
+                         "use by CSS%d, MIF Image ID %x\n",
+                         zfcp_scsi_dev_lun(sdev),
+                         (unsigned long long)zfcp_sdev->port->wwpn,
+                         qual->fsf_queue_designator.cssid,
+                         qual->fsf_queue_designator.hla);
+        else
+                zfcp_act_eval_err(zfcp_sdev->port->adapter, qual->word[2]);
+
+        zfcp_erp_set_lun_status(sdev,
+                                ZFCP_STATUS_COMMON_ERP_FAILED |
+                                ZFCP_STATUS_COMMON_ACCESS_DENIED);
+        atomic_clear_mask(ZFCP_STATUS_LUN_SHARED, &zfcp_sdev->status);
+        atomic_clear_mask(ZFCP_STATUS_LUN_READONLY, &zfcp_sdev->status);
+}
+
+/**
+ * zfcp_cfdc_open_lun_eval - Eval access ctrl. status for successful "open lun"
+ * @sdev: The SCSI device / LUN where to evaluate the status
+ * @bottom: The qtcb bottom with the status from the "open lun"
+ *
+ * Returns: 0 if LUN is usable, -EACCES if the access control table
+ *          reports an unsupported configuration.
+ */
+int zfcp_cfdc_open_lun_eval(struct scsi_device *sdev,
+                            struct fsf_qtcb_bottom_support *bottom)
+{
+        int shared, rw;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+        struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
+
+        if ((adapter->connection_features & FSF_FEATURE_NPIV_MODE) ||
+            !(adapter->adapter_features & FSF_FEATURE_LUN_SHARING) ||
+            zfcp_ccw_priv_sch(adapter))
+                return 0;
+
+        shared = !(bottom->lun_access_info & FSF_UNIT_ACCESS_EXCLUSIVE);
+        rw = (bottom->lun_access_info & FSF_UNIT_ACCESS_OUTBOUND_TRANSFER);
+
+        if (shared)
+                atomic_set_mask(ZFCP_STATUS_LUN_SHARED, &zfcp_sdev->status);
+
+        if (!rw) {
+                atomic_set_mask(ZFCP_STATUS_LUN_READONLY, &zfcp_sdev->status);
+                dev_info(&adapter->ccw_device->dev, "SCSI device at LUN "
+                         "0x%016Lx on port 0x%016Lx opened read-only\n",
+                         zfcp_scsi_dev_lun(sdev),
+                         (unsigned long long)zfcp_sdev->port->wwpn);
+        }
+
+        if (!shared && !rw) {
+                dev_err(&adapter->ccw_device->dev, "Exclusive read-only access "
+                        "not supported (LUN 0x%016Lx, port 0x%016Lx)\n",
+                        zfcp_scsi_dev_lun(sdev),
+                        (unsigned long long)zfcp_sdev->port->wwpn);
+                zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
+                zfcp_erp_lun_shutdown(sdev, 0, "fsouh_6");
+                return -EACCES;
+        }
+
+        if (shared && rw) {
+                dev_err(&adapter->ccw_device->dev,
+                        "Shared read-write access not supported "
+                        "(LUN 0x%016Lx, port 0x%016Lx)\n",
+                        zfcp_scsi_dev_lun(sdev),
+                        (unsigned long long)zfcp_sdev->port->wwpn);
+                zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
+                zfcp_erp_lun_shutdown(sdev, 0, "fsosh_8");
+                return -EACCES;
+        }
+
+        return 0;
+}
diff --git a/drivers/s390/scsi/zfcp_dbf.c b/drivers/s390/scsi/zfcp_dbf.c
index a86117b0d6e1..96d1462e0bf5 100644
--- a/drivers/s390/scsi/zfcp_dbf.c
+++ b/drivers/s390/scsi/zfcp_dbf.c
@@ -3,7 +3,7 @@
  *
  * Debug traces for zfcp.
  *
- * Copyright IBM Corporation 2002, 2009
+ * Copyright IBM Corporation 2002, 2010
  */
 
 #define KMSG_COMPONENT "zfcp"
@@ -22,982 +22,392 @@ module_param(dbfsize, uint, 0400);
 MODULE_PARM_DESC(dbfsize,
                  "number of pages for each debug feature area (default 4)");
 
-static void zfcp_dbf_hexdump(debug_info_t *dbf, void *to, int to_len,
-                             int level, char *from, int from_len)
+static inline unsigned int zfcp_dbf_plen(unsigned int offset)
 {
-        int offset;
-        struct zfcp_dbf_dump *dump = to;
-        int room = to_len - sizeof(*dump);
-
-        for (offset = 0; offset < from_len; offset += dump->size) {
-                memset(to, 0, to_len);
-                strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE);
-                dump->total_size = from_len;
-                dump->offset = offset;
-                dump->size = min(from_len - offset, room);
-                memcpy(dump->data, from + offset, dump->size);
-                debug_event(dbf, level, dump, dump->size + sizeof(*dump));
-        }
+        return sizeof(struct zfcp_dbf_pay) + offset - ZFCP_DBF_PAY_MAX_REC;
 }
 
-static void zfcp_dbf_tag(char **p, const char *label, const char *tag)
+static inline
+void zfcp_dbf_pl_write(struct zfcp_dbf *dbf, void *data, u16 length, char *area,
+                       u64 req_id)
 {
-        int i;
-
-        *p += sprintf(*p, "%-24s", label);
-        for (i = 0; i < ZFCP_DBF_TAG_SIZE; i++)
-                *p += sprintf(*p, "%c", tag[i]);
-        *p += sprintf(*p, "\n");
-}
+        struct zfcp_dbf_pay *pl = &dbf->pay_buf;
+        u16 offset = 0, rec_length;
 
-static void zfcp_dbf_outs(char **buf, const char *s1, const char *s2)
-{
-        *buf += sprintf(*buf, "%-24s%s\n", s1, s2);
-}
+        spin_lock(&dbf->pay_lock);
+        memset(pl, 0, sizeof(*pl));
+        pl->fsf_req_id = req_id;
+        memcpy(pl->area, area, ZFCP_DBF_TAG_LEN);
 
-static void zfcp_dbf_out(char **buf, const char *s, const char *format, ...)
-{
-        va_list arg;
+        while (offset < length) {
+                rec_length = min((u16) ZFCP_DBF_PAY_MAX_REC,
+                                 (u16) (length - offset));
+                memcpy(pl->data, data + offset, rec_length);
+                debug_event(dbf->pay, 1, pl, zfcp_dbf_plen(rec_length));
 
-        *buf += sprintf(*buf, "%-24s", s);
-        va_start(arg, format);
-        *buf += vsprintf(*buf, format, arg);
-        va_end(arg);
-        *buf += sprintf(*buf, "\n");
-}
-
-static void zfcp_dbf_outd(char **p, const char *label, char *buffer,
-                          int buflen, int offset, int total_size)
-{
-        if (!offset)
-                *p += sprintf(*p, "%-24s  ", label);
-        while (buflen--) {
-                if (offset > 0) {
-                        if ((offset % 32) == 0)
-                                *p += sprintf(*p, "\n%-24c  ", ' ');
-                        else if ((offset % 4) == 0)
-                                *p += sprintf(*p, " ");
-                }
-                *p += sprintf(*p, "%02x", *buffer++);
-                if (++offset == total_size) {
-                        *p += sprintf(*p, "\n");
-                        break;
-                }
+                offset += rec_length;
+                pl->counter++;
         }
-        if (!total_size)
-                *p += sprintf(*p, "\n");
-}
 
-static int zfcp_dbf_view_header(debug_info_t *id, struct debug_view *view,
-                                int area, debug_entry_t *entry, char *out_buf)
-{
-        struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)DEBUG_DATA(entry);
-        struct timespec t;
-        char *p = out_buf;
-
-        if (strncmp(dump->tag, "dump", ZFCP_DBF_TAG_SIZE) != 0) {
-                stck_to_timespec(entry->id.stck, &t);
-                zfcp_dbf_out(&p, "timestamp", "%011lu:%06lu",
-                             t.tv_sec, t.tv_nsec);
-                zfcp_dbf_out(&p, "cpu", "%02i", entry->id.fields.cpuid);
-        } else  {
-                zfcp_dbf_outd(&p, "", dump->data, dump->size, dump->offset,
-                              dump->total_size);
-                if ((dump->offset + dump->size) == dump->total_size)
-                        p += sprintf(p, "\n");
-        }
-        return p - out_buf;
+        spin_unlock(&dbf->pay_lock);
 }
 
-void _zfcp_dbf_hba_fsf_response(const char *tag2, int level,
-                                struct zfcp_fsf_req *fsf_req,
-                                struct zfcp_dbf *dbf)
+/**
+ * zfcp_dbf_hba_fsf_res - trace event for fsf responses
+ * @tag: tag indicating which kind of unsolicited status has been received
+ * @req: request for which a response was received
+ */
+void zfcp_dbf_hba_fsf_res(char *tag, struct zfcp_fsf_req *req)
 {
-        struct fsf_qtcb *qtcb = fsf_req->qtcb;
-        union fsf_prot_status_qual *prot_status_qual =
-                                        &qtcb->prefix.prot_status_qual;
-        union fsf_status_qual *fsf_status_qual = &qtcb->header.fsf_status_qual;
-        struct scsi_cmnd *scsi_cmnd;
-        struct zfcp_port *port;
-        struct zfcp_unit *unit;
-        struct zfcp_send_els *send_els;
-        struct zfcp_dbf_hba_record *rec = &dbf->hba_buf;
-        struct zfcp_dbf_hba_record_response *response = &rec->u.response;
+        struct zfcp_dbf *dbf = req->adapter->dbf;
+        struct fsf_qtcb_prefix *q_pref = &req->qtcb->prefix;
+        struct fsf_qtcb_header *q_head = &req->qtcb->header;
+        struct zfcp_dbf_hba *rec = &dbf->hba_buf;
         unsigned long flags;
 
         spin_lock_irqsave(&dbf->hba_lock, flags);
         memset(rec, 0, sizeof(*rec));
-        strncpy(rec->tag, "resp", ZFCP_DBF_TAG_SIZE);
-        strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE);
-
-        response->fsf_command = fsf_req->fsf_command;
-        response->fsf_reqid = fsf_req->req_id;
-        response->fsf_seqno = fsf_req->seq_no;
-        response->fsf_issued = fsf_req->issued;
-        response->fsf_prot_status = qtcb->prefix.prot_status;
-        response->fsf_status = qtcb->header.fsf_status;
-        memcpy(response->fsf_prot_status_qual,
-               prot_status_qual, FSF_PROT_STATUS_QUAL_SIZE);
-        memcpy(response->fsf_status_qual,
-               fsf_status_qual, FSF_STATUS_QUALIFIER_SIZE);
-        response->fsf_req_status = fsf_req->status;
-        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;
-
-        switch (fsf_req->fsf_command) {
-        case FSF_QTCB_FCP_CMND:
-                if (fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)
-                        break;
-                scsi_cmnd = (struct scsi_cmnd *)fsf_req->data;
-                if (scsi_cmnd) {
-                        response->u.fcp.cmnd = (unsigned long)scsi_cmnd;
-                        response->u.fcp.serial = scsi_cmnd->serial_number;
-                        response->u.fcp.data_dir =
-                                qtcb->bottom.io.data_direction;
-                }
-                break;
-
-        case FSF_QTCB_OPEN_PORT_WITH_DID:
-        case FSF_QTCB_CLOSE_PORT:
-        case FSF_QTCB_CLOSE_PHYSICAL_PORT:
-                port = (struct zfcp_port *)fsf_req->data;
-                response->u.port.wwpn = port->wwpn;
-                response->u.port.d_id = port->d_id;
-                response->u.port.port_handle = qtcb->header.port_handle;
-                break;
-
-        case FSF_QTCB_OPEN_LUN:
-        case FSF_QTCB_CLOSE_LUN:
-                unit = (struct zfcp_unit *)fsf_req->data;
-                port = unit->port;
-                response->u.unit.wwpn = port->wwpn;
-                response->u.unit.fcp_lun = unit->fcp_lun;
-                response->u.unit.port_handle = qtcb->header.port_handle;
-                response->u.unit.lun_handle = qtcb->header.lun_handle;
-                break;
-
-        case FSF_QTCB_SEND_ELS:
-                send_els = (struct zfcp_send_els *)fsf_req->data;
-                response->u.els.d_id = ntoh24(qtcb->bottom.support.d_id);
-                break;
-
-        case FSF_QTCB_ABORT_FCP_CMND:
-        case FSF_QTCB_SEND_GENERIC:
-        case FSF_QTCB_EXCHANGE_CONFIG_DATA:
-        case FSF_QTCB_EXCHANGE_PORT_DATA:
-        case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
-        case FSF_QTCB_UPLOAD_CONTROL_FILE:
-                break;
-        }
-
-        debug_event(dbf->hba, level, rec, sizeof(*rec));
 
-        /* have fcp channel microcode fixed to use as little as possible */
-        if (fsf_req->fsf_command != FSF_QTCB_FCP_CMND) {
-                /* adjust length skipping trailing zeros */
-                char *buf = (char *)qtcb + qtcb->header.log_start;
-                int len = qtcb->header.log_length;
-                for (; len && !buf[len - 1]; len--);
-                zfcp_dbf_hexdump(dbf->hba, rec, sizeof(*rec), level, buf,
-                                 len);
+        memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
+        rec->id = ZFCP_DBF_HBA_RES;
+        rec->fsf_req_id = req->req_id;
+        rec->fsf_req_status = req->status;
+        rec->fsf_cmd = req->fsf_command;
+        rec->fsf_seq_no = req->seq_no;
+        rec->u.res.req_issued = req->issued;
+        rec->u.res.prot_status = q_pref->prot_status;
+        rec->u.res.fsf_status = q_head->fsf_status;
+
+        memcpy(rec->u.res.prot_status_qual, &q_pref->prot_status_qual,
+               FSF_PROT_STATUS_QUAL_SIZE);
+        memcpy(rec->u.res.fsf_status_qual, &q_head->fsf_status_qual,
+               FSF_STATUS_QUALIFIER_SIZE);
+
+        if (req->fsf_command != FSF_QTCB_FCP_CMND) {
+                rec->pl_len = q_head->log_length;
+                zfcp_dbf_pl_write(dbf, (char *)q_pref + q_head->log_start,
+                                  rec->pl_len, "fsf_res", req->req_id);
         }
 
-        spin_unlock_irqrestore(&dbf->hba_lock, flags);
-}
-
-void _zfcp_dbf_hba_fsf_unsol(const char *tag, int level, struct zfcp_dbf *dbf,
-                             struct fsf_status_read_buffer *status_buffer)
-{
-        struct zfcp_dbf_hba_record *rec = &dbf->hba_buf;
-        unsigned long flags;
-
-        spin_lock_irqsave(&dbf->hba_lock, flags);
-        memset(rec, 0, sizeof(*rec));
-        strncpy(rec->tag, "stat", ZFCP_DBF_TAG_SIZE);
-        strncpy(rec->tag2, tag, ZFCP_DBF_TAG_SIZE);
-
-        rec->u.status.failed = atomic_read(&dbf->adapter->stat_miss);
-        if (status_buffer != NULL) {
-                rec->u.status.status_type = status_buffer->status_type;
-                rec->u.status.status_subtype = status_buffer->status_subtype;
-                memcpy(&rec->u.status.queue_designator,
-                       &status_buffer->queue_designator,
-                       sizeof(struct fsf_queue_designator));
-
-                switch (status_buffer->status_type) {
-                case FSF_STATUS_READ_SENSE_DATA_AVAIL:
-                        rec->u.status.payload_size =
-                            ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL;
-                        break;
-
-                case FSF_STATUS_READ_BIT_ERROR_THRESHOLD:
-                        rec->u.status.payload_size =
-                            ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD;
-                        break;
-
-                case FSF_STATUS_READ_LINK_DOWN:
-                        switch (status_buffer->status_subtype) {
-                        case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK:
-                        case FSF_STATUS_READ_SUB_FDISC_FAILED:
-                                rec->u.status.payload_size =
-                                        sizeof(struct fsf_link_down_info);
-                        }
-                        break;
-
-                case FSF_STATUS_READ_FEATURE_UPDATE_ALERT:
-                        rec->u.status.payload_size =
-                            ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT;
-                        break;
-                }
-                memcpy(&rec->u.status.payload,
-                       &status_buffer->payload, rec->u.status.payload_size);
-        }
-
-        debug_event(dbf->hba, level, rec, sizeof(*rec));
+        debug_event(dbf->hba, 1, rec, sizeof(*rec));
         spin_unlock_irqrestore(&dbf->hba_lock, flags);
 }
 
 /**
- * zfcp_dbf_hba_qdio - trace event for QDIO related failure
- * @qdio: qdio structure affected by this QDIO related event
- * @qdio_error: as passed by qdio module
- * @sbal_index: first buffer with error condition, as passed by qdio module
- * @sbal_count: number of buffers affected, as passed by qdio module
+ * zfcp_dbf_hba_fsf_uss - trace event for an unsolicited status buffer
+ * @tag: tag indicating which kind of unsolicited status has been received
+ * @req: request providing the unsolicited status
  */
-void zfcp_dbf_hba_qdio(struct zfcp_dbf *dbf, unsigned int qdio_error,
-                       int sbal_index, int sbal_count)
+void zfcp_dbf_hba_fsf_uss(char *tag, struct zfcp_fsf_req *req)
 {
-        struct zfcp_dbf_hba_record *r = &dbf->hba_buf;
+        struct zfcp_dbf *dbf = req->adapter->dbf;
+        struct fsf_status_read_buffer *srb = req->data;
+        struct zfcp_dbf_hba *rec = &dbf->hba_buf;
         unsigned long flags;
 
         spin_lock_irqsave(&dbf->hba_lock, flags);
-        memset(r, 0, sizeof(*r));
-        strncpy(r->tag, "qdio", ZFCP_DBF_TAG_SIZE);
-        r->u.qdio.qdio_error = qdio_error;
-        r->u.qdio.sbal_index = sbal_index;
-        r->u.qdio.sbal_count = sbal_count;
-        debug_event(dbf->hba, 0, r, sizeof(*r));
+        memset(rec, 0, sizeof(*rec));
+
+        memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
+        rec->id = ZFCP_DBF_HBA_USS;
+        rec->fsf_req_id = req->req_id;
+        rec->fsf_req_status = req->status;
+        rec->fsf_cmd = req->fsf_command;
+
+        if (!srb)
+                goto log;
+
+        rec->u.uss.status_type = srb->status_type;
+        rec->u.uss.status_subtype = srb->status_subtype;
+        rec->u.uss.d_id = ntoh24(srb->d_id);
+        rec->u.uss.lun = srb->fcp_lun;
+        memcpy(&rec->u.uss.queue_designator, &srb->queue_designator,
+               sizeof(rec->u.uss.queue_designator));
+
+        /* status read buffer payload length */
+        rec->pl_len = (!srb->length) ? 0 : srb->length -
+                        offsetof(struct fsf_status_read_buffer, payload);
+
+        if (rec->pl_len)
+                zfcp_dbf_pl_write(dbf, srb->payload.data, rec->pl_len,
+                                  "fsf_uss", req->req_id);
+log:
+        debug_event(dbf->hba, 2, rec, sizeof(*rec));
         spin_unlock_irqrestore(&dbf->hba_lock, flags);
 }
 
 /**
- * zfcp_dbf_hba_berr - trace event for bit error threshold
- * @dbf: dbf structure affected by this QDIO related event
- * @req: fsf request
+ * zfcp_dbf_hba_bit_err - trace event for bit error conditions
+ * @tag: tag indicating which kind of unsolicited status has been received
+ * @req: request which caused the bit_error condition
  */
-void zfcp_dbf_hba_berr(struct zfcp_dbf *dbf, struct zfcp_fsf_req *req)
+void zfcp_dbf_hba_bit_err(char *tag, struct zfcp_fsf_req *req)
 {
-        struct zfcp_dbf_hba_record *r = &dbf->hba_buf;
+        struct zfcp_dbf *dbf = req->adapter->dbf;
+        struct zfcp_dbf_hba *rec = &dbf->hba_buf;
         struct fsf_status_read_buffer *sr_buf = req->data;
-        struct fsf_bit_error_payload *err = &sr_buf->payload.bit_error;
         unsigned long flags;
 
         spin_lock_irqsave(&dbf->hba_lock, flags);
-        memset(r, 0, sizeof(*r));
-        strncpy(r->tag, "berr", ZFCP_DBF_TAG_SIZE);
-        memcpy(&r->u.berr, err, sizeof(struct fsf_bit_error_payload));
-        debug_event(dbf->hba, 0, r, sizeof(*r));
-        spin_unlock_irqrestore(&dbf->hba_lock, flags);
-}
-static void zfcp_dbf_hba_view_response(char **p,
-                                       struct zfcp_dbf_hba_record_response *r)
-{
-        struct timespec t;
-
-        zfcp_dbf_out(p, "fsf_command", "0x%08x", r->fsf_command);
-        zfcp_dbf_out(p, "fsf_reqid", "0x%0Lx", r->fsf_reqid);
-        zfcp_dbf_out(p, "fsf_seqno", "0x%08x", r->fsf_seqno);
-        stck_to_timespec(r->fsf_issued, &t);
-        zfcp_dbf_out(p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec);
-        zfcp_dbf_out(p, "fsf_prot_status", "0x%08x", r->fsf_prot_status);
-        zfcp_dbf_out(p, "fsf_status", "0x%08x", r->fsf_status);
-        zfcp_dbf_outd(p, "fsf_prot_status_qual", r->fsf_prot_status_qual,
-                      FSF_PROT_STATUS_QUAL_SIZE, 0, FSF_PROT_STATUS_QUAL_SIZE);
-        zfcp_dbf_outd(p, "fsf_status_qual", r->fsf_status_qual,
-                      FSF_STATUS_QUALIFIER_SIZE, 0, FSF_STATUS_QUALIFIER_SIZE);
-        zfcp_dbf_out(p, "fsf_req_status", "0x%08x", r->fsf_req_status);
-        zfcp_dbf_out(p, "sbal_first", "0x%02x", r->sbal_first);
-        zfcp_dbf_out(p, "sbal_last", "0x%02x", r->sbal_last);
-        zfcp_dbf_out(p, "sbal_response", "0x%02x", r->sbal_response);
-        zfcp_dbf_out(p, "pool", "0x%02x", r->pool);
-
-        switch (r->fsf_command) {
-        case FSF_QTCB_FCP_CMND:
-                if (r->fsf_req_status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)
-                        break;
-                zfcp_dbf_out(p, "data_direction", "0x%04x", r->u.fcp.data_dir);
-                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");
-                break;
-
-        case FSF_QTCB_OPEN_PORT_WITH_DID:
-        case FSF_QTCB_CLOSE_PORT:
-        case FSF_QTCB_CLOSE_PHYSICAL_PORT:
-                zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.port.wwpn);
-                zfcp_dbf_out(p, "d_id", "0x%06x", r->u.port.d_id);
-                zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.port.port_handle);
-                break;
-
-        case FSF_QTCB_OPEN_LUN:
-        case FSF_QTCB_CLOSE_LUN:
-                zfcp_dbf_out(p, "wwpn", "0x%016Lx", r->u.unit.wwpn);
-                zfcp_dbf_out(p, "fcp_lun", "0x%016Lx", r->u.unit.fcp_lun);
-                zfcp_dbf_out(p, "port_handle", "0x%08x", r->u.unit.port_handle);
-                zfcp_dbf_out(p, "lun_handle", "0x%08x", r->u.unit.lun_handle);
-                break;
-
-        case FSF_QTCB_SEND_ELS:
-                zfcp_dbf_out(p, "d_id", "0x%06x", r->u.els.d_id);
-                break;
-
-        case FSF_QTCB_ABORT_FCP_CMND:
-        case FSF_QTCB_SEND_GENERIC:
-        case FSF_QTCB_EXCHANGE_CONFIG_DATA:
-        case FSF_QTCB_EXCHANGE_PORT_DATA:
-        case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
-        case FSF_QTCB_UPLOAD_CONTROL_FILE:
-                break;
-        }
-}
-
-static void zfcp_dbf_hba_view_status(char **p,
-                                     struct zfcp_dbf_hba_record_status *r)
-{
-        zfcp_dbf_out(p, "failed", "0x%02x", r->failed);
-        zfcp_dbf_out(p, "status_type", "0x%08x", r->status_type);
-        zfcp_dbf_out(p, "status_subtype", "0x%08x", r->status_subtype);
-        zfcp_dbf_outd(p, "queue_designator", (char *)&r->queue_designator,
-                      sizeof(struct fsf_queue_designator), 0,
-                      sizeof(struct fsf_queue_designator));
-        zfcp_dbf_outd(p, "payload", (char *)&r->payload, r->payload_size, 0,
-                      r->payload_size);
-}
-
-static void zfcp_dbf_hba_view_qdio(char **p, struct zfcp_dbf_hba_record_qdio *r)
-{
-        zfcp_dbf_out(p, "qdio_error", "0x%08x", r->qdio_error);
-        zfcp_dbf_out(p, "sbal_index", "0x%02x", r->sbal_index);
-        zfcp_dbf_out(p, "sbal_count", "0x%02x", r->sbal_count);
-}
+        memset(rec, 0, sizeof(*rec));
 
-static void zfcp_dbf_hba_view_berr(char **p, struct fsf_bit_error_payload *r)
-{
-        zfcp_dbf_out(p, "link_failures", "%d", r->link_failure_error_count);
-        zfcp_dbf_out(p, "loss_of_sync_err", "%d", r->loss_of_sync_error_count);
-        zfcp_dbf_out(p, "loss_of_sig_err", "%d", r->loss_of_signal_error_count);
-        zfcp_dbf_out(p, "prim_seq_err", "%d",
-                     r->primitive_sequence_error_count);
-        zfcp_dbf_out(p, "inval_trans_word_err", "%d",
-                     r->invalid_transmission_word_error_count);
-        zfcp_dbf_out(p, "CRC_errors", "%d", r->crc_error_count);
-        zfcp_dbf_out(p, "prim_seq_event_to", "%d",
-                     r->primitive_sequence_event_timeout_count);
-        zfcp_dbf_out(p, "elast_buf_overrun_err", "%d",
-                     r->elastic_buffer_overrun_error_count);
-        zfcp_dbf_out(p, "adv_rec_buf2buf_cred", "%d",
-                     r->advertised_receive_b2b_credit);
-        zfcp_dbf_out(p, "curr_rec_buf2buf_cred", "%d",
-                     r->current_receive_b2b_credit);
-        zfcp_dbf_out(p, "adv_trans_buf2buf_cred", "%d",
-                     r->advertised_transmit_b2b_credit);
-        zfcp_dbf_out(p, "curr_trans_buf2buf_cred", "%d",
-                     r->current_transmit_b2b_credit);
-}
+        memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
+        rec->id = ZFCP_DBF_HBA_BIT;
+        rec->fsf_req_id = req->req_id;
+        rec->fsf_req_status = req->status;
+        rec->fsf_cmd = req->fsf_command;
+        memcpy(&rec->u.be, &sr_buf->payload.bit_error,
+               sizeof(struct fsf_bit_error_payload));
 
-static int zfcp_dbf_hba_view_format(debug_info_t *id, struct debug_view *view,
-                                    char *out_buf, const char *in_buf)
-{
-        struct zfcp_dbf_hba_record *r = (struct zfcp_dbf_hba_record *)in_buf;
-        char *p = out_buf;
-
-        if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0)
-                return 0;
-
-        zfcp_dbf_tag(&p, "tag", r->tag);
-        if (isalpha(r->tag2[0]))
-                zfcp_dbf_tag(&p, "tag2", r->tag2);
-
-        if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) == 0)
-                zfcp_dbf_hba_view_response(&p, &r->u.response);
-        else if (strncmp(r->tag, "stat", ZFCP_DBF_TAG_SIZE) == 0)
-                zfcp_dbf_hba_view_status(&p, &r->u.status);
-        else if (strncmp(r->tag, "qdio", ZFCP_DBF_TAG_SIZE) == 0)
-                zfcp_dbf_hba_view_qdio(&p, &r->u.qdio);
-        else if (strncmp(r->tag, "berr", ZFCP_DBF_TAG_SIZE) == 0)
-                zfcp_dbf_hba_view_berr(&p, &r->u.berr);
-
-        if (strncmp(r->tag, "resp", ZFCP_DBF_TAG_SIZE) != 0)
-                p += sprintf(p, "\n");
-        return p - out_buf;
+        debug_event(dbf->hba, 1, rec, sizeof(*rec));
+        spin_unlock_irqrestore(&dbf->hba_lock, flags);
 }
 
-static struct debug_view zfcp_dbf_hba_view = {
-        .name = "structured",
-        .header_proc = zfcp_dbf_view_header,
-        .format_proc = zfcp_dbf_hba_view_format,
-};
-
-static const char *zfcp_dbf_rec_tags[] = {
-        [ZFCP_REC_DBF_ID_THREAD] = "thread",
-        [ZFCP_REC_DBF_ID_TARGET] = "target",
-        [ZFCP_REC_DBF_ID_TRIGGER] = "trigger",
-        [ZFCP_REC_DBF_ID_ACTION] = "action",
-};
-
-static int zfcp_dbf_rec_view_format(debug_info_t *id, struct debug_view *view,
-                                    char *buf, const char *_rec)
+static void zfcp_dbf_set_common(struct zfcp_dbf_rec *rec,
+                                struct zfcp_adapter *adapter,
+                                struct zfcp_port *port,
+                                struct scsi_device *sdev)
 {
-        struct zfcp_dbf_rec_record *r = (struct zfcp_dbf_rec_record *)_rec;
-        char *p = buf;
-        char hint[ZFCP_DBF_ID_SIZE + 1];
-
-        memcpy(hint, r->id2, ZFCP_DBF_ID_SIZE);
-        hint[ZFCP_DBF_ID_SIZE] = 0;
-        zfcp_dbf_outs(&p, "tag", zfcp_dbf_rec_tags[r->id]);
-        zfcp_dbf_outs(&p, "hint", hint);
-        switch (r->id) {
-        case ZFCP_REC_DBF_ID_THREAD:
-                zfcp_dbf_out(&p, "total", "%d", r->u.thread.total);
-                zfcp_dbf_out(&p, "ready", "%d", r->u.thread.ready);
-                zfcp_dbf_out(&p, "running", "%d", r->u.thread.running);
-                break;
-        case ZFCP_REC_DBF_ID_TARGET:
-                zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.target.ref);
-                zfcp_dbf_out(&p, "status", "0x%08x", r->u.target.status);
-                zfcp_dbf_out(&p, "erp_count", "%d", r->u.target.erp_count);
-                zfcp_dbf_out(&p, "d_id", "0x%06x", r->u.target.d_id);
-                zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.target.wwpn);
-                zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.target.fcp_lun);
-                break;
-        case ZFCP_REC_DBF_ID_TRIGGER:
-                zfcp_dbf_out(&p, "reference", "0x%016Lx", r->u.trigger.ref);
-                zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.trigger.action);
-                zfcp_dbf_out(&p, "requested", "%d", r->u.trigger.want);
-                zfcp_dbf_out(&p, "executed", "%d", r->u.trigger.need);
-                zfcp_dbf_out(&p, "wwpn", "0x%016Lx", r->u.trigger.wwpn);
-                zfcp_dbf_out(&p, "fcp_lun", "0x%016Lx", r->u.trigger.fcp_lun);
-                zfcp_dbf_out(&p, "adapter_status", "0x%08x", r->u.trigger.as);
-                zfcp_dbf_out(&p, "port_status", "0x%08x", r->u.trigger.ps);
-                zfcp_dbf_out(&p, "unit_status", "0x%08x", r->u.trigger.us);
-                break;
-        case ZFCP_REC_DBF_ID_ACTION:
-                zfcp_dbf_out(&p, "erp_action", "0x%016Lx", r->u.action.action);
-                zfcp_dbf_out(&p, "fsf_req", "0x%016Lx", r->u.action.fsf_req);
-                zfcp_dbf_out(&p, "status", "0x%08Lx", r->u.action.status);
-                zfcp_dbf_out(&p, "step", "0x%08Lx", r->u.action.step);
-                break;
+        rec->adapter_status = atomic_read(&adapter->status);
+        if (port) {
+                rec->port_status = atomic_read(&port->status);
+                rec->wwpn = port->wwpn;
+                rec->d_id = port->d_id;
+        }
+        if (sdev) {
+                rec->lun_status = atomic_read(&sdev_to_zfcp(sdev)->status);
+                rec->lun = zfcp_scsi_dev_lun(sdev);
         }
-        p += sprintf(p, "\n");
-        return p - buf;
 }
 
-static struct debug_view zfcp_dbf_rec_view = {
-        .name = "structured",
-        .header_proc = zfcp_dbf_view_header,
-        .format_proc = zfcp_dbf_rec_view_format,
-};
-
 /**
- * zfcp_dbf_rec_thread - trace event related to recovery thread operation
- * @id2: identifier for event
- * @dbf: reference to dbf structure
- * This function assumes that the caller is holding erp_lock.
+ * zfcp_dbf_rec_trig - trace event related to triggered recovery
+ * @tag: identifier for event
+ * @adapter: adapter on which the erp_action should run
+ * @port: remote port involved in the erp_action
+ * @sdev: scsi device involved in the erp_action
+ * @want: wanted erp_action
+ * @need: required erp_action
+ *
+ * The adapter->erp_lock has to be held.
  */
-void zfcp_dbf_rec_thread(char *id2, struct zfcp_dbf *dbf)
+void zfcp_dbf_rec_trig(char *tag, struct zfcp_adapter *adapter,
+                       struct zfcp_port *port, struct scsi_device *sdev,
+                       u8 want, u8 need)
 {
-        struct zfcp_adapter *adapter = dbf->adapter;
-        struct zfcp_dbf_rec_record *r = &dbf->rec_buf;
-        unsigned long flags = 0;
+        struct zfcp_dbf *dbf = adapter->dbf;
+        struct zfcp_dbf_rec *rec = &dbf->rec_buf;
         struct list_head *entry;
-        unsigned ready = 0, running = 0, total;
-
-        list_for_each(entry, &adapter->erp_ready_head)
-                ready++;
-        list_for_each(entry, &adapter->erp_running_head)
-                running++;
-        total = adapter->erp_total_count;
-
-        spin_lock_irqsave(&dbf->rec_lock, flags);
-        memset(r, 0, sizeof(*r));
-        r->id = ZFCP_REC_DBF_ID_THREAD;
-        memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE);
-        r->u.thread.total = total;
-        r->u.thread.ready = ready;
-        r->u.thread.running = running;
-        debug_event(dbf->rec, 6, r, sizeof(*r));
-        spin_unlock_irqrestore(&dbf->rec_lock, flags);
-}
-
-/**
- * zfcp_dbf_rec_thread - trace event related to recovery thread operation
- * @id2: identifier for event
- * @adapter: adapter
- * This function assumes that the caller does not hold erp_lock.
- */
-void zfcp_dbf_rec_thread_lock(char *id2, struct zfcp_dbf *dbf)
-{
-        struct zfcp_adapter *adapter = dbf->adapter;
-        unsigned long flags;
-
-        read_lock_irqsave(&adapter->erp_lock, flags);
-        zfcp_dbf_rec_thread(id2, dbf);
-        read_unlock_irqrestore(&adapter->erp_lock, flags);
-}
-
-static void zfcp_dbf_rec_target(char *id2, void *ref, struct zfcp_dbf *dbf,
-                                atomic_t *status, atomic_t *erp_count, u64 wwpn,
-                                u32 d_id, u64 fcp_lun)
-{
-        struct zfcp_dbf_rec_record *r = &dbf->rec_buf;
         unsigned long flags;
 
         spin_lock_irqsave(&dbf->rec_lock, flags);
-        memset(r, 0, sizeof(*r));
-        r->id = ZFCP_REC_DBF_ID_TARGET;
-        memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE);
-        r->u.target.ref = (unsigned long)ref;
-        r->u.target.status = atomic_read(status);
-        r->u.target.wwpn = wwpn;
-        r->u.target.d_id = d_id;
-        r->u.target.fcp_lun = fcp_lun;
-        r->u.target.erp_count = atomic_read(erp_count);
-        debug_event(dbf->rec, 3, r, sizeof(*r));
-        spin_unlock_irqrestore(&dbf->rec_lock, flags);
-}
-
-/**
- * zfcp_dbf_rec_adapter - trace event for adapter state change
- * @id: identifier for trigger of state change
- * @ref: additional reference (e.g. request)
- * @dbf: reference to dbf structure
- */
-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,
-                            ZFCP_DBF_INVALID_LUN);
-}
-
-/**
- * zfcp_dbf_rec_port - trace event for port state change
- * @id: identifier for trigger of state change
- * @ref: additional reference (e.g. request)
- * @port: port
- */
-void zfcp_dbf_rec_port(char *id, void *ref, struct zfcp_port *port)
-{
-        struct zfcp_dbf *dbf = port->adapter->dbf;
+        memset(rec, 0, sizeof(*rec));
 
-        zfcp_dbf_rec_target(id, ref, dbf, &port->status,
-                            &port->erp_counter, port->wwpn, port->d_id,
-                            ZFCP_DBF_INVALID_LUN);
-}
+        rec->id = ZFCP_DBF_REC_TRIG;
+        memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
+        zfcp_dbf_set_common(rec, adapter, port, sdev);
 
-/**
- * zfcp_dbf_rec_unit - trace event for unit state change
- * @id: identifier for trigger of state change
- * @ref: additional reference (e.g. request)
- * @unit: unit
- */
-void zfcp_dbf_rec_unit(char *id, void *ref, struct zfcp_unit *unit)
-{
-        struct zfcp_port *port = unit->port;
-        struct zfcp_dbf *dbf = port->adapter->dbf;
+        list_for_each(entry, &adapter->erp_ready_head)
+                rec->u.trig.ready++;
 
-        zfcp_dbf_rec_target(id, ref, dbf, &unit->status,
-                                  &unit->erp_counter, port->wwpn, port->d_id,
-                                  unit->fcp_lun);
-}
+        list_for_each(entry, &adapter->erp_running_head)
+                rec->u.trig.running++;
 
-/**
- * zfcp_dbf_rec_trigger - trace event for triggered error recovery
- * @id2: identifier for error recovery trigger
- * @ref: additional reference (e.g. request)
- * @want: originally requested error recovery action
- * @need: error recovery action actually initiated
- * @action: address of error recovery action struct
- * @adapter: adapter
- * @port: port
- * @unit: unit
- */
-void zfcp_dbf_rec_trigger(char *id2, void *ref, u8 want, u8 need, void *action,
-                          struct zfcp_adapter *adapter, struct zfcp_port *port,
-                          struct zfcp_unit *unit)
-{
-        struct zfcp_dbf *dbf = adapter->dbf;
-        struct zfcp_dbf_rec_record *r = &dbf->rec_buf;
-        unsigned long flags;
+        rec->u.trig.want = want;
+        rec->u.trig.need = need;
 
-        spin_lock_irqsave(&dbf->rec_lock, flags);
-        memset(r, 0, sizeof(*r));
-        r->id = ZFCP_REC_DBF_ID_TRIGGER;
-        memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE);
-        r->u.trigger.ref = (unsigned long)ref;
-        r->u.trigger.want = want;
-        r->u.trigger.need = need;
-        r->u.trigger.action = (unsigned long)action;
-        r->u.trigger.as = atomic_read(&adapter->status);
-        if (port) {
-                r->u.trigger.ps = atomic_read(&port->status);
-                r->u.trigger.wwpn = port->wwpn;
-        }
-        if (unit)
-                r->u.trigger.us = atomic_read(&unit->status);
-        r->u.trigger.fcp_lun = unit ? unit->fcp_lun : ZFCP_DBF_INVALID_LUN;
-        debug_event(dbf->rec, action ? 1 : 4, r, sizeof(*r));
+        debug_event(dbf->rec, 1, rec, sizeof(*rec));
         spin_unlock_irqrestore(&dbf->rec_lock, flags);
 }
 
+
 /**
- * zfcp_dbf_rec_action - trace event showing progress of recovery action
- * @id2: identifier
- * @erp_action: error recovery action struct pointer
+ * zfcp_dbf_rec_run - trace event related to running recovery
+ * @tag: identifier for event
+ * @erp: erp_action running
  */
-void zfcp_dbf_rec_action(char *id2, struct zfcp_erp_action *erp_action)
+void zfcp_dbf_rec_run(char *tag, struct zfcp_erp_action *erp)
 {
-        struct zfcp_dbf *dbf = erp_action->adapter->dbf;
-        struct zfcp_dbf_rec_record *r = &dbf->rec_buf;
+        struct zfcp_dbf *dbf = erp->adapter->dbf;
+        struct zfcp_dbf_rec *rec = &dbf->rec_buf;
         unsigned long flags;
 
         spin_lock_irqsave(&dbf->rec_lock, flags);
-        memset(r, 0, sizeof(*r));
-        r->id = ZFCP_REC_DBF_ID_ACTION;
-        memcpy(r->id2, id2, ZFCP_DBF_ID_SIZE);
-        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 = erp_action->fsf_req_id;
-        debug_event(dbf->rec, 5, r, sizeof(*r));
-        spin_unlock_irqrestore(&dbf->rec_lock, flags);
-}
+        memset(rec, 0, sizeof(*rec));
 
-/**
- * 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, u32 d_id)
-{
-        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 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;
-        unsigned long flags;
+        rec->id = ZFCP_DBF_REC_RUN;
+        memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
+        zfcp_dbf_set_common(rec, erp->adapter, erp->port, erp->sdev);
 
-        spin_lock_irqsave(&dbf->san_lock, flags);
-        memset(r, 0, sizeof(*r));
-        strncpy(r->tag, "octc", ZFCP_DBF_TAG_SIZE);
-        r->fsf_reqid = fsf_req->req_id;
-        r->fsf_seqno = fsf_req->seq_no;
-        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 fc_ct_hdr), oct->len);
-        spin_unlock_irqrestore(&dbf->san_lock, flags);
-}
+        rec->u.run.fsf_req_id = erp->fsf_req_id;
+        rec->u.run.rec_status = erp->status;
+        rec->u.run.rec_step = erp->step;
+        rec->u.run.rec_action = erp->action;
 
-/**
- * zfcp_dbf_san_ct_response - trace event for completion of CT request
- * @fsf_req: request containing CT response
- */
-void zfcp_dbf_san_ct_response(struct zfcp_fsf_req *fsf_req)
-{
-        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;
-        int level = 3;
-        unsigned long flags;
+        if (erp->sdev)
+                rec->u.run.rec_count =
+                        atomic_read(&sdev_to_zfcp(erp->sdev)->erp_counter);
+        else if (erp->port)
+                rec->u.run.rec_count = atomic_read(&erp->port->erp_counter);
+        else
+                rec->u.run.rec_count = atomic_read(&erp->adapter->erp_counter);
 
-        spin_lock_irqsave(&dbf->san_lock, flags);
-        memset(r, 0, sizeof(*r));
-        strncpy(r->tag, "rctc", ZFCP_DBF_TAG_SIZE);
-        r->fsf_reqid = fsf_req->req_id;
-        r->fsf_seqno = fsf_req->seq_no;
-        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 fc_ct_hdr), rct->len);
-        spin_unlock_irqrestore(&dbf->san_lock, flags);
+        debug_event(dbf->rec, 1, rec, sizeof(*rec));
+        spin_unlock_irqrestore(&dbf->rec_lock, flags);
 }
 
-static void zfcp_dbf_san_els(const char *tag, int level,
-                             struct zfcp_fsf_req *fsf_req, u32 d_id,
-                             void *buffer, int buflen)
+static inline
+void zfcp_dbf_san(char *tag, struct zfcp_dbf *dbf, void *data, u8 id, u16 len,
+                  u64 req_id, u32 d_id)
 {
-        struct zfcp_adapter *adapter = fsf_req->adapter;
-        struct zfcp_dbf *dbf = adapter->dbf;
-        struct zfcp_dbf_san_record *rec = &dbf->san_buf;
+        struct zfcp_dbf_san *rec = &dbf->san_buf;
+        u16 rec_len;
         unsigned long flags;
 
         spin_lock_irqsave(&dbf->san_lock, flags);
         memset(rec, 0, sizeof(*rec));
-        strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE);
-        rec->fsf_reqid = fsf_req->req_id;
-        rec->fsf_seqno = fsf_req->seq_no;
-        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));
+
+        rec->id = id;
+        rec->fsf_req_id = req_id;
+        rec->d_id = d_id;
+        rec_len = min(len, (u16)ZFCP_DBF_SAN_MAX_PAYLOAD);
+        memcpy(rec->payload, data, rec_len);
+        memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
+
+        debug_event(dbf->san, 1, rec, sizeof(*rec));
         spin_unlock_irqrestore(&dbf->san_lock, flags);
 }
 
 /**
- * zfcp_dbf_san_els_request - trace event for issued ELS
- * @fsf_req: request containing issued ELS
+ * zfcp_dbf_san_req - trace event for issued SAN request
+ * @tag: indentifier for event
+ * @fsf_req: request containing issued CT data
+ * d_id: destination ID
  */
-void zfcp_dbf_san_els_request(struct zfcp_fsf_req *fsf_req)
+void zfcp_dbf_san_req(char *tag, struct zfcp_fsf_req *fsf, u32 d_id)
 {
-        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);
+        struct zfcp_dbf *dbf = fsf->adapter->dbf;
+        struct zfcp_fsf_ct_els *ct_els = fsf->data;
+        u16 length;
 
-        zfcp_dbf_san_els("oels", 2, fsf_req, d_id,
-                         sg_virt(els->req), els->req->length);
+        length = (u16)(ct_els->req->length + FC_CT_HDR_LEN);
+        zfcp_dbf_san(tag, dbf, sg_virt(ct_els->req), ZFCP_DBF_SAN_REQ, length,
+                     fsf->req_id, d_id);
 }
 
 /**
- * zfcp_dbf_san_els_response - trace event for completed ELS
- * @fsf_req: request containing ELS response
+ * zfcp_dbf_san_res - trace event for received SAN request
+ * @tag: indentifier for event
+ * @fsf_req: request containing issued CT data
  */
-void zfcp_dbf_san_els_response(struct zfcp_fsf_req *fsf_req)
+void zfcp_dbf_san_res(char *tag, struct zfcp_fsf_req *fsf)
 {
-        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);
+        struct zfcp_dbf *dbf = fsf->adapter->dbf;
+        struct zfcp_fsf_ct_els *ct_els = fsf->data;
+        u16 length;
 
-        zfcp_dbf_san_els("rels", 2, fsf_req, d_id,
-                               sg_virt(els->resp), els->resp->length);
+        length = (u16)(ct_els->resp->length + FC_CT_HDR_LEN);
+        zfcp_dbf_san(tag, dbf, sg_virt(ct_els->resp), ZFCP_DBF_SAN_RES, length,
+                     fsf->req_id, 0);
 }
 
 /**
- * zfcp_dbf_san_incoming_els - trace event for incomig ELS
- * @fsf_req: request containing unsolicited status buffer with incoming ELS
+ * zfcp_dbf_san_in_els - trace event for incoming ELS
+ * @tag: indentifier for event
+ * @fsf_req: request containing issued CT data
  */
-void zfcp_dbf_san_incoming_els(struct zfcp_fsf_req *fsf_req)
+void zfcp_dbf_san_in_els(char *tag, struct zfcp_fsf_req *fsf)
 {
-        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);
+        struct zfcp_dbf *dbf = fsf->adapter->dbf;
+        struct fsf_status_read_buffer *srb =
+                (struct fsf_status_read_buffer *) fsf->data;
+        u16 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,
-                                    char *out_buf, const char *in_buf)
-{
-        struct zfcp_dbf_san_record *r = (struct zfcp_dbf_san_record *)in_buf;
-        char *p = out_buf;
-
-        if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0)
-                return 0;
-
-        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);
-
-        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);
-                zfcp_dbf_out(&p, "gs_subtype", "0x%02x", ct->gs_subtype);
-                zfcp_dbf_out(&p, "options", "0x%02x", ct->options);
-                zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size);
-        } else if (strncmp(r->tag, "rctc", ZFCP_DBF_TAG_SIZE) == 0) {
-                struct zfcp_dbf_san_record_ct_response *ct = &r->u.ct_resp;
-                zfcp_dbf_out(&p, "cmd_rsp_code", "0x%04x", ct->cmd_rsp_code);
-                zfcp_dbf_out(&p, "revision", "0x%02x", ct->revision);
-                zfcp_dbf_out(&p, "reason_code", "0x%02x", ct->reason_code);
-                zfcp_dbf_out(&p, "reason_code_expl", "0x%02x", ct->expl);
-                zfcp_dbf_out(&p, "vendor_unique", "0x%02x", ct->vendor_unique);
-                zfcp_dbf_out(&p, "max_res_size", "0x%04x", ct->max_res_size);
-        } else if (strncmp(r->tag, "oels", ZFCP_DBF_TAG_SIZE) == 0 ||
-                   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, "d_id", "0x%06x", els->d_id);
-        }
-        return p - out_buf;
+        length = (u16)(srb->length -
+                        offsetof(struct fsf_status_read_buffer, payload));
+        zfcp_dbf_san(tag, dbf, srb->payload.data, ZFCP_DBF_SAN_ELS, length,
+                     fsf->req_id, ntoh24(srb->d_id));
 }
 
-static struct debug_view zfcp_dbf_san_view = {
-        .name = "structured",
-        .header_proc = zfcp_dbf_view_header,
-        .format_proc = zfcp_dbf_san_view_format,
-};
-
-void _zfcp_dbf_scsi(const char *tag, const char *tag2, int level,
-                    struct zfcp_dbf *dbf, struct scsi_cmnd *scsi_cmnd,
-                    struct zfcp_fsf_req *fsf_req, unsigned long old_req_id)
+/**
+ * zfcp_dbf_scsi - trace event for scsi commands
+ * @tag: identifier for event
+ * @sc: pointer to struct scsi_cmnd
+ * @fsf: pointer to struct zfcp_fsf_req
+ */
+void zfcp_dbf_scsi(char *tag, struct scsi_cmnd *sc, struct zfcp_fsf_req *fsf)
 {
-        struct zfcp_dbf_scsi_record *rec = &dbf->scsi_buf;
-        struct zfcp_dbf_dump *dump = (struct zfcp_dbf_dump *)rec;
-        unsigned long flags;
+        struct zfcp_adapter *adapter =
+                (struct zfcp_adapter *) sc->device->host->hostdata[0];
+        struct zfcp_dbf *dbf = adapter->dbf;
+        struct zfcp_dbf_scsi *rec = &dbf->scsi_buf;
         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;
+        struct fcp_resp_rsp_info *fcp_rsp_info;
+        unsigned long flags;
 
         spin_lock_irqsave(&dbf->scsi_lock, flags);
-        do {
-                memset(rec, 0, sizeof(*rec));
-                if (offset == 0) {
-                        strncpy(rec->tag, tag, ZFCP_DBF_TAG_SIZE);
-                        strncpy(rec->tag2, tag2, ZFCP_DBF_TAG_SIZE);
-                        if (scsi_cmnd != NULL) {
-                                if (scsi_cmnd->device) {
-                                        rec->scsi_id = scsi_cmnd->device->id;
-                                        rec->scsi_lun = scsi_cmnd->device->lun;
-                                }
-                                rec->scsi_result = scsi_cmnd->result;
-                                rec->scsi_cmnd = (unsigned long)scsi_cmnd;
-                                rec->scsi_serial = scsi_cmnd->serial_number;
-                                memcpy(rec->scsi_opcode, scsi_cmnd->cmnd,
-                                        min((int)scsi_cmnd->cmd_len,
-                                                ZFCP_DBF_SCSI_OPCODE));
-                                rec->scsi_retries = scsi_cmnd->retries;
-                                rec->scsi_allowed = scsi_cmnd->allowed;
-                        }
-                        if (fsf_req != NULL) {
-                                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,
-                                                   ZFCP_DBF_SCSI_FCP_SNS_INFO));
-                                        offset += min(buflen,
-                                                      ZFCP_DBF_SCSI_FCP_SNS_INFO);
-                                }
-
-                                rec->fsf_reqid = fsf_req->req_id;
-                                rec->fsf_seqno = fsf_req->seq_no;
-                                rec->fsf_issued = fsf_req->issued;
-                        }
-                        rec->old_fsf_reqid = old_req_id;
-                } else {
-                        strncpy(dump->tag, "dump", ZFCP_DBF_TAG_SIZE);
-                        dump->total_size = buflen;
-                        dump->offset = offset;
-                        dump->size = min(buflen - offset,
-                                         (int)sizeof(struct
-                                                     zfcp_dbf_scsi_record) -
-                                         (int)sizeof(struct zfcp_dbf_dump));
-                        memcpy(dump->data, fcp_sns_info + offset, dump->size);
-                        offset += dump->size;
-                }
-                debug_event(dbf->scsi, level, rec, sizeof(*rec));
-        } while (offset < buflen);
-        spin_unlock_irqrestore(&dbf->scsi_lock, flags);
-}
+        memset(rec, 0, sizeof(*rec));
 
-static int zfcp_dbf_scsi_view_format(debug_info_t *id, struct debug_view *view,
-                                     char *out_buf, const char *in_buf)
-{
-        struct zfcp_dbf_scsi_record *r = (struct zfcp_dbf_scsi_record *)in_buf;
-        struct timespec t;
-        char *p = out_buf;
-
-        if (strncmp(r->tag, "dump", ZFCP_DBF_TAG_SIZE) == 0)
-                return 0;
-
-        zfcp_dbf_tag(&p, "tag", r->tag);
-        zfcp_dbf_tag(&p, "tag2", r->tag2);
-        zfcp_dbf_out(&p, "scsi_id", "0x%08x", r->scsi_id);
-        zfcp_dbf_out(&p, "scsi_lun", "0x%08x", r->scsi_lun);
-        zfcp_dbf_out(&p, "scsi_result", "0x%08x", r->scsi_result);
-        zfcp_dbf_out(&p, "scsi_cmnd", "0x%0Lx", r->scsi_cmnd);
-        zfcp_dbf_out(&p, "scsi_serial", "0x%016Lx", r->scsi_serial);
-        zfcp_dbf_outd(&p, "scsi_opcode", r->scsi_opcode, ZFCP_DBF_SCSI_OPCODE,
-                      0, ZFCP_DBF_SCSI_OPCODE);
-        zfcp_dbf_out(&p, "scsi_retries", "0x%02x", r->scsi_retries);
-        zfcp_dbf_out(&p, "scsi_allowed", "0x%02x", r->scsi_allowed);
-        if (strncmp(r->tag, "abrt", ZFCP_DBF_TAG_SIZE) == 0)
-                zfcp_dbf_out(&p, "old_fsf_reqid", "0x%0Lx", r->old_fsf_reqid);
-        zfcp_dbf_out(&p, "fsf_reqid", "0x%0Lx", r->fsf_reqid);
-        zfcp_dbf_out(&p, "fsf_seqno", "0x%08x", r->fsf_seqno);
-        stck_to_timespec(r->fsf_issued, &t);
-        zfcp_dbf_out(&p, "fsf_issued", "%011lu:%06lu", t.tv_sec, t.tv_nsec);
-
-        if (strncmp(r->tag, "rslt", ZFCP_DBF_TAG_SIZE) == 0) {
-                zfcp_dbf_out(&p, "fcp_rsp_validity", "0x%02x", r->rsp_validity);
-                zfcp_dbf_out(&p, "fcp_rsp_scsi_status", "0x%02x",
-                             r->rsp_scsi_status);
-                zfcp_dbf_out(&p, "fcp_rsp_resid", "0x%08x", r->rsp_resid);
-                zfcp_dbf_out(&p, "fcp_rsp_code", "0x%08x", r->rsp_code);
-                zfcp_dbf_out(&p, "fcp_sns_info_len", "0x%08x", r->sns_info_len);
-                zfcp_dbf_outd(&p, "fcp_sns_info", r->sns_info,
-                              min((int)r->sns_info_len,
-                              ZFCP_DBF_SCSI_FCP_SNS_INFO), 0,
-                              r->sns_info_len);
+        memcpy(rec->tag, tag, ZFCP_DBF_TAG_LEN);
+        rec->id = ZFCP_DBF_SCSI_CMND;
+        rec->scsi_result = sc->result;
+        rec->scsi_retries = sc->retries;
+        rec->scsi_allowed = sc->allowed;
+        rec->scsi_id = sc->device->id;
+        rec->scsi_lun = sc->device->lun;
+        rec->host_scribble = (unsigned long)sc->host_scribble;
+
+        memcpy(rec->scsi_opcode, sc->cmnd,
+               min((int)sc->cmd_len, ZFCP_DBF_SCSI_OPCODE));
+
+        if (fsf) {
+                rec->fsf_req_id = fsf->req_id;
+                fcp_rsp = (struct fcp_resp_with_ext *)
+                                &(fsf->qtcb->bottom.io.fcp_rsp);
+                memcpy(&rec->fcp_rsp, fcp_rsp, FCP_RESP_WITH_EXT);
+                if (fcp_rsp->resp.fr_flags & FCP_RSP_LEN_VAL) {
+                        fcp_rsp_info = (struct fcp_resp_rsp_info *) &fcp_rsp[1];
+                        rec->fcp_rsp_info = fcp_rsp_info->rsp_code;
+                }
+                if (fcp_rsp->resp.fr_flags & FCP_SNS_LEN_VAL) {
+                        rec->pl_len = min((u16)SCSI_SENSE_BUFFERSIZE,
+                                          (u16)ZFCP_DBF_PAY_MAX_REC);
+                        zfcp_dbf_pl_write(dbf, sc->sense_buffer, rec->pl_len,
+                                          "fcp_sns", fsf->req_id);
+                }
         }
-        p += sprintf(p, "\n");
-        return p - out_buf;
-}
 
-static struct debug_view zfcp_dbf_scsi_view = {
-        .name = "structured",
-        .header_proc = zfcp_dbf_view_header,
-        .format_proc = zfcp_dbf_scsi_view_format,
-};
+        debug_event(dbf->scsi, 1, rec, sizeof(*rec));
+        spin_unlock_irqrestore(&dbf->scsi_lock, flags);
+}
 
-static debug_info_t *zfcp_dbf_reg(const char *name, int level,
-                                  struct debug_view *view, int size)
+static debug_info_t *zfcp_dbf_reg(const char *name, int size, int rec_size)
 {
         struct debug_info *d;
 
-        d = debug_register(name, dbfsize, level, size);
+        d = debug_register(name, size, 1, rec_size);
         if (!d)
                 return NULL;
 
         debug_register_view(d, &debug_hex_ascii_view);
-        debug_register_view(d, view);
-        debug_set_level(d, level);
+        debug_set_level(d, 3);
 
         return d;
 }
 
+static void zfcp_dbf_unregister(struct zfcp_dbf *dbf)
+{
+        if (!dbf)
+                return;
+
+        debug_unregister(dbf->scsi);
+        debug_unregister(dbf->san);
+        debug_unregister(dbf->hba);
+        debug_unregister(dbf->pay);
+        debug_unregister(dbf->rec);
+        kfree(dbf);
+}
+
 /**
  * zfcp_adapter_debug_register - registers debug feature for an adapter
  * @adapter: pointer to adapter for which debug features should be registered
@@ -1005,69 +415,66 @@ static debug_info_t *zfcp_dbf_reg(const char *name, int level,
  */
 int zfcp_dbf_adapter_register(struct zfcp_adapter *adapter)
 {
-        char dbf_name[DEBUG_MAX_NAME_LEN];
+        char name[DEBUG_MAX_NAME_LEN];
         struct zfcp_dbf *dbf;
 
         dbf = kzalloc(sizeof(struct zfcp_dbf), GFP_KERNEL);
         if (!dbf)
                 return -ENOMEM;
 
-        dbf->adapter = adapter;
-
+        spin_lock_init(&dbf->pay_lock);
         spin_lock_init(&dbf->hba_lock);
         spin_lock_init(&dbf->san_lock);
         spin_lock_init(&dbf->scsi_lock);
         spin_lock_init(&dbf->rec_lock);
 
         /* debug feature area which records recovery activity */
-        sprintf(dbf_name, "zfcp_%s_rec", dev_name(&adapter->ccw_device->dev));
-        dbf->rec = zfcp_dbf_reg(dbf_name, 3, &zfcp_dbf_rec_view,
-                                sizeof(struct zfcp_dbf_rec_record));
+        sprintf(name, "zfcp_%s_rec", dev_name(&adapter->ccw_device->dev));
+        dbf->rec = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_rec));
         if (!dbf->rec)
                 goto err_out;
 
         /* debug feature area which records HBA (FSF and QDIO) conditions */
-        sprintf(dbf_name, "zfcp_%s_hba", dev_name(&adapter->ccw_device->dev));
-        dbf->hba = zfcp_dbf_reg(dbf_name, 3, &zfcp_dbf_hba_view,
-                                sizeof(struct zfcp_dbf_hba_record));
+        sprintf(name, "zfcp_%s_hba", dev_name(&adapter->ccw_device->dev));
+        dbf->hba = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_hba));
         if (!dbf->hba)
                 goto err_out;
 
+        /* debug feature area which records payload info */
+        sprintf(name, "zfcp_%s_pay", dev_name(&adapter->ccw_device->dev));
+        dbf->pay = zfcp_dbf_reg(name, dbfsize * 2, sizeof(struct zfcp_dbf_pay));
+        if (!dbf->pay)
+                goto err_out;
+
         /* debug feature area which records SAN command failures and recovery */
-        sprintf(dbf_name, "zfcp_%s_san", dev_name(&adapter->ccw_device->dev));
-        dbf->san = zfcp_dbf_reg(dbf_name, 6, &zfcp_dbf_san_view,
-                                sizeof(struct zfcp_dbf_san_record));
+        sprintf(name, "zfcp_%s_san", dev_name(&adapter->ccw_device->dev));
+        dbf->san = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_san));
         if (!dbf->san)
                 goto err_out;
 
         /* debug feature area which records SCSI command failures and recovery */
-        sprintf(dbf_name, "zfcp_%s_scsi", dev_name(&adapter->ccw_device->dev));
-        dbf->scsi = zfcp_dbf_reg(dbf_name, 3, &zfcp_dbf_scsi_view,
-                                 sizeof(struct zfcp_dbf_scsi_record));
+        sprintf(name, "zfcp_%s_scsi", dev_name(&adapter->ccw_device->dev));
+        dbf->scsi = zfcp_dbf_reg(name, dbfsize, sizeof(struct zfcp_dbf_scsi));
         if (!dbf->scsi)
                 goto err_out;
 
         adapter->dbf = dbf;
-        return 0;
 
+        return 0;
 err_out:
-        zfcp_dbf_adapter_unregister(dbf);
+        zfcp_dbf_unregister(dbf);
         return -ENOMEM;
 }
 
 /**
  * zfcp_adapter_debug_unregister - unregisters debug feature for an adapter
- * @dbf: pointer to dbf for which debug features should be unregistered
+ * @adapter: pointer to adapter for which debug features should be unregistered
  */
-void zfcp_dbf_adapter_unregister(struct zfcp_dbf *dbf)
+void zfcp_dbf_adapter_unregister(struct zfcp_adapter *adapter)
 {
-        if (!dbf)
-                return;
-        debug_unregister(dbf->scsi);
-        debug_unregister(dbf->san);
-        debug_unregister(dbf->hba);
-        debug_unregister(dbf->rec);
-        dbf->adapter->dbf = NULL;
-        kfree(dbf);
+        struct zfcp_dbf *dbf = adapter->dbf;
+
+        adapter->dbf = NULL;
+        zfcp_dbf_unregister(dbf);
 }
 
diff --git a/drivers/s390/scsi/zfcp_dbf.h b/drivers/s390/scsi/zfcp_dbf.h
index 2bcc3403126a..714f087eb7a9 100644
--- a/drivers/s390/scsi/zfcp_dbf.h
+++ b/drivers/s390/scsi/zfcp_dbf.h
@@ -1,22 +1,8 @@
 /*
- * This file is part of the zfcp device driver for
- * FCP adapters for IBM System z9 and zSeries.
+ * zfcp device driver
+ * debug feature declarations
  *
- * Copyright IBM Corp. 2008, 2009
- *
- * 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.
+ * Copyright IBM Corp. 2008, 2010
  */
 
 #ifndef ZFCP_DBF_H
@@ -27,339 +13,370 @@
 #include "zfcp_fsf.h"
 #include "zfcp_def.h"
 
-#define ZFCP_DBF_TAG_SIZE      4
-#define ZFCP_DBF_ID_SIZE       7
+#define ZFCP_DBF_TAG_LEN       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 */
-        u32 offset;             /* how much data has being already dumped */
-        u32 size;               /* how much data comes with this record */
-        u8 data[];              /* dump data */
-} __attribute__ ((packed));
-
-struct zfcp_dbf_rec_record_thread {
-        u32 total;
+/**
+ * struct zfcp_dbf_rec_trigger - trace record for triggered recovery action
+ * @ready: number of ready recovery actions
+ * @running: number of running recovery actions
+ * @want: wanted recovery action
+ * @need: needed recovery action
+ */
+struct zfcp_dbf_rec_trigger {
         u32 ready;
         u32 running;
-};
-
-struct zfcp_dbf_rec_record_target {
-        u64 ref;
-        u32 status;
-        u32 d_id;
-        u64 wwpn;
-        u64 fcp_lun;
-        u32 erp_count;
-};
-
-struct zfcp_dbf_rec_record_trigger {
         u8 want;
         u8 need;
-        u32 as;
-        u32 ps;
-        u32 us;
-        u64 ref;
-        u64 action;
-        u64 wwpn;
-        u64 fcp_lun;
-};
+} __packed;
 
-struct zfcp_dbf_rec_record_action {
-        u32 status;
-        u32 step;
-        u64 action;
-        u64 fsf_req;
+/**
+ * struct zfcp_dbf_rec_running - trace record for running recovery
+ * @fsf_req_id: request id for fsf requests
+ * @rec_status: status of the fsf request
+ * @rec_step: current step of the recovery action
+ * rec_count: recovery counter
+ */
+struct zfcp_dbf_rec_running {
+        u64 fsf_req_id;
+        u32 rec_status;
+        u16 rec_step;
+        u8 rec_action;
+        u8 rec_count;
+} __packed;
+
+/**
+ * enum zfcp_dbf_rec_id - recovery trace record id
+ * @ZFCP_DBF_REC_TRIG: triggered recovery identifier
+ * @ZFCP_DBF_REC_RUN: running recovery identifier
+ */
+enum zfcp_dbf_rec_id {
+        ZFCP_DBF_REC_TRIG       = 1,
+        ZFCP_DBF_REC_RUN        = 2,
 };
 
-struct zfcp_dbf_rec_record {
+/**
+ * struct zfcp_dbf_rec - trace record for error recovery actions
+ * @id: unique number of recovery record type
+ * @tag: identifier string specifying the location of initiation
+ * @lun: logical unit number
+ * @wwpn: word wide port number
+ * @d_id: destination ID
+ * @adapter_status: current status of the adapter
+ * @port_status: current status of the port
+ * @lun_status: current status of the lun
+ * @u.trig: structure zfcp_dbf_rec_trigger
+ * @u.run: structure zfcp_dbf_rec_running
+ */
+struct zfcp_dbf_rec {
         u8 id;
-        char id2[7];
+        char tag[ZFCP_DBF_TAG_LEN];
+        u64 lun;
+        u64 wwpn;
+        u32 d_id;
+        u32 adapter_status;
+        u32 port_status;
+        u32 lun_status;
         union {
-                struct zfcp_dbf_rec_record_action action;
-                struct zfcp_dbf_rec_record_thread thread;
-                struct zfcp_dbf_rec_record_target target;
-                struct zfcp_dbf_rec_record_trigger trigger;
+                struct zfcp_dbf_rec_trigger trig;
+                struct zfcp_dbf_rec_running run;
         } u;
-};
+} __packed;
 
-enum {
-        ZFCP_REC_DBF_ID_ACTION,
-        ZFCP_REC_DBF_ID_THREAD,
-        ZFCP_REC_DBF_ID_TARGET,
-        ZFCP_REC_DBF_ID_TRIGGER,
+/**
+ * enum zfcp_dbf_san_id - SAN trace record identifier
+ * @ZFCP_DBF_SAN_REQ: request trace record id
+ * @ZFCP_DBF_SAN_RES: response trace record id
+ * @ZFCP_DBF_SAN_ELS: extended link service record id
+ */
+enum zfcp_dbf_san_id {
+        ZFCP_DBF_SAN_REQ        = 1,
+        ZFCP_DBF_SAN_RES        = 2,
+        ZFCP_DBF_SAN_ELS        = 3,
 };
 
-struct zfcp_dbf_hba_record_response {
-        u32 fsf_command;
-        u64 fsf_reqid;
-        u32 fsf_seqno;
-        u64 fsf_issued;
-        u32 fsf_prot_status;
+/** struct zfcp_dbf_san - trace record for SAN requests and responses
+ * @id: unique number of recovery record type
+ * @tag: identifier string specifying the location of initiation
+ * @fsf_req_id: request id for fsf requests
+ * @payload: unformatted information related to request/response
+ * @d_id: destination id
+ */
+struct zfcp_dbf_san {
+        u8 id;
+        char tag[ZFCP_DBF_TAG_LEN];
+        u64 fsf_req_id;
+        u32 d_id;
+#define ZFCP_DBF_SAN_MAX_PAYLOAD (FC_CT_HDR_LEN + 32)
+        char payload[ZFCP_DBF_SAN_MAX_PAYLOAD];
+} __packed;
+
+/**
+ * struct zfcp_dbf_hba_res - trace record for hba responses
+ * @req_issued: timestamp when request was issued
+ * @prot_status: protocol status
+ * @prot_status_qual: protocol status qualifier
+ * @fsf_status: fsf status
+ * @fsf_status_qual: fsf status qualifier
+ */
+struct zfcp_dbf_hba_res {
+        u64 req_issued;
+        u32 prot_status;
+        u8  prot_status_qual[FSF_PROT_STATUS_QUAL_SIZE];
         u32 fsf_status;
-        u8 fsf_prot_status_qual[FSF_PROT_STATUS_QUAL_SIZE];
-        u8 fsf_status_qual[FSF_STATUS_QUALIFIER_SIZE];
-        u32 fsf_req_status;
-        u8 sbal_first;
-        u8 sbal_last;
-        u8 sbal_response;
-        u8 pool;
-        u64 erp_action;
-        union {
-                struct {
-                        u64 cmnd;
-                        u64 serial;
-                        u32 data_dir;
-                } fcp;
-                struct {
-                        u64 wwpn;
-                        u32 d_id;
-                        u32 port_handle;
-                } port;
-                struct {
-                        u64 wwpn;
-                        u64 fcp_lun;
-                        u32 port_handle;
-                        u32 lun_handle;
-                } unit;
-                struct {
-                        u32 d_id;
-                } els;
-        } u;
-} __attribute__ ((packed));
+        u8  fsf_status_qual[FSF_STATUS_QUALIFIER_SIZE];
+} __packed;
 
-struct zfcp_dbf_hba_record_status {
-        u8 failed;
+/**
+ * struct zfcp_dbf_hba_uss - trace record for unsolicited status
+ * @status_type: type of unsolicited status
+ * @status_subtype: subtype of unsolicited status
+ * @d_id: destination ID
+ * @lun: logical unit number
+ * @queue_designator: queue designator
+ */
+struct zfcp_dbf_hba_uss {
         u32 status_type;
         u32 status_subtype;
-        struct fsf_queue_designator
-         queue_designator;
-        u32 payload_size;
-#define ZFCP_DBF_UNSOL_PAYLOAD                          80
-#define ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL         32
-#define ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD      56
-#define ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT     2 * sizeof(u32)
-        u8 payload[ZFCP_DBF_UNSOL_PAYLOAD];
-} __attribute__ ((packed));
-
-struct zfcp_dbf_hba_record_qdio {
-        u32 qdio_error;
-        u8 sbal_index;
-        u8 sbal_count;
-} __attribute__ ((packed));
-
-struct zfcp_dbf_hba_record {
-        u8 tag[ZFCP_DBF_TAG_SIZE];
-        u8 tag2[ZFCP_DBF_TAG_SIZE];
-        union {
-                struct zfcp_dbf_hba_record_response response;
-                struct zfcp_dbf_hba_record_status status;
-                struct zfcp_dbf_hba_record_qdio qdio;
-                struct fsf_bit_error_payload berr;
-        } u;
-} __attribute__ ((packed));
-
-struct zfcp_dbf_san_record_ct_request {
-        u16 cmd_req_code;
-        u8 revision;
-        u8 gs_type;
-        u8 gs_subtype;
-        u8 options;
-        u16 max_res_size;
-        u32 len;
-        u32 d_id;
-} __attribute__ ((packed));
-
-struct zfcp_dbf_san_record_ct_response {
-        u16 cmd_rsp_code;
-        u8 revision;
-        u8 reason_code;
-        u8 expl;
-        u8 vendor_unique;
-        u16 max_res_size;
-        u32 len;
-} __attribute__ ((packed));
-
-struct zfcp_dbf_san_record_els {
         u32 d_id;
-} __attribute__ ((packed));
+        u64 lun;
+        u64 queue_designator;
+} __packed;
+
+/**
+ * enum zfcp_dbf_hba_id - HBA trace record identifier
+ * @ZFCP_DBF_HBA_RES: response trace record
+ * @ZFCP_DBF_HBA_USS: unsolicited status trace record
+ * @ZFCP_DBF_HBA_BIT: bit error trace record
+ */
+enum zfcp_dbf_hba_id {
+        ZFCP_DBF_HBA_RES        = 1,
+        ZFCP_DBF_HBA_USS        = 2,
+        ZFCP_DBF_HBA_BIT        = 3,
+};
 
-struct zfcp_dbf_san_record {
-        u8 tag[ZFCP_DBF_TAG_SIZE];
-        u64 fsf_reqid;
-        u32 fsf_seqno;
+/**
+ * struct zfcp_dbf_hba - common trace record for HBA records
+ * @id: unique number of recovery record type
+ * @tag: identifier string specifying the location of initiation
+ * @fsf_req_id: request id for fsf requests
+ * @fsf_req_status: status of fsf request
+ * @fsf_cmd: fsf command
+ * @fsf_seq_no: fsf sequence number
+ * @pl_len: length of payload stored as zfcp_dbf_pay
+ * @u: record type specific data
+ */
+struct zfcp_dbf_hba {
+        u8 id;
+        char tag[ZFCP_DBF_TAG_LEN];
+        u64 fsf_req_id;
+        u32 fsf_req_status;
+        u32 fsf_cmd;
+        u32 fsf_seq_no;
+        u16 pl_len;
         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;
+                struct zfcp_dbf_hba_res res;
+                struct zfcp_dbf_hba_uss uss;
+                struct fsf_bit_error_payload be;
         } u;
-} __attribute__ ((packed));
+} __packed;
 
-#define ZFCP_DBF_SAN_MAX_PAYLOAD 1024
+/**
+ * enum zfcp_dbf_scsi_id - scsi trace record identifier
+ * @ZFCP_DBF_SCSI_CMND: scsi command trace record
+ */
+enum zfcp_dbf_scsi_id {
+        ZFCP_DBF_SCSI_CMND      = 1,
+};
 
-struct zfcp_dbf_scsi_record {
-        u8 tag[ZFCP_DBF_TAG_SIZE];
-        u8 tag2[ZFCP_DBF_TAG_SIZE];
+/**
+ * struct zfcp_dbf_scsi - common trace record for SCSI records
+ * @id: unique number of recovery record type
+ * @tag: identifier string specifying the location of initiation
+ * @scsi_id: scsi device id
+ * @scsi_lun: scsi device logical unit number
+ * @scsi_result: scsi result
+ * @scsi_retries: current retry number of scsi request
+ * @scsi_allowed: allowed retries
+ * @fcp_rsp_info: FCP response info
+ * @scsi_opcode: scsi opcode
+ * @fsf_req_id: request id of fsf request
+ * @host_scribble: LLD specific data attached to SCSI request
+ * @pl_len: length of paload stored as zfcp_dbf_pay
+ * @fsf_rsp: response for fsf request
+ */
+struct zfcp_dbf_scsi {
+        u8 id;
+        char tag[ZFCP_DBF_TAG_LEN];
         u32 scsi_id;
         u32 scsi_lun;
         u32 scsi_result;
-        u64 scsi_cmnd;
-        u64 scsi_serial;
-#define ZFCP_DBF_SCSI_OPCODE    16
-        u8 scsi_opcode[ZFCP_DBF_SCSI_OPCODE];
         u8 scsi_retries;
         u8 scsi_allowed;
-        u64 fsf_reqid;
-        u32 fsf_seqno;
-        u64 fsf_issued;
-        u64 old_fsf_reqid;
-        u8 rsp_validity;
-        u8 rsp_scsi_status;
-        u32 rsp_resid;
-        u8 rsp_code;
-#define ZFCP_DBF_SCSI_FCP_SNS_INFO      16
-#define ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO  256
-        u32 sns_info_len;
-        u8 sns_info[ZFCP_DBF_SCSI_FCP_SNS_INFO];
-} __attribute__ ((packed));
+        u8 fcp_rsp_info;
+#define ZFCP_DBF_SCSI_OPCODE    16
+        u8 scsi_opcode[ZFCP_DBF_SCSI_OPCODE];
+        u64 fsf_req_id;
+        u64 host_scribble;
+        u16 pl_len;
+        struct fcp_resp_with_ext fcp_rsp;
+} __packed;
+
+/**
+ * struct zfcp_dbf_pay - trace record for unformatted payload information
+ * @area: area this record is originated from
+ * @counter: ascending record number
+ * @fsf_req_id: request id of fsf request
+ * @data: unformatted data
+ */
+struct zfcp_dbf_pay {
+        u8 counter;
+        char area[ZFCP_DBF_TAG_LEN];
+        u64 fsf_req_id;
+#define ZFCP_DBF_PAY_MAX_REC 0x100
+        char data[ZFCP_DBF_PAY_MAX_REC];
+} __packed;
 
+/**
+ * struct zfcp_dbf - main dbf trace structure
+ * @pay: reference to payload trace area
+ * @rec: reference to recovery trace area
+ * @hba: reference to hba trace area
+ * @san: reference to san trace area
+ * @scsi: reference to scsi trace area
+ * @pay_lock: lock protecting payload trace buffer
+ * @rec_lock: lock protecting recovery trace buffer
+ * @hba_lock: lock protecting hba trace buffer
+ * @san_lock: lock protecting san trace buffer
+ * @scsi_lock: lock protecting scsi trace buffer
+ * @pay_buf: pre-allocated buffer for payload
+ * @rec_buf: pre-allocated buffer for recovery
+ * @hba_buf: pre-allocated buffer for hba
+ * @san_buf: pre-allocated buffer for san
+ * @scsi_buf: pre-allocated buffer for scsi
+ */
 struct zfcp_dbf {
+        debug_info_t                    *pay;
         debug_info_t                    *rec;
         debug_info_t                    *hba;
         debug_info_t                    *san;
         debug_info_t                    *scsi;
+        spinlock_t                      pay_lock;
         spinlock_t                      rec_lock;
         spinlock_t                      hba_lock;
         spinlock_t                      san_lock;
         spinlock_t                      scsi_lock;
-        struct zfcp_dbf_rec_record      rec_buf;
-        struct zfcp_dbf_hba_record      hba_buf;
-        struct zfcp_dbf_san_record      san_buf;
-        struct zfcp_dbf_scsi_record     scsi_buf;
-        struct zfcp_adapter             *adapter;
+        struct zfcp_dbf_pay             pay_buf;
+        struct zfcp_dbf_rec             rec_buf;
+        struct zfcp_dbf_hba             hba_buf;
+        struct zfcp_dbf_san             san_buf;
+        struct zfcp_dbf_scsi            scsi_buf;
 };
 
 static inline
-void zfcp_dbf_hba_fsf_resp(const char *tag2, int level,
-                           struct zfcp_fsf_req *req, struct zfcp_dbf *dbf)
+void zfcp_dbf_hba_fsf_resp(char *tag, int level, struct zfcp_fsf_req *req)
 {
-        if (level <= dbf->hba->level)
-                _zfcp_dbf_hba_fsf_response(tag2, level, req, dbf);
+        if (level <= req->adapter->dbf->hba->level)
+                zfcp_dbf_hba_fsf_res(tag, req);
 }
 
 /**
  * zfcp_dbf_hba_fsf_response - trace event for request completion
- * @fsf_req: request that has been completed
+ * @req: request that has been completed
  */
-static inline void zfcp_dbf_hba_fsf_response(struct zfcp_fsf_req *req)
+static inline
+void zfcp_dbf_hba_fsf_response(struct zfcp_fsf_req *req)
 {
-        struct zfcp_dbf *dbf = req->adapter->dbf;
         struct fsf_qtcb *qtcb = req->qtcb;
 
         if ((qtcb->prefix.prot_status != FSF_PROT_GOOD) &&
             (qtcb->prefix.prot_status != FSF_PROT_FSF_STATUS_PRESENTED)) {
-                zfcp_dbf_hba_fsf_resp("perr", 1, req, dbf);
+                zfcp_dbf_hba_fsf_resp("fs_perr", 1, req);
 
         } else if (qtcb->header.fsf_status != FSF_GOOD) {
-                zfcp_dbf_hba_fsf_resp("ferr", 1, req, dbf);
+                zfcp_dbf_hba_fsf_resp("fs_ferr", 1, req);
 
         } else if ((req->fsf_command == FSF_QTCB_OPEN_PORT_WITH_DID) ||
                    (req->fsf_command == FSF_QTCB_OPEN_LUN)) {
-                zfcp_dbf_hba_fsf_resp("open", 4, req, dbf);
+                zfcp_dbf_hba_fsf_resp("fs_open", 4, req);
 
         } else if (qtcb->header.log_length) {
-                zfcp_dbf_hba_fsf_resp("qtcb", 5, req, dbf);
+                zfcp_dbf_hba_fsf_resp("fs_qtcb", 5, req);
 
         } else {
-                zfcp_dbf_hba_fsf_resp("norm", 6, req, dbf);
+                zfcp_dbf_hba_fsf_resp("fs_norm", 6, req);
         }
- }
-
-/**
- * zfcp_dbf_hba_fsf_unsol - trace event for an unsolicited status buffer
- * @tag: tag indicating which kind of unsolicited status has been received
- * @dbf: reference to dbf structure
- * @status_buffer: buffer containing payload of unsolicited status
- */
-static inline
-void zfcp_dbf_hba_fsf_unsol(const char *tag, struct zfcp_dbf *dbf,
-                            struct fsf_status_read_buffer *buf)
-{
-        int level = 2;
-
-        if (level <= dbf->hba->level)
-                _zfcp_dbf_hba_fsf_unsol(tag, level, dbf, buf);
 }
 
 static inline
-void zfcp_dbf_scsi(const char *tag, const char *tag2, int level,
-                   struct zfcp_dbf *dbf, struct scsi_cmnd *scmd,
-                   struct zfcp_fsf_req *req, unsigned long old_id)
+void _zfcp_dbf_scsi(char *tag, int level, struct scsi_cmnd *scmd,
+                   struct zfcp_fsf_req *req)
 {
-        if (level <= dbf->scsi->level)
-                _zfcp_dbf_scsi(tag, tag2, level, dbf, scmd, req, old_id);
+        struct zfcp_adapter *adapter = (struct zfcp_adapter *)
+                                        scmd->device->host->hostdata[0];
+
+        if (level <= adapter->dbf->scsi->level)
+                zfcp_dbf_scsi(tag, scmd, req);
 }
 
 /**
  * zfcp_dbf_scsi_result - trace event for SCSI command completion
- * @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)
+void zfcp_dbf_scsi_result(struct scsi_cmnd *scmd, struct zfcp_fsf_req *req)
 {
         if (scmd->result != 0)
-                zfcp_dbf_scsi("rslt", "erro", 3, dbf, scmd, req, 0);
+                _zfcp_dbf_scsi("rsl_err", 3, scmd, req);
         else if (scmd->retries > 0)
-                zfcp_dbf_scsi("rslt", "retr", 4, dbf, scmd, req, 0);
+                _zfcp_dbf_scsi("rsl_ret", 4, scmd, req);
         else
-                zfcp_dbf_scsi("rslt", "norm", 6, dbf, scmd, req, 0);
+                _zfcp_dbf_scsi("rsl_nor", 6, scmd, req);
 }
 
 /**
  * zfcp_dbf_scsi_fail_send - trace event for failure to send SCSI command
- * @dbf: adapter dbf trace
  * @scmd: SCSI command pointer
  */
 static inline
-void zfcp_dbf_scsi_fail_send(struct zfcp_dbf *dbf, struct scsi_cmnd *scmd)
+void zfcp_dbf_scsi_fail_send(struct scsi_cmnd *scmd)
 {
-        zfcp_dbf_scsi("rslt", "fail", 4, dbf, scmd, NULL, 0);
+        _zfcp_dbf_scsi("rsl_fai", 4, scmd, NULL);
 }
 
 /**
  * zfcp_dbf_scsi_abort - trace event for SCSI command abort
  * @tag: tag indicating success or failure of abort operation
- * @adapter: adapter thas has been used to issue SCSI command to be aborted
  * @scmd: SCSI command to be aborted
- * @new_req: request containing abort (might be NULL)
- * @old_id: identifier of request containg SCSI command to be aborted
+ * @fsf_req: request containing abort (might be NULL)
  */
 static inline
-void zfcp_dbf_scsi_abort(const char *tag, struct zfcp_dbf *dbf,
-                         struct scsi_cmnd *scmd, struct zfcp_fsf_req *new_req,
-                         unsigned long old_id)
+void zfcp_dbf_scsi_abort(char *tag, struct scsi_cmnd *scmd,
+                         struct zfcp_fsf_req *fsf_req)
 {
-        zfcp_dbf_scsi("abrt", tag, 1, dbf, scmd, new_req, old_id);
+        _zfcp_dbf_scsi(tag, 1, scmd, fsf_req);
 }
 
 /**
  * zfcp_dbf_scsi_devreset - trace event for Logical Unit or Target Reset
  * @tag: tag indicating success or failure of reset operation
+ * @scmnd: SCSI command which caused this error recovery
  * @flag: indicates type of reset (Target Reset, Logical Unit Reset)
- * @unit: unit that needs reset
- * @scsi_cmnd: SCSI command which caused this error recovery
  */
 static inline
-void zfcp_dbf_scsi_devreset(const char *tag, u8 flag, struct zfcp_unit *unit,
-                            struct scsi_cmnd *scsi_cmnd)
+void zfcp_dbf_scsi_devreset(char *tag, struct scsi_cmnd *scmnd, u8 flag)
 {
-        zfcp_dbf_scsi(flag == FCP_TMF_TGT_RESET ? "trst" : "lrst", tag, 1,
-                            unit->port->adapter->dbf, scsi_cmnd, NULL, 0);
+        char tmp_tag[ZFCP_DBF_TAG_LEN];
+
+        if (flag == FCP_TMF_TGT_RESET)
+                memcpy(tmp_tag, "tr_", 3);
+        else
+                memcpy(tmp_tag, "lr_", 3);
+
+        memcpy(&tmp_tag[3], tag, 4);
+        _zfcp_dbf_scsi(tmp_tag, 1, scmnd, NULL);
 }
 
 #endif /* ZFCP_DBF_H */
diff --git a/drivers/s390/scsi/zfcp_def.h b/drivers/s390/scsi/zfcp_def.h
index e1c6b6e05a75..527ba48eea57 100644
--- a/drivers/s390/scsi/zfcp_def.h
+++ b/drivers/s390/scsi/zfcp_def.h
@@ -85,11 +85,10 @@ struct zfcp_reqlist;
 #define ZFCP_STATUS_PORT_LINK_TEST              0x00000002
 
 /* logical unit status */
-#define ZFCP_STATUS_UNIT_SHARED                 0x00000004
-#define ZFCP_STATUS_UNIT_READONLY               0x00000008
+#define ZFCP_STATUS_LUN_SHARED                  0x00000004
+#define ZFCP_STATUS_LUN_READONLY                0x00000008
 
 /* FSF request status (this does not have a common part) */
-#define ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT      0x00000002
 #define ZFCP_STATUS_FSFREQ_ERROR                0x00000008
 #define ZFCP_STATUS_FSFREQ_CLEANUP              0x00000010
 #define ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED       0x00000040
@@ -108,7 +107,7 @@ struct zfcp_adapter_mempool {
         mempool_t *scsi_req;
         mempool_t *scsi_abort;
         mempool_t *status_read_req;
-        mempool_t *status_read_data;
+        mempool_t *sr_data;
         mempool_t *gid_pn;
         mempool_t *qtcb_pool;
 };
@@ -118,7 +117,7 @@ struct zfcp_erp_action {
         int action;                   /* requested action code */
         struct zfcp_adapter *adapter; /* device which should be recovered */
         struct zfcp_port *port;
-        struct zfcp_unit *unit;
+        struct scsi_device *sdev;
         u32             status;       /* recovery status */
         u32 step;                     /* active step of this erp action */
         unsigned long           fsf_req_id;
@@ -190,6 +189,7 @@ struct zfcp_adapter {
         struct fsf_qtcb_bottom_port *stats_reset_data;
         unsigned long           stats_reset;
         struct work_struct      scan_work;
+        struct work_struct      ns_up_work;
         struct service_level    service_level;
         struct workqueue_struct *work_queue;
         struct device_dma_parameters dma_parms;
@@ -219,21 +219,66 @@ struct zfcp_port {
         unsigned int            starget_id;
 };
 
+/**
+ * struct zfcp_unit - LUN configured via zfcp sysfs
+ * @dev: struct device for sysfs representation and reference counting
+ * @list: entry in LUN/unit list per zfcp_port
+ * @port: reference to zfcp_port where this LUN is configured
+ * @fcp_lun: 64 bit LUN value
+ * @scsi_work: for running scsi_scan_target
+ *
+ * This is the representation of a LUN that has been configured for
+ * usage. The main data here is the 64 bit LUN value, data for
+ * running I/O and recovery is in struct zfcp_scsi_dev.
+ */
 struct zfcp_unit {
-        struct device          dev;
-        struct list_head       list;           /* list of logical units */
-        struct zfcp_port       *port;          /* remote port of unit */
-        atomic_t               status;         /* status of this logical unit */
-        u64                    fcp_lun;        /* own FCP_LUN */
-        u32                    handle;         /* handle assigned by FSF */
-        struct scsi_device     *device;        /* scsi device struct pointer */
-        struct zfcp_erp_action erp_action;     /* pending error recovery */
-        atomic_t               erp_counter;
-        struct zfcp_latencies   latencies;
+        struct device           dev;
+        struct list_head        list;
+        struct zfcp_port        *port;
+        u64                     fcp_lun;
         struct work_struct      scsi_work;
 };
 
 /**
+ * struct zfcp_scsi_dev - zfcp data per SCSI device
+ * @status: zfcp internal status flags
+ * @lun_handle: handle from "open lun" for issuing FSF requests
+ * @erp_action: zfcp erp data for opening and recovering this LUN
+ * @erp_counter: zfcp erp counter for this LUN
+ * @latencies: FSF channel and fabric latencies
+ * @port: zfcp_port where this LUN belongs to
+ */
+struct zfcp_scsi_dev {
+        atomic_t                status;
+        u32                     lun_handle;
+        struct zfcp_erp_action  erp_action;
+        atomic_t                erp_counter;
+        struct zfcp_latencies   latencies;
+        struct zfcp_port        *port;
+};
+
+/**
+ * sdev_to_zfcp - Access zfcp LUN data for SCSI device
+ * @sdev: scsi_device where to get the zfcp_scsi_dev pointer
+ */
+static inline struct zfcp_scsi_dev *sdev_to_zfcp(struct scsi_device *sdev)
+{
+        return scsi_transport_device_data(sdev);
+}
+
+/**
+ * zfcp_scsi_dev_lun - Return SCSI device LUN as 64 bit FCP LUN
+ * @sdev: SCSI device where to get the LUN from
+ */
+static inline u64 zfcp_scsi_dev_lun(struct scsi_device *sdev)
+{
+        u64 fcp_lun;
+
+        int_to_scsilun(sdev->lun, (struct scsi_lun *)&fcp_lun);
+        return fcp_lun;
+}
+
+/**
  * struct zfcp_fsf_req - basic FSF request structure
  * @list: list of FSF requests
  * @req_id: unique request ID
@@ -249,7 +294,6 @@ struct zfcp_unit {
  * @erp_action: reference to erp action if request issued on behalf of ERP
  * @pool: reference to memory pool if used for this request
  * @issued: time when request was send (STCK)
- * @unit: reference to unit if this request is a SCSI request
  * @handler: handler which should be called to process response
  */
 struct zfcp_fsf_req {
@@ -267,24 +311,7 @@ struct zfcp_fsf_req {
         struct zfcp_erp_action  *erp_action;
         mempool_t               *pool;
         unsigned long long      issued;
-        struct zfcp_unit        *unit;
         void                    (*handler)(struct zfcp_fsf_req *);
 };
 
-/* driver data */
-struct zfcp_data {
-        struct scsi_host_template scsi_host_template;
-        struct scsi_transport_template *scsi_transport_template;
-        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 ********************************/
-
-#define ZFCP_SET                0x00000100
-#define ZFCP_CLEAR              0x00000200
-
 #endif /* ZFCP_DEF_H */
diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c
index 160b432c907f..e1b4f800e226 100644
--- a/drivers/s390/scsi/zfcp_erp.c
+++ b/drivers/s390/scsi/zfcp_erp.c
@@ -21,6 +21,7 @@ enum zfcp_erp_act_flags {
         ZFCP_STATUS_ERP_DISMISSING      = 0x00100000,
         ZFCP_STATUS_ERP_DISMISSED       = 0x00200000,
         ZFCP_STATUS_ERP_LOWMEM          = 0x00400000,
+        ZFCP_STATUS_ERP_NO_REF          = 0x00800000,
 };
 
 enum zfcp_erp_steps {
@@ -29,12 +30,12 @@ enum zfcp_erp_steps {
         ZFCP_ERP_STEP_PHYS_PORT_CLOSING = 0x0010,
         ZFCP_ERP_STEP_PORT_CLOSING      = 0x0100,
         ZFCP_ERP_STEP_PORT_OPENING      = 0x0800,
-        ZFCP_ERP_STEP_UNIT_CLOSING      = 0x1000,
-        ZFCP_ERP_STEP_UNIT_OPENING      = 0x2000,
+        ZFCP_ERP_STEP_LUN_CLOSING       = 0x1000,
+        ZFCP_ERP_STEP_LUN_OPENING       = 0x2000,
 };
 
 enum zfcp_erp_act_type {
-        ZFCP_ERP_ACTION_REOPEN_UNIT        = 1,
+        ZFCP_ERP_ACTION_REOPEN_LUN         = 1,
         ZFCP_ERP_ACTION_REOPEN_PORT        = 2,
         ZFCP_ERP_ACTION_REOPEN_PORT_FORCED = 3,
         ZFCP_ERP_ACTION_REOPEN_ADAPTER     = 4,
@@ -56,9 +57,8 @@ enum zfcp_erp_act_result {
 
 static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask)
 {
-        zfcp_erp_modify_adapter_status(adapter, "erablk1", NULL,
-                                       ZFCP_STATUS_COMMON_UNBLOCKED | mask,
-                                       ZFCP_CLEAR);
+        zfcp_erp_clear_adapter_status(adapter,
+                                       ZFCP_STATUS_COMMON_UNBLOCKED | mask);
 }
 
 static int zfcp_erp_action_exists(struct zfcp_erp_action *act)
@@ -76,9 +76,9 @@ static void zfcp_erp_action_ready(struct zfcp_erp_action *act)
         struct zfcp_adapter *adapter = act->adapter;
 
         list_move(&act->list, &act->adapter->erp_ready_head);
-        zfcp_dbf_rec_action("erardy1", act);
+        zfcp_dbf_rec_run("erardy1", act);
         wake_up(&adapter->erp_ready_wq);
-        zfcp_dbf_rec_thread("erardy2", adapter->dbf);
+        zfcp_dbf_rec_run("erardy2", act);
 }
 
 static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
@@ -88,24 +88,24 @@ static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
                 zfcp_erp_action_ready(act);
 }
 
-static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit)
+static void zfcp_erp_action_dismiss_lun(struct scsi_device *sdev)
 {
-        if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
-                zfcp_erp_action_dismiss(&unit->erp_action);
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+
+        if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
+                zfcp_erp_action_dismiss(&zfcp_sdev->erp_action);
 }
 
 static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
 {
-        struct zfcp_unit *unit;
+        struct scsi_device *sdev;
 
         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
                 zfcp_erp_action_dismiss(&port->erp_action);
-        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);
-        }
+        else
+                shost_for_each_device(sdev, port->adapter->scsi_host)
+                        if (sdev_to_zfcp(sdev)->port == port)
+                                zfcp_erp_action_dismiss_lun(sdev);
 }
 
 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
@@ -124,15 +124,17 @@ static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
 
 static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter,
                                  struct zfcp_port *port,
-                                 struct zfcp_unit *unit)
+                                 struct scsi_device *sdev)
 {
         int need = want;
-        int u_status, p_status, a_status;
+        int l_status, p_status, a_status;
+        struct zfcp_scsi_dev *zfcp_sdev;
 
         switch (want) {
-        case ZFCP_ERP_ACTION_REOPEN_UNIT:
-                u_status = atomic_read(&unit->status);
-                if (u_status & ZFCP_STATUS_COMMON_ERP_INUSE)
+        case ZFCP_ERP_ACTION_REOPEN_LUN:
+                zfcp_sdev = sdev_to_zfcp(sdev);
+                l_status = atomic_read(&zfcp_sdev->status);
+                if (l_status & ZFCP_STATUS_COMMON_ERP_INUSE)
                         return 0;
                 p_status = atomic_read(&port->status);
                 if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) ||
@@ -154,6 +156,8 @@ static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter,
                 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) ||
                       a_status & ZFCP_STATUS_COMMON_ERP_FAILED)
                         return 0;
+                if (p_status & ZFCP_STATUS_COMMON_NOESC)
+                        return need;
                 if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED))
                         need = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
                 /* fall through */
@@ -169,22 +173,29 @@ static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter,
         return need;
 }
 
-static struct zfcp_erp_action *zfcp_erp_setup_act(int need,
+static struct zfcp_erp_action *zfcp_erp_setup_act(int need, u32 act_status,
                                                   struct zfcp_adapter *adapter,
                                                   struct zfcp_port *port,
-                                                  struct zfcp_unit *unit)
+                                                  struct scsi_device *sdev)
 {
         struct zfcp_erp_action *erp_action;
-        u32 status = 0;
+        struct zfcp_scsi_dev *zfcp_sdev;
 
         switch (need) {
-        case ZFCP_ERP_ACTION_REOPEN_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))
-                        status = ZFCP_STATUS_ERP_CLOSE_ONLY;
+        case ZFCP_ERP_ACTION_REOPEN_LUN:
+                zfcp_sdev = sdev_to_zfcp(sdev);
+                if (!(act_status & ZFCP_STATUS_ERP_NO_REF))
+                        if (scsi_device_get(sdev))
+                                return NULL;
+                atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
+                                &zfcp_sdev->status);
+                erp_action = &zfcp_sdev->erp_action;
+                memset(erp_action, 0, sizeof(struct zfcp_erp_action));
+                erp_action->port = port;
+                erp_action->sdev = sdev;
+                if (!(atomic_read(&zfcp_sdev->status) &
+                      ZFCP_STATUS_COMMON_RUNNING))
+                        act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
                 break;
 
         case ZFCP_ERP_ACTION_REOPEN_PORT:
@@ -194,8 +205,10 @@ static struct zfcp_erp_action *zfcp_erp_setup_act(int need,
                 zfcp_erp_action_dismiss_port(port);
                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
                 erp_action = &port->erp_action;
+                memset(erp_action, 0, sizeof(struct zfcp_erp_action));
+                erp_action->port = port;
                 if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING))
-                        status = ZFCP_STATUS_ERP_CLOSE_ONLY;
+                        act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
                 break;
 
         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
@@ -203,66 +216,65 @@ static struct zfcp_erp_action *zfcp_erp_setup_act(int need,
                 zfcp_erp_action_dismiss_adapter(adapter);
                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
                 erp_action = &adapter->erp_action;
+                memset(erp_action, 0, sizeof(struct zfcp_erp_action));
                 if (!(atomic_read(&adapter->status) &
                       ZFCP_STATUS_COMMON_RUNNING))
-                        status = ZFCP_STATUS_ERP_CLOSE_ONLY;
+                        act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
                 break;
 
         default:
                 return NULL;
         }
 
-        memset(erp_action, 0, sizeof(struct zfcp_erp_action));
         erp_action->adapter = adapter;
-        erp_action->port = port;
-        erp_action->unit = unit;
         erp_action->action = need;
-        erp_action->status = status;
+        erp_action->status = act_status;
 
         return erp_action;
 }
 
 static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter,
                                    struct zfcp_port *port,
-                                   struct zfcp_unit *unit, char *id, void *ref)
+                                   struct scsi_device *sdev,
+                                   char *id, u32 act_status)
 {
         int retval = 1, need;
-        struct zfcp_erp_action *act = NULL;
+        struct zfcp_erp_action *act;
 
         if (!adapter->erp_thread)
                 return -EIO;
 
-        need = zfcp_erp_required_act(want, adapter, port, unit);
+        need = zfcp_erp_required_act(want, adapter, port, sdev);
         if (!need)
                 goto out;
 
-        atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
-        act = zfcp_erp_setup_act(need, adapter, port, unit);
+        act = zfcp_erp_setup_act(need, act_status, adapter, port, sdev);
         if (!act)
                 goto out;
+        atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
         ++adapter->erp_total_count;
         list_add_tail(&act->list, &adapter->erp_ready_head);
         wake_up(&adapter->erp_ready_wq);
-        zfcp_dbf_rec_thread("eracte1", adapter->dbf);
         retval = 0;
  out:
-        zfcp_dbf_rec_trigger(id, ref, want, need, act, adapter, port, unit);
+        zfcp_dbf_rec_trig(id, adapter, port, sdev, want, need);
         return retval;
 }
 
 static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
-                                    int clear_mask, char *id, void *ref)
+                                    int clear_mask, char *id)
 {
         zfcp_erp_adapter_block(adapter, clear_mask);
         zfcp_scsi_schedule_rports_block(adapter);
 
         /* ensure propagation of failed status to new devices */
         if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
-                zfcp_erp_adapter_failed(adapter, "erareo1", NULL);
+                zfcp_erp_set_adapter_status(adapter,
+                                            ZFCP_STATUS_COMMON_ERP_FAILED);
                 return -EIO;
         }
         return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
-                                       adapter, NULL, NULL, id, ref);
+                                       adapter, NULL, NULL, id, 0);
 }
 
 /**
@@ -270,10 +282,8 @@ static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
  * @adapter: Adapter to reopen.
  * @clear: Status flags to clear.
  * @id: Id for debug trace event.
- * @ref: Reference for debug trace event.
  */
-void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
-                             char *id, void *ref)
+void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear, char *id)
 {
         unsigned long flags;
 
@@ -282,10 +292,11 @@ void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
 
         write_lock_irqsave(&adapter->erp_lock, flags);
         if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
-                zfcp_erp_adapter_failed(adapter, "erareo1", NULL);
+                zfcp_erp_set_adapter_status(adapter,
+                                            ZFCP_STATUS_COMMON_ERP_FAILED);
         else
                 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter,
-                                        NULL, NULL, id, ref);
+                                        NULL, NULL, id, 0);
         write_unlock_irqrestore(&adapter->erp_lock, flags);
 }
 
@@ -294,13 +305,12 @@ void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
  * @adapter: Adapter to shut down.
  * @clear: Status flags to clear.
  * @id: Id for debug trace event.
- * @ref: Reference for debug trace event.
  */
 void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
-                               char *id, void *ref)
+                               char *id)
 {
         int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
-        zfcp_erp_adapter_reopen(adapter, clear | flags, id, ref);
+        zfcp_erp_adapter_reopen(adapter, clear | flags, id);
 }
 
 /**
@@ -308,38 +318,21 @@ void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
  * @port: Port to shut down.
  * @clear: Status flags to clear.
  * @id: Id for debug trace event.
- * @ref: Reference for debug trace event.
- */
-void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *id,
-                            void *ref)
-{
-        int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
-        zfcp_erp_port_reopen(port, clear | flags, id, ref);
-}
-
-/**
- * zfcp_erp_unit_shutdown - Shutdown unit
- * @unit: Unit to shut down.
- * @clear: Status flags to clear.
- * @id: Id for debug trace event.
- * @ref: Reference for debug trace event.
  */
-void zfcp_erp_unit_shutdown(struct zfcp_unit *unit, int clear, char *id,
-                            void *ref)
+void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *id)
 {
         int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
-        zfcp_erp_unit_reopen(unit, clear | flags, id, ref);
+        zfcp_erp_port_reopen(port, clear | flags, id);
 }
 
 static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
 {
-        zfcp_erp_modify_port_status(port, "erpblk1", NULL,
-                                    ZFCP_STATUS_COMMON_UNBLOCKED | clear,
-                                    ZFCP_CLEAR);
+        zfcp_erp_clear_port_status(port,
+                                    ZFCP_STATUS_COMMON_UNBLOCKED | clear);
 }
 
-static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port,
-                                         int clear, char *id, void *ref)
+static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,
+                                         char *id)
 {
         zfcp_erp_port_block(port, clear);
         zfcp_scsi_schedule_rport_block(port);
@@ -348,136 +341,171 @@ static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port,
                 return;
 
         zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
-                                port->adapter, port, NULL, id, ref);
+                                port->adapter, port, NULL, id, 0);
 }
 
 /**
  * zfcp_erp_port_forced_reopen - Forced close of port and open again
  * @port: Port to force close and to reopen.
+ * @clear: Status flags to clear.
  * @id: Id for debug trace event.
- * @ref: Reference for debug trace event.
  */
-void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear, char *id,
-                                 void *ref)
+void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear, char *id)
 {
         unsigned long flags;
         struct zfcp_adapter *adapter = port->adapter;
 
         write_lock_irqsave(&adapter->erp_lock, flags);
-        _zfcp_erp_port_forced_reopen(port, clear, id, ref);
+        _zfcp_erp_port_forced_reopen(port, clear, id);
         write_unlock_irqrestore(&adapter->erp_lock, flags);
 }
 
-static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id,
-                                 void *ref)
+static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id)
 {
         zfcp_erp_port_block(port, clear);
         zfcp_scsi_schedule_rport_block(port);
 
         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
                 /* ensure propagation of failed status to new devices */
-                zfcp_erp_port_failed(port, "erpreo1", NULL);
+                zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
                 return -EIO;
         }
 
         return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
-                                       port->adapter, port, NULL, id, ref);
+                                       port->adapter, port, NULL, id, 0);
 }
 
 /**
  * zfcp_erp_port_reopen - trigger remote port recovery
  * @port: port to recover
  * @clear_mask: flags in port status to be cleared
+ * @id: Id for debug trace event.
  *
  * Returns 0 if recovery has been triggered, < 0 if not.
  */
-int zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id, void *ref)
+int zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id)
 {
         int retval;
         unsigned long flags;
         struct zfcp_adapter *adapter = port->adapter;
 
         write_lock_irqsave(&adapter->erp_lock, flags);
-        retval = _zfcp_erp_port_reopen(port, clear, id, ref);
+        retval = _zfcp_erp_port_reopen(port, clear, id);
         write_unlock_irqrestore(&adapter->erp_lock, flags);
 
         return retval;
 }
 
-static void zfcp_erp_unit_block(struct zfcp_unit *unit, int clear_mask)
+static void zfcp_erp_lun_block(struct scsi_device *sdev, int clear_mask)
 {
-        zfcp_erp_modify_unit_status(unit, "erublk1", NULL,
-                                    ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask,
-                                    ZFCP_CLEAR);
+        zfcp_erp_clear_lun_status(sdev,
+                                  ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask);
 }
 
-static void _zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear, char *id,
-                                  void *ref)
+static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
+                                 u32 act_status)
 {
-        struct zfcp_adapter *adapter = unit->port->adapter;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+        struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
 
-        zfcp_erp_unit_block(unit, clear);
+        zfcp_erp_lun_block(sdev, clear);
 
-        if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
+        if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
                 return;
 
-        zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_UNIT,
-                                adapter, unit->port, unit, id, ref);
+        zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_LUN, adapter,
+                                zfcp_sdev->port, sdev, id, act_status);
 }
 
 /**
- * zfcp_erp_unit_reopen - initiate reopen of a unit
- * @unit: unit to be reopened
- * @clear_mask: specifies flags in unit status to be cleared
+ * zfcp_erp_lun_reopen - initiate reopen of a LUN
+ * @sdev: SCSI device / LUN to be reopened
+ * @clear_mask: specifies flags in LUN status to be cleared
+ * @id: Id for debug trace event.
+ *
  * Return: 0 on success, < 0 on error
  */
-void zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear, char *id,
-                          void *ref)
+void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id)
 {
         unsigned long flags;
-        struct zfcp_port *port = unit->port;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+        struct zfcp_port *port = zfcp_sdev->port;
         struct zfcp_adapter *adapter = port->adapter;
 
         write_lock_irqsave(&adapter->erp_lock, flags);
-        _zfcp_erp_unit_reopen(unit, clear, id, ref);
+        _zfcp_erp_lun_reopen(sdev, clear, id, 0);
         write_unlock_irqrestore(&adapter->erp_lock, flags);
 }
 
-static int status_change_set(unsigned long mask, atomic_t *status)
+/**
+ * zfcp_erp_lun_shutdown - Shutdown LUN
+ * @sdev: SCSI device / LUN to shut down.
+ * @clear: Status flags to clear.
+ * @id: Id for debug trace event.
+ */
+void zfcp_erp_lun_shutdown(struct scsi_device *sdev, int clear, char *id)
 {
-        return (atomic_read(status) ^ mask) & mask;
+        int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
+        zfcp_erp_lun_reopen(sdev, clear | flags, id);
 }
 
-static int status_change_clear(unsigned long mask, atomic_t *status)
+/**
+ * zfcp_erp_lun_shutdown_wait - Shutdown LUN and wait for erp completion
+ * @sdev: SCSI device / LUN to shut down.
+ * @id: Id for debug trace event.
+ *
+ * Do not acquire a reference for the LUN when creating the ERP
+ * action. It is safe, because this function waits for the ERP to
+ * complete first. This allows to shutdown the LUN, even when the SCSI
+ * device is in the state SDEV_DEL when scsi_device_get will fail.
+ */
+void zfcp_erp_lun_shutdown_wait(struct scsi_device *sdev, char *id)
 {
-        return atomic_read(status) & mask;
+        unsigned long flags;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+        struct zfcp_port *port = zfcp_sdev->port;
+        struct zfcp_adapter *adapter = port->adapter;
+        int clear = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
+
+        write_lock_irqsave(&adapter->erp_lock, flags);
+        _zfcp_erp_lun_reopen(sdev, clear, id, ZFCP_STATUS_ERP_NO_REF);
+        write_unlock_irqrestore(&adapter->erp_lock, flags);
+
+        zfcp_erp_wait(adapter);
+}
+
+static int status_change_set(unsigned long mask, atomic_t *status)
+{
+        return (atomic_read(status) ^ mask) & mask;
 }
 
 static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
 {
         if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status))
-                zfcp_dbf_rec_adapter("eraubl1", NULL, adapter->dbf);
+                zfcp_dbf_rec_run("eraubl1", &adapter->erp_action);
         atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
 }
 
 static void zfcp_erp_port_unblock(struct zfcp_port *port)
 {
         if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status))
-                zfcp_dbf_rec_port("erpubl1", NULL, port);
+                zfcp_dbf_rec_run("erpubl1", &port->erp_action);
         atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
 }
 
-static void zfcp_erp_unit_unblock(struct zfcp_unit *unit)
+static void zfcp_erp_lun_unblock(struct scsi_device *sdev)
 {
-        if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status))
-                zfcp_dbf_rec_unit("eruubl1", NULL, unit);
-        atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status);
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+
+        if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status))
+                zfcp_dbf_rec_run("erlubl1", &sdev_to_zfcp(sdev)->erp_action);
+        atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status);
 }
 
 static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
 {
         list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
-        zfcp_dbf_rec_action("erator1", erp_action);
+        zfcp_dbf_rec_run("erator1", erp_action);
 }
 
 static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
@@ -494,11 +522,11 @@ static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
                 if (act->status & (ZFCP_STATUS_ERP_DISMISSED |
                                    ZFCP_STATUS_ERP_TIMEDOUT)) {
                         req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
-                        zfcp_dbf_rec_action("erscf_1", act);
+                        zfcp_dbf_rec_run("erscf_1", act);
                         req->erp_action = NULL;
                 }
                 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
-                        zfcp_dbf_rec_action("erscf_2", act);
+                        zfcp_dbf_rec_run("erscf_2", act);
                 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
                         act->fsf_req_id = 0;
         } else
@@ -549,41 +577,40 @@ static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
 }
 
 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
-                                      int clear, char *id, void *ref)
+                                      int clear, char *id)
 {
         struct zfcp_port *port;
 
         read_lock(&adapter->port_list_lock);
         list_for_each_entry(port, &adapter->port_list, list)
-                _zfcp_erp_port_reopen(port, clear, id, ref);
+                _zfcp_erp_port_reopen(port, clear, id);
         read_unlock(&adapter->port_list_lock);
 }
 
-static void _zfcp_erp_unit_reopen_all(struct zfcp_port *port, int clear,
-                                      char *id, void *ref)
+static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
+                                     char *id)
 {
-        struct zfcp_unit *unit;
+        struct scsi_device *sdev;
 
-        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);
+        shost_for_each_device(sdev, port->adapter->scsi_host)
+                if (sdev_to_zfcp(sdev)->port == port)
+                        _zfcp_erp_lun_reopen(sdev, clear, id, 0);
 }
 
 static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
 {
         switch (act->action) {
         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
-                _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1", NULL);
+                _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1");
                 break;
         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
-                _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2", NULL);
+                _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2");
                 break;
         case ZFCP_ERP_ACTION_REOPEN_PORT:
-                _zfcp_erp_port_reopen(act->port, 0, "ersff_3", NULL);
+                _zfcp_erp_port_reopen(act->port, 0, "ersff_3");
                 break;
-        case ZFCP_ERP_ACTION_REOPEN_UNIT:
-                _zfcp_erp_unit_reopen(act->unit, 0, "ersff_4", NULL);
+        case ZFCP_ERP_ACTION_REOPEN_LUN:
+                _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", 0);
                 break;
         }
 }
@@ -592,13 +619,13 @@ static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act)
 {
         switch (act->action) {
         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
-                _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1", NULL);
+                _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1");
                 break;
         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
-                _zfcp_erp_port_reopen(act->port, 0, "ersfs_2", NULL);
+                _zfcp_erp_port_reopen(act->port, 0, "ersfs_2");
                 break;
         case ZFCP_ERP_ACTION_REOPEN_PORT:
-                _zfcp_erp_unit_reopen_all(act->port, 0, "ersfs_3", NULL);
+                _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3");
                 break;
         }
 }
@@ -617,17 +644,6 @@ static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
         read_unlock_irqrestore(&adapter->erp_lock, flags);
 }
 
-static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *act)
-{
-        struct zfcp_qdio *qdio = act->adapter->qdio;
-
-        if (zfcp_qdio_open(qdio))
-                return ZFCP_ERP_FAILED;
-        init_waitqueue_head(&qdio->req_q_wq);
-        atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &act->adapter->status);
-        return ZFCP_ERP_SUCCEEDED;
-}
-
 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
 {
         struct zfcp_port *port;
@@ -635,7 +651,7 @@ static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
                                  adapter->peer_d_id);
         if (IS_ERR(port)) /* error or port already attached */
                 return;
-        _zfcp_erp_port_reopen(port, 0, "ereptp1", NULL);
+        _zfcp_erp_port_reopen(port, 0, "ereptp1");
 }
 
 static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
@@ -658,10 +674,8 @@ static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
                         return ZFCP_ERP_FAILED;
                 }
 
-                zfcp_dbf_rec_thread_lock("erasfx1", adapter->dbf);
                 wait_event(adapter->erp_ready_wq,
                            !list_empty(&adapter->erp_ready_head));
-                zfcp_dbf_rec_thread_lock("erasfx2", adapter->dbf);
                 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
                         break;
 
@@ -700,10 +714,10 @@ static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *act)
         if (ret)
                 return ZFCP_ERP_FAILED;
 
-        zfcp_dbf_rec_thread_lock("erasox1", adapter->dbf);
+        zfcp_dbf_rec_run("erasox1", act);
         wait_event(adapter->erp_ready_wq,
                    !list_empty(&adapter->erp_ready_head));
-        zfcp_dbf_rec_thread_lock("erasox2", adapter->dbf);
+        zfcp_dbf_rec_run("erasox2", act);
         if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
                 return ZFCP_ERP_FAILED;
 
@@ -718,7 +732,7 @@ static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *act)
         if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)
                 return ZFCP_ERP_FAILED;
 
-        if (mempool_resize(act->adapter->pool.status_read_data,
+        if (mempool_resize(act->adapter->pool.sr_data,
                            act->adapter->stat_read_buf_num, GFP_KERNEL))
                 return ZFCP_ERP_FAILED;
 
@@ -742,9 +756,8 @@ static void zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *act)
         zfcp_fsf_req_dismiss_all(adapter);
         adapter->fsf_req_seq_no = 0;
         zfcp_fc_wka_ports_force_offline(adapter->gs);
-        /* all ports and units are closed */
-        zfcp_erp_modify_adapter_status(adapter, "erascl1", NULL,
-                                       ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
+        /* all ports and LUNs are closed */
+        zfcp_erp_clear_adapter_status(adapter, ZFCP_STATUS_COMMON_OPEN);
 
         atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
                           ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
@@ -754,7 +767,7 @@ static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *act)
 {
         struct zfcp_adapter *adapter = act->adapter;
 
-        if (zfcp_erp_adapter_strategy_open_qdio(act)) {
+        if (zfcp_qdio_open(adapter->qdio)) {
                 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
                                   ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
                                   &adapter->status);
@@ -861,7 +874,7 @@ static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
         struct zfcp_port *port = act->port;
 
         if (port->wwpn != adapter->peer_wwpn) {
-                zfcp_erp_port_failed(port, "eroptp1", NULL);
+                zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
                 return ZFCP_ERP_FAILED;
         }
         port->d_id = adapter->peer_d_id;
@@ -933,82 +946,87 @@ close_init_done:
         return zfcp_erp_port_strategy_open_common(erp_action);
 }
 
-static void zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit)
+static void zfcp_erp_lun_strategy_clearstati(struct scsi_device *sdev)
 {
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+
         atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
-                          ZFCP_STATUS_UNIT_SHARED |
-                          ZFCP_STATUS_UNIT_READONLY,
-                          &unit->status);
+                          ZFCP_STATUS_LUN_SHARED | ZFCP_STATUS_LUN_READONLY,
+                          &zfcp_sdev->status);
 }
 
-static int zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action)
+static int zfcp_erp_lun_strategy_close(struct zfcp_erp_action *erp_action)
 {
-        int retval = zfcp_fsf_close_unit(erp_action);
+        int retval = zfcp_fsf_close_lun(erp_action);
         if (retval == -ENOMEM)
                 return ZFCP_ERP_NOMEM;
-        erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING;
+        erp_action->step = ZFCP_ERP_STEP_LUN_CLOSING;
         if (retval)
                 return ZFCP_ERP_FAILED;
         return ZFCP_ERP_CONTINUES;
 }
 
-static int zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action)
+static int zfcp_erp_lun_strategy_open(struct zfcp_erp_action *erp_action)
 {
-        int retval = zfcp_fsf_open_unit(erp_action);
+        int retval = zfcp_fsf_open_lun(erp_action);
         if (retval == -ENOMEM)
                 return ZFCP_ERP_NOMEM;
-        erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING;
+        erp_action->step = ZFCP_ERP_STEP_LUN_OPENING;
         if (retval)
                 return  ZFCP_ERP_FAILED;
         return ZFCP_ERP_CONTINUES;
 }
 
-static int zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action)
+static int zfcp_erp_lun_strategy(struct zfcp_erp_action *erp_action)
 {
-        struct zfcp_unit *unit = erp_action->unit;
+        struct scsi_device *sdev = erp_action->sdev;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
 
         switch (erp_action->step) {
         case ZFCP_ERP_STEP_UNINITIALIZED:
-                zfcp_erp_unit_strategy_clearstati(unit);
-                if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN)
-                        return zfcp_erp_unit_strategy_close(erp_action);
+                zfcp_erp_lun_strategy_clearstati(sdev);
+                if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
+                        return zfcp_erp_lun_strategy_close(erp_action);
                 /* already closed, fall through */
-        case ZFCP_ERP_STEP_UNIT_CLOSING:
-                if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN)
+        case ZFCP_ERP_STEP_LUN_CLOSING:
+                if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
                         return ZFCP_ERP_FAILED;
                 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
                         return ZFCP_ERP_EXIT;
-                return zfcp_erp_unit_strategy_open(erp_action);
+                return zfcp_erp_lun_strategy_open(erp_action);
 
-        case ZFCP_ERP_STEP_UNIT_OPENING:
-                if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN)
+        case ZFCP_ERP_STEP_LUN_OPENING:
+                if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
                         return ZFCP_ERP_SUCCEEDED;
         }
         return ZFCP_ERP_FAILED;
 }
 
-static int zfcp_erp_strategy_check_unit(struct zfcp_unit *unit, int result)
+static int zfcp_erp_strategy_check_lun(struct scsi_device *sdev, int result)
 {
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+
         switch (result) {
         case ZFCP_ERP_SUCCEEDED :
-                atomic_set(&unit->erp_counter, 0);
-                zfcp_erp_unit_unblock(unit);
+                atomic_set(&zfcp_sdev->erp_counter, 0);
+                zfcp_erp_lun_unblock(sdev);
                 break;
         case ZFCP_ERP_FAILED :
-                atomic_inc(&unit->erp_counter);
-                if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS) {
-                        dev_err(&unit->port->adapter->ccw_device->dev,
-                                "ERP failed for unit 0x%016Lx on "
+                atomic_inc(&zfcp_sdev->erp_counter);
+                if (atomic_read(&zfcp_sdev->erp_counter) > ZFCP_MAX_ERPS) {
+                        dev_err(&zfcp_sdev->port->adapter->ccw_device->dev,
+                                "ERP failed for LUN 0x%016Lx on "
                                 "port 0x%016Lx\n",
-                                (unsigned long long)unit->fcp_lun,
-                                (unsigned long long)unit->port->wwpn);
-                        zfcp_erp_unit_failed(unit, "erusck1", NULL);
+                                (unsigned long long)zfcp_scsi_dev_lun(sdev),
+                                (unsigned long long)zfcp_sdev->port->wwpn);
+                        zfcp_erp_set_lun_status(sdev,
+                                                ZFCP_STATUS_COMMON_ERP_FAILED);
                 }
                 break;
         }
 
-        if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
-                zfcp_erp_unit_block(unit, 0);
+        if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
+                zfcp_erp_lun_block(sdev, 0);
                 result = ZFCP_ERP_EXIT;
         }
         return result;
@@ -1032,7 +1050,8 @@ static int zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
                         dev_err(&port->adapter->ccw_device->dev,
                                 "ERP failed for remote port 0x%016Lx\n",
                                 (unsigned long long)port->wwpn);
-                        zfcp_erp_port_failed(port, "erpsck1", NULL);
+                        zfcp_erp_set_port_status(port,
+                                         ZFCP_STATUS_COMMON_ERP_FAILED);
                 }
                 break;
         }
@@ -1059,7 +1078,8 @@ static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter,
                         dev_err(&adapter->ccw_device->dev,
                                 "ERP cannot recover an error "
                                 "on the FCP device\n");
-                        zfcp_erp_adapter_failed(adapter, "erasck1", NULL);
+                        zfcp_erp_set_adapter_status(adapter,
+                                            ZFCP_STATUS_COMMON_ERP_FAILED);
                 }
                 break;
         }
@@ -1076,12 +1096,12 @@ static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action,
 {
         struct zfcp_adapter *adapter = erp_action->adapter;
         struct zfcp_port *port = erp_action->port;
-        struct zfcp_unit *unit = erp_action->unit;
+        struct scsi_device *sdev = erp_action->sdev;
 
         switch (erp_action->action) {
 
-        case ZFCP_ERP_ACTION_REOPEN_UNIT:
-                result = zfcp_erp_strategy_check_unit(unit, result);
+        case ZFCP_ERP_ACTION_REOPEN_LUN:
+                result = zfcp_erp_strategy_check_lun(sdev, result);
                 break;
 
         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
@@ -1116,7 +1136,8 @@ static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
         int action = act->action;
         struct zfcp_adapter *adapter = act->adapter;
         struct zfcp_port *port = act->port;
-        struct zfcp_unit *unit = act->unit;
+        struct scsi_device *sdev = act->sdev;
+        struct zfcp_scsi_dev *zfcp_sdev;
         u32 erp_status = act->status;
 
         switch (action) {
@@ -1124,7 +1145,7 @@ static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
                 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
                         _zfcp_erp_adapter_reopen(adapter,
                                                  ZFCP_STATUS_COMMON_ERP_FAILED,
-                                                 "ersscg1", NULL);
+                                                 "ersscg1");
                         return ZFCP_ERP_EXIT;
                 }
                 break;
@@ -1134,16 +1155,17 @@ static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
                 if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
                         _zfcp_erp_port_reopen(port,
                                               ZFCP_STATUS_COMMON_ERP_FAILED,
-                                              "ersscg2", NULL);
+                                              "ersscg2");
                         return ZFCP_ERP_EXIT;
                 }
                 break;
 
-        case ZFCP_ERP_ACTION_REOPEN_UNIT:
-                if (zfcp_erp_strat_change_det(&unit->status, erp_status)) {
-                        _zfcp_erp_unit_reopen(unit,
-                                              ZFCP_STATUS_COMMON_ERP_FAILED,
-                                              "ersscg3", NULL);
+        case ZFCP_ERP_ACTION_REOPEN_LUN:
+                zfcp_sdev = sdev_to_zfcp(sdev);
+                if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) {
+                        _zfcp_erp_lun_reopen(sdev,
+                                             ZFCP_STATUS_COMMON_ERP_FAILED,
+                                             "ersscg3", 0);
                         return ZFCP_ERP_EXIT;
                 }
                 break;
@@ -1154,6 +1176,7 @@ static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
 static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
 {
         struct zfcp_adapter *adapter = erp_action->adapter;
+        struct zfcp_scsi_dev *zfcp_sdev;
 
         adapter->erp_total_count--;
         if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
@@ -1162,12 +1185,13 @@ static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
         }
 
         list_del(&erp_action->list);
-        zfcp_dbf_rec_action("eractd1", erp_action);
+        zfcp_dbf_rec_run("eractd1", erp_action);
 
         switch (erp_action->action) {
-        case ZFCP_ERP_ACTION_REOPEN_UNIT:
+        case ZFCP_ERP_ACTION_REOPEN_LUN:
+                zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
-                                  &erp_action->unit->status);
+                                  &zfcp_sdev->status);
                 break;
 
         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
@@ -1187,11 +1211,12 @@ static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
 {
         struct zfcp_adapter *adapter = act->adapter;
         struct zfcp_port *port = act->port;
-        struct zfcp_unit *unit = act->unit;
+        struct scsi_device *sdev = act->sdev;
 
         switch (act->action) {
-        case ZFCP_ERP_ACTION_REOPEN_UNIT:
-                put_device(&unit->dev);
+        case ZFCP_ERP_ACTION_REOPEN_LUN:
+                if (!(act->status & ZFCP_STATUS_ERP_NO_REF))
+                        scsi_device_put(sdev);
                 break;
 
         case ZFCP_ERP_ACTION_REOPEN_PORT:
@@ -1206,8 +1231,10 @@ static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
                 if (result == ZFCP_ERP_SUCCEEDED) {
                         register_service_level(&adapter->service_level);
                         queue_work(adapter->work_queue, &adapter->scan_work);
+                        queue_work(adapter->work_queue, &adapter->ns_up_work);
                 } else
                         unregister_service_level(&adapter->service_level);
+
                 kref_put(&adapter->ref, zfcp_adapter_release);
                 break;
         }
@@ -1222,8 +1249,8 @@ static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
                 return zfcp_erp_port_forced_strategy(erp_action);
         case ZFCP_ERP_ACTION_REOPEN_PORT:
                 return zfcp_erp_port_strategy(erp_action);
-        case ZFCP_ERP_ACTION_REOPEN_UNIT:
-                return zfcp_erp_unit_strategy(erp_action);
+        case ZFCP_ERP_ACTION_REOPEN_LUN:
+                return zfcp_erp_lun_strategy(erp_action);
         }
         return ZFCP_ERP_FAILED;
 }
@@ -1267,7 +1294,7 @@ static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
                         erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
                 }
                 if (adapter->erp_total_count == adapter->erp_low_mem_count)
-                        _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1", NULL);
+                        _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1");
                 else {
                         zfcp_erp_strategy_memwait(erp_action);
                         retval = ZFCP_ERP_CONTINUES;
@@ -1311,11 +1338,9 @@ static int zfcp_erp_thread(void *data)
         unsigned long flags;
 
         for (;;) {
-                zfcp_dbf_rec_thread_lock("erthrd1", adapter->dbf);
                 wait_event_interruptible(adapter->erp_ready_wq,
                            !list_empty(&adapter->erp_ready_head) ||
                            kthread_should_stop());
-                zfcp_dbf_rec_thread_lock("erthrd2", adapter->dbf);
 
                 if (kthread_should_stop())
                         break;
@@ -1376,42 +1401,6 @@ void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
 }
 
 /**
- * zfcp_erp_adapter_failed - Set adapter status to failed.
- * @adapter: Failed adapter.
- * @id: Event id for debug trace.
- * @ref: Reference for debug trace.
- */
-void zfcp_erp_adapter_failed(struct zfcp_adapter *adapter, char *id, void *ref)
-{
-        zfcp_erp_modify_adapter_status(adapter, id, ref,
-                                       ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
-}
-
-/**
- * zfcp_erp_port_failed - Set port status to failed.
- * @port: Failed port.
- * @id: Event id for debug trace.
- * @ref: Reference for debug trace.
- */
-void zfcp_erp_port_failed(struct zfcp_port *port, char *id, void *ref)
-{
-        zfcp_erp_modify_port_status(port, id, ref,
-                                    ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
-}
-
-/**
- * zfcp_erp_unit_failed - Set unit status to failed.
- * @unit: Failed unit.
- * @id: Event id for debug trace.
- * @ref: Reference for debug trace.
- */
-void zfcp_erp_unit_failed(struct zfcp_unit *unit, char *id, void *ref)
-{
-        zfcp_erp_modify_unit_status(unit, id, ref,
-                                    ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
-}
-
-/**
  * zfcp_erp_wait - wait for completion of error recovery on an adapter
  * @adapter: adapter for which to wait for completion of its error recovery
  */
@@ -1423,210 +1412,148 @@ void zfcp_erp_wait(struct zfcp_adapter *adapter)
 }
 
 /**
- * zfcp_erp_modify_adapter_status - change adapter status bits
+ * zfcp_erp_set_adapter_status - set adapter status bits
  * @adapter: adapter to change the status
- * @id: id for the debug trace
- * @ref: reference for the debug trace
  * @mask: status bits to change
- * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
  *
- * Changes in common status bits are propagated to attached ports and units.
+ * Changes in common status bits are propagated to attached ports and LUNs.
  */
-void zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter, char *id,
-                                    void *ref, u32 mask, int set_or_clear)
+void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
 {
         struct zfcp_port *port;
+        struct scsi_device *sdev;
         unsigned long flags;
         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
 
-        if (set_or_clear == ZFCP_SET) {
-                if (status_change_set(mask, &adapter->status))
-                        zfcp_dbf_rec_adapter(id, ref, adapter->dbf);
-                atomic_set_mask(mask, &adapter->status);
-        } else {
-                if (status_change_clear(mask, &adapter->status))
-                        zfcp_dbf_rec_adapter(id, ref, adapter->dbf);
-                atomic_clear_mask(mask, &adapter->status);
-                if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
-                        atomic_set(&adapter->erp_counter, 0);
-        }
+        atomic_set_mask(mask, &adapter->status);
 
-        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);
-        }
+        if (!common_mask)
+                return;
+
+        read_lock_irqsave(&adapter->port_list_lock, flags);
+        list_for_each_entry(port, &adapter->port_list, list)
+                atomic_set_mask(common_mask, &port->status);
+        read_unlock_irqrestore(&adapter->port_list_lock, flags);
+
+        shost_for_each_device(sdev, adapter->scsi_host)
+                atomic_set_mask(common_mask, &sdev_to_zfcp(sdev)->status);
 }
 
 /**
- * zfcp_erp_modify_port_status - change port status bits
- * @port: port to change the status bits
- * @id: id for the debug trace
- * @ref: reference for the debug trace
+ * zfcp_erp_clear_adapter_status - clear adapter status bits
+ * @adapter: adapter to change the status
  * @mask: status bits to change
- * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
  *
- * Changes in common status bits are propagated to attached units.
+ * Changes in common status bits are propagated to attached ports and LUNs.
  */
-void zfcp_erp_modify_port_status(struct zfcp_port *port, char *id, void *ref,
-                                 u32 mask, int set_or_clear)
+void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
 {
-        struct zfcp_unit *unit;
+        struct zfcp_port *port;
+        struct scsi_device *sdev;
         unsigned long flags;
         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
+        u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
 
-        if (set_or_clear == ZFCP_SET) {
-                if (status_change_set(mask, &port->status))
-                        zfcp_dbf_rec_port(id, ref, port);
-                atomic_set_mask(mask, &port->status);
-        } else {
-                if (status_change_clear(mask, &port->status))
-                        zfcp_dbf_rec_port(id, ref, port);
-                atomic_clear_mask(mask, &port->status);
-                if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
+        atomic_clear_mask(mask, &adapter->status);
+
+        if (!common_mask)
+                return;
+
+        if (clear_counter)
+                atomic_set(&adapter->erp_counter, 0);
+
+        read_lock_irqsave(&adapter->port_list_lock, flags);
+        list_for_each_entry(port, &adapter->port_list, list) {
+                atomic_clear_mask(common_mask, &port->status);
+                if (clear_counter)
                         atomic_set(&port->erp_counter, 0);
         }
+        read_unlock_irqrestore(&adapter->port_list_lock, flags);
 
-        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);
+        shost_for_each_device(sdev, adapter->scsi_host) {
+                atomic_clear_mask(common_mask, &sdev_to_zfcp(sdev)->status);
+                if (clear_counter)
+                        atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
         }
 }
 
 /**
- * zfcp_erp_modify_unit_status - change unit status bits
- * @unit: unit to change the status bits
- * @id: id for the debug trace
- * @ref: reference for the debug trace
+ * zfcp_erp_set_port_status - set port status bits
+ * @port: port to change the status
  * @mask: status bits to change
- * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
- */
-void zfcp_erp_modify_unit_status(struct zfcp_unit *unit, char *id, void *ref,
-                                 u32 mask, int set_or_clear)
-{
-        if (set_or_clear == ZFCP_SET) {
-                if (status_change_set(mask, &unit->status))
-                        zfcp_dbf_rec_unit(id, ref, unit);
-                atomic_set_mask(mask, &unit->status);
-        } else {
-                if (status_change_clear(mask, &unit->status))
-                        zfcp_dbf_rec_unit(id, ref, unit);
-                atomic_clear_mask(mask, &unit->status);
-                if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) {
-                        atomic_set(&unit->erp_counter, 0);
-                }
-        }
-}
-
-/**
- * zfcp_erp_port_boxed - Mark port as "boxed" and start ERP
- * @port: The "boxed" port.
- * @id: The debug trace id.
- * @id: Reference for the debug trace.
+ *
+ * Changes in common status bits are propagated to attached LUNs.
  */
-void zfcp_erp_port_boxed(struct zfcp_port *port, char *id, void *ref)
+void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
 {
-        zfcp_erp_modify_port_status(port, id, ref,
-                                    ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET);
-        zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
-}
+        struct scsi_device *sdev;
+        u32 common_mask = mask & ZFCP_COMMON_FLAGS;
 
-/**
- * zfcp_erp_unit_boxed - Mark unit as "boxed" and start ERP
- * @port: The "boxed" unit.
- * @id: The debug trace id.
- * @id: Reference for the debug trace.
- */
-void zfcp_erp_unit_boxed(struct zfcp_unit *unit, char *id, void *ref)
-{
-        zfcp_erp_modify_unit_status(unit, id, ref,
-                                    ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET);
-        zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
-}
+        atomic_set_mask(mask, &port->status);
 
-/**
- * zfcp_erp_port_access_denied - Adapter denied access to port.
- * @port: port where access has been denied
- * @id: id for debug trace
- * @ref: reference for debug trace
- *
- * Since the adapter has denied access, stop using the port and the
- * attached units.
- */
-void zfcp_erp_port_access_denied(struct zfcp_port *port, char *id, void *ref)
-{
-        zfcp_erp_modify_port_status(port, id, ref,
-                                    ZFCP_STATUS_COMMON_ERP_FAILED |
-                                    ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
+        if (!common_mask)
+                return;
+
+        shost_for_each_device(sdev, port->adapter->scsi_host)
+                if (sdev_to_zfcp(sdev)->port == port)
+                        atomic_set_mask(common_mask,
+                                        &sdev_to_zfcp(sdev)->status);
 }
 
 /**
- * zfcp_erp_unit_access_denied - Adapter denied access to unit.
- * @unit: unit where access has been denied
- * @id: id for debug trace
- * @ref: reference for debug trace
+ * zfcp_erp_clear_port_status - clear port status bits
+ * @port: adapter to change the status
+ * @mask: status bits to change
  *
- * Since the adapter has denied access, stop using the unit.
+ * Changes in common status bits are propagated to attached LUNs.
  */
-void zfcp_erp_unit_access_denied(struct zfcp_unit *unit, char *id, void *ref)
+void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
 {
-        zfcp_erp_modify_unit_status(unit, id, ref,
-                                    ZFCP_STATUS_COMMON_ERP_FAILED |
-                                    ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
-}
+        struct scsi_device *sdev;
+        u32 common_mask = mask & ZFCP_COMMON_FLAGS;
+        u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
 
-static void zfcp_erp_unit_access_changed(struct zfcp_unit *unit, char *id,
-                                         void *ref)
-{
-        int status = atomic_read(&unit->status);
-        if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED |
-                        ZFCP_STATUS_COMMON_ACCESS_BOXED)))
+        atomic_clear_mask(mask, &port->status);
+
+        if (!common_mask)
                 return;
 
-        zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
+        if (clear_counter)
+                atomic_set(&port->erp_counter, 0);
+
+        shost_for_each_device(sdev, port->adapter->scsi_host)
+                if (sdev_to_zfcp(sdev)->port == port) {
+                        atomic_clear_mask(common_mask,
+                                          &sdev_to_zfcp(sdev)->status);
+                        if (clear_counter)
+                                atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
+                }
 }
 
-static void zfcp_erp_port_access_changed(struct zfcp_port *port, char *id,
-                                         void *ref)
+/**
+ * zfcp_erp_set_lun_status - set lun status bits
+ * @sdev: SCSI device / lun to set the status bits
+ * @mask: status bits to change
+ */
+void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask)
 {
-        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))) {
-                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;
-        }
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
 
-        zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
+        atomic_set_mask(mask, &zfcp_sdev->status);
 }
 
 /**
- * zfcp_erp_adapter_access_changed - Process change in adapter ACT
- * @adapter: Adapter where the Access Control Table (ACT) changed
- * @id: Id for debug trace
- * @ref: Reference for debug trace
+ * zfcp_erp_clear_lun_status - clear lun status bits
+ * @sdev: SCSi device / lun to clear the status bits
+ * @mask: status bits to change
  */
-void zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter, char *id,
-                                     void *ref)
+void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask)
 {
-        unsigned long flags;
-        struct zfcp_port *port;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
 
-        if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
-                return;
+        atomic_clear_mask(mask, &zfcp_sdev->status);
 
-        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(&adapter->port_list_lock, flags);
+        if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
+                atomic_set(&zfcp_sdev->erp_counter, 0);
 }
+
diff --git a/drivers/s390/scsi/zfcp_ext.h b/drivers/s390/scsi/zfcp_ext.h
index 3b93239c6f69..03627cfd81cd 100644
--- a/drivers/s390/scsi/zfcp_ext.h
+++ b/drivers/s390/scsi/zfcp_ext.h
@@ -15,12 +15,10 @@
 #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 struct zfcp_adapter *zfcp_adapter_enqueue(struct ccw_device *);
 extern struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *, u64, u32,
                                            u32);
-extern struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *, u64);
 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 *,
@@ -36,66 +34,53 @@ extern void zfcp_ccw_adapter_put(struct zfcp_adapter *);
 
 /* zfcp_cfdc.c */
 extern struct miscdevice zfcp_cfdc_misc;
+extern void zfcp_cfdc_port_denied(struct zfcp_port *, union fsf_status_qual *);
+extern void zfcp_cfdc_lun_denied(struct scsi_device *, union fsf_status_qual *);
+extern void zfcp_cfdc_lun_shrng_vltn(struct scsi_device *,
+                                     union fsf_status_qual *);
+extern int zfcp_cfdc_open_lun_eval(struct scsi_device *,
+                                   struct fsf_qtcb_bottom_support *);
+extern void zfcp_cfdc_adapter_access_changed(struct zfcp_adapter *);
+
 
 /* zfcp_dbf.c */
 extern int zfcp_dbf_adapter_register(struct zfcp_adapter *);
-extern void zfcp_dbf_adapter_unregister(struct zfcp_dbf *);
-extern void zfcp_dbf_rec_thread(char *, struct zfcp_dbf *);
-extern void zfcp_dbf_rec_thread_lock(char *, struct zfcp_dbf *);
-extern void zfcp_dbf_rec_adapter(char *, void *, struct zfcp_dbf *);
-extern void zfcp_dbf_rec_port(char *, void *, struct zfcp_port *);
-extern void zfcp_dbf_rec_unit(char *, void *, struct zfcp_unit *);
-extern void zfcp_dbf_rec_trigger(char *, void *, u8, u8, void *,
-                                 struct zfcp_adapter *, struct zfcp_port *,
-                                 struct zfcp_unit *);
-extern void zfcp_dbf_rec_action(char *, struct zfcp_erp_action *);
-extern void _zfcp_dbf_hba_fsf_response(const char *, int, struct zfcp_fsf_req *,
-                                       struct zfcp_dbf *);
-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_adapter_unregister(struct zfcp_adapter *);
+extern void zfcp_dbf_rec_trig(char *, struct zfcp_adapter *,
+                              struct zfcp_port *, struct scsi_device *, u8, u8);
+extern void zfcp_dbf_rec_run(char *, struct zfcp_erp_action *);
+extern void zfcp_dbf_hba_fsf_uss(char *, struct zfcp_fsf_req *);
+extern void zfcp_dbf_hba_fsf_res(char *, struct zfcp_fsf_req *);
+extern void zfcp_dbf_hba_bit_err(char *, struct zfcp_fsf_req *);
 extern void zfcp_dbf_hba_berr(struct zfcp_dbf *, 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 *);
-extern void zfcp_dbf_san_incoming_els(struct zfcp_fsf_req *);
-extern void _zfcp_dbf_scsi(const char *, const char *, int, struct zfcp_dbf *,
-                           struct scsi_cmnd *, struct zfcp_fsf_req *,
-                           unsigned long);
+extern void zfcp_dbf_san_req(char *, struct zfcp_fsf_req *, u32);
+extern void zfcp_dbf_san_res(char *, struct zfcp_fsf_req *);
+extern void zfcp_dbf_san_in_els(char *, struct zfcp_fsf_req *);
+extern void zfcp_dbf_scsi(char *, struct scsi_cmnd *, struct zfcp_fsf_req *);
 
 /* zfcp_erp.c */
-extern void zfcp_erp_modify_adapter_status(struct zfcp_adapter *, char *,
-                                           void *, u32, int);
-extern void zfcp_erp_adapter_reopen(struct zfcp_adapter *, int, char *, void *);
-extern void zfcp_erp_adapter_shutdown(struct zfcp_adapter *, int, char *,
-                                      void *);
-extern void zfcp_erp_adapter_failed(struct zfcp_adapter *, char *, void *);
-extern void zfcp_erp_modify_port_status(struct zfcp_port *, char *, void *, u32,
-                                        int);
-extern int  zfcp_erp_port_reopen(struct zfcp_port *, int, char *, void *);
-extern void zfcp_erp_port_shutdown(struct zfcp_port *, int, char *, void *);
-extern void zfcp_erp_port_forced_reopen(struct zfcp_port *, int, char *,
-                                        void *);
-extern void zfcp_erp_port_failed(struct zfcp_port *, char *, void *);
-extern void zfcp_erp_modify_unit_status(struct zfcp_unit *, char *, void *, u32,
-                                        int);
-extern void zfcp_erp_unit_reopen(struct zfcp_unit *, int, char *, void *);
-extern void zfcp_erp_unit_shutdown(struct zfcp_unit *, int, char *, void *);
-extern void zfcp_erp_unit_failed(struct zfcp_unit *, char *, void *);
+extern void zfcp_erp_set_adapter_status(struct zfcp_adapter *, u32);
+extern void zfcp_erp_clear_adapter_status(struct zfcp_adapter *, u32);
+extern void zfcp_erp_adapter_reopen(struct zfcp_adapter *, int, char *);
+extern void zfcp_erp_adapter_shutdown(struct zfcp_adapter *, int, char *);
+extern void zfcp_erp_set_port_status(struct zfcp_port *, u32);
+extern void zfcp_erp_clear_port_status(struct zfcp_port *, u32);
+extern int  zfcp_erp_port_reopen(struct zfcp_port *, int, char *);
+extern void zfcp_erp_port_shutdown(struct zfcp_port *, int, char *);
+extern void zfcp_erp_port_forced_reopen(struct zfcp_port *, int, char *);
+extern void zfcp_erp_set_lun_status(struct scsi_device *, u32);
+extern void zfcp_erp_clear_lun_status(struct scsi_device *, u32);
+extern void zfcp_erp_lun_reopen(struct scsi_device *, int, char *);
+extern void zfcp_erp_lun_shutdown(struct scsi_device *, int, char *);
+extern void zfcp_erp_lun_shutdown_wait(struct scsi_device *, char *);
 extern int  zfcp_erp_thread_setup(struct zfcp_adapter *);
 extern void zfcp_erp_thread_kill(struct zfcp_adapter *);
 extern void zfcp_erp_wait(struct zfcp_adapter *);
 extern void zfcp_erp_notify(struct zfcp_erp_action *, unsigned long);
-extern void zfcp_erp_port_boxed(struct zfcp_port *, char *, void *);
-extern void zfcp_erp_unit_boxed(struct zfcp_unit *, char *, void *);
-extern void zfcp_erp_port_access_denied(struct zfcp_port *, char *, void *);
-extern void zfcp_erp_unit_access_denied(struct zfcp_unit *, char *, void *);
-extern void zfcp_erp_adapter_access_changed(struct zfcp_adapter *, char *,
-                                            void *);
 extern void zfcp_erp_timeout_handler(unsigned long);
 
 /* zfcp_fc.c */
+extern struct kmem_cache *zfcp_fc_req_cache;
 extern void zfcp_fc_enqueue_event(struct zfcp_adapter *,
                                 enum fc_host_event_code event_code, u32);
 extern void zfcp_fc_post_event(struct work_struct *);
@@ -111,15 +96,17 @@ extern int zfcp_fc_gs_setup(struct zfcp_adapter *);
 extern void zfcp_fc_gs_destroy(struct zfcp_adapter *);
 extern int zfcp_fc_exec_bsg_job(struct fc_bsg_job *);
 extern int zfcp_fc_timeout_bsg_job(struct fc_bsg_job *);
+extern void zfcp_fc_sym_name_update(struct work_struct *);
 
 /* zfcp_fsf.c */
+extern struct kmem_cache *zfcp_fsf_qtcb_cache;
 extern int zfcp_fsf_open_port(struct zfcp_erp_action *);
 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 *);
-extern int zfcp_fsf_close_unit(struct zfcp_erp_action *);
+extern int zfcp_fsf_open_lun(struct zfcp_erp_action *);
+extern int zfcp_fsf_close_lun(struct zfcp_erp_action *);
 extern int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *);
 extern int zfcp_fsf_exchange_config_data_sync(struct zfcp_qdio *,
                                               struct fsf_qtcb_bottom_config *);
@@ -135,12 +122,10 @@ 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 int zfcp_fsf_fcp_cmnd(struct scsi_cmnd *);
 extern void zfcp_fsf_req_free(struct zfcp_fsf_req *);
-extern struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_unit *, u8);
-extern struct zfcp_fsf_req *zfcp_fsf_abort_fcp_command(unsigned long,
-                                                       struct zfcp_unit *);
+extern struct zfcp_fsf_req *zfcp_fsf_fcp_task_mgmt(struct scsi_cmnd *, u8);
+extern struct zfcp_fsf_req *zfcp_fsf_abort_fcp_cmnd(struct scsi_cmnd *);
 extern void zfcp_fsf_reqid_check(struct zfcp_qdio *, int);
 
 /* zfcp_qdio.c */
@@ -153,18 +138,18 @@ extern int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *, struct zfcp_qdio_req *,
 extern int zfcp_qdio_open(struct zfcp_qdio *);
 extern void zfcp_qdio_close(struct zfcp_qdio *);
 extern void zfcp_qdio_siosl(struct zfcp_adapter *);
+extern struct zfcp_fsf_req *zfcp_fsf_get_req(struct zfcp_qdio *,
+                                             struct qdio_buffer *);
 
 /* zfcp_scsi.c */
-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 struct scsi_transport_template *zfcp_scsi_transport_template;
+extern int zfcp_scsi_adapter_register(struct zfcp_adapter *);
+extern void zfcp_scsi_adapter_unregister(struct zfcp_adapter *);
 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 *);
 extern void zfcp_scsi_schedule_rport_block(struct zfcp_port *);
 extern void zfcp_scsi_schedule_rports_block(struct zfcp_adapter *);
-extern void zfcp_scsi_scan(struct zfcp_unit *);
-extern void zfcp_scsi_scan_work(struct work_struct *);
 extern void zfcp_scsi_set_prot(struct zfcp_adapter *);
 extern void zfcp_scsi_dif_sense_error(struct scsi_cmnd *, int);
 
@@ -175,4 +160,13 @@ extern struct attribute_group zfcp_sysfs_port_attrs;
 extern struct device_attribute *zfcp_sysfs_sdev_attrs[];
 extern struct device_attribute *zfcp_sysfs_shost_attrs[];
 
+/* zfcp_unit.c */
+extern int zfcp_unit_add(struct zfcp_port *, u64);
+extern int zfcp_unit_remove(struct zfcp_port *, u64);
+extern struct zfcp_unit *zfcp_unit_find(struct zfcp_port *, u64);
+extern struct scsi_device *zfcp_unit_sdev(struct zfcp_unit *unit);
+extern void zfcp_unit_scsi_scan(struct zfcp_unit *);
+extern void zfcp_unit_queue_scsi_scan(struct zfcp_port *);
+extern unsigned int zfcp_unit_sdev_status(struct zfcp_unit *);
+
 #endif  /* ZFCP_EXT_H */
diff --git a/drivers/s390/scsi/zfcp_fc.c b/drivers/s390/scsi/zfcp_fc.c
index 6f3ed2b9a349..297e6b71ce9c 100644
--- a/drivers/s390/scsi/zfcp_fc.c
+++ b/drivers/s390/scsi/zfcp_fc.c
@@ -11,11 +11,14 @@
 
 #include <linux/types.h>
 #include <linux/slab.h>
+#include <linux/utsname.h>
 #include <scsi/fc/fc_els.h>
 #include <scsi/libfc.h>
 #include "zfcp_ext.h"
 #include "zfcp_fc.h"
 
+struct kmem_cache *zfcp_fc_req_cache;
+
 static u32 zfcp_fc_rscn_range_mask[] = {
         [ELS_ADDR_FMT_PORT]             = 0xFFFFFF,
         [ELS_ADDR_FMT_AREA]             = 0xFFFF00,
@@ -174,7 +177,7 @@ static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req, u32 range,
                 if (!port->d_id)
                         zfcp_erp_port_reopen(port,
                                              ZFCP_STATUS_COMMON_ERP_FAILED,
-                                             "fcrscn1", NULL);
+                                             "fcrscn1");
         }
         read_unlock_irqrestore(&adapter->port_list_lock, flags);
 }
@@ -215,7 +218,7 @@ static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req *req, u64 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);
+                        zfcp_erp_port_forced_reopen(port, 0, "fciwwp1");
                         break;
                 }
         read_unlock_irqrestore(&adapter->port_list_lock, flags);
@@ -251,7 +254,7 @@ void zfcp_fc_incoming_els(struct zfcp_fsf_req *fsf_req)
                 (struct fsf_status_read_buffer *) fsf_req->data;
         unsigned int els_type = status_buffer->payload.data[0];
 
-        zfcp_dbf_san_incoming_els(fsf_req);
+        zfcp_dbf_san_in_els("fciels1", fsf_req);
         if (els_type == ELS_PLOGI)
                 zfcp_fc_incoming_plogi(fsf_req);
         else if (els_type == ELS_LOGO)
@@ -260,24 +263,18 @@ void zfcp_fc_incoming_els(struct zfcp_fsf_req *fsf_req)
                 zfcp_fc_incoming_rscn(fsf_req);
 }
 
-static void zfcp_fc_ns_gid_pn_eval(void *data)
+static void zfcp_fc_ns_gid_pn_eval(struct zfcp_fc_req *fc_req)
 {
-        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;
+        struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
+        struct zfcp_fc_gid_pn_rsp *gid_pn_rsp = &fc_req->u.gid_pn.rsp;
 
-        if (ct->status)
+        if (ct_els->status)
                 return;
-        if (gid_pn_resp->ct_hdr.ct_cmd != FC_FS_ACC)
+        if (gid_pn_rsp->ct_hdr.ct_cmd != FC_FS_ACC)
                 return;
 
-        /* paranoia */
-        if (gid_pn_req->gid_pn.fn_wwpn != port->wwpn)
-                return;
         /* looks like a valid d_id */
-        port->d_id = ntoh24(gid_pn_resp->gid_pn.fp_fid);
+        ct_els->port->d_id = ntoh24(gid_pn_rsp->gid_pn.fp_fid);
 }
 
 static void zfcp_fc_complete(void *data)
@@ -285,69 +282,73 @@ static void zfcp_fc_complete(void *data)
         complete(data);
 }
 
+static void zfcp_fc_ct_ns_init(struct fc_ct_hdr *ct_hdr, u16 cmd, u16 mr_size)
+{
+        ct_hdr->ct_rev = FC_CT_REV;
+        ct_hdr->ct_fs_type = FC_FST_DIR;
+        ct_hdr->ct_fs_subtype = FC_NS_SUBTYPE;
+        ct_hdr->ct_cmd = cmd;
+        ct_hdr->ct_mr_size = mr_size / 4;
+}
+
 static int zfcp_fc_ns_gid_pn_request(struct zfcp_port *port,
-                                     struct zfcp_fc_gid_pn *gid_pn)
+                                     struct zfcp_fc_req *fc_req)
 {
         struct zfcp_adapter *adapter = port->adapter;
         DECLARE_COMPLETION_ONSTACK(completion);
+        struct zfcp_fc_gid_pn_req *gid_pn_req = &fc_req->u.gid_pn.req;
+        struct zfcp_fc_gid_pn_rsp *gid_pn_rsp = &fc_req->u.gid_pn.rsp;
         int ret;
 
         /* setup parameters for send generic command */
-        gid_pn->port = port;
-        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->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,
+        fc_req->ct_els.port = port;
+        fc_req->ct_els.handler = zfcp_fc_complete;
+        fc_req->ct_els.handler_data = &completion;
+        fc_req->ct_els.req = &fc_req->sg_req;
+        fc_req->ct_els.resp = &fc_req->sg_rsp;
+        sg_init_one(&fc_req->sg_req, gid_pn_req, sizeof(*gid_pn_req));
+        sg_init_one(&fc_req->sg_rsp, gid_pn_rsp, sizeof(*gid_pn_rsp));
+
+        zfcp_fc_ct_ns_init(&gid_pn_req->ct_hdr,
+                           FC_NS_GID_PN, ZFCP_FC_CT_SIZE_PAGE);
+        gid_pn_req->gid_pn.fn_wwpn = port->wwpn;
+
+        ret = zfcp_fsf_send_ct(&adapter->gs->ds, &fc_req->ct_els,
                                adapter->pool.gid_pn_req,
                                ZFCP_FC_CTELS_TMO);
         if (!ret) {
                 wait_for_completion(&completion);
-                zfcp_fc_ns_gid_pn_eval(gid_pn);
+                zfcp_fc_ns_gid_pn_eval(fc_req);
         }
         return ret;
 }
 
 /**
- * zfcp_fc_ns_gid_pn_request - initiate GID_PN nameserver request
+ * zfcp_fc_ns_gid_pn - initiate GID_PN nameserver request
  * @port: port where GID_PN request is needed
  * return: -ENOMEM on error, 0 otherwise
  */
 static int zfcp_fc_ns_gid_pn(struct zfcp_port *port)
 {
         int ret;
-        struct zfcp_fc_gid_pn *gid_pn;
+        struct zfcp_fc_req *fc_req;
         struct zfcp_adapter *adapter = port->adapter;
 
-        gid_pn = mempool_alloc(adapter->pool.gid_pn, GFP_ATOMIC);
-        if (!gid_pn)
+        fc_req = mempool_alloc(adapter->pool.gid_pn, GFP_ATOMIC);
+        if (!fc_req)
                 return -ENOMEM;
 
-        memset(gid_pn, 0, sizeof(*gid_pn));
+        memset(fc_req, 0, sizeof(*fc_req));
 
         ret = zfcp_fc_wka_port_get(&adapter->gs->ds);
         if (ret)
                 goto out;
 
-        ret = zfcp_fc_ns_gid_pn_request(port, gid_pn);
+        ret = zfcp_fc_ns_gid_pn_request(port, fc_req);
 
         zfcp_fc_wka_port_put(&adapter->gs->ds);
 out:
-        mempool_free(gid_pn, adapter->pool.gid_pn);
+        mempool_free(fc_req, adapter->pool.gid_pn);
         return ret;
 }
 
@@ -360,16 +361,16 @@ void zfcp_fc_port_did_lookup(struct work_struct *work)
         ret = zfcp_fc_ns_gid_pn(port);
         if (ret) {
                 /* could not issue gid_pn for some reason */
-                zfcp_erp_adapter_reopen(port->adapter, 0, "fcgpn_1", NULL);
+                zfcp_erp_adapter_reopen(port->adapter, 0, "fcgpn_1");
                 goto out;
         }
 
         if (!port->d_id) {
-                zfcp_erp_port_failed(port, "fcgpn_2", NULL);
+                zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
                 goto out;
         }
 
-        zfcp_erp_port_reopen(port, 0, "fcgpn_3", NULL);
+        zfcp_erp_port_reopen(port, 0, "fcgpn_3");
 out:
         put_device(&port->dev);
 }
@@ -419,14 +420,14 @@ void zfcp_fc_plogi_evaluate(struct zfcp_port *port, struct fc_els_flogi *plogi)
 
 static void zfcp_fc_adisc_handler(void *data)
 {
-        struct zfcp_fc_els_adisc *adisc = data;
-        struct zfcp_port *port = adisc->els.port;
-        struct fc_els_adisc *adisc_resp = &adisc->adisc_resp;
+        struct zfcp_fc_req *fc_req = data;
+        struct zfcp_port *port = fc_req->ct_els.port;
+        struct fc_els_adisc *adisc_resp = &fc_req->u.adisc.rsp;
 
-        if (adisc->els.status) {
+        if (fc_req->ct_els.status) {
                 /* request rejected or timed out */
                 zfcp_erp_port_forced_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                            "fcadh_1", NULL);
+                                            "fcadh_1");
                 goto out;
         }
 
@@ -436,7 +437,7 @@ static void zfcp_fc_adisc_handler(void *data)
         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);
+                                     "fcadh_2");
                 goto out;
         }
 
@@ -445,42 +446,42 @@ static void zfcp_fc_adisc_handler(void *data)
  out:
         atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status);
         put_device(&port->dev);
-        kmem_cache_free(zfcp_data.adisc_cache, adisc);
+        kmem_cache_free(zfcp_fc_req_cache, fc_req);
 }
 
 static int zfcp_fc_adisc(struct zfcp_port *port)
 {
-        struct zfcp_fc_els_adisc *adisc;
+        struct zfcp_fc_req *fc_req;
         struct zfcp_adapter *adapter = port->adapter;
+        struct Scsi_Host *shost = adapter->scsi_host;
         int ret;
 
-        adisc = kmem_cache_zalloc(zfcp_data.adisc_cache, GFP_ATOMIC);
-        if (!adisc)
+        fc_req = kmem_cache_zalloc(zfcp_fc_req_cache, GFP_ATOMIC);
+        if (!fc_req)
                 return -ENOMEM;
 
-        adisc->els.port = port;
-        adisc->els.req = &adisc->req;
-        adisc->els.resp = &adisc->resp;
-        sg_init_one(adisc->els.req, &adisc->adisc_req,
+        fc_req->ct_els.port = port;
+        fc_req->ct_els.req = &fc_req->sg_req;
+        fc_req->ct_els.resp = &fc_req->sg_rsp;
+        sg_init_one(&fc_req->sg_req, &fc_req->u.adisc.req,
                     sizeof(struct fc_els_adisc));
-        sg_init_one(adisc->els.resp, &adisc->adisc_resp,
+        sg_init_one(&fc_req->sg_rsp, &fc_req->u.adisc.rsp,
                     sizeof(struct fc_els_adisc));
 
-        adisc->els.handler = zfcp_fc_adisc_handler;
-        adisc->els.handler_data = adisc;
+        fc_req->ct_els.handler = zfcp_fc_adisc_handler;
+        fc_req->ct_els.handler_data = fc_req;
 
         /* 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->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));
+        fc_req->u.adisc.req.adisc_wwpn = fc_host_port_name(shost);
+        fc_req->u.adisc.req.adisc_wwnn = fc_host_node_name(shost);
+        fc_req->u.adisc.req.adisc_cmd = ELS_ADISC;
+        hton24(fc_req->u.adisc.req.adisc_port_id, fc_host_port_id(shost));
 
-        ret = zfcp_fsf_send_els(adapter, port->d_id, &adisc->els,
+        ret = zfcp_fsf_send_els(adapter, port->d_id, &fc_req->ct_els,
                                 ZFCP_FC_CTELS_TMO);
         if (ret)
-                kmem_cache_free(zfcp_data.adisc_cache, adisc);
+                kmem_cache_free(zfcp_fc_req_cache, fc_req);
 
         return ret;
 }
@@ -507,7 +508,7 @@ void zfcp_fc_link_test_work(struct work_struct *work)
 
         /* send of ADISC was not possible */
         atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status);
-        zfcp_erp_port_forced_reopen(port, 0, "fcltwk1", NULL);
+        zfcp_erp_port_forced_reopen(port, 0, "fcltwk1");
 
 out:
         put_device(&port->dev);
@@ -528,68 +529,42 @@ void zfcp_fc_test_link(struct zfcp_port *port)
                 put_device(&port->dev);
 }
 
-static void zfcp_free_sg_env(struct zfcp_fc_gpn_ft *gpn_ft, int buf_num)
+static struct zfcp_fc_req *zfcp_alloc_sg_env(int buf_num)
 {
-        struct scatterlist *sg = &gpn_ft->sg_req;
-
-        kmem_cache_free(zfcp_data.gpn_ft_cache, sg_virt(sg));
-        zfcp_sg_free_table(gpn_ft->sg_resp, buf_num);
-
-        kfree(gpn_ft);
-}
+        struct zfcp_fc_req *fc_req;
 
-static struct zfcp_fc_gpn_ft *zfcp_alloc_sg_env(int buf_num)
-{
-        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)
+        fc_req = kmem_cache_zalloc(zfcp_fc_req_cache, GFP_KERNEL);
+        if (!fc_req)
                 return NULL;
 
-        req = kmem_cache_zalloc(zfcp_data.gpn_ft_cache, GFP_KERNEL);
-        if (!req) {
-                kfree(gpn_ft);
-                gpn_ft = NULL;
-                goto out;
+        if (zfcp_sg_setup_table(&fc_req->sg_rsp, buf_num)) {
+                kmem_cache_free(zfcp_fc_req_cache, fc_req);
+                return NULL;
         }
-        sg_init_one(&gpn_ft->sg_req, req, sizeof(*req));
 
-        if (zfcp_sg_setup_table(gpn_ft->sg_resp, buf_num)) {
-                zfcp_free_sg_env(gpn_ft, buf_num);
-                gpn_ft = NULL;
-        }
-out:
-        return gpn_ft;
-}
+        sg_init_one(&fc_req->sg_req, &fc_req->u.gpn_ft.req,
+                    sizeof(struct zfcp_fc_gpn_ft_req));
 
+        return fc_req;
+}
 
-static int zfcp_fc_send_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
+static int zfcp_fc_send_gpn_ft(struct zfcp_fc_req *fc_req,
                                struct zfcp_adapter *adapter, int max_bytes)
 {
-        struct zfcp_fsf_ct_els *ct = &gpn_ft->ct;
-        struct zfcp_fc_gpn_ft_req *req = sg_virt(&gpn_ft->sg_req);
+        struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
+        struct zfcp_fc_gpn_ft_req *req = &fc_req->u.gpn_ft.req;
         DECLARE_COMPLETION_ONSTACK(completion);
         int ret;
 
-        /* prepare CT IU for GPN_FT */
-        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;
+        zfcp_fc_ct_ns_init(&req->ct_hdr, FC_NS_GPN_FT, max_bytes);
         req->gpn_ft.fn_fc4_type = FC_TYPE_FCP;
 
-        /* prepare zfcp_send_ct */
-        ct->handler = zfcp_fc_complete;
-        ct->handler_data = &completion;
-        ct->req = &gpn_ft->sg_req;
-        ct->resp = gpn_ft->sg_resp;
+        ct_els->handler = zfcp_fc_complete;
+        ct_els->handler_data = &completion;
+        ct_els->req = &fc_req->sg_req;
+        ct_els->resp = &fc_req->sg_rsp;
 
-        ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct, NULL,
+        ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct_els, NULL,
                                ZFCP_FC_CTELS_TMO);
         if (!ret)
                 wait_for_completion(&completion);
@@ -610,11 +585,11 @@ static void zfcp_fc_validate_port(struct zfcp_port *port, struct list_head *lh)
         list_move_tail(&port->list, lh);
 }
 
-static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
+static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_req *fc_req,
                                struct zfcp_adapter *adapter, int max_entries)
 {
-        struct zfcp_fsf_ct_els *ct = &gpn_ft->ct;
-        struct scatterlist *sg = gpn_ft->sg_resp;
+        struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
+        struct scatterlist *sg = &fc_req->sg_rsp;
         struct fc_ct_hdr *hdr = sg_virt(sg);
         struct fc_gpn_ft_resp *acc = sg_virt(sg);
         struct zfcp_port *port, *tmp;
@@ -623,7 +598,7 @@ static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
         u32 d_id;
         int ret = 0, x, last = 0;
 
-        if (ct->status)
+        if (ct_els->status)
                 return -EIO;
 
         if (hdr->ct_cmd != FC_FS_ACC) {
@@ -659,7 +634,7 @@ static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
                 port = zfcp_port_enqueue(adapter, acc->fp_wwpn,
                                          ZFCP_STATUS_COMMON_NOESC, d_id);
                 if (!IS_ERR(port))
-                        zfcp_erp_port_reopen(port, 0, "fcegpf1", NULL);
+                        zfcp_erp_port_reopen(port, 0, "fcegpf1");
                 else if (PTR_ERR(port) != -EEXIST)
                         ret = PTR_ERR(port);
         }
@@ -671,7 +646,7 @@ static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
         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_erp_port_shutdown(port, 0, "fcegpf2");
                 zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs);
         }
 
@@ -687,7 +662,7 @@ 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_fc_gpn_ft *gpn_ft;
+        struct zfcp_fc_req *fc_req;
         int chain, max_entries, buf_num, max_bytes;
 
         chain = adapter->adapter_features & FSF_FEATURE_ELS_CT_CHAINED_SBALS;
@@ -702,25 +677,145 @@ void zfcp_fc_scan_ports(struct work_struct *work)
         if (zfcp_fc_wka_port_get(&adapter->gs->ds))
                 return;
 
-        gpn_ft = zfcp_alloc_sg_env(buf_num);
-        if (!gpn_ft)
+        fc_req = zfcp_alloc_sg_env(buf_num);
+        if (!fc_req)
                 goto out;
 
         for (i = 0; i < 3; i++) {
-                ret = zfcp_fc_send_gpn_ft(gpn_ft, adapter, max_bytes);
+                ret = zfcp_fc_send_gpn_ft(fc_req, adapter, max_bytes);
                 if (!ret) {
-                        ret = zfcp_fc_eval_gpn_ft(gpn_ft, adapter, max_entries);
+                        ret = zfcp_fc_eval_gpn_ft(fc_req, adapter, max_entries);
                         if (ret == -EAGAIN)
                                 ssleep(1);
                         else
                                 break;
                 }
         }
-        zfcp_free_sg_env(gpn_ft, buf_num);
+        zfcp_sg_free_table(&fc_req->sg_rsp, buf_num);
+        kmem_cache_free(zfcp_fc_req_cache, fc_req);
 out:
         zfcp_fc_wka_port_put(&adapter->gs->ds);
 }
 
+static int zfcp_fc_gspn(struct zfcp_adapter *adapter,
+                        struct zfcp_fc_req *fc_req)
+{
+        DECLARE_COMPLETION_ONSTACK(completion);
+        char devno[] = "DEVNO:";
+        struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
+        struct zfcp_fc_gspn_req *gspn_req = &fc_req->u.gspn.req;
+        struct zfcp_fc_gspn_rsp *gspn_rsp = &fc_req->u.gspn.rsp;
+        int ret;
+
+        zfcp_fc_ct_ns_init(&gspn_req->ct_hdr, FC_NS_GSPN_ID,
+                           FC_SYMBOLIC_NAME_SIZE);
+        hton24(gspn_req->gspn.fp_fid, fc_host_port_id(adapter->scsi_host));
+
+        sg_init_one(&fc_req->sg_req, gspn_req, sizeof(*gspn_req));
+        sg_init_one(&fc_req->sg_rsp, gspn_rsp, sizeof(*gspn_rsp));
+
+        ct_els->handler = zfcp_fc_complete;
+        ct_els->handler_data = &completion;
+        ct_els->req = &fc_req->sg_req;
+        ct_els->resp = &fc_req->sg_rsp;
+
+        ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct_els, NULL,
+                               ZFCP_FC_CTELS_TMO);
+        if (ret)
+                return ret;
+
+        wait_for_completion(&completion);
+        if (ct_els->status)
+                return ct_els->status;
+
+        if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_NPIV &&
+            !(strstr(gspn_rsp->gspn.fp_name, devno)))
+                snprintf(fc_host_symbolic_name(adapter->scsi_host),
+                         FC_SYMBOLIC_NAME_SIZE, "%s%s %s NAME: %s",
+                         gspn_rsp->gspn.fp_name, devno,
+                         dev_name(&adapter->ccw_device->dev),
+                         init_utsname()->nodename);
+        else
+                strlcpy(fc_host_symbolic_name(adapter->scsi_host),
+                        gspn_rsp->gspn.fp_name, FC_SYMBOLIC_NAME_SIZE);
+
+        return 0;
+}
+
+static void zfcp_fc_rspn(struct zfcp_adapter *adapter,
+                         struct zfcp_fc_req *fc_req)
+{
+        DECLARE_COMPLETION_ONSTACK(completion);
+        struct Scsi_Host *shost = adapter->scsi_host;
+        struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els;
+        struct zfcp_fc_rspn_req *rspn_req = &fc_req->u.rspn.req;
+        struct fc_ct_hdr *rspn_rsp = &fc_req->u.rspn.rsp;
+        int ret, len;
+
+        zfcp_fc_ct_ns_init(&rspn_req->ct_hdr, FC_NS_RSPN_ID,
+                           FC_SYMBOLIC_NAME_SIZE);
+        hton24(rspn_req->rspn.fr_fid.fp_fid, fc_host_port_id(shost));
+        len = strlcpy(rspn_req->rspn.fr_name, fc_host_symbolic_name(shost),
+                      FC_SYMBOLIC_NAME_SIZE);
+        rspn_req->rspn.fr_name_len = len;
+
+        sg_init_one(&fc_req->sg_req, rspn_req, sizeof(*rspn_req));
+        sg_init_one(&fc_req->sg_rsp, rspn_rsp, sizeof(*rspn_rsp));
+
+        ct_els->handler = zfcp_fc_complete;
+        ct_els->handler_data = &completion;
+        ct_els->req = &fc_req->sg_req;
+        ct_els->resp = &fc_req->sg_rsp;
+
+        ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct_els, NULL,
+                               ZFCP_FC_CTELS_TMO);
+        if (!ret)
+                wait_for_completion(&completion);
+}
+
+/**
+ * zfcp_fc_sym_name_update - Retrieve and update the symbolic port name
+ * @work: ns_up_work of the adapter where to update the symbolic port name
+ *
+ * Retrieve the current symbolic port name that may have been set by
+ * the hardware using the GSPN request and update the fc_host
+ * symbolic_name sysfs attribute. When running in NPIV mode (and hence
+ * the port name is unique for this system), update the symbolic port
+ * name to add Linux specific information and update the FC nameserver
+ * using the RSPN request.
+ */
+void zfcp_fc_sym_name_update(struct work_struct *work)
+{
+        struct zfcp_adapter *adapter = container_of(work, struct zfcp_adapter,
+                                                    ns_up_work);
+        int ret;
+        struct zfcp_fc_req *fc_req;
+
+        if (fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPORT &&
+            fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPIV)
+                return;
+
+        fc_req = kmem_cache_zalloc(zfcp_fc_req_cache, GFP_KERNEL);
+        if (!fc_req)
+                return;
+
+        ret = zfcp_fc_wka_port_get(&adapter->gs->ds);
+        if (ret)
+                goto out_free;
+
+        ret = zfcp_fc_gspn(adapter, fc_req);
+        if (ret || fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPIV)
+                goto out_ds_put;
+
+        memset(fc_req, 0, sizeof(*fc_req));
+        zfcp_fc_rspn(adapter, fc_req);
+
+out_ds_put:
+        zfcp_fc_wka_port_put(&adapter->gs->ds);
+out_free:
+        kmem_cache_free(zfcp_fc_req_cache, fc_req);
+}
+
 static void zfcp_fc_ct_els_job_handler(void *data)
 {
         struct fc_bsg_job *job = data;
diff --git a/drivers/s390/scsi/zfcp_fc.h b/drivers/s390/scsi/zfcp_fc.h
index 938d50360166..4561f3bf7300 100644
--- a/drivers/s390/scsi/zfcp_fc.h
+++ b/drivers/s390/scsi/zfcp_fc.h
@@ -64,33 +64,16 @@ struct zfcp_fc_gid_pn_req {
 } __packed;
 
 /**
- * struct zfcp_fc_gid_pn_resp - container for ct header plus gid_pn response
+ * struct zfcp_fc_gid_pn_rsp - 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 zfcp_fc_gid_pn_rsp {
         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
@@ -101,41 +84,72 @@ struct zfcp_fc_gpn_ft_req {
 } __packed;
 
 /**
- * struct zfcp_fc_gpn_ft_resp - container for ct header plus gpn_ft response
+ * struct zfcp_fc_gspn_req - container for ct header plus GSPN_ID request
  * @ct_hdr: FC GS common transport header
- * @gpn_ft: Array of gpn_ft response data to fill one memory page
+ * @gspn: GSPN_ID request
  */
-struct zfcp_fc_gpn_ft_resp {
+struct zfcp_fc_gspn_req {
         struct fc_ct_hdr        ct_hdr;
-        struct fc_gpn_ft_resp   gpn_ft[ZFCP_FC_GPN_FT_ENT_PAGE];
+        struct fc_gid_pn_resp   gspn;
 } __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_gspn_rsp - container for ct header plus GSPN_ID response
+ * @ct_hdr: FC GS common transport header
+ * @gspn: GSPN_ID response
+ * @name: The name string of the GSPN_ID response
  */
-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_gspn_rsp {
+        struct fc_ct_hdr        ct_hdr;
+        struct fc_gspn_resp     gspn;
+        char                    name[FC_SYMBOLIC_NAME_SIZE];
+} __packed;
 
 /**
- * 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_rspn_req - container for ct header plus RSPN_ID request
+ * @ct_hdr: FC GS common transport header
+ * @rspn: RSPN_ID request
+ * @name: The name string of the RSPN_ID request
  */
-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;
+struct zfcp_fc_rspn_req {
+        struct fc_ct_hdr        ct_hdr;
+        struct fc_ns_rspn       rspn;
+        char                    name[FC_SYMBOLIC_NAME_SIZE];
+} __packed;
+
+/**
+ * struct zfcp_fc_req - Container for FC ELS and CT requests sent from zfcp
+ * @ct_els: data required for issuing fsf command
+ * @sg_req: scatterlist entry for request data
+ * @sg_rsp: scatterlist entry for response data
+ * @u: request specific data
+ */
+struct zfcp_fc_req {
+        struct zfcp_fsf_ct_els                          ct_els;
+        struct scatterlist                              sg_req;
+        struct scatterlist                              sg_rsp;
+        union {
+                struct {
+                        struct fc_els_adisc             req;
+                        struct fc_els_adisc             rsp;
+                } adisc;
+                struct {
+                        struct zfcp_fc_gid_pn_req       req;
+                        struct zfcp_fc_gid_pn_rsp       rsp;
+                } gid_pn;
+                struct {
+                        struct scatterlist sg_rsp2[ZFCP_FC_GPN_FT_NUM_BUFS - 1];
+                        struct zfcp_fc_gpn_ft_req       req;
+                } gpn_ft;
+                struct {
+                        struct zfcp_fc_gspn_req         req;
+                        struct zfcp_fc_gspn_rsp         rsp;
+                } gspn;
+                struct {
+                        struct zfcp_fc_rspn_req         req;
+                        struct fc_ct_hdr                rsp;
+                } rspn;
+        } u;
 };
 
 /**
@@ -192,14 +206,21 @@ struct zfcp_fc_wka_ports {
  * 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
+ * @tm: task management flags to setup task management command
  */
 static inline
-void zfcp_fc_scsi_to_fcp(struct fcp_cmnd *fcp, struct scsi_cmnd *scsi)
+void zfcp_fc_scsi_to_fcp(struct fcp_cmnd *fcp, struct scsi_cmnd *scsi,
+                         u8 tm_flags)
 {
         char tag[2];
 
         int_to_scsilun(scsi->device->lun, (struct scsi_lun *) &fcp->fc_lun);
 
+        if (unlikely(tm_flags)) {
+                fcp->fc_tm_flags = tm_flags;
+                return;
+        }
+
         if (scsi_populate_tag_msg(scsi, tag)) {
                 switch (tag[0]) {
                 case MSG_ORDERED_TAG:
@@ -226,19 +247,6 @@ void zfcp_fc_scsi_to_fcp(struct fcp_cmnd *fcp, struct scsi_cmnd *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
@@ -270,7 +278,7 @@ void zfcp_fc_eval_fcp_rsp(struct fcp_resp_with_ext *fcp_rsp,
         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 += fcp_rsp->ext.fr_rsp_len;
                 sense_len = min(fcp_rsp->ext.fr_sns_len,
                                 (u32) SCSI_SENSE_BUFFERSIZE);
                 memcpy(scsi->sense_buffer, sense, sense_len);
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
index 9d1d7d1842ce..022fb6a8cb83 100644
--- a/drivers/s390/scsi/zfcp_fsf.c
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -18,12 +18,14 @@
 #include "zfcp_qdio.h"
 #include "zfcp_reqlist.h"
 
+struct kmem_cache *zfcp_fsf_qtcb_cache;
+
 static void zfcp_fsf_request_timeout_handler(unsigned long data)
 {
         struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
         zfcp_qdio_siosl(adapter);
         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                "fsrth_1", NULL);
+                                "fsrth_1");
 }
 
 static void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req,
@@ -61,50 +63,11 @@ static u32 fsf_qtcb_type[] = {
         [FSF_QTCB_UPLOAD_CONTROL_FILE] =  FSF_SUPPORT_COMMAND
 };
 
-static void zfcp_act_eval_err(struct zfcp_adapter *adapter, u32 table)
-{
-        u16 subtable = table >> 16;
-        u16 rule = table & 0xffff;
-        const char *act_type[] = { "unknown", "OS", "WWPN", "DID", "LUN" };
-
-        if (subtable && subtable < ARRAY_SIZE(act_type))
-                dev_warn(&adapter->ccw_device->dev,
-                         "Access denied according to ACT rule type %s, "
-                         "rule %d\n", act_type[subtable], rule);
-}
-
-static void zfcp_fsf_access_denied_port(struct zfcp_fsf_req *req,
-                                        struct zfcp_port *port)
-{
-        struct fsf_qtcb_header *header = &req->qtcb->header;
-        dev_warn(&req->adapter->ccw_device->dev,
-                 "Access denied to port 0x%016Lx\n",
-                 (unsigned long long)port->wwpn);
-        zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
-        zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
-        zfcp_erp_port_access_denied(port, "fspad_1", req);
-        req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-}
-
-static void zfcp_fsf_access_denied_unit(struct zfcp_fsf_req *req,
-                                        struct zfcp_unit *unit)
-{
-        struct fsf_qtcb_header *header = &req->qtcb->header;
-        dev_warn(&req->adapter->ccw_device->dev,
-                 "Access denied to unit 0x%016Lx on port 0x%016Lx\n",
-                 (unsigned long long)unit->fcp_lun,
-                 (unsigned long long)unit->port->wwpn);
-        zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
-        zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
-        zfcp_erp_unit_access_denied(unit, "fsuad_1", req);
-        req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-}
-
 static void zfcp_fsf_class_not_supp(struct zfcp_fsf_req *req)
 {
         dev_err(&req->adapter->ccw_device->dev, "FCP device not "
                 "operational because of an unsupported FC class\n");
-        zfcp_erp_adapter_shutdown(req->adapter, 0, "fscns_1", req);
+        zfcp_erp_adapter_shutdown(req->adapter, 0, "fscns_1");
         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 }
 
@@ -122,7 +85,7 @@ void zfcp_fsf_req_free(struct zfcp_fsf_req *req)
         }
 
         if (likely(req->qtcb))
-                kmem_cache_free(zfcp_data.qtcb_cache, req->qtcb);
+                kmem_cache_free(zfcp_fsf_qtcb_cache, req->qtcb);
         kfree(req);
 }
 
@@ -137,13 +100,13 @@ static void zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *req)
         read_lock_irqsave(&adapter->port_list_lock, flags);
         list_for_each_entry(port, &adapter->port_list, list)
                 if (port->d_id == d_id) {
-                        zfcp_erp_port_reopen(port, 0, "fssrpc1", req);
+                        zfcp_erp_port_reopen(port, 0, "fssrpc1");
                         break;
                 }
         read_unlock_irqrestore(&adapter->port_list_lock, flags);
 }
 
-static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req *req, char *id,
+static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req *req,
                                          struct fsf_link_down_info *link_down)
 {
         struct zfcp_adapter *adapter = req->adapter;
@@ -223,7 +186,7 @@ static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req *req, char *id,
                          "the FC fabric is down\n");
         }
 out:
-        zfcp_erp_adapter_failed(adapter, id, req);
+        zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
 }
 
 static void zfcp_fsf_status_read_link_down(struct zfcp_fsf_req *req)
@@ -234,13 +197,13 @@ static void zfcp_fsf_status_read_link_down(struct zfcp_fsf_req *req)
 
         switch (sr_buf->status_subtype) {
         case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK:
-                zfcp_fsf_link_down_info_eval(req, "fssrld1", ldi);
+                zfcp_fsf_link_down_info_eval(req, ldi);
                 break;
         case FSF_STATUS_READ_SUB_FDISC_FAILED:
-                zfcp_fsf_link_down_info_eval(req, "fssrld2", ldi);
+                zfcp_fsf_link_down_info_eval(req, ldi);
                 break;
         case FSF_STATUS_READ_SUB_FIRMWARE_UPDATE:
-                zfcp_fsf_link_down_info_eval(req, "fssrld3", NULL);
+                zfcp_fsf_link_down_info_eval(req, NULL);
         };
 }
 
@@ -250,13 +213,13 @@ static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
         struct fsf_status_read_buffer *sr_buf = req->data;
 
         if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
-                zfcp_dbf_hba_fsf_unsol("dism", adapter->dbf, sr_buf);
-                mempool_free(sr_buf, adapter->pool.status_read_data);
+                zfcp_dbf_hba_fsf_uss("fssrh_1", req);
+                mempool_free(virt_to_page(sr_buf), adapter->pool.sr_data);
                 zfcp_fsf_req_free(req);
                 return;
         }
 
-        zfcp_dbf_hba_fsf_unsol("read", adapter->dbf, sr_buf);
+        zfcp_dbf_hba_fsf_uss("fssrh_2", req);
 
         switch (sr_buf->status_type) {
         case FSF_STATUS_READ_PORT_CLOSED:
@@ -271,7 +234,7 @@ static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
                 dev_warn(&adapter->ccw_device->dev,
                          "The error threshold for checksum statistics "
                          "has been exceeded\n");
-                zfcp_dbf_hba_berr(adapter->dbf, req);
+                zfcp_dbf_hba_bit_err("fssrh_3", req);
                 break;
         case FSF_STATUS_READ_LINK_DOWN:
                 zfcp_fsf_status_read_link_down(req);
@@ -281,32 +244,30 @@ static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
                 dev_info(&adapter->ccw_device->dev,
                          "The local link has been restored\n");
                 /* All ports should be marked as ready to run again */
-                zfcp_erp_modify_adapter_status(adapter, "fssrh_1", NULL,
-                                               ZFCP_STATUS_COMMON_RUNNING,
-                                               ZFCP_SET);
+                zfcp_erp_set_adapter_status(adapter,
+                                            ZFCP_STATUS_COMMON_RUNNING);
                 zfcp_erp_adapter_reopen(adapter,
                                         ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
                                         ZFCP_STATUS_COMMON_ERP_FAILED,
-                                        "fssrh_2", req);
+                                        "fssrh_2");
                 zfcp_fc_enqueue_event(adapter, FCH_EVT_LINKUP, 0);
 
                 break;
         case FSF_STATUS_READ_NOTIFICATION_LOST:
                 if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_ACT_UPDATED)
-                        zfcp_erp_adapter_access_changed(adapter, "fssrh_3",
-                                                        req);
+                        zfcp_cfdc_adapter_access_changed(adapter);
                 if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_INCOMING_ELS)
                         queue_work(adapter->work_queue, &adapter->scan_work);
                 break;
         case FSF_STATUS_READ_CFDC_UPDATED:
-                zfcp_erp_adapter_access_changed(adapter, "fssrh_4", req);
+                zfcp_cfdc_adapter_access_changed(adapter);
                 break;
         case FSF_STATUS_READ_FEATURE_UPDATE_ALERT:
                 adapter->adapter_features = sr_buf->payload.word[0];
                 break;
         }
 
-        mempool_free(sr_buf, adapter->pool.status_read_data);
+        mempool_free(virt_to_page(sr_buf), adapter->pool.sr_data);
         zfcp_fsf_req_free(req);
 
         atomic_inc(&adapter->stat_miss);
@@ -328,7 +289,7 @@ static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *req)
                         "The FCP adapter reported a problem "
                         "that cannot be recovered\n");
                 zfcp_qdio_siosl(req->adapter);
-                zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfsqe1", req);
+                zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfsqe1");
                 break;
         }
         /* all non-return stats set FSFREQ_ERROR*/
@@ -345,7 +306,7 @@ static void zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *req)
                 dev_err(&req->adapter->ccw_device->dev,
                         "The FCP adapter does not recognize the command 0x%x\n",
                         req->qtcb->header.fsf_command);
-                zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfse_1", req);
+                zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfse_1");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -376,17 +337,17 @@ static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
                         "QTCB version 0x%x not supported by FCP adapter "
                         "(0x%x to 0x%x)\n", FSF_QTCB_CURRENT_VERSION,
                         psq->word[0], psq->word[1]);
-                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_1", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_1");
                 break;
         case FSF_PROT_ERROR_STATE:
         case FSF_PROT_SEQ_NUMB_ERROR:
-                zfcp_erp_adapter_reopen(adapter, 0, "fspse_2", req);
+                zfcp_erp_adapter_reopen(adapter, 0, "fspse_2");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_PROT_UNSUPP_QTCB_TYPE:
                 dev_err(&adapter->ccw_device->dev,
                         "The QTCB type is not supported by the FCP adapter\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_3", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_3");
                 break;
         case FSF_PROT_HOST_CONNECTION_INITIALIZING:
                 atomic_set_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
@@ -396,30 +357,28 @@ static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
                 dev_err(&adapter->ccw_device->dev,
                         "0x%Lx is an ambiguous request identifier\n",
                         (unsigned long long)qtcb->bottom.support.req_handle);
-                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_4", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_4");
                 break;
         case FSF_PROT_LINK_DOWN:
-                zfcp_fsf_link_down_info_eval(req, "fspse_5",
-                                             &psq->link_down_info);
+                zfcp_fsf_link_down_info_eval(req, &psq->link_down_info);
                 /* go through reopen to flush pending requests */
-                zfcp_erp_adapter_reopen(adapter, 0, "fspse_6", req);
+                zfcp_erp_adapter_reopen(adapter, 0, "fspse_6");
                 break;
         case FSF_PROT_REEST_QUEUE:
                 /* All ports should be marked as ready to run again */
-                zfcp_erp_modify_adapter_status(adapter, "fspse_7", NULL,
-                                               ZFCP_STATUS_COMMON_RUNNING,
-                                               ZFCP_SET);
+                zfcp_erp_set_adapter_status(adapter,
+                                            ZFCP_STATUS_COMMON_RUNNING);
                 zfcp_erp_adapter_reopen(adapter,
                                         ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
                                         ZFCP_STATUS_COMMON_ERP_FAILED,
-                                        "fspse_8", req);
+                                        "fspse_8");
                 break;
         default:
                 dev_err(&adapter->ccw_device->dev,
                         "0x%x is not a valid transfer protocol status\n",
                         qtcb->prefix.prot_status);
                 zfcp_qdio_siosl(adapter);
-                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_9", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_9");
         }
         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 }
@@ -525,7 +484,7 @@ static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *req)
                 dev_err(&adapter->ccw_device->dev,
                         "Unknown or unsupported arbitrated loop "
                         "fibre channel topology detected\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, "fsece_1", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fsece_1");
                 return -EIO;
         }
 
@@ -561,7 +520,7 @@ static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
                                 "FCP adapter maximum QTCB size (%d bytes) "
                                 "is too small\n",
                                 bottom->max_qtcb_size);
-                        zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh1", req);
+                        zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh1");
                         return;
                 }
                 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
@@ -575,14 +534,11 @@ static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
                 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
                 adapter->hydra_version = 0;
 
-                atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
-                                &adapter->status);
-
-                zfcp_fsf_link_down_info_eval(req, "fsecdh2",
+                zfcp_fsf_link_down_info_eval(req,
                         &qtcb->header.fsf_status_qual.link_down_info);
                 break;
         default:
-                zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh3", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh3");
                 return;
         }
 
@@ -598,14 +554,14 @@ static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
                 dev_err(&adapter->ccw_device->dev,
                         "The FCP adapter only supports newer "
                         "control block versions\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh4", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh4");
                 return;
         }
         if (FSF_QTCB_CURRENT_VERSION > bottom->high_qtcb_version) {
                 dev_err(&adapter->ccw_device->dev,
                         "The FCP adapter only supports older "
                         "control block versions\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh5", req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh5");
         }
 }
 
@@ -644,7 +600,7 @@ static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req)
                 break;
         case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
                 zfcp_fsf_exchange_port_evaluate(req);
-                zfcp_fsf_link_down_info_eval(req, "fsepdh1",
+                zfcp_fsf_link_down_info_eval(req,
                         &qtcb->header.fsf_status_qual.link_down_info);
                 break;
         }
@@ -674,7 +630,7 @@ static struct fsf_qtcb *zfcp_qtcb_alloc(mempool_t *pool)
         if (likely(pool))
                 qtcb = mempool_alloc(pool, GFP_ATOMIC);
         else
-                qtcb = kmem_cache_alloc(zfcp_data.qtcb_cache, GFP_ATOMIC);
+                qtcb = kmem_cache_alloc(zfcp_fsf_qtcb_cache, GFP_ATOMIC);
 
         if (unlikely(!qtcb))
                 return NULL;
@@ -684,7 +640,7 @@ static struct fsf_qtcb *zfcp_qtcb_alloc(mempool_t *pool)
 }
 
 static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_qdio *qdio,
-                                                u32 fsf_cmd, u32 sbtype,
+                                                u32 fsf_cmd, u8 sbtype,
                                                 mempool_t *pool)
 {
         struct zfcp_adapter *adapter = qdio->adapter;
@@ -746,7 +702,7 @@ static int zfcp_fsf_req_send(struct zfcp_fsf_req *req)
                 del_timer(&req->timer);
                 /* lookup request again, list might have changed */
                 zfcp_reqlist_find_rm(adapter->req_list, req_id);
-                zfcp_erp_adapter_reopen(adapter, 0, "fsrs__1", req);
+                zfcp_erp_adapter_reopen(adapter, 0, "fsrs__1");
                 return -EIO;
         }
 
@@ -769,9 +725,10 @@ int zfcp_fsf_status_read(struct zfcp_qdio *qdio)
         struct zfcp_adapter *adapter = qdio->adapter;
         struct zfcp_fsf_req *req;
         struct fsf_status_read_buffer *sr_buf;
+        struct page *page;
         int retval = -EIO;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out;
 
@@ -782,11 +739,12 @@ int zfcp_fsf_status_read(struct zfcp_qdio *qdio)
                 goto out;
         }
 
-        sr_buf = mempool_alloc(adapter->pool.status_read_data, GFP_ATOMIC);
-        if (!sr_buf) {
+        page = mempool_alloc(adapter->pool.sr_data, GFP_ATOMIC);
+        if (!page) {
                 retval = -ENOMEM;
                 goto failed_buf;
         }
+        sr_buf = page_address(page);
         memset(sr_buf, 0, sizeof(*sr_buf));
         req->data = sr_buf;
 
@@ -800,18 +758,20 @@ int zfcp_fsf_status_read(struct zfcp_qdio *qdio)
         goto out;
 
 failed_req_send:
-        mempool_free(sr_buf, adapter->pool.status_read_data);
+        req->data = NULL;
+        mempool_free(virt_to_page(sr_buf), adapter->pool.sr_data);
 failed_buf:
+        zfcp_dbf_hba_fsf_uss("fssr__1", req);
         zfcp_fsf_req_free(req);
-        zfcp_dbf_hba_fsf_unsol("fail", adapter->dbf, NULL);
 out:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return retval;
 }
 
 static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
 {
-        struct zfcp_unit *unit = req->data;
+        struct scsi_device *sdev = req->data;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
         union fsf_status_qual *fsq = &req->qtcb->header.fsf_status_qual;
 
         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
@@ -820,14 +780,14 @@ static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
         switch (req->qtcb->header.fsf_status) {
         case FSF_PORT_HANDLE_NOT_VALID:
                 if (fsq->word[0] == fsq->word[1]) {
-                        zfcp_erp_adapter_reopen(unit->port->adapter, 0,
-                                                "fsafch1", req);
+                        zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0,
+                                                "fsafch1");
                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 }
                 break;
         case FSF_LUN_HANDLE_NOT_VALID:
                 if (fsq->word[0] == fsq->word[1]) {
-                        zfcp_erp_port_reopen(unit->port, 0, "fsafch2", req);
+                        zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fsafch2");
                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 }
                 break;
@@ -835,17 +795,22 @@ static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
                 req->status |= ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED;
                 break;
         case FSF_PORT_BOXED:
-                zfcp_erp_port_boxed(unit->port, "fsafch3", req);
+                zfcp_erp_set_port_status(zfcp_sdev->port,
+                                         ZFCP_STATUS_COMMON_ACCESS_BOXED);
+                zfcp_erp_port_reopen(zfcp_sdev->port,
+                                     ZFCP_STATUS_COMMON_ERP_FAILED, "fsafch3");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_LUN_BOXED:
-                zfcp_erp_unit_boxed(unit, "fsafch4", req);
+                zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ACCESS_BOXED);
+                zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED,
+                                    "fsafch4");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
                 switch (fsq->word[0]) {
                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
-                        zfcp_fc_test_link(unit->port);
+                        zfcp_fc_test_link(zfcp_sdev->port);
                         /* fall through */
                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
@@ -859,39 +824,40 @@ static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
 }
 
 /**
- * zfcp_fsf_abort_fcp_command - abort running SCSI command
- * @old_req_id: unsigned long
- * @unit: pointer to struct zfcp_unit
+ * zfcp_fsf_abort_fcp_cmnd - abort running SCSI command
+ * @scmnd: The SCSI command to abort
  * Returns: pointer to struct zfcp_fsf_req
  */
 
-struct zfcp_fsf_req *zfcp_fsf_abort_fcp_command(unsigned long old_req_id,
-                                                struct zfcp_unit *unit)
+struct zfcp_fsf_req *zfcp_fsf_abort_fcp_cmnd(struct scsi_cmnd *scmnd)
 {
         struct zfcp_fsf_req *req = NULL;
-        struct zfcp_qdio *qdio = unit->port->adapter->qdio;
+        struct scsi_device *sdev = scmnd->device;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+        struct zfcp_qdio *qdio = zfcp_sdev->port->adapter->qdio;
+        unsigned long old_req_id = (unsigned long) scmnd->host_scribble;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out;
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_ABORT_FCP_CMND,
-                                  SBAL_FLAGS0_TYPE_READ,
+                                  SBAL_SFLAGS0_TYPE_READ,
                                   qdio->adapter->pool.scsi_abort);
         if (IS_ERR(req)) {
                 req = NULL;
                 goto out;
         }
 
-        if (unlikely(!(atomic_read(&unit->status) &
+        if (unlikely(!(atomic_read(&zfcp_sdev->status) &
                        ZFCP_STATUS_COMMON_UNBLOCKED)))
                 goto out_error_free;
 
         zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
 
-        req->data = unit;
+        req->data = sdev;
         req->handler = zfcp_fsf_abort_fcp_command_handler;
-        req->qtcb->header.lun_handle = unit->handle;
-        req->qtcb->header.port_handle = unit->port->handle;
+        req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
+        req->qtcb->header.port_handle = zfcp_sdev->port->handle;
         req->qtcb->bottom.support.req_handle = (u64) old_req_id;
 
         zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT);
@@ -902,7 +868,7 @@ out_error_free:
         zfcp_fsf_req_free(req);
         req = NULL;
 out:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return req;
 }
 
@@ -919,7 +885,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);
+                zfcp_dbf_san_res("fsscth1", req);
                 ct->status = 0;
                 break;
         case FSF_SERVICE_CLASS_NOT_SUPPORTED:
@@ -939,7 +905,7 @@ static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(adapter, 0, "fsscth1", req);
+                zfcp_erp_adapter_reopen(adapter, 0, "fsscth1");
                 /* fall through */
         case FSF_GENERIC_COMMAND_REJECTED:
         case FSF_PAYLOAD_SIZE_MISMATCH:
@@ -1041,12 +1007,12 @@ int zfcp_fsf_send_ct(struct zfcp_fc_wka_port *wka_port,
         struct zfcp_fsf_req *req;
         int ret = -EIO;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out;
 
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_SEND_GENERIC,
-                                  SBAL_FLAGS0_TYPE_WRITE_READ, pool);
+                                  SBAL_SFLAGS0_TYPE_WRITE_READ, pool);
 
         if (IS_ERR(req)) {
                 ret = PTR_ERR(req);
@@ -1062,7 +1028,7 @@ int zfcp_fsf_send_ct(struct zfcp_fc_wka_port *wka_port,
         req->qtcb->header.port_handle = wka_port->handle;
         req->data = ct;
 
-        zfcp_dbf_san_ct_request(req, wka_port->d_id);
+        zfcp_dbf_san_req("fssct_1", req, wka_port->d_id);
 
         ret = zfcp_fsf_req_send(req);
         if (ret)
@@ -1073,7 +1039,7 @@ int zfcp_fsf_send_ct(struct zfcp_fc_wka_port *wka_port,
 failed_send:
         zfcp_fsf_req_free(req);
 out:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return ret;
 }
 
@@ -1090,7 +1056,7 @@ static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req *req)
 
         switch (header->fsf_status) {
         case FSF_GOOD:
-                zfcp_dbf_san_els_response(req);
+                zfcp_dbf_san_res("fsselh1", req);
                 send_els->status = 0;
                 break;
         case FSF_SERVICE_CLASS_NOT_SUPPORTED:
@@ -1111,11 +1077,13 @@ static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req *req)
         case FSF_RESPONSE_SIZE_TOO_LARGE:
                 break;
         case FSF_ACCESS_DENIED:
-                if (port)
-                        zfcp_fsf_access_denied_port(req, port);
+                if (port) {
+                        zfcp_cfdc_port_denied(port, &header->fsf_status_qual);
+                        req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+                }
                 break;
         case FSF_SBAL_MISMATCH:
-                /* should never occure, avoided in zfcp_fsf_send_els */
+                /* should never occur, avoided in zfcp_fsf_send_els */
                 /* fall through */
         default:
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
@@ -1137,12 +1105,12 @@ int zfcp_fsf_send_els(struct zfcp_adapter *adapter, u32 d_id,
         struct zfcp_qdio *qdio = adapter->qdio;
         int ret = -EIO;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out;
 
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_SEND_ELS,
-                                  SBAL_FLAGS0_TYPE_WRITE_READ, NULL);
+                                  SBAL_SFLAGS0_TYPE_WRITE_READ, NULL);
 
         if (IS_ERR(req)) {
                 ret = PTR_ERR(req);
@@ -1162,7 +1130,7 @@ int zfcp_fsf_send_els(struct zfcp_adapter *adapter, u32 d_id,
         req->handler = zfcp_fsf_send_els_handler;
         req->data = els;
 
-        zfcp_dbf_san_els_request(req);
+        zfcp_dbf_san_req("fssels1", req, d_id);
 
         ret = zfcp_fsf_req_send(req);
         if (ret)
@@ -1173,7 +1141,7 @@ int zfcp_fsf_send_els(struct zfcp_adapter *adapter, u32 d_id,
 failed_send:
         zfcp_fsf_req_free(req);
 out:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return ret;
 }
 
@@ -1183,12 +1151,12 @@ int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
         struct zfcp_qdio *qdio = erp_action->adapter->qdio;
         int retval = -EIO;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out;
 
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_CONFIG_DATA,
-                                  SBAL_FLAGS0_TYPE_READ,
+                                  SBAL_SFLAGS0_TYPE_READ,
                                   qdio->adapter->pool.erp_req);
 
         if (IS_ERR(req)) {
@@ -1215,7 +1183,7 @@ int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
                 erp_action->fsf_req_id = 0;
         }
 out:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return retval;
 }
 
@@ -1225,12 +1193,12 @@ int zfcp_fsf_exchange_config_data_sync(struct zfcp_qdio *qdio,
         struct zfcp_fsf_req *req = NULL;
         int retval = -EIO;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out_unlock;
 
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_CONFIG_DATA,
-                                  SBAL_FLAGS0_TYPE_READ, NULL);
+                                  SBAL_SFLAGS0_TYPE_READ, NULL);
 
         if (IS_ERR(req)) {
                 retval = PTR_ERR(req);
@@ -1251,7 +1219,7 @@ int zfcp_fsf_exchange_config_data_sync(struct zfcp_qdio *qdio,
 
         zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
         retval = zfcp_fsf_req_send(req);
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         if (!retval)
                 wait_for_completion(&req->completion);
 
@@ -1259,7 +1227,7 @@ int zfcp_fsf_exchange_config_data_sync(struct zfcp_qdio *qdio,
         return retval;
 
 out_unlock:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return retval;
 }
 
@@ -1277,12 +1245,12 @@ int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action)
         if (!(qdio->adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
                 return -EOPNOTSUPP;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out;
 
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_PORT_DATA,
-                                  SBAL_FLAGS0_TYPE_READ,
+                                  SBAL_SFLAGS0_TYPE_READ,
                                   qdio->adapter->pool.erp_req);
 
         if (IS_ERR(req)) {
@@ -1304,7 +1272,7 @@ int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action)
                 erp_action->fsf_req_id = 0;
         }
 out:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return retval;
 }
 
@@ -1323,12 +1291,12 @@ int zfcp_fsf_exchange_port_data_sync(struct zfcp_qdio *qdio,
         if (!(qdio->adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT))
                 return -EOPNOTSUPP;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out_unlock;
 
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_EXCHANGE_PORT_DATA,
-                                  SBAL_FLAGS0_TYPE_READ, NULL);
+                                  SBAL_SFLAGS0_TYPE_READ, NULL);
 
         if (IS_ERR(req)) {
                 retval = PTR_ERR(req);
@@ -1343,7 +1311,7 @@ int zfcp_fsf_exchange_port_data_sync(struct zfcp_qdio *qdio,
         req->handler = zfcp_fsf_exchange_port_data_handler;
         zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
         retval = zfcp_fsf_req_send(req);
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
 
         if (!retval)
                 wait_for_completion(&req->completion);
@@ -1353,7 +1321,7 @@ int zfcp_fsf_exchange_port_data_sync(struct zfcp_qdio *qdio,
         return retval;
 
 out_unlock:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return retval;
 }
 
@@ -1370,14 +1338,16 @@ static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req)
         case FSF_PORT_ALREADY_OPEN:
                 break;
         case FSF_ACCESS_DENIED:
-                zfcp_fsf_access_denied_port(req, port);
+                zfcp_cfdc_port_denied(port, &header->fsf_status_qual);
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
                 dev_warn(&req->adapter->ccw_device->dev,
                          "Not enough FCP adapter resources to open "
                          "remote port 0x%016Lx\n",
                          (unsigned long long)port->wwpn);
-                zfcp_erp_port_failed(port, "fsoph_1", req);
+                zfcp_erp_set_port_status(port,
+                                         ZFCP_STATUS_COMMON_ERP_FAILED);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -1437,12 +1407,12 @@ int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
         struct zfcp_fsf_req *req;
         int retval = -EIO;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out;
 
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_OPEN_PORT_WITH_DID,
-                                  SBAL_FLAGS0_TYPE_READ,
+                                  SBAL_SFLAGS0_TYPE_READ,
                                   qdio->adapter->pool.erp_req);
 
         if (IS_ERR(req)) {
@@ -1468,7 +1438,7 @@ int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
                 put_device(&port->dev);
         }
 out:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return retval;
 }
 
@@ -1481,15 +1451,13 @@ static void zfcp_fsf_close_port_handler(struct zfcp_fsf_req *req)
 
         switch (req->qtcb->header.fsf_status) {
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(port->adapter, 0, "fscph_1", req);
+                zfcp_erp_adapter_reopen(port->adapter, 0, "fscph_1");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
                 break;
         case FSF_GOOD:
-                zfcp_erp_modify_port_status(port, "fscph_2", req,
-                                            ZFCP_STATUS_COMMON_OPEN,
-                                            ZFCP_CLEAR);
+                zfcp_erp_clear_port_status(port, ZFCP_STATUS_COMMON_OPEN);
                 break;
         }
 }
@@ -1505,12 +1473,12 @@ int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
         struct zfcp_fsf_req *req;
         int retval = -EIO;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out;
 
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_PORT,
-                                  SBAL_FLAGS0_TYPE_READ,
+                                  SBAL_SFLAGS0_TYPE_READ,
                                   qdio->adapter->pool.erp_req);
 
         if (IS_ERR(req)) {
@@ -1534,7 +1502,7 @@ int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
                 erp_action->fsf_req_id = 0;
         }
 out:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return retval;
 }
 
@@ -1580,15 +1548,15 @@ int zfcp_fsf_open_wka_port(struct zfcp_fc_wka_port *wka_port)
         struct zfcp_fsf_req *req;
         int retval = -EIO;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out;
 
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_OPEN_PORT_WITH_DID,
-                                  SBAL_FLAGS0_TYPE_READ,
+                                  SBAL_SFLAGS0_TYPE_READ,
                                   qdio->adapter->pool.erp_req);
 
-        if (unlikely(IS_ERR(req))) {
+        if (IS_ERR(req)) {
                 retval = PTR_ERR(req);
                 goto out;
         }
@@ -1605,7 +1573,7 @@ int zfcp_fsf_open_wka_port(struct zfcp_fc_wka_port *wka_port)
         if (retval)
                 zfcp_fsf_req_free(req);
 out:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return retval;
 }
 
@@ -1615,7 +1583,7 @@ static void zfcp_fsf_close_wka_port_handler(struct zfcp_fsf_req *req)
 
         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);
+                zfcp_erp_adapter_reopen(wka_port->adapter, 0, "fscwph1");
         }
 
         wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE;
@@ -1633,15 +1601,15 @@ int zfcp_fsf_close_wka_port(struct zfcp_fc_wka_port *wka_port)
         struct zfcp_fsf_req *req;
         int retval = -EIO;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out;
 
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_PORT,
-                                  SBAL_FLAGS0_TYPE_READ,
+                                  SBAL_SFLAGS0_TYPE_READ,
                                   qdio->adapter->pool.erp_req);
 
-        if (unlikely(IS_ERR(req))) {
+        if (IS_ERR(req)) {
                 retval = PTR_ERR(req);
                 goto out;
         }
@@ -1658,7 +1626,7 @@ int zfcp_fsf_close_wka_port(struct zfcp_fc_wka_port *wka_port)
         if (retval)
                 zfcp_fsf_req_free(req);
 out:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return retval;
 }
 
@@ -1666,29 +1634,30 @@ static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
 {
         struct zfcp_port *port = req->data;
         struct fsf_qtcb_header *header = &req->qtcb->header;
-        struct zfcp_unit *unit;
+        struct scsi_device *sdev;
 
         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
                 return;
 
         switch (header->fsf_status) {
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(port->adapter, 0, "fscpph1", req);
+                zfcp_erp_adapter_reopen(port->adapter, 0, "fscpph1");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ACCESS_DENIED:
-                zfcp_fsf_access_denied_port(req, port);
+                zfcp_cfdc_port_denied(port, &header->fsf_status_qual);
                 break;
         case FSF_PORT_BOXED:
                 /* 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);
-                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);
+                shost_for_each_device(sdev, port->adapter->scsi_host)
+                        if (sdev_to_zfcp(sdev)->port == port)
+                                atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
+                                                  &sdev_to_zfcp(sdev)->status);
+                zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ACCESS_BOXED);
+                zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED,
+                                     "fscpph2");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -1705,11 +1674,10 @@ 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);
-                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);
+                shost_for_each_device(sdev, port->adapter->scsi_host)
+                        if (sdev_to_zfcp(sdev)->port == port)
+                                atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
+                                                  &sdev_to_zfcp(sdev)->status);
                 break;
         }
 }
@@ -1725,12 +1693,12 @@ int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
         struct zfcp_fsf_req *req;
         int retval = -EIO;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out;
 
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_PHYSICAL_PORT,
-                                  SBAL_FLAGS0_TYPE_READ,
+                                  SBAL_SFLAGS0_TYPE_READ,
                                   qdio->adapter->pool.erp_req);
 
         if (IS_ERR(req)) {
@@ -1754,69 +1722,56 @@ int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
                 erp_action->fsf_req_id = 0;
         }
 out:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return retval;
 }
 
-static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
+static void zfcp_fsf_open_lun_handler(struct zfcp_fsf_req *req)
 {
         struct zfcp_adapter *adapter = req->adapter;
-        struct zfcp_unit *unit = req->data;
+        struct scsi_device *sdev = req->data;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
         struct fsf_qtcb_header *header = &req->qtcb->header;
         struct fsf_qtcb_bottom_support *bottom = &req->qtcb->bottom.support;
-        struct fsf_queue_designator *queue_designator =
-                                &header->fsf_status_qual.fsf_queue_designator;
-        int exclusive, readwrite;
 
         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
                 return;
 
         atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
                           ZFCP_STATUS_COMMON_ACCESS_BOXED |
-                          ZFCP_STATUS_UNIT_SHARED |
-                          ZFCP_STATUS_UNIT_READONLY,
-                          &unit->status);
+                          ZFCP_STATUS_LUN_SHARED |
+                          ZFCP_STATUS_LUN_READONLY,
+                          &zfcp_sdev->status);
 
         switch (header->fsf_status) {
 
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(unit->port->adapter, 0, "fsouh_1", req);
+                zfcp_erp_adapter_reopen(adapter, 0, "fsouh_1");
                 /* fall through */
         case FSF_LUN_ALREADY_OPEN:
                 break;
         case FSF_ACCESS_DENIED:
-                zfcp_fsf_access_denied_unit(req, unit);
-                atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
-                atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
+                zfcp_cfdc_lun_denied(sdev, &header->fsf_status_qual);
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_PORT_BOXED:
-                zfcp_erp_port_boxed(unit->port, "fsouh_2", req);
+                zfcp_erp_set_port_status(zfcp_sdev->port,
+                                         ZFCP_STATUS_COMMON_ACCESS_BOXED);
+                zfcp_erp_port_reopen(zfcp_sdev->port,
+                                     ZFCP_STATUS_COMMON_ERP_FAILED, "fsouh_2");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_LUN_SHARING_VIOLATION:
-                if (header->fsf_status_qual.word[0])
-                        dev_warn(&adapter->ccw_device->dev,
-                                 "LUN 0x%Lx on port 0x%Lx is already in "
-                                 "use by CSS%d, MIF Image ID %x\n",
-                                 (unsigned long long)unit->fcp_lun,
-                                 (unsigned long long)unit->port->wwpn,
-                                 queue_designator->cssid,
-                                 queue_designator->hla);
-                else
-                        zfcp_act_eval_err(adapter,
-                                          header->fsf_status_qual.word[2]);
-                zfcp_erp_unit_access_denied(unit, "fsouh_3", req);
-                atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
-                atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
+                zfcp_cfdc_lun_shrng_vltn(sdev, &header->fsf_status_qual);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED:
                 dev_warn(&adapter->ccw_device->dev,
                          "No handle is available for LUN "
                          "0x%016Lx on port 0x%016Lx\n",
-                         (unsigned long long)unit->fcp_lun,
-                         (unsigned long long)unit->port->wwpn);
-                zfcp_erp_unit_failed(unit, "fsouh_4", req);
+                         (unsigned long long)zfcp_scsi_dev_lun(sdev),
+                         (unsigned long long)zfcp_sdev->port->wwpn);
+                zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ERP_FAILED);
                 /* fall through */
         case FSF_INVALID_COMMAND_OPTION:
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
@@ -1824,7 +1779,7 @@ static void zfcp_fsf_open_unit_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:
-                        zfcp_fc_test_link(unit->port);
+                        zfcp_fc_test_link(zfcp_sdev->port);
                         /* fall through */
                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
@@ -1833,75 +1788,31 @@ static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
                 break;
 
         case FSF_GOOD:
-                unit->handle = header->lun_handle;
-                atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
-
-                if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE) &&
-                    (adapter->adapter_features & FSF_FEATURE_LUN_SHARING) &&
-                    !zfcp_ccw_priv_sch(adapter)) {
-                        exclusive = (bottom->lun_access_info &
-                                        FSF_UNIT_ACCESS_EXCLUSIVE);
-                        readwrite = (bottom->lun_access_info &
-                                        FSF_UNIT_ACCESS_OUTBOUND_TRANSFER);
-
-                        if (!exclusive)
-                                atomic_set_mask(ZFCP_STATUS_UNIT_SHARED,
-                                                &unit->status);
-
-                        if (!readwrite) {
-                                atomic_set_mask(ZFCP_STATUS_UNIT_READONLY,
-                                                &unit->status);
-                                dev_info(&adapter->ccw_device->dev,
-                                         "SCSI device at LUN 0x%016Lx on port "
-                                         "0x%016Lx opened read-only\n",
-                                         (unsigned long long)unit->fcp_lun,
-                                         (unsigned long long)unit->port->wwpn);
-                        }
-
-                        if (exclusive && !readwrite) {
-                                dev_err(&adapter->ccw_device->dev,
-                                        "Exclusive read-only access not "
-                                        "supported (unit 0x%016Lx, "
-                                        "port 0x%016Lx)\n",
-                                        (unsigned long long)unit->fcp_lun,
-                                        (unsigned long long)unit->port->wwpn);
-                                zfcp_erp_unit_failed(unit, "fsouh_5", req);
-                                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-                                zfcp_erp_unit_shutdown(unit, 0, "fsouh_6", req);
-                        } else if (!exclusive && readwrite) {
-                                dev_err(&adapter->ccw_device->dev,
-                                        "Shared read-write access not "
-                                        "supported (unit 0x%016Lx, port "
-                                        "0x%016Lx)\n",
-                                        (unsigned long long)unit->fcp_lun,
-                                        (unsigned long long)unit->port->wwpn);
-                                zfcp_erp_unit_failed(unit, "fsouh_7", req);
-                                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-                                zfcp_erp_unit_shutdown(unit, 0, "fsouh_8", req);
-                        }
-                }
+                zfcp_sdev->lun_handle = header->lun_handle;
+                atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &zfcp_sdev->status);
+                zfcp_cfdc_open_lun_eval(sdev, bottom);
                 break;
         }
 }
 
 /**
- * zfcp_fsf_open_unit - open unit
+ * zfcp_fsf_open_lun - open LUN
  * @erp_action: pointer to struct zfcp_erp_action
  * Returns: 0 on success, error otherwise
  */
-int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
+int zfcp_fsf_open_lun(struct zfcp_erp_action *erp_action)
 {
         struct zfcp_adapter *adapter = erp_action->adapter;
         struct zfcp_qdio *qdio = adapter->qdio;
         struct zfcp_fsf_req *req;
         int retval = -EIO;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out;
 
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_OPEN_LUN,
-                                  SBAL_FLAGS0_TYPE_READ,
+                                  SBAL_SFLAGS0_TYPE_READ,
                                   adapter->pool.erp_req);
 
         if (IS_ERR(req)) {
@@ -1913,9 +1824,9 @@ int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
         zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
 
         req->qtcb->header.port_handle = erp_action->port->handle;
-        req->qtcb->bottom.support.fcp_lun = erp_action->unit->fcp_lun;
-        req->handler = zfcp_fsf_open_unit_handler;
-        req->data = erp_action->unit;
+        req->qtcb->bottom.support.fcp_lun = zfcp_scsi_dev_lun(erp_action->sdev);
+        req->handler = zfcp_fsf_open_lun_handler;
+        req->data = erp_action->sdev;
         req->erp_action = erp_action;
         erp_action->fsf_req_id = req->req_id;
 
@@ -1929,34 +1840,38 @@ int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
                 erp_action->fsf_req_id = 0;
         }
 out:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return retval;
 }
 
-static void zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *req)
+static void zfcp_fsf_close_lun_handler(struct zfcp_fsf_req *req)
 {
-        struct zfcp_unit *unit = req->data;
+        struct scsi_device *sdev = req->data;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
 
         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
                 return;
 
         switch (req->qtcb->header.fsf_status) {
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(unit->port->adapter, 0, "fscuh_1", req);
+                zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0, "fscuh_1");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_LUN_HANDLE_NOT_VALID:
-                zfcp_erp_port_reopen(unit->port, 0, "fscuh_2", req);
+                zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fscuh_2");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_PORT_BOXED:
-                zfcp_erp_port_boxed(unit->port, "fscuh_3", req);
+                zfcp_erp_set_port_status(zfcp_sdev->port,
+                                         ZFCP_STATUS_COMMON_ACCESS_BOXED);
+                zfcp_erp_port_reopen(zfcp_sdev->port,
+                                     ZFCP_STATUS_COMMON_ERP_FAILED, "fscuh_3");
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
                 switch (req->qtcb->header.fsf_status_qual.word[0]) {
                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
-                        zfcp_fc_test_link(unit->port);
+                        zfcp_fc_test_link(zfcp_sdev->port);
                         /* fall through */
                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
@@ -1964,28 +1879,29 @@ static void zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *req)
                 }
                 break;
         case FSF_GOOD:
-                atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
+                atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, &zfcp_sdev->status);
                 break;
         }
 }
 
 /**
- * zfcp_fsf_close_unit - close zfcp unit
- * @erp_action: pointer to struct zfcp_unit
+ * zfcp_fsf_close_LUN - close LUN
+ * @erp_action: pointer to erp_action triggering the "close LUN"
  * Returns: 0 on success, error otherwise
  */
-int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
+int zfcp_fsf_close_lun(struct zfcp_erp_action *erp_action)
 {
         struct zfcp_qdio *qdio = erp_action->adapter->qdio;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
         struct zfcp_fsf_req *req;
         int retval = -EIO;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out;
 
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_CLOSE_LUN,
-                                  SBAL_FLAGS0_TYPE_READ,
+                                  SBAL_SFLAGS0_TYPE_READ,
                                   qdio->adapter->pool.erp_req);
 
         if (IS_ERR(req)) {
@@ -1997,9 +1913,9 @@ int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
         zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
 
         req->qtcb->header.port_handle = erp_action->port->handle;
-        req->qtcb->header.lun_handle = erp_action->unit->handle;
-        req->handler = zfcp_fsf_close_unit_handler;
-        req->data = erp_action->unit;
+        req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
+        req->handler = zfcp_fsf_close_lun_handler;
+        req->data = erp_action->sdev;
         req->erp_action = erp_action;
         erp_action->fsf_req_id = req->req_id;
 
@@ -2010,7 +1926,7 @@ int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
                 erp_action->fsf_req_id = 0;
         }
 out:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return retval;
 }
 
@@ -2025,7 +1941,7 @@ static void zfcp_fsf_req_trace(struct zfcp_fsf_req *req, struct scsi_cmnd *scsi)
 {
         struct fsf_qual_latency_info *lat_in;
         struct latency_cont *lat = NULL;
-        struct zfcp_unit *unit = req->unit;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scsi->device);
         struct zfcp_blk_drv_data blktrc;
         int ticks = req->adapter->timer_ticks;
 
@@ -2048,24 +1964,24 @@ static void zfcp_fsf_req_trace(struct zfcp_fsf_req *req, struct scsi_cmnd *scsi)
                 case FSF_DATADIR_DIF_READ_STRIP:
                 case FSF_DATADIR_DIF_READ_CONVERT:
                 case FSF_DATADIR_READ:
-                        lat = &unit->latencies.read;
+                        lat = &zfcp_sdev->latencies.read;
                         break;
                 case FSF_DATADIR_DIF_WRITE_INSERT:
                 case FSF_DATADIR_DIF_WRITE_CONVERT:
                 case FSF_DATADIR_WRITE:
-                        lat = &unit->latencies.write;
+                        lat = &zfcp_sdev->latencies.write;
                         break;
                 case FSF_DATADIR_CMND:
-                        lat = &unit->latencies.cmd;
+                        lat = &zfcp_sdev->latencies.cmd;
                         break;
                 }
 
                 if (lat) {
-                        spin_lock(&unit->latencies.lock);
+                        spin_lock(&zfcp_sdev->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);
+                        spin_unlock(&zfcp_sdev->latencies.lock);
                 }
         }
 
@@ -2073,7 +1989,79 @@ static void zfcp_fsf_req_trace(struct zfcp_fsf_req *req, struct scsi_cmnd *scsi)
                             sizeof(blktrc));
 }
 
-static void zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *req)
+static void zfcp_fsf_fcp_handler_common(struct zfcp_fsf_req *req)
+{
+        struct scsi_cmnd *scmnd = req->data;
+        struct scsi_device *sdev = scmnd->device;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+        struct fsf_qtcb_header *header = &req->qtcb->header;
+
+        if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
+                return;
+
+        switch (header->fsf_status) {
+        case FSF_HANDLE_MISMATCH:
+        case FSF_PORT_HANDLE_NOT_VALID:
+                zfcp_erp_adapter_reopen(zfcp_sdev->port->adapter, 0, "fssfch1");
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+                break;
+        case FSF_FCPLUN_NOT_VALID:
+        case FSF_LUN_HANDLE_NOT_VALID:
+                zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fssfch2");
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+                break;
+        case FSF_SERVICE_CLASS_NOT_SUPPORTED:
+                zfcp_fsf_class_not_supp(req);
+                break;
+        case FSF_ACCESS_DENIED:
+                zfcp_cfdc_lun_denied(sdev, &header->fsf_status_qual);
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+                break;
+        case FSF_DIRECTION_INDICATOR_NOT_VALID:
+                dev_err(&req->adapter->ccw_device->dev,
+                        "Incorrect direction %d, LUN 0x%016Lx on port "
+                        "0x%016Lx closed\n",
+                        req->qtcb->bottom.io.data_direction,
+                        (unsigned long long)zfcp_scsi_dev_lun(sdev),
+                        (unsigned long long)zfcp_sdev->port->wwpn);
+                zfcp_erp_adapter_shutdown(zfcp_sdev->port->adapter, 0,
+                                          "fssfch3");
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+                break;
+        case FSF_CMND_LENGTH_NOT_VALID:
+                dev_err(&req->adapter->ccw_device->dev,
+                        "Incorrect CDB length %d, LUN 0x%016Lx on "
+                        "port 0x%016Lx closed\n",
+                        req->qtcb->bottom.io.fcp_cmnd_length,
+                        (unsigned long long)zfcp_scsi_dev_lun(sdev),
+                        (unsigned long long)zfcp_sdev->port->wwpn);
+                zfcp_erp_adapter_shutdown(zfcp_sdev->port->adapter, 0,
+                                          "fssfch4");
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+                break;
+        case FSF_PORT_BOXED:
+                zfcp_erp_set_port_status(zfcp_sdev->port,
+                                         ZFCP_STATUS_COMMON_ACCESS_BOXED);
+                zfcp_erp_port_reopen(zfcp_sdev->port,
+                                     ZFCP_STATUS_COMMON_ERP_FAILED, "fssfch5");
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+                break;
+        case FSF_LUN_BOXED:
+                zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_ACCESS_BOXED);
+                zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED,
+                                    "fssfch6");
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+                break;
+        case FSF_ADAPTER_STATUS_AVAILABLE:
+                if (header->fsf_status_qual.word[0] ==
+                    FSF_SQ_INVOKE_LINK_TEST_PROCEDURE)
+                        zfcp_fc_test_link(zfcp_sdev->port);
+                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+                break;
+        }
+}
+
+static void zfcp_fsf_fcp_cmnd_handler(struct zfcp_fsf_req *req)
 {
         struct scsi_cmnd *scpnt;
         struct fcp_resp_with_ext *fcp_rsp;
@@ -2087,6 +2075,8 @@ static void zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *req)
                 return;
         }
 
+        zfcp_fsf_fcp_handler_common(req);
+
         if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
                 set_host_byte(scpnt, DID_TRANSPORT_DISRUPTED);
                 goto skip_fsfstatus;
@@ -2112,7 +2102,7 @@ static void zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *req)
 
 skip_fsfstatus:
         zfcp_fsf_req_trace(req, scpnt);
-        zfcp_dbf_scsi_result(req->adapter->dbf, scpnt, req);
+        zfcp_dbf_scsi_result(scpnt, req);
 
         scpnt->host_scribble = NULL;
         (scpnt->scsi_done) (scpnt);
@@ -2125,97 +2115,6 @@ skip_fsfstatus:
         read_unlock_irqrestore(&req->adapter->abort_lock, flags);
 }
 
-static void zfcp_fsf_send_fcp_ctm_handler(struct zfcp_fsf_req *req)
-{
-        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 ((rsp_info->rsp_code != FCP_TMF_CMPL) ||
-             (req->status & ZFCP_STATUS_FSFREQ_ERROR))
-                req->status |= ZFCP_STATUS_FSFREQ_TMFUNCFAILED;
-}
-
-
-static void zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *req)
-{
-        struct zfcp_unit *unit;
-        struct fsf_qtcb_header *header = &req->qtcb->header;
-
-        if (unlikely(req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT))
-                unit = req->data;
-        else
-                unit = req->unit;
-
-        if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
-                goto skip_fsfstatus;
-
-        switch (header->fsf_status) {
-        case FSF_HANDLE_MISMATCH:
-        case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(unit->port->adapter, 0, "fssfch1", req);
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-                break;
-        case FSF_FCPLUN_NOT_VALID:
-        case FSF_LUN_HANDLE_NOT_VALID:
-                zfcp_erp_port_reopen(unit->port, 0, "fssfch2", req);
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-                break;
-        case FSF_SERVICE_CLASS_NOT_SUPPORTED:
-                zfcp_fsf_class_not_supp(req);
-                break;
-        case FSF_ACCESS_DENIED:
-                zfcp_fsf_access_denied_unit(req, unit);
-                break;
-        case FSF_DIRECTION_INDICATOR_NOT_VALID:
-                dev_err(&req->adapter->ccw_device->dev,
-                        "Incorrect direction %d, unit 0x%016Lx on port "
-                        "0x%016Lx closed\n",
-                        req->qtcb->bottom.io.data_direction,
-                        (unsigned long long)unit->fcp_lun,
-                        (unsigned long long)unit->port->wwpn);
-                zfcp_erp_adapter_shutdown(unit->port->adapter, 0, "fssfch3",
-                                          req);
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-                break;
-        case FSF_CMND_LENGTH_NOT_VALID:
-                dev_err(&req->adapter->ccw_device->dev,
-                        "Incorrect CDB length %d, unit 0x%016Lx on "
-                        "port 0x%016Lx closed\n",
-                        req->qtcb->bottom.io.fcp_cmnd_length,
-                        (unsigned long long)unit->fcp_lun,
-                        (unsigned long long)unit->port->wwpn);
-                zfcp_erp_adapter_shutdown(unit->port->adapter, 0, "fssfch4",
-                                          req);
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-                break;
-        case FSF_PORT_BOXED:
-                zfcp_erp_port_boxed(unit->port, "fssfch5", req);
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-                break;
-        case FSF_LUN_BOXED:
-                zfcp_erp_unit_boxed(unit, "fssfch6", req);
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-                break;
-        case FSF_ADAPTER_STATUS_AVAILABLE:
-                if (header->fsf_status_qual.word[0] ==
-                    FSF_SQ_INVOKE_LINK_TEST_PROCEDURE)
-                        zfcp_fc_test_link(unit->port);
-                req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-                break;
-        }
-skip_fsfstatus:
-        if (req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)
-                zfcp_fsf_send_fcp_ctm_handler(req);
-        else {
-                zfcp_fsf_send_fcp_command_task_handler(req);
-                req->unit = NULL;
-                put_device(&unit->dev);
-        }
-}
-
 static int zfcp_fsf_set_data_dir(struct scsi_cmnd *scsi_cmnd, u32 *data_dir)
 {
         switch (scsi_get_prot_op(scsi_cmnd)) {
@@ -2255,33 +2154,34 @@ static int zfcp_fsf_set_data_dir(struct scsi_cmnd *scsi_cmnd, u32 *data_dir)
 }
 
 /**
- * zfcp_fsf_send_fcp_command_task - initiate an FCP command (for a SCSI command)
- * @unit: unit where command is sent to
+ * zfcp_fsf_fcp_cmnd - initiate an FCP command (for a SCSI command)
  * @scsi_cmnd: scsi command to be sent
  */
-int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
-                                   struct scsi_cmnd *scsi_cmnd)
+int zfcp_fsf_fcp_cmnd(struct scsi_cmnd *scsi_cmnd)
 {
         struct zfcp_fsf_req *req;
         struct fcp_cmnd *fcp_cmnd;
-        unsigned int sbtype = SBAL_FLAGS0_TYPE_READ;
+        u8 sbtype = SBAL_SFLAGS0_TYPE_READ;
         int real_bytes, retval = -EIO, dix_bytes = 0;
-        struct zfcp_adapter *adapter = unit->port->adapter;
+        struct scsi_device *sdev = scsi_cmnd->device;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+        struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
         struct zfcp_qdio *qdio = adapter->qdio;
         struct fsf_qtcb_bottom_io *io;
+        unsigned long flags;
 
-        if (unlikely(!(atomic_read(&unit->status) &
+        if (unlikely(!(atomic_read(&zfcp_sdev->status) &
                        ZFCP_STATUS_COMMON_UNBLOCKED)))
                 return -EBUSY;
 
-        spin_lock(&qdio->req_q_lock);
+        spin_lock_irqsave(&qdio->req_q_lock, flags);
         if (atomic_read(&qdio->req_q_free) <= 0) {
                 atomic_inc(&qdio->req_q_full);
                 goto out;
         }
 
         if (scsi_cmnd->sc_data_direction == DMA_TO_DEVICE)
-                sbtype = SBAL_FLAGS0_TYPE_WRITE;
+                sbtype = SBAL_SFLAGS0_TYPE_WRITE;
 
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_FCP_CMND,
                                   sbtype, adapter->pool.scsi_req);
@@ -2295,11 +2195,10 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
 
         io = &req->qtcb->bottom.io;
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        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->handler = zfcp_fsf_fcp_cmnd_handler;
+        req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
+        req->qtcb->header.port_handle = zfcp_sdev->port->handle;
         io->service_class = FSF_CLASS_3;
         io->fcp_cmnd_length = FCP_CMND_LEN;
 
@@ -2310,10 +2209,8 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
 
         zfcp_fsf_set_data_dir(scsi_cmnd, &io->data_direction);
 
-        get_device(&unit->dev);
-
         fcp_cmnd = (struct fcp_cmnd *) &req->qtcb->bottom.io.fcp_cmnd;
-        zfcp_fc_scsi_to_fcp(fcp_cmnd, scsi_cmnd);
+        zfcp_fc_scsi_to_fcp(fcp_cmnd, scsi_cmnd, 0);
 
         if (scsi_prot_sg_count(scsi_cmnd)) {
                 zfcp_qdio_set_data_div(qdio, &req->qdio_req,
@@ -2338,36 +2235,52 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
         goto out;
 
 failed_scsi_cmnd:
-        put_device(&unit->dev);
         zfcp_fsf_req_free(req);
         scsi_cmnd->host_scribble = NULL;
 out:
-        spin_unlock(&qdio->req_q_lock);
+        spin_unlock_irqrestore(&qdio->req_q_lock, flags);
         return retval;
 }
 
+static void zfcp_fsf_fcp_task_mgmt_handler(struct zfcp_fsf_req *req)
+{
+        struct fcp_resp_with_ext *fcp_rsp;
+        struct fcp_resp_rsp_info *rsp_info;
+
+        zfcp_fsf_fcp_handler_common(req);
+
+        fcp_rsp = (struct fcp_resp_with_ext *) &req->qtcb->bottom.io.fcp_rsp;
+        rsp_info = (struct fcp_resp_rsp_info *) &fcp_rsp[1];
+
+        if ((rsp_info->rsp_code != FCP_TMF_CMPL) ||
+             (req->status & ZFCP_STATUS_FSFREQ_ERROR))
+                req->status |= ZFCP_STATUS_FSFREQ_TMFUNCFAILED;
+}
+
 /**
- * zfcp_fsf_send_fcp_ctm - send SCSI task management command
- * @unit: pointer to struct zfcp_unit
+ * zfcp_fsf_fcp_task_mgmt - send SCSI task management command
+ * @scmnd: SCSI command to send the task management command for
  * @tm_flags: unsigned byte for task management flags
  * Returns: on success pointer to struct fsf_req, NULL otherwise
  */
-struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_unit *unit, u8 tm_flags)
+struct zfcp_fsf_req *zfcp_fsf_fcp_task_mgmt(struct scsi_cmnd *scmnd,
+                                            u8 tm_flags)
 {
         struct zfcp_fsf_req *req = NULL;
         struct fcp_cmnd *fcp_cmnd;
-        struct zfcp_qdio *qdio = unit->port->adapter->qdio;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scmnd->device);
+        struct zfcp_qdio *qdio = zfcp_sdev->port->adapter->qdio;
 
-        if (unlikely(!(atomic_read(&unit->status) &
+        if (unlikely(!(atomic_read(&zfcp_sdev->status) &
                        ZFCP_STATUS_COMMON_UNBLOCKED)))
                 return NULL;
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out;
 
         req = zfcp_fsf_req_create(qdio, FSF_QTCB_FCP_CMND,
-                                  SBAL_FLAGS0_TYPE_WRITE,
+                                  SBAL_SFLAGS0_TYPE_WRITE,
                                   qdio->adapter->pool.scsi_req);
 
         if (IS_ERR(req)) {
@@ -2375,11 +2288,10 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_unit *unit, u8 tm_flags)
                 goto out;
         }
 
-        req->status |= ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT;
-        req->data = unit;
-        req->handler = zfcp_fsf_send_fcp_command_handler;
-        req->qtcb->header.lun_handle = unit->handle;
-        req->qtcb->header.port_handle = unit->port->handle;
+        req->data = scmnd;
+        req->handler = zfcp_fsf_fcp_task_mgmt_handler;
+        req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
+        req->qtcb->header.port_handle = zfcp_sdev->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 = FCP_CMND_LEN;
@@ -2387,7 +2299,7 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_unit *unit, u8 tm_flags)
         zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
 
         fcp_cmnd = (struct fcp_cmnd *) &req->qtcb->bottom.io.fcp_cmnd;
-        zfcp_fc_fcp_tm(fcp_cmnd, unit->device, tm_flags);
+        zfcp_fc_scsi_to_fcp(fcp_cmnd, scmnd, tm_flags);
 
         zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT);
         if (!zfcp_fsf_req_send(req))
@@ -2396,7 +2308,7 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_unit *unit, u8 tm_flags)
         zfcp_fsf_req_free(req);
         req = NULL;
 out:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return req;
 }
 
@@ -2416,23 +2328,24 @@ struct zfcp_fsf_req *zfcp_fsf_control_file(struct zfcp_adapter *adapter,
         struct zfcp_qdio *qdio = adapter->qdio;
         struct zfcp_fsf_req *req = NULL;
         struct fsf_qtcb_bottom_support *bottom;
-        int direction, retval = -EIO, bytes;
+        int retval = -EIO, bytes;
+        u8 direction;
 
         if (!(adapter->adapter_features & FSF_FEATURE_CFDC))
                 return ERR_PTR(-EOPNOTSUPP);
 
         switch (fsf_cfdc->command) {
         case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
-                direction = SBAL_FLAGS0_TYPE_WRITE;
+                direction = SBAL_SFLAGS0_TYPE_WRITE;
                 break;
         case FSF_QTCB_UPLOAD_CONTROL_FILE:
-                direction = SBAL_FLAGS0_TYPE_READ;
+                direction = SBAL_SFLAGS0_TYPE_READ;
                 break;
         default:
                 return ERR_PTR(-EINVAL);
         }
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
                 goto out;
 
@@ -2459,7 +2372,7 @@ struct zfcp_fsf_req *zfcp_fsf_control_file(struct zfcp_adapter *adapter,
         zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT);
         retval = zfcp_fsf_req_send(req);
 out:
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
 
         if (!retval) {
                 wait_for_completion(&req->completion);
@@ -2501,7 +2414,16 @@ void zfcp_fsf_reqid_check(struct zfcp_qdio *qdio, int sbal_idx)
                 fsf_req->qdio_req.sbal_response = sbal_idx;
                 zfcp_fsf_req_complete(fsf_req);
 
-                if (likely(sbale->flags & SBAL_FLAGS_LAST_ENTRY))
+                if (likely(sbale->eflags & SBAL_EFLAGS_LAST_ENTRY))
                         break;
         }
 }
+
+struct zfcp_fsf_req *zfcp_fsf_get_req(struct zfcp_qdio *qdio,
+                                      struct qdio_buffer *sbal)
+{
+        struct qdio_buffer_element *sbale = &sbal->element[0];
+        u64 req_id = (unsigned long) sbale->addr;
+
+        return zfcp_reqlist_find(qdio->adapter->req_list, req_id);
+}
diff --git a/drivers/s390/scsi/zfcp_qdio.c b/drivers/s390/scsi/zfcp_qdio.c
index b2635759721c..d9c40ea73eef 100644
--- a/drivers/s390/scsi/zfcp_qdio.c
+++ b/drivers/s390/scsi/zfcp_qdio.c
@@ -41,7 +41,7 @@ static void zfcp_qdio_handler_error(struct zfcp_qdio *qdio, char *id,
                 zfcp_qdio_siosl(adapter);
         zfcp_erp_adapter_reopen(adapter,
                                 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
-                                ZFCP_STATUS_COMMON_ERP_FAILED, id, NULL);
+                                ZFCP_STATUS_COMMON_ERP_FAILED, id);
 }
 
 static void zfcp_qdio_zero_sbals(struct qdio_buffer *sbal[], int first, int cnt)
@@ -60,13 +60,11 @@ static inline void zfcp_qdio_account(struct zfcp_qdio *qdio)
         unsigned long long now, span;
         int used;
 
-        spin_lock(&qdio->stat_lock);
         now = get_clock_monotonic();
         span = (now - qdio->req_q_time) >> 12;
         used = QDIO_MAX_BUFFERS_PER_Q - atomic_read(&qdio->req_q_free);
         qdio->req_q_util += used * span;
         qdio->req_q_time = now;
-        spin_unlock(&qdio->stat_lock);
 }
 
 static void zfcp_qdio_int_req(struct ccw_device *cdev, unsigned int qdio_err,
@@ -76,7 +74,6 @@ static void zfcp_qdio_int_req(struct ccw_device *cdev, unsigned int qdio_err,
         struct zfcp_qdio *qdio = (struct zfcp_qdio *) parm;
 
         if (unlikely(qdio_err)) {
-                zfcp_dbf_hba_qdio(qdio->adapter->dbf, qdio_err, idx, count);
                 zfcp_qdio_handler_error(qdio, "qdireq1", qdio_err);
                 return;
         }
@@ -84,7 +81,9 @@ static void zfcp_qdio_int_req(struct ccw_device *cdev, unsigned int qdio_err,
         /* cleanup all SBALs being program-owned now */
         zfcp_qdio_zero_sbals(qdio->req_q, idx, count);
 
+        spin_lock_irq(&qdio->stat_lock);
         zfcp_qdio_account(qdio);
+        spin_unlock_irq(&qdio->stat_lock);
         atomic_add(count, &qdio->req_q_free);
         wake_up(&qdio->req_q_wq);
 }
@@ -97,7 +96,6 @@ static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err,
         int sbal_idx, sbal_no;
 
         if (unlikely(qdio_err)) {
-                zfcp_dbf_hba_qdio(qdio->adapter->dbf, qdio_err, idx, count);
                 zfcp_qdio_handler_error(qdio, "qdires1", qdio_err);
                 return;
         }
@@ -116,7 +114,7 @@ static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err,
          * put SBALs back to response queue
          */
         if (do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, idx, count))
-                zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdires2", NULL);
+                zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdires2");
 }
 
 static struct qdio_buffer_element *
@@ -126,7 +124,7 @@ zfcp_qdio_sbal_chain(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req)
 
         /* set last entry flag in current SBALE of current SBAL */
         sbale = zfcp_qdio_sbale_curr(qdio, q_req);
-        sbale->flags |= SBAL_FLAGS_LAST_ENTRY;
+        sbale->eflags |= SBAL_EFLAGS_LAST_ENTRY;
 
         /* don't exceed last allowed SBAL */
         if (q_req->sbal_last == q_req->sbal_limit)
@@ -134,7 +132,7 @@ zfcp_qdio_sbal_chain(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req)
 
         /* set chaining flag in first SBALE of current SBAL */
         sbale = zfcp_qdio_sbale_req(qdio, q_req);
-        sbale->flags |= SBAL_FLAGS0_MORE_SBALS;
+        sbale->sflags |= SBAL_SFLAGS0_MORE_SBALS;
 
         /* calculate index of next SBAL */
         q_req->sbal_last++;
@@ -149,7 +147,7 @@ zfcp_qdio_sbal_chain(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req)
 
         /* set storage-block type for new SBAL */
         sbale = zfcp_qdio_sbale_curr(qdio, q_req);
-        sbale->flags |= q_req->sbtype;
+        sbale->sflags |= q_req->sbtype;
 
         return sbale;
 }
@@ -179,7 +177,7 @@ int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req,
 
         /* set storage-block type for this request */
         sbale = zfcp_qdio_sbale_req(qdio, q_req);
-        sbale->flags |= q_req->sbtype;
+        sbale->sflags |= q_req->sbtype;
 
         for (; sg; sg = sg_next(sg)) {
                 sbale = zfcp_qdio_sbale_next(qdio, q_req);
@@ -201,11 +199,11 @@ int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req,
 
 static int zfcp_qdio_sbal_check(struct zfcp_qdio *qdio)
 {
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         if (atomic_read(&qdio->req_q_free) ||
             !(atomic_read(&qdio->adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP))
                 return 1;
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         return 0;
 }
 
@@ -223,7 +221,7 @@ int zfcp_qdio_sbal_get(struct zfcp_qdio *qdio)
 {
         long ret;
 
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
         ret = wait_event_interruptible_timeout(qdio->req_q_wq,
                                zfcp_qdio_sbal_check(qdio), 5 * HZ);
 
@@ -236,10 +234,10 @@ int zfcp_qdio_sbal_get(struct zfcp_qdio *qdio)
         if (!ret) {
                 atomic_inc(&qdio->req_q_full);
                 /* assume hanging outbound queue, try queue recovery */
-                zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdsbg_1", NULL);
+                zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdsbg_1");
         }
 
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         return -EIO;
 }
 
@@ -254,7 +252,9 @@ int zfcp_qdio_send(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req)
         int retval;
         u8 sbal_number = q_req->sbal_number;
 
+        spin_lock(&qdio->stat_lock);
         zfcp_qdio_account(qdio);
+        spin_unlock(&qdio->stat_lock);
 
         retval = do_QDIO(qdio->adapter->ccw_device, QDIO_FLAG_SYNC_OUTPUT, 0,
                          q_req->sbal_first, sbal_number);
@@ -277,16 +277,12 @@ int zfcp_qdio_send(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req)
 static void zfcp_qdio_setup_init_data(struct qdio_initialize *id,
                                       struct zfcp_qdio *qdio)
 {
-
+        memset(id, 0, sizeof(*id));
         id->cdev = qdio->adapter->ccw_device;
         id->q_format = QDIO_ZFCP_QFMT;
         memcpy(id->adapter_name, dev_name(&id->cdev->dev), 8);
         ASCEBC(id->adapter_name, 8);
         id->qib_rflags = QIB_RFLAGS_ENABLE_DATA_DIV;
-        id->qib_param_field_format = 0;
-        id->qib_param_field = NULL;
-        id->input_slib_elements = NULL;
-        id->output_slib_elements = NULL;
         id->no_input_qs = 1;
         id->no_output_qs = 1;
         id->input_handler = zfcp_qdio_int_resp;
@@ -294,6 +290,8 @@ static void zfcp_qdio_setup_init_data(struct qdio_initialize *id,
         id->int_parm = (unsigned long) qdio;
         id->input_sbal_addr_array = (void **) (qdio->res_q);
         id->output_sbal_addr_array = (void **) (qdio->req_q);
+        id->scan_threshold =
+                QDIO_MAX_BUFFERS_PER_Q - ZFCP_QDIO_MAX_SBALS_PER_REQ * 2;
 }
 
 /**
@@ -311,6 +309,7 @@ static int zfcp_qdio_allocate(struct zfcp_qdio *qdio)
                 return -ENOMEM;
 
         zfcp_qdio_setup_init_data(&init_data, qdio);
+        init_waitqueue_head(&qdio->req_q_wq);
 
         return qdio_allocate(&init_data);
 }
@@ -328,9 +327,9 @@ void zfcp_qdio_close(struct zfcp_qdio *qdio)
                 return;
 
         /* clear QDIOUP flag, thus do_QDIO is not called during qdio_shutdown */
-        spin_lock_bh(&qdio->req_q_lock);
+        spin_lock_irq(&qdio->req_q_lock);
         atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
-        spin_unlock_bh(&qdio->req_q_lock);
+        spin_unlock_irq(&qdio->req_q_lock);
 
         wake_up(&qdio->req_q_wq);
 
@@ -385,16 +384,18 @@ int zfcp_qdio_open(struct zfcp_qdio *qdio)
         for (cc = 0; cc < QDIO_MAX_BUFFERS_PER_Q; cc++) {
                 sbale = &(qdio->res_q[cc]->element[0]);
                 sbale->length = 0;
-                sbale->flags = SBAL_FLAGS_LAST_ENTRY;
+                sbale->eflags = SBAL_EFLAGS_LAST_ENTRY;
+                sbale->sflags = 0;
                 sbale->addr = NULL;
         }
 
         if (do_QDIO(cdev, QDIO_FLAG_SYNC_INPUT, 0, 0, QDIO_MAX_BUFFERS_PER_Q))
                 goto failed_qdio;
 
-        /* set index of first avalable SBALS / number of available SBALS */
+        /* set index of first available SBALS / number of available SBALS */
         qdio->req_q_idx = 0;
         atomic_set(&qdio->req_q_free, QDIO_MAX_BUFFERS_PER_Q);
+        atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &qdio->adapter->status);
 
         return 0;
 
diff --git a/drivers/s390/scsi/zfcp_qdio.h b/drivers/s390/scsi/zfcp_qdio.h
index 2297d8d3e947..54e22ace012b 100644
--- a/drivers/s390/scsi/zfcp_qdio.h
+++ b/drivers/s390/scsi/zfcp_qdio.h
@@ -67,7 +67,7 @@ struct zfcp_qdio {
  * @qdio_outb_usage: usage of outbound queue
  */
 struct zfcp_qdio_req {
-        u32     sbtype;
+        u8      sbtype;
         u8      sbal_number;
         u8      sbal_first;
         u8      sbal_last;
@@ -116,7 +116,7 @@ zfcp_qdio_sbale_curr(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req)
  */
 static inline
 void zfcp_qdio_req_init(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req,
-                        unsigned long req_id, u32 sbtype, void *data, u32 len)
+                        unsigned long req_id, u8 sbtype, void *data, u32 len)
 {
         struct qdio_buffer_element *sbale;
         int count = min(atomic_read(&qdio->req_q_free),
@@ -131,7 +131,8 @@ void zfcp_qdio_req_init(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req,
 
         sbale = zfcp_qdio_sbale_req(qdio, q_req);
         sbale->addr = (void *) req_id;
-        sbale->flags = SBAL_FLAGS0_COMMAND | sbtype;
+        sbale->eflags = 0;
+        sbale->sflags = SBAL_SFLAGS0_COMMAND | sbtype;
 
         if (unlikely(!data))
                 return;
@@ -173,7 +174,7 @@ void zfcp_qdio_set_sbale_last(struct zfcp_qdio *qdio,
         struct qdio_buffer_element *sbale;
 
         sbale = zfcp_qdio_sbale_curr(qdio, q_req);
-        sbale->flags |= SBAL_FLAGS_LAST_ENTRY;
+        sbale->eflags |= SBAL_EFLAGS_LAST_ENTRY;
 }
 
 /**
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
index cb000c9833bb..2a4991d6d4d5 100644
--- a/drivers/s390/scsi/zfcp_scsi.c
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -30,6 +30,10 @@ module_param_named(dif, enable_dif, bool, 0600);
 MODULE_PARM_DESC(dif, "Enable DIF/DIX data integrity support");
 #endif
 
+static bool allow_lun_scan = 1;
+module_param(allow_lun_scan, bool, 0600);
+MODULE_PARM_DESC(allow_lun_scan, "For NPIV, scan and attach all storage LUNs");
+
 static int zfcp_scsi_change_queue_depth(struct scsi_device *sdev, int depth,
                                         int reason)
 {
@@ -49,11 +53,12 @@ static int zfcp_scsi_change_queue_depth(struct scsi_device *sdev, int depth,
         return sdev->queue_depth;
 }
 
-static void zfcp_scsi_slave_destroy(struct scsi_device *sdpnt)
+static void zfcp_scsi_slave_destroy(struct scsi_device *sdev)
 {
-        struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata;
-        unit->device = NULL;
-        put_device(&unit->dev);
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+
+        zfcp_erp_lun_shutdown_wait(sdev, "scssd_1");
+        put_device(&zfcp_sdev->port->dev);
 }
 
 static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
@@ -67,47 +72,35 @@ static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
 
 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);
-        zfcp_dbf_scsi_fail_send(adapter->dbf, scpnt);
+        zfcp_dbf_scsi_fail_send(scpnt);
         scpnt->scsi_done(scpnt);
 }
 
-static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
-                                  void (*done) (struct scsi_cmnd *))
+static
+int zfcp_scsi_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scpnt)
 {
-        struct zfcp_unit *unit;
-        struct zfcp_adapter *adapter;
-        int    status, scsi_result, ret;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scpnt->device);
         struct fc_rport *rport = starget_to_rport(scsi_target(scpnt->device));
+        int    status, scsi_result, ret;
 
         /* reset the status for this request */
         scpnt->result = 0;
         scpnt->host_scribble = NULL;
-        scpnt->scsi_done = done;
-
-        /*
-         * figure out adapter and target device
-         * (stored there by zfcp_scsi_slave_alloc)
-         */
-        adapter = (struct zfcp_adapter *) scpnt->device->host->hostdata[0];
-        unit = scpnt->device->hostdata;
 
         scsi_result = fc_remote_port_chkready(rport);
         if (unlikely(scsi_result)) {
                 scpnt->result = scsi_result;
-                zfcp_dbf_scsi_fail_send(adapter->dbf, scpnt);
+                zfcp_dbf_scsi_fail_send(scpnt);
                 scpnt->scsi_done(scpnt);
                 return 0;
         }
 
-        status = atomic_read(&unit->status);
+        status = atomic_read(&zfcp_sdev->status);
         if (unlikely(status & ZFCP_STATUS_COMMON_ERP_FAILED) &&
-                     !(atomic_read(&unit->port->status) &
+                     !(atomic_read(&zfcp_sdev->port->status) &
                        ZFCP_STATUS_COMMON_ERP_FAILED)) {
-                /* only unit access denied, but port is good
+                /* only LUN access denied, but port is good
                  * not covered by FC transport, have to fail here */
                 zfcp_scsi_command_fail(scpnt, DID_ERROR);
                 return 0;
@@ -115,8 +108,8 @@ static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
 
         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
+                 * open LUN pending: this is temporary, will result in
+                 *      open LUN or ERP_FAILED, so retry command
                  * call to rport_delete pending: mimic retry from
                  *      fc_remote_port_chkready until rport is BLOCKED
                  */
@@ -124,7 +117,7 @@ static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
                 return 0;
         }
 
-        ret = zfcp_fsf_send_fcp_command_task(unit, scpnt);
+        ret = zfcp_fsf_fcp_cmnd(scpnt);
         if (unlikely(ret == -EBUSY))
                 return SCSI_MLQUEUE_DEVICE_BUSY;
         else if (unlikely(ret < 0))
@@ -133,45 +126,43 @@ static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
         return ret;
 }
 
-static struct zfcp_unit *zfcp_unit_lookup(struct zfcp_adapter *adapter,
-                                          unsigned int id, u64 lun)
+static int zfcp_scsi_slave_alloc(struct scsi_device *sdev)
 {
-        unsigned long flags;
+        struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
+        struct zfcp_adapter *adapter =
+                (struct zfcp_adapter *) sdev->host->hostdata[0];
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
         struct zfcp_port *port;
-        struct zfcp_unit *unit = NULL;
+        struct zfcp_unit *unit;
+        int npiv = adapter->connection_features & FSF_FEATURE_NPIV_MODE;
 
-        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;
-                unit = zfcp_get_unit_by_lun(port, lun);
-                if (unit)
-                        break;
-        }
-        read_unlock_irqrestore(&adapter->port_list_lock, flags);
+        port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
+        if (!port)
+                return -ENXIO;
 
-        return unit;
-}
+        unit = zfcp_unit_find(port, zfcp_scsi_dev_lun(sdev));
+        if (unit)
+                put_device(&unit->dev);
 
-static int zfcp_scsi_slave_alloc(struct scsi_device *sdp)
-{
-        struct zfcp_adapter *adapter;
-        struct zfcp_unit *unit;
-        u64 lun;
+        if (!unit && !(allow_lun_scan && npiv)) {
+                put_device(&port->dev);
+                return -ENXIO;
+        }
 
-        adapter = (struct zfcp_adapter *) sdp->host->hostdata[0];
-        if (!adapter)
-                goto out;
+        zfcp_sdev->port = port;
+        zfcp_sdev->latencies.write.channel.min = 0xFFFFFFFF;
+        zfcp_sdev->latencies.write.fabric.min = 0xFFFFFFFF;
+        zfcp_sdev->latencies.read.channel.min = 0xFFFFFFFF;
+        zfcp_sdev->latencies.read.fabric.min = 0xFFFFFFFF;
+        zfcp_sdev->latencies.cmd.channel.min = 0xFFFFFFFF;
+        zfcp_sdev->latencies.cmd.fabric.min = 0xFFFFFFFF;
+        spin_lock_init(&zfcp_sdev->latencies.lock);
 
-        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;
-                return 0;
-        }
-out:
-        return -ENXIO;
+        zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_RUNNING);
+        zfcp_erp_lun_reopen(sdev, 0, "scsla_1");
+        zfcp_erp_wait(port->adapter);
+
+        return 0;
 }
 
 static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
@@ -179,7 +170,6 @@ static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
         struct Scsi_Host *scsi_host = scpnt->device->host;
         struct zfcp_adapter *adapter =
                 (struct zfcp_adapter *) scsi_host->hostdata[0];
-        struct zfcp_unit *unit = scpnt->device->hostdata;
         struct zfcp_fsf_req *old_req, *abrt_req;
         unsigned long flags;
         unsigned long old_reqid = (unsigned long) scpnt->host_scribble;
@@ -193,8 +183,7 @@ static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
         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,
-                                    old_reqid);
+                zfcp_dbf_scsi_abort("abrt_or", scpnt, NULL);
                 return FAILED; /* completion could be in progress */
         }
         old_req->data = NULL;
@@ -203,49 +192,52 @@ static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
         write_unlock_irqrestore(&adapter->abort_lock, flags);
 
         while (retry--) {
-                abrt_req = zfcp_fsf_abort_fcp_command(old_reqid, unit);
+                abrt_req = zfcp_fsf_abort_fcp_cmnd(scpnt);
                 if (abrt_req)
                         break;
 
                 zfcp_erp_wait(adapter);
                 ret = fc_block_scsi_eh(scpnt);
-                if (ret)
+                if (ret) {
+                        zfcp_dbf_scsi_abort("abrt_bl", scpnt, NULL);
                         return ret;
+                }
                 if (!(atomic_read(&adapter->status) &
                       ZFCP_STATUS_COMMON_RUNNING)) {
-                        zfcp_dbf_scsi_abort("nres", adapter->dbf, scpnt, NULL,
-                                            old_reqid);
+                        zfcp_dbf_scsi_abort("abrt_ru", scpnt, NULL);
                         return SUCCESS;
                 }
         }
-        if (!abrt_req)
+        if (!abrt_req) {
+                zfcp_dbf_scsi_abort("abrt_ar", scpnt, NULL);
                 return FAILED;
+        }
 
         wait_for_completion(&abrt_req->completion);
 
         if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED)
-                dbf_tag = "okay";
+                dbf_tag = "abrt_ok";
         else if (abrt_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED)
-                dbf_tag = "lte2";
+                dbf_tag = "abrt_nn";
         else {
-                dbf_tag = "fail";
+                dbf_tag = "abrt_fa";
                 retval = FAILED;
         }
-        zfcp_dbf_scsi_abort(dbf_tag, adapter->dbf, scpnt, abrt_req, old_reqid);
+        zfcp_dbf_scsi_abort(dbf_tag, scpnt, abrt_req);
         zfcp_fsf_req_free(abrt_req);
         return retval;
 }
 
 static int zfcp_task_mgmt_function(struct scsi_cmnd *scpnt, u8 tm_flags)
 {
-        struct zfcp_unit *unit = scpnt->device->hostdata;
-        struct zfcp_adapter *adapter = unit->port->adapter;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scpnt->device);
+        struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
         struct zfcp_fsf_req *fsf_req = NULL;
         int retval = SUCCESS, ret;
         int retry = 3;
 
         while (retry--) {
-                fsf_req = zfcp_fsf_send_fcp_ctm(unit, tm_flags);
+                fsf_req = zfcp_fsf_fcp_task_mgmt(scpnt, tm_flags);
                 if (fsf_req)
                         break;
 
@@ -256,7 +248,7 @@ static int zfcp_task_mgmt_function(struct scsi_cmnd *scpnt, u8 tm_flags)
 
                 if (!(atomic_read(&adapter->status) &
                       ZFCP_STATUS_COMMON_RUNNING)) {
-                        zfcp_dbf_scsi_devreset("nres", tm_flags, unit, scpnt);
+                        zfcp_dbf_scsi_devreset("nres", scpnt, tm_flags);
                         return SUCCESS;
                 }
         }
@@ -266,10 +258,10 @@ static int zfcp_task_mgmt_function(struct scsi_cmnd *scpnt, u8 tm_flags)
         wait_for_completion(&fsf_req->completion);
 
         if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCFAILED) {
-                zfcp_dbf_scsi_devreset("fail", tm_flags, unit, scpnt);
+                zfcp_dbf_scsi_devreset("fail", scpnt, tm_flags);
                 retval = FAILED;
         } else
-                zfcp_dbf_scsi_devreset("okay", tm_flags, unit, scpnt);
+                zfcp_dbf_scsi_devreset("okay", scpnt, tm_flags);
 
         zfcp_fsf_req_free(fsf_req);
         return retval;
@@ -287,11 +279,11 @@ static int zfcp_scsi_eh_target_reset_handler(struct scsi_cmnd *scpnt)
 
 static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
 {
-        struct zfcp_unit *unit = scpnt->device->hostdata;
-        struct zfcp_adapter *adapter = unit->port->adapter;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scpnt->device);
+        struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
         int ret;
 
-        zfcp_erp_adapter_reopen(adapter, 0, "schrh_1", scpnt);
+        zfcp_erp_adapter_reopen(adapter, 0, "schrh_1");
         zfcp_erp_wait(adapter);
         ret = fc_block_scsi_eh(scpnt);
         if (ret)
@@ -300,7 +292,37 @@ static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
         return SUCCESS;
 }
 
-int zfcp_adapter_scsi_register(struct zfcp_adapter *adapter)
+struct scsi_transport_template *zfcp_scsi_transport_template;
+
+static struct scsi_host_template zfcp_scsi_host_template = {
+        .module                  = THIS_MODULE,
+        .name                    = "zfcp",
+        .queuecommand            = zfcp_scsi_queuecommand,
+        .eh_abort_handler        = zfcp_scsi_eh_abort_handler,
+        .eh_device_reset_handler = zfcp_scsi_eh_device_reset_handler,
+        .eh_target_reset_handler = zfcp_scsi_eh_target_reset_handler,
+        .eh_host_reset_handler   = zfcp_scsi_eh_host_reset_handler,
+        .slave_alloc             = zfcp_scsi_slave_alloc,
+        .slave_configure         = zfcp_scsi_slave_configure,
+        .slave_destroy           = zfcp_scsi_slave_destroy,
+        .change_queue_depth      = zfcp_scsi_change_queue_depth,
+        .proc_name               = "zfcp",
+        .can_queue               = 4096,
+        .this_id                 = -1,
+        .sg_tablesize            = ZFCP_QDIO_MAX_SBALES_PER_REQ,
+        .max_sectors             = (ZFCP_QDIO_MAX_SBALES_PER_REQ * 8),
+        .dma_boundary            = ZFCP_QDIO_SBALE_LEN - 1,
+        .cmd_per_lun             = 1,
+        .use_clustering          = 1,
+        .shost_attrs             = zfcp_sysfs_shost_attrs,
+        .sdev_attrs              = zfcp_sysfs_sdev_attrs,
+};
+
+/**
+ * zfcp_scsi_adapter_register - Register SCSI and FC host with SCSI midlayer
+ * @adapter: The zfcp adapter to register with the SCSI midlayer
+ */
+int zfcp_scsi_adapter_register(struct zfcp_adapter *adapter)
 {
         struct ccw_dev_id dev_id;
 
@@ -309,7 +331,7 @@ int zfcp_adapter_scsi_register(struct zfcp_adapter *adapter)
 
         ccw_device_get_id(adapter->ccw_device, &dev_id);
         /* register adapter as SCSI host with mid layer of SCSI stack */
-        adapter->scsi_host = scsi_host_alloc(&zfcp_data.scsi_host_template,
+        adapter->scsi_host = scsi_host_alloc(&zfcp_scsi_host_template,
                                              sizeof (struct zfcp_adapter *));
         if (!adapter->scsi_host) {
                 dev_err(&adapter->ccw_device->dev,
@@ -319,12 +341,12 @@ int zfcp_adapter_scsi_register(struct zfcp_adapter *adapter)
         }
 
         /* tell the SCSI stack some characteristics of this adapter */
-        adapter->scsi_host->max_id = 1;
-        adapter->scsi_host->max_lun = 1;
+        adapter->scsi_host->max_id = 511;
+        adapter->scsi_host->max_lun = 0xFFFFFFFF;
         adapter->scsi_host->max_channel = 0;
         adapter->scsi_host->unique_id = dev_id.devno;
         adapter->scsi_host->max_cmd_len = 16; /* in struct fcp_cmnd */
-        adapter->scsi_host->transportt = zfcp_data.scsi_transport_template;
+        adapter->scsi_host->transportt = zfcp_scsi_transport_template;
 
         adapter->scsi_host->hostdata[0] = (unsigned long) adapter;
 
@@ -336,7 +358,11 @@ int zfcp_adapter_scsi_register(struct zfcp_adapter *adapter)
         return 0;
 }
 
-void zfcp_adapter_scsi_unregister(struct zfcp_adapter *adapter)
+/**
+ * zfcp_scsi_adapter_unregister - Unregister SCSI and FC host from SCSI midlayer
+ * @adapter: The zfcp adapter to unregister.
+ */
+void zfcp_scsi_adapter_unregister(struct zfcp_adapter *adapter)
 {
         struct Scsi_Host *shost;
         struct zfcp_port *port;
@@ -354,8 +380,6 @@ void zfcp_adapter_scsi_unregister(struct zfcp_adapter *adapter)
         scsi_remove_host(shost);
         scsi_host_put(shost);
         adapter->scsi_host = NULL;
-
-        return;
 }
 
 static struct fc_host_statistics*
@@ -529,25 +553,11 @@ static void zfcp_scsi_terminate_rport_io(struct fc_rport *rport)
         port = zfcp_get_port_by_wwpn(adapter, rport->port_name);
 
         if (port) {
-                zfcp_erp_port_forced_reopen(port, 0, "sctrpi1", NULL);
+                zfcp_erp_port_forced_reopen(port, 0, "sctrpi1");
                 put_device(&port->dev);
         }
 }
 
-static void zfcp_scsi_queue_unit_register(struct zfcp_port *port)
-{
-        struct zfcp_unit *unit;
-
-        read_lock_irq(&port->unit_list_lock);
-        list_for_each_entry(unit, &port->unit_list, list) {
-                get_device(&unit->dev);
-                if (scsi_queue_work(port->adapter->scsi_host,
-                                    &unit->scsi_work) <= 0)
-                        put_device(&unit->dev);
-        }
-        read_unlock_irq(&port->unit_list_lock);
-}
-
 static void zfcp_scsi_rport_register(struct zfcp_port *port)
 {
         struct fc_rport_identifiers ids;
@@ -574,7 +584,7 @@ static void zfcp_scsi_rport_register(struct zfcp_port *port)
         port->rport = rport;
         port->starget_id = rport->scsi_target_id;
 
-        zfcp_scsi_queue_unit_register(port);
+        zfcp_unit_queue_scsi_scan(port);
 }
 
 static void zfcp_scsi_rport_block(struct zfcp_port *port)
@@ -638,29 +648,6 @@ void zfcp_scsi_rport_work(struct work_struct *work)
 }
 
 /**
- * zfcp_scsi_scan - Register LUN with SCSI midlayer
- * @unit: The LUN/unit to register
- */
-void zfcp_scsi_scan(struct zfcp_unit *unit)
-{
-        struct fc_rport *rport = unit->port->rport;
-
-        if (rport && rport->port_state == FC_PORTSTATE_ONLINE)
-                scsi_scan_target(&rport->dev, 0, rport->scsi_target_id,
-                                 scsilun_to_int((struct scsi_lun *)
-                                                &unit->fcp_lun), 0);
-}
-
-void zfcp_scsi_scan_work(struct work_struct *work)
-{
-        struct zfcp_unit *unit = container_of(work, struct zfcp_unit,
-                                              scsi_work);
-
-        zfcp_scsi_scan(unit);
-        put_device(&unit->dev);
-}
-
-/**
  * zfcp_scsi_set_prot - Configure DIF/DIX support in scsi_host
  * @adapter: The adapter where to configure DIF/DIX for the SCSI host
  */
@@ -681,6 +668,7 @@ void zfcp_scsi_set_prot(struct zfcp_adapter *adapter)
             adapter->adapter_features & FSF_FEATURE_DIX_PROT_TCPIP) {
                 mask |= SHOST_DIX_TYPE1_PROTECTION;
                 scsi_host_set_guard(shost, SHOST_DIX_GUARD_IP);
+                shost->sg_prot_tablesize = ZFCP_QDIO_MAX_SBALES_PER_REQ / 2;
                 shost->sg_tablesize = ZFCP_QDIO_MAX_SBALES_PER_REQ / 2;
                 shost->max_sectors = ZFCP_QDIO_MAX_SBALES_PER_REQ * 8 / 2;
         }
@@ -732,34 +720,8 @@ struct fc_function_template zfcp_transport_functions = {
         /* no functions registered for following dynamic attributes but
            directly set by LLDD */
         .show_host_port_type = 1,
+        .show_host_symbolic_name = 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 = {
-        .scsi_host_template = {
-                .name                    = "zfcp",
-                .module                  = THIS_MODULE,
-                .proc_name               = "zfcp",
-                .change_queue_depth      = zfcp_scsi_change_queue_depth,
-                .slave_alloc             = zfcp_scsi_slave_alloc,
-                .slave_configure         = zfcp_scsi_slave_configure,
-                .slave_destroy           = zfcp_scsi_slave_destroy,
-                .queuecommand            = zfcp_scsi_queuecommand,
-                .eh_abort_handler        = zfcp_scsi_eh_abort_handler,
-                .eh_device_reset_handler = zfcp_scsi_eh_device_reset_handler,
-                .eh_target_reset_handler = zfcp_scsi_eh_target_reset_handler,
-                .eh_host_reset_handler   = zfcp_scsi_eh_host_reset_handler,
-                .can_queue               = 4096,
-                .this_id                 = -1,
-                .sg_tablesize            = ZFCP_QDIO_MAX_SBALES_PER_REQ,
-                .cmd_per_lun             = 1,
-                .use_clustering          = 1,
-                .sdev_attrs              = zfcp_sysfs_sdev_attrs,
-                .max_sectors             = (ZFCP_QDIO_MAX_SBALES_PER_REQ * 8),
-                .dma_boundary            = ZFCP_QDIO_SBALE_LEN - 1,
-                .shost_attrs             = zfcp_sysfs_shost_attrs,
-        },
-};
diff --git a/drivers/s390/scsi/zfcp_sysfs.c b/drivers/s390/scsi/zfcp_sysfs.c
index b4561c86e230..cdc4ff78a7ba 100644
--- a/drivers/s390/scsi/zfcp_sysfs.c
+++ b/drivers/s390/scsi/zfcp_sysfs.c
@@ -68,63 +68,95 @@ ZFCP_DEFINE_ATTR(zfcp_port, port, access_denied, "%d\n",
                   ZFCP_STATUS_COMMON_ACCESS_DENIED) != 0);
 
 ZFCP_DEFINE_ATTR(zfcp_unit, unit, status, "0x%08x\n",
-                 atomic_read(&unit->status));
+                 zfcp_unit_sdev_status(unit));
 ZFCP_DEFINE_ATTR(zfcp_unit, unit, in_recovery, "%d\n",
-                 (atomic_read(&unit->status) &
+                 (zfcp_unit_sdev_status(unit) &
                   ZFCP_STATUS_COMMON_ERP_INUSE) != 0);
 ZFCP_DEFINE_ATTR(zfcp_unit, unit, access_denied, "%d\n",
-                 (atomic_read(&unit->status) &
+                 (zfcp_unit_sdev_status(unit) &
                   ZFCP_STATUS_COMMON_ACCESS_DENIED) != 0);
 ZFCP_DEFINE_ATTR(zfcp_unit, unit, access_shared, "%d\n",
-                 (atomic_read(&unit->status) &
-                  ZFCP_STATUS_UNIT_SHARED) != 0);
+                 (zfcp_unit_sdev_status(unit) &
+                  ZFCP_STATUS_LUN_SHARED) != 0);
 ZFCP_DEFINE_ATTR(zfcp_unit, unit, access_readonly, "%d\n",
-                 (atomic_read(&unit->status) &
-                  ZFCP_STATUS_UNIT_READONLY) != 0);
+                 (zfcp_unit_sdev_status(unit) &
+                  ZFCP_STATUS_LUN_READONLY) != 0);
 
-#define ZFCP_SYSFS_FAILED(_feat_def, _feat, _adapter, _mod_id, _reopen_id)     \
-static ssize_t zfcp_sysfs_##_feat##_failed_show(struct device *dev,            \
-                                                struct device_attribute *attr, \
-                                                char *buf)                     \
-{                                                                              \
-        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");                                    \
-        else                                                                   \
-                return sprintf(buf, "0\n");                                    \
-}                                                                              \
-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 = container_of(dev, struct _feat_def, dev);    \
-        unsigned long val;                                                     \
-        int retval = 0;                                                        \
-                                                                               \
-        if (!(_feat && get_device(&_feat->dev)))                               \
-                return -EBUSY;                                                 \
-                                                                               \
-        if (strict_strtoul(buf, 0, &val) || val != 0) {                        \
-                retval = -EINVAL;                                              \
-                goto out;                                                      \
-        }                                                                      \
-                                                                               \
-        zfcp_erp_modify_##_feat##_status(_feat, _mod_id, NULL,                 \
-                                         ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);\
-        zfcp_erp_##_feat##_reopen(_feat, ZFCP_STATUS_COMMON_ERP_FAILED,        \
-                                  _reopen_id, NULL);                           \
-        zfcp_erp_wait(_adapter);                                               \
-out:                                                                           \
-        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);
+static ssize_t zfcp_sysfs_port_failed_show(struct device *dev,
+                                           struct device_attribute *attr,
+                                           char *buf)
+{
+        struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
+
+        if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
+                return sprintf(buf, "1\n");
+
+        return sprintf(buf, "0\n");
+}
+
+static ssize_t zfcp_sysfs_port_failed_store(struct device *dev,
+                                            struct device_attribute *attr,
+                                            const char *buf, size_t count)
+{
+        struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
+        unsigned long val;
+
+        if (strict_strtoul(buf, 0, &val) || val != 0)
+                return -EINVAL;
+
+        zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_RUNNING);
+        zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, "sypfai2");
+        zfcp_erp_wait(port->adapter);
 
-ZFCP_SYSFS_FAILED(zfcp_port, port, port->adapter, "sypfai1", "sypfai2");
-ZFCP_SYSFS_FAILED(zfcp_unit, unit, unit->port->adapter, "syufai1", "syufai2");
+        return count;
+}
+static ZFCP_DEV_ATTR(port, failed, S_IWUSR | S_IRUGO,
+                     zfcp_sysfs_port_failed_show,
+                     zfcp_sysfs_port_failed_store);
+
+static ssize_t zfcp_sysfs_unit_failed_show(struct device *dev,
+                                           struct device_attribute *attr,
+                                           char *buf)
+{
+        struct zfcp_unit *unit = container_of(dev, struct zfcp_unit, dev);
+        struct scsi_device *sdev;
+        unsigned int status, failed = 1;
+
+        sdev = zfcp_unit_sdev(unit);
+        if (sdev) {
+                status = atomic_read(&sdev_to_zfcp(sdev)->status);
+                failed = status & ZFCP_STATUS_COMMON_ERP_FAILED ? 1 : 0;
+                scsi_device_put(sdev);
+        }
+
+        return sprintf(buf, "%d\n", failed);
+}
+
+static ssize_t zfcp_sysfs_unit_failed_store(struct device *dev,
+                                            struct device_attribute *attr,
+                                            const char *buf, size_t count)
+{
+        struct zfcp_unit *unit = container_of(dev, struct zfcp_unit, dev);
+        unsigned long val;
+        struct scsi_device *sdev;
+
+        if (strict_strtoul(buf, 0, &val) || val != 0)
+                return -EINVAL;
+
+        sdev = zfcp_unit_sdev(unit);
+        if (sdev) {
+                zfcp_erp_set_lun_status(sdev, ZFCP_STATUS_COMMON_RUNNING);
+                zfcp_erp_lun_reopen(sdev, ZFCP_STATUS_COMMON_ERP_FAILED,
+                                    "syufai2");
+                zfcp_erp_wait(unit->port->adapter);
+        } else
+                zfcp_unit_scsi_scan(unit);
+
+        return count;
+}
+static ZFCP_DEV_ATTR(unit, failed, S_IWUSR | S_IRUGO,
+                     zfcp_sysfs_unit_failed_show,
+                     zfcp_sysfs_unit_failed_store);
 
 static ssize_t zfcp_sysfs_adapter_failed_show(struct device *dev,
                                               struct device_attribute *attr,
@@ -163,10 +195,9 @@ static ssize_t zfcp_sysfs_adapter_failed_store(struct device *dev,
                 goto out;
         }
 
-        zfcp_erp_modify_adapter_status(adapter, "syafai1", NULL,
-                                       ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
+        zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
-                                "syafai2", NULL);
+                                "syafai2");
         zfcp_erp_wait(adapter);
 out:
         zfcp_ccw_adapter_put(adapter);
@@ -224,7 +255,7 @@ static ssize_t zfcp_sysfs_port_remove_store(struct device *dev,
 
         put_device(&port->dev);
 
-        zfcp_erp_port_shutdown(port, 0, "syprs_1", NULL);
+        zfcp_erp_port_shutdown(port, 0, "syprs_1");
         zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs);
  out:
         zfcp_ccw_adapter_put(adapter);
@@ -257,28 +288,15 @@ static ssize_t zfcp_sysfs_unit_add_store(struct device *dev,
                                          const char *buf, size_t count)
 {
         struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
-        struct zfcp_unit *unit;
         u64 fcp_lun;
-        int retval = -EINVAL;
-
-        if (!(port && get_device(&port->dev)))
-                return -EBUSY;
 
         if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun))
-                goto out;
+                return -EINVAL;
 
-        unit = zfcp_unit_enqueue(port, fcp_lun);
-        if (IS_ERR(unit))
-                goto out;
-        else
-                retval = 0;
+        if (zfcp_unit_add(port, fcp_lun))
+                return -EINVAL;
 
-        zfcp_erp_unit_reopen(unit, 0, "syuas_1", NULL);
-        zfcp_erp_wait(unit->port->adapter);
-        zfcp_scsi_scan(unit);
-out:
-        put_device(&port->dev);
-        return retval ? retval : (ssize_t) count;
+        return count;
 }
 static DEVICE_ATTR(unit_add, S_IWUSR, NULL, zfcp_sysfs_unit_add_store);
 
@@ -287,42 +305,15 @@ static ssize_t zfcp_sysfs_unit_remove_store(struct device *dev,
                                             const char *buf, size_t count)
 {
         struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
-        struct zfcp_unit *unit;
         u64 fcp_lun;
-        int retval = -EINVAL;
-        struct scsi_device *sdev;
-
-        if (!(port && get_device(&port->dev)))
-                return -EBUSY;
 
         if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun))
-                goto out;
+                return -EINVAL;
 
-        unit = zfcp_get_unit_by_lun(port, fcp_lun);
-        if (!unit)
-                goto out;
-        else
-                retval = 0;
-
-        sdev = scsi_device_lookup(port->adapter->scsi_host, 0,
-                                  port->starget_id,
-                                  scsilun_to_int((struct scsi_lun *)&fcp_lun));
-        if (sdev) {
-                scsi_remove_device(sdev);
-                scsi_device_put(sdev);
-        }
-
-        write_lock_irq(&port->unit_list_lock);
-        list_del(&unit->list);
-        write_unlock_irq(&port->unit_list_lock);
-
-        put_device(&unit->dev);
+        if (zfcp_unit_remove(port, fcp_lun))
+                return -EINVAL;
 
-        zfcp_erp_unit_shutdown(unit, 0, "syurs_1", NULL);
-        zfcp_device_unregister(&unit->dev, &zfcp_sysfs_unit_attrs);
-out:
-        put_device(&port->dev);
-        return retval ? retval : (ssize_t) count;
+        return count;
 }
 static DEVICE_ATTR(unit_remove, S_IWUSR, NULL, zfcp_sysfs_unit_remove_store);
 
@@ -363,9 +354,9 @@ zfcp_sysfs_unit_##_name##_latency_show(struct device *dev,		\
                                        struct device_attribute *attr,   \
                                        char *buf) {                     \
         struct scsi_device *sdev = to_scsi_device(dev);                 \
-        struct zfcp_unit *unit = sdev->hostdata;                        \
-        struct zfcp_latencies *lat = &unit->latencies;                  \
-        struct zfcp_adapter *adapter = unit->port->adapter;             \
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);           \
+        struct zfcp_latencies *lat = &zfcp_sdev->latencies;             \
+        struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;        \
         unsigned long long fsum, fmin, fmax, csum, cmin, cmax, cc;      \
                                                                         \
         spin_lock_bh(&lat->lock);                                       \
@@ -394,8 +385,8 @@ zfcp_sysfs_unit_##_name##_latency_store(struct device *dev,		\
                                         const char *buf, size_t count)  \
 {                                                                       \
         struct scsi_device *sdev = to_scsi_device(dev);                 \
-        struct zfcp_unit *unit = sdev->hostdata;                        \
-        struct zfcp_latencies *lat = &unit->latencies;                  \
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);           \
+        struct zfcp_latencies *lat = &zfcp_sdev->latencies;             \
         unsigned long flags;                                            \
                                                                         \
         spin_lock_irqsave(&lat->lock, flags);                           \
@@ -423,19 +414,28 @@ static ssize_t zfcp_sysfs_scsi_##_name##_show(struct device *dev,	\
                                               struct device_attribute *attr,\
                                               char *buf)                 \
 {                                                                        \
-        struct scsi_device *sdev  = to_scsi_device(dev);                 \
-        struct zfcp_unit *unit = sdev->hostdata;                         \
+        struct scsi_device *sdev = to_scsi_device(dev);                  \
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);            \
+        struct zfcp_port *port = zfcp_sdev->port;                        \
                                                                          \
         return sprintf(buf, _format, _value);                            \
 }                                                                        \
 static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_scsi_##_name##_show, NULL);
 
 ZFCP_DEFINE_SCSI_ATTR(hba_id, "%s\n",
-                      dev_name(&unit->port->adapter->ccw_device->dev));
+                      dev_name(&port->adapter->ccw_device->dev));
 ZFCP_DEFINE_SCSI_ATTR(wwpn, "0x%016llx\n",
-                      (unsigned long long) unit->port->wwpn);
-ZFCP_DEFINE_SCSI_ATTR(fcp_lun, "0x%016llx\n",
-                      (unsigned long long) unit->fcp_lun);
+                      (unsigned long long) port->wwpn);
+
+static ssize_t zfcp_sysfs_scsi_fcp_lun_show(struct device *dev,
+                                            struct device_attribute *attr,
+                                            char *buf)
+{
+        struct scsi_device *sdev = to_scsi_device(dev);
+
+        return sprintf(buf, "0x%016llx\n", zfcp_scsi_dev_lun(sdev));
+}
+static DEVICE_ATTR(fcp_lun, S_IRUGO, zfcp_sysfs_scsi_fcp_lun_show, NULL);
 
 struct device_attribute *zfcp_sysfs_sdev_attrs[] = {
         &dev_attr_fcp_lun,
diff --git a/drivers/s390/scsi/zfcp_unit.c b/drivers/s390/scsi/zfcp_unit.c
new file mode 100644
index 000000000000..20796ebc33ce
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_unit.c
@@ -0,0 +1,244 @@
+/*
+ * zfcp device driver
+ *
+ * Tracking of manually configured LUNs and helper functions to
+ * register the LUNs with the SCSI midlayer.
+ *
+ * Copyright IBM Corporation 2010
+ */
+
+#include "zfcp_def.h"
+#include "zfcp_ext.h"
+
+/**
+ * zfcp_unit_scsi_scan - Register LUN with SCSI midlayer
+ * @unit: The zfcp LUN/unit to register
+ *
+ * When the SCSI midlayer is not allowed to automatically scan and
+ * attach SCSI devices, zfcp has to register the single devices with
+ * the SCSI midlayer.
+ */
+void zfcp_unit_scsi_scan(struct zfcp_unit *unit)
+{
+        struct fc_rport *rport = unit->port->rport;
+        unsigned int lun;
+
+        lun = scsilun_to_int((struct scsi_lun *) &unit->fcp_lun);
+
+        if (rport && rport->port_state == FC_PORTSTATE_ONLINE)
+                scsi_scan_target(&rport->dev, 0, rport->scsi_target_id, lun, 1);
+}
+
+static void zfcp_unit_scsi_scan_work(struct work_struct *work)
+{
+        struct zfcp_unit *unit = container_of(work, struct zfcp_unit,
+                                              scsi_work);
+
+        zfcp_unit_scsi_scan(unit);
+        put_device(&unit->dev);
+}
+
+/**
+ * zfcp_unit_queue_scsi_scan - Register configured units on port
+ * @port: The zfcp_port where to register units
+ *
+ * After opening a port, all units configured on this port have to be
+ * registered with the SCSI midlayer. This function should be called
+ * after calling fc_remote_port_add, so that the fc_rport is already
+ * ONLINE and the call to scsi_scan_target runs the same way as the
+ * call in the FC transport class.
+ */
+void zfcp_unit_queue_scsi_scan(struct zfcp_port *port)
+{
+        struct zfcp_unit *unit;
+
+        read_lock_irq(&port->unit_list_lock);
+        list_for_each_entry(unit, &port->unit_list, list) {
+                get_device(&unit->dev);
+                if (scsi_queue_work(port->adapter->scsi_host,
+                                    &unit->scsi_work) <= 0)
+                        put_device(&unit->dev);
+        }
+        read_unlock_irq(&port->unit_list_lock);
+}
+
+static struct zfcp_unit *_zfcp_unit_find(struct zfcp_port *port, u64 fcp_lun)
+{
+        struct zfcp_unit *unit;
+
+        list_for_each_entry(unit, &port->unit_list, list)
+                if (unit->fcp_lun == fcp_lun) {
+                        get_device(&unit->dev);
+                        return unit;
+                }
+
+        return NULL;
+}
+
+/**
+ * zfcp_unit_find - Find and return zfcp_unit with specified FCP LUN
+ * @port: zfcp_port where to look for the unit
+ * @fcp_lun: 64 Bit FCP LUN used to identify the zfcp_unit
+ *
+ * If zfcp_unit is found, a reference is acquired that has to be
+ * released later.
+ *
+ * Returns: Pointer to the zfcp_unit, or NULL if there is no zfcp_unit
+ *          with the specified FCP LUN.
+ */
+struct zfcp_unit *zfcp_unit_find(struct zfcp_port *port, u64 fcp_lun)
+{
+        struct zfcp_unit *unit;
+
+        read_lock_irq(&port->unit_list_lock);
+        unit = _zfcp_unit_find(port, fcp_lun);
+        read_unlock_irq(&port->unit_list_lock);
+        return unit;
+}
+
+/**
+ * zfcp_unit_release - Drop reference to zfcp_port and free memory of zfcp_unit.
+ * @dev: pointer to device in zfcp_unit
+ */
+static void zfcp_unit_release(struct device *dev)
+{
+        struct zfcp_unit *unit = container_of(dev, struct zfcp_unit, dev);
+
+        put_device(&unit->port->dev);
+        kfree(unit);
+}
+
+/**
+ * zfcp_unit_enqueue - enqueue unit to unit list of a port.
+ * @port: pointer to port where unit is added
+ * @fcp_lun: FCP LUN of unit to be enqueued
+ * Returns: 0 success
+ *
+ * Sets up some unit internal structures and creates sysfs entry.
+ */
+int zfcp_unit_add(struct zfcp_port *port, u64 fcp_lun)
+{
+        struct zfcp_unit *unit;
+
+        unit = zfcp_unit_find(port, fcp_lun);
+        if (unit) {
+                put_device(&unit->dev);
+                return -EEXIST;
+        }
+
+        unit = kzalloc(sizeof(struct zfcp_unit), GFP_KERNEL);
+        if (!unit)
+                return -ENOMEM;
+
+        unit->port = port;
+        unit->fcp_lun = fcp_lun;
+        unit->dev.parent = &port->dev;
+        unit->dev.release = zfcp_unit_release;
+        INIT_WORK(&unit->scsi_work, zfcp_unit_scsi_scan_work);
+
+        if (dev_set_name(&unit->dev, "0x%016llx",
+                         (unsigned long long) fcp_lun)) {
+                kfree(unit);
+                return -ENOMEM;
+        }
+
+        get_device(&port->dev);
+
+        if (device_register(&unit->dev)) {
+                put_device(&unit->dev);
+                return -ENOMEM;
+        }
+
+        if (sysfs_create_group(&unit->dev.kobj, &zfcp_sysfs_unit_attrs)) {
+                device_unregister(&unit->dev);
+                return -EINVAL;
+        }
+
+        write_lock_irq(&port->unit_list_lock);
+        list_add_tail(&unit->list, &port->unit_list);
+        write_unlock_irq(&port->unit_list_lock);
+
+        zfcp_unit_scsi_scan(unit);
+
+        return 0;
+}
+
+/**
+ * zfcp_unit_sdev - Return SCSI device for zfcp_unit
+ * @unit: The zfcp_unit where to get the SCSI device for
+ *
+ * Returns: scsi_device pointer on success, NULL if there is no SCSI
+ *          device for this zfcp_unit
+ *
+ * On success, the caller also holds a reference to the SCSI device
+ * that must be released with scsi_device_put.
+ */
+struct scsi_device *zfcp_unit_sdev(struct zfcp_unit *unit)
+{
+        struct Scsi_Host *shost;
+        struct zfcp_port *port;
+        unsigned int lun;
+
+        lun = scsilun_to_int((struct scsi_lun *) &unit->fcp_lun);
+        port = unit->port;
+        shost = port->adapter->scsi_host;
+        return scsi_device_lookup(shost, 0, port->starget_id, lun);
+}
+
+/**
+ * zfcp_unit_sdev_status - Return zfcp LUN status for SCSI device
+ * @unit: The unit to lookup the SCSI device for
+ *
+ * Returns the zfcp LUN status field of the SCSI device if the SCSI device
+ * for the zfcp_unit exists, 0 otherwise.
+ */
+unsigned int zfcp_unit_sdev_status(struct zfcp_unit *unit)
+{
+        unsigned int status = 0;
+        struct scsi_device *sdev;
+        struct zfcp_scsi_dev *zfcp_sdev;
+
+        sdev = zfcp_unit_sdev(unit);
+        if (sdev) {
+                zfcp_sdev = sdev_to_zfcp(sdev);
+                status = atomic_read(&zfcp_sdev->status);
+                scsi_device_put(sdev);
+        }
+
+        return status;
+}
+
+/**
+ * zfcp_unit_remove - Remove entry from list of configured units
+ * @port: The port where to remove the unit from the configuration
+ * @fcp_lun: The 64 bit LUN of the unit to remove
+ *
+ * Returns: -EINVAL if a unit with the specified LUN does not exist,
+ *          0 on success.
+ */
+int zfcp_unit_remove(struct zfcp_port *port, u64 fcp_lun)
+{
+        struct zfcp_unit *unit;
+        struct scsi_device *sdev;
+
+        write_lock_irq(&port->unit_list_lock);
+        unit = _zfcp_unit_find(port, fcp_lun);
+        if (unit)
+                list_del(&unit->list);
+        write_unlock_irq(&port->unit_list_lock);
+
+        if (!unit)
+                return -EINVAL;
+
+        sdev = zfcp_unit_sdev(unit);
+        if (sdev) {
+                scsi_remove_device(sdev);
+                scsi_device_put(sdev);
+        }
+
+        put_device(&unit->dev);
+
+        zfcp_device_unregister(&unit->dev, &zfcp_sysfs_unit_attrs);
+
+        return 0;
+}