Lines Matching +full:serial +full:- +full:dat +full:- +full:low
1 // SPDX-License-Identifier: GPL-2.0
135 /* set ECKD specific ccw-device options */
141 "ccw-device options");
164 return (d1 + (d2 - 1)) / d2;
173 switch (rdc->dev_type) {
202 geo->cyl = (__u16) cyl;
203 geo->head = cyl >> 16;
204 geo->head <<= 4;
205 geo->head |= head;
215 struct dasd_eckd_private *private = device->private;
224 return -EINVAL;
229 return -EINVAL;
243 *track = cyl * private->rdc_data.trk_per_cyl + head;
250 struct dasd_eckd_private *private = device->private;
253 rc = get_phys_clock(&data->ep_sys_time);
258 if ((rc && !private->rdc_data.facilities.XRC_supported) ||
259 rc == -EOPNOTSUPP || rc == -EACCES)
262 /* switch on System Time Stamp - needed for XRC Support */
263 data->ga_extended |= 0x08; /* switch on 'Time Stamp Valid' */
264 data->ga_extended |= 0x02; /* switch on 'Extended Parameter' */
267 ccw->count = sizeof(struct DE_eckd_data);
268 ccw->flags |= CCW_FLAG_SLI;
279 struct dasd_eckd_private *private = device->private;
285 ccw->cmd_code = DASD_ECKD_CCW_DEFINE_EXTENT;
286 ccw->flags = 0;
287 ccw->count = 16;
288 ccw->cda = virt_to_dma32(data);
301 data->mask.perm = 0x1;
302 data->attributes.operation = private->attrib.operation;
305 data->mask.perm = 0x1;
306 data->attributes.operation = DASD_BYPASS_CACHE;
310 data->mask.perm = 0x1;
311 data->attributes.operation = private->attrib.operation;
312 data->blk_size = 0;
318 data->mask.perm = 0x02;
319 data->attributes.operation = private->attrib.operation;
324 data->attributes.operation = DASD_BYPASS_CACHE;
330 data->mask.perm = 0x3;
331 data->mask.auth = 0x1;
332 data->attributes.operation = DASD_BYPASS_CACHE;
336 data->mask.perm = 0x03;
337 data->attributes.operation = private->attrib.operation;
338 data->blk_size = 0;
341 data->mask.perm = 0x02;
342 data->attributes.operation = private->attrib.operation;
343 data->blk_size = blksize;
347 dev_err(&device->cdev->dev,
352 data->attributes.mode = 0x3; /* ECKD */
354 if ((private->rdc_data.cu_type == 0x2105 ||
355 private->rdc_data.cu_type == 0x2107 ||
356 private->rdc_data.cu_type == 0x1750)
357 && !(private->uses_cdl && trk < 2))
358 data->ga_extended |= 0x40; /* Regular Data Format Mode */
360 heads = private->rdc_data.trk_per_cyl;
366 /* check for sequential prestage - enhance cylinder range */
367 if (data->attributes.operation == DASD_SEQ_PRESTAGE ||
368 data->attributes.operation == DASD_SEQ_ACCESS) {
370 if (endcyl + private->attrib.nr_cyl < private->real_cyl)
371 endcyl += private->attrib.nr_cyl;
373 endcyl = (private->real_cyl - 1);
376 set_ch_t(&data->beg_ext, begcyl, beghead);
377 set_ch_t(&data->end_ext, endcyl, endhead);
387 struct dasd_eckd_private *private = device->private;
392 ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD_EXT;
393 ccw->flags = 0;
395 ccw->count = 22;
397 ccw->count = 20;
398 ccw->cda = virt_to_dma32(data);
404 switch (private->rdc_data.dev_type) {
408 sector = (49 + (rec_on_trk - 1) * (10 + d)) / 8;
412 sector = (39 + (rec_on_trk - 1) * (8 + d)) / 7;
416 data->sector = sector;
421 data->count = count;
424 data->operation.orientation = 0x3;
425 data->operation.operation = 0x03;
428 data->operation.orientation = 0x3;
429 data->operation.operation = 0x16;
432 data->operation.orientation = 0x1;
433 data->operation.operation = 0x03;
434 data->count++;
437 data->operation.orientation = 0x3;
438 data->operation.operation = 0x16;
439 data->count++;
445 data->auxiliary.length_valid = 0x1;
446 data->length = reclen;
447 data->operation.operation = 0x01;
451 data->auxiliary.length_valid = 0x1;
452 data->length = reclen;
453 data->operation.operation = 0x03;
456 data->operation.orientation = 0x0;
457 data->operation.operation = 0x3F;
458 data->extended_operation = 0x11;
459 data->length = 0;
460 data->extended_parameter_length = 0x02;
461 if (data->count > 8) {
462 data->extended_parameter[0] = 0xFF;
463 data->extended_parameter[1] = 0xFF;
464 data->extended_parameter[1] <<= (16 - count);
466 data->extended_parameter[0] = 0xFF;
467 data->extended_parameter[0] <<= (8 - count);
468 data->extended_parameter[1] = 0x00;
470 data->sector = 0xFF;
473 data->auxiliary.length_valid = 0x1;
474 data->length = reclen; /* not tlf, as one might think */
475 data->operation.operation = 0x3F;
476 data->extended_operation = 0x23;
482 data->auxiliary.length_valid = 0x1;
483 data->length = reclen;
484 data->operation.operation = 0x06;
488 data->auxiliary.length_valid = 0x1;
489 data->length = reclen;
490 data->operation.operation = 0x16;
493 data->operation.operation = 0x06;
496 data->operation.orientation = 0x1;
497 data->operation.operation = 0x0C;
498 data->extended_parameter_length = 0;
499 data->sector = 0xFF;
502 data->auxiliary.length_valid = 0x1;
503 data->length = tlf;
504 data->operation.operation = 0x0C;
507 data->length = reclen;
508 data->auxiliary.length_valid = 0x1;
509 data->operation.operation = 0x0b;
516 set_ch_t(&data->seek_addr,
517 trk / private->rdc_data.trk_per_cyl,
518 trk % private->rdc_data.trk_per_cyl);
519 data->search_arg.cyl = data->seek_addr.cyl;
520 data->search_arg.head = data->seek_addr.head;
521 data->search_arg.record = rec_on_trk;
535 basepriv = basedev->private;
536 startpriv = startdev->private;
537 dedata = &pfxdata->define_extent;
538 lredata = &pfxdata->locate_record;
540 ccw->cmd_code = DASD_ECKD_CCW_PFX;
541 ccw->flags = 0;
543 ccw->count = sizeof(*pfxdata) + 2;
544 ccw->cda = virt_to_dma32(pfxdata);
547 ccw->count = sizeof(*pfxdata);
548 ccw->cda = virt_to_dma32(pfxdata);
557 return -EINVAL;
559 pfxdata->format = format;
560 pfxdata->base_address = basepriv->conf.ned->unit_addr;
561 pfxdata->base_lss = basepriv->conf.ned->ID;
562 pfxdata->validity.define_extent = 1;
565 if (startpriv->uid.type == UA_BASE_PAV_ALIAS)
566 pfxdata->validity.verify_base = 1;
568 if (startpriv->uid.type == UA_HYPER_PAV_ALIAS) {
569 pfxdata->validity.verify_base = 1;
570 pfxdata->validity.hyper_pav = 1;
580 if (dedata->ga_extended & 0x08 && dedata->ga_extended & 0x02)
581 pfxdata->validity.time_stamp = 1; /* 'Time Stamp Valid' */
604 struct dasd_eckd_private *private = device->private;
612 ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD;
613 ccw->flags = 0;
614 ccw->count = 16;
615 ccw->cda = virt_to_dma32(data);
620 switch (private->rdc_data.dev_type) {
624 sector = (49 + (rec_on_trk - 1) * (10 + d)) / 8;
628 sector = (39 + (rec_on_trk - 1) * (8 + d)) / 7;
632 data->sector = sector;
633 data->count = no_rec;
636 data->operation.orientation = 0x3;
637 data->operation.operation = 0x03;
640 data->operation.orientation = 0x3;
641 data->operation.operation = 0x16;
644 data->operation.orientation = 0x1;
645 data->operation.operation = 0x03;
646 data->count++;
649 data->operation.orientation = 0x3;
650 data->operation.operation = 0x16;
651 data->count++;
657 data->auxiliary.last_bytes_used = 0x1;
658 data->length = reclen;
659 data->operation.operation = 0x01;
663 data->auxiliary.last_bytes_used = 0x1;
664 data->length = reclen;
665 data->operation.operation = 0x03;
671 data->auxiliary.last_bytes_used = 0x1;
672 data->length = reclen;
673 data->operation.operation = 0x06;
677 data->auxiliary.last_bytes_used = 0x1;
678 data->length = reclen;
679 data->operation.operation = 0x16;
682 data->operation.operation = 0x06;
685 data->length = reclen;
686 data->auxiliary.last_bytes_used = 0x1;
687 data->operation.operation = 0x0b;
693 set_ch_t(&data->seek_addr,
694 trk / private->rdc_data.trk_per_cyl,
695 trk % private->rdc_data.trk_per_cyl);
696 data->search_arg.cyl = data->seek_addr.cyl;
697 data->search_arg.head = data->seek_addr.head;
698 data->search_arg.record = rec_on_trk;
709 * ccw->cmd_code |= 0x8;
741 memcpy(uid->vendor, conf->ned->HDA_manufacturer,
742 sizeof(uid->vendor) - 1);
743 EBCASC(uid->vendor, sizeof(uid->vendor) - 1);
744 memcpy(uid->serial, &conf->ned->serial,
745 sizeof(uid->serial) - 1);
746 EBCASC(uid->serial, sizeof(uid->serial) - 1);
747 uid->ssid = conf->gneq->subsystemID;
748 uid->real_unit_addr = conf->ned->unit_addr;
749 if (conf->sneq) {
750 uid->type = conf->sneq->sua_flags;
751 if (uid->type == UA_BASE_PAV_ALIAS)
752 uid->base_unit_addr = conf->sneq->base_unit_addr;
754 uid->type = UA_BASE_DEVICE;
756 if (conf->vdsneq) {
758 sprintf(uid->vduit+2*count, "%02x",
759 conf->vdsneq->uit[count]);
769 struct dasd_eckd_private *private = device->private;
773 return -ENODEV;
774 if (!private->conf.ned || !private->conf.gneq)
775 return -ENODEV;
776 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
777 create_uid(&private->conf, &private->uid);
778 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
784 struct dasd_eckd_private *private = device->private;
788 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
789 *uid = private->uid;
790 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
793 return -EINVAL;
827 ccw = cqr->cpaddr;
828 ccw->cmd_code = DASD_ECKD_CCW_RCD;
829 ccw->flags = 0;
830 ccw->cda = virt_to_dma32(rcd_buffer);
831 ccw->count = DASD_ECKD_RCD_DATA_SIZE;
832 cqr->magic = DASD_ECKD_MAGIC;
834 cqr->startdev = device;
835 cqr->memdev = device;
836 cqr->block = NULL;
837 cqr->expires = 10*HZ;
838 cqr->lpm = lpm;
839 cqr->retries = 256;
840 cqr->buildclk = get_tod_clock();
841 cqr->status = DASD_CQR_FILLED;
842 set_bit(DASD_CQR_VERIFY_PATH, &cqr->flags);
848 * the buffer has to be re-initialized with the EBCDIC "V1.0"
856 if (cqr->status != DASD_CQR_DONE) {
857 ccw = cqr->cpaddr;
858 rcd_buffer = dma32_to_virt(ccw->cda);
880 ciw = ccw_device_get_ciw(device->cdev, CIW_TYPE_RCD);
881 if (!ciw || ciw->cmd != DASD_ECKD_CCW_RCD)
882 return -EOPNOTSUPP;
885 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
886 set_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags);
887 cqr->retries = 5;
888 cqr->callback = read_conf_cb;
906 ciw = ccw_device_get_ciw(device->cdev, CIW_TYPE_RCD);
907 if (!ciw || ciw->cmd != DASD_ECKD_CCW_RCD) {
908 ret = -EOPNOTSUPP;
913 ret = -ENOMEM;
922 ret = -ENOMEM;
926 cqr->callback = read_conf_cb;
931 dasd_sfree_request(cqr, cqr->memdev);
951 conf->ned = NULL;
952 conf->sneq = NULL;
953 conf->vdsneq = NULL;
954 conf->gneq = NULL;
955 count = conf->len / sizeof(struct dasd_sneq);
956 sneq = (struct dasd_sneq *)conf->data;
958 if (sneq->flags.identifier == 1 && sneq->format == 1)
959 conf->sneq = sneq;
960 else if (sneq->flags.identifier == 1 && sneq->format == 4)
961 conf->vdsneq = (struct vd_sneq *)sneq;
962 else if (sneq->flags.identifier == 2)
963 conf->gneq = (struct dasd_gneq *)sneq;
964 else if (sneq->flags.identifier == 3 && sneq->res1 == 1)
965 conf->ned = (struct dasd_ned *)sneq;
968 if (!conf->ned || !conf->gneq) {
969 conf->ned = NULL;
970 conf->sneq = NULL;
971 conf->vdsneq = NULL;
972 conf->gneq = NULL;
973 return -EINVAL;
988 if (gneq->flags.identifier == 2) {
1003 struct dasd_eckd_private *private = device->private;
1011 * also replace the old private->conf_data pointer
1014 cdp = device->path[chp].conf_data;
1015 if (private->conf.data == cdp) {
1016 private->conf.data = (void *)conf_data;
1017 dasd_eckd_identify_conf_parts(&private->conf);
1019 ccw_device_get_schid(device->cdev, &sch_id);
1020 device->path[chp].conf_data = conf_data;
1021 device->path[chp].cssid = sch_id.cssid;
1022 device->path[chp].ssid = sch_id.ssid;
1023 chp_desc = ccw_device_get_chp_desc(device->cdev, chp);
1025 device->path[chp].chpid = chp_desc->chpid;
1032 struct dasd_eckd_private *private = device->private;
1035 private->conf.data = NULL;
1036 private->conf.len = 0;
1038 kfree(device->path[i].conf_data);
1039 device->path[i].conf_data = NULL;
1040 device->path[i].cssid = 0;
1041 device->path[i].ssid = 0;
1042 device->path[i].chpid = 0;
1049 struct dasd_eckd_private *private = device->private;
1055 rc = chsc_scud(private->uid.ssid, (u64 *)esm, &esm_valid);
1058 device->path[chp].fc_security = 0;
1064 device->path[chp].fc_security = esm[chp];
1066 device->path[chp].fc_security = 0;
1076 uid.vendor, uid.serial, uid.ssid, uid.real_unit_addr,
1084 struct dasd_eckd_private *private = device->private;
1094 dasd_eckd_get_uid_string(&private->conf, print_device_uid);
1095 dev_err(&device->cdev->dev,
1112 private = device->private;
1113 opm = ccw_device_get_path_mask(device->cdev);
1122 if (rc && rc != -EOPNOTSUPP) { /* -EOPNOTSUPP is ok */
1123 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
1129 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
1140 private->conf.data = conf_data;
1141 private->conf.len = conf_len;
1142 if (dasd_eckd_identify_conf_parts(&private->conf)) {
1143 private->conf.data = NULL;
1144 private->conf.len = 0;
1156 path_err = -EINVAL;
1185 struct dasd_eckd_private *private = device->private;
1194 fcx_in_gneq = private->conf.gneq->reserved2[7] & 0x04;
1195 fcx_in_features = private->features.feature[40] & 0x80;
1201 mdc = ccw_device_get_mdc(device->cdev, 0);
1203 dev_warn(&device->cdev->dev, "Detecting the maximum supported data size for zHPF requests failed\n");
1212 struct dasd_eckd_private *private = device->private;
1216 if (private->fcx_max_data) {
1217 mdc = ccw_device_get_mdc(device->cdev, lpm);
1219 dev_warn(&device->cdev->dev,
1226 if (fcx_max_data < private->fcx_max_data) {
1227 dev_warn(&device->cdev->dev,
1231 private->fcx_max_data);
1232 return -EACCES;
1241 struct dasd_eckd_private *private = device->private;
1243 int rc = -ENODEV;
1248 memset(&data->rcd_buffer, 0, sizeof(data->rcd_buffer));
1249 memset(&data->cqr, 0, sizeof(data->cqr));
1250 data->cqr.cpaddr = &data->ccw;
1251 rc = dasd_eckd_read_conf_immediately(device, &data->cqr,
1252 data->rcd_buffer,
1256 if (rc == -EOPNOTSUPP) /* -EOPNOTSUPP is ok */
1258 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
1263 memcpy(private->conf.data, data->rcd_buffer,
1265 if (dasd_eckd_identify_conf_parts(&private->conf)) {
1266 rc = -ENODEV;
1296 if (!(lpm & data->tbvpm))
1298 memset(&data->rcd_buffer, 0, sizeof(data->rcd_buffer));
1299 memset(&data->cqr, 0, sizeof(data->cqr));
1300 data->cqr.cpaddr = &data->ccw;
1301 rc = dasd_eckd_read_conf_immediately(device, &data->cqr,
1302 data->rcd_buffer,
1305 switch (dasd_eckd_path_access(data->rcd_buffer,
1316 } else if (rc == -EOPNOTSUPP) {
1317 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
1321 } else if (rc == -EAGAIN) {
1322 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
1327 dev_warn(&device->cdev->dev,
1345 memcpy(&path_rcd_buf, data->rcd_buffer,
1378 dev_err(&device->cdev->dev,
1393 memcpy(conf_data, data->rcd_buffer,
1398 * be stored due to low mem condition
1414 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
1429 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
1441 device = data->device;
1444 if (test_bit(DASD_FLAG_SUSPENDED, &device->flags)) {
1449 if (test_and_set_bit(DASD_FLAG_PATH_VERIFY, &device->flags)) {
1454 if (data->tbvpm)
1456 if (data->fcsecpm)
1459 clear_bit(DASD_FLAG_PATH_VERIFY, &device->flags);
1461 if (data->isglobal)
1476 data->isglobal = 1;
1478 return -ENOMEM;
1481 INIT_WORK(&data->worker, do_pe_handler_work);
1483 data->device = device;
1484 data->tbvpm = tbvpm;
1485 data->fcsecpm = fcsecpm;
1486 schedule_work(&data->worker);
1492 struct dasd_eckd_private *private = device->private;
1495 if (!private->fcx_max_data)
1496 private->fcx_max_data = get_fcx_max_data(device);
1497 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
1500 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
1505 struct dasd_eckd_private *private = device->private;
1512 memset(&private->features, 0, sizeof(struct dasd_rssd_features));
1518 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", "Could not "
1522 cqr->startdev = device;
1523 cqr->memdev = device;
1524 cqr->block = NULL;
1525 cqr->retries = 256;
1526 cqr->expires = 10 * HZ;
1529 prssdp = (struct dasd_psf_prssd_data *) cqr->data;
1531 prssdp->order = PSF_ORDER_PRSSD;
1532 prssdp->suborder = 0x41; /* Read Feature Codes */
1535 ccw = cqr->cpaddr;
1536 ccw->cmd_code = DASD_ECKD_CCW_PSF;
1537 ccw->count = sizeof(struct dasd_psf_prssd_data);
1538 ccw->flags |= CCW_FLAG_CC;
1539 ccw->cda = virt_to_dma32(prssdp);
1541 /* Read Subsystem Data - feature codes */
1546 ccw->cmd_code = DASD_ECKD_CCW_RSSD;
1547 ccw->count = sizeof(struct dasd_rssd_features);
1548 ccw->cda = virt_to_dma32(features);
1550 cqr->buildclk = get_tod_clock();
1551 cqr->status = DASD_CQR_FILLED;
1554 prssdp = (struct dasd_psf_prssd_data *) cqr->data;
1556 memcpy(&private->features, features,
1559 dev_warn(&device->cdev->dev, "Reading device feature codes"
1561 dasd_sfree_request(cqr, cqr->memdev);
1565 /* Read Volume Information - Volume Storage Query */
1568 struct dasd_eckd_private *private = device->private;
1577 if (private->uid.type == UA_BASE_PAV_ALIAS ||
1578 private->uid.type == UA_HYPER_PAV_ALIAS)
1585 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
1589 cqr = &dasd_vol_info_req->cqr;
1592 cqr->cpaddr = &dasd_vol_info_req->ccw;
1593 cqr->data = &dasd_vol_info_req->data;
1594 cqr->magic = DASD_ECKD_MAGIC;
1598 prssdp = cqr->data;
1599 prssdp->order = PSF_ORDER_PRSSD;
1600 prssdp->suborder = PSF_SUBORDER_VSQ; /* Volume Storage Query */
1601 prssdp->lss = private->conf.ned->ID;
1602 prssdp->volume = private->conf.ned->unit_addr;
1604 ccw = cqr->cpaddr;
1605 ccw->cmd_code = DASD_ECKD_CCW_PSF;
1606 ccw->count = sizeof(*prssdp);
1607 ccw->flags |= CCW_FLAG_CC;
1608 ccw->cda = virt_to_dma32(prssdp);
1610 /* Read Subsystem Data - Volume Storage Query */
1615 ccw->cmd_code = DASD_ECKD_CCW_RSSD;
1616 ccw->count = sizeof(*vsq);
1617 ccw->flags |= CCW_FLAG_SLI;
1618 ccw->cda = virt_to_dma32(vsq);
1620 cqr->buildclk = get_tod_clock();
1621 cqr->status = DASD_CQR_FILLED;
1622 cqr->startdev = device;
1623 cqr->memdev = device;
1624 cqr->block = NULL;
1625 cqr->retries = 256;
1626 cqr->expires = device->default_expires * HZ;
1628 __set_bit(DASD_CQR_SUPPRESS_CR, &cqr->flags);
1632 memcpy(&private->vsq, vsq, sizeof(*vsq));
1634 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
1641 dasd_sfree_request(cqr, cqr->memdev);
1648 struct dasd_eckd_private *private = device->private;
1650 return private->vsq.vol_info.ese;
1655 struct dasd_eckd_private *private = device->private;
1657 return private->vsq.extent_pool_id;
1667 struct dasd_eckd_private *private = device->private;
1672 return rc ? : private->vsq.space_configured;
1681 struct dasd_eckd_private *private = device->private;
1686 return rc ? : private->vsq.space_allocated;
1691 struct dasd_eckd_private *private = device->private;
1693 return private->vsq.logical_capacity;
1703 device = data->device;
1704 base = data->base;
1711 dev_warn(&device->cdev->dev, "No space left in the extent pool\n");
1726 return -ENOMEM;
1727 INIT_WORK(&data->worker, dasd_eckd_ext_pool_exhaust_work);
1729 data->device = device;
1731 if (cqr->block)
1732 data->base = cqr->block->base;
1733 else if (cqr->basedev)
1734 data->base = cqr->basedev;
1736 data->base = NULL;
1738 schedule_work(&data->worker);
1746 struct dasd_eckd_private *private = device->private;
1751 for (i = 0; i < lcq->pool_count; i++) {
1752 eps = lcq->ext_pool_sum[i];
1754 memcpy(&private->eps, &eps,
1760 /* Read Extent Pool Information - Logical Configuration Query */
1763 struct dasd_eckd_private *private = device->private;
1771 if (private->uid.type == UA_BASE_PAV_ALIAS ||
1772 private->uid.type == UA_HYPER_PAV_ALIAS)
1778 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
1784 prssdp = cqr->data;
1786 prssdp->order = PSF_ORDER_PRSSD;
1787 prssdp->suborder = PSF_SUBORDER_LCQ; /* Logical Configuration Query */
1789 ccw = cqr->cpaddr;
1790 ccw->cmd_code = DASD_ECKD_CCW_PSF;
1791 ccw->count = sizeof(*prssdp);
1792 ccw->flags |= CCW_FLAG_CC;
1793 ccw->cda = virt_to_dma32(prssdp);
1799 ccw->cmd_code = DASD_ECKD_CCW_RSSD;
1800 ccw->count = sizeof(*lcq);
1801 ccw->flags |= CCW_FLAG_SLI;
1802 ccw->cda = virt_to_dma32(lcq);
1804 cqr->buildclk = get_tod_clock();
1805 cqr->status = DASD_CQR_FILLED;
1806 cqr->startdev = device;
1807 cqr->memdev = device;
1808 cqr->block = NULL;
1809 cqr->retries = 256;
1810 cqr->expires = device->default_expires * HZ;
1812 __set_bit(DASD_CQR_SUPPRESS_CR, &cqr->flags);
1818 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
1822 dasd_sfree_request(cqr, cqr->memdev);
1834 struct dasd_eckd_private *private = device->private;
1835 struct dasd_ext_pool_sum eps = private->eps;
1849 struct dasd_eckd_private *private = device->private;
1851 return private->eps.warn_thrshld;
1856 struct dasd_eckd_private *private = device->private;
1858 return private->eps.flags.capacity_at_warnlevel;
1866 struct dasd_eckd_private *private = device->private;
1868 return private->eps.flags.pool_oos;
1872 * Build CP for Perform Subsystem Function - SSC.
1887 "Could not allocate PSF-SSC request");
1890 psf_ssc_data = (struct dasd_psf_ssc_data *)cqr->data;
1891 psf_ssc_data->order = PSF_ORDER_SSC;
1892 psf_ssc_data->suborder = 0xc0;
1894 psf_ssc_data->suborder |= 0x08;
1895 psf_ssc_data->reserved[0] = 0x88;
1897 ccw = cqr->cpaddr;
1898 ccw->cmd_code = DASD_ECKD_CCW_PSF;
1899 ccw->cda = virt_to_dma32(psf_ssc_data);
1900 ccw->count = 66;
1902 cqr->startdev = device;
1903 cqr->memdev = device;
1904 cqr->block = NULL;
1905 cqr->retries = 256;
1906 cqr->expires = 10*HZ;
1907 cqr->buildclk = get_tod_clock();
1908 cqr->status = DASD_CQR_FILLED;
1932 cqr->flags |= flags;
1938 else if (cqr->intrc == -EAGAIN)
1939 rc = -EAGAIN;
1941 dasd_sfree_request(cqr, cqr->memdev);
1951 struct dasd_eckd_private *private = device->private;
1954 if (private->uid.type == UA_BASE_PAV_ALIAS ||
1955 private->uid.type == UA_HYPER_PAV_ALIAS)
1965 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "PSF-SSC for SSID %04x "
1966 "returned rc=%d", private->uid.ssid, rc);
1981 == -EAGAIN) {
1983 schedule_work(&device->kick_validate);
1994 if (test_bit(DASD_FLAG_OFFLINE, &device->flags) ||
1995 device->state < DASD_STATE_ONLINE) {
2000 if (!schedule_work(&device->kick_validate))
2009 if (!device->copy)
2012 if (device->copy->active->device == device)
2030 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
2034 device->block = block;
2035 block->base = device;
2042 struct dasd_eckd_private *private = device->private;
2044 return private->rdc_data.facilities.PPRC_enabled;
2054 struct dasd_eckd_private *private = device->private;
2060 INIT_WORK(&device->kick_validate, dasd_eckd_do_validate_server);
2062 INIT_WORK(&device->suc_work, dasd_alias_handle_summary_unit_check);
2064 if (!ccw_device_is_pathgroup(device->cdev)) {
2065 dev_warn(&device->cdev->dev,
2067 return -EIO;
2069 if (!ccw_device_is_multipath(device->cdev)) {
2070 dev_info(&device->cdev->dev,
2076 dev_warn(&device->cdev->dev,
2079 return -ENOMEM;
2081 device->private = private;
2086 private->init_cqr_status = -1;
2088 private->attrib.operation = DASD_NORMAL_CACHE;
2089 private->attrib.nr_cyl = 0;
2097 device->default_expires = DASD_EXPIRES;
2098 device->default_retries = DASD_RETRIES;
2099 device->path_thrhld = DASD_ECKD_PATH_THRHLD;
2100 device->path_interval = DASD_ECKD_PATH_INTERVAL;
2101 device->aq_timeouts = DASD_RETRIES_MAX;
2103 if (private->conf.gneq) {
2105 for (i = 0; i < private->conf.gneq->timeout.value; i++)
2107 value = value * private->conf.gneq->timeout.number;
2110 device->default_expires = value;
2115 &private->rdc_data, 64);
2117 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
2123 rc = dasd_devmap_set_device_copy_relation(device->cdev,
2126 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
2160 if ((device->features & DASD_FEATURE_USERAW) &&
2161 !(private->rdc_data.facilities.RT_in_LR)) {
2162 dev_err(&device->cdev->dev, "The storage server does not "
2163 "support raw-track access\n");
2164 rc = -EINVAL;
2169 if (private->rdc_data.no_cyl == LV_COMPAT_CYL &&
2170 private->rdc_data.long_no_cyl)
2171 private->real_cyl = private->rdc_data.long_no_cyl;
2173 private->real_cyl = private->rdc_data.no_cyl;
2175 private->fcx_max_data = get_fcx_max_data(device);
2179 set_bit(DASD_FLAG_DEVICE_RO, &device->flags);
2181 dev_info(&device->cdev->dev, "New DASD %04X/%02X (CU %04X/%02X) "
2183 private->rdc_data.dev_type,
2184 private->rdc_data.dev_model,
2185 private->rdc_data.cu_type,
2186 private->rdc_data.cu_model.model,
2187 private->real_cyl,
2188 private->rdc_data.trk_per_cyl,
2189 private->rdc_data.sec_per_trk,
2190 readonly ? ", read-only device" : "");
2196 dasd_free_block(device->block);
2197 device->block = NULL;
2201 kfree(device->private);
2202 device->private = NULL;
2208 struct dasd_eckd_private *private = device->private;
2214 private->conf.ned = NULL;
2215 private->conf.sneq = NULL;
2216 private->conf.vdsneq = NULL;
2217 private->conf.gneq = NULL;
2225 struct dasd_eckd_private *private = device->private;
2239 ccw = cqr->cpaddr;
2241 define_extent(ccw++, cqr->data, 0, 1,
2243 LO_data = cqr->data + sizeof(struct DE_eckd_data);
2245 ccw[-1].flags |= CCW_FLAG_CC;
2249 count_data = private->count_area;
2251 ccw[-1].flags |= CCW_FLAG_CC;
2252 ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT;
2253 ccw->flags = 0;
2254 ccw->count = 8;
2255 ccw->cda = virt_to_dma32(count_data);
2261 ccw[-1].flags |= CCW_FLAG_CC;
2265 ccw[-1].flags |= CCW_FLAG_CC;
2266 ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT;
2267 ccw->flags = 0;
2268 ccw->count = 8;
2269 ccw->cda = virt_to_dma32(count_data);
2271 cqr->block = NULL;
2272 cqr->startdev = device;
2273 cqr->memdev = device;
2274 cqr->retries = 255;
2275 cqr->buildclk = get_tod_clock();
2276 cqr->status = DASD_CQR_FILLED;
2278 set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags);
2279 set_bit(DASD_CQR_SUPPRESS_IT, &cqr->flags);
2288 if (init_cqr->status == DASD_CQR_DONE)
2290 else if (init_cqr->status == DASD_CQR_NEED_ERP ||
2291 init_cqr->status == DASD_CQR_FAILED) {
2292 sense = dasd_get_sense(&init_cqr->irb);
2311 struct dasd_device *device = init_cqr->startdev;
2312 struct dasd_eckd_private *private = device->private;
2314 private->init_cqr_status = dasd_eckd_analysis_evaluation(init_cqr);
2323 init_cqr = dasd_eckd_analysis_ccw(block->base);
2326 init_cqr->callback = dasd_eckd_analysis_callback;
2327 init_cqr->callback_data = NULL;
2328 init_cqr->expires = 5*HZ;
2332 clear_bit(DASD_CQR_FLAGS_USE_ERP, &init_cqr->flags);
2333 init_cqr->retries = 0;
2335 return -EAGAIN;
2340 struct dasd_device *device = block->base;
2341 struct dasd_eckd_private *private = device->private;
2347 status = private->init_cqr_status;
2348 private->init_cqr_status = -1;
2357 if (device->features & DASD_FEATURE_USERAW) {
2358 block->bp_block = DASD_RAW_BLOCKSIZE;
2360 block->s2b_shift = 3;
2365 dev_warn(&device->cdev->dev, "The DASD is not formatted\n");
2366 return -EMEDIUMTYPE;
2368 dev_err(&device->cdev->dev,
2371 return -EIO;
2374 private->uses_cdl = 1;
2378 if (private->count_area[i].kl != 4 ||
2379 private->count_area[i].dl != dasd_eckd_cdl_reclen(i) - 4 ||
2380 private->count_area[i].cyl != 0 ||
2381 private->count_area[i].head != count_area_head[i] ||
2382 private->count_area[i].record != count_area_rec[i]) {
2383 private->uses_cdl = 0;
2388 count_area = &private->count_area[3];
2390 if (private->uses_cdl == 0) {
2392 if ((private->count_area[i].kl != 0) ||
2393 (private->count_area[i].dl !=
2394 private->count_area[0].dl) ||
2395 private->count_area[i].cyl != 0 ||
2396 private->count_area[i].head != count_area_head[i] ||
2397 private->count_area[i].record != count_area_rec[i])
2401 count_area = &private->count_area[0];
2403 if (private->count_area[3].record == 1)
2404 dev_warn(&device->cdev->dev,
2408 if (count_area != NULL && count_area->kl == 0) {
2410 if (dasd_check_blocksize(count_area->dl) == 0)
2411 block->bp_block = count_area->dl;
2413 if (block->bp_block == 0) {
2414 dev_warn(&device->cdev->dev,
2416 return -EMEDIUMTYPE;
2418 block->s2b_shift = 0; /* bits to shift 512 to get a block */
2419 for (sb = 512; sb < block->bp_block; sb = sb << 1)
2420 block->s2b_shift++;
2422 blk_per_trk = recs_per_track(&private->rdc_data, 0, block->bp_block);
2425 block->blocks = ((unsigned long) private->real_cyl *
2426 private->rdc_data.trk_per_cyl *
2429 dev_info(&device->cdev->dev,
2431 "%s\n", (block->bp_block >> 10),
2432 (((unsigned long) private->real_cyl *
2433 private->rdc_data.trk_per_cyl *
2434 blk_per_trk * (block->bp_block >> 9)) >> 1),
2435 ((blk_per_trk * block->bp_block) >> 10),
2436 private->uses_cdl ?
2444 struct dasd_eckd_private *private = block->base->private;
2446 if (private->init_cqr_status < 0)
2459 if (cancel_work_sync(&device->reload_device))
2461 if (cancel_work_sync(&device->kick_validate))
2475 struct dasd_eckd_private *private = block->base->private;
2477 if (dasd_check_blocksize(block->bp_block) == 0) {
2478 geo->sectors = recs_per_track(&private->rdc_data,
2479 0, block->bp_block);
2481 geo->cylinders = private->rdc_data.no_cyl;
2482 geo->heads = private->rdc_data.trk_per_cyl;
2510 start_priv = startdev->private;
2512 count = rpt * (fdata->stop_unit - fdata->start_unit + 1);
2524 start_priv->count++;
2526 itcw = itcw_init(cqr->data, itcw_size, ITCW_OP_READ, 0, count, 0);
2528 rc = -EINVAL;
2532 cqr->cpaddr = itcw_get_tcw(itcw);
2533 rc = prepare_itcw(itcw, fdata->start_unit, fdata->stop_unit,
2544 rc = -EINVAL;
2549 last_tidaw->flags |= TIDAW_FLAGS_LAST;
2552 cqr->cpmode = 1;
2553 cqr->startdev = startdev;
2554 cqr->memdev = startdev;
2555 cqr->basedev = base;
2556 cqr->retries = startdev->default_retries;
2557 cqr->expires = startdev->default_expires * HZ;
2558 cqr->buildclk = get_tod_clock();
2559 cqr->status = DASD_CQR_FILLED;
2561 set_bit(DASD_CQR_SUPPRESS_IL, &cqr->flags);
2595 start_priv = startdev->private;
2596 base_priv = base->private;
2598 count = rpt * (fdata->stop_unit - fdata->start_unit + 1);
2600 use_prefix = base_priv->features.feature[8] & 0x01;
2616 start_priv->count++;
2617 data = cqr->data;
2618 ccw = cqr->cpaddr;
2621 prefix_LRE(ccw++, data, fdata->start_unit, fdata->stop_unit,
2625 define_extent(ccw++, data, fdata->start_unit, fdata->stop_unit,
2629 ccw[-1].flags |= CCW_FLAG_CC;
2631 locate_record(ccw++, data, fdata->start_unit, 0, count,
2636 ccw[-1].flags |= CCW_FLAG_CC;
2637 ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT;
2638 ccw->flags = CCW_FLAG_SLI;
2639 ccw->count = 8;
2640 ccw->cda = virt_to_dma32(fmt_buffer);
2645 cqr->startdev = startdev;
2646 cqr->memdev = startdev;
2647 cqr->basedev = base;
2648 cqr->retries = DASD_RETRIES;
2649 cqr->expires = startdev->default_expires * HZ;
2650 cqr->buildclk = get_tod_clock();
2651 cqr->status = DASD_CQR_FILLED;
2653 set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags);
2683 start_priv = startdev->private;
2684 base_priv = base->private;
2686 rpt = recs_per_track(&base_priv->rdc_data, 0, fdata->blksize);
2688 nr_tracks = fdata->stop_unit - fdata->start_unit + 1;
2691 * fdata->intensity is a bit string that tells us what to do:
2699 if (fdata->intensity & 0x10) {
2701 intensity = fdata->intensity & ~0x10;
2704 intensity = fdata->intensity;
2707 use_prefix = base_priv->features.feature[8] & 0x01;
2749 dev_warn(&startdev->cdev->dev,
2751 fdata->intensity);
2752 return ERR_PTR(-EINVAL);
2759 start_priv->count++;
2760 data = fcp->data;
2761 ccw = fcp->cpaddr;
2767 fdata->start_unit, fdata->stop_unit,
2772 ->define_extent.ga_extended |= 0x04;
2776 fdata->start_unit, fdata->stop_unit,
2781 ->ga_extended |= 0x04;
2784 ccw[-1].flags |= CCW_FLAG_CC;
2786 fdata->start_unit, 0, rpt*nr_tracks,
2788 fdata->blksize);
2794 fdata->start_unit, fdata->stop_unit,
2800 fdata->start_unit, fdata->stop_unit,
2804 ccw[-1].flags |= CCW_FLAG_CC;
2806 fdata->start_unit, 0, rpt * nr_tracks + 1,
2808 base->block->bp_block);
2814 fdata->start_unit, fdata->stop_unit,
2819 fdata->start_unit, fdata->stop_unit,
2823 ccw[-1].flags |= CCW_FLAG_CC;
2825 fdata->start_unit, 0, 1,
2834 (fdata->start_unit + j) /
2835 base_priv->rdc_data.trk_per_cyl,
2836 (fdata->start_unit + j) %
2837 base_priv->rdc_data.trk_per_cyl);
2841 ect->cyl = address.cyl;
2842 ect->head = address.head;
2843 ect->record = 0;
2844 ect->kl = 0;
2845 ect->dl = 8;
2846 ccw[-1].flags |= CCW_FLAG_CC;
2847 ccw->cmd_code = DASD_ECKD_CCW_WRITE_RECORD_ZERO;
2848 ccw->flags = CCW_FLAG_SLI;
2849 ccw->count = 8;
2850 ccw->cda = virt_to_dma32(ect);
2856 ect->cyl = address.cyl;
2857 ect->head = address.head;
2858 ect->record = 1;
2859 ect->kl = 0;
2860 ect->dl = 0;
2861 ccw[-1].flags |= CCW_FLAG_CC;
2862 ccw->cmd_code = DASD_ECKD_CCW_WRITE_CKD;
2863 ccw->flags = CCW_FLAG_SLI;
2864 ccw->count = 8;
2865 ccw->cda = virt_to_dma32(ect);
2870 ect->cyl = address.cyl;
2871 ect->head = address.head;
2872 ect->record = i + 1;
2873 ect->kl = 0;
2874 ect->dl = fdata->blksize;
2876 * Check for special tracks 0-1
2882 ect->kl = 4;
2883 ect->dl = sizes_trk0[i] - 4;
2888 ect->kl = 44;
2889 ect->dl = LABEL_SIZE - 44;
2891 ccw[-1].flags |= CCW_FLAG_CC;
2893 ccw->cmd_code =
2896 ccw->cmd_code =
2898 ccw->flags = CCW_FLAG_SLI;
2899 ccw->count = 8;
2900 ccw->cda = virt_to_dma32(ect);
2906 fcp->startdev = startdev;
2907 fcp->memdev = startdev;
2908 fcp->basedev = base;
2909 fcp->retries = 256;
2910 fcp->expires = startdev->default_expires * HZ;
2911 fcp->buildclk = get_tod_clock();
2912 fcp->status = DASD_CQR_FILLED;
2948 struct dasd_eckd_private *private = base->private;
2950 if (fdata->start_unit >=
2951 (private->real_cyl * private->rdc_data.trk_per_cyl)) {
2952 dev_warn(&base->cdev->dev,
2954 fdata->start_unit);
2955 return -EINVAL;
2957 if (fdata->stop_unit >=
2958 (private->real_cyl * private->rdc_data.trk_per_cyl)) {
2959 dev_warn(&base->cdev->dev,
2961 fdata->stop_unit);
2962 return -EINVAL;
2964 if (fdata->start_unit > fdata->stop_unit) {
2965 dev_warn(&base->cdev->dev,
2967 fdata->start_unit);
2968 return -EINVAL;
2970 if (dasd_check_blocksize(fdata->blksize) != 0) {
2971 dev_warn(&base->cdev->dev,
2973 fdata->blksize);
2974 return -EINVAL;
2988 struct dasd_eckd_private *private = base->private;
3003 old_start = fdata->start_unit;
3004 old_stop = fdata->stop_unit;
3015 recs_per_track(&private->rdc_data, 0, fdata->blksize);
3020 while (fdata->start_unit <= old_stop) {
3021 step = fdata->stop_unit - fdata->start_unit + 1;
3023 fdata->stop_unit =
3024 fdata->start_unit + format_step - 1;
3032 if (rc == -ENOMEM) {
3045 list_add_tail(&cqr->blocklist, &format_queue);
3048 step = fdata->stop_unit - fdata->start_unit + 1;
3051 fdata->start_unit = fdata->stop_unit + 1;
3052 fdata->stop_unit = old_stop;
3059 device = cqr->startdev;
3060 private = device->private;
3062 if (cqr->status == DASD_CQR_FAILED) {
3068 sense = dasd_get_sense(&cqr->irb);
3069 memcpy(irb, &cqr->irb, sizeof(*irb));
3071 rc = -EIO;
3073 list_del_init(&cqr->blocklist);
3075 private->count--;
3078 if (rc && rc != -EIO)
3080 if (rc == -EIO) {
3086 * pass the -EIO to the IOCTL, therefore reset the rc
3100 fdata->start_unit = old_start;
3101 fdata->stop_unit = old_stop;
3116 struct dasd_block *block = cqr->block;
3121 spin_lock_irqsave(&block->format_lock, flags);
3122 if (cqr->trkcount != atomic_read(&block->trkcount)) {
3132 list_for_each_entry(format, &block->format_list, list) {
3133 if (format->track == to_format->track) {
3138 list_add_tail(&to_format->list, &block->format_list);
3141 spin_unlock_irqrestore(&block->format_lock, flags);
3150 spin_lock_irqsave(&block->format_lock, flags);
3151 atomic_inc(&block->trkcount);
3152 list_del_init(&format->list);
3153 spin_unlock_irqrestore(&block->format_lock, flags);
3161 struct dasd_device *device = cqr->startdev;
3162 struct dasd_eckd_private *private = device->private;
3165 clear_format_track(format, cqr->basedev->block);
3166 private->count--;
3189 block = cqr->block;
3190 base = block->base;
3191 private = base->private;
3192 blksize = block->bp_block;
3193 recs_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
3194 format = &startdev->format_entry;
3196 first_trk = blk_rq_pos(req) >> block->s2b_shift;
3199 (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
3207 "ESE error track %llu not within range %llu - %llu\n",
3209 return ERR_PTR(-EINVAL);
3211 format->track = curr_trk;
3215 cqr->retries++;
3216 return ERR_PTR(-EEXIST);
3222 fdata.intensity = private->uses_cdl ? DASD_FMT_INT_COMPAT : 0;
3226 return ERR_PTR(-EINVAL);
3236 fcqr->callback = dasd_eckd_ese_format_cb;
3237 fcqr->callback_data = (void *) format;
3273 req = (struct request *) cqr->callback_data;
3274 base = cqr->block->base;
3275 blksize = base->block->bp_block;
3276 block = cqr->block;
3277 private = base->private;
3281 recs_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
3282 first_trk = first_blk = blk_rq_pos(req) >> block->s2b_shift;
3285 (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
3294 "ESE error track %llu not within range %llu - %llu\n",
3296 return -EINVAL;
3304 skip_block = curr_trk * recs_per_trk - first_blk;
3313 cqr->proc_bytes = blk_count * blksize;
3319 skip_block--;
3340 * - if data reoccurs (same head and record may reoccur), which may
3342 * - when the head changes, because we're iterating over several tracks
3344 * - when we've reached the end of sensible data in the buffer (the
3357 return i - start;
3381 trkcount = cdata->expect.stop_unit - cdata->expect.start_unit + 1;
3384 for (i = cdata->expect.start_unit; i <= cdata->expect.stop_unit; i++) {
3393 if (i != cdata->expect.start_unit)
3394 pos += rpt_max - count;
3404 cdata->result = DASD_FMT_ERR_TOO_FEW_RECORDS;
3408 cdata->result = DASD_FMT_ERR_TOO_MANY_RECORDS;
3413 blksize = cdata->expect.blksize;
3420 if ((cdata->expect.intensity & 0x08) &&
3423 blksize = sizes_trk0[j] - 4;
3427 if ((cdata->expect.intensity & 0x08) &&
3429 blksize = LABEL_SIZE - 44;
3435 cdata->result = DASD_FMT_ERR_BLKSIZE;
3440 cdata->result = DASD_FMT_ERR_KEY_LENGTH;
3447 cdata->result = DASD_FMT_ERR_RECORD_ID;
3458 if (!cdata->result) {
3459 i--;
3460 pos--;
3463 cdata->unit = i;
3464 cdata->num_records = count;
3465 cdata->rec = fmt_buffer[pos].record;
3466 cdata->blksize = fmt_buffer[pos].dl;
3467 cdata->key_length = fmt_buffer[pos].kl;
3477 struct dasd_eckd_private *private = base->private;
3487 trk_per_cyl = private->rdc_data.trk_per_cyl;
3490 rpt_max = recs_per_track(&private->rdc_data, 0, 512) + 1;
3491 rpt_exp = recs_per_track(&private->rdc_data, 0, cdata->expect.blksize);
3493 trkcount = cdata->expect.stop_unit - cdata->expect.start_unit + 1;
3498 return -ENOMEM;
3508 if ((private->features.feature[40] & 0x04) &&
3509 fmt_buffer_size <= private->fcx_max_data)
3512 rc = dasd_eckd_format_process_data(base, &cdata->expect, enable_pav,
3514 if (rc && rc != -EIO)
3516 if (rc == -EIO) {
3524 rc = dasd_eckd_format_process_data(base, &cdata->expect,
3546 if (cqr->retries < 0) {
3547 cqr->status = DASD_CQR_FAILED;
3550 cqr->status = DASD_CQR_FILLED;
3551 if (cqr->block && (cqr->startdev != cqr->block->base)) {
3553 cqr->startdev = cqr->block->base;
3554 cqr->lpm = dasd_path_get_opm(cqr->block->base);
3561 struct dasd_device *device = (struct dasd_device *) cqr->startdev;
3562 struct ccw_device *cdev = device->cdev;
3564 switch (cdev->id.cu_type) {
3589 struct dasd_eckd_private *private = device->private;
3593 if ((scsw_dstat(&irb->scsw) & mask) == mask) {
3598 if (!device->block && private->lcu &&
3599 device->state == DASD_STATE_ONLINE &&
3600 !test_bit(DASD_FLAG_OFFLINE, &device->flags) &&
3601 !test_bit(DASD_FLAG_SUSPENDED, &device->flags)) {
3615 (scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK)) {
3616 if (test_and_set_bit(DASD_FLAG_SUC, &device->flags)) {
3625 clear_bit(DASD_FLAG_SUC, &device->flags);
3629 private->suc_reason = sense[8];
3632 private->suc_reason);
3634 if (!schedule_work(&device->suc_work))
3650 if (device->block && (sense[27] & DASD_SENSE_BIT_0) &&
3652 (scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK) &&
3653 test_bit(DASD_FLAG_IS_RESERVED, &device->flags)) {
3654 if (device->features & DASD_FEATURE_FAILONSLCK)
3655 set_bit(DASD_FLAG_LOCK_STOLEN, &device->flags);
3656 clear_bit(DASD_FLAG_IS_RESERVED, &device->flags);
3657 dev_err(&device->cdev->dev,
3666 struct dasd_eckd_private *private = device->private;
3670 trks_per_vol = private->real_cyl * private->rdc_data.trk_per_cyl;
3673 dev_warn(&device->cdev->dev,
3676 rc = -EINVAL;
3678 dev_warn(&device->cdev->dev,
3681 rc = -EINVAL;
3683 dev_warn(&device->cdev->dev,
3686 rc = -EINVAL;
3706 tmp = from + trks_per_ext - (from % trks_per_ext) - 1;
3709 cur_pos = tmp - from + 1;
3713 if (to - (from + cur_pos) + 1 >= trks_per_ext) {
3714 tmp = to - ((to - trks_per_ext + 1) % trks_per_ext);
3715 count += (tmp - (from + cur_pos) + 1) / trks_per_ext;
3735 return -ENOMEM;
3739 rc = temp->dev_info[0].state;
3753 struct dasd_eckd_private *private = device->private;
3771 return ERR_PTR(-EINVAL);
3779 features = &private->features;
3781 trks_per_ext = dasd_eckd_ext_size(device) * private->rdc_data.trk_per_cyl;
3790 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
3795 ras_data = cqr->data;
3798 ras_data->order = DSO_ORDER_RAS;
3799 ras_data->flags.vol_type = 0; /* CKD volume */
3801 ras_data->op_flags.by_extent = by_extent;
3807 if (features->feature[56] & 0x01 && !copy_relation)
3808 ras_data->op_flags.guarantee_init = 1;
3810 ras_data->lss = private->conf.ned->ID;
3811 ras_data->dev_addr = private->conf.ned->unit_addr;
3812 ras_data->nr_exts = nr_exts;
3815 heads = private->rdc_data.trk_per_cyl;
3817 cur_to_trk = first_trk + trks_per_ext -
3818 (first_trk % trks_per_ext) - 1;
3821 ras_range = (struct dasd_dso_ras_ext_range *)(cqr->data + ras_size);
3829 set_ch_t(&ras_range->beg_ext, beg_cyl, beg_head);
3830 set_ch_t(&ras_range->end_ext, end_cyl, end_head);
3833 cur_to_trk = cur_from_trk + trks_per_ext - 1;
3840 ccw = cqr->cpaddr;
3841 ccw->cda = virt_to_dma32(cqr->data);
3842 ccw->cmd_code = DASD_ECKD_CCW_DSO;
3843 ccw->count = size;
3845 cqr->startdev = device;
3846 cqr->memdev = device;
3847 cqr->block = block;
3848 cqr->retries = 256;
3849 cqr->expires = device->default_expires * HZ;
3850 cqr->buildclk = get_tod_clock();
3851 cqr->status = DASD_CQR_FILLED;
3867 dasd_sfree_request(cqr, cqr->memdev);
3875 struct dasd_eckd_private *private = device->private;
3876 struct dasd_block *block = device->block;
3888 device_exts = private->real_cyl / dasd_eckd_ext_size(device);
3889 trks_per_ext = dasd_eckd_ext_size(device) * private->rdc_data.trk_per_cyl;
3898 stop = cur_pos + step -
3899 ((cur_pos + step) % trks_per_ext) - 1;
3906 if (rc == -ENOMEM) {
3915 spin_lock_irq(&block->queue_lock);
3916 list_add_tail(&cqr->blocklist, &ras_queue);
3917 spin_unlock_irq(&block->queue_lock);
3925 device = cqr->startdev;
3926 private = device->private;
3928 spin_lock_irq(&block->queue_lock);
3929 list_del_init(&cqr->blocklist);
3930 spin_unlock_irq(&block->queue_lock);
3932 private->count--;
3943 if (rdata->intensity & DASD_FMT_INT_ESE_FULL)
3945 else if (rdata->intensity == 0)
3946 return dasd_eckd_release_space_trks(device, rdata->start_unit,
3947 rdata->stop_unit);
3949 return -EINVAL;
3980 basedev = block->base;
3981 private = basedev->private;
3987 return ERR_PTR(-EINVAL);
3993 if (bv.bv_len & (blksize - 1))
3995 return ERR_PTR(-EINVAL);
3996 count += bv.bv_len >> (block->s2b_shift + 9);
3998 cidaw += bv.bv_len >> (block->s2b_shift + 9);
4001 if (count != last_rec - first_rec + 1)
4002 return ERR_PTR(-EINVAL);
4005 use_prefix = private->features.feature[8] & 0x01;
4022 if (private->uses_cdl && first_rec < 2*blk_per_trk) {
4024 count = 2*blk_per_trk - first_rec;
4033 ccw = cqr->cpaddr;
4036 if (prefix(ccw++, cqr->data, first_trk,
4037 last_trk, cmd, basedev, startdev) == -EAGAIN) {
4042 return ERR_PTR(-EAGAIN);
4044 idaws = (dma64_t *)(cqr->data + sizeof(struct PFX_eckd_data));
4046 if (define_extent(ccw++, cqr->data, first_trk,
4047 last_trk, cmd, basedev, 0) == -EAGAIN) {
4052 return ERR_PTR(-EAGAIN);
4054 idaws = (dma64_t *)(cqr->data + sizeof(struct DE_eckd_data));
4059 if (private->uses_cdl == 0 || recid > 2*blk_per_trk) {
4061 ccw[-1].flags |= CCW_FLAG_CC;
4063 last_rec - recid + 1, cmd, basedev, blksize);
4081 if (private->uses_cdl && recid < 2*blk_per_trk) {
4088 blksize - count);
4090 ccw[-1].flags |= CCW_FLAG_CC;
4096 if (private->uses_cdl && recid == 2*blk_per_trk) {
4097 ccw[-1].flags |= CCW_FLAG_CC;
4100 last_rec - recid + 1,
4104 ccw[-1].flags |= CCW_FLAG_CC;
4105 ccw->cmd_code = rcmd;
4106 ccw->count = count;
4108 ccw->cda = virt_to_dma32(idaws);
4109 ccw->flags = CCW_FLAG_IDA;
4112 ccw->cda = virt_to_dma32(dst);
4113 ccw->flags = 0;
4121 block->base->features & DASD_FEATURE_FAILFAST)
4122 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
4123 cqr->startdev = startdev;
4124 cqr->memdev = startdev;
4125 cqr->block = block;
4126 cqr->expires = startdev->default_expires * HZ; /* default 5 minutes */
4127 cqr->lpm = dasd_path_get_ppm(startdev);
4128 cqr->retries = startdev->default_retries;
4129 cqr->buildclk = get_tod_clock();
4130 cqr->status = DASD_CQR_FILLED;
4134 set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags);
4170 basedev = block->base;
4176 return ERR_PTR(-EINVAL);
4183 cidaw = last_rec - first_rec + 1;
4184 trkcount = last_trk - first_trk + 1;
4196 ccw = cqr->cpaddr;
4199 tlf = last_offs - first_offs + 1;
4204 if (prefix_LRE(ccw++, cqr->data, first_trk,
4208 tlf) == -EAGAIN) {
4213 return ERR_PTR(-EAGAIN);
4219 * - all idaws but the first and the last must address full pages
4220 * (or 2K blocks on 31-bit)
4221 * - the scope of a ccw and it's idal ends with the track boundaries
4223 idaws = (dma64_t *)(cqr->data + sizeof(struct PFX_eckd_data));
4237 count_to_trk_end = blk_per_trk - recoffs;
4238 count = min((last_rec - recid + 1),
4241 ccw[-1].flags |= CCW_FLAG_CC;
4242 ccw->cmd_code = cmd;
4243 ccw->count = len_to_track_end;
4244 ccw->cda = virt_to_dma32(idaws);
4245 ccw->flags = CCW_FLAG_IDA;
4260 if ((unsigned long)(dst) & (IDA_BLOCK_SIZE - 1)) {
4262 return ERR_PTR(-ERANGE);
4268 return ERR_PTR(-ERANGE);
4271 seg_len -= part_len;
4274 len_to_track_end -= part_len;
4276 * -> create an idaw
4280 if (!((unsigned long)(idaw_dst + idaw_len) & (IDA_BLOCK_SIZE - 1)))
4298 block->base->features & DASD_FEATURE_FAILFAST)
4299 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
4300 cqr->startdev = startdev;
4301 cqr->memdev = startdev;
4302 cqr->block = block;
4303 cqr->expires = startdev->default_expires * HZ; /* default 5 minutes */
4304 cqr->lpm = dasd_path_get_ppm(startdev);
4305 cqr->retries = startdev->default_retries;
4306 cqr->buildclk = get_tod_clock();
4307 cqr->status = DASD_CQR_FILLED;
4311 set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags);
4342 basepriv = basedev->private;
4343 startpriv = startdev->private;
4349 pfxdata.base_address = basepriv->conf.ned->unit_addr;
4350 pfxdata.base_lss = basepriv->conf.ned->ID;
4354 if (startpriv->uid.type == UA_BASE_PAV_ALIAS)
4357 if (startpriv->uid.type == UA_HYPER_PAV_ALIAS) {
4364 dedata->mask.perm = 0x1;
4365 dedata->attributes.operation = basepriv->attrib.operation;
4366 dedata->blk_size = blksize;
4367 dedata->ga_extended |= 0x42;
4368 lredata->operation.orientation = 0x0;
4369 lredata->operation.operation = 0x0C;
4370 lredata->auxiliary.check_bytes = 0x01;
4374 dedata->mask.perm = 0x02;
4375 dedata->attributes.operation = basepriv->attrib.operation;
4376 dedata->blk_size = blksize;
4378 dedata->ga_extended |= 0x42;
4379 lredata->operation.orientation = 0x0;
4380 lredata->operation.operation = 0x3F;
4381 lredata->extended_operation = 0x23;
4382 lredata->auxiliary.check_bytes = 0x2;
4388 if (dedata->ga_extended & 0x08 && dedata->ga_extended & 0x02)
4393 dedata->mask.perm = 0x1;
4394 dedata->attributes.operation = DASD_BYPASS_CACHE;
4395 dedata->ga_extended |= 0x42;
4396 dedata->blk_size = blksize;
4397 lredata->operation.orientation = 0x2;
4398 lredata->operation.operation = 0x16;
4399 lredata->auxiliary.check_bytes = 0x01;
4411 dedata->attributes.mode = 0x3; /* ECKD */
4413 heads = basepriv->rdc_data.trk_per_cyl;
4419 /* check for sequential prestage - enhance cylinder range */
4420 if (dedata->attributes.operation == DASD_SEQ_PRESTAGE ||
4421 dedata->attributes.operation == DASD_SEQ_ACCESS) {
4423 if (endcyl + basepriv->attrib.nr_cyl < basepriv->real_cyl)
4424 endcyl += basepriv->attrib.nr_cyl;
4426 endcyl = (basepriv->real_cyl - 1);
4429 set_ch_t(&dedata->beg_ext, begcyl, beghead);
4430 set_ch_t(&dedata->end_ext, endcyl, endhead);
4432 dedata->ep_format = 0x20; /* records per track is valid */
4433 dedata->ep_rec_per_track = blk_per_trk;
4436 switch (basepriv->rdc_data.dev_type) {
4440 sector = (49 + (rec_on_trk - 1) * (10 + d)) / 8;
4444 sector = (39 + (rec_on_trk - 1) * (8 + d)) / 7;
4450 lredata->auxiliary.length_valid = 0;
4451 lredata->auxiliary.length_scope = 0;
4452 lredata->sector = 0xff;
4454 lredata->auxiliary.length_valid = 1;
4455 lredata->auxiliary.length_scope = 1;
4456 lredata->sector = sector;
4458 lredata->auxiliary.imbedded_ccw_valid = 1;
4459 lredata->length = tlf;
4460 lredata->imbedded_ccw = cmd;
4461 lredata->count = count;
4462 set_ch_t(&lredata->seek_addr, begcyl, beghead);
4463 lredata->search_arg.cyl = lredata->seek_addr.cyl;
4464 lredata->search_arg.head = lredata->seek_addr.head;
4465 lredata->search_arg.record = rec_on_trk;
4505 basedev = block->base;
4513 return ERR_PTR(-EINVAL);
4521 trkcount = last_trk - first_trk + 1;
4527 ctidaw += (last_trk - first_trk);
4538 tlf = last_offs - first_offs + 1;
4543 itcw = itcw_init(cqr->data, itcw_size, itcw_op, 0, ctidaw, 0);
4545 ret = -EINVAL;
4548 cqr->cpaddr = itcw_get_tcw(itcw);
4553 (last_rec - first_rec + 1) * blksize,
4554 tlf, blk_per_trk) == -EAGAIN) {
4558 ret = -EAGAIN;
4580 count_to_trk_end = blk_per_trk - offs;
4581 count = min((last_rec - recid + 1),
4588 seg_len -= part_len;
4589 len_to_track_end -= part_len;
4599 ret = -EINVAL;
4611 ret = -EINVAL;
4616 last_tidaw->flags |= TIDAW_FLAGS_LAST;
4617 last_tidaw->flags &= ~TIDAW_FLAGS_INSERT_CBC;
4621 block->base->features & DASD_FEATURE_FAILFAST)
4622 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
4623 cqr->cpmode = 1;
4624 cqr->startdev = startdev;
4625 cqr->memdev = startdev;
4626 cqr->block = block;
4627 cqr->expires = startdev->default_expires * HZ; /* default 5 minutes */
4628 cqr->lpm = dasd_path_get_ppm(startdev);
4629 cqr->retries = startdev->default_retries;
4630 cqr->buildclk = get_tod_clock();
4631 cqr->status = DASD_CQR_FILLED;
4635 set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags);
4636 set_bit(DASD_CQR_SUPPRESS_IT, &cqr->flags);
4662 basedev = block->base;
4663 private = basedev->private;
4666 blksize = block->bp_block;
4667 blk_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
4669 return ERR_PTR(-EINVAL);
4671 first_rec = first_trk = blk_rq_pos(req) >> block->s2b_shift;
4674 (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
4676 cdlspecial = (private->uses_cdl && first_rec < 2*blk_per_trk);
4678 fcx_multitrack = private->features.feature[40] & 0x20;
4681 return ERR_PTR(-EINVAL);
4684 data_size += (last_trk - first_trk) * 4;
4687 cmdrtd = private->features.feature[9] & 0x20;
4688 cmdwtd = private->features.feature[12] & 0x40;
4689 use_prefix = private->features.feature[8] & 0x01;
4694 } else if ((data_size <= private->fcx_max_data)
4701 if (IS_ERR(cqr) && (PTR_ERR(cqr) != -EAGAIN) &&
4702 (PTR_ERR(cqr) != -ENOMEM))
4712 if (IS_ERR(cqr) && (PTR_ERR(cqr) != -EAGAIN) &&
4713 (PTR_ERR(cqr) != -ENOMEM))
4755 end_padding_sectors = (DASD_RAW_SECTORS_PER_TRACK - end_sector_offset) %
4757 basedev = block->base;
4763 return ERR_PTR(-EINVAL);
4767 last_trk = (blk_rq_pos(req) + blk_rq_sectors(req) - 1) /
4769 trkcount = last_trk - first_trk + 1;
4776 return ERR_PTR(-EINVAL);
4788 base_priv = basedev->private;
4789 use_prefix = base_priv->features.feature[8] & 0x01;
4808 ccw = cqr->cpaddr;
4809 data = cqr->data;
4816 ccw[-1].flags |= CCW_FLAG_CC;
4823 idaws = (dma64_t *)(cqr->data + size);
4826 ccw[-1].flags |= CCW_FLAG_CC;
4827 ccw->cmd_code = cmd;
4829 ccw->count = 57326;
4831 len_to_track_end = 65536 - start_padding_sectors * 512;
4832 ccw->cda = virt_to_dma32(idaws);
4833 ccw->flags |= CCW_FLAG_IDA;
4834 ccw->flags |= CCW_FLAG_SLI;
4845 ccw[-1].flags |= CCW_FLAG_CC;
4846 ccw->cmd_code = cmd;
4848 ccw->count = 57326;
4851 ccw->cda = virt_to_dma32(idaws);
4852 ccw->flags |= CCW_FLAG_IDA;
4853 ccw->flags |= CCW_FLAG_SLI;
4856 len_to_track_end -= seg_len;
4862 block->base->features & DASD_FEATURE_FAILFAST)
4863 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
4864 cqr->startdev = startdev;
4865 cqr->memdev = startdev;
4866 cqr->block = block;
4867 cqr->expires = startdev->default_expires * HZ;
4868 cqr->lpm = dasd_path_get_ppm(startdev);
4869 cqr->retries = startdev->default_retries;
4870 cqr->buildclk = get_tod_clock();
4871 cqr->status = DASD_CQR_FILLED;
4891 private = cqr->block->base->private;
4892 blksize = cqr->block->bp_block;
4893 blk_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
4894 recid = blk_rq_pos(req) >> cqr->block->s2b_shift;
4895 ccw = cqr->cpaddr;
4898 if (private->uses_cdl == 0 || recid > 2*blk_per_trk)
4904 if (private->uses_cdl && recid <= 2*blk_per_trk)
4907 if (ccw->flags & CCW_FLAG_IDA)
4908 cda = dma64_to_virt(*((dma64_t *)dma32_to_virt(ccw->cda)));
4910 cda = dma32_to_virt(ccw->cda);
4924 status = cqr->status == DASD_CQR_DONE;
4925 dasd_sfree_request(cqr, cqr->memdev);
4933 * Either reset cqr->startdev as well (summary unit check handling)
4944 if (cqr->cpmode == 1) {
4945 tcw = cqr->cpaddr;
4947 dcw = (struct dcw *)&tccb->tca[0];
4948 pfxdata = (struct PFX_eckd_data *)&dcw->cd[0];
4949 pfxdata->validity.verify_base = 0;
4950 pfxdata->validity.hyper_pav = 0;
4952 ccw = cqr->cpaddr;
4953 pfxdata = cqr->data;
4954 if (ccw->cmd_code == DASD_ECKD_CCW_PFX) {
4955 pfxdata->validity.verify_base = 0;
4956 pfxdata->validity.hyper_pav = 0;
4975 private = startdev->private;
4976 if (private->count >= DASD_ECKD_CHANQ_MAX_SIZE)
4977 return ERR_PTR(-EBUSY);
4979 spin_lock_irqsave(get_ccwdev_lock(startdev->cdev), flags);
4980 private->count++;
4981 if ((base->features & DASD_FEATURE_USERAW))
4986 private->count--;
4987 spin_unlock_irqrestore(get_ccwdev_lock(startdev->cdev), flags);
4997 spin_lock_irqsave(get_ccwdev_lock(cqr->memdev->cdev), flags);
4998 private = cqr->memdev->private;
4999 private->count--;
5000 spin_unlock_irqrestore(get_ccwdev_lock(cqr->memdev->cdev), flags);
5008 struct dasd_eckd_private *private = device->private;
5010 info->label_block = 2;
5011 info->FBA_layout = private->uses_cdl ? 0 : 1;
5012 info->format = private->uses_cdl ? DASD_FORMAT_CDL : DASD_FORMAT_LDL;
5013 info->characteristics_size = sizeof(private->rdc_data);
5014 memcpy(info->characteristics, &private->rdc_data,
5015 sizeof(private->rdc_data));
5016 info->confdata_size = min_t(unsigned long, private->conf.len,
5017 sizeof(info->configuration_data));
5018 memcpy(info->configuration_data, private->conf.data,
5019 info->confdata_size);
5041 return -EACCES;
5048 cqr = &dasd_reserve_req->cqr;
5050 memset(&dasd_reserve_req->ccw, 0,
5051 sizeof(dasd_reserve_req->ccw));
5052 cqr->cpaddr = &dasd_reserve_req->ccw;
5053 cqr->data = &dasd_reserve_req->data;
5054 cqr->magic = DASD_ECKD_MAGIC;
5056 ccw = cqr->cpaddr;
5057 ccw->cmd_code = DASD_ECKD_CCW_RELEASE;
5058 ccw->flags |= CCW_FLAG_SLI;
5059 ccw->count = 32;
5060 ccw->cda = virt_to_dma32(cqr->data);
5061 cqr->startdev = device;
5062 cqr->memdev = device;
5063 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
5064 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
5065 cqr->retries = 2; /* set retry counter to enable basic ERP */
5066 cqr->expires = 2 * HZ;
5067 cqr->buildclk = get_tod_clock();
5068 cqr->status = DASD_CQR_FILLED;
5072 clear_bit(DASD_FLAG_IS_RESERVED, &device->flags);
5077 dasd_sfree_request(cqr, cqr->memdev);
5096 return -EACCES;
5103 cqr = &dasd_reserve_req->cqr;
5105 memset(&dasd_reserve_req->ccw, 0,
5106 sizeof(dasd_reserve_req->ccw));
5107 cqr->cpaddr = &dasd_reserve_req->ccw;
5108 cqr->data = &dasd_reserve_req->data;
5109 cqr->magic = DASD_ECKD_MAGIC;
5111 ccw = cqr->cpaddr;
5112 ccw->cmd_code = DASD_ECKD_CCW_RESERVE;
5113 ccw->flags |= CCW_FLAG_SLI;
5114 ccw->count = 32;
5115 ccw->cda = virt_to_dma32(cqr->data);
5116 cqr->startdev = device;
5117 cqr->memdev = device;
5118 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
5119 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
5120 cqr->retries = 2; /* set retry counter to enable basic ERP */
5121 cqr->expires = 2 * HZ;
5122 cqr->buildclk = get_tod_clock();
5123 cqr->status = DASD_CQR_FILLED;
5127 set_bit(DASD_FLAG_IS_RESERVED, &device->flags);
5132 dasd_sfree_request(cqr, cqr->memdev);
5137 * Steal lock ioctl - unconditional reserve device.
5150 return -EACCES;
5157 cqr = &dasd_reserve_req->cqr;
5159 memset(&dasd_reserve_req->ccw, 0,
5160 sizeof(dasd_reserve_req->ccw));
5161 cqr->cpaddr = &dasd_reserve_req->ccw;
5162 cqr->data = &dasd_reserve_req->data;
5163 cqr->magic = DASD_ECKD_MAGIC;
5165 ccw = cqr->cpaddr;
5166 ccw->cmd_code = DASD_ECKD_CCW_SLCK;
5167 ccw->flags |= CCW_FLAG_SLI;
5168 ccw->count = 32;
5169 ccw->cda = virt_to_dma32(cqr->data);
5170 cqr->startdev = device;
5171 cqr->memdev = device;
5172 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
5173 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
5174 cqr->retries = 2; /* set retry counter to enable basic ERP */
5175 cqr->expires = 2 * HZ;
5176 cqr->buildclk = get_tod_clock();
5177 cqr->status = DASD_CQR_FILLED;
5181 set_bit(DASD_FLAG_IS_RESERVED, &device->flags);
5186 dasd_sfree_request(cqr, cqr->memdev);
5191 * SNID - Sense Path Group ID
5206 return -EACCES;
5209 return -EFAULT;
5218 cqr = &dasd_reserve_req->cqr;
5220 memset(&dasd_reserve_req->ccw, 0,
5221 sizeof(dasd_reserve_req->ccw));
5222 cqr->cpaddr = &dasd_reserve_req->ccw;
5223 cqr->data = &dasd_reserve_req->data;
5224 cqr->magic = DASD_ECKD_MAGIC;
5226 ccw = cqr->cpaddr;
5227 ccw->cmd_code = DASD_ECKD_CCW_SNID;
5228 ccw->flags |= CCW_FLAG_SLI;
5229 ccw->count = 12;
5230 ccw->cda = virt_to_dma32(cqr->data);
5231 cqr->startdev = device;
5232 cqr->memdev = device;
5233 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
5234 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
5235 set_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags);
5236 cqr->retries = 5;
5237 cqr->expires = 10 * HZ;
5238 cqr->buildclk = get_tod_clock();
5239 cqr->status = DASD_CQR_FILLED;
5240 cqr->lpm = usrparm.path_mask;
5244 if (!rc && usrparm.path_mask && (cqr->lpm != usrparm.path_mask))
5245 rc = -EIO;
5247 usrparm.data = *((struct dasd_snid_data *)cqr->data);
5249 rc = -EFAULT;
5255 dasd_sfree_request(cqr, cqr->memdev);
5280 cqr->startdev = device;
5281 cqr->memdev = device;
5282 cqr->retries = 0;
5283 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
5284 cqr->expires = 10 * HZ;
5287 prssdp = (struct dasd_psf_prssd_data *) cqr->data;
5289 prssdp->order = PSF_ORDER_PRSSD;
5290 prssdp->suborder = 0x01; /* Performance Statistics */
5291 prssdp->varies[1] = 0x01; /* Perf Statistics for the Subsystem */
5293 ccw = cqr->cpaddr;
5294 ccw->cmd_code = DASD_ECKD_CCW_PSF;
5295 ccw->count = sizeof(struct dasd_psf_prssd_data);
5296 ccw->flags |= CCW_FLAG_CC;
5297 ccw->cda = virt_to_dma32(prssdp);
5299 /* Read Subsystem Data - Performance Statistics */
5304 ccw->cmd_code = DASD_ECKD_CCW_RSSD;
5305 ccw->count = sizeof(struct dasd_rssd_perf_stats_t);
5306 ccw->cda = virt_to_dma32(stats);
5308 cqr->buildclk = get_tod_clock();
5309 cqr->status = DASD_CQR_FILLED;
5312 prssdp = (struct dasd_psf_prssd_data *) cqr->data;
5316 rc = -EFAULT;
5318 dasd_sfree_request(cqr, cqr->memdev);
5329 struct dasd_eckd_private *private = device->private;
5330 struct attrib_data_t attrib = private->attrib;
5334 return -EACCES;
5336 return -EINVAL;
5341 rc = -EFAULT;
5353 struct dasd_eckd_private *private = device->private;
5357 return -EACCES;
5359 return -EINVAL;
5362 return -EFAULT;
5363 private->attrib = attrib;
5365 dev_info(&device->cdev->dev,
5367 private->attrib.operation, private->attrib.nr_cyl);
5385 return -EACCES;
5389 rc = -EFAULT;
5394 rc = -EINVAL;
5407 rc = -EINVAL;
5414 rc = -ENOMEM;
5419 rc = -EFAULT;
5436 cqr->startdev = device;
5437 cqr->memdev = device;
5438 cqr->retries = 3;
5439 cqr->expires = 10 * HZ;
5440 cqr->buildclk = get_tod_clock();
5441 cqr->status = DASD_CQR_FILLED;
5444 ccw = cqr->cpaddr;
5447 ccw->cmd_code = DASD_ECKD_CCW_PSF;
5448 ccw->count = usrparm.psf_data_len;
5449 ccw->flags |= CCW_FLAG_CC;
5450 ccw->cda = virt_to_dma32(psf_data);
5455 ccw->cmd_code = DASD_ECKD_CCW_RSSD;
5456 ccw->count = usrparm.rssd_result_len;
5457 ccw->flags = CCW_FLAG_SLI ;
5458 ccw->cda = virt_to_dma32(rssd_result);
5464 rc = -EFAULT;
5471 dasd_sfree_request(cqr, cqr->memdev);
5485 struct dasd_device *device = block->base;
5505 return -ENOTTY;
5522 len += sprintf(page + len, "CCW %px: %08X %08X DAT:",
5526 if (from->flags & CCW_FLAG_IDA)
5527 datap = dma64_to_virt(*((dma64_t *)dma32_to_virt(from->cda)));
5529 datap = dma32_to_virt(from->cda);
5532 for (count = 0; count < from->count && count < 128; count++) {
5545 dev_err(&device->cdev->dev, "%s", page);
5556 stat = (u64 *) &irb->scsw;
5581 dev = &device->cdev->dev;
5593 req, scsw_cc(&irb->scsw), scsw_fctl(&irb->scsw),
5594 scsw_actl(&irb->scsw), scsw_stctl(&irb->scsw),
5595 scsw_dstat(&irb->scsw), scsw_cstat(&irb->scsw),
5596 req ? req->intrc : 0);
5598 dma32_to_virt(irb->scsw.cmd.cpa));
5599 if (irb->esw.esw0.erw.cons) {
5601 len += sprintf(page + len, "Sense(hex) %2d-%2d:",
5606 irb->ecw[8 * sl + sct]);
5611 if (irb->ecw[27] & DASD_SENSE_BIT_0) {
5615 irb->ecw[7] >> 4, irb->ecw[7] & 0x0f,
5616 irb->ecw[1] & 0x10 ? "" : "no");
5621 irb->ecw[6] & 0x0f, irb->ecw[22] >> 4);
5624 sprintf(page + len, "SORRY - NO VALID SENSE AVAILABLE\n");
5632 first = req->cpaddr;
5633 for (last = first; last->flags & (CCW_FLAG_CC | CCW_FLAG_DC); last++);
5639 /* scsw->cda is either valid or zero */
5641 fail = dma32_to_virt(irb->scsw.cmd.cpa); /* failing CCW */
5642 if (from < fail - 2) {
5643 from = fail - 2; /* there is a gap - print header */
5652 if (from < last - 1) {
5653 from = last - 1; /* there is a gap - print header */
5684 req, scsw_cc(&irb->scsw), scsw_fctl(&irb->scsw),
5685 scsw_actl(&irb->scsw), scsw_stctl(&irb->scsw),
5686 scsw_dstat(&irb->scsw), scsw_cstat(&irb->scsw),
5687 irb->scsw.tm.fcxs,
5688 (irb->scsw.tm.ifob << 7) | irb->scsw.tm.sesq,
5689 req ? req->intrc : 0);
5691 dma32_to_virt(irb->scsw.tm.tcw));
5695 if (irb->scsw.tm.tcw && (irb->scsw.tm.fcxs & 0x01))
5696 tsb = tcw_get_tsb(dma32_to_virt(irb->scsw.tm.tcw));
5699 len += sprintf(page + len, "tsb->length %d\n", tsb->length);
5700 len += sprintf(page + len, "tsb->flags %x\n", tsb->flags);
5701 len += sprintf(page + len, "tsb->dcw_offset %d\n", tsb->dcw_offset);
5702 len += sprintf(page + len, "tsb->count %d\n", tsb->count);
5703 residual = tsb->count - 28;
5706 switch (tsb->flags & 0x07) {
5708 len += sprintf(page + len, "tsb->tsa.iostat.dev_time %d\n",
5709 tsb->tsa.iostat.dev_time);
5710 len += sprintf(page + len, "tsb->tsa.iostat.def_time %d\n",
5711 tsb->tsa.iostat.def_time);
5712 len += sprintf(page + len, "tsb->tsa.iostat.queue_time %d\n",
5713 tsb->tsa.iostat.queue_time);
5714 len += sprintf(page + len, "tsb->tsa.iostat.dev_busy_time %d\n",
5715 tsb->tsa.iostat.dev_busy_time);
5716 len += sprintf(page + len, "tsb->tsa.iostat.dev_act_time %d\n",
5717 tsb->tsa.iostat.dev_act_time);
5718 sense = tsb->tsa.iostat.sense;
5721 len += sprintf(page + len, "tsb->tsa.ddpc.rc %d\n",
5722 tsb->tsa.ddpc.rc);
5725 "tsb->tsa.ddpc.rcq %2d-%2d: ",
5727 rcq = tsb->tsa.ddpc.rcq;
5734 sense = tsb->tsa.ddpc.sense;
5738 "tsb->tsa.intrg.: not supported yet\n");
5745 "Sense(hex) %2d-%2d:",
5767 sprintf(page + len, "SORRY - NO VALID SENSE AVAILABLE\n");
5770 sprintf(page + len, "SORRY - NO TSB DATA AVAILABLE\n");
5772 dev_err(&device->cdev->dev, "%s", page);
5788 test_bit(DASD_CQR_SUPPRESS_IT, &req->flags))
5792 test_bit(DASD_CQR_SUPPRESS_CR, &req->flags))
5796 test_bit(DASD_CQR_SUPPRESS_NRF, &req->flags))
5799 if (scsw_cstat(&irb->scsw) == 0x40 &&
5800 test_bit(DASD_CQR_SUPPRESS_IL, &req->flags))
5803 if (scsw_is_tm(&irb->scsw))
5811 struct dasd_eckd_private *private = device->private;
5823 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
5824 old_base = private->uid.base_unit_addr;
5825 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
5846 dasd_eckd_get_uid_string(&private->conf, print_uid);
5847 dev_info(&device->cdev->dev,
5854 return -1;
5872 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
5877 cqr->lpm = lpum;
5879 cqr->startdev = device;
5880 cqr->memdev = device;
5881 cqr->block = NULL;
5882 cqr->expires = 10 * HZ;
5883 set_bit(DASD_CQR_VERIFY_PATH, &cqr->flags);
5887 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
5888 cqr->retries = 256;
5891 prssdp = (struct dasd_psf_prssd_data *) cqr->data;
5893 prssdp->order = PSF_ORDER_PRSSD;
5894 prssdp->suborder = 0x03; /* Message Buffer */
5897 ccw = cqr->cpaddr;
5898 ccw->cmd_code = DASD_ECKD_CCW_PSF;
5899 ccw->count = sizeof(struct dasd_psf_prssd_data);
5900 ccw->flags |= CCW_FLAG_CC;
5901 ccw->flags |= CCW_FLAG_SLI;
5902 ccw->cda = virt_to_dma32(prssdp);
5904 /* Read Subsystem Data - message buffer */
5909 ccw->cmd_code = DASD_ECKD_CCW_RSSD;
5910 ccw->count = sizeof(struct dasd_rssd_messages);
5911 ccw->flags |= CCW_FLAG_SLI;
5912 ccw->cda = virt_to_dma32(message_buf);
5914 cqr->buildclk = get_tod_clock();
5915 cqr->status = DASD_CQR_FILLED;
5918 prssdp = (struct dasd_psf_prssd_data *) cqr->data;
5923 } else if (cqr->lpm) {
5929 cqr->lpm = 0;
5932 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
5935 dasd_sfree_request(cqr, cqr->memdev);
5942 struct dasd_eckd_private *private = device->private;
5950 if (!device->block && private->lcu->pav == HYPER_PAV)
5951 return -EOPNOTSUPP;
5954 if (!(private->features.feature[14] & 0x80))
5955 return -EOPNOTSUPP;
5961 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
5968 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
5970 return -ENOMEM;
5972 cqr->startdev = device;
5973 cqr->memdev = device;
5974 cqr->block = NULL;
5975 cqr->retries = 256;
5976 cqr->expires = 10 * HZ;
5979 prssdp = (struct dasd_psf_prssd_data *) cqr->data;
5981 prssdp->order = PSF_ORDER_PRSSD;
5982 prssdp->suborder = PSF_SUBORDER_QHA; /* query host access */
5984 prssdp->lss = private->conf.ned->ID;
5985 prssdp->volume = private->conf.ned->unit_addr;
5988 ccw = cqr->cpaddr;
5989 ccw->cmd_code = DASD_ECKD_CCW_PSF;
5990 ccw->count = sizeof(struct dasd_psf_prssd_data);
5991 ccw->flags |= CCW_FLAG_CC;
5992 ccw->flags |= CCW_FLAG_SLI;
5993 ccw->cda = virt_to_dma32(prssdp);
5995 /* Read Subsystem Data - query host access */
5997 ccw->cmd_code = DASD_ECKD_CCW_RSSD;
5998 ccw->count = sizeof(struct dasd_psf_query_host_access);
5999 ccw->flags |= CCW_FLAG_SLI;
6000 ccw->cda = virt_to_dma32(host_access);
6002 cqr->buildclk = get_tod_clock();
6003 cqr->status = DASD_CQR_FILLED;
6005 __set_bit(DASD_CQR_SUPPRESS_CR, &cqr->flags);
6010 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
6013 rc = -EOPNOTSUPP;
6016 dasd_sfree_request(cqr, cqr->memdev);
6033 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
6035 return -ENOMEM;
6044 access->host_access_information;
6045 for (i = 0; i < info->entry_count; i++) {
6047 (info->entry + i * info->entry_size);
6048 if (entry->status_flags & DASD_ECKD_PG_GROUPED)
6069 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
6071 return -ENOMEM;
6080 access->host_access_information;
6081 for (i = 0; i < info->entry_count; i++) {
6083 (info->entry + i * info->entry_size);
6085 seq_printf(m, "pgid %*phN\n", 11, entry->pgid);
6087 seq_printf(m, "status_flags %02x\n", entry->status_flags);
6089 memcpy(&sysplex, &entry->sysplex_name, sizeof(sysplex) - 1);
6093 seq_printf(m, "supported_cylinder %d\n", entry->cylinder);
6096 entry->timestamp);
6110 if (copy->entry[i].configured &&
6111 strncmp(copy->entry[i].busid, busid, DASD_BUS_ID_SIZE) == 0)
6112 return copy->entry[i].device;
6126 if (copy->entry[i].configured &&
6127 strncmp(copy->entry[i].busid, new_busid,
6129 copy->active = ©->entry[i];
6130 copy->entry[i].primary = true;
6131 } else if (copy->entry[i].configured &&
6132 strncmp(copy->entry[i].busid, old_busid,
6134 copy->entry[i].primary = false;
6154 copy = device->copy;
6157 primary = copy->active->device;
6161 if (strncmp(dev_name(&primary->cdev->dev), prim_busid, DASD_BUS_ID_SIZE) != 0)
6177 block = primary->block;
6178 primary->block = NULL;
6179 secondary->block = block;
6180 block->base = secondary;
6185 gdp = block->gdp;
6188 /* re-enable device */
6197 * Perform Subsystem Function - Peer-to-Peer Remote Copy Extended Query
6212 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
6216 cqr->startdev = device;
6217 cqr->memdev = device;
6218 cqr->block = NULL;
6219 cqr->retries = 256;
6220 cqr->expires = 10 * HZ;
6223 prssdp = (struct dasd_psf_prssd_data *)cqr->data;
6225 prssdp->order = PSF_ORDER_PRSSD;
6226 prssdp->suborder = PSF_SUBORDER_PPRCEQ;
6227 prssdp->varies[0] = PPRCEQ_SCOPE_4;
6230 ccw = cqr->cpaddr;
6231 ccw->cmd_code = DASD_ECKD_CCW_PSF;
6232 ccw->count = sizeof(struct dasd_psf_prssd_data);
6233 ccw->flags |= CCW_FLAG_CC;
6234 ccw->flags |= CCW_FLAG_SLI;
6235 ccw->cda = virt_to_dma32(prssdp);
6237 /* Read Subsystem Data - query host access */
6239 ccw->cmd_code = DASD_ECKD_CCW_RSSD;
6240 ccw->count = sizeof(*pprc_data);
6241 ccw->flags |= CCW_FLAG_SLI;
6242 ccw->cda = virt_to_dma32(pprc_data);
6244 cqr->buildclk = get_tod_clock();
6245 cqr->status = DASD_CQR_FILLED;
6251 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
6254 rc = -EOPNOTSUPP;
6257 dasd_sfree_request(cqr, cqr->memdev);
6262 * ECKD NOP - no operation
6272 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
6276 cqr->startdev = device;
6277 cqr->memdev = device;
6278 cqr->block = NULL;
6279 cqr->retries = 1;
6280 cqr->expires = 10 * HZ;
6282 ccw = cqr->cpaddr;
6283 ccw->cmd_code = DASD_ECKD_CCW_NOP;
6284 ccw->flags |= CCW_FLAG_SLI;
6286 cqr->buildclk = get_tod_clock();
6287 cqr->status = DASD_CQR_FILLED;
6291 DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
6293 rc = -EOPNOTSUPP;
6295 dasd_sfree_request(cqr, cqr->memdev);
6305 * Perform Subsystem Function - CUIR response
6323 "Could not allocate PSF-CUIR request");
6327 psf_cuir = (struct dasd_psf_cuir_response *)cqr->data;
6328 psf_cuir->order = PSF_ORDER_CUIR_RESPONSE;
6329 psf_cuir->cc = response;
6330 psf_cuir->chpid = device->path[pos].chpid;
6331 psf_cuir->message_id = message_id;
6332 psf_cuir->cssid = device->path[pos].cssid;
6333 psf_cuir->ssid = device->path[pos].ssid;
6334 ccw = cqr->cpaddr;
6335 ccw->cmd_code = DASD_ECKD_CCW_PSF;
6336 ccw->cda = virt_to_dma32(psf_cuir);
6337 ccw->flags = CCW_FLAG_SLI;
6338 ccw->count = sizeof(struct dasd_psf_cuir_response);
6340 cqr->startdev = device;
6341 cqr->memdev = device;
6342 cqr->block = NULL;
6343 cqr->retries = 256;
6344 cqr->expires = 10*HZ;
6345 cqr->buildclk = get_tod_clock();
6346 cqr->status = DASD_CQR_FILLED;
6347 set_bit(DASD_CQR_VERIFY_PATH, &cqr->flags);
6351 dasd_sfree_request(cqr, cqr->memdev);
6367 if (cuir->record_selector == 0)
6370 conf_data = device->path[pos].conf_data;
6371 if (conf_data->gneq.record_selector ==
6372 cuir->record_selector)
6376 return device->path[pathmask_to_pos(lpum)].conf_data;
6401 if (!cuir->ned_map ||
6402 !(cuir->neq_map[0] | cuir->neq_map[1] | cuir->neq_map[2]))
6408 pos = 8 - ffs(cuir->ned_map);
6409 ref_ned = (char *)&ref_conf_data->neds[pos];
6410 ref_gneq = (char *)&ref_conf_data->gneq;
6412 mask = cuir->neq_map[2];
6413 mask |= cuir->neq_map[1] << 8;
6414 mask |= cuir->neq_map[0] << 16;
6419 conf_data = device->path[path].conf_data;
6420 pos = 8 - ffs(cuir->ned_map);
6421 ned = (char *) &conf_data->neds[pos];
6425 gneq = (char *)&conf_data->gneq;
6430 pos = ffs(bitmask) - 1;
6431 if (memcmp(&ref_gneq[31 - pos], &gneq[31 - pos], 1)
6452 pos = 8 - ffs(paths);
6456 device->path[pos].cssid,
6457 device->path[pos].chpid);
6460 device->path[pos].cssid,
6461 device->path[pos].chpid);
6462 clear_bit(7 - pos, &paths);
6478 return -EINVAL;
6497 struct dasd_eckd_private *private = device->private;
6505 list_for_each_entry_safe(dev, n, &private->lcu->active_devices,
6507 spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags);
6509 spin_unlock_irqrestore(get_ccwdev_lock(dev->cdev), flags);
6515 list_for_each_entry_safe(dev, n, &private->lcu->inactive_devices,
6517 spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags);
6519 spin_unlock_irqrestore(get_ccwdev_lock(dev->cdev), flags);
6526 &private->lcu->grouplist, group) {
6527 list_for_each_entry_safe(dev, n, &pavgroup->baselist,
6529 spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags);
6532 get_ccwdev_lock(dev->cdev), flags);
6537 list_for_each_entry_safe(dev, n, &pavgroup->aliaslist,
6539 spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags);
6542 get_ccwdev_lock(dev->cdev), flags);
6558 struct dasd_eckd_private *private = device->private;
6569 &private->lcu->active_devices,
6579 &private->lcu->inactive_devices,
6590 &private->lcu->grouplist,
6593 &pavgroup->baselist,
6603 &pavgroup->aliaslist,
6629 if (cuir->code == CUIR_QUIESCE) {
6635 } else if (cuir->code == CUIR_RESUME) {
6643 cuir->message_id, lpum);
6646 cuir->message_id);
6648 device->discipline->check_attention(device, lpum);
6653 struct dasd_eckd_private *private = device->private;
6658 spin_lock_irqsave(&private->lcu->lock, flags);
6659 list_for_each_entry_safe(dev, n, &private->lcu->active_devices,
6661 if (dev->stopped & DASD_STOPPED_NOSPC)
6664 list_for_each_entry_safe(dev, n, &private->lcu->inactive_devices,
6666 if (dev->stopped & DASD_STOPPED_NOSPC)
6671 &private->lcu->grouplist,
6673 list_for_each_entry_safe(dev, n, &pavgroup->baselist,
6675 if (dev->stopped & DASD_STOPPED_NOSPC)
6678 list_for_each_entry_safe(dev, n, &pavgroup->aliaslist,
6680 if (dev->stopped & DASD_STOPPED_NOSPC)
6684 spin_unlock_irqrestore(&private->lcu->lock, flags);
6692 switch (oos->code) {
6695 dev_warn(&device->cdev->dev,
6701 dev_warn(&device->cdev->dev,
6706 dev_info(&device->cdev->dev,
6715 device->discipline->check_attention(device, lpum);
6726 device = data->device;
6733 rc = dasd_eckd_read_message_buffer(device, messages, data->lpum);
6737 if (messages->length == ATTENTION_LENGTH_CUIR &&
6738 messages->format == ATTENTION_FORMAT_CUIR)
6739 dasd_eckd_handle_cuir(device, messages, data->lpum);
6740 if (messages->length == ATTENTION_LENGTH_OOS &&
6741 messages->format == ATTENTION_FORMAT_OOS)
6742 dasd_eckd_handle_oos(device, messages, data->lpum);
6756 return -ENOMEM;
6757 INIT_WORK(&data->worker, dasd_eckd_check_attention_work);
6759 data->device = device;
6760 data->lpum = lpum;
6761 schedule_work(&data->worker);
6770 dev_err(&device->cdev->dev,
6780 struct dasd_eckd_private *private = device->private;
6782 dev_err(&device->cdev->dev,
6784 private->fcx_max_data = 0;
6789 struct dasd_eckd_private *private = device->private;
6791 return private->fcx_max_data ? 1 : 0;
6797 struct dasd_eckd_private *private = device->private;
6799 if (!private->fcx_max_data) {
6805 if (irb->scsw.tm.sesq == SCSW_SESQ_DEV_NOFCX) {
6807 } else if (irb->scsw.tm.sesq == SCSW_SESQ_PATH_NOFCX) {
6808 if (dasd_eckd_disable_hpf_path(device, irb->esw.esw1.lpum))
6824 if (block->base->features & DASD_FEATURE_USERAW) {
6832 return DASD_ECKD_MAX_BLOCKS_RAW << block->s2b_shift;
6835 return DASD_ECKD_MAX_BLOCKS << block->s2b_shift;
6840 .name = "dasd-eckd",
6921 return -ENOMEM;
6926 return -ENOMEM;
6933 return -ENOMEM;
6940 return -ENOMEM;