[S390] dasd: add hyper PAV support to DASD device driver, part 1

Parallel access volumes (PAV) is a storage server feature, that allows
to start multiple channel programs on the same DASD in parallel. It
defines alias devices which can be used as alternative paths to the
same disk. With the old base PAV support we only needed rudimentary
functionality in the DASD device driver. As the mapping between base
and alias devices was static, we just had to export an identifier
(uid) and could leave the combining of devices to external layers
like a device mapper multipath.
Now hyper PAV removes the requirement to dedicate alias devices to
specific base devices. Instead each alias devices can be combined with
multiple base device on a per request basis. This requires full
support by the DASD device driver as now each channel program itself
has to identify the target base device.
The changes to the dasd device driver and the ECKD discipline are:
- Separate subchannel device representation (dasd_device) from block
  device representation (dasd_block). Only base devices are block
  devices.
- Gather information about base and alias devices and possible
  combinations.
- For each request decide which dasd_device should be used (base or
  alias) and build specific channel program.
- Support summary unit checks, which allow the storage server to
  upgrade / downgrade between base and hyper PAV at runtime (support
  is mandatory).

Signed-off-by: Stefan Weinhuber <wein@de.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

1 files changed, 575 insertions, 212 deletions

diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index 6038d9195e27..61f16937c1e0 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -52,16 +52,6 @@ MODULE_LICENSE("GPL");
 
 static struct dasd_discipline dasd_eckd_discipline;
 
-struct dasd_eckd_private {
-        struct dasd_eckd_characteristics rdc_data;
-        struct dasd_eckd_confdata conf_data;
-        struct dasd_eckd_path path_data;
-        struct eckd_count count_area[5];
-        int init_cqr_status;
-        int uses_cdl;
-        struct attrib_data_t attrib;    /* e.g. cache operations */
-};
-
 /* The ccw bus type uses this table to find devices that it sends to
  * dasd_eckd_probe */
 static struct ccw_device_id dasd_eckd_ids[] = {
@@ -188,7 +178,7 @@ check_XRC (struct ccw1         *de_ccw,
         if (rc == -ENOSYS || rc == -EACCES)
                 rc = 0;
 
-        de_ccw->count = sizeof (struct DE_eckd_data);
+        de_ccw->count = sizeof(struct DE_eckd_data);
         de_ccw->flags |= CCW_FLAG_SLI;
         return rc;
 }
@@ -208,7 +198,7 @@ define_extent(struct ccw1 * ccw, struct DE_eckd_data * data, int trk,
         ccw->count = 16;
         ccw->cda = (__u32) __pa(data);
 
-        memset(data, 0, sizeof (struct DE_eckd_data));
+        memset(data, 0, sizeof(struct DE_eckd_data));
         switch (cmd) {
         case DASD_ECKD_CCW_READ_HOME_ADDRESS:
         case DASD_ECKD_CCW_READ_RECORD_ZERO:
@@ -280,6 +270,132 @@ define_extent(struct ccw1 * ccw, struct DE_eckd_data * data, int trk,
         return rc;
 }
 
+static int check_XRC_on_prefix(struct PFX_eckd_data *pfxdata,
+                               struct dasd_device  *device)
+{
+        struct dasd_eckd_private *private;
+        int rc;
+
+        private = (struct dasd_eckd_private *) device->private;
+        if (!private->rdc_data.facilities.XRC_supported)
+                return 0;
+
+        /* switch on System Time Stamp - needed for XRC Support */
+        pfxdata->define_extend.ga_extended |= 0x08; /* 'Time Stamp Valid'   */
+        pfxdata->define_extend.ga_extended |= 0x02; /* 'Extended Parameter' */
+        pfxdata->validity.time_stamp = 1;           /* 'Time Stamp Valid'   */
+
+        rc = get_sync_clock(&pfxdata->define_extend.ep_sys_time);
+        /* Ignore return code if sync clock is switched off. */
+        if (rc == -ENOSYS || rc == -EACCES)
+                rc = 0;
+        return rc;
+}
+
+static int prefix(struct ccw1 *ccw, struct PFX_eckd_data *pfxdata, int trk,
+                  int totrk, int cmd, struct dasd_device *basedev,
+                  struct dasd_device *startdev)
+{
+        struct dasd_eckd_private *basepriv, *startpriv;
+        struct DE_eckd_data *data;
+        struct ch_t geo, beg, end;
+        int rc = 0;
+
+        basepriv = (struct dasd_eckd_private *) basedev->private;
+        startpriv = (struct dasd_eckd_private *) startdev->private;
+        data = &pfxdata->define_extend;
+
+        ccw->cmd_code = DASD_ECKD_CCW_PFX;
+        ccw->flags = 0;
+        ccw->count = sizeof(*pfxdata);
+        ccw->cda = (__u32) __pa(pfxdata);
+
+        memset(pfxdata, 0, sizeof(*pfxdata));
+        /* prefix data */
+        pfxdata->format = 0;
+        pfxdata->base_address = basepriv->conf_data.ned1.unit_addr;
+        pfxdata->base_lss = basepriv->conf_data.ned1.ID;
+        pfxdata->validity.define_extend = 1;
+
+        /* private uid is kept up to date, conf_data may be outdated */
+        if (startpriv->uid.type != UA_BASE_DEVICE) {
+                pfxdata->validity.verify_base = 1;
+                if (startpriv->uid.type == UA_HYPER_PAV_ALIAS)
+                        pfxdata->validity.hyper_pav = 1;
+        }
+
+        /* define extend data (mostly)*/
+        switch (cmd) {
+        case DASD_ECKD_CCW_READ_HOME_ADDRESS:
+        case DASD_ECKD_CCW_READ_RECORD_ZERO:
+        case DASD_ECKD_CCW_READ:
+        case DASD_ECKD_CCW_READ_MT:
+        case DASD_ECKD_CCW_READ_CKD:
+        case DASD_ECKD_CCW_READ_CKD_MT:
+        case DASD_ECKD_CCW_READ_KD:
+        case DASD_ECKD_CCW_READ_KD_MT:
+        case DASD_ECKD_CCW_READ_COUNT:
+                data->mask.perm = 0x1;
+                data->attributes.operation = basepriv->attrib.operation;
+                break;
+        case DASD_ECKD_CCW_WRITE:
+        case DASD_ECKD_CCW_WRITE_MT:
+        case DASD_ECKD_CCW_WRITE_KD:
+        case DASD_ECKD_CCW_WRITE_KD_MT:
+                data->mask.perm = 0x02;
+                data->attributes.operation = basepriv->attrib.operation;
+                rc = check_XRC_on_prefix(pfxdata, basedev);
+                break;
+        case DASD_ECKD_CCW_WRITE_CKD:
+        case DASD_ECKD_CCW_WRITE_CKD_MT:
+                data->attributes.operation = DASD_BYPASS_CACHE;
+                rc = check_XRC_on_prefix(pfxdata, basedev);
+                break;
+        case DASD_ECKD_CCW_ERASE:
+        case DASD_ECKD_CCW_WRITE_HOME_ADDRESS:
+        case DASD_ECKD_CCW_WRITE_RECORD_ZERO:
+                data->mask.perm = 0x3;
+                data->mask.auth = 0x1;
+                data->attributes.operation = DASD_BYPASS_CACHE;
+                rc = check_XRC_on_prefix(pfxdata, basedev);
+                break;
+        default:
+                DEV_MESSAGE(KERN_ERR, basedev, "unknown opcode 0x%x", cmd);
+                break;
+        }
+
+        data->attributes.mode = 0x3;    /* ECKD */
+
+        if ((basepriv->rdc_data.cu_type == 0x2105 ||
+             basepriv->rdc_data.cu_type == 0x2107 ||
+             basepriv->rdc_data.cu_type == 0x1750)
+            && !(basepriv->uses_cdl && trk < 2))
+                data->ga_extended |= 0x40; /* Regular Data Format Mode */
+
+        geo.cyl = basepriv->rdc_data.no_cyl;
+        geo.head = basepriv->rdc_data.trk_per_cyl;
+        beg.cyl = trk / geo.head;
+        beg.head = trk % geo.head;
+        end.cyl = totrk / geo.head;
+        end.head = totrk % geo.head;
+
+        /* check for sequential prestage - enhance cylinder range */
+        if (data->attributes.operation == DASD_SEQ_PRESTAGE ||
+            data->attributes.operation == DASD_SEQ_ACCESS) {
+
+                if (end.cyl + basepriv->attrib.nr_cyl < geo.cyl)
+                        end.cyl += basepriv->attrib.nr_cyl;
+                else
+                        end.cyl = (geo.cyl - 1);
+        }
+
+        data->beg_ext.cyl = beg.cyl;
+        data->beg_ext.head = beg.head;
+        data->end_ext.cyl = end.cyl;
+        data->end_ext.head = end.head;
+        return rc;
+}
+
 static void
 locate_record(struct ccw1 *ccw, struct LO_eckd_data *data, int trk,
               int rec_on_trk, int no_rec, int cmd,
@@ -300,7 +416,7 @@ locate_record(struct ccw1 *ccw, struct LO_eckd_data *data, int trk,
         ccw->count = 16;
         ccw->cda = (__u32) __pa(data);
 
-        memset(data, 0, sizeof (struct LO_eckd_data));
+        memset(data, 0, sizeof(struct LO_eckd_data));
         sector = 0;
         if (rec_on_trk) {
                 switch (private->rdc_data.dev_type) {
@@ -441,12 +557,15 @@ dasd_eckd_generate_uid(struct dasd_device *device, struct dasd_uid *uid)
                sizeof(uid->serial) - 1);
         EBCASC(uid->serial, sizeof(uid->serial) - 1);
         uid->ssid = confdata->neq.subsystemID;
-        if (confdata->ned2.sneq.flags == 0x40) {
-                uid->alias = 1;
-                uid->unit_addr = confdata->ned2.sneq.base_unit_addr;
-        } else
-                uid->unit_addr = confdata->ned1.unit_addr;
-
+        uid->real_unit_addr = confdata->ned1.unit_addr;
+        if (confdata->ned2.sneq.flags == 0x40 &&
+            confdata->ned2.sneq.format == 0x0001) {
+                uid->type = confdata->ned2.sneq.sua_flags;
+                if (uid->type == UA_BASE_PAV_ALIAS)
+                        uid->base_unit_addr = confdata->ned2.sneq.base_unit_addr;
+        } else {
+                uid->type = UA_BASE_DEVICE;
+        }
         return 0;
 }
 
@@ -470,7 +589,9 @@ static struct dasd_ccw_req *dasd_eckd_build_rcd_lpm(struct dasd_device *device,
         ccw->cda = (__u32)(addr_t)rcd_buffer;
         ccw->count = ciw->count;
 
-        cqr->device = device;
+        cqr->startdev = device;
+        cqr->memdev = device;
+        cqr->block = NULL;
         cqr->expires = 10*HZ;
         cqr->lpm = lpm;
         clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
@@ -511,7 +632,7 @@ static int dasd_eckd_read_conf_lpm(struct dasd_device *device,
         /*
          * on success we update the user input parms
          */
-        dasd_sfree_request(cqr, cqr->device);
+        dasd_sfree_request(cqr, cqr->memdev);
         if (ret)
                 goto out_error;
 
@@ -557,19 +678,19 @@ dasd_eckd_read_conf(struct dasd_device *device)
                                         "data retrieved");
                                 continue;       /* no error */
                         }
-                        if (conf_len != sizeof (struct dasd_eckd_confdata)) {
+                        if (conf_len != sizeof(struct dasd_eckd_confdata)) {
                                 MESSAGE(KERN_WARNING,
                                         "sizes of configuration data mismatch"
                                         "%d (read) vs %ld (expected)",
                                         conf_len,
-                                        sizeof (struct dasd_eckd_confdata));
+                                        sizeof(struct dasd_eckd_confdata));
                                 kfree(conf_data);
                                 continue;       /* no error */
                         }
                         /* save first valid configuration data */
                         if (!conf_data_saved){
                                 memcpy(&private->conf_data, conf_data,
-                                       sizeof (struct dasd_eckd_confdata));
+                                       sizeof(struct dasd_eckd_confdata));
                                 conf_data_saved++;
                         }
                         switch (((char *)conf_data)[242] & 0x07){
@@ -586,39 +707,104 @@ dasd_eckd_read_conf(struct dasd_device *device)
         return 0;
 }
 
+static int dasd_eckd_read_features(struct dasd_device *device)
+{
+        struct dasd_psf_prssd_data *prssdp;
+        struct dasd_rssd_features *features;
+        struct dasd_ccw_req *cqr;
+        struct ccw1 *ccw;
+        int rc;
+        struct dasd_eckd_private *private;
+
+        private = (struct dasd_eckd_private *) device->private;
+        cqr = dasd_smalloc_request(dasd_eckd_discipline.name,
+                                   1 /* PSF */  + 1 /* RSSD */ ,
+                                   (sizeof(struct dasd_psf_prssd_data) +
+                                    sizeof(struct dasd_rssd_features)),
+                                   device);
+        if (IS_ERR(cqr)) {
+                DEV_MESSAGE(KERN_WARNING, device, "%s",
+                            "Could not allocate initialization request");
+                return PTR_ERR(cqr);
+        }
+        cqr->startdev = device;
+        cqr->memdev = device;
+        cqr->block = NULL;
+        clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
+        cqr->retries = 5;
+        cqr->expires = 10 * HZ;
+
+        /* Prepare for Read Subsystem Data */
+        prssdp = (struct dasd_psf_prssd_data *) cqr->data;
+        memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data));
+        prssdp->order = PSF_ORDER_PRSSD;
+        prssdp->suborder = 0x41;        /* Read Feature Codes */
+        /* all other bytes of prssdp must be zero */
+
+        ccw = cqr->cpaddr;
+        ccw->cmd_code = DASD_ECKD_CCW_PSF;
+        ccw->count = sizeof(struct dasd_psf_prssd_data);
+        ccw->flags |= CCW_FLAG_CC;
+        ccw->cda = (__u32)(addr_t) prssdp;
+
+        /* Read Subsystem Data - feature codes */
+        features = (struct dasd_rssd_features *) (prssdp + 1);
+        memset(features, 0, sizeof(struct dasd_rssd_features));
+
+        ccw++;
+        ccw->cmd_code = DASD_ECKD_CCW_RSSD;
+        ccw->count = sizeof(struct dasd_rssd_features);
+        ccw->cda = (__u32)(addr_t) features;
+
+        cqr->buildclk = get_clock();
+        cqr->status = DASD_CQR_FILLED;
+        rc = dasd_sleep_on(cqr);
+        if (rc == 0) {
+                prssdp = (struct dasd_psf_prssd_data *) cqr->data;
+                features = (struct dasd_rssd_features *) (prssdp + 1);
+                memcpy(&private->features, features,
+                       sizeof(struct dasd_rssd_features));
+        }
+        dasd_sfree_request(cqr, cqr->memdev);
+        return rc;
+}
+
+
 /*
  * Build CP for Perform Subsystem Function - SSC.
  */
-static struct dasd_ccw_req *
-dasd_eckd_build_psf_ssc(struct dasd_device *device)
+static struct dasd_ccw_req *dasd_eckd_build_psf_ssc(struct dasd_device *device)
 {
-       struct dasd_ccw_req *cqr;
-       struct dasd_psf_ssc_data *psf_ssc_data;
-       struct ccw1 *ccw;
+        struct dasd_ccw_req *cqr;
+        struct dasd_psf_ssc_data *psf_ssc_data;
+        struct ccw1 *ccw;
 
-       cqr = dasd_smalloc_request("ECKD", 1 /* PSF */ ,
+        cqr = dasd_smalloc_request("ECKD", 1 /* PSF */ ,
                                   sizeof(struct dasd_psf_ssc_data),
                                   device);
 
-       if (IS_ERR(cqr)) {
-               DEV_MESSAGE(KERN_WARNING, device, "%s",
+        if (IS_ERR(cqr)) {
+                DEV_MESSAGE(KERN_WARNING, device, "%s",
                            "Could not allocate PSF-SSC request");
-               return cqr;
-       }
-       psf_ssc_data = (struct dasd_psf_ssc_data *)cqr->data;
-       psf_ssc_data->order = PSF_ORDER_SSC;
-       psf_ssc_data->suborder = 0x08;
-
-       ccw = cqr->cpaddr;
-       ccw->cmd_code = DASD_ECKD_CCW_PSF;
-       ccw->cda = (__u32)(addr_t)psf_ssc_data;
-       ccw->count = 66;
-
-       cqr->device = device;
-       cqr->expires = 10*HZ;
-       cqr->buildclk = get_clock();
-       cqr->status = DASD_CQR_FILLED;
-       return cqr;
+                return cqr;
+        }
+        psf_ssc_data = (struct dasd_psf_ssc_data *)cqr->data;
+        psf_ssc_data->order = PSF_ORDER_SSC;
+        psf_ssc_data->suborder = 0x88;
+        psf_ssc_data->reserved[0] = 0x88;
+
+        ccw = cqr->cpaddr;
+        ccw->cmd_code = DASD_ECKD_CCW_PSF;
+        ccw->cda = (__u32)(addr_t)psf_ssc_data;
+        ccw->count = 66;
+
+        cqr->startdev = device;
+        cqr->memdev = device;
+        cqr->block = NULL;
+        cqr->expires = 10*HZ;
+        cqr->buildclk = get_clock();
+        cqr->status = DASD_CQR_FILLED;
+        return cqr;
 }
 
 /*
@@ -629,28 +815,28 @@ dasd_eckd_build_psf_ssc(struct dasd_device *device)
 static int
 dasd_eckd_psf_ssc(struct dasd_device *device)
 {
-       struct dasd_ccw_req *cqr;
-       int rc;
-
-       cqr = dasd_eckd_build_psf_ssc(device);
-       if (IS_ERR(cqr))
-               return PTR_ERR(cqr);
-
-       rc = dasd_sleep_on(cqr);
-       if (!rc)
-               /* trigger CIO to reprobe devices */
-               css_schedule_reprobe();
-       dasd_sfree_request(cqr, cqr->device);
-       return rc;
+        struct dasd_ccw_req *cqr;
+        int rc;
+
+        cqr = dasd_eckd_build_psf_ssc(device);
+        if (IS_ERR(cqr))
+                return PTR_ERR(cqr);
+
+        rc = dasd_sleep_on(cqr);
+        if (!rc)
+                /* trigger CIO to reprobe devices */
+                css_schedule_reprobe();
+        dasd_sfree_request(cqr, cqr->memdev);
+        return rc;
 }
 
 /*
  * Valide storage server of current device.
  */
-static int
-dasd_eckd_validate_server(struct dasd_device *device, struct dasd_uid *uid)
+static int dasd_eckd_validate_server(struct dasd_device *device)
 {
         int rc;
+        struct dasd_eckd_private *private;
 
         /* Currently PAV is the only reason to 'validate' server on LPAR */
         if (dasd_nopav || MACHINE_IS_VM)
@@ -659,9 +845,11 @@ dasd_eckd_validate_server(struct dasd_device *device, struct dasd_uid *uid)
         rc = dasd_eckd_psf_ssc(device);
         /* may be requested feature is not available on server,
          * therefore just report error and go ahead */
+        private = (struct dasd_eckd_private *) device->private;
         DEV_MESSAGE(KERN_INFO, device,
                     "PSF-SSC on storage subsystem %s.%s.%04x returned rc=%d",
-                    uid->vendor, uid->serial, uid->ssid, rc);
+                    private->uid.vendor, private->uid.serial,
+                    private->uid.ssid, rc);
         /* RE-Read Configuration Data */
         return dasd_eckd_read_conf(device);
 }
@@ -674,9 +862,9 @@ static int
 dasd_eckd_check_characteristics(struct dasd_device *device)
 {
         struct dasd_eckd_private *private;
-        struct dasd_uid uid;
+        struct dasd_block *block;
         void *rdc_data;
-        int rc;
+        int is_known, rc;
 
         private = (struct dasd_eckd_private *) device->private;
         if (private == NULL) {
@@ -699,27 +887,54 @@ dasd_eckd_check_characteristics(struct dasd_device *device)
         /* Read Configuration Data */
         rc = dasd_eckd_read_conf(device);
         if (rc)
-                return rc;
+                goto out_err1;
 
         /* Generate device unique id and register in devmap */
-        rc = dasd_eckd_generate_uid(device, &uid);
+        rc = dasd_eckd_generate_uid(device, &private->uid);
         if (rc)
-                return rc;
-        rc = dasd_set_uid(device->cdev, &uid);
-        if (rc == 1)    /* new server found */
-                rc = dasd_eckd_validate_server(device, &uid);
+                goto out_err1;
+        dasd_set_uid(device->cdev, &private->uid);
+
+        if (private->uid.type == UA_BASE_DEVICE) {
+                block = dasd_alloc_block();
+                if (IS_ERR(block)) {
+                        DEV_MESSAGE(KERN_WARNING, device, "%s",
+                                    "could not allocate dasd block structure");
+                        rc = PTR_ERR(block);
+                        goto out_err1;
+                }
+                device->block = block;
+                block->base = device;
+        }
+
+        /* register lcu with alias handling, enable PAV if this is a new lcu */
+        is_known = dasd_alias_make_device_known_to_lcu(device);
+        if (is_known < 0) {
+                rc = is_known;
+                goto out_err2;
+        }
+        if (!is_known) {
+                /* new lcu found */
+                rc = dasd_eckd_validate_server(device); /* will switch pav on */
+                if (rc)
+                        goto out_err3;
+        }
+
+        /* Read Feature Codes */
+        rc = dasd_eckd_read_features(device);
         if (rc)
-                return rc;
+                goto out_err3;
 
         /* Read Device Characteristics */
         rdc_data = (void *) &(private->rdc_data);
         memset(rdc_data, 0, sizeof(rdc_data));
         rc = dasd_generic_read_dev_chars(device, "ECKD", &rdc_data, 64);
-        if (rc)
+        if (rc) {
                 DEV_MESSAGE(KERN_WARNING, device,
                             "Read device characteristics returned "
                             "rc=%d", rc);
-
+                goto out_err3;
+        }
         DEV_MESSAGE(KERN_INFO, device,
                     "%04X/%02X(CU:%04X/%02X) Cyl:%d Head:%d Sec:%d",
                     private->rdc_data.dev_type,
@@ -729,9 +944,24 @@ dasd_eckd_check_characteristics(struct dasd_device *device)
                     private->rdc_data.no_cyl,
                     private->rdc_data.trk_per_cyl,
                     private->rdc_data.sec_per_trk);
+        return 0;
+
+out_err3:
+        dasd_alias_disconnect_device_from_lcu(device);
+out_err2:
+        dasd_free_block(device->block);
+        device->block = NULL;
+out_err1:
+        kfree(device->private);
+        device->private = NULL;
         return rc;
 }
 
+static void dasd_eckd_uncheck_device(struct dasd_device *device)
+{
+        dasd_alias_disconnect_device_from_lcu(device);
+}
+
 static struct dasd_ccw_req *
 dasd_eckd_analysis_ccw(struct dasd_device *device)
 {
@@ -755,7 +985,7 @@ dasd_eckd_analysis_ccw(struct dasd_device *device)
         /* Define extent for the first 3 tracks. */
         define_extent(ccw++, cqr->data, 0, 2,
                       DASD_ECKD_CCW_READ_COUNT, device);
-        LO_data = cqr->data + sizeof (struct DE_eckd_data);
+        LO_data = cqr->data + sizeof(struct DE_eckd_data);
         /* Locate record for the first 4 records on track 0. */
         ccw[-1].flags |= CCW_FLAG_CC;
         locate_record(ccw++, LO_data++, 0, 0, 4,
@@ -783,7 +1013,9 @@ dasd_eckd_analysis_ccw(struct dasd_device *device)
         ccw->count = 8;
         ccw->cda = (__u32)(addr_t) count_data;
 
-        cqr->device = device;
+        cqr->block = NULL;
+        cqr->startdev = device;
+        cqr->memdev = device;
         cqr->retries = 0;
         cqr->buildclk = get_clock();
         cqr->status = DASD_CQR_FILLED;
@@ -803,7 +1035,7 @@ dasd_eckd_analysis_callback(struct dasd_ccw_req *init_cqr, void *data)
         struct dasd_eckd_private *private;
         struct dasd_device *device;
 
-        device = init_cqr->device;
+        device = init_cqr->startdev;
         private = (struct dasd_eckd_private *) device->private;
         private->init_cqr_status = init_cqr->status;
         dasd_sfree_request(init_cqr, device);
@@ -811,13 +1043,13 @@ dasd_eckd_analysis_callback(struct dasd_ccw_req *init_cqr, void *data)
 }
 
 static int
-dasd_eckd_start_analysis(struct dasd_device *device)
+dasd_eckd_start_analysis(struct dasd_block *block)
 {
         struct dasd_eckd_private *private;
         struct dasd_ccw_req *init_cqr;
 
-        private = (struct dasd_eckd_private *) device->private;
-        init_cqr = dasd_eckd_analysis_ccw(device);
+        private = (struct dasd_eckd_private *) block->base->private;
+        init_cqr = dasd_eckd_analysis_ccw(block->base);
         if (IS_ERR(init_cqr))
                 return PTR_ERR(init_cqr);
         init_cqr->callback = dasd_eckd_analysis_callback;
@@ -828,13 +1060,15 @@ dasd_eckd_start_analysis(struct dasd_device *device)
 }
 
 static int
-dasd_eckd_end_analysis(struct dasd_device *device)
+dasd_eckd_end_analysis(struct dasd_block *block)
 {
+        struct dasd_device *device;
         struct dasd_eckd_private *private;
         struct eckd_count *count_area;
         unsigned int sb, blk_per_trk;
         int status, i;
 
+        device = block->base;
         private = (struct dasd_eckd_private *) device->private;
         status = private->init_cqr_status;
         private->init_cqr_status = -1;
@@ -846,7 +1080,7 @@ dasd_eckd_end_analysis(struct dasd_device *device)
 
         private->uses_cdl = 1;
         /* Calculate number of blocks/records per track. */
-        blk_per_trk = recs_per_track(&private->rdc_data, 0, device->bp_block);
+        blk_per_trk = recs_per_track(&private->rdc_data, 0, block->bp_block);
         /* Check Track 0 for Compatible Disk Layout */
         count_area = NULL;
         for (i = 0; i < 3; i++) {
@@ -876,56 +1110,65 @@ dasd_eckd_end_analysis(struct dasd_device *device)
         if (count_area != NULL && count_area->kl == 0) {
                 /* we found notthing violating our disk layout */
                 if (dasd_check_blocksize(count_area->dl) == 0)
-                        device->bp_block = count_area->dl;
+                        block->bp_block = count_area->dl;
         }
-        if (device->bp_block == 0) {
+        if (block->bp_block == 0) {
                 DEV_MESSAGE(KERN_WARNING, device, "%s",
                             "Volume has incompatible disk layout");
                 return -EMEDIUMTYPE;
         }
-        device->s2b_shift = 0;  /* bits to shift 512 to get a block */
-        for (sb = 512; sb < device->bp_block; sb = sb << 1)
-                device->s2b_shift++;
+        block->s2b_shift = 0;   /* bits to shift 512 to get a block */
+        for (sb = 512; sb < block->bp_block; sb = sb << 1)
+                block->s2b_shift++;
 
-        blk_per_trk = recs_per_track(&private->rdc_data, 0, device->bp_block);
-        device->blocks = (private->rdc_data.no_cyl *
+        blk_per_trk = recs_per_track(&private->rdc_data, 0, block->bp_block);
+        block->blocks = (private->rdc_data.no_cyl *
                           private->rdc_data.trk_per_cyl *
                           blk_per_trk);
 
         DEV_MESSAGE(KERN_INFO, device,
                     "(%dkB blks): %dkB at %dkB/trk %s",
-                    (device->bp_block >> 10),
+                    (block->bp_block >> 10),
                     ((private->rdc_data.no_cyl *
                       private->rdc_data.trk_per_cyl *
-                      blk_per_trk * (device->bp_block >> 9)) >> 1),
-                    ((blk_per_trk * device->bp_block) >> 10),
+                      blk_per_trk * (block->bp_block >> 9)) >> 1),
+                    ((blk_per_trk * block->bp_block) >> 10),
                     private->uses_cdl ?
                     "compatible disk layout" : "linux disk layout");
 
         return 0;
 }
 
-static int
-dasd_eckd_do_analysis(struct dasd_device *device)
+static int dasd_eckd_do_analysis(struct dasd_block *block)
 {
         struct dasd_eckd_private *private;
 
-        private = (struct dasd_eckd_private *) device->private;
+        private = (struct dasd_eckd_private *) block->base->private;
         if (private->init_cqr_status < 0)
-                return dasd_eckd_start_analysis(device);
+                return dasd_eckd_start_analysis(block);
         else
-                return dasd_eckd_end_analysis(device);
+                return dasd_eckd_end_analysis(block);
 }
 
+static int dasd_eckd_ready_to_online(struct dasd_device *device)
+{
+        return dasd_alias_add_device(device);
+};
+
+static int dasd_eckd_online_to_ready(struct dasd_device *device)
+{
+        return dasd_alias_remove_device(device);
+};
+
 static int
-dasd_eckd_fill_geometry(struct dasd_device *device, struct hd_geometry *geo)
+dasd_eckd_fill_geometry(struct dasd_block *block, struct hd_geometry *geo)
 {
         struct dasd_eckd_private *private;
 
-        private = (struct dasd_eckd_private *) device->private;
-        if (dasd_check_blocksize(device->bp_block) == 0) {
+        private = (struct dasd_eckd_private *) block->base->private;
+        if (dasd_check_blocksize(block->bp_block) == 0) {
                 geo->sectors = recs_per_track(&private->rdc_data,
-                                              0, device->bp_block);
+                                              0, block->bp_block);
         }
         geo->cylinders = private->rdc_data.no_cyl;
         geo->heads = private->rdc_data.trk_per_cyl;
@@ -1037,7 +1280,7 @@ dasd_eckd_format_device(struct dasd_device * device,
                 locate_record(ccw++, (struct LO_eckd_data *) data,
                               fdata->start_unit, 0, rpt + 1,
                               DASD_ECKD_CCW_WRITE_RECORD_ZERO, device,
-                              device->bp_block);
+                              device->block->bp_block);
                 data += sizeof(struct LO_eckd_data);
                 break;
         case 0x04: /* Invalidate track. */
@@ -1110,43 +1353,28 @@ dasd_eckd_format_device(struct dasd_device * device,
                         ccw++;
                 }
         }
-        fcp->device = device;
-        fcp->retries = 2;       /* set retry counter to enable ERP */
+        fcp->startdev = device;
+        fcp->memdev = device;
+        clear_bit(DASD_CQR_FLAGS_USE_ERP, &fcp->flags);
+        fcp->retries = 5;       /* set retry counter to enable default ERP */
         fcp->buildclk = get_clock();
         fcp->status = DASD_CQR_FILLED;
         return fcp;
 }
 
-static dasd_era_t
-dasd_eckd_examine_error(struct dasd_ccw_req * cqr, struct irb * irb)
+static void dasd_eckd_handle_terminated_request(struct dasd_ccw_req *cqr)
 {
-        struct dasd_device *device = (struct dasd_device *) cqr->device;
-        struct ccw_device *cdev = device->cdev;
-
-        if (irb->scsw.cstat == 0x00 &&
-            irb->scsw.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END))
-                return dasd_era_none;
-
-        switch (cdev->id.cu_type) {
-        case 0x3990:
-        case 0x2105:
-        case 0x2107:
-        case 0x1750:
-                return dasd_3990_erp_examine(cqr, irb);
-        case 0x9343:
-                return dasd_9343_erp_examine(cqr, irb);
-        case 0x3880:
-        default:
-                DEV_MESSAGE(KERN_WARNING, device, "%s",
-                            "default (unknown CU type) - RECOVERABLE return");
-                return dasd_era_recover;
+        cqr->status = DASD_CQR_FILLED;
+        if (cqr->block && (cqr->startdev != cqr->block->base)) {
+                dasd_eckd_reset_ccw_to_base_io(cqr);
+                cqr->startdev = cqr->block->base;
         }
-}
+};
 
 static dasd_erp_fn_t
 dasd_eckd_erp_action(struct dasd_ccw_req * cqr)
 {
-        struct dasd_device *device = (struct dasd_device *) cqr->device;
+        struct dasd_device *device = (struct dasd_device *) cqr->startdev;
         struct ccw_device *cdev = device->cdev;
 
         switch (cdev->id.cu_type) {
@@ -1168,8 +1396,37 @@ dasd_eckd_erp_postaction(struct dasd_ccw_req * cqr)
         return dasd_default_erp_postaction;
 }
 
-static struct dasd_ccw_req *
-dasd_eckd_build_cp(struct dasd_device * device, struct request *req)
+
+static void dasd_eckd_handle_unsolicited_interrupt(struct dasd_device *device,
+                                                   struct irb *irb)
+{
+        char mask;
+
+        /* first of all check for state change pending interrupt */
+        mask = DEV_STAT_ATTENTION | DEV_STAT_DEV_END | DEV_STAT_UNIT_EXCEP;
+        if ((irb->scsw.dstat & mask) == mask) {
+                dasd_generic_handle_state_change(device);
+                return;
+        }
+
+        /* summary unit check */
+        if ((irb->scsw.dstat & DEV_STAT_UNIT_CHECK) && irb->ecw[7] == 0x0D) {
+                dasd_alias_handle_summary_unit_check(device, irb);
+                return;
+        }
+
+        /* just report other unsolicited interrupts */
+        DEV_MESSAGE(KERN_DEBUG, device, "%s",
+                    "unsolicited interrupt received");
+        device->discipline->dump_sense(device, NULL, irb);
+        dasd_schedule_device_bh(device);
+
+        return;
+};
+
+static struct dasd_ccw_req *dasd_eckd_build_cp(struct dasd_device *startdev,
+                                               struct dasd_block *block,
+                                               struct request *req)
 {
         struct dasd_eckd_private *private;
         unsigned long *idaws;
@@ -1185,8 +1442,11 @@ dasd_eckd_build_cp(struct dasd_device * device, struct request *req)
         sector_t first_trk, last_trk;
         unsigned int first_offs, last_offs;
         unsigned char cmd, rcmd;
+        int use_prefix;
+        struct dasd_device *basedev;
 
-        private = (struct dasd_eckd_private *) device->private;
+        basedev = block->base;
+        private = (struct dasd_eckd_private *) basedev->private;
         if (rq_data_dir(req) == READ)
                 cmd = DASD_ECKD_CCW_READ_MT;
         else if (rq_data_dir(req) == WRITE)
@@ -1194,13 +1454,13 @@ dasd_eckd_build_cp(struct dasd_device * device, struct request *req)
         else
                 return ERR_PTR(-EINVAL);
         /* Calculate number of blocks/records per track. */
-        blksize = device->bp_block;
+        blksize = block->bp_block;
         blk_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
         /* Calculate record id of first and last block. */
-        first_rec = first_trk = req->sector >> device->s2b_shift;
+        first_rec = first_trk = req->sector >> block->s2b_shift;
         first_offs = sector_div(first_trk, blk_per_trk);
         last_rec = last_trk =
-                (req->sector + req->nr_sectors - 1) >> device->s2b_shift;
+                (req->sector + req->nr_sectors - 1) >> block->s2b_shift;
         last_offs = sector_div(last_trk, blk_per_trk);
         /* Check struct bio and count the number of blocks for the request. */
         count = 0;
@@ -1209,20 +1469,33 @@ dasd_eckd_build_cp(struct dasd_device * device, struct request *req)
                 if (bv->bv_len & (blksize - 1))
                         /* Eckd can only do full blocks. */
                         return ERR_PTR(-EINVAL);
-                count += bv->bv_len >> (device->s2b_shift + 9);
+                count += bv->bv_len >> (block->s2b_shift + 9);
 #if defined(CONFIG_64BIT)
                 if (idal_is_needed (page_address(bv->bv_page), bv->bv_len))
-                        cidaw += bv->bv_len >> (device->s2b_shift + 9);
+                        cidaw += bv->bv_len >> (block->s2b_shift + 9);
 #endif
         }
         /* Paranoia. */
         if (count != last_rec - first_rec + 1)
                 return ERR_PTR(-EINVAL);
-        /* 1x define extent + 1x locate record + number of blocks */
-        cplength = 2 + count;
-        /* 1x define extent + 1x locate record + cidaws*sizeof(long) */
-        datasize = sizeof(struct DE_eckd_data) + sizeof(struct LO_eckd_data) +
-                cidaw * sizeof(unsigned long);
+
+        /* use the prefix command if available */
+        use_prefix = private->features.feature[8] & 0x01;
+        if (use_prefix) {
+                /* 1x prefix + number of blocks */
+                cplength = 2 + count;
+                /* 1x prefix + cidaws*sizeof(long) */
+                datasize = sizeof(struct PFX_eckd_data) +
+                        sizeof(struct LO_eckd_data) +
+                        cidaw * sizeof(unsigned long);
+        } else {
+                /* 1x define extent + 1x locate record + number of blocks */
+                cplength = 2 + count;
+                /* 1x define extent + 1x locate record + cidaws*sizeof(long) */
+                datasize = sizeof(struct DE_eckd_data) +
+                        sizeof(struct LO_eckd_data) +
+                        cidaw * sizeof(unsigned long);
+        }
         /* Find out the number of additional locate record ccws for cdl. */
         if (private->uses_cdl && first_rec < 2*blk_per_trk) {
                 if (last_rec >= 2*blk_per_trk)
@@ -1232,26 +1505,42 @@ dasd_eckd_build_cp(struct dasd_device * device, struct request *req)
         }
         /* Allocate the ccw request. */
         cqr = dasd_smalloc_request(dasd_eckd_discipline.name,
-                                   cplength, datasize, device);
+                                   cplength, datasize, startdev);
         if (IS_ERR(cqr))
                 return cqr;
         ccw = cqr->cpaddr;
-        /* First ccw is define extent. */
-        if (define_extent(ccw++, cqr->data, first_trk,
-                          last_trk, cmd, device) == -EAGAIN) {
-                /* Clock not in sync and XRC is enabled. Try again later. */
-                dasd_sfree_request(cqr, device);
-                return ERR_PTR(-EAGAIN);
+        /* First ccw is define extent or prefix. */
+        if (use_prefix) {
+                if (prefix(ccw++, cqr->data, first_trk,
+                           last_trk, cmd, basedev, startdev) == -EAGAIN) {
+                        /* Clock not in sync and XRC is enabled.
+                         * Try again later.
+                         */
+                        dasd_sfree_request(cqr, startdev);
+                        return ERR_PTR(-EAGAIN);
+                }
+                idaws = (unsigned long *) (cqr->data +
+                                           sizeof(struct PFX_eckd_data));
+        } else {
+                if (define_extent(ccw++, cqr->data, first_trk,
+                                  last_trk, cmd, startdev) == -EAGAIN) {
+                        /* Clock not in sync and XRC is enabled.
+                         * Try again later.
+                         */
+                        dasd_sfree_request(cqr, startdev);
+                        return ERR_PTR(-EAGAIN);
+                }
+                idaws = (unsigned long *) (cqr->data +
+                                           sizeof(struct DE_eckd_data));
         }
         /* Build locate_record+read/write/ccws. */
-        idaws = (unsigned long *) (cqr->data + sizeof(struct DE_eckd_data));
         LO_data = (struct LO_eckd_data *) (idaws + cidaw);
         recid = first_rec;
         if (private->uses_cdl == 0 || recid > 2*blk_per_trk) {
                 /* Only standard blocks so there is just one locate record. */
                 ccw[-1].flags |= CCW_FLAG_CC;
                 locate_record(ccw++, LO_data++, first_trk, first_offs + 1,
-                              last_rec - recid + 1, cmd, device, blksize);
+                              last_rec - recid + 1, cmd, basedev, blksize);
         }
         rq_for_each_segment(bv, req, iter) {
                 dst = page_address(bv->bv_page) + bv->bv_offset;
@@ -1281,7 +1570,7 @@ dasd_eckd_build_cp(struct dasd_device * device, struct request *req)
                                 ccw[-1].flags |= CCW_FLAG_CC;
                                 locate_record(ccw++, LO_data++,
                                               trkid, recoffs + 1,
-                                              1, rcmd, device, count);
+                                              1, rcmd, basedev, count);
                         }
                         /* Locate record for standard blocks ? */
                         if (private->uses_cdl && recid == 2*blk_per_trk) {
@@ -1289,7 +1578,7 @@ dasd_eckd_build_cp(struct dasd_device * device, struct request *req)
                                 locate_record(ccw++, LO_data++,
                                               trkid, recoffs + 1,
                                               last_rec - recid + 1,
-                                              cmd, device, count);
+                                              cmd, basedev, count);
                         }
                         /* Read/write ccw. */
                         ccw[-1].flags |= CCW_FLAG_CC;
@@ -1310,7 +1599,9 @@ dasd_eckd_build_cp(struct dasd_device * device, struct request *req)
         }
         if (req->cmd_flags & REQ_FAILFAST)
                 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
-        cqr->device = device;
+        cqr->startdev = startdev;
+        cqr->memdev = startdev;
+        cqr->block = block;
         cqr->expires = 5 * 60 * HZ;     /* 5 minutes */
         cqr->lpm = private->path_data.ppm;
         cqr->retries = 256;
@@ -1333,10 +1624,10 @@ dasd_eckd_free_cp(struct dasd_ccw_req *cqr, struct request *req)
 
         if (!dasd_page_cache)
                 goto out;
-        private = (struct dasd_eckd_private *) cqr->device->private;
-        blksize = cqr->device->bp_block;
+        private = (struct dasd_eckd_private *) cqr->block->base->private;
+        blksize = cqr->block->bp_block;
         blk_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
-        recid = req->sector >> cqr->device->s2b_shift;
+        recid = req->sector >> cqr->block->s2b_shift;
         ccw = cqr->cpaddr;
         /* Skip over define extent & locate record. */
         ccw++;
@@ -1367,10 +1658,71 @@ dasd_eckd_free_cp(struct dasd_ccw_req *cqr, struct request *req)
         }
 out:
         status = cqr->status == DASD_CQR_DONE;
-        dasd_sfree_request(cqr, cqr->device);
+        dasd_sfree_request(cqr, cqr->memdev);
         return status;
 }
 
+/*
+ * Modify ccw chain in cqr so it can be started on a base device.
+ *
+ * Note that this is not enough to restart the cqr!
+ * Either reset cqr->startdev as well (summary unit check handling)
+ * or restart via separate cqr (as in ERP handling).
+ */
+void dasd_eckd_reset_ccw_to_base_io(struct dasd_ccw_req *cqr)
+{
+        struct ccw1 *ccw;
+        struct PFX_eckd_data *pfxdata;
+
+        ccw = cqr->cpaddr;
+        pfxdata = cqr->data;
+
+        if (ccw->cmd_code == DASD_ECKD_CCW_PFX) {
+                pfxdata->validity.verify_base = 0;
+                pfxdata->validity.hyper_pav = 0;
+        }
+}
+
+#define DASD_ECKD_CHANQ_MAX_SIZE 4
+
+static struct dasd_ccw_req *dasd_eckd_build_alias_cp(struct dasd_device *base,
+                                                     struct dasd_block *block,
+                                                     struct request *req)
+{
+        struct dasd_eckd_private *private;
+        struct dasd_device *startdev;
+        unsigned long flags;
+        struct dasd_ccw_req *cqr;
+
+        startdev = dasd_alias_get_start_dev(base);
+        if (!startdev)
+                startdev = base;
+        private = (struct dasd_eckd_private *) startdev->private;
+        if (private->count >= DASD_ECKD_CHANQ_MAX_SIZE)
+                return ERR_PTR(-EBUSY);
+
+        spin_lock_irqsave(get_ccwdev_lock(startdev->cdev), flags);
+        private->count++;
+        cqr = dasd_eckd_build_cp(startdev, block, req);
+        if (IS_ERR(cqr))
+                private->count--;
+        spin_unlock_irqrestore(get_ccwdev_lock(startdev->cdev), flags);
+        return cqr;
+}
+
+static int dasd_eckd_free_alias_cp(struct dasd_ccw_req *cqr,
+                                   struct request *req)
+{
+        struct dasd_eckd_private *private;
+        unsigned long flags;
+
+        spin_lock_irqsave(get_ccwdev_lock(cqr->memdev->cdev), flags);
+        private = (struct dasd_eckd_private *) cqr->memdev->private;
+        private->count--;
+        spin_unlock_irqrestore(get_ccwdev_lock(cqr->memdev->cdev), flags);
+        return dasd_eckd_free_cp(cqr, req);
+}
+
 static int
 dasd_eckd_fill_info(struct dasd_device * device,
                     struct dasd_information2_t * info)
@@ -1384,9 +1736,9 @@ dasd_eckd_fill_info(struct dasd_device * device,
         info->characteristics_size = sizeof(struct dasd_eckd_characteristics);
         memcpy(info->characteristics, &private->rdc_data,
                sizeof(struct dasd_eckd_characteristics));
-        info->confdata_size = sizeof (struct dasd_eckd_confdata);
+        info->confdata_size = sizeof(struct dasd_eckd_confdata);
         memcpy(info->configuration_data, &private->conf_data,
-               sizeof (struct dasd_eckd_confdata));
+               sizeof(struct dasd_eckd_confdata));
         return 0;
 }
 
@@ -1419,7 +1771,8 @@ dasd_eckd_release(struct dasd_device *device)
         cqr->cpaddr->flags |= CCW_FLAG_SLI;
         cqr->cpaddr->count = 32;
         cqr->cpaddr->cda = (__u32)(addr_t) cqr->data;
-        cqr->device = device;
+        cqr->startdev = device;
+        cqr->memdev = device;
         clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
         set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
         cqr->retries = 2;       /* set retry counter to enable basic ERP */
@@ -1429,7 +1782,7 @@ dasd_eckd_release(struct dasd_device *device)
 
         rc = dasd_sleep_on_immediatly(cqr);
 
-        dasd_sfree_request(cqr, cqr->device);
+        dasd_sfree_request(cqr, cqr->memdev);
         return rc;
 }
 
@@ -1459,7 +1812,8 @@ dasd_eckd_reserve(struct dasd_device *device)
         cqr->cpaddr->flags |= CCW_FLAG_SLI;
         cqr->cpaddr->count = 32;
         cqr->cpaddr->cda = (__u32)(addr_t) cqr->data;
-        cqr->device = device;
+        cqr->startdev = device;
+        cqr->memdev = device;
         clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
         set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
         cqr->retries = 2;       /* set retry counter to enable basic ERP */
@@ -1469,7 +1823,7 @@ dasd_eckd_reserve(struct dasd_device *device)
 
         rc = dasd_sleep_on_immediatly(cqr);
 
-        dasd_sfree_request(cqr, cqr->device);
+        dasd_sfree_request(cqr, cqr->memdev);
         return rc;
 }
 
@@ -1498,7 +1852,8 @@ dasd_eckd_steal_lock(struct dasd_device *device)
         cqr->cpaddr->flags |= CCW_FLAG_SLI;
         cqr->cpaddr->count = 32;
         cqr->cpaddr->cda = (__u32)(addr_t) cqr->data;
-        cqr->device = device;
+        cqr->startdev = device;
+        cqr->memdev = device;
         clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
         set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
         cqr->retries = 2;       /* set retry counter to enable basic ERP */
@@ -1508,7 +1863,7 @@ dasd_eckd_steal_lock(struct dasd_device *device)
 
         rc = dasd_sleep_on_immediatly(cqr);
 
-        dasd_sfree_request(cqr, cqr->device);
+        dasd_sfree_request(cqr, cqr->memdev);
         return rc;
 }
 
@@ -1526,52 +1881,52 @@ dasd_eckd_performance(struct dasd_device *device, void __user *argp)
 
         cqr = dasd_smalloc_request(dasd_eckd_discipline.name,
                                    1 /* PSF */  + 1 /* RSSD */ ,
-                                   (sizeof (struct dasd_psf_prssd_data) +
-                                    sizeof (struct dasd_rssd_perf_stats_t)),
+                                   (sizeof(struct dasd_psf_prssd_data) +
+                                    sizeof(struct dasd_rssd_perf_stats_t)),
                                    device);
         if (IS_ERR(cqr)) {
                 DEV_MESSAGE(KERN_WARNING, device, "%s",
                             "Could not allocate initialization request");
                 return PTR_ERR(cqr);
         }
-        cqr->device = device;
+        cqr->startdev = device;
+        cqr->memdev = device;
         cqr->retries = 0;
         cqr->expires = 10 * HZ;
 
         /* Prepare for Read Subsystem Data */
         prssdp = (struct dasd_psf_prssd_data *) cqr->data;
-        memset(prssdp, 0, sizeof (struct dasd_psf_prssd_data));
+        memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data));
         prssdp->order = PSF_ORDER_PRSSD;
         prssdp->suborder = 0x01;        /* Performance Statistics */
         prssdp->varies[1] = 0x01;       /* Perf Statistics for the Subsystem */
 
         ccw = cqr->cpaddr;
         ccw->cmd_code = DASD_ECKD_CCW_PSF;
-        ccw->count = sizeof (struct dasd_psf_prssd_data);
+        ccw->count = sizeof(struct dasd_psf_prssd_data);
         ccw->flags |= CCW_FLAG_CC;
         ccw->cda = (__u32)(addr_t) prssdp;
 
         /* Read Subsystem Data - Performance Statistics */
         stats = (struct dasd_rssd_perf_stats_t *) (prssdp + 1);
-        memset(stats, 0, sizeof (struct dasd_rssd_perf_stats_t));
+        memset(stats, 0, sizeof(struct dasd_rssd_perf_stats_t));
 
         ccw++;
         ccw->cmd_code = DASD_ECKD_CCW_RSSD;
-        ccw->count = sizeof (struct dasd_rssd_perf_stats_t);
+        ccw->count = sizeof(struct dasd_rssd_perf_stats_t);
         ccw->cda = (__u32)(addr_t) stats;
 
         cqr->buildclk = get_clock();
         cqr->status = DASD_CQR_FILLED;
         rc = dasd_sleep_on(cqr);
         if (rc == 0) {
-                /* Prepare for Read Subsystem Data */
                 prssdp = (struct dasd_psf_prssd_data *) cqr->data;
                 stats = (struct dasd_rssd_perf_stats_t *) (prssdp + 1);
                 if (copy_to_user(argp, stats,
                                  sizeof(struct dasd_rssd_perf_stats_t)))
                         rc = -EFAULT;
         }
-        dasd_sfree_request(cqr, cqr->device);
+        dasd_sfree_request(cqr, cqr->memdev);
         return rc;
 }
 
@@ -1594,7 +1949,7 @@ dasd_eckd_get_attrib(struct dasd_device *device, void __user *argp)
 
         rc = 0;
         if (copy_to_user(argp, (long *) &attrib,
-                         sizeof (struct attrib_data_t)))
+                         sizeof(struct attrib_data_t)))
                 rc = -EFAULT;
 
         return rc;
@@ -1627,8 +1982,10 @@ dasd_eckd_set_attrib(struct dasd_device *device, void __user *argp)
 }
 
 static int
-dasd_eckd_ioctl(struct dasd_device *device, unsigned int cmd, void __user *argp)
+dasd_eckd_ioctl(struct dasd_block *block, unsigned int cmd, void __user *argp)
 {
+        struct dasd_device *device = block->base;
+
         switch (cmd) {
         case BIODASDGATTR:
                 return dasd_eckd_get_attrib(device, argp);
@@ -1685,9 +2042,8 @@ dasd_eckd_dump_ccw_range(struct ccw1 *from, struct ccw1 *to, char *page)
  * Print sense data and related channel program.
  * Parts are printed because printk buffer is only 1024 bytes.
  */
-static void
-dasd_eckd_dump_sense(struct dasd_device *device, struct dasd_ccw_req * req,
-                     struct irb *irb)
+static void dasd_eckd_dump_sense(struct dasd_device *device,
+                                 struct dasd_ccw_req *req, struct irb *irb)
 {
         char *page;
         struct ccw1 *first, *last, *fail, *from, *to;
@@ -1743,37 +2099,40 @@ dasd_eckd_dump_sense(struct dasd_device *device, struct dasd_ccw_req * req,
         }
         printk("%s", page);
 
-        /* dump the Channel Program (max 140 Bytes per line) */
-        /* Count CCW and print first CCWs (maximum 1024 % 140 = 7) */
-        first = req->cpaddr;
-        for (last = first; last->flags & (CCW_FLAG_CC | CCW_FLAG_DC); last++);
-        to = min(first + 6, last);
-        len = sprintf(page,  KERN_ERR PRINTK_HEADER
-                      " Related CP in req: %p\n", req);
-        dasd_eckd_dump_ccw_range(first, to, page + len);
-        printk("%s", page);
+        if (req) {
+                /* req == NULL for unsolicited interrupts */
+                /* dump the Channel Program (max 140 Bytes per line) */
+                /* Count CCW and print first CCWs (maximum 1024 % 140 = 7) */
+                first = req->cpaddr;
+                for (last = first; last->flags & (CCW_FLAG_CC | CCW_FLAG_DC); last++);
+                to = min(first + 6, last);
+                len = sprintf(page,  KERN_ERR PRINTK_HEADER
+                              " Related CP in req: %p\n", req);
+                dasd_eckd_dump_ccw_range(first, to, page + len);
+                printk("%s", page);
 
-        /* print failing CCW area (maximum 4) */
-        /* scsw->cda is either valid or zero  */
-        len = 0;
-        from = ++to;
-        fail = (struct ccw1 *)(addr_t) irb->scsw.cpa; /* failing CCW */
-        if (from <  fail - 2) {
-                from = fail - 2;     /* there is a gap - print header */
-                len += sprintf(page, KERN_ERR PRINTK_HEADER "......\n");
-        }
-        to = min(fail + 1, last);
-        len += dasd_eckd_dump_ccw_range(from, to, page + len);
-
-        /* print last CCWs (maximum 2) */
-        from = max(from, ++to);
-        if (from < last - 1) {
-                from = last - 1;     /* there is a gap - print header */
-                len += sprintf(page + len, KERN_ERR PRINTK_HEADER "......\n");
+                /* print failing CCW area (maximum 4) */
+                /* scsw->cda is either valid or zero  */
+                len = 0;
+                from = ++to;
+                fail = (struct ccw1 *)(addr_t) irb->scsw.cpa; /* failing CCW */
+                if (from <  fail - 2) {
+                        from = fail - 2;     /* there is a gap - print header */
+                        len += sprintf(page, KERN_ERR PRINTK_HEADER "......\n");
+                }
+                to = min(fail + 1, last);
+                len += dasd_eckd_dump_ccw_range(from, to, page + len);
+
+                /* print last CCWs (maximum 2) */
+                from = max(from, ++to);
+                if (from < last - 1) {
+                        from = last - 1;     /* there is a gap - print header */
+                        len += sprintf(page + len, KERN_ERR PRINTK_HEADER "......\n");
+                }
+                len += dasd_eckd_dump_ccw_range(from, last, page + len);
+                if (len > 0)
+                        printk("%s", page);
         }
-        len += dasd_eckd_dump_ccw_range(from, last, page + len);
-        if (len > 0)
-                printk("%s", page);
         free_page((unsigned long) page);
 }
 
@@ -1796,16 +2155,20 @@ static struct dasd_discipline dasd_eckd_discipline = {
         .ebcname = "ECKD",
         .max_blocks = 240,
         .check_device = dasd_eckd_check_characteristics,
+        .uncheck_device = dasd_eckd_uncheck_device,
         .do_analysis = dasd_eckd_do_analysis,
+        .ready_to_online = dasd_eckd_ready_to_online,
+        .online_to_ready = dasd_eckd_online_to_ready,
         .fill_geometry = dasd_eckd_fill_geometry,
         .start_IO = dasd_start_IO,
         .term_IO = dasd_term_IO,
+        .handle_terminated_request = dasd_eckd_handle_terminated_request,
         .format_device = dasd_eckd_format_device,
-        .examine_error = dasd_eckd_examine_error,
         .erp_action = dasd_eckd_erp_action,
         .erp_postaction = dasd_eckd_erp_postaction,
-        .build_cp = dasd_eckd_build_cp,
-        .free_cp = dasd_eckd_free_cp,
+        .handle_unsolicited_interrupt = dasd_eckd_handle_unsolicited_interrupt,
+        .build_cp = dasd_eckd_build_alias_cp,
+        .free_cp = dasd_eckd_free_alias_cp,
         .dump_sense = dasd_eckd_dump_sense,
         .fill_info = dasd_eckd_fill_info,
         .ioctl = dasd_eckd_ioctl,