33 files changed, 863 insertions, 467 deletions

diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index f1b7fdc58a5f..82758cbb220b 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -246,7 +246,7 @@ static struct dentry *dasd_debugfs_setup(const char *name,
 static int dasd_state_known_to_basic(struct dasd_device *device)
 {
         struct dasd_block *block = device->block;
-        int rc;
+        int rc = 0;
 
         /* Allocate and register gendisk structure. */
         if (block) {
@@ -273,7 +273,8 @@ static int dasd_state_known_to_basic(struct dasd_device *device)
         DBF_DEV_EVENT(DBF_EMERG, device, "%s", "debug area created");
 
         device->state = DASD_STATE_BASIC;
-        return 0;
+
+        return rc;
 }
 
 /*
@@ -282,6 +283,7 @@ static int dasd_state_known_to_basic(struct dasd_device *device)
 static int dasd_state_basic_to_known(struct dasd_device *device)
 {
         int rc;
+
         if (device->block) {
                 dasd_profile_exit(&device->block->profile);
                 if (device->block->debugfs_dentry)
@@ -332,8 +334,10 @@ static int dasd_state_basic_to_ready(struct dasd_device *device)
                 if (block->base->discipline->do_analysis != NULL)
                         rc = block->base->discipline->do_analysis(block);
                 if (rc) {
-                        if (rc != -EAGAIN)
+                        if (rc != -EAGAIN) {
                                 device->state = DASD_STATE_UNFMT;
+                                goto out;
+                        }
                         return rc;
                 }
                 dasd_setup_queue(block);
@@ -341,11 +345,16 @@ static int dasd_state_basic_to_ready(struct dasd_device *device)
                              block->blocks << block->s2b_shift);
                 device->state = DASD_STATE_READY;
                 rc = dasd_scan_partitions(block);
-                if (rc)
+                if (rc) {
                         device->state = DASD_STATE_BASIC;
+                        return rc;
+                }
         } else {
                 device->state = DASD_STATE_READY;
         }
+out:
+        if (device->discipline->basic_to_ready)
+                rc = device->discipline->basic_to_ready(device);
         return rc;
 }
 
@@ -368,6 +377,11 @@ static int dasd_state_ready_to_basic(struct dasd_device *device)
 {
         int rc;
 
+        if (device->discipline->ready_to_basic) {
+                rc = device->discipline->ready_to_basic(device);
+                if (rc)
+                        return rc;
+        }
         device->state = DASD_STATE_BASIC;
         if (device->block) {
                 struct dasd_block *block = device->block;
@@ -402,16 +416,10 @@ static int dasd_state_unfmt_to_basic(struct dasd_device *device)
 static int
 dasd_state_ready_to_online(struct dasd_device * device)
 {
-        int rc;
         struct gendisk *disk;
         struct disk_part_iter piter;
         struct hd_struct *part;
 
-        if (device->discipline->ready_to_online) {
-                rc = device->discipline->ready_to_online(device);
-                if (rc)
-                        return rc;
-        }
         device->state = DASD_STATE_ONLINE;
         if (device->block) {
                 dasd_schedule_block_bh(device->block);
@@ -444,6 +452,7 @@ static int dasd_state_online_to_ready(struct dasd_device *device)
                 if (rc)
                         return rc;
         }
+
         device->state = DASD_STATE_READY;
         if (device->block && !(device->features & DASD_FEATURE_USERAW)) {
                 disk = device->block->bdev->bd_disk;
@@ -2223,6 +2232,77 @@ static int _dasd_sleep_on(struct dasd_ccw_req *maincqr, int interruptible)
         return rc;
 }
 
+static inline int _wait_for_wakeup_queue(struct list_head *ccw_queue)
+{
+        struct dasd_ccw_req *cqr;
+
+        list_for_each_entry(cqr, ccw_queue, blocklist) {
+                if (cqr->callback_data != DASD_SLEEPON_END_TAG)
+                        return 0;
+        }
+
+        return 1;
+}
+
+static int _dasd_sleep_on_queue(struct list_head *ccw_queue, int interruptible)
+{
+        struct dasd_device *device;
+        int rc;
+        struct dasd_ccw_req *cqr, *n;
+
+retry:
+        list_for_each_entry_safe(cqr, n, ccw_queue, blocklist) {
+                device = cqr->startdev;
+                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) &&
+                    !dasd_eer_enabled(device)) {
+                        cqr->status = DASD_CQR_FAILED;
+                        cqr->intrc = -EAGAIN;
+                        continue;
+                }
+
+                /*Don't try to start requests if device is stopped*/
+                if (interruptible) {
+                        rc = wait_event_interruptible(
+                                generic_waitq, !device->stopped);
+                        if (rc == -ERESTARTSYS) {
+                                cqr->status = DASD_CQR_FAILED;
+                                cqr->intrc = rc;
+                                continue;
+                        }
+                } else
+                        wait_event(generic_waitq, !(device->stopped));
+
+                if (!cqr->callback)
+                        cqr->callback = dasd_wakeup_cb;
+                cqr->callback_data = DASD_SLEEPON_START_TAG;
+                dasd_add_request_tail(cqr);
+        }
+
+        wait_event(generic_waitq, _wait_for_wakeup_queue(ccw_queue));
+
+        rc = 0;
+        list_for_each_entry_safe(cqr, n, ccw_queue, blocklist) {
+                if (__dasd_sleep_on_erp(cqr))
+                        rc = 1;
+        }
+        if (rc)
+                goto retry;
+
+
+        return 0;
+}
+
 /*
  * Queue a request to the tail of the device ccw_queue and wait for
  * it's completion.
@@ -2233,6 +2313,15 @@ int dasd_sleep_on(struct dasd_ccw_req *cqr)
 }
 
 /*
+ * Start requests from a ccw_queue and wait for their completion.
+ */
+int dasd_sleep_on_queue(struct list_head *ccw_queue)
+{
+        return _dasd_sleep_on_queue(ccw_queue, 0);
+}
+EXPORT_SYMBOL(dasd_sleep_on_queue);
+
+/*
  * Queue a request to the tail of the device ccw_queue and wait
  * interruptible for it's completion.
  */
@@ -2663,6 +2752,26 @@ static void _dasd_wake_block_flush_cb(struct dasd_ccw_req *cqr, void *data)
 }
 
 /*
+ * Requeue a request back to the block request queue
+ * only works for block requests
+ */
+static int _dasd_requeue_request(struct dasd_ccw_req *cqr)
+{
+        struct dasd_block *block = cqr->block;
+        struct request *req;
+        unsigned long flags;
+
+        if (!block)
+                return -EINVAL;
+        spin_lock_irqsave(&block->queue_lock, flags);
+        req = (struct request *) cqr->callback_data;
+        blk_requeue_request(block->request_queue, req);
+        spin_unlock_irqrestore(&block->queue_lock, flags);
+
+        return 0;
+}
+
+/*
  * Go through all request on the dasd_block request queue, cancel them
  * on the respective dasd_device, and return them to the generic
  * block layer.
@@ -3380,10 +3489,11 @@ EXPORT_SYMBOL_GPL(dasd_generic_verify_path);
 
 int dasd_generic_pm_freeze(struct ccw_device *cdev)
 {
+        struct dasd_device *device = dasd_device_from_cdev(cdev);
+        struct list_head freeze_queue;
         struct dasd_ccw_req *cqr, *n;
+        struct dasd_ccw_req *refers;
         int rc;
-        struct list_head freeze_queue;
-        struct dasd_device *device = dasd_device_from_cdev(cdev);
 
         if (IS_ERR(device))
                 return PTR_ERR(device);
@@ -3396,7 +3506,8 @@ int dasd_generic_pm_freeze(struct ccw_device *cdev)
 
         /* disallow new I/O  */
         dasd_device_set_stop_bits(device, DASD_STOPPED_PM);
-        /* clear active requests */
+
+        /* clear active requests and requeue them to block layer if possible */
         INIT_LIST_HEAD(&freeze_queue);
         spin_lock_irq(get_ccwdev_lock(cdev));
         rc = 0;
@@ -3416,7 +3527,6 @@ int dasd_generic_pm_freeze(struct ccw_device *cdev)
                 }
                 list_move_tail(&cqr->devlist, &freeze_queue);
         }
-
         spin_unlock_irq(get_ccwdev_lock(cdev));
 
         list_for_each_entry_safe(cqr, n, &freeze_queue, devlist) {
@@ -3424,12 +3534,38 @@ int dasd_generic_pm_freeze(struct ccw_device *cdev)
                            (cqr->status != DASD_CQR_CLEAR_PENDING));
                 if (cqr->status == DASD_CQR_CLEARED)
                         cqr->status = DASD_CQR_QUEUED;
+
+                /* requeue requests to blocklayer will only work for
+                   block device requests */
+                if (_dasd_requeue_request(cqr))
+                        continue;
+
+                /* remove requests from device and block queue */
+                list_del_init(&cqr->devlist);
+                while (cqr->refers != NULL) {
+                        refers = cqr->refers;
+                        /* remove the request from the block queue */
+                        list_del(&cqr->blocklist);
+                        /* free the finished erp request */
+                        dasd_free_erp_request(cqr, cqr->memdev);
+                        cqr = refers;
+                }
+                if (cqr->block)
+                        list_del_init(&cqr->blocklist);
+                cqr->block->base->discipline->free_cp(
+                        cqr, (struct request *) cqr->callback_data);
         }
-        /* move freeze_queue to start of the ccw_queue */
-        spin_lock_irq(get_ccwdev_lock(cdev));
-        list_splice_tail(&freeze_queue, &device->ccw_queue);
-        spin_unlock_irq(get_ccwdev_lock(cdev));
 
+        /*
+         * if requests remain then they are internal request
+         * and go back to the device queue
+         */
+        if (!list_empty(&freeze_queue)) {
+                /* move freeze_queue to start of the ccw_queue */
+                spin_lock_irq(get_ccwdev_lock(cdev));
+                list_splice_tail(&freeze_queue, &device->ccw_queue);
+                spin_unlock_irq(get_ccwdev_lock(cdev));
+        }
         dasd_put_device(device);
         return rc;
 }
diff --git a/drivers/s390/block/dasd_devmap.c b/drivers/s390/block/dasd_devmap.c
index c196827c228f..a71bb8aaca1d 100644
--- a/drivers/s390/block/dasd_devmap.c
+++ b/drivers/s390/block/dasd_devmap.c
@@ -410,8 +410,7 @@ dasd_add_busid(const char *bus_id, int features)
         struct dasd_devmap *devmap, *new, *tmp;
         int hash;
 
-        new = (struct dasd_devmap *)
-                kzalloc(sizeof(struct dasd_devmap), GFP_KERNEL);
+        new = kzalloc(sizeof(struct dasd_devmap), GFP_KERNEL);
         if (!new)
                 return ERR_PTR(-ENOMEM);
         spin_lock(&dasd_devmap_lock);
diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index 6999fd919e94..6a44b27623ed 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -2022,7 +2022,7 @@ static int dasd_eckd_do_analysis(struct dasd_block *block)
                 return dasd_eckd_end_analysis(block);
 }
 
-static int dasd_eckd_ready_to_online(struct dasd_device *device)
+static int dasd_eckd_basic_to_ready(struct dasd_device *device)
 {
         return dasd_alias_add_device(device);
 };
@@ -2031,6 +2031,11 @@ static int dasd_eckd_online_to_ready(struct dasd_device *device)
 {
         cancel_work_sync(&device->reload_device);
         cancel_work_sync(&device->kick_validate);
+        return 0;
+};
+
+static int dasd_eckd_ready_to_basic(struct dasd_device *device)
+{
         return dasd_alias_remove_device(device);
 };
 
@@ -2050,45 +2055,34 @@ dasd_eckd_fill_geometry(struct dasd_block *block, struct hd_geometry *geo)
 }
 
 static struct dasd_ccw_req *
-dasd_eckd_format_device(struct dasd_device * device,
-                        struct format_data_t * fdata)
+dasd_eckd_build_format(struct dasd_device *base,
+                       struct format_data_t *fdata)
 {
-        struct dasd_eckd_private *private;
+        struct dasd_eckd_private *base_priv;
+        struct dasd_eckd_private *start_priv;
+        struct dasd_device *startdev;
         struct dasd_ccw_req *fcp;
         struct eckd_count *ect;
+        struct ch_t address;
         struct ccw1 *ccw;
         void *data;
         int rpt;
-        struct ch_t address;
         int cplength, datasize;
-        int i;
+        int i, j;
         int intensity = 0;
         int r0_perm;
+        int nr_tracks;
 
-        private = (struct dasd_eckd_private *) device->private;
-        rpt = recs_per_track(&private->rdc_data, 0, fdata->blksize);
-        set_ch_t(&address,
-                 fdata->start_unit / private->rdc_data.trk_per_cyl,
-                 fdata->start_unit % private->rdc_data.trk_per_cyl);
+        startdev = dasd_alias_get_start_dev(base);
+        if (!startdev)
+                startdev = base;
 
-        /* Sanity checks. */
-        if (fdata->start_unit >=
-            (private->real_cyl * private->rdc_data.trk_per_cyl)) {
-                dev_warn(&device->cdev->dev, "Start track number %d used in "
-                         "formatting is too big\n", fdata->start_unit);
-                return ERR_PTR(-EINVAL);
-        }
-        if (fdata->start_unit > fdata->stop_unit) {
-                dev_warn(&device->cdev->dev, "Start track %d used in "
-                         "formatting exceeds end track\n", fdata->start_unit);
-                return ERR_PTR(-EINVAL);
-        }
-        if (dasd_check_blocksize(fdata->blksize) != 0) {
-                dev_warn(&device->cdev->dev,
-                         "The DASD cannot be formatted with block size %d\n",
-                         fdata->blksize);
-                return ERR_PTR(-EINVAL);
-        }
+        start_priv = (struct dasd_eckd_private *) startdev->private;
+        base_priv = (struct dasd_eckd_private *) base->private;
+
+        rpt = recs_per_track(&base_priv->rdc_data, 0, fdata->blksize);
+
+        nr_tracks = fdata->stop_unit - fdata->start_unit + 1;
 
         /*
          * fdata->intensity is a bit string that tells us what to do:
@@ -2106,149 +2100,282 @@ dasd_eckd_format_device(struct dasd_device * device,
                 r0_perm = 1;
                 intensity = fdata->intensity;
         }
+
         switch (intensity) {
         case 0x00:      /* Normal format */
         case 0x08:      /* Normal format, use cdl. */
-                cplength = 2 + rpt;
-                datasize = sizeof(struct DE_eckd_data) +
+                cplength = 2 + (rpt*nr_tracks);
+                datasize = sizeof(struct PFX_eckd_data) +
                         sizeof(struct LO_eckd_data) +
-                        rpt * sizeof(struct eckd_count);
+                        rpt * nr_tracks * sizeof(struct eckd_count);
                 break;
         case 0x01:      /* Write record zero and format track. */
         case 0x09:      /* Write record zero and format track, use cdl. */
-                cplength = 3 + rpt;
-                datasize = sizeof(struct DE_eckd_data) +
+                cplength = 2 + rpt * nr_tracks;
+                datasize = sizeof(struct PFX_eckd_data) +
                         sizeof(struct LO_eckd_data) +
                         sizeof(struct eckd_count) +
-                        rpt * sizeof(struct eckd_count);
+                        rpt * nr_tracks * sizeof(struct eckd_count);
                 break;
         case 0x04:      /* Invalidate track. */
         case 0x0c:      /* Invalidate track, use cdl. */
                 cplength = 3;
-                datasize = sizeof(struct DE_eckd_data) +
+                datasize = sizeof(struct PFX_eckd_data) +
                         sizeof(struct LO_eckd_data) +
                         sizeof(struct eckd_count);
                 break;
         default:
-                dev_warn(&device->cdev->dev, "An I/O control call used "
-                         "incorrect flags 0x%x\n", fdata->intensity);
+                dev_warn(&startdev->cdev->dev,
+                         "An I/O control call used incorrect flags 0x%x\n",
+                         fdata->intensity);
                 return ERR_PTR(-EINVAL);
         }
         /* Allocate the format ccw request. */
-        fcp = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, device);
+        fcp = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength,
+                                   datasize, startdev);
         if (IS_ERR(fcp))
                 return fcp;
 
+        start_priv->count++;
         data = fcp->data;
         ccw = fcp->cpaddr;
 
         switch (intensity & ~0x08) {
         case 0x00: /* Normal format. */
-                define_extent(ccw++, (struct DE_eckd_data *) data,
-                              fdata->start_unit, fdata->start_unit,
-                              DASD_ECKD_CCW_WRITE_CKD, device);
+                prefix(ccw++, (struct PFX_eckd_data *) data,
+                       fdata->start_unit, fdata->stop_unit,
+                       DASD_ECKD_CCW_WRITE_CKD, base, startdev);
                 /* grant subsystem permission to format R0 */
                 if (r0_perm)
-                        ((struct DE_eckd_data *)data)->ga_extended |= 0x04;
-                data += sizeof(struct DE_eckd_data);
+                        ((struct PFX_eckd_data *)data)
+                                ->define_extent.ga_extended |= 0x04;
+                data += sizeof(struct PFX_eckd_data);
                 ccw[-1].flags |= CCW_FLAG_CC;
                 locate_record(ccw++, (struct LO_eckd_data *) data,
-                              fdata->start_unit, 0, rpt,
-                              DASD_ECKD_CCW_WRITE_CKD, device,
+                              fdata->start_unit, 0, rpt*nr_tracks,
+                              DASD_ECKD_CCW_WRITE_CKD, base,
                               fdata->blksize);
                 data += sizeof(struct LO_eckd_data);
                 break;
         case 0x01: /* Write record zero + format track. */
-                define_extent(ccw++, (struct DE_eckd_data *) data,
-                              fdata->start_unit, fdata->start_unit,
-                              DASD_ECKD_CCW_WRITE_RECORD_ZERO,
-                              device);
-                data += sizeof(struct DE_eckd_data);
+                prefix(ccw++, (struct PFX_eckd_data *) data,
+                       fdata->start_unit, fdata->stop_unit,
+                       DASD_ECKD_CCW_WRITE_RECORD_ZERO,
+                       base, startdev);
+                data += sizeof(struct PFX_eckd_data);
                 ccw[-1].flags |= CCW_FLAG_CC;
                 locate_record(ccw++, (struct LO_eckd_data *) data,
-                              fdata->start_unit, 0, rpt + 1,
-                              DASD_ECKD_CCW_WRITE_RECORD_ZERO, device,
-                              device->block->bp_block);
+                              fdata->start_unit, 0, rpt * nr_tracks + 1,
+                              DASD_ECKD_CCW_WRITE_RECORD_ZERO, base,
+                              base->block->bp_block);
                 data += sizeof(struct LO_eckd_data);
                 break;
         case 0x04: /* Invalidate track. */
-                define_extent(ccw++, (struct DE_eckd_data *) data,
-                              fdata->start_unit, fdata->start_unit,
-                              DASD_ECKD_CCW_WRITE_CKD, device);
-                data += sizeof(struct DE_eckd_data);
+                prefix(ccw++, (struct PFX_eckd_data *) data,
+                       fdata->start_unit, fdata->stop_unit,
+                       DASD_ECKD_CCW_WRITE_CKD, base, startdev);
+                data += sizeof(struct PFX_eckd_data);
                 ccw[-1].flags |= CCW_FLAG_CC;
                 locate_record(ccw++, (struct LO_eckd_data *) data,
                               fdata->start_unit, 0, 1,
-                              DASD_ECKD_CCW_WRITE_CKD, device, 8);
+                              DASD_ECKD_CCW_WRITE_CKD, base, 8);
                 data += sizeof(struct LO_eckd_data);
                 break;
         }
-        if (intensity & 0x01) { /* write record zero */
-                ect = (struct eckd_count *) data;
-                data += sizeof(struct eckd_count);
-                ect->cyl = address.cyl;
-                ect->head = address.head;
-                ect->record = 0;
-                ect->kl = 0;
-                ect->dl = 8;
-                ccw[-1].flags |= CCW_FLAG_CC;
-                ccw->cmd_code = DASD_ECKD_CCW_WRITE_RECORD_ZERO;
-                ccw->flags = CCW_FLAG_SLI;
-                ccw->count = 8;
-                ccw->cda = (__u32)(addr_t) ect;
-                ccw++;
-        }
-        if ((intensity & ~0x08) & 0x04) {       /* erase track */
-                ect = (struct eckd_count *) data;
-                data += sizeof(struct eckd_count);
-                ect->cyl = address.cyl;
-                ect->head = address.head;
-                ect->record = 1;
-                ect->kl = 0;
-                ect->dl = 0;
-                ccw[-1].flags |= CCW_FLAG_CC;
-                ccw->cmd_code = DASD_ECKD_CCW_WRITE_CKD;
-                ccw->flags = CCW_FLAG_SLI;
-                ccw->count = 8;
-                ccw->cda = (__u32)(addr_t) ect;
-        } else {                /* write remaining records */
-                for (i = 0; i < rpt; i++) {
+
+        for (j = 0; j < nr_tracks; j++) {
+                /* calculate cylinder and head for the current track */
+                set_ch_t(&address,
+                         (fdata->start_unit + j) /
+                         base_priv->rdc_data.trk_per_cyl,
+                         (fdata->start_unit + j) %
+                         base_priv->rdc_data.trk_per_cyl);
+                if (intensity & 0x01) { /* write record zero */
                         ect = (struct eckd_count *) data;
                         data += sizeof(struct eckd_count);
                         ect->cyl = address.cyl;
                         ect->head = address.head;
-                        ect->record = i + 1;
+                        ect->record = 0;
                         ect->kl = 0;
-                        ect->dl = fdata->blksize;
-                        /* Check for special tracks 0-1 when formatting CDL */
-                        if ((intensity & 0x08) &&
-                            fdata->start_unit == 0) {
-                                if (i < 3) {
-                                        ect->kl = 4;
-                                        ect->dl = sizes_trk0[i] - 4;
-                                }
-                        }
-                        if ((intensity & 0x08) &&
-                            fdata->start_unit == 1) {
-                                ect->kl = 44;
-                                ect->dl = LABEL_SIZE - 44;
-                        }
+                        ect->dl = 8;
                         ccw[-1].flags |= CCW_FLAG_CC;
-                        ccw->cmd_code = DASD_ECKD_CCW_WRITE_CKD;
+                        ccw->cmd_code = DASD_ECKD_CCW_WRITE_RECORD_ZERO;
                         ccw->flags = CCW_FLAG_SLI;
                         ccw->count = 8;
                         ccw->cda = (__u32)(addr_t) ect;
                         ccw++;
                 }
+                if ((intensity & ~0x08) & 0x04) {       /* erase track */
+                        ect = (struct eckd_count *) data;
+                        data += sizeof(struct eckd_count);
+                        ect->cyl = address.cyl;
+                        ect->head = address.head;
+                        ect->record = 1;
+                        ect->kl = 0;
+                        ect->dl = 0;
+                        ccw[-1].flags |= CCW_FLAG_CC;
+                        ccw->cmd_code = DASD_ECKD_CCW_WRITE_CKD;
+                        ccw->flags = CCW_FLAG_SLI;
+                        ccw->count = 8;
+                        ccw->cda = (__u32)(addr_t) ect;
+                } else {                /* write remaining records */
+                        for (i = 0; i < rpt; i++) {
+                                ect = (struct eckd_count *) data;
+                                data += sizeof(struct eckd_count);
+                                ect->cyl = address.cyl;
+                                ect->head = address.head;
+                                ect->record = i + 1;
+                                ect->kl = 0;
+                                ect->dl = fdata->blksize;
+                                /*
+                                 * Check for special tracks 0-1
+                                 * when formatting CDL
+                                 */
+                                if ((intensity & 0x08) &&
+                                    fdata->start_unit == 0) {
+                                        if (i < 3) {
+                                                ect->kl = 4;
+                                                ect->dl = sizes_trk0[i] - 4;
+                                        }
+                                }
+                                if ((intensity & 0x08) &&
+                                    fdata->start_unit == 1) {
+                                        ect->kl = 44;
+                                        ect->dl = LABEL_SIZE - 44;
+                                }
+                                ccw[-1].flags |= CCW_FLAG_CC;
+                                if (i != 0 || j == 0)
+                                        ccw->cmd_code =
+                                                DASD_ECKD_CCW_WRITE_CKD;
+                                else
+                                        ccw->cmd_code =
+                                                DASD_ECKD_CCW_WRITE_CKD_MT;
+                                ccw->flags = CCW_FLAG_SLI;
+                                ccw->count = 8;
+                                        ccw->cda = (__u32)(addr_t) ect;
+                                        ccw++;
+                        }
+                }
         }
-        fcp->startdev = device;
-        fcp->memdev = device;
+
+        fcp->startdev = startdev;
+        fcp->memdev = startdev;
         fcp->retries = 256;
+        fcp->expires = startdev->default_expires * HZ;
         fcp->buildclk = get_tod_clock();
         fcp->status = DASD_CQR_FILLED;
+
         return fcp;
 }
 
+static int
+dasd_eckd_format_device(struct dasd_device *base,
+                        struct format_data_t *fdata)
+{
+        struct dasd_ccw_req *cqr, *n;
+        struct dasd_block *block;
+        struct dasd_eckd_private *private;
+        struct list_head format_queue;
+        struct dasd_device *device;
+        int old_stop, format_step;
+        int step, rc = 0;
+
+        block = base->block;
+        private = (struct dasd_eckd_private *) base->private;
+
+        /* Sanity checks. */
+        if (fdata->start_unit >=
+            (private->real_cyl * private->rdc_data.trk_per_cyl)) {
+                dev_warn(&base->cdev->dev,
+                         "Start track number %u used in formatting is too big\n",
+                         fdata->start_unit);
+                return -EINVAL;
+        }
+        if (fdata->stop_unit >=
+            (private->real_cyl * private->rdc_data.trk_per_cyl)) {
+                dev_warn(&base->cdev->dev,
+                         "Stop track number %u used in formatting is too big\n",
+                         fdata->stop_unit);
+                return -EINVAL;
+        }
+        if (fdata->start_unit > fdata->stop_unit) {
+                dev_warn(&base->cdev->dev,
+                         "Start track %u used in formatting exceeds end track\n",
+                         fdata->start_unit);
+                return -EINVAL;
+        }
+        if (dasd_check_blocksize(fdata->blksize) != 0) {
+                dev_warn(&base->cdev->dev,
+                         "The DASD cannot be formatted with block size %u\n",
+                         fdata->blksize);
+                return -EINVAL;
+        }
+
+        INIT_LIST_HEAD(&format_queue);
+        old_stop = fdata->stop_unit;
+
+        while (fdata->start_unit <= 1) {
+                fdata->stop_unit = fdata->start_unit;
+                cqr = dasd_eckd_build_format(base, fdata);
+                list_add(&cqr->blocklist, &format_queue);
+
+                fdata->stop_unit = old_stop;
+                fdata->start_unit++;
+
+                if (fdata->start_unit > fdata->stop_unit)
+                        goto sleep;
+        }
+
+retry:
+        format_step = 255 / recs_per_track(&private->rdc_data, 0,
+                                           fdata->blksize);
+        while (fdata->start_unit <= old_stop) {
+                step = fdata->stop_unit - fdata->start_unit + 1;
+                if (step > format_step)
+                        fdata->stop_unit = fdata->start_unit + format_step - 1;
+
+                cqr = dasd_eckd_build_format(base, fdata);
+                if (IS_ERR(cqr)) {
+                        if (PTR_ERR(cqr) == -ENOMEM) {
+                                /*
+                                 * not enough memory available
+                                 * go to out and start requests
+                                 * retry after first requests were finished
+                                 */
+                                fdata->stop_unit = old_stop;
+                                goto sleep;
+                        } else
+                                return PTR_ERR(cqr);
+                }
+                list_add(&cqr->blocklist, &format_queue);
+
+                fdata->start_unit = fdata->stop_unit + 1;
+                fdata->stop_unit = old_stop;
+        }
+
+sleep:
+        dasd_sleep_on_queue(&format_queue);
+
+        list_for_each_entry_safe(cqr, n, &format_queue, blocklist) {
+                device = cqr->startdev;
+                private = (struct dasd_eckd_private *) device->private;
+                if (cqr->status == DASD_CQR_FAILED)
+                        rc = -EIO;
+                list_del_init(&cqr->blocklist);
+                dasd_sfree_request(cqr, device);
+                private->count--;
+        }
+
+        /*
+         * in case of ENOMEM we need to retry after
+         * first requests are finished
+         */
+        if (fdata->start_unit <= fdata->stop_unit)
+                goto retry;
+
+        return rc;
+}
+
 static void dasd_eckd_handle_terminated_request(struct dasd_ccw_req *cqr)
 {
         cqr->status = DASD_CQR_FILLED;
@@ -4305,8 +4432,9 @@ static struct dasd_discipline dasd_eckd_discipline = {
         .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,
+        .basic_to_ready = dasd_eckd_basic_to_ready,
         .online_to_ready = dasd_eckd_online_to_ready,
+        .ready_to_basic = dasd_eckd_ready_to_basic,
         .fill_geometry = dasd_eckd_fill_geometry,
         .start_IO = dasd_start_IO,
         .term_IO = dasd_term_IO,
diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
index 899e3f5a56e5..0785bd9bd5b6 100644
--- a/drivers/s390/block/dasd_int.h
+++ b/drivers/s390/block/dasd_int.h
@@ -300,10 +300,11 @@ struct dasd_discipline {
          * Last things to do when a device is set online, and first things
          * when it is set offline.
          */
-        int (*ready_to_online) (struct dasd_device *);
+        int (*basic_to_ready) (struct dasd_device *);
         int (*online_to_ready) (struct dasd_device *);
+        int (*ready_to_basic)  (struct dasd_device *);
 
-        /*
+        /* (struct dasd_device *);
          * Device operation functions. build_cp creates a ccw chain for
          * a block device request, start_io starts the request and
          * term_IO cancels it (e.g. in case of a timeout). format_device
@@ -317,8 +318,8 @@ struct dasd_discipline {
         int (*start_IO) (struct dasd_ccw_req *);
         int (*term_IO) (struct dasd_ccw_req *);
         void (*handle_terminated_request) (struct dasd_ccw_req *);
-        struct dasd_ccw_req *(*format_device) (struct dasd_device *,
-                                               struct format_data_t *);
+        int (*format_device) (struct dasd_device *,
+                              struct format_data_t *);
         int (*free_cp) (struct dasd_ccw_req *, struct request *);
 
         /*
@@ -672,6 +673,7 @@ int  dasd_term_IO(struct dasd_ccw_req *);
 void dasd_schedule_device_bh(struct dasd_device *);
 void dasd_schedule_block_bh(struct dasd_block *);
 int  dasd_sleep_on(struct dasd_ccw_req *);
+int  dasd_sleep_on_queue(struct list_head *);
 int  dasd_sleep_on_immediatly(struct dasd_ccw_req *);
 int  dasd_sleep_on_interruptible(struct dasd_ccw_req *);
 void dasd_device_set_timer(struct dasd_device *, int);
diff --git a/drivers/s390/block/dasd_ioctl.c b/drivers/s390/block/dasd_ioctl.c
index 03c0e0444553..8be1b51e9311 100644
--- a/drivers/s390/block/dasd_ioctl.c
+++ b/drivers/s390/block/dasd_ioctl.c
@@ -143,12 +143,12 @@ static int dasd_ioctl_resume(struct dasd_block *block)
 /*
  * performs formatting of _device_ according to _fdata_
  * Note: The discipline's format_function is assumed to deliver formatting
- * commands to format a single unit of the device. In terms of the ECKD
- * devices this means CCWs are generated to format a single track.
+ * commands to format multiple units of the device. In terms of the ECKD
+ * devices this means CCWs are generated to format multiple tracks.
  */
-static int dasd_format(struct dasd_block *block, struct format_data_t *fdata)
+static int
+dasd_format(struct dasd_block *block, struct format_data_t *fdata)
 {
-        struct dasd_ccw_req *cqr;
         struct dasd_device *base;
         int rc;
 
@@ -157,8 +157,8 @@ static int dasd_format(struct dasd_block *block, struct format_data_t *fdata)
                 return -EPERM;
 
         if (base->state != DASD_STATE_BASIC) {
-                pr_warning("%s: The DASD cannot be formatted while it is "
-                           "enabled\n",  dev_name(&base->cdev->dev));
+                pr_warn("%s: The DASD cannot be formatted while it is enabled\n",
+                        dev_name(&base->cdev->dev));
                 return -EBUSY;
         }
 
@@ -178,21 +178,10 @@ static int dasd_format(struct dasd_block *block, struct format_data_t *fdata)
                 bdput(bdev);
         }
 
-        while (fdata->start_unit <= fdata->stop_unit) {
-                cqr = base->discipline->format_device(base, fdata);
-                if (IS_ERR(cqr))
-                        return PTR_ERR(cqr);
-                rc = dasd_sleep_on_interruptible(cqr);
-                dasd_sfree_request(cqr, cqr->memdev);
-                if (rc) {
-                        if (rc != -ERESTARTSYS)
-                                pr_err("%s: Formatting unit %d failed with "
-                                       "rc=%d\n", dev_name(&base->cdev->dev),
-                                       fdata->start_unit, rc);
-                        return rc;
-                }
-                fdata->start_unit++;
-        }
+        rc = base->discipline->format_device(base, fdata);
+        if (rc)
+                return rc;
+
         return 0;
 }
 
diff --git a/drivers/s390/block/scm_blk.c b/drivers/s390/block/scm_blk.c
index 9978ad4433cb..b303cab76a7f 100644
--- a/drivers/s390/block/scm_blk.c
+++ b/drivers/s390/block/scm_blk.c
@@ -135,6 +135,11 @@ static const struct block_device_operations scm_blk_devops = {
         .release = scm_release,
 };
 
+static bool scm_permit_request(struct scm_blk_dev *bdev, struct request *req)
+{
+        return rq_data_dir(req) != WRITE || bdev->state != SCM_WR_PROHIBIT;
+}
+
 static void scm_request_prepare(struct scm_request *scmrq)
 {
         struct scm_blk_dev *bdev = scmrq->bdev;
@@ -195,14 +200,18 @@ void scm_request_requeue(struct scm_request *scmrq)
 
         scm_release_cluster(scmrq);
         blk_requeue_request(bdev->rq, scmrq->request);
+        atomic_dec(&bdev->queued_reqs);
         scm_request_done(scmrq);
         scm_ensure_queue_restart(bdev);
 }
 
 void scm_request_finish(struct scm_request *scmrq)
 {
+        struct scm_blk_dev *bdev = scmrq->bdev;
+
         scm_release_cluster(scmrq);
         blk_end_request_all(scmrq->request, scmrq->error);
+        atomic_dec(&bdev->queued_reqs);
         scm_request_done(scmrq);
 }
 
@@ -218,6 +227,10 @@ static void scm_blk_request(struct request_queue *rq)
                 if (req->cmd_type != REQ_TYPE_FS)
                         continue;
 
+                if (!scm_permit_request(bdev, req)) {
+                        scm_ensure_queue_restart(bdev);
+                        return;
+                }
                 scmrq = scm_request_fetch();
                 if (!scmrq) {
                         SCM_LOG(5, "no request");
@@ -231,11 +244,13 @@ static void scm_blk_request(struct request_queue *rq)
                         return;
                 }
                 if (scm_need_cluster_request(scmrq)) {
+                        atomic_inc(&bdev->queued_reqs);
                         blk_start_request(req);
                         scm_initiate_cluster_request(scmrq);
                         return;
                 }
                 scm_request_prepare(scmrq);
+                atomic_inc(&bdev->queued_reqs);
                 blk_start_request(req);
 
                 ret = scm_start_aob(scmrq->aob);
@@ -244,7 +259,6 @@ static void scm_blk_request(struct request_queue *rq)
                         scm_request_requeue(scmrq);
                         return;
                 }
-                atomic_inc(&bdev->queued_reqs);
         }
 }
 
@@ -280,6 +294,38 @@ void scm_blk_irq(struct scm_device *scmdev, void *data, int error)
         tasklet_hi_schedule(&bdev->tasklet);
 }
 
+static void scm_blk_handle_error(struct scm_request *scmrq)
+{
+        struct scm_blk_dev *bdev = scmrq->bdev;
+        unsigned long flags;
+
+        if (scmrq->error != -EIO)
+                goto restart;
+
+        /* For -EIO the response block is valid. */
+        switch (scmrq->aob->response.eqc) {
+        case EQC_WR_PROHIBIT:
+                spin_lock_irqsave(&bdev->lock, flags);
+                if (bdev->state != SCM_WR_PROHIBIT)
+                        pr_info("%lx: Write access to the SCM increment is suspended\n",
+                                (unsigned long) bdev->scmdev->address);
+                bdev->state = SCM_WR_PROHIBIT;
+                spin_unlock_irqrestore(&bdev->lock, flags);
+                goto requeue;
+        default:
+                break;
+        }
+
+restart:
+        if (!scm_start_aob(scmrq->aob))
+                return;
+
+requeue:
+        spin_lock_irqsave(&bdev->rq_lock, flags);
+        scm_request_requeue(scmrq);
+        spin_unlock_irqrestore(&bdev->rq_lock, flags);
+}
+
 static void scm_blk_tasklet(struct scm_blk_dev *bdev)
 {
         struct scm_request *scmrq;
@@ -293,11 +339,8 @@ static void scm_blk_tasklet(struct scm_blk_dev *bdev)
                 spin_unlock_irqrestore(&bdev->lock, flags);
 
                 if (scmrq->error && scmrq->retries-- > 0) {
-                        if (scm_start_aob(scmrq->aob)) {
-                                spin_lock_irqsave(&bdev->rq_lock, flags);
-                                scm_request_requeue(scmrq);
-                                spin_unlock_irqrestore(&bdev->rq_lock, flags);
-                        }
+                        scm_blk_handle_error(scmrq);
+
                         /* Request restarted or requeued, handle next. */
                         spin_lock_irqsave(&bdev->lock, flags);
                         continue;
@@ -310,7 +353,6 @@ static void scm_blk_tasklet(struct scm_blk_dev *bdev)
                 }
 
                 scm_request_finish(scmrq);
-                atomic_dec(&bdev->queued_reqs);
                 spin_lock_irqsave(&bdev->lock, flags);
         }
         spin_unlock_irqrestore(&bdev->lock, flags);
@@ -332,6 +374,7 @@ int scm_blk_dev_setup(struct scm_blk_dev *bdev, struct scm_device *scmdev)
         }
 
         bdev->scmdev = scmdev;
+        bdev->state = SCM_OPER;
         spin_lock_init(&bdev->rq_lock);
         spin_lock_init(&bdev->lock);
         INIT_LIST_HEAD(&bdev->finished_requests);
@@ -396,6 +439,18 @@ void scm_blk_dev_cleanup(struct scm_blk_dev *bdev)
         put_disk(bdev->gendisk);
 }
 
+void scm_blk_set_available(struct scm_blk_dev *bdev)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&bdev->lock, flags);
+        if (bdev->state == SCM_WR_PROHIBIT)
+                pr_info("%lx: Write access to the SCM increment is restored\n",
+                        (unsigned long) bdev->scmdev->address);
+        bdev->state = SCM_OPER;
+        spin_unlock_irqrestore(&bdev->lock, flags);
+}
+
 static int __init scm_blk_init(void)
 {
         int ret = -EINVAL;
@@ -408,12 +463,15 @@ static int __init scm_blk_init(void)
                 goto out;
 
         scm_major = ret;
-        if (scm_alloc_rqs(nr_requests))
-                goto out_unreg;
+        ret = scm_alloc_rqs(nr_requests);
+        if (ret)
+                goto out_free;
 
         scm_debug = debug_register("scm_log", 16, 1, 16);
-        if (!scm_debug)
+        if (!scm_debug) {
+                ret = -ENOMEM;
                 goto out_free;
+        }
 
         debug_register_view(scm_debug, &debug_hex_ascii_view);
         debug_set_level(scm_debug, 2);
@@ -428,7 +486,6 @@ out_dbf:
         debug_unregister(scm_debug);
 out_free:
         scm_free_rqs();
-out_unreg:
         unregister_blkdev(scm_major, "scm");
 out:
         return ret;
diff --git a/drivers/s390/block/scm_blk.h b/drivers/s390/block/scm_blk.h
index 3c1ccf494647..8b387b32fd62 100644
--- a/drivers/s390/block/scm_blk.h
+++ b/drivers/s390/block/scm_blk.h
@@ -21,6 +21,7 @@ struct scm_blk_dev {
         spinlock_t rq_lock;     /* guard the request queue */
         spinlock_t lock;        /* guard the rest of the blockdev */
         atomic_t queued_reqs;
+        enum {SCM_OPER, SCM_WR_PROHIBIT} state;
         struct list_head finished_requests;
 #ifdef CONFIG_SCM_BLOCK_CLUSTER_WRITE
         struct list_head cluster_list;
@@ -48,6 +49,7 @@ struct scm_request {
 
 int scm_blk_dev_setup(struct scm_blk_dev *, struct scm_device *);
 void scm_blk_dev_cleanup(struct scm_blk_dev *);
+void scm_blk_set_available(struct scm_blk_dev *);
 void scm_blk_irq(struct scm_device *, void *, int);
 
 void scm_request_finish(struct scm_request *);
diff --git a/drivers/s390/block/scm_blk_cluster.c b/drivers/s390/block/scm_blk_cluster.c
index f4bb61b0cea1..c0d102e3a48b 100644
--- a/drivers/s390/block/scm_blk_cluster.c
+++ b/drivers/s390/block/scm_blk_cluster.c
@@ -223,6 +223,8 @@ void scm_cluster_request_irq(struct scm_request *scmrq)
 
 bool scm_cluster_size_valid(void)
 {
-        return write_cluster_size == 0 || write_cluster_size == 32 ||
-                write_cluster_size == 64 || write_cluster_size == 128;
+        if (write_cluster_size == 1 || write_cluster_size > 128)
+                return false;
+
+        return !(write_cluster_size & (write_cluster_size - 1));
 }
diff --git a/drivers/s390/block/scm_drv.c b/drivers/s390/block/scm_drv.c
index 9fa0a908607b..c98cf52d78d1 100644
--- a/drivers/s390/block/scm_drv.c
+++ b/drivers/s390/block/scm_drv.c
@@ -13,12 +13,23 @@
 #include <asm/eadm.h>
 #include "scm_blk.h"
 
-static void notify(struct scm_device *scmdev)
+static void scm_notify(struct scm_device *scmdev, enum scm_event event)
 {
-        pr_info("%lu: The capabilities of the SCM increment changed\n",
-                (unsigned long) scmdev->address);
-        SCM_LOG(2, "State changed");
-        SCM_LOG_STATE(2, scmdev);
+        struct scm_blk_dev *bdev = dev_get_drvdata(&scmdev->dev);
+
+        switch (event) {
+        case SCM_CHANGE:
+                pr_info("%lx: The capabilities of the SCM increment changed\n",
+                        (unsigned long) scmdev->address);
+                SCM_LOG(2, "State changed");
+                SCM_LOG_STATE(2, scmdev);
+                break;
+        case SCM_AVAIL:
+                SCM_LOG(2, "Increment available");
+                SCM_LOG_STATE(2, scmdev);
+                scm_blk_set_available(bdev);
+                break;
+        }
 }
 
 static int scm_probe(struct scm_device *scmdev)
@@ -64,7 +75,7 @@ static struct scm_driver scm_drv = {
                 .name = "scm_block",
                 .owner = THIS_MODULE,
         },
-        .notify = notify,
+        .notify = scm_notify,
         .probe = scm_probe,
         .remove = scm_remove,
         .handler = scm_blk_irq,
diff --git a/drivers/s390/char/con3215.c b/drivers/s390/char/con3215.c
index 7b00fa634d40..eb5d22795c47 100644
--- a/drivers/s390/char/con3215.c
+++ b/drivers/s390/char/con3215.c
@@ -502,7 +502,7 @@ static void raw3215_make_room(struct raw3215_info *raw, unsigned int length)
                 raw3215_try_io(raw);
                 raw->flags &= ~RAW3215_FLUSHING;
 #ifdef CONFIG_TN3215_CONSOLE
-                wait_cons_dev();
+                ccw_device_wait_idle(raw->cdev);
 #endif
                 /* Enough room freed up ? */
                 if (RAW3215_BUFFER_SIZE - raw->count >= length)
@@ -858,7 +858,7 @@ static void con3215_flush(void)
         raw = raw3215[0];  /* console 3215 is the first one */
         if (raw->port.flags & ASYNC_SUSPENDED)
                 /* The console is still frozen for suspend. */
-                if (ccw_device_force_console())
+                if (ccw_device_force_console(raw->cdev))
                         /* Forcing didn't work, no panic message .. */
                         return;
         spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
diff --git a/drivers/s390/char/monreader.c b/drivers/s390/char/monreader.c
index f4ff515db251..0da3ae3cd63b 100644
--- a/drivers/s390/char/monreader.c
+++ b/drivers/s390/char/monreader.c
@@ -174,8 +174,7 @@ static void mon_free_mem(struct mon_private *monpriv)
         int i;
 
         for (i = 0; i < MON_MSGLIM; i++)
-                if (monpriv->msg_array[i])
-                        kfree(monpriv->msg_array[i]);
+                kfree(monpriv->msg_array[i]);
         kfree(monpriv);
 }
 
diff --git a/drivers/s390/char/raw3270.c b/drivers/s390/char/raw3270.c
index 4c9030a5b9f2..24a08e8f19e1 100644
--- a/drivers/s390/char/raw3270.c
+++ b/drivers/s390/char/raw3270.c
@@ -796,7 +796,7 @@ struct raw3270 __init *raw3270_setup_console(struct ccw_device *cdev)
         do {
                 __raw3270_reset_device(rp);
                 while (!raw3270_state_final(rp)) {
-                        wait_cons_dev();
+                        ccw_device_wait_idle(rp->cdev);
                         barrier();
                 }
         } while (rp->state != RAW3270_STATE_READY);
@@ -810,7 +810,7 @@ raw3270_wait_cons_dev(struct raw3270 *rp)
         unsigned long flags;
 
         spin_lock_irqsave(get_ccwdev_lock(rp->cdev), flags);
-        wait_cons_dev();
+        ccw_device_wait_idle(rp->cdev);
         spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
 }
 
@@ -1274,7 +1274,7 @@ void raw3270_pm_unfreeze(struct raw3270_view *view)
 
         rp = view->dev;
         if (rp && test_bit(RAW3270_FLAGS_FROZEN, &rp->flags))
-                ccw_device_force_console();
+                ccw_device_force_console(rp->cdev);
 #endif
 }
 
diff --git a/drivers/s390/char/sclp_cmd.c b/drivers/s390/char/sclp_cmd.c
index 30a2255389e5..178836ec252b 100644
--- a/drivers/s390/char/sclp_cmd.c
+++ b/drivers/s390/char/sclp_cmd.c
@@ -561,6 +561,8 @@ static void __init sclp_add_standby_memory(void)
         add_memory_merged(0);
 }
 
+#define MEM_SCT_SIZE (1UL << SECTION_SIZE_BITS)
+
 static void __init insert_increment(u16 rn, int standby, int assigned)
 {
         struct memory_increment *incr, *new_incr;
@@ -573,7 +575,7 @@ static void __init insert_increment(u16 rn, int standby, int assigned)
         new_incr->rn = rn;
         new_incr->standby = standby;
         if (!standby)
-                new_incr->usecount = 1;
+                new_incr->usecount = rzm > MEM_SCT_SIZE ? rzm/MEM_SCT_SIZE : 1;
         last_rn = 0;
         prev = &sclp_mem_list;
         list_for_each_entry(incr, &sclp_mem_list, list) {
@@ -627,6 +629,8 @@ static int __init sclp_detect_standby_memory(void)
         struct read_storage_sccb *sccb;
         int i, id, assigned, rc;
 
+        if (OLDMEM_BASE) /* No standby memory in kdump mode */
+                return 0;
         if (!early_read_info_sccb_valid)
                 return 0;
         if ((sclp_facilities & 0xe00000000000ULL) != 0xe00000000000ULL)
diff --git a/drivers/s390/char/tty3270.c b/drivers/s390/char/tty3270.c
index b907dba24025..cee69dac3e18 100644
--- a/drivers/s390/char/tty3270.c
+++ b/drivers/s390/char/tty3270.c
@@ -915,7 +915,7 @@ static int tty3270_install(struct tty_driver *driver, struct tty_struct *tty)
         int i, rc;
 
         /* Check if the tty3270 is already there. */
-        view = raw3270_find_view(&tty3270_fn, tty->index);
+        view = raw3270_find_view(&tty3270_fn, tty->index + RAW3270_FIRSTMINOR);
         if (!IS_ERR(view)) {
                 tp = container_of(view, struct tty3270, view);
                 tty->driver_data = tp;
@@ -927,15 +927,16 @@ static int tty3270_install(struct tty_driver *driver, struct tty_struct *tty)
                 tp->inattr = TF_INPUT;
                 return tty_port_install(&tp->port, driver, tty);
         }
-        if (tty3270_max_index < tty->index)
-                tty3270_max_index = tty->index;
+        if (tty3270_max_index < tty->index + 1)
+                tty3270_max_index = tty->index + 1;
 
         /* Allocate tty3270 structure on first open. */
         tp = tty3270_alloc_view();
         if (IS_ERR(tp))
                 return PTR_ERR(tp);
 
-        rc = raw3270_add_view(&tp->view, &tty3270_fn, tty->index);
+        rc = raw3270_add_view(&tp->view, &tty3270_fn,
+                              tty->index + RAW3270_FIRSTMINOR);
         if (rc) {
                 tty3270_free_view(tp);
                 return rc;
@@ -1846,12 +1847,12 @@ static const struct tty_operations tty3270_ops = {
 
 void tty3270_create_cb(int minor)
 {
-        tty_register_device(tty3270_driver, minor, NULL);
+        tty_register_device(tty3270_driver, minor - RAW3270_FIRSTMINOR, NULL);
 }
 
 void tty3270_destroy_cb(int minor)
 {
-        tty_unregister_device(tty3270_driver, minor);
+        tty_unregister_device(tty3270_driver, minor - RAW3270_FIRSTMINOR);
 }
 
 struct raw3270_notifier tty3270_notifier =
@@ -1884,7 +1885,8 @@ static int __init tty3270_init(void)
         driver->driver_name = "tty3270";
         driver->name = "3270/tty";
         driver->major = IBM_TTY3270_MAJOR;
-        driver->minor_start = 0;
+        driver->minor_start = RAW3270_FIRSTMINOR;
+        driver->name_base = RAW3270_FIRSTMINOR;
         driver->type = TTY_DRIVER_TYPE_SYSTEM;
         driver->subtype = SYSTEM_TYPE_TTY;
         driver->init_termios = tty_std_termios;
diff --git a/drivers/s390/char/zcore.c b/drivers/s390/char/zcore.c
index 1d61a01576d2..22820610022c 100644
--- a/drivers/s390/char/zcore.c
+++ b/drivers/s390/char/zcore.c
@@ -127,7 +127,7 @@ static int memcpy_hsa(void *dest, unsigned long src, size_t count, int mode)
         }
         if (mode == TO_USER) {
                 if (copy_to_user((__force __user void*) dest + offs, buf,
-                                 PAGE_SIZE))
+                                 count - offs))
                         return -EFAULT;
         } else
                 memcpy(dest + offs, buf, count - offs);
diff --git a/drivers/s390/cio/chp.c b/drivers/s390/cio/chp.c
index 50ad5fdd815d..21fabc6d5a9c 100644
--- a/drivers/s390/cio/chp.c
+++ b/drivers/s390/cio/chp.c
@@ -377,6 +377,26 @@ static void chp_release(struct device *dev)
 }
 
 /**
+ * chp_update_desc - update channel-path description
+ * @chp - channel-path
+ *
+ * Update the channel-path description of the specified channel-path.
+ * Return zero on success, non-zero otherwise.
+ */
+int chp_update_desc(struct channel_path *chp)
+{
+        int rc;
+
+        rc = chsc_determine_base_channel_path_desc(chp->chpid, &chp->desc);
+        if (rc)
+                return rc;
+
+        rc = chsc_determine_fmt1_channel_path_desc(chp->chpid, &chp->desc_fmt1);
+
+        return rc;
+}
+
+/**
  * chp_new - register a new channel-path
  * @chpid - channel-path ID
  *
@@ -403,7 +423,7 @@ int chp_new(struct chp_id chpid)
         mutex_init(&chp->lock);
 
         /* Obtain channel path description and fill it in. */
-        ret = chsc_determine_base_channel_path_desc(chpid, &chp->desc);
+        ret = chp_update_desc(chp);
         if (ret)
                 goto out_free;
         if ((chp->desc.flags & 0x80) == 0) {
diff --git a/drivers/s390/cio/chp.h b/drivers/s390/cio/chp.h
index e1399dbee834..9284b785a06f 100644
--- a/drivers/s390/cio/chp.h
+++ b/drivers/s390/cio/chp.h
@@ -44,6 +44,7 @@ struct channel_path {
         struct mutex lock; /* Serialize access to below members. */
         int state;
         struct channel_path_desc desc;
+        struct channel_path_desc_fmt1 desc_fmt1;
         /* Channel-measurement related stuff: */
         int cmg;
         int shared;
@@ -62,6 +63,7 @@ int chp_is_registered(struct chp_id chpid);
 void *chp_get_chp_desc(struct chp_id chpid);
 void chp_remove_cmg_attr(struct channel_path *chp);
 int chp_add_cmg_attr(struct channel_path *chp);
+int chp_update_desc(struct channel_path *chp);
 int chp_new(struct chp_id chpid);
 void chp_cfg_schedule(struct chp_id chpid, int configure);
 void chp_cfg_cancel_deconfigure(struct chp_id chpid);
diff --git a/drivers/s390/cio/chsc.c b/drivers/s390/cio/chsc.c
index 31ceef1beb8b..8ea7d9b2c671 100644
--- a/drivers/s390/cio/chsc.c
+++ b/drivers/s390/cio/chsc.c
@@ -376,7 +376,7 @@ static void chsc_process_sei_chp_avail(struct chsc_sei_nt0_area *sei_area)
                         continue;
                 }
                 mutex_lock(&chp->lock);
-                chsc_determine_base_channel_path_desc(chpid, &chp->desc);
+                chp_update_desc(chp);
                 mutex_unlock(&chp->lock);
         }
 }
@@ -433,6 +433,20 @@ static void chsc_process_sei_scm_change(struct chsc_sei_nt0_area *sei_area)
                               " failed (rc=%d).\n", ret);
 }
 
+static void chsc_process_sei_scm_avail(struct chsc_sei_nt0_area *sei_area)
+{
+        int ret;
+
+        CIO_CRW_EVENT(4, "chsc: scm available information\n");
+        if (sei_area->rs != 7)
+                return;
+
+        ret = scm_process_availability_information();
+        if (ret)
+                CIO_CRW_EVENT(0, "chsc: process availability information"
+                              " failed (rc=%d).\n", ret);
+}
+
 static void chsc_process_sei_nt2(struct chsc_sei_nt2_area *sei_area)
 {
         switch (sei_area->cc) {
@@ -468,6 +482,9 @@ static void chsc_process_sei_nt0(struct chsc_sei_nt0_area *sei_area)
         case 12: /* scm change notification */
                 chsc_process_sei_scm_change(sei_area);
                 break;
+        case 14: /* scm available notification */
+                chsc_process_sei_scm_avail(sei_area);
+                break;
         default: /* other stuff */
                 CIO_CRW_EVENT(2, "chsc: sei nt0 unhandled cc=%d\n",
                               sei_area->cc);
@@ -614,8 +631,8 @@ int chsc_chp_vary(struct chp_id chpid, int on)
          * Redo PathVerification on the devices the chpid connects to
          */
         if (on) {
-                /* Try to update the channel path descritor. */
-                chsc_determine_base_channel_path_desc(chpid, &chp->desc);
+                /* Try to update the channel path description. */
+                chp_update_desc(chp);
                 for_each_subchannel_staged(s390_subchannel_vary_chpid_on,
                                            __s390_vary_chpid_on, &chpid);
         } else
@@ -808,9 +825,10 @@ int chsc_determine_fmt1_channel_path_desc(struct chp_id chpid,
 {
         struct chsc_response_struct *chsc_resp;
         struct chsc_scpd *scpd_area;
+        unsigned long flags;
         int ret;
 
-        spin_lock_irq(&chsc_page_lock);
+        spin_lock_irqsave(&chsc_page_lock, flags);
         scpd_area = chsc_page;
         ret = chsc_determine_channel_path_desc(chpid, 0, 0, 1, 0, scpd_area);
         if (ret)
@@ -818,7 +836,7 @@ int chsc_determine_fmt1_channel_path_desc(struct chp_id chpid,
         chsc_resp = (void *)&scpd_area->response;
         memcpy(desc, &chsc_resp->data, sizeof(*desc));
 out:
-        spin_unlock_irq(&chsc_page_lock);
+        spin_unlock_irqrestore(&chsc_page_lock, flags);
         return ret;
 }
 
diff --git a/drivers/s390/cio/chsc.h b/drivers/s390/cio/chsc.h
index 227e05f674b3..349d5fc47196 100644
--- a/drivers/s390/cio/chsc.h
+++ b/drivers/s390/cio/chsc.h
@@ -156,8 +156,10 @@ int chsc_scm_info(struct chsc_scm_info *scm_area, u64 token);
 
 #ifdef CONFIG_SCM_BUS
 int scm_update_information(void);
+int scm_process_availability_information(void);
 #else /* CONFIG_SCM_BUS */
 static inline int scm_update_information(void) { return 0; }
+static inline int scm_process_availability_information(void) { return 0; }
 #endif /* CONFIG_SCM_BUS */
 
 
diff --git a/drivers/s390/cio/cio.c b/drivers/s390/cio/cio.c
index 986ef6a92a41..935d80b4e9ce 100644
--- a/drivers/s390/cio/cio.c
+++ b/drivers/s390/cio/cio.c
@@ -471,15 +471,6 @@ int cio_disable_subchannel(struct subchannel *sch)
 }
 EXPORT_SYMBOL_GPL(cio_disable_subchannel);
 
-int cio_create_sch_lock(struct subchannel *sch)
-{
-        sch->lock = kmalloc(sizeof(spinlock_t), GFP_KERNEL);
-        if (!sch->lock)
-                return -ENOMEM;
-        spin_lock_init(sch->lock);
-        return 0;
-}
-
 static int cio_check_devno_blacklisted(struct subchannel *sch)
 {
         if (is_blacklisted(sch->schid.ssid, sch->schib.pmcw.dev)) {
@@ -536,32 +527,19 @@ int cio_validate_subchannel(struct subchannel *sch, struct subchannel_id schid)
         sprintf(dbf_txt, "valsch%x", schid.sch_no);
         CIO_TRACE_EVENT(4, dbf_txt);
 
-        /* Nuke all fields. */
-        memset(sch, 0, sizeof(struct subchannel));
-
-        sch->schid = schid;
-        if (cio_is_console(schid)) {
-                sch->lock = cio_get_console_lock();
-        } else {
-                err = cio_create_sch_lock(sch);
-                if (err)
-                        goto out;
-        }
-        mutex_init(&sch->reg_mutex);
-
         /*
          * The first subchannel that is not-operational (ccode==3)
-         *  indicates that there aren't any more devices available.
+         * indicates that there aren't any more devices available.
          * If stsch gets an exception, it means the current subchannel set
-         *  is not valid.
+         * is not valid.
          */
-        ccode = stsch_err (schid, &sch->schib);
+        ccode = stsch_err(schid, &sch->schib);
         if (ccode) {
                 err = (ccode == 3) ? -ENXIO : ccode;
                 goto out;
         }
-        /* Copy subchannel type from path management control word. */
         sch->st = sch->schib.pmcw.st;
+        sch->schid = schid;
 
         switch (sch->st) {
         case SUBCHANNEL_TYPE_IO:
@@ -578,11 +556,7 @@ int cio_validate_subchannel(struct subchannel *sch, struct subchannel_id schid)
 
         CIO_MSG_EVENT(4, "Subchannel 0.%x.%04x reports subchannel type %04X\n",
                       sch->schid.ssid, sch->schid.sch_no, sch->st);
-        return 0;
 out:
-        if (!cio_is_console(schid))
-                kfree(sch->lock);
-        sch->lock = NULL;
         return err;
 }
 
@@ -650,15 +624,13 @@ void __irq_entry do_IRQ(struct pt_regs *regs)
 }
 
 #ifdef CONFIG_CCW_CONSOLE
-static struct subchannel console_subchannel;
-static struct io_subchannel_private console_priv;
-static int console_subchannel_in_use;
+static struct subchannel *console_sch;
 
 /*
  * Use cio_tsch to update the subchannel status and call the interrupt handler
- * if status had been pending. Called with the console_subchannel lock.
+ * if status had been pending. Called with the subchannel's lock held.
  */
-static void cio_tsch(struct subchannel *sch)
+void cio_tsch(struct subchannel *sch)
 {
         struct irb *irb;
         int irq_context;
@@ -675,6 +647,7 @@ static void cio_tsch(struct subchannel *sch)
                 local_bh_disable();
                 irq_enter();
         }
+        kstat_incr_irqs_this_cpu(IO_INTERRUPT, NULL);
         if (sch->driver && sch->driver->irq)
                 sch->driver->irq(sch);
         else
@@ -685,135 +658,90 @@ static void cio_tsch(struct subchannel *sch)
         }
 }
 
-void *cio_get_console_priv(void)
-{
-        return &console_priv;
-}
-
-/*
- * busy wait for the next interrupt on the console
- */
-void wait_cons_dev(void)
+static int cio_test_for_console(struct subchannel_id schid, void *data)
 {
-        if (!console_subchannel_in_use)
-                return;
-
-        while (1) {
-                cio_tsch(&console_subchannel);
-                if (console_subchannel.schib.scsw.cmd.actl == 0)
-                        break;
-                udelay_simple(100);
-        }
-}
+        struct schib schib;
 
-static int
-cio_test_for_console(struct subchannel_id schid, void *data)
-{
-        if (stsch_err(schid, &console_subchannel.schib) != 0)
+        if (stsch_err(schid, &schib) != 0)
                 return -ENXIO;
-        if ((console_subchannel.schib.pmcw.st == SUBCHANNEL_TYPE_IO) &&
-            console_subchannel.schib.pmcw.dnv &&
-            (console_subchannel.schib.pmcw.dev == console_devno)) {
+        if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv &&
+            (schib.pmcw.dev == console_devno)) {
                 console_irq = schid.sch_no;
                 return 1; /* found */
         }
         return 0;
 }
 
-
-static int
-cio_get_console_sch_no(void)
+static int cio_get_console_sch_no(void)
 {
         struct subchannel_id schid;
-        
+        struct schib schib;
+
         init_subchannel_id(&schid);
         if (console_irq != -1) {
                 /* VM provided us with the irq number of the console. */
                 schid.sch_no = console_irq;
-                if (stsch_err(schid, &console_subchannel.schib) != 0 ||
-                    (console_subchannel.schib.pmcw.st != SUBCHANNEL_TYPE_IO) ||
-                    !console_subchannel.schib.pmcw.dnv)
+                if (stsch_err(schid, &schib) != 0 ||
+                    (schib.pmcw.st != SUBCHANNEL_TYPE_IO) || !schib.pmcw.dnv)
                         return -1;
-                console_devno = console_subchannel.schib.pmcw.dev;
+                console_devno = schib.pmcw.dev;
         } else if (console_devno != -1) {
                 /* At least the console device number is known. */
                 for_each_subchannel(cio_test_for_console, NULL);
-                if (console_irq == -1)
-                        return -1;
-        } else {
-                /* unlike in 2.4, we cannot autoprobe here, since
-                 * the channel subsystem is not fully initialized.
-                 * With some luck, the HWC console can take over */
-                return -1;
         }
         return console_irq;
 }
 
-struct subchannel *
-cio_probe_console(void)
+struct subchannel *cio_probe_console(void)
 {
-        int sch_no, ret;
         struct subchannel_id schid;
+        struct subchannel *sch;
+        int sch_no, ret;
 
-        if (xchg(&console_subchannel_in_use, 1) != 0)
-                return ERR_PTR(-EBUSY);
         sch_no = cio_get_console_sch_no();
         if (sch_no == -1) {
-                console_subchannel_in_use = 0;
                 pr_warning("No CCW console was found\n");
                 return ERR_PTR(-ENODEV);
         }
-        memset(&console_subchannel, 0, sizeof(struct subchannel));
         init_subchannel_id(&schid);
         schid.sch_no = sch_no;
-        ret = cio_validate_subchannel(&console_subchannel, schid);
-        if (ret) {
-                console_subchannel_in_use = 0;
-                return ERR_PTR(-ENODEV);
-        }
+        sch = css_alloc_subchannel(schid);
+        if (IS_ERR(sch))
+                return sch;
 
-        /*
-         * enable console I/O-interrupt subclass
-         */
         isc_register(CONSOLE_ISC);
-        console_subchannel.config.isc = CONSOLE_ISC;
-        console_subchannel.config.intparm = (u32)(addr_t)&console_subchannel;
-        ret = cio_commit_config(&console_subchannel);
+        sch->config.isc = CONSOLE_ISC;
+        sch->config.intparm = (u32)(addr_t)sch;
+        ret = cio_commit_config(sch);
         if (ret) {
                 isc_unregister(CONSOLE_ISC);
-                console_subchannel_in_use = 0;
+                put_device(&sch->dev);
                 return ERR_PTR(ret);
         }
-        return &console_subchannel;
-}
-
-void
-cio_release_console(void)
-{
-        console_subchannel.config.intparm = 0;
-        cio_commit_config(&console_subchannel);
-        isc_unregister(CONSOLE_ISC);
-        console_subchannel_in_use = 0;
+        console_sch = sch;
+        return sch;
 }
 
-/* Bah... hack to catch console special sausages. */
-int
-cio_is_console(struct subchannel_id schid)
+int cio_is_console(struct subchannel_id schid)
 {
-        if (!console_subchannel_in_use)
+        if (!console_sch)
                 return 0;
-        return schid_equal(&schid, &console_subchannel.schid);
+        return schid_equal(&schid, &console_sch->schid);
 }
 
-struct subchannel *
-cio_get_console_subchannel(void)
+void cio_register_early_subchannels(void)
 {
-        if (!console_subchannel_in_use)
-                return NULL;
-        return &console_subchannel;
+        int ret;
+
+        if (!console_sch)
+                return;
+
+        ret = css_register_subchannel(console_sch);
+        if (ret)
+                put_device(&console_sch->dev);
 }
+#endif /* CONFIG_CCW_CONSOLE */
 
-#endif
 static int
 __disable_subchannel_easy(struct subchannel_id schid, struct schib *schib)
 {
diff --git a/drivers/s390/cio/cio.h b/drivers/s390/cio/cio.h
index 4a1ff5c2eb88..d62f5e7f3cf1 100644
--- a/drivers/s390/cio/cio.h
+++ b/drivers/s390/cio/cio.h
@@ -121,23 +121,18 @@ extern int cio_commit_config(struct subchannel *sch);
 int cio_tm_start_key(struct subchannel *sch, struct tcw *tcw, u8 lpm, u8 key);
 int cio_tm_intrg(struct subchannel *sch);
 
-int cio_create_sch_lock(struct subchannel *);
 void do_adapter_IO(u8 isc);
 void do_IRQ(struct pt_regs *);
 
 /* Use with care. */
 #ifdef CONFIG_CCW_CONSOLE
 extern struct subchannel *cio_probe_console(void);
-extern void cio_release_console(void);
 extern int cio_is_console(struct subchannel_id);
-extern struct subchannel *cio_get_console_subchannel(void);
-extern spinlock_t * cio_get_console_lock(void);
-extern void *cio_get_console_priv(void);
+extern void cio_register_early_subchannels(void);
+extern void cio_tsch(struct subchannel *sch);
 #else
 #define cio_is_console(schid) 0
-#define cio_get_console_subchannel() NULL
-#define cio_get_console_lock() NULL
-#define cio_get_console_priv() NULL
+static inline void cio_register_early_subchannels(void) {}
 #endif
 
 #endif
diff --git a/drivers/s390/cio/css.c b/drivers/s390/cio/css.c
index a239237d43f3..1ebe5d3ddebb 100644
--- a/drivers/s390/cio/css.c
+++ b/drivers/s390/cio/css.c
@@ -137,37 +137,53 @@ out:
 
 static void css_sch_todo(struct work_struct *work);
 
-static struct subchannel *
-css_alloc_subchannel(struct subchannel_id schid)
+static int css_sch_create_locks(struct subchannel *sch)
+{
+        sch->lock = kmalloc(sizeof(*sch->lock), GFP_KERNEL);
+        if (!sch->lock)
+                return -ENOMEM;
+
+        spin_lock_init(sch->lock);
+        mutex_init(&sch->reg_mutex);
+
+        return 0;
+}
+
+static void css_subchannel_release(struct device *dev)
+{
+        struct subchannel *sch = to_subchannel(dev);
+
+        sch->config.intparm = 0;
+        cio_commit_config(sch);
+        kfree(sch->lock);
+        kfree(sch);
+}
+
+struct subchannel *css_alloc_subchannel(struct subchannel_id schid)
 {
         struct subchannel *sch;
         int ret;
 
-        sch = kmalloc (sizeof (*sch), GFP_KERNEL | GFP_DMA);
-        if (sch == NULL)
+        sch = kzalloc(sizeof(*sch), GFP_KERNEL | GFP_DMA);
+        if (!sch)
                 return ERR_PTR(-ENOMEM);
-        ret = cio_validate_subchannel (sch, schid);
-        if (ret < 0) {
-                kfree(sch);
-                return ERR_PTR(ret);
-        }
+
+        ret = cio_validate_subchannel(sch, schid);
+        if (ret < 0)
+                goto err;
+
+        ret = css_sch_create_locks(sch);
+        if (ret)
+                goto err;
+
         INIT_WORK(&sch->todo_work, css_sch_todo);
+        sch->dev.release = &css_subchannel_release;
+        device_initialize(&sch->dev);
         return sch;
-}
-
-static void
-css_subchannel_release(struct device *dev)
-{
-        struct subchannel *sch;
 
-        sch = to_subchannel(dev);
-        if (!cio_is_console(sch->schid)) {
-                /* Reset intparm to zeroes. */
-                sch->config.intparm = 0;
-                cio_commit_config(sch);
-                kfree(sch->lock);
-                kfree(sch);
-        }
+err:
+        kfree(sch);
+        return ERR_PTR(ret);
 }
 
 static int css_sch_device_register(struct subchannel *sch)
@@ -177,7 +193,7 @@ static int css_sch_device_register(struct subchannel *sch)
         mutex_lock(&sch->reg_mutex);
         dev_set_name(&sch->dev, "0.%x.%04x", sch->schid.ssid,
                      sch->schid.sch_no);
-        ret = device_register(&sch->dev);
+        ret = device_add(&sch->dev);
         mutex_unlock(&sch->reg_mutex);
         return ret;
 }
@@ -228,16 +244,11 @@ void css_update_ssd_info(struct subchannel *sch)
 {
         int ret;
 
-        if (cio_is_console(sch->schid)) {
-                /* Console is initialized too early for functions requiring
-                 * memory allocation. */
+        ret = chsc_get_ssd_info(sch->schid, &sch->ssd_info);
+        if (ret)
                 ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw);
-        } else {
-                ret = chsc_get_ssd_info(sch->schid, &sch->ssd_info);
-                if (ret)
-                        ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw);
-                ssd_register_chpids(&sch->ssd_info);
-        }
+
+        ssd_register_chpids(&sch->ssd_info);
 }
 
 static ssize_t type_show(struct device *dev, struct device_attribute *attr,
@@ -275,14 +286,13 @@ static const struct attribute_group *default_subch_attr_groups[] = {
         NULL,
 };
 
-static int css_register_subchannel(struct subchannel *sch)
+int css_register_subchannel(struct subchannel *sch)
 {
         int ret;
 
         /* Initialize the subchannel structure */
         sch->dev.parent = &channel_subsystems[0]->device;
         sch->dev.bus = &css_bus_type;
-        sch->dev.release = &css_subchannel_release;
         sch->dev.groups = default_subch_attr_groups;
         /*
          * We don't want to generate uevents for I/O subchannels that don't
@@ -314,23 +324,19 @@ static int css_register_subchannel(struct subchannel *sch)
         return ret;
 }
 
-int css_probe_device(struct subchannel_id schid)
+static int css_probe_device(struct subchannel_id schid)
 {
-        int ret;
         struct subchannel *sch;
+        int ret;
+
+        sch = css_alloc_subchannel(schid);
+        if (IS_ERR(sch))
+                return PTR_ERR(sch);
 
-        if (cio_is_console(schid))
-                sch = cio_get_console_subchannel();
-        else {
-                sch = css_alloc_subchannel(schid);
-                if (IS_ERR(sch))
-                        return PTR_ERR(sch);
-        }
         ret = css_register_subchannel(sch);
-        if (ret) {
-                if (!cio_is_console(schid))
-                        put_device(&sch->dev);
-        }
+        if (ret)
+                put_device(&sch->dev);
+
         return ret;
 }
 
@@ -770,7 +776,7 @@ static int __init setup_css(int nr)
         css->pseudo_subchannel->dev.release = css_subchannel_release;
         dev_set_name(&css->pseudo_subchannel->dev, "defunct");
         mutex_init(&css->pseudo_subchannel->reg_mutex);
-        ret = cio_create_sch_lock(css->pseudo_subchannel);
+        ret = css_sch_create_locks(css->pseudo_subchannel);
         if (ret) {
                 kfree(css->pseudo_subchannel);
                 return ret;
@@ -870,8 +876,7 @@ static struct notifier_block css_power_notifier = {
 
 /*
  * Now that the driver core is running, we can setup our channel subsystem.
- * The struct subchannel's are created during probing (except for the
- * static console subchannel).
+ * The struct subchannel's are created during probing.
  */
 static int __init css_bus_init(void)
 {
@@ -1050,6 +1055,8 @@ int css_complete_work(void)
  */
 static int __init channel_subsystem_init_sync(void)
 {
+        /* Register subchannels which are already in use. */
+        cio_register_early_subchannels();
         /* Start initial subchannel evaluation. */
         css_schedule_eval_all();
         css_complete_work();
@@ -1065,9 +1072,8 @@ void channel_subsystem_reinit(void)
         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);
+                if (chp)
+                        chp_update_desc(chp);
         }
 }
 
diff --git a/drivers/s390/cio/css.h b/drivers/s390/cio/css.h
index 4af3dfe70ef5..b1de60335238 100644
--- a/drivers/s390/cio/css.h
+++ b/drivers/s390/cio/css.h
@@ -101,7 +101,8 @@ extern int css_driver_register(struct css_driver *);
 extern void css_driver_unregister(struct css_driver *);
 
 extern void css_sch_device_unregister(struct subchannel *);
-extern int css_probe_device(struct subchannel_id);
+extern int css_register_subchannel(struct subchannel *);
+extern struct subchannel *css_alloc_subchannel(struct subchannel_id);
 extern struct subchannel *get_subchannel_by_schid(struct subchannel_id);
 extern int css_init_done;
 extern int max_ssid;
@@ -109,7 +110,6 @@ int for_each_subchannel_staged(int (*fn_known)(struct subchannel *, void *),
                                int (*fn_unknown)(struct subchannel_id,
                                void *), void *data);
 extern int for_each_subchannel(int(*fn)(struct subchannel_id, void *), void *);
-extern void css_reiterate_subchannels(void);
 void css_update_ssd_info(struct subchannel *sch);
 
 struct channel_subsystem {
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index c6767f5a58b2..1ab5f6c36d9b 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -19,6 +19,7 @@
 #include <linux/list.h>
 #include <linux/device.h>
 #include <linux/workqueue.h>
+#include <linux/delay.h>
 #include <linux/timer.h>
 #include <linux/kernel_stat.h>
 
@@ -43,6 +44,10 @@ static DEFINE_SPINLOCK(recovery_lock);
 static int recovery_phase;
 static const unsigned long recovery_delay[] = { 3, 30, 300 };
 
+static atomic_t ccw_device_init_count = ATOMIC_INIT(0);
+static DECLARE_WAIT_QUEUE_HEAD(ccw_device_init_wq);
+static struct bus_type ccw_bus_type;
+
 /******************* bus type handling ***********************/
 
 /* The Linux driver model distinguishes between a bus type and
@@ -127,8 +132,6 @@ static int ccw_uevent(struct device *dev, struct kobj_uevent_env *env)
         return ret;
 }
 
-static struct bus_type ccw_bus_type;
-
 static void io_subchannel_irq(struct subchannel *);
 static int io_subchannel_probe(struct subchannel *);
 static int io_subchannel_remove(struct subchannel *);
@@ -137,8 +140,6 @@ static int io_subchannel_sch_event(struct subchannel *, int);
 static int io_subchannel_chp_event(struct subchannel *, struct chp_link *,
                                    int);
 static void recovery_func(unsigned long data);
-wait_queue_head_t ccw_device_init_wq;
-atomic_t ccw_device_init_count;
 
 static struct css_device_id io_subchannel_ids[] = {
         { .match_flags = 0x1, .type = SUBCHANNEL_TYPE_IO, },
@@ -191,10 +192,7 @@ int __init io_subchannel_init(void)
 {
         int ret;
 
-        init_waitqueue_head(&ccw_device_init_wq);
-        atomic_set(&ccw_device_init_count, 0);
         setup_timer(&recovery_timer, recovery_func, 0);
-
         ret = bus_register(&ccw_bus_type);
         if (ret)
                 return ret;
@@ -1086,19 +1084,14 @@ static int io_subchannel_probe(struct subchannel *sch)
                 dev_set_uevent_suppress(&sch->dev, 0);
                 kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
                 cdev = sch_get_cdev(sch);
-                cdev->dev.groups = ccwdev_attr_groups;
-                device_initialize(&cdev->dev);
-                cdev->private->flags.initialized = 1;
-                ccw_device_register(cdev);
-                /*
-                 * Check if the device is already online. If it is
-                 * the reference count needs to be corrected since we
-                 * didn't obtain a reference in ccw_device_set_online.
-                 */
-                if (cdev->private->state != DEV_STATE_NOT_OPER &&
-                    cdev->private->state != DEV_STATE_OFFLINE &&
-                    cdev->private->state != DEV_STATE_BOXED)
-                        get_device(&cdev->dev);
+                rc = ccw_device_register(cdev);
+                if (rc) {
+                        /* Release online reference. */
+                        put_device(&cdev->dev);
+                        goto out_schedule;
+                }
+                if (atomic_dec_and_test(&ccw_device_init_count))
+                        wake_up(&ccw_device_init_wq);
                 return 0;
         }
         io_subchannel_init_fields(sch);
@@ -1580,88 +1573,102 @@ out:
 }
 
 #ifdef CONFIG_CCW_CONSOLE
-static struct ccw_device console_cdev;
-static struct ccw_device_private console_private;
-static int console_cdev_in_use;
-
-static DEFINE_SPINLOCK(ccw_console_lock);
-
-spinlock_t * cio_get_console_lock(void)
-{
-        return &ccw_console_lock;
-}
-
 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. */
-        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)
                 return rc;
         sch->driver = &io_subchannel_driver;
-        /* Initialize the ccw_device structure. */
-        cdev->dev.parent= &sch->dev;
         sch_set_cdev(sch, cdev);
         io_subchannel_recog(cdev, sch);
         /* Now wait for the async. recognition to come to an end. */
         spin_lock_irq(cdev->ccwlock);
         while (!dev_fsm_final_state(cdev))
-                wait_cons_dev();
-        rc = -EIO;
-        if (cdev->private->state != DEV_STATE_OFFLINE)
+                ccw_device_wait_idle(cdev);
+
+        /* Hold on to an extra reference while device is online. */
+        get_device(&cdev->dev);
+        rc = ccw_device_online(cdev);
+        if (rc)
                 goto out_unlock;
-        ccw_device_online(cdev);
+
         while (!dev_fsm_final_state(cdev))
-                wait_cons_dev();
-        if (cdev->private->state != DEV_STATE_ONLINE)
-                goto out_unlock;
-        rc = 0;
+                ccw_device_wait_idle(cdev);
+
+        if (cdev->private->state == DEV_STATE_ONLINE)
+                cdev->online = 1;
+        else
+                rc = -EIO;
 out_unlock:
         spin_unlock_irq(cdev->ccwlock);
+        if (rc) /* Give up online reference since onlining failed. */
+                put_device(&cdev->dev);
         return rc;
 }
 
-struct ccw_device *
-ccw_device_probe_console(void)
+struct ccw_device *ccw_device_probe_console(void)
 {
+        struct io_subchannel_private *io_priv;
+        struct ccw_device *cdev;
         struct subchannel *sch;
         int ret;
 
-        if (xchg(&console_cdev_in_use, 1) != 0)
-                return ERR_PTR(-EBUSY);
         sch = cio_probe_console();
-        if (IS_ERR(sch)) {
-                console_cdev_in_use = 0;
-                return (void *) sch;
+        if (IS_ERR(sch))
+                return ERR_CAST(sch);
+
+        io_priv = kzalloc(sizeof(*io_priv), GFP_KERNEL | GFP_DMA);
+        if (!io_priv) {
+                put_device(&sch->dev);
+                return ERR_PTR(-ENOMEM);
         }
-        memset(&console_cdev, 0, sizeof(struct ccw_device));
-        memset(&console_private, 0, sizeof(struct ccw_device_private));
-        console_cdev.private = &console_private;
-        console_private.cdev = &console_cdev;
-        console_private.int_class = IRQIO_CIO;
-        ret = ccw_device_console_enable(&console_cdev, sch);
+        cdev = io_subchannel_create_ccwdev(sch);
+        if (IS_ERR(cdev)) {
+                put_device(&sch->dev);
+                kfree(io_priv);
+                return cdev;
+        }
+        set_io_private(sch, io_priv);
+        ret = ccw_device_console_enable(cdev, sch);
         if (ret) {
-                cio_release_console();
-                console_cdev_in_use = 0;
+                set_io_private(sch, NULL);
+                put_device(&sch->dev);
+                put_device(&cdev->dev);
+                kfree(io_priv);
                 return ERR_PTR(ret);
         }
-        console_cdev.online = 1;
-        return &console_cdev;
+        return cdev;
+}
+
+/**
+ * ccw_device_wait_idle() - busy wait for device to become idle
+ * @cdev: ccw device
+ *
+ * Poll until activity control is zero, that is, no function or data
+ * transfer is pending/active.
+ * Called with device lock being held.
+ */
+void ccw_device_wait_idle(struct ccw_device *cdev)
+{
+        struct subchannel *sch = to_subchannel(cdev->dev.parent);
+
+        while (1) {
+                cio_tsch(sch);
+                if (sch->schib.scsw.cmd.actl == 0)
+                        break;
+                udelay_simple(100);
+        }
 }
 
 static int ccw_device_pm_restore(struct device *dev);
 
-int ccw_device_force_console(void)
+int ccw_device_force_console(struct ccw_device *cdev)
 {
-        if (!console_cdev_in_use)
-                return -ENODEV;
-        return ccw_device_pm_restore(&console_cdev.dev);
+        return ccw_device_pm_restore(&cdev->dev);
 }
 EXPORT_SYMBOL_GPL(ccw_device_force_console);
 #endif
diff --git a/drivers/s390/cio/device.h b/drivers/s390/cio/device.h
index 7d4ecb65db00..8d1d29873172 100644
--- a/drivers/s390/cio/device.h
+++ b/drivers/s390/cio/device.h
@@ -81,8 +81,6 @@ dev_fsm_final_state(struct ccw_device *cdev)
                 cdev->private->state == DEV_STATE_BOXED);
 }
 
-extern wait_queue_head_t ccw_device_init_wq;
-extern atomic_t ccw_device_init_count;
 int __init io_subchannel_init(void);
 
 void io_subchannel_recog_done(struct ccw_device *cdev);
diff --git a/drivers/s390/cio/device_ops.c b/drivers/s390/cio/device_ops.c
index c77b6e06bf64..4845d64f2842 100644
--- a/drivers/s390/cio/device_ops.c
+++ b/drivers/s390/cio/device_ops.c
@@ -704,9 +704,9 @@ EXPORT_SYMBOL(ccw_device_tm_start_timeout);
 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 channel_path *chp;
         struct chp_id chpid;
-        int mdc = 0, ret, i;
+        int mdc = 0, i;
 
         /* Adjust requested path mask to excluded varied off paths. */
         if (mask)
@@ -719,14 +719,20 @@ int ccw_device_get_mdc(struct ccw_device *cdev, u8 mask)
                 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)
+                chp = chpid_to_chp(chpid);
+                if (!chp)
+                        continue;
+
+                mutex_lock(&chp->lock);
+                if (!chp->desc_fmt1.f) {
+                        mutex_unlock(&chp->lock);
                         return 0;
-                if (!desc.r)
+                }
+                if (!chp->desc_fmt1.r)
                         mdc = 1;
-                mdc = mdc ? min(mdc, (int)desc.mdc) : desc.mdc;
+                mdc = mdc ? min_t(int, mdc, chp->desc_fmt1.mdc) :
+                            chp->desc_fmt1.mdc;
+                mutex_unlock(&chp->lock);
         }
 
         return mdc;
diff --git a/drivers/s390/cio/idset.c b/drivers/s390/cio/idset.c
index 65d13e38803f..5a999084a229 100644
--- a/drivers/s390/cio/idset.c
+++ b/drivers/s390/cio/idset.c
@@ -17,7 +17,7 @@ struct idset {
 
 static inline unsigned long bitmap_size(int num_ssid, int num_id)
 {
-        return __BITOPS_WORDS(num_ssid * num_id) * sizeof(unsigned long);
+        return BITS_TO_LONGS(num_ssid * num_id) * sizeof(unsigned long);
 }
 
 static struct idset *idset_new(int num_ssid, int num_id)
diff --git a/drivers/s390/cio/scm.c b/drivers/s390/cio/scm.c
index bcf20f3aa51b..46ec25632e8b 100644
--- a/drivers/s390/cio/scm.c
+++ b/drivers/s390/cio/scm.c
@@ -211,7 +211,7 @@ static void scmdev_update(struct scm_device *scmdev, struct sale *sale)
                 goto out;
         scmdrv = to_scm_drv(scmdev->dev.driver);
         if (changed && scmdrv->notify)
-                scmdrv->notify(scmdev);
+                scmdrv->notify(scmdev, SCM_CHANGE);
 out:
         device_unlock(&scmdev->dev);
         if (changed)
@@ -297,6 +297,22 @@ int scm_update_information(void)
         return ret;
 }
 
+static int scm_dev_avail(struct device *dev, void *unused)
+{
+        struct scm_driver *scmdrv = to_scm_drv(dev->driver);
+        struct scm_device *scmdev = to_scm_dev(dev);
+
+        if (dev->driver && scmdrv->notify)
+                scmdrv->notify(scmdev, SCM_AVAIL);
+
+        return 0;
+}
+
+int scm_process_availability_information(void)
+{
+        return bus_for_each_dev(&scm_bus_type, NULL, NULL, scm_dev_avail);
+}
+
 static int __init scm_init(void)
 {
         int ret;
diff --git a/drivers/s390/net/qeth_core.h b/drivers/s390/net/qeth_core.h
index d87961d4c0de..6ccb7457746b 100644
--- a/drivers/s390/net/qeth_core.h
+++ b/drivers/s390/net/qeth_core.h
@@ -769,6 +769,7 @@ struct qeth_card {
         unsigned long thread_start_mask;
         unsigned long thread_allowed_mask;
         unsigned long thread_running_mask;
+        struct task_struct *recovery_task;
         spinlock_t ip_lock;
         struct list_head ip_list;
         struct list_head *ip_tbd_list;
@@ -862,6 +863,8 @@ extern struct qeth_card_list_struct qeth_core_card_list;
 extern struct kmem_cache *qeth_core_header_cache;
 extern struct qeth_dbf_info qeth_dbf[QETH_DBF_INFOS];
 
+void qeth_set_recovery_task(struct qeth_card *);
+void qeth_clear_recovery_task(struct qeth_card *);
 void qeth_set_allowed_threads(struct qeth_card *, unsigned long , int);
 int qeth_threads_running(struct qeth_card *, unsigned long);
 int qeth_wait_for_threads(struct qeth_card *, unsigned long);
@@ -916,6 +919,7 @@ int qeth_send_control_data(struct qeth_card *, int, struct qeth_cmd_buffer *,
         void *reply_param);
 int qeth_get_priority_queue(struct qeth_card *, struct sk_buff *, int, int);
 int qeth_get_elements_no(struct qeth_card *, void *, struct sk_buff *, int);
+int qeth_get_elements_for_frags(struct sk_buff *);
 int qeth_do_send_packet_fast(struct qeth_card *, struct qeth_qdio_out_q *,
                         struct sk_buff *, struct qeth_hdr *, int, int, int);
 int qeth_do_send_packet(struct qeth_card *, struct qeth_qdio_out_q *,
diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c
index 0d8cdff81813..451f92020599 100644
--- a/drivers/s390/net/qeth_core_main.c
+++ b/drivers/s390/net/qeth_core_main.c
@@ -177,6 +177,23 @@ const char *qeth_get_cardname_short(struct qeth_card *card)
         return "n/a";
 }
 
+void qeth_set_recovery_task(struct qeth_card *card)
+{
+        card->recovery_task = current;
+}
+EXPORT_SYMBOL_GPL(qeth_set_recovery_task);
+
+void qeth_clear_recovery_task(struct qeth_card *card)
+{
+        card->recovery_task = NULL;
+}
+EXPORT_SYMBOL_GPL(qeth_clear_recovery_task);
+
+static bool qeth_is_recovery_task(const struct qeth_card *card)
+{
+        return card->recovery_task == current;
+}
+
 void qeth_set_allowed_threads(struct qeth_card *card, unsigned long threads,
                          int clear_start_mask)
 {
@@ -205,6 +222,8 @@ EXPORT_SYMBOL_GPL(qeth_threads_running);
 
 int qeth_wait_for_threads(struct qeth_card *card, unsigned long threads)
 {
+        if (qeth_is_recovery_task(card))
+                return 0;
         return wait_event_interruptible(card->wait_q,
                         qeth_threads_running(card, threads) == 0);
 }
@@ -3679,6 +3698,25 @@ int qeth_get_priority_queue(struct qeth_card *card, struct sk_buff *skb,
 }
 EXPORT_SYMBOL_GPL(qeth_get_priority_queue);
 
+int qeth_get_elements_for_frags(struct sk_buff *skb)
+{
+        int cnt, length, e, elements = 0;
+        struct skb_frag_struct *frag;
+        char *data;
+
+        for (cnt = 0; cnt < skb_shinfo(skb)->nr_frags; cnt++) {
+                frag = &skb_shinfo(skb)->frags[cnt];
+                data = (char *)page_to_phys(skb_frag_page(frag)) +
+                        frag->page_offset;
+                length = frag->size;
+                e = PFN_UP((unsigned long)data + length - 1) -
+                        PFN_DOWN((unsigned long)data);
+                elements += e;
+        }
+        return elements;
+}
+EXPORT_SYMBOL_GPL(qeth_get_elements_for_frags);
+
 int qeth_get_elements_no(struct qeth_card *card, void *hdr,
                      struct sk_buff *skb, int elems)
 {
@@ -3686,7 +3724,8 @@ int qeth_get_elements_no(struct qeth_card *card, void *hdr,
         int elements_needed = PFN_UP((unsigned long)skb->data + dlen - 1) -
                 PFN_DOWN((unsigned long)skb->data);
 
-        elements_needed += skb_shinfo(skb)->nr_frags;
+        elements_needed += qeth_get_elements_for_frags(skb);
+
         if ((elements_needed + elems) > QETH_MAX_BUFFER_ELEMENTS(card)) {
                 QETH_DBF_MESSAGE(2, "Invalid size of IP packet "
                         "(Number=%d / Length=%d). Discarded.\n",
@@ -3771,12 +3810,23 @@ static inline void __qeth_fill_buffer(struct sk_buff *skb,
 
         for (cnt = 0; cnt < skb_shinfo(skb)->nr_frags; cnt++) {
                 frag = &skb_shinfo(skb)->frags[cnt];
-                buffer->element[element].addr = (char *)
-                        page_to_phys(skb_frag_page(frag))
-                        + frag->page_offset;
-                buffer->element[element].length = frag->size;
-                buffer->element[element].eflags = SBAL_EFLAGS_MIDDLE_FRAG;
-                element++;
+                data = (char *)page_to_phys(skb_frag_page(frag)) +
+                        frag->page_offset;
+                length = frag->size;
+                while (length > 0) {
+                        length_here = PAGE_SIZE -
+                                ((unsigned long) data % PAGE_SIZE);
+                        if (length < length_here)
+                                length_here = length;
+
+                        buffer->element[element].addr = data;
+                        buffer->element[element].length = length_here;
+                        buffer->element[element].eflags =
+                                SBAL_EFLAGS_MIDDLE_FRAG;
+                        length -= length_here;
+                        data += length_here;
+                        element++;
+                }
         }
 
         if (buffer->element[element - 1].eflags)
diff --git a/drivers/s390/net/qeth_l2_main.c b/drivers/s390/net/qeth_l2_main.c
index d690166efeaf..155b101bd730 100644
--- a/drivers/s390/net/qeth_l2_main.c
+++ b/drivers/s390/net/qeth_l2_main.c
@@ -1143,6 +1143,7 @@ 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");
+        qeth_set_recovery_task(card);
         __qeth_l2_set_offline(card->gdev, 1);
         rc = __qeth_l2_set_online(card->gdev, 1);
         if (!rc)
@@ -1153,6 +1154,7 @@ 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_recovery_task(card);
         qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
         qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
         return 0;
diff --git a/drivers/s390/net/qeth_l3_main.c b/drivers/s390/net/qeth_l3_main.c
index 091ca0efa1c5..1f7edf1b26c3 100644
--- a/drivers/s390/net/qeth_l3_main.c
+++ b/drivers/s390/net/qeth_l3_main.c
@@ -623,7 +623,7 @@ static int qeth_l3_send_setrouting(struct qeth_card *card,
         return rc;
 }
 
-static void qeth_l3_correct_routing_type(struct qeth_card *card,
+static int qeth_l3_correct_routing_type(struct qeth_card *card,
                 enum qeth_routing_types *type, enum qeth_prot_versions prot)
 {
         if (card->info.type == QETH_CARD_TYPE_IQD) {
@@ -632,7 +632,7 @@ static void qeth_l3_correct_routing_type(struct qeth_card *card,
                 case PRIMARY_CONNECTOR:
                 case SECONDARY_CONNECTOR:
                 case MULTICAST_ROUTER:
-                        return;
+                        return 0;
                 default:
                         goto out_inval;
                 }
@@ -641,17 +641,18 @@ static void qeth_l3_correct_routing_type(struct qeth_card *card,
                 case NO_ROUTER:
                 case PRIMARY_ROUTER:
                 case SECONDARY_ROUTER:
-                        return;
+                        return 0;
                 case MULTICAST_ROUTER:
                         if (qeth_is_ipafunc_supported(card, prot,
                                                       IPA_OSA_MC_ROUTER))
-                                return;
+                                return 0;
                 default:
                         goto out_inval;
                 }
         }
 out_inval:
         *type = NO_ROUTER;
+        return -EINVAL;
 }
 
 int qeth_l3_setrouting_v4(struct qeth_card *card)
@@ -660,8 +661,10 @@ int qeth_l3_setrouting_v4(struct qeth_card *card)
 
         QETH_CARD_TEXT(card, 3, "setrtg4");
 
-        qeth_l3_correct_routing_type(card, &card->options.route4.type,
+        rc = qeth_l3_correct_routing_type(card, &card->options.route4.type,
                                   QETH_PROT_IPV4);
+        if (rc)
+                return rc;
 
         rc = qeth_l3_send_setrouting(card, card->options.route4.type,
                                   QETH_PROT_IPV4);
@@ -683,8 +686,10 @@ int qeth_l3_setrouting_v6(struct qeth_card *card)
 
         if (!qeth_is_supported(card, IPA_IPV6))
                 return 0;
-        qeth_l3_correct_routing_type(card, &card->options.route6.type,
+        rc = qeth_l3_correct_routing_type(card, &card->options.route6.type,
                                   QETH_PROT_IPV6);
+        if (rc)
+                return rc;
 
         rc = qeth_l3_send_setrouting(card, card->options.route6.type,
                                   QETH_PROT_IPV6);
@@ -2898,7 +2903,9 @@ static inline int qeth_l3_tso_elements(struct sk_buff *skb)
                 tcp_hdr(skb)->doff * 4;
         int tcpd_len = skb->len - (tcpd - (unsigned long)skb->data);
         int elements = PFN_UP(tcpd + tcpd_len - 1) - PFN_DOWN(tcpd);
-        elements += skb_shinfo(skb)->nr_frags;
+
+        elements += qeth_get_elements_for_frags(skb);
+
         return elements;
 }
 
@@ -3348,7 +3355,6 @@ static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
                 rc = -ENODEV;
                 goto out_remove;
         }
-        qeth_trace_features(card);
 
         if (!card->dev && qeth_l3_setup_netdev(card)) {
                 rc = -ENODEV;
@@ -3425,6 +3431,7 @@ contin:
                 qeth_l3_set_multicast_list(card->dev);
                 rtnl_unlock();
         }
+        qeth_trace_features(card);
         /* let user_space know that device is online */
         kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
         mutex_unlock(&card->conf_mutex);
@@ -3508,6 +3515,7 @@ 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");
+        qeth_set_recovery_task(card);
         __qeth_l3_set_offline(card->gdev, 1);
         rc = __qeth_l3_set_online(card->gdev, 1);
         if (!rc)
@@ -3518,6 +3526,7 @@ 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_recovery_task(card);
         qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
         qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
         return 0;
diff --git a/drivers/s390/net/qeth_l3_sys.c b/drivers/s390/net/qeth_l3_sys.c
index ebc379486267..e70af2406ff9 100644
--- a/drivers/s390/net/qeth_l3_sys.c
+++ b/drivers/s390/net/qeth_l3_sys.c
@@ -87,6 +87,8 @@ static ssize_t qeth_l3_dev_route_store(struct qeth_card *card,
                         rc = qeth_l3_setrouting_v6(card);
         }
 out:
+        if (rc)
+                route->type = old_route_type;
         mutex_unlock(&card->conf_mutex);
         return rc ? rc : count;
 }