1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com> 4 * Horst Hummel <Horst.Hummel@de.ibm.com> 5 * Carsten Otte <Cotte@de.ibm.com> 6 * Martin Schwidefsky <schwidefsky@de.ibm.com> 7 * Bugreports.to..: <Linux390@de.ibm.com> 8 * Copyright IBM Corp. 1999, 2009 9 * EMC Symmetrix ioctl Copyright EMC Corporation, 2008 10 * Author.........: Nigel Hislop <hislop_nigel@emc.com> 11 */ 12 13 #define KMSG_COMPONENT "dasd-eckd" 14 15 #include <linux/stddef.h> 16 #include <linux/kernel.h> 17 #include <linux/slab.h> 18 #include <linux/hdreg.h> /* HDIO_GETGEO */ 19 #include <linux/bio.h> 20 #include <linux/module.h> 21 #include <linux/compat.h> 22 #include <linux/init.h> 23 #include <linux/seq_file.h> 24 25 #include <asm/css_chars.h> 26 #include <asm/debug.h> 27 #include <asm/idals.h> 28 #include <asm/ebcdic.h> 29 #include <asm/io.h> 30 #include <linux/uaccess.h> 31 #include <asm/cio.h> 32 #include <asm/ccwdev.h> 33 #include <asm/itcw.h> 34 #include <asm/schid.h> 35 #include <asm/chpid.h> 36 37 #include "dasd_int.h" 38 #include "dasd_eckd.h" 39 40 #ifdef PRINTK_HEADER 41 #undef PRINTK_HEADER 42 #endif /* PRINTK_HEADER */ 43 #define PRINTK_HEADER "dasd(eckd):" 44 45 #define ECKD_C0(i) (i->home_bytes) 46 #define ECKD_F(i) (i->formula) 47 #define ECKD_F1(i) (ECKD_F(i)==0x01?(i->factors.f_0x01.f1):\ 48 (i->factors.f_0x02.f1)) 49 #define ECKD_F2(i) (ECKD_F(i)==0x01?(i->factors.f_0x01.f2):\ 50 (i->factors.f_0x02.f2)) 51 #define ECKD_F3(i) (ECKD_F(i)==0x01?(i->factors.f_0x01.f3):\ 52 (i->factors.f_0x02.f3)) 53 #define ECKD_F4(i) (ECKD_F(i)==0x02?(i->factors.f_0x02.f4):0) 54 #define ECKD_F5(i) (ECKD_F(i)==0x02?(i->factors.f_0x02.f5):0) 55 #define ECKD_F6(i) (i->factor6) 56 #define ECKD_F7(i) (i->factor7) 57 #define ECKD_F8(i) (i->factor8) 58 59 /* 60 * raw track access always map to 64k in memory 61 * so it maps to 16 blocks of 4k per track 62 */ 63 #define DASD_RAW_BLOCK_PER_TRACK 16 64 #define DASD_RAW_BLOCKSIZE 4096 65 /* 64k are 128 x 512 byte sectors */ 66 #define DASD_RAW_SECTORS_PER_TRACK 128 67 68 MODULE_LICENSE("GPL"); 69 70 static struct dasd_discipline dasd_eckd_discipline; 71 72 /* The ccw bus type uses this table to find devices that it sends to 73 * dasd_eckd_probe */ 74 static struct ccw_device_id dasd_eckd_ids[] = { 75 { CCW_DEVICE_DEVTYPE (0x3990, 0, 0x3390, 0), .driver_info = 0x1}, 76 { CCW_DEVICE_DEVTYPE (0x2105, 0, 0x3390, 0), .driver_info = 0x2}, 77 { CCW_DEVICE_DEVTYPE (0x3880, 0, 0x3380, 0), .driver_info = 0x3}, 78 { CCW_DEVICE_DEVTYPE (0x3990, 0, 0x3380, 0), .driver_info = 0x4}, 79 { CCW_DEVICE_DEVTYPE (0x2105, 0, 0x3380, 0), .driver_info = 0x5}, 80 { CCW_DEVICE_DEVTYPE (0x9343, 0, 0x9345, 0), .driver_info = 0x6}, 81 { CCW_DEVICE_DEVTYPE (0x2107, 0, 0x3390, 0), .driver_info = 0x7}, 82 { CCW_DEVICE_DEVTYPE (0x2107, 0, 0x3380, 0), .driver_info = 0x8}, 83 { CCW_DEVICE_DEVTYPE (0x1750, 0, 0x3390, 0), .driver_info = 0x9}, 84 { CCW_DEVICE_DEVTYPE (0x1750, 0, 0x3380, 0), .driver_info = 0xa}, 85 { /* end of list */ }, 86 }; 87 88 MODULE_DEVICE_TABLE(ccw, dasd_eckd_ids); 89 90 static struct ccw_driver dasd_eckd_driver; /* see below */ 91 92 static void *rawpadpage; 93 94 #define INIT_CQR_OK 0 95 #define INIT_CQR_UNFORMATTED 1 96 #define INIT_CQR_ERROR 2 97 98 /* emergency request for reserve/release */ 99 static struct { 100 struct dasd_ccw_req cqr; 101 struct ccw1 ccw; 102 char data[32]; 103 } *dasd_reserve_req; 104 static DEFINE_MUTEX(dasd_reserve_mutex); 105 106 /* definitions for the path verification worker */ 107 struct path_verification_work_data { 108 struct work_struct worker; 109 struct dasd_device *device; 110 struct dasd_ccw_req cqr; 111 struct ccw1 ccw; 112 __u8 rcd_buffer[DASD_ECKD_RCD_DATA_SIZE]; 113 int isglobal; 114 __u8 tbvpm; 115 }; 116 static struct path_verification_work_data *path_verification_worker; 117 static DEFINE_MUTEX(dasd_path_verification_mutex); 118 119 struct check_attention_work_data { 120 struct work_struct worker; 121 struct dasd_device *device; 122 __u8 lpum; 123 }; 124 125 static int prepare_itcw(struct itcw *, unsigned int, unsigned int, int, 126 struct dasd_device *, struct dasd_device *, 127 unsigned int, int, unsigned int, unsigned int, 128 unsigned int, unsigned int); 129 130 /* initial attempt at a probe function. this can be simplified once 131 * the other detection code is gone */ 132 static int 133 dasd_eckd_probe (struct ccw_device *cdev) 134 { 135 int ret; 136 137 /* set ECKD specific ccw-device options */ 138 ret = ccw_device_set_options(cdev, CCWDEV_ALLOW_FORCE | 139 CCWDEV_DO_PATHGROUP | CCWDEV_DO_MULTIPATH); 140 if (ret) { 141 DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s", 142 "dasd_eckd_probe: could not set " 143 "ccw-device options"); 144 return ret; 145 } 146 ret = dasd_generic_probe(cdev, &dasd_eckd_discipline); 147 return ret; 148 } 149 150 static int 151 dasd_eckd_set_online(struct ccw_device *cdev) 152 { 153 return dasd_generic_set_online(cdev, &dasd_eckd_discipline); 154 } 155 156 static const int sizes_trk0[] = { 28, 148, 84 }; 157 #define LABEL_SIZE 140 158 159 /* head and record addresses of count_area read in analysis ccw */ 160 static const int count_area_head[] = { 0, 0, 0, 0, 2 }; 161 static const int count_area_rec[] = { 1, 2, 3, 4, 1 }; 162 163 static inline unsigned int 164 round_up_multiple(unsigned int no, unsigned int mult) 165 { 166 int rem = no % mult; 167 return (rem ? no - rem + mult : no); 168 } 169 170 static inline unsigned int 171 ceil_quot(unsigned int d1, unsigned int d2) 172 { 173 return (d1 + (d2 - 1)) / d2; 174 } 175 176 static unsigned int 177 recs_per_track(struct dasd_eckd_characteristics * rdc, 178 unsigned int kl, unsigned int dl) 179 { 180 int dn, kn; 181 182 switch (rdc->dev_type) { 183 case 0x3380: 184 if (kl) 185 return 1499 / (15 + 7 + ceil_quot(kl + 12, 32) + 186 ceil_quot(dl + 12, 32)); 187 else 188 return 1499 / (15 + ceil_quot(dl + 12, 32)); 189 case 0x3390: 190 dn = ceil_quot(dl + 6, 232) + 1; 191 if (kl) { 192 kn = ceil_quot(kl + 6, 232) + 1; 193 return 1729 / (10 + 9 + ceil_quot(kl + 6 * kn, 34) + 194 9 + ceil_quot(dl + 6 * dn, 34)); 195 } else 196 return 1729 / (10 + 9 + ceil_quot(dl + 6 * dn, 34)); 197 case 0x9345: 198 dn = ceil_quot(dl + 6, 232) + 1; 199 if (kl) { 200 kn = ceil_quot(kl + 6, 232) + 1; 201 return 1420 / (18 + 7 + ceil_quot(kl + 6 * kn, 34) + 202 ceil_quot(dl + 6 * dn, 34)); 203 } else 204 return 1420 / (18 + 7 + ceil_quot(dl + 6 * dn, 34)); 205 } 206 return 0; 207 } 208 209 static void set_ch_t(struct ch_t *geo, __u32 cyl, __u8 head) 210 { 211 geo->cyl = (__u16) cyl; 212 geo->head = cyl >> 16; 213 geo->head <<= 4; 214 geo->head |= head; 215 } 216 217 static int check_XRC(struct ccw1 *ccw, struct DE_eckd_data *data, 218 struct dasd_device *device) 219 { 220 struct dasd_eckd_private *private = device->private; 221 int rc; 222 223 if (!private->rdc_data.facilities.XRC_supported) 224 return 0; 225 226 /* switch on System Time Stamp - needed for XRC Support */ 227 data->ga_extended |= 0x08; /* switch on 'Time Stamp Valid' */ 228 data->ga_extended |= 0x02; /* switch on 'Extended Parameter' */ 229 230 rc = get_phys_clock(&data->ep_sys_time); 231 /* Ignore return code if sync clock is switched off. */ 232 if (rc == -EOPNOTSUPP || rc == -EACCES) 233 rc = 0; 234 235 if (ccw) { 236 ccw->count = sizeof(struct DE_eckd_data); 237 ccw->flags |= CCW_FLAG_SLI; 238 } 239 240 return rc; 241 } 242 243 static int 244 define_extent(struct ccw1 *ccw, struct DE_eckd_data *data, unsigned int trk, 245 unsigned int totrk, int cmd, struct dasd_device *device, 246 int blksize) 247 { 248 struct dasd_eckd_private *private = device->private; 249 u16 heads, beghead, endhead; 250 u32 begcyl, endcyl; 251 int rc = 0; 252 253 if (ccw) { 254 ccw->cmd_code = DASD_ECKD_CCW_DEFINE_EXTENT; 255 ccw->flags = 0; 256 ccw->count = 16; 257 ccw->cda = (__u32)__pa(data); 258 } 259 260 memset(data, 0, sizeof(struct DE_eckd_data)); 261 switch (cmd) { 262 case DASD_ECKD_CCW_READ_HOME_ADDRESS: 263 case DASD_ECKD_CCW_READ_RECORD_ZERO: 264 case DASD_ECKD_CCW_READ: 265 case DASD_ECKD_CCW_READ_MT: 266 case DASD_ECKD_CCW_READ_CKD: 267 case DASD_ECKD_CCW_READ_CKD_MT: 268 case DASD_ECKD_CCW_READ_KD: 269 case DASD_ECKD_CCW_READ_KD_MT: 270 data->mask.perm = 0x1; 271 data->attributes.operation = private->attrib.operation; 272 break; 273 case DASD_ECKD_CCW_READ_COUNT: 274 data->mask.perm = 0x1; 275 data->attributes.operation = DASD_BYPASS_CACHE; 276 break; 277 case DASD_ECKD_CCW_READ_TRACK: 278 case DASD_ECKD_CCW_READ_TRACK_DATA: 279 data->mask.perm = 0x1; 280 data->attributes.operation = private->attrib.operation; 281 data->blk_size = 0; 282 break; 283 case DASD_ECKD_CCW_WRITE: 284 case DASD_ECKD_CCW_WRITE_MT: 285 case DASD_ECKD_CCW_WRITE_KD: 286 case DASD_ECKD_CCW_WRITE_KD_MT: 287 data->mask.perm = 0x02; 288 data->attributes.operation = private->attrib.operation; 289 rc = check_XRC(ccw, data, device); 290 break; 291 case DASD_ECKD_CCW_WRITE_CKD: 292 case DASD_ECKD_CCW_WRITE_CKD_MT: 293 data->attributes.operation = DASD_BYPASS_CACHE; 294 rc = check_XRC(ccw, data, device); 295 break; 296 case DASD_ECKD_CCW_ERASE: 297 case DASD_ECKD_CCW_WRITE_HOME_ADDRESS: 298 case DASD_ECKD_CCW_WRITE_RECORD_ZERO: 299 data->mask.perm = 0x3; 300 data->mask.auth = 0x1; 301 data->attributes.operation = DASD_BYPASS_CACHE; 302 rc = check_XRC(ccw, data, device); 303 break; 304 case DASD_ECKD_CCW_WRITE_FULL_TRACK: 305 data->mask.perm = 0x03; 306 data->attributes.operation = private->attrib.operation; 307 data->blk_size = 0; 308 break; 309 case DASD_ECKD_CCW_WRITE_TRACK_DATA: 310 data->mask.perm = 0x02; 311 data->attributes.operation = private->attrib.operation; 312 data->blk_size = blksize; 313 rc = check_XRC(ccw, data, device); 314 break; 315 default: 316 dev_err(&device->cdev->dev, 317 "0x%x is not a known command\n", cmd); 318 break; 319 } 320 321 data->attributes.mode = 0x3; /* ECKD */ 322 323 if ((private->rdc_data.cu_type == 0x2105 || 324 private->rdc_data.cu_type == 0x2107 || 325 private->rdc_data.cu_type == 0x1750) 326 && !(private->uses_cdl && trk < 2)) 327 data->ga_extended |= 0x40; /* Regular Data Format Mode */ 328 329 heads = private->rdc_data.trk_per_cyl; 330 begcyl = trk / heads; 331 beghead = trk % heads; 332 endcyl = totrk / heads; 333 endhead = totrk % heads; 334 335 /* check for sequential prestage - enhance cylinder range */ 336 if (data->attributes.operation == DASD_SEQ_PRESTAGE || 337 data->attributes.operation == DASD_SEQ_ACCESS) { 338 339 if (endcyl + private->attrib.nr_cyl < private->real_cyl) 340 endcyl += private->attrib.nr_cyl; 341 else 342 endcyl = (private->real_cyl - 1); 343 } 344 345 set_ch_t(&data->beg_ext, begcyl, beghead); 346 set_ch_t(&data->end_ext, endcyl, endhead); 347 return rc; 348 } 349 350 351 static void locate_record_ext(struct ccw1 *ccw, struct LRE_eckd_data *data, 352 unsigned int trk, unsigned int rec_on_trk, 353 int count, int cmd, struct dasd_device *device, 354 unsigned int reclen, unsigned int tlf) 355 { 356 struct dasd_eckd_private *private = device->private; 357 int sector; 358 int dn, d; 359 360 if (ccw) { 361 ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD_EXT; 362 ccw->flags = 0; 363 if (cmd == DASD_ECKD_CCW_WRITE_FULL_TRACK) 364 ccw->count = 22; 365 else 366 ccw->count = 20; 367 ccw->cda = (__u32)__pa(data); 368 } 369 370 memset(data, 0, sizeof(*data)); 371 sector = 0; 372 if (rec_on_trk) { 373 switch (private->rdc_data.dev_type) { 374 case 0x3390: 375 dn = ceil_quot(reclen + 6, 232); 376 d = 9 + ceil_quot(reclen + 6 * (dn + 1), 34); 377 sector = (49 + (rec_on_trk - 1) * (10 + d)) / 8; 378 break; 379 case 0x3380: 380 d = 7 + ceil_quot(reclen + 12, 32); 381 sector = (39 + (rec_on_trk - 1) * (8 + d)) / 7; 382 break; 383 } 384 } 385 data->sector = sector; 386 /* note: meaning of count depends on the operation 387 * for record based I/O it's the number of records, but for 388 * track based I/O it's the number of tracks 389 */ 390 data->count = count; 391 switch (cmd) { 392 case DASD_ECKD_CCW_WRITE_HOME_ADDRESS: 393 data->operation.orientation = 0x3; 394 data->operation.operation = 0x03; 395 break; 396 case DASD_ECKD_CCW_READ_HOME_ADDRESS: 397 data->operation.orientation = 0x3; 398 data->operation.operation = 0x16; 399 break; 400 case DASD_ECKD_CCW_WRITE_RECORD_ZERO: 401 data->operation.orientation = 0x1; 402 data->operation.operation = 0x03; 403 data->count++; 404 break; 405 case DASD_ECKD_CCW_READ_RECORD_ZERO: 406 data->operation.orientation = 0x3; 407 data->operation.operation = 0x16; 408 data->count++; 409 break; 410 case DASD_ECKD_CCW_WRITE: 411 case DASD_ECKD_CCW_WRITE_MT: 412 case DASD_ECKD_CCW_WRITE_KD: 413 case DASD_ECKD_CCW_WRITE_KD_MT: 414 data->auxiliary.length_valid = 0x1; 415 data->length = reclen; 416 data->operation.operation = 0x01; 417 break; 418 case DASD_ECKD_CCW_WRITE_CKD: 419 case DASD_ECKD_CCW_WRITE_CKD_MT: 420 data->auxiliary.length_valid = 0x1; 421 data->length = reclen; 422 data->operation.operation = 0x03; 423 break; 424 case DASD_ECKD_CCW_WRITE_FULL_TRACK: 425 data->operation.orientation = 0x0; 426 data->operation.operation = 0x3F; 427 data->extended_operation = 0x11; 428 data->length = 0; 429 data->extended_parameter_length = 0x02; 430 if (data->count > 8) { 431 data->extended_parameter[0] = 0xFF; 432 data->extended_parameter[1] = 0xFF; 433 data->extended_parameter[1] <<= (16 - count); 434 } else { 435 data->extended_parameter[0] = 0xFF; 436 data->extended_parameter[0] <<= (8 - count); 437 data->extended_parameter[1] = 0x00; 438 } 439 data->sector = 0xFF; 440 break; 441 case DASD_ECKD_CCW_WRITE_TRACK_DATA: 442 data->auxiliary.length_valid = 0x1; 443 data->length = reclen; /* not tlf, as one might think */ 444 data->operation.operation = 0x3F; 445 data->extended_operation = 0x23; 446 break; 447 case DASD_ECKD_CCW_READ: 448 case DASD_ECKD_CCW_READ_MT: 449 case DASD_ECKD_CCW_READ_KD: 450 case DASD_ECKD_CCW_READ_KD_MT: 451 data->auxiliary.length_valid = 0x1; 452 data->length = reclen; 453 data->operation.operation = 0x06; 454 break; 455 case DASD_ECKD_CCW_READ_CKD: 456 case DASD_ECKD_CCW_READ_CKD_MT: 457 data->auxiliary.length_valid = 0x1; 458 data->length = reclen; 459 data->operation.operation = 0x16; 460 break; 461 case DASD_ECKD_CCW_READ_COUNT: 462 data->operation.operation = 0x06; 463 break; 464 case DASD_ECKD_CCW_READ_TRACK: 465 data->operation.orientation = 0x1; 466 data->operation.operation = 0x0C; 467 data->extended_parameter_length = 0; 468 data->sector = 0xFF; 469 break; 470 case DASD_ECKD_CCW_READ_TRACK_DATA: 471 data->auxiliary.length_valid = 0x1; 472 data->length = tlf; 473 data->operation.operation = 0x0C; 474 break; 475 case DASD_ECKD_CCW_ERASE: 476 data->length = reclen; 477 data->auxiliary.length_valid = 0x1; 478 data->operation.operation = 0x0b; 479 break; 480 default: 481 DBF_DEV_EVENT(DBF_ERR, device, 482 "fill LRE unknown opcode 0x%x", cmd); 483 BUG(); 484 } 485 set_ch_t(&data->seek_addr, 486 trk / private->rdc_data.trk_per_cyl, 487 trk % private->rdc_data.trk_per_cyl); 488 data->search_arg.cyl = data->seek_addr.cyl; 489 data->search_arg.head = data->seek_addr.head; 490 data->search_arg.record = rec_on_trk; 491 } 492 493 static int prefix_LRE(struct ccw1 *ccw, struct PFX_eckd_data *pfxdata, 494 unsigned int trk, unsigned int totrk, int cmd, 495 struct dasd_device *basedev, struct dasd_device *startdev, 496 unsigned int format, unsigned int rec_on_trk, int count, 497 unsigned int blksize, unsigned int tlf) 498 { 499 struct dasd_eckd_private *basepriv, *startpriv; 500 struct LRE_eckd_data *lredata; 501 struct DE_eckd_data *dedata; 502 int rc = 0; 503 504 basepriv = basedev->private; 505 startpriv = startdev->private; 506 dedata = &pfxdata->define_extent; 507 lredata = &pfxdata->locate_record; 508 509 ccw->cmd_code = DASD_ECKD_CCW_PFX; 510 ccw->flags = 0; 511 if (cmd == DASD_ECKD_CCW_WRITE_FULL_TRACK) { 512 ccw->count = sizeof(*pfxdata) + 2; 513 ccw->cda = (__u32) __pa(pfxdata); 514 memset(pfxdata, 0, sizeof(*pfxdata) + 2); 515 } else { 516 ccw->count = sizeof(*pfxdata); 517 ccw->cda = (__u32) __pa(pfxdata); 518 memset(pfxdata, 0, sizeof(*pfxdata)); 519 } 520 521 /* prefix data */ 522 if (format > 1) { 523 DBF_DEV_EVENT(DBF_ERR, basedev, 524 "PFX LRE unknown format 0x%x", format); 525 BUG(); 526 return -EINVAL; 527 } 528 pfxdata->format = format; 529 pfxdata->base_address = basepriv->ned->unit_addr; 530 pfxdata->base_lss = basepriv->ned->ID; 531 pfxdata->validity.define_extent = 1; 532 533 /* private uid is kept up to date, conf_data may be outdated */ 534 if (startpriv->uid.type != UA_BASE_DEVICE) { 535 pfxdata->validity.verify_base = 1; 536 if (startpriv->uid.type == UA_HYPER_PAV_ALIAS) 537 pfxdata->validity.hyper_pav = 1; 538 } 539 540 rc = define_extent(NULL, dedata, trk, totrk, cmd, basedev, blksize); 541 542 /* 543 * For some commands the System Time Stamp is set in the define extent 544 * data when XRC is supported. The validity of the time stamp must be 545 * reflected in the prefix data as well. 546 */ 547 if (dedata->ga_extended & 0x08 && dedata->ga_extended & 0x02) 548 pfxdata->validity.time_stamp = 1; /* 'Time Stamp Valid' */ 549 550 if (format == 1) { 551 locate_record_ext(NULL, lredata, trk, rec_on_trk, count, cmd, 552 basedev, blksize, tlf); 553 } 554 555 return rc; 556 } 557 558 static int prefix(struct ccw1 *ccw, struct PFX_eckd_data *pfxdata, 559 unsigned int trk, unsigned int totrk, int cmd, 560 struct dasd_device *basedev, struct dasd_device *startdev) 561 { 562 return prefix_LRE(ccw, pfxdata, trk, totrk, cmd, basedev, startdev, 563 0, 0, 0, 0, 0); 564 } 565 566 static void 567 locate_record(struct ccw1 *ccw, struct LO_eckd_data *data, unsigned int trk, 568 unsigned int rec_on_trk, int no_rec, int cmd, 569 struct dasd_device * device, int reclen) 570 { 571 struct dasd_eckd_private *private = device->private; 572 int sector; 573 int dn, d; 574 575 DBF_DEV_EVENT(DBF_INFO, device, 576 "Locate: trk %d, rec %d, no_rec %d, cmd %d, reclen %d", 577 trk, rec_on_trk, no_rec, cmd, reclen); 578 579 ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD; 580 ccw->flags = 0; 581 ccw->count = 16; 582 ccw->cda = (__u32) __pa(data); 583 584 memset(data, 0, sizeof(struct LO_eckd_data)); 585 sector = 0; 586 if (rec_on_trk) { 587 switch (private->rdc_data.dev_type) { 588 case 0x3390: 589 dn = ceil_quot(reclen + 6, 232); 590 d = 9 + ceil_quot(reclen + 6 * (dn + 1), 34); 591 sector = (49 + (rec_on_trk - 1) * (10 + d)) / 8; 592 break; 593 case 0x3380: 594 d = 7 + ceil_quot(reclen + 12, 32); 595 sector = (39 + (rec_on_trk - 1) * (8 + d)) / 7; 596 break; 597 } 598 } 599 data->sector = sector; 600 data->count = no_rec; 601 switch (cmd) { 602 case DASD_ECKD_CCW_WRITE_HOME_ADDRESS: 603 data->operation.orientation = 0x3; 604 data->operation.operation = 0x03; 605 break; 606 case DASD_ECKD_CCW_READ_HOME_ADDRESS: 607 data->operation.orientation = 0x3; 608 data->operation.operation = 0x16; 609 break; 610 case DASD_ECKD_CCW_WRITE_RECORD_ZERO: 611 data->operation.orientation = 0x1; 612 data->operation.operation = 0x03; 613 data->count++; 614 break; 615 case DASD_ECKD_CCW_READ_RECORD_ZERO: 616 data->operation.orientation = 0x3; 617 data->operation.operation = 0x16; 618 data->count++; 619 break; 620 case DASD_ECKD_CCW_WRITE: 621 case DASD_ECKD_CCW_WRITE_MT: 622 case DASD_ECKD_CCW_WRITE_KD: 623 case DASD_ECKD_CCW_WRITE_KD_MT: 624 data->auxiliary.last_bytes_used = 0x1; 625 data->length = reclen; 626 data->operation.operation = 0x01; 627 break; 628 case DASD_ECKD_CCW_WRITE_CKD: 629 case DASD_ECKD_CCW_WRITE_CKD_MT: 630 data->auxiliary.last_bytes_used = 0x1; 631 data->length = reclen; 632 data->operation.operation = 0x03; 633 break; 634 case DASD_ECKD_CCW_READ: 635 case DASD_ECKD_CCW_READ_MT: 636 case DASD_ECKD_CCW_READ_KD: 637 case DASD_ECKD_CCW_READ_KD_MT: 638 data->auxiliary.last_bytes_used = 0x1; 639 data->length = reclen; 640 data->operation.operation = 0x06; 641 break; 642 case DASD_ECKD_CCW_READ_CKD: 643 case DASD_ECKD_CCW_READ_CKD_MT: 644 data->auxiliary.last_bytes_used = 0x1; 645 data->length = reclen; 646 data->operation.operation = 0x16; 647 break; 648 case DASD_ECKD_CCW_READ_COUNT: 649 data->operation.operation = 0x06; 650 break; 651 case DASD_ECKD_CCW_ERASE: 652 data->length = reclen; 653 data->auxiliary.last_bytes_used = 0x1; 654 data->operation.operation = 0x0b; 655 break; 656 default: 657 DBF_DEV_EVENT(DBF_ERR, device, "unknown locate record " 658 "opcode 0x%x", cmd); 659 } 660 set_ch_t(&data->seek_addr, 661 trk / private->rdc_data.trk_per_cyl, 662 trk % private->rdc_data.trk_per_cyl); 663 data->search_arg.cyl = data->seek_addr.cyl; 664 data->search_arg.head = data->seek_addr.head; 665 data->search_arg.record = rec_on_trk; 666 } 667 668 /* 669 * Returns 1 if the block is one of the special blocks that needs 670 * to get read/written with the KD variant of the command. 671 * That is DASD_ECKD_READ_KD_MT instead of DASD_ECKD_READ_MT and 672 * DASD_ECKD_WRITE_KD_MT instead of DASD_ECKD_WRITE_MT. 673 * Luckily the KD variants differ only by one bit (0x08) from the 674 * normal variant. So don't wonder about code like: 675 * if (dasd_eckd_cdl_special(blk_per_trk, recid)) 676 * ccw->cmd_code |= 0x8; 677 */ 678 static inline int 679 dasd_eckd_cdl_special(int blk_per_trk, int recid) 680 { 681 if (recid < 3) 682 return 1; 683 if (recid < blk_per_trk) 684 return 0; 685 if (recid < 2 * blk_per_trk) 686 return 1; 687 return 0; 688 } 689 690 /* 691 * Returns the record size for the special blocks of the cdl format. 692 * Only returns something useful if dasd_eckd_cdl_special is true 693 * for the recid. 694 */ 695 static inline int 696 dasd_eckd_cdl_reclen(int recid) 697 { 698 if (recid < 3) 699 return sizes_trk0[recid]; 700 return LABEL_SIZE; 701 } 702 /* create unique id from private structure. */ 703 static void create_uid(struct dasd_eckd_private *private) 704 { 705 int count; 706 struct dasd_uid *uid; 707 708 uid = &private->uid; 709 memset(uid, 0, sizeof(struct dasd_uid)); 710 memcpy(uid->vendor, private->ned->HDA_manufacturer, 711 sizeof(uid->vendor) - 1); 712 EBCASC(uid->vendor, sizeof(uid->vendor) - 1); 713 memcpy(uid->serial, private->ned->HDA_location, 714 sizeof(uid->serial) - 1); 715 EBCASC(uid->serial, sizeof(uid->serial) - 1); 716 uid->ssid = private->gneq->subsystemID; 717 uid->real_unit_addr = private->ned->unit_addr; 718 if (private->sneq) { 719 uid->type = private->sneq->sua_flags; 720 if (uid->type == UA_BASE_PAV_ALIAS) 721 uid->base_unit_addr = private->sneq->base_unit_addr; 722 } else { 723 uid->type = UA_BASE_DEVICE; 724 } 725 if (private->vdsneq) { 726 for (count = 0; count < 16; count++) { 727 sprintf(uid->vduit+2*count, "%02x", 728 private->vdsneq->uit[count]); 729 } 730 } 731 } 732 733 /* 734 * Generate device unique id that specifies the physical device. 735 */ 736 static int dasd_eckd_generate_uid(struct dasd_device *device) 737 { 738 struct dasd_eckd_private *private = device->private; 739 unsigned long flags; 740 741 if (!private) 742 return -ENODEV; 743 if (!private->ned || !private->gneq) 744 return -ENODEV; 745 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 746 create_uid(private); 747 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 748 return 0; 749 } 750 751 static int dasd_eckd_get_uid(struct dasd_device *device, struct dasd_uid *uid) 752 { 753 struct dasd_eckd_private *private = device->private; 754 unsigned long flags; 755 756 if (private) { 757 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 758 *uid = private->uid; 759 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 760 return 0; 761 } 762 return -EINVAL; 763 } 764 765 /* 766 * compare device UID with data of a given dasd_eckd_private structure 767 * return 0 for match 768 */ 769 static int dasd_eckd_compare_path_uid(struct dasd_device *device, 770 struct dasd_eckd_private *private) 771 { 772 struct dasd_uid device_uid; 773 774 create_uid(private); 775 dasd_eckd_get_uid(device, &device_uid); 776 777 return memcmp(&device_uid, &private->uid, sizeof(struct dasd_uid)); 778 } 779 780 static void dasd_eckd_fill_rcd_cqr(struct dasd_device *device, 781 struct dasd_ccw_req *cqr, 782 __u8 *rcd_buffer, 783 __u8 lpm) 784 { 785 struct ccw1 *ccw; 786 /* 787 * buffer has to start with EBCDIC "V1.0" to show 788 * support for virtual device SNEQ 789 */ 790 rcd_buffer[0] = 0xE5; 791 rcd_buffer[1] = 0xF1; 792 rcd_buffer[2] = 0x4B; 793 rcd_buffer[3] = 0xF0; 794 795 ccw = cqr->cpaddr; 796 ccw->cmd_code = DASD_ECKD_CCW_RCD; 797 ccw->flags = 0; 798 ccw->cda = (__u32)(addr_t)rcd_buffer; 799 ccw->count = DASD_ECKD_RCD_DATA_SIZE; 800 cqr->magic = DASD_ECKD_MAGIC; 801 802 cqr->startdev = device; 803 cqr->memdev = device; 804 cqr->block = NULL; 805 cqr->expires = 10*HZ; 806 cqr->lpm = lpm; 807 cqr->retries = 256; 808 cqr->buildclk = get_tod_clock(); 809 cqr->status = DASD_CQR_FILLED; 810 set_bit(DASD_CQR_VERIFY_PATH, &cqr->flags); 811 } 812 813 /* 814 * Wakeup helper for read_conf 815 * if the cqr is not done and needs some error recovery 816 * the buffer has to be re-initialized with the EBCDIC "V1.0" 817 * to show support for virtual device SNEQ 818 */ 819 static void read_conf_cb(struct dasd_ccw_req *cqr, void *data) 820 { 821 struct ccw1 *ccw; 822 __u8 *rcd_buffer; 823 824 if (cqr->status != DASD_CQR_DONE) { 825 ccw = cqr->cpaddr; 826 rcd_buffer = (__u8 *)((addr_t) ccw->cda); 827 memset(rcd_buffer, 0, sizeof(*rcd_buffer)); 828 829 rcd_buffer[0] = 0xE5; 830 rcd_buffer[1] = 0xF1; 831 rcd_buffer[2] = 0x4B; 832 rcd_buffer[3] = 0xF0; 833 } 834 dasd_wakeup_cb(cqr, data); 835 } 836 837 static int dasd_eckd_read_conf_immediately(struct dasd_device *device, 838 struct dasd_ccw_req *cqr, 839 __u8 *rcd_buffer, 840 __u8 lpm) 841 { 842 struct ciw *ciw; 843 int rc; 844 /* 845 * sanity check: scan for RCD command in extended SenseID data 846 * some devices do not support RCD 847 */ 848 ciw = ccw_device_get_ciw(device->cdev, CIW_TYPE_RCD); 849 if (!ciw || ciw->cmd != DASD_ECKD_CCW_RCD) 850 return -EOPNOTSUPP; 851 852 dasd_eckd_fill_rcd_cqr(device, cqr, rcd_buffer, lpm); 853 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 854 set_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags); 855 cqr->retries = 5; 856 cqr->callback = read_conf_cb; 857 rc = dasd_sleep_on_immediatly(cqr); 858 return rc; 859 } 860 861 static int dasd_eckd_read_conf_lpm(struct dasd_device *device, 862 void **rcd_buffer, 863 int *rcd_buffer_size, __u8 lpm) 864 { 865 struct ciw *ciw; 866 char *rcd_buf = NULL; 867 int ret; 868 struct dasd_ccw_req *cqr; 869 870 /* 871 * sanity check: scan for RCD command in extended SenseID data 872 * some devices do not support RCD 873 */ 874 ciw = ccw_device_get_ciw(device->cdev, CIW_TYPE_RCD); 875 if (!ciw || ciw->cmd != DASD_ECKD_CCW_RCD) { 876 ret = -EOPNOTSUPP; 877 goto out_error; 878 } 879 rcd_buf = kzalloc(DASD_ECKD_RCD_DATA_SIZE, GFP_KERNEL | GFP_DMA); 880 if (!rcd_buf) { 881 ret = -ENOMEM; 882 goto out_error; 883 } 884 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* RCD */, 885 0, /* use rcd_buf as data ara */ 886 device); 887 if (IS_ERR(cqr)) { 888 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 889 "Could not allocate RCD request"); 890 ret = -ENOMEM; 891 goto out_error; 892 } 893 dasd_eckd_fill_rcd_cqr(device, cqr, rcd_buf, lpm); 894 cqr->callback = read_conf_cb; 895 ret = dasd_sleep_on(cqr); 896 /* 897 * on success we update the user input parms 898 */ 899 dasd_sfree_request(cqr, cqr->memdev); 900 if (ret) 901 goto out_error; 902 903 *rcd_buffer_size = DASD_ECKD_RCD_DATA_SIZE; 904 *rcd_buffer = rcd_buf; 905 return 0; 906 out_error: 907 kfree(rcd_buf); 908 *rcd_buffer = NULL; 909 *rcd_buffer_size = 0; 910 return ret; 911 } 912 913 static int dasd_eckd_identify_conf_parts(struct dasd_eckd_private *private) 914 { 915 916 struct dasd_sneq *sneq; 917 int i, count; 918 919 private->ned = NULL; 920 private->sneq = NULL; 921 private->vdsneq = NULL; 922 private->gneq = NULL; 923 count = private->conf_len / sizeof(struct dasd_sneq); 924 sneq = (struct dasd_sneq *)private->conf_data; 925 for (i = 0; i < count; ++i) { 926 if (sneq->flags.identifier == 1 && sneq->format == 1) 927 private->sneq = sneq; 928 else if (sneq->flags.identifier == 1 && sneq->format == 4) 929 private->vdsneq = (struct vd_sneq *)sneq; 930 else if (sneq->flags.identifier == 2) 931 private->gneq = (struct dasd_gneq *)sneq; 932 else if (sneq->flags.identifier == 3 && sneq->res1 == 1) 933 private->ned = (struct dasd_ned *)sneq; 934 sneq++; 935 } 936 if (!private->ned || !private->gneq) { 937 private->ned = NULL; 938 private->sneq = NULL; 939 private->vdsneq = NULL; 940 private->gneq = NULL; 941 return -EINVAL; 942 } 943 return 0; 944 945 }; 946 947 static unsigned char dasd_eckd_path_access(void *conf_data, int conf_len) 948 { 949 struct dasd_gneq *gneq; 950 int i, count, found; 951 952 count = conf_len / sizeof(*gneq); 953 gneq = (struct dasd_gneq *)conf_data; 954 found = 0; 955 for (i = 0; i < count; ++i) { 956 if (gneq->flags.identifier == 2) { 957 found = 1; 958 break; 959 } 960 gneq++; 961 } 962 if (found) 963 return ((char *)gneq)[18] & 0x07; 964 else 965 return 0; 966 } 967 968 static void dasd_eckd_clear_conf_data(struct dasd_device *device) 969 { 970 struct dasd_eckd_private *private = device->private; 971 int i; 972 973 private->conf_data = NULL; 974 private->conf_len = 0; 975 for (i = 0; i < 8; i++) { 976 kfree(device->path[i].conf_data); 977 device->path[i].conf_data = NULL; 978 device->path[i].cssid = 0; 979 device->path[i].ssid = 0; 980 device->path[i].chpid = 0; 981 } 982 } 983 984 985 static int dasd_eckd_read_conf(struct dasd_device *device) 986 { 987 void *conf_data; 988 int conf_len, conf_data_saved; 989 int rc, path_err, pos; 990 __u8 lpm, opm; 991 struct dasd_eckd_private *private, path_private; 992 struct dasd_uid *uid; 993 char print_path_uid[60], print_device_uid[60]; 994 struct channel_path_desc *chp_desc; 995 struct subchannel_id sch_id; 996 997 private = device->private; 998 opm = ccw_device_get_path_mask(device->cdev); 999 ccw_device_get_schid(device->cdev, &sch_id); 1000 conf_data_saved = 0; 1001 path_err = 0; 1002 /* get configuration data per operational path */ 1003 for (lpm = 0x80; lpm; lpm>>= 1) { 1004 if (!(lpm & opm)) 1005 continue; 1006 rc = dasd_eckd_read_conf_lpm(device, &conf_data, 1007 &conf_len, lpm); 1008 if (rc && rc != -EOPNOTSUPP) { /* -EOPNOTSUPP is ok */ 1009 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 1010 "Read configuration data returned " 1011 "error %d", rc); 1012 return rc; 1013 } 1014 if (conf_data == NULL) { 1015 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 1016 "No configuration data " 1017 "retrieved"); 1018 /* no further analysis possible */ 1019 dasd_path_add_opm(device, opm); 1020 continue; /* no error */ 1021 } 1022 /* save first valid configuration data */ 1023 if (!conf_data_saved) { 1024 /* initially clear previously stored conf_data */ 1025 dasd_eckd_clear_conf_data(device); 1026 private->conf_data = conf_data; 1027 private->conf_len = conf_len; 1028 if (dasd_eckd_identify_conf_parts(private)) { 1029 private->conf_data = NULL; 1030 private->conf_len = 0; 1031 kfree(conf_data); 1032 continue; 1033 } 1034 pos = pathmask_to_pos(lpm); 1035 /* store per path conf_data */ 1036 device->path[pos].conf_data = conf_data; 1037 device->path[pos].cssid = sch_id.cssid; 1038 device->path[pos].ssid = sch_id.ssid; 1039 chp_desc = ccw_device_get_chp_desc(device->cdev, pos); 1040 if (chp_desc) 1041 device->path[pos].chpid = chp_desc->chpid; 1042 kfree(chp_desc); 1043 /* 1044 * build device UID that other path data 1045 * can be compared to it 1046 */ 1047 dasd_eckd_generate_uid(device); 1048 conf_data_saved++; 1049 } else { 1050 path_private.conf_data = conf_data; 1051 path_private.conf_len = DASD_ECKD_RCD_DATA_SIZE; 1052 if (dasd_eckd_identify_conf_parts( 1053 &path_private)) { 1054 path_private.conf_data = NULL; 1055 path_private.conf_len = 0; 1056 kfree(conf_data); 1057 continue; 1058 } 1059 if (dasd_eckd_compare_path_uid( 1060 device, &path_private)) { 1061 uid = &path_private.uid; 1062 if (strlen(uid->vduit) > 0) 1063 snprintf(print_path_uid, 1064 sizeof(print_path_uid), 1065 "%s.%s.%04x.%02x.%s", 1066 uid->vendor, uid->serial, 1067 uid->ssid, uid->real_unit_addr, 1068 uid->vduit); 1069 else 1070 snprintf(print_path_uid, 1071 sizeof(print_path_uid), 1072 "%s.%s.%04x.%02x", 1073 uid->vendor, uid->serial, 1074 uid->ssid, 1075 uid->real_unit_addr); 1076 uid = &private->uid; 1077 if (strlen(uid->vduit) > 0) 1078 snprintf(print_device_uid, 1079 sizeof(print_device_uid), 1080 "%s.%s.%04x.%02x.%s", 1081 uid->vendor, uid->serial, 1082 uid->ssid, uid->real_unit_addr, 1083 uid->vduit); 1084 else 1085 snprintf(print_device_uid, 1086 sizeof(print_device_uid), 1087 "%s.%s.%04x.%02x", 1088 uid->vendor, uid->serial, 1089 uid->ssid, 1090 uid->real_unit_addr); 1091 dev_err(&device->cdev->dev, 1092 "Not all channel paths lead to " 1093 "the same device, path %02X leads to " 1094 "device %s instead of %s\n", lpm, 1095 print_path_uid, print_device_uid); 1096 path_err = -EINVAL; 1097 dasd_path_add_cablepm(device, lpm); 1098 continue; 1099 } 1100 pos = pathmask_to_pos(lpm); 1101 /* store per path conf_data */ 1102 device->path[pos].conf_data = conf_data; 1103 device->path[pos].cssid = sch_id.cssid; 1104 device->path[pos].ssid = sch_id.ssid; 1105 chp_desc = ccw_device_get_chp_desc(device->cdev, pos); 1106 if (chp_desc) 1107 device->path[pos].chpid = chp_desc->chpid; 1108 kfree(chp_desc); 1109 path_private.conf_data = NULL; 1110 path_private.conf_len = 0; 1111 } 1112 switch (dasd_eckd_path_access(conf_data, conf_len)) { 1113 case 0x02: 1114 dasd_path_add_nppm(device, lpm); 1115 break; 1116 case 0x03: 1117 dasd_path_add_ppm(device, lpm); 1118 break; 1119 } 1120 if (!dasd_path_get_opm(device)) { 1121 dasd_path_set_opm(device, lpm); 1122 dasd_generic_path_operational(device); 1123 } else { 1124 dasd_path_add_opm(device, lpm); 1125 } 1126 } 1127 1128 return path_err; 1129 } 1130 1131 static u32 get_fcx_max_data(struct dasd_device *device) 1132 { 1133 struct dasd_eckd_private *private = device->private; 1134 int fcx_in_css, fcx_in_gneq, fcx_in_features; 1135 int tpm, mdc; 1136 1137 if (dasd_nofcx) 1138 return 0; 1139 /* is transport mode supported? */ 1140 fcx_in_css = css_general_characteristics.fcx; 1141 fcx_in_gneq = private->gneq->reserved2[7] & 0x04; 1142 fcx_in_features = private->features.feature[40] & 0x80; 1143 tpm = fcx_in_css && fcx_in_gneq && fcx_in_features; 1144 1145 if (!tpm) 1146 return 0; 1147 1148 mdc = ccw_device_get_mdc(device->cdev, 0); 1149 if (mdc < 0) { 1150 dev_warn(&device->cdev->dev, "Detecting the maximum supported data size for zHPF requests failed\n"); 1151 return 0; 1152 } else { 1153 return (u32)mdc * FCX_MAX_DATA_FACTOR; 1154 } 1155 } 1156 1157 static int verify_fcx_max_data(struct dasd_device *device, __u8 lpm) 1158 { 1159 struct dasd_eckd_private *private = device->private; 1160 int mdc; 1161 u32 fcx_max_data; 1162 1163 if (private->fcx_max_data) { 1164 mdc = ccw_device_get_mdc(device->cdev, lpm); 1165 if ((mdc < 0)) { 1166 dev_warn(&device->cdev->dev, 1167 "Detecting the maximum data size for zHPF " 1168 "requests failed (rc=%d) for a new path %x\n", 1169 mdc, lpm); 1170 return mdc; 1171 } 1172 fcx_max_data = (u32)mdc * FCX_MAX_DATA_FACTOR; 1173 if (fcx_max_data < private->fcx_max_data) { 1174 dev_warn(&device->cdev->dev, 1175 "The maximum data size for zHPF requests %u " 1176 "on a new path %x is below the active maximum " 1177 "%u\n", fcx_max_data, lpm, 1178 private->fcx_max_data); 1179 return -EACCES; 1180 } 1181 } 1182 return 0; 1183 } 1184 1185 static int rebuild_device_uid(struct dasd_device *device, 1186 struct path_verification_work_data *data) 1187 { 1188 struct dasd_eckd_private *private = device->private; 1189 __u8 lpm, opm = dasd_path_get_opm(device); 1190 int rc = -ENODEV; 1191 1192 for (lpm = 0x80; lpm; lpm >>= 1) { 1193 if (!(lpm & opm)) 1194 continue; 1195 memset(&data->rcd_buffer, 0, sizeof(data->rcd_buffer)); 1196 memset(&data->cqr, 0, sizeof(data->cqr)); 1197 data->cqr.cpaddr = &data->ccw; 1198 rc = dasd_eckd_read_conf_immediately(device, &data->cqr, 1199 data->rcd_buffer, 1200 lpm); 1201 1202 if (rc) { 1203 if (rc == -EOPNOTSUPP) /* -EOPNOTSUPP is ok */ 1204 continue; 1205 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 1206 "Read configuration data " 1207 "returned error %d", rc); 1208 break; 1209 } 1210 memcpy(private->conf_data, data->rcd_buffer, 1211 DASD_ECKD_RCD_DATA_SIZE); 1212 if (dasd_eckd_identify_conf_parts(private)) { 1213 rc = -ENODEV; 1214 } else /* first valid path is enough */ 1215 break; 1216 } 1217 1218 if (!rc) 1219 rc = dasd_eckd_generate_uid(device); 1220 1221 return rc; 1222 } 1223 1224 static void do_path_verification_work(struct work_struct *work) 1225 { 1226 struct path_verification_work_data *data; 1227 struct dasd_device *device; 1228 struct dasd_eckd_private path_private; 1229 struct dasd_uid *uid; 1230 __u8 path_rcd_buf[DASD_ECKD_RCD_DATA_SIZE]; 1231 __u8 lpm, opm, npm, ppm, epm, hpfpm, cablepm; 1232 unsigned long flags; 1233 char print_uid[60]; 1234 int rc; 1235 1236 data = container_of(work, struct path_verification_work_data, worker); 1237 device = data->device; 1238 1239 /* delay path verification until device was resumed */ 1240 if (test_bit(DASD_FLAG_SUSPENDED, &device->flags)) { 1241 schedule_work(work); 1242 return; 1243 } 1244 /* check if path verification already running and delay if so */ 1245 if (test_and_set_bit(DASD_FLAG_PATH_VERIFY, &device->flags)) { 1246 schedule_work(work); 1247 return; 1248 } 1249 opm = 0; 1250 npm = 0; 1251 ppm = 0; 1252 epm = 0; 1253 hpfpm = 0; 1254 cablepm = 0; 1255 1256 for (lpm = 0x80; lpm; lpm >>= 1) { 1257 if (!(lpm & data->tbvpm)) 1258 continue; 1259 memset(&data->rcd_buffer, 0, sizeof(data->rcd_buffer)); 1260 memset(&data->cqr, 0, sizeof(data->cqr)); 1261 data->cqr.cpaddr = &data->ccw; 1262 rc = dasd_eckd_read_conf_immediately(device, &data->cqr, 1263 data->rcd_buffer, 1264 lpm); 1265 if (!rc) { 1266 switch (dasd_eckd_path_access(data->rcd_buffer, 1267 DASD_ECKD_RCD_DATA_SIZE) 1268 ) { 1269 case 0x02: 1270 npm |= lpm; 1271 break; 1272 case 0x03: 1273 ppm |= lpm; 1274 break; 1275 } 1276 opm |= lpm; 1277 } else if (rc == -EOPNOTSUPP) { 1278 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 1279 "path verification: No configuration " 1280 "data retrieved"); 1281 opm |= lpm; 1282 } else if (rc == -EAGAIN) { 1283 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 1284 "path verification: device is stopped," 1285 " try again later"); 1286 epm |= lpm; 1287 } else { 1288 dev_warn(&device->cdev->dev, 1289 "Reading device feature codes failed " 1290 "(rc=%d) for new path %x\n", rc, lpm); 1291 continue; 1292 } 1293 if (verify_fcx_max_data(device, lpm)) { 1294 opm &= ~lpm; 1295 npm &= ~lpm; 1296 ppm &= ~lpm; 1297 hpfpm |= lpm; 1298 continue; 1299 } 1300 1301 /* 1302 * save conf_data for comparison after 1303 * rebuild_device_uid may have changed 1304 * the original data 1305 */ 1306 memcpy(&path_rcd_buf, data->rcd_buffer, 1307 DASD_ECKD_RCD_DATA_SIZE); 1308 path_private.conf_data = (void *) &path_rcd_buf; 1309 path_private.conf_len = DASD_ECKD_RCD_DATA_SIZE; 1310 if (dasd_eckd_identify_conf_parts(&path_private)) { 1311 path_private.conf_data = NULL; 1312 path_private.conf_len = 0; 1313 continue; 1314 } 1315 1316 /* 1317 * compare path UID with device UID only if at least 1318 * one valid path is left 1319 * in other case the device UID may have changed and 1320 * the first working path UID will be used as device UID 1321 */ 1322 if (dasd_path_get_opm(device) && 1323 dasd_eckd_compare_path_uid(device, &path_private)) { 1324 /* 1325 * the comparison was not successful 1326 * rebuild the device UID with at least one 1327 * known path in case a z/VM hyperswap command 1328 * has changed the device 1329 * 1330 * after this compare again 1331 * 1332 * if either the rebuild or the recompare fails 1333 * the path can not be used 1334 */ 1335 if (rebuild_device_uid(device, data) || 1336 dasd_eckd_compare_path_uid( 1337 device, &path_private)) { 1338 uid = &path_private.uid; 1339 if (strlen(uid->vduit) > 0) 1340 snprintf(print_uid, sizeof(print_uid), 1341 "%s.%s.%04x.%02x.%s", 1342 uid->vendor, uid->serial, 1343 uid->ssid, uid->real_unit_addr, 1344 uid->vduit); 1345 else 1346 snprintf(print_uid, sizeof(print_uid), 1347 "%s.%s.%04x.%02x", 1348 uid->vendor, uid->serial, 1349 uid->ssid, 1350 uid->real_unit_addr); 1351 dev_err(&device->cdev->dev, 1352 "The newly added channel path %02X " 1353 "will not be used because it leads " 1354 "to a different device %s\n", 1355 lpm, print_uid); 1356 opm &= ~lpm; 1357 npm &= ~lpm; 1358 ppm &= ~lpm; 1359 cablepm |= lpm; 1360 continue; 1361 } 1362 } 1363 1364 /* 1365 * There is a small chance that a path is lost again between 1366 * above path verification and the following modification of 1367 * the device opm mask. We could avoid that race here by using 1368 * yet another path mask, but we rather deal with this unlikely 1369 * situation in dasd_start_IO. 1370 */ 1371 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 1372 if (!dasd_path_get_opm(device) && opm) { 1373 dasd_path_set_opm(device, opm); 1374 dasd_generic_path_operational(device); 1375 } else { 1376 dasd_path_add_opm(device, opm); 1377 } 1378 dasd_path_add_nppm(device, npm); 1379 dasd_path_add_ppm(device, ppm); 1380 dasd_path_add_tbvpm(device, epm); 1381 dasd_path_add_cablepm(device, cablepm); 1382 dasd_path_add_nohpfpm(device, hpfpm); 1383 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 1384 } 1385 clear_bit(DASD_FLAG_PATH_VERIFY, &device->flags); 1386 dasd_put_device(device); 1387 if (data->isglobal) 1388 mutex_unlock(&dasd_path_verification_mutex); 1389 else 1390 kfree(data); 1391 } 1392 1393 static int dasd_eckd_verify_path(struct dasd_device *device, __u8 lpm) 1394 { 1395 struct path_verification_work_data *data; 1396 1397 data = kmalloc(sizeof(*data), GFP_ATOMIC | GFP_DMA); 1398 if (!data) { 1399 if (mutex_trylock(&dasd_path_verification_mutex)) { 1400 data = path_verification_worker; 1401 data->isglobal = 1; 1402 } else 1403 return -ENOMEM; 1404 } else { 1405 memset(data, 0, sizeof(*data)); 1406 data->isglobal = 0; 1407 } 1408 INIT_WORK(&data->worker, do_path_verification_work); 1409 dasd_get_device(device); 1410 data->device = device; 1411 data->tbvpm = lpm; 1412 schedule_work(&data->worker); 1413 return 0; 1414 } 1415 1416 static void dasd_eckd_reset_path(struct dasd_device *device, __u8 pm) 1417 { 1418 struct dasd_eckd_private *private = device->private; 1419 unsigned long flags; 1420 1421 if (!private->fcx_max_data) 1422 private->fcx_max_data = get_fcx_max_data(device); 1423 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 1424 dasd_path_set_tbvpm(device, pm ? : dasd_path_get_notoperpm(device)); 1425 dasd_schedule_device_bh(device); 1426 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 1427 } 1428 1429 static int dasd_eckd_read_features(struct dasd_device *device) 1430 { 1431 struct dasd_eckd_private *private = device->private; 1432 struct dasd_psf_prssd_data *prssdp; 1433 struct dasd_rssd_features *features; 1434 struct dasd_ccw_req *cqr; 1435 struct ccw1 *ccw; 1436 int rc; 1437 1438 memset(&private->features, 0, sizeof(struct dasd_rssd_features)); 1439 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */, 1440 (sizeof(struct dasd_psf_prssd_data) + 1441 sizeof(struct dasd_rssd_features)), 1442 device); 1443 if (IS_ERR(cqr)) { 1444 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", "Could not " 1445 "allocate initialization request"); 1446 return PTR_ERR(cqr); 1447 } 1448 cqr->startdev = device; 1449 cqr->memdev = device; 1450 cqr->block = NULL; 1451 cqr->retries = 256; 1452 cqr->expires = 10 * HZ; 1453 1454 /* Prepare for Read Subsystem Data */ 1455 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 1456 memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data)); 1457 prssdp->order = PSF_ORDER_PRSSD; 1458 prssdp->suborder = 0x41; /* Read Feature Codes */ 1459 /* all other bytes of prssdp must be zero */ 1460 1461 ccw = cqr->cpaddr; 1462 ccw->cmd_code = DASD_ECKD_CCW_PSF; 1463 ccw->count = sizeof(struct dasd_psf_prssd_data); 1464 ccw->flags |= CCW_FLAG_CC; 1465 ccw->cda = (__u32)(addr_t) prssdp; 1466 1467 /* Read Subsystem Data - feature codes */ 1468 features = (struct dasd_rssd_features *) (prssdp + 1); 1469 memset(features, 0, sizeof(struct dasd_rssd_features)); 1470 1471 ccw++; 1472 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 1473 ccw->count = sizeof(struct dasd_rssd_features); 1474 ccw->cda = (__u32)(addr_t) features; 1475 1476 cqr->buildclk = get_tod_clock(); 1477 cqr->status = DASD_CQR_FILLED; 1478 rc = dasd_sleep_on(cqr); 1479 if (rc == 0) { 1480 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 1481 features = (struct dasd_rssd_features *) (prssdp + 1); 1482 memcpy(&private->features, features, 1483 sizeof(struct dasd_rssd_features)); 1484 } else 1485 dev_warn(&device->cdev->dev, "Reading device feature codes" 1486 " failed with rc=%d\n", rc); 1487 dasd_sfree_request(cqr, cqr->memdev); 1488 return rc; 1489 } 1490 1491 1492 /* 1493 * Build CP for Perform Subsystem Function - SSC. 1494 */ 1495 static struct dasd_ccw_req *dasd_eckd_build_psf_ssc(struct dasd_device *device, 1496 int enable_pav) 1497 { 1498 struct dasd_ccw_req *cqr; 1499 struct dasd_psf_ssc_data *psf_ssc_data; 1500 struct ccw1 *ccw; 1501 1502 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ , 1503 sizeof(struct dasd_psf_ssc_data), 1504 device); 1505 1506 if (IS_ERR(cqr)) { 1507 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1508 "Could not allocate PSF-SSC request"); 1509 return cqr; 1510 } 1511 psf_ssc_data = (struct dasd_psf_ssc_data *)cqr->data; 1512 psf_ssc_data->order = PSF_ORDER_SSC; 1513 psf_ssc_data->suborder = 0xc0; 1514 if (enable_pav) { 1515 psf_ssc_data->suborder |= 0x08; 1516 psf_ssc_data->reserved[0] = 0x88; 1517 } 1518 ccw = cqr->cpaddr; 1519 ccw->cmd_code = DASD_ECKD_CCW_PSF; 1520 ccw->cda = (__u32)(addr_t)psf_ssc_data; 1521 ccw->count = 66; 1522 1523 cqr->startdev = device; 1524 cqr->memdev = device; 1525 cqr->block = NULL; 1526 cqr->retries = 256; 1527 cqr->expires = 10*HZ; 1528 cqr->buildclk = get_tod_clock(); 1529 cqr->status = DASD_CQR_FILLED; 1530 return cqr; 1531 } 1532 1533 /* 1534 * Perform Subsystem Function. 1535 * It is necessary to trigger CIO for channel revalidation since this 1536 * call might change behaviour of DASD devices. 1537 */ 1538 static int 1539 dasd_eckd_psf_ssc(struct dasd_device *device, int enable_pav, 1540 unsigned long flags) 1541 { 1542 struct dasd_ccw_req *cqr; 1543 int rc; 1544 1545 cqr = dasd_eckd_build_psf_ssc(device, enable_pav); 1546 if (IS_ERR(cqr)) 1547 return PTR_ERR(cqr); 1548 1549 /* 1550 * set flags e.g. turn on failfast, to prevent blocking 1551 * the calling function should handle failed requests 1552 */ 1553 cqr->flags |= flags; 1554 1555 rc = dasd_sleep_on(cqr); 1556 if (!rc) 1557 /* trigger CIO to reprobe devices */ 1558 css_schedule_reprobe(); 1559 else if (cqr->intrc == -EAGAIN) 1560 rc = -EAGAIN; 1561 1562 dasd_sfree_request(cqr, cqr->memdev); 1563 return rc; 1564 } 1565 1566 /* 1567 * Valide storage server of current device. 1568 */ 1569 static int dasd_eckd_validate_server(struct dasd_device *device, 1570 unsigned long flags) 1571 { 1572 struct dasd_eckd_private *private = device->private; 1573 int enable_pav, rc; 1574 1575 if (private->uid.type == UA_BASE_PAV_ALIAS || 1576 private->uid.type == UA_HYPER_PAV_ALIAS) 1577 return 0; 1578 if (dasd_nopav || MACHINE_IS_VM) 1579 enable_pav = 0; 1580 else 1581 enable_pav = 1; 1582 rc = dasd_eckd_psf_ssc(device, enable_pav, flags); 1583 1584 /* may be requested feature is not available on server, 1585 * therefore just report error and go ahead */ 1586 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "PSF-SSC for SSID %04x " 1587 "returned rc=%d", private->uid.ssid, rc); 1588 return rc; 1589 } 1590 1591 /* 1592 * worker to do a validate server in case of a lost pathgroup 1593 */ 1594 static void dasd_eckd_do_validate_server(struct work_struct *work) 1595 { 1596 struct dasd_device *device = container_of(work, struct dasd_device, 1597 kick_validate); 1598 unsigned long flags = 0; 1599 1600 set_bit(DASD_CQR_FLAGS_FAILFAST, &flags); 1601 if (dasd_eckd_validate_server(device, flags) 1602 == -EAGAIN) { 1603 /* schedule worker again if failed */ 1604 schedule_work(&device->kick_validate); 1605 return; 1606 } 1607 1608 dasd_put_device(device); 1609 } 1610 1611 static void dasd_eckd_kick_validate_server(struct dasd_device *device) 1612 { 1613 dasd_get_device(device); 1614 /* exit if device not online or in offline processing */ 1615 if (test_bit(DASD_FLAG_OFFLINE, &device->flags) || 1616 device->state < DASD_STATE_ONLINE) { 1617 dasd_put_device(device); 1618 return; 1619 } 1620 /* queue call to do_validate_server to the kernel event daemon. */ 1621 if (!schedule_work(&device->kick_validate)) 1622 dasd_put_device(device); 1623 } 1624 1625 /* 1626 * Check device characteristics. 1627 * If the device is accessible using ECKD discipline, the device is enabled. 1628 */ 1629 static int 1630 dasd_eckd_check_characteristics(struct dasd_device *device) 1631 { 1632 struct dasd_eckd_private *private = device->private; 1633 struct dasd_block *block; 1634 struct dasd_uid temp_uid; 1635 int rc, i; 1636 int readonly; 1637 unsigned long value; 1638 1639 /* setup work queue for validate server*/ 1640 INIT_WORK(&device->kick_validate, dasd_eckd_do_validate_server); 1641 /* setup work queue for summary unit check */ 1642 INIT_WORK(&device->suc_work, dasd_alias_handle_summary_unit_check); 1643 1644 if (!ccw_device_is_pathgroup(device->cdev)) { 1645 dev_warn(&device->cdev->dev, 1646 "A channel path group could not be established\n"); 1647 return -EIO; 1648 } 1649 if (!ccw_device_is_multipath(device->cdev)) { 1650 dev_info(&device->cdev->dev, 1651 "The DASD is not operating in multipath mode\n"); 1652 } 1653 if (!private) { 1654 private = kzalloc(sizeof(*private), GFP_KERNEL | GFP_DMA); 1655 if (!private) { 1656 dev_warn(&device->cdev->dev, 1657 "Allocating memory for private DASD data " 1658 "failed\n"); 1659 return -ENOMEM; 1660 } 1661 device->private = private; 1662 } else { 1663 memset(private, 0, sizeof(*private)); 1664 } 1665 /* Invalidate status of initial analysis. */ 1666 private->init_cqr_status = -1; 1667 /* Set default cache operations. */ 1668 private->attrib.operation = DASD_NORMAL_CACHE; 1669 private->attrib.nr_cyl = 0; 1670 1671 /* Read Configuration Data */ 1672 rc = dasd_eckd_read_conf(device); 1673 if (rc) 1674 goto out_err1; 1675 1676 /* set some default values */ 1677 device->default_expires = DASD_EXPIRES; 1678 device->default_retries = DASD_RETRIES; 1679 device->path_thrhld = DASD_ECKD_PATH_THRHLD; 1680 device->path_interval = DASD_ECKD_PATH_INTERVAL; 1681 1682 if (private->gneq) { 1683 value = 1; 1684 for (i = 0; i < private->gneq->timeout.value; i++) 1685 value = 10 * value; 1686 value = value * private->gneq->timeout.number; 1687 /* do not accept useless values */ 1688 if (value != 0 && value <= DASD_EXPIRES_MAX) 1689 device->default_expires = value; 1690 } 1691 1692 dasd_eckd_get_uid(device, &temp_uid); 1693 if (temp_uid.type == UA_BASE_DEVICE) { 1694 block = dasd_alloc_block(); 1695 if (IS_ERR(block)) { 1696 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 1697 "could not allocate dasd " 1698 "block structure"); 1699 rc = PTR_ERR(block); 1700 goto out_err1; 1701 } 1702 device->block = block; 1703 block->base = device; 1704 } 1705 1706 /* register lcu with alias handling, enable PAV */ 1707 rc = dasd_alias_make_device_known_to_lcu(device); 1708 if (rc) 1709 goto out_err2; 1710 1711 dasd_eckd_validate_server(device, 0); 1712 1713 /* device may report different configuration data after LCU setup */ 1714 rc = dasd_eckd_read_conf(device); 1715 if (rc) 1716 goto out_err3; 1717 1718 /* Read Feature Codes */ 1719 dasd_eckd_read_features(device); 1720 1721 /* Read Device Characteristics */ 1722 rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC, 1723 &private->rdc_data, 64); 1724 if (rc) { 1725 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 1726 "Read device characteristic failed, rc=%d", rc); 1727 goto out_err3; 1728 } 1729 1730 if ((device->features & DASD_FEATURE_USERAW) && 1731 !(private->rdc_data.facilities.RT_in_LR)) { 1732 dev_err(&device->cdev->dev, "The storage server does not " 1733 "support raw-track access\n"); 1734 rc = -EINVAL; 1735 goto out_err3; 1736 } 1737 1738 /* find the valid cylinder size */ 1739 if (private->rdc_data.no_cyl == LV_COMPAT_CYL && 1740 private->rdc_data.long_no_cyl) 1741 private->real_cyl = private->rdc_data.long_no_cyl; 1742 else 1743 private->real_cyl = private->rdc_data.no_cyl; 1744 1745 private->fcx_max_data = get_fcx_max_data(device); 1746 1747 readonly = dasd_device_is_ro(device); 1748 if (readonly) 1749 set_bit(DASD_FLAG_DEVICE_RO, &device->flags); 1750 1751 dev_info(&device->cdev->dev, "New DASD %04X/%02X (CU %04X/%02X) " 1752 "with %d cylinders, %d heads, %d sectors%s\n", 1753 private->rdc_data.dev_type, 1754 private->rdc_data.dev_model, 1755 private->rdc_data.cu_type, 1756 private->rdc_data.cu_model.model, 1757 private->real_cyl, 1758 private->rdc_data.trk_per_cyl, 1759 private->rdc_data.sec_per_trk, 1760 readonly ? ", read-only device" : ""); 1761 return 0; 1762 1763 out_err3: 1764 dasd_alias_disconnect_device_from_lcu(device); 1765 out_err2: 1766 dasd_free_block(device->block); 1767 device->block = NULL; 1768 out_err1: 1769 kfree(private->conf_data); 1770 kfree(device->private); 1771 device->private = NULL; 1772 return rc; 1773 } 1774 1775 static void dasd_eckd_uncheck_device(struct dasd_device *device) 1776 { 1777 struct dasd_eckd_private *private = device->private; 1778 int i; 1779 1780 dasd_alias_disconnect_device_from_lcu(device); 1781 private->ned = NULL; 1782 private->sneq = NULL; 1783 private->vdsneq = NULL; 1784 private->gneq = NULL; 1785 private->conf_len = 0; 1786 for (i = 0; i < 8; i++) { 1787 kfree(device->path[i].conf_data); 1788 if ((__u8 *)device->path[i].conf_data == 1789 private->conf_data) { 1790 private->conf_data = NULL; 1791 private->conf_len = 0; 1792 } 1793 device->path[i].conf_data = NULL; 1794 device->path[i].cssid = 0; 1795 device->path[i].ssid = 0; 1796 device->path[i].chpid = 0; 1797 } 1798 kfree(private->conf_data); 1799 private->conf_data = NULL; 1800 } 1801 1802 static struct dasd_ccw_req * 1803 dasd_eckd_analysis_ccw(struct dasd_device *device) 1804 { 1805 struct dasd_eckd_private *private = device->private; 1806 struct eckd_count *count_data; 1807 struct LO_eckd_data *LO_data; 1808 struct dasd_ccw_req *cqr; 1809 struct ccw1 *ccw; 1810 int cplength, datasize; 1811 int i; 1812 1813 cplength = 8; 1814 datasize = sizeof(struct DE_eckd_data) + 2*sizeof(struct LO_eckd_data); 1815 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, device); 1816 if (IS_ERR(cqr)) 1817 return cqr; 1818 ccw = cqr->cpaddr; 1819 /* Define extent for the first 3 tracks. */ 1820 define_extent(ccw++, cqr->data, 0, 2, 1821 DASD_ECKD_CCW_READ_COUNT, device, 0); 1822 LO_data = cqr->data + sizeof(struct DE_eckd_data); 1823 /* Locate record for the first 4 records on track 0. */ 1824 ccw[-1].flags |= CCW_FLAG_CC; 1825 locate_record(ccw++, LO_data++, 0, 0, 4, 1826 DASD_ECKD_CCW_READ_COUNT, device, 0); 1827 1828 count_data = private->count_area; 1829 for (i = 0; i < 4; i++) { 1830 ccw[-1].flags |= CCW_FLAG_CC; 1831 ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT; 1832 ccw->flags = 0; 1833 ccw->count = 8; 1834 ccw->cda = (__u32)(addr_t) count_data; 1835 ccw++; 1836 count_data++; 1837 } 1838 1839 /* Locate record for the first record on track 2. */ 1840 ccw[-1].flags |= CCW_FLAG_CC; 1841 locate_record(ccw++, LO_data++, 2, 0, 1, 1842 DASD_ECKD_CCW_READ_COUNT, device, 0); 1843 /* Read count ccw. */ 1844 ccw[-1].flags |= CCW_FLAG_CC; 1845 ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT; 1846 ccw->flags = 0; 1847 ccw->count = 8; 1848 ccw->cda = (__u32)(addr_t) count_data; 1849 1850 cqr->block = NULL; 1851 cqr->startdev = device; 1852 cqr->memdev = device; 1853 cqr->retries = 255; 1854 cqr->buildclk = get_tod_clock(); 1855 cqr->status = DASD_CQR_FILLED; 1856 return cqr; 1857 } 1858 1859 /* differentiate between 'no record found' and any other error */ 1860 static int dasd_eckd_analysis_evaluation(struct dasd_ccw_req *init_cqr) 1861 { 1862 char *sense; 1863 if (init_cqr->status == DASD_CQR_DONE) 1864 return INIT_CQR_OK; 1865 else if (init_cqr->status == DASD_CQR_NEED_ERP || 1866 init_cqr->status == DASD_CQR_FAILED) { 1867 sense = dasd_get_sense(&init_cqr->irb); 1868 if (sense && (sense[1] & SNS1_NO_REC_FOUND)) 1869 return INIT_CQR_UNFORMATTED; 1870 else 1871 return INIT_CQR_ERROR; 1872 } else 1873 return INIT_CQR_ERROR; 1874 } 1875 1876 /* 1877 * This is the callback function for the init_analysis cqr. It saves 1878 * the status of the initial analysis ccw before it frees it and kicks 1879 * the device to continue the startup sequence. This will call 1880 * dasd_eckd_do_analysis again (if the devices has not been marked 1881 * for deletion in the meantime). 1882 */ 1883 static void dasd_eckd_analysis_callback(struct dasd_ccw_req *init_cqr, 1884 void *data) 1885 { 1886 struct dasd_device *device = init_cqr->startdev; 1887 struct dasd_eckd_private *private = device->private; 1888 1889 private->init_cqr_status = dasd_eckd_analysis_evaluation(init_cqr); 1890 dasd_sfree_request(init_cqr, device); 1891 dasd_kick_device(device); 1892 } 1893 1894 static int dasd_eckd_start_analysis(struct dasd_block *block) 1895 { 1896 struct dasd_ccw_req *init_cqr; 1897 1898 init_cqr = dasd_eckd_analysis_ccw(block->base); 1899 if (IS_ERR(init_cqr)) 1900 return PTR_ERR(init_cqr); 1901 init_cqr->callback = dasd_eckd_analysis_callback; 1902 init_cqr->callback_data = NULL; 1903 init_cqr->expires = 5*HZ; 1904 /* first try without ERP, so we can later handle unformatted 1905 * devices as special case 1906 */ 1907 clear_bit(DASD_CQR_FLAGS_USE_ERP, &init_cqr->flags); 1908 init_cqr->retries = 0; 1909 dasd_add_request_head(init_cqr); 1910 return -EAGAIN; 1911 } 1912 1913 static int dasd_eckd_end_analysis(struct dasd_block *block) 1914 { 1915 struct dasd_device *device = block->base; 1916 struct dasd_eckd_private *private = device->private; 1917 struct eckd_count *count_area; 1918 unsigned int sb, blk_per_trk; 1919 int status, i; 1920 struct dasd_ccw_req *init_cqr; 1921 1922 status = private->init_cqr_status; 1923 private->init_cqr_status = -1; 1924 if (status == INIT_CQR_ERROR) { 1925 /* try again, this time with full ERP */ 1926 init_cqr = dasd_eckd_analysis_ccw(device); 1927 dasd_sleep_on(init_cqr); 1928 status = dasd_eckd_analysis_evaluation(init_cqr); 1929 dasd_sfree_request(init_cqr, device); 1930 } 1931 1932 if (device->features & DASD_FEATURE_USERAW) { 1933 block->bp_block = DASD_RAW_BLOCKSIZE; 1934 blk_per_trk = DASD_RAW_BLOCK_PER_TRACK; 1935 block->s2b_shift = 3; 1936 goto raw; 1937 } 1938 1939 if (status == INIT_CQR_UNFORMATTED) { 1940 dev_warn(&device->cdev->dev, "The DASD is not formatted\n"); 1941 return -EMEDIUMTYPE; 1942 } else if (status == INIT_CQR_ERROR) { 1943 dev_err(&device->cdev->dev, 1944 "Detecting the DASD disk layout failed because " 1945 "of an I/O error\n"); 1946 return -EIO; 1947 } 1948 1949 private->uses_cdl = 1; 1950 /* Check Track 0 for Compatible Disk Layout */ 1951 count_area = NULL; 1952 for (i = 0; i < 3; i++) { 1953 if (private->count_area[i].kl != 4 || 1954 private->count_area[i].dl != dasd_eckd_cdl_reclen(i) - 4 || 1955 private->count_area[i].cyl != 0 || 1956 private->count_area[i].head != count_area_head[i] || 1957 private->count_area[i].record != count_area_rec[i]) { 1958 private->uses_cdl = 0; 1959 break; 1960 } 1961 } 1962 if (i == 3) 1963 count_area = &private->count_area[4]; 1964 1965 if (private->uses_cdl == 0) { 1966 for (i = 0; i < 5; i++) { 1967 if ((private->count_area[i].kl != 0) || 1968 (private->count_area[i].dl != 1969 private->count_area[0].dl) || 1970 private->count_area[i].cyl != 0 || 1971 private->count_area[i].head != count_area_head[i] || 1972 private->count_area[i].record != count_area_rec[i]) 1973 break; 1974 } 1975 if (i == 5) 1976 count_area = &private->count_area[0]; 1977 } else { 1978 if (private->count_area[3].record == 1) 1979 dev_warn(&device->cdev->dev, 1980 "Track 0 has no records following the VTOC\n"); 1981 } 1982 1983 if (count_area != NULL && count_area->kl == 0) { 1984 /* we found notthing violating our disk layout */ 1985 if (dasd_check_blocksize(count_area->dl) == 0) 1986 block->bp_block = count_area->dl; 1987 } 1988 if (block->bp_block == 0) { 1989 dev_warn(&device->cdev->dev, 1990 "The disk layout of the DASD is not supported\n"); 1991 return -EMEDIUMTYPE; 1992 } 1993 block->s2b_shift = 0; /* bits to shift 512 to get a block */ 1994 for (sb = 512; sb < block->bp_block; sb = sb << 1) 1995 block->s2b_shift++; 1996 1997 blk_per_trk = recs_per_track(&private->rdc_data, 0, block->bp_block); 1998 1999 raw: 2000 block->blocks = (private->real_cyl * 2001 private->rdc_data.trk_per_cyl * 2002 blk_per_trk); 2003 2004 dev_info(&device->cdev->dev, 2005 "DASD with %d KB/block, %d KB total size, %d KB/track, " 2006 "%s\n", (block->bp_block >> 10), 2007 ((private->real_cyl * 2008 private->rdc_data.trk_per_cyl * 2009 blk_per_trk * (block->bp_block >> 9)) >> 1), 2010 ((blk_per_trk * block->bp_block) >> 10), 2011 private->uses_cdl ? 2012 "compatible disk layout" : "linux disk layout"); 2013 2014 return 0; 2015 } 2016 2017 static int dasd_eckd_do_analysis(struct dasd_block *block) 2018 { 2019 struct dasd_eckd_private *private = block->base->private; 2020 2021 if (private->init_cqr_status < 0) 2022 return dasd_eckd_start_analysis(block); 2023 else 2024 return dasd_eckd_end_analysis(block); 2025 } 2026 2027 static int dasd_eckd_basic_to_ready(struct dasd_device *device) 2028 { 2029 return dasd_alias_add_device(device); 2030 }; 2031 2032 static int dasd_eckd_online_to_ready(struct dasd_device *device) 2033 { 2034 cancel_work_sync(&device->reload_device); 2035 cancel_work_sync(&device->kick_validate); 2036 return 0; 2037 }; 2038 2039 static int dasd_eckd_basic_to_known(struct dasd_device *device) 2040 { 2041 return dasd_alias_remove_device(device); 2042 }; 2043 2044 static int 2045 dasd_eckd_fill_geometry(struct dasd_block *block, struct hd_geometry *geo) 2046 { 2047 struct dasd_eckd_private *private = block->base->private; 2048 2049 if (dasd_check_blocksize(block->bp_block) == 0) { 2050 geo->sectors = recs_per_track(&private->rdc_data, 2051 0, block->bp_block); 2052 } 2053 geo->cylinders = private->rdc_data.no_cyl; 2054 geo->heads = private->rdc_data.trk_per_cyl; 2055 return 0; 2056 } 2057 2058 /* 2059 * Build the TCW request for the format check 2060 */ 2061 static struct dasd_ccw_req * 2062 dasd_eckd_build_check_tcw(struct dasd_device *base, struct format_data_t *fdata, 2063 int enable_pav, struct eckd_count *fmt_buffer, 2064 int rpt) 2065 { 2066 struct dasd_eckd_private *start_priv; 2067 struct dasd_device *startdev = NULL; 2068 struct tidaw *last_tidaw = NULL; 2069 struct dasd_ccw_req *cqr; 2070 struct itcw *itcw; 2071 int itcw_size; 2072 int count; 2073 int rc; 2074 int i; 2075 2076 if (enable_pav) 2077 startdev = dasd_alias_get_start_dev(base); 2078 2079 if (!startdev) 2080 startdev = base; 2081 2082 start_priv = startdev->private; 2083 2084 count = rpt * (fdata->stop_unit - fdata->start_unit + 1); 2085 2086 /* 2087 * we're adding 'count' amount of tidaw to the itcw. 2088 * calculate the corresponding itcw_size 2089 */ 2090 itcw_size = itcw_calc_size(0, count, 0); 2091 2092 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 0, itcw_size, startdev); 2093 if (IS_ERR(cqr)) 2094 return cqr; 2095 2096 start_priv->count++; 2097 2098 itcw = itcw_init(cqr->data, itcw_size, ITCW_OP_READ, 0, count, 0); 2099 if (IS_ERR(itcw)) { 2100 rc = -EINVAL; 2101 goto out_err; 2102 } 2103 2104 cqr->cpaddr = itcw_get_tcw(itcw); 2105 rc = prepare_itcw(itcw, fdata->start_unit, fdata->stop_unit, 2106 DASD_ECKD_CCW_READ_COUNT_MT, base, startdev, 0, count, 2107 sizeof(struct eckd_count), 2108 count * sizeof(struct eckd_count), 0, rpt); 2109 if (rc) 2110 goto out_err; 2111 2112 for (i = 0; i < count; i++) { 2113 last_tidaw = itcw_add_tidaw(itcw, 0, fmt_buffer++, 2114 sizeof(struct eckd_count)); 2115 if (IS_ERR(last_tidaw)) { 2116 rc = -EINVAL; 2117 goto out_err; 2118 } 2119 } 2120 2121 last_tidaw->flags |= TIDAW_FLAGS_LAST; 2122 itcw_finalize(itcw); 2123 2124 cqr->cpmode = 1; 2125 cqr->startdev = startdev; 2126 cqr->memdev = startdev; 2127 cqr->basedev = base; 2128 cqr->retries = startdev->default_retries; 2129 cqr->expires = startdev->default_expires * HZ; 2130 cqr->buildclk = get_tod_clock(); 2131 cqr->status = DASD_CQR_FILLED; 2132 /* Set flags to suppress output for expected errors */ 2133 set_bit(DASD_CQR_SUPPRESS_FP, &cqr->flags); 2134 set_bit(DASD_CQR_SUPPRESS_IL, &cqr->flags); 2135 2136 return cqr; 2137 2138 out_err: 2139 dasd_sfree_request(cqr, startdev); 2140 2141 return ERR_PTR(rc); 2142 } 2143 2144 /* 2145 * Build the CCW request for the format check 2146 */ 2147 static struct dasd_ccw_req * 2148 dasd_eckd_build_check(struct dasd_device *base, struct format_data_t *fdata, 2149 int enable_pav, struct eckd_count *fmt_buffer, int rpt) 2150 { 2151 struct dasd_eckd_private *start_priv; 2152 struct dasd_eckd_private *base_priv; 2153 struct dasd_device *startdev = NULL; 2154 struct dasd_ccw_req *cqr; 2155 struct ccw1 *ccw; 2156 void *data; 2157 int cplength, datasize; 2158 int use_prefix; 2159 int count; 2160 int i; 2161 2162 if (enable_pav) 2163 startdev = dasd_alias_get_start_dev(base); 2164 2165 if (!startdev) 2166 startdev = base; 2167 2168 start_priv = startdev->private; 2169 base_priv = base->private; 2170 2171 count = rpt * (fdata->stop_unit - fdata->start_unit + 1); 2172 2173 use_prefix = base_priv->features.feature[8] & 0x01; 2174 2175 if (use_prefix) { 2176 cplength = 1; 2177 datasize = sizeof(struct PFX_eckd_data); 2178 } else { 2179 cplength = 2; 2180 datasize = sizeof(struct DE_eckd_data) + 2181 sizeof(struct LO_eckd_data); 2182 } 2183 cplength += count; 2184 2185 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, 2186 startdev); 2187 if (IS_ERR(cqr)) 2188 return cqr; 2189 2190 start_priv->count++; 2191 data = cqr->data; 2192 ccw = cqr->cpaddr; 2193 2194 if (use_prefix) { 2195 prefix_LRE(ccw++, data, fdata->start_unit, fdata->stop_unit, 2196 DASD_ECKD_CCW_READ_COUNT, base, startdev, 1, 0, 2197 count, 0, 0); 2198 } else { 2199 define_extent(ccw++, data, fdata->start_unit, fdata->stop_unit, 2200 DASD_ECKD_CCW_READ_COUNT, startdev, 0); 2201 2202 data += sizeof(struct DE_eckd_data); 2203 ccw[-1].flags |= CCW_FLAG_CC; 2204 2205 locate_record(ccw++, data, fdata->start_unit, 0, count, 2206 DASD_ECKD_CCW_READ_COUNT, base, 0); 2207 } 2208 2209 for (i = 0; i < count; i++) { 2210 ccw[-1].flags |= CCW_FLAG_CC; 2211 ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT; 2212 ccw->flags = CCW_FLAG_SLI; 2213 ccw->count = 8; 2214 ccw->cda = (__u32)(addr_t) fmt_buffer; 2215 ccw++; 2216 fmt_buffer++; 2217 } 2218 2219 cqr->startdev = startdev; 2220 cqr->memdev = startdev; 2221 cqr->basedev = base; 2222 cqr->retries = DASD_RETRIES; 2223 cqr->expires = startdev->default_expires * HZ; 2224 cqr->buildclk = get_tod_clock(); 2225 cqr->status = DASD_CQR_FILLED; 2226 /* Set flags to suppress output for expected errors */ 2227 set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags); 2228 2229 return cqr; 2230 } 2231 2232 static struct dasd_ccw_req * 2233 dasd_eckd_build_format(struct dasd_device *base, 2234 struct format_data_t *fdata, 2235 int enable_pav) 2236 { 2237 struct dasd_eckd_private *base_priv; 2238 struct dasd_eckd_private *start_priv; 2239 struct dasd_device *startdev = NULL; 2240 struct dasd_ccw_req *fcp; 2241 struct eckd_count *ect; 2242 struct ch_t address; 2243 struct ccw1 *ccw; 2244 void *data; 2245 int rpt; 2246 int cplength, datasize; 2247 int i, j; 2248 int intensity = 0; 2249 int r0_perm; 2250 int nr_tracks; 2251 int use_prefix; 2252 2253 if (enable_pav) 2254 startdev = dasd_alias_get_start_dev(base); 2255 2256 if (!startdev) 2257 startdev = base; 2258 2259 start_priv = startdev->private; 2260 base_priv = base->private; 2261 2262 rpt = recs_per_track(&base_priv->rdc_data, 0, fdata->blksize); 2263 2264 nr_tracks = fdata->stop_unit - fdata->start_unit + 1; 2265 2266 /* 2267 * fdata->intensity is a bit string that tells us what to do: 2268 * Bit 0: write record zero 2269 * Bit 1: write home address, currently not supported 2270 * Bit 2: invalidate tracks 2271 * Bit 3: use OS/390 compatible disk layout (cdl) 2272 * Bit 4: do not allow storage subsystem to modify record zero 2273 * Only some bit combinations do make sense. 2274 */ 2275 if (fdata->intensity & 0x10) { 2276 r0_perm = 0; 2277 intensity = fdata->intensity & ~0x10; 2278 } else { 2279 r0_perm = 1; 2280 intensity = fdata->intensity; 2281 } 2282 2283 use_prefix = base_priv->features.feature[8] & 0x01; 2284 2285 switch (intensity) { 2286 case 0x00: /* Normal format */ 2287 case 0x08: /* Normal format, use cdl. */ 2288 cplength = 2 + (rpt*nr_tracks); 2289 if (use_prefix) 2290 datasize = sizeof(struct PFX_eckd_data) + 2291 sizeof(struct LO_eckd_data) + 2292 rpt * nr_tracks * sizeof(struct eckd_count); 2293 else 2294 datasize = sizeof(struct DE_eckd_data) + 2295 sizeof(struct LO_eckd_data) + 2296 rpt * nr_tracks * sizeof(struct eckd_count); 2297 break; 2298 case 0x01: /* Write record zero and format track. */ 2299 case 0x09: /* Write record zero and format track, use cdl. */ 2300 cplength = 2 + rpt * nr_tracks; 2301 if (use_prefix) 2302 datasize = sizeof(struct PFX_eckd_data) + 2303 sizeof(struct LO_eckd_data) + 2304 sizeof(struct eckd_count) + 2305 rpt * nr_tracks * sizeof(struct eckd_count); 2306 else 2307 datasize = sizeof(struct DE_eckd_data) + 2308 sizeof(struct LO_eckd_data) + 2309 sizeof(struct eckd_count) + 2310 rpt * nr_tracks * sizeof(struct eckd_count); 2311 break; 2312 case 0x04: /* Invalidate track. */ 2313 case 0x0c: /* Invalidate track, use cdl. */ 2314 cplength = 3; 2315 if (use_prefix) 2316 datasize = sizeof(struct PFX_eckd_data) + 2317 sizeof(struct LO_eckd_data) + 2318 sizeof(struct eckd_count); 2319 else 2320 datasize = sizeof(struct DE_eckd_data) + 2321 sizeof(struct LO_eckd_data) + 2322 sizeof(struct eckd_count); 2323 break; 2324 default: 2325 dev_warn(&startdev->cdev->dev, 2326 "An I/O control call used incorrect flags 0x%x\n", 2327 fdata->intensity); 2328 return ERR_PTR(-EINVAL); 2329 } 2330 /* Allocate the format ccw request. */ 2331 fcp = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, 2332 datasize, startdev); 2333 if (IS_ERR(fcp)) 2334 return fcp; 2335 2336 start_priv->count++; 2337 data = fcp->data; 2338 ccw = fcp->cpaddr; 2339 2340 switch (intensity & ~0x08) { 2341 case 0x00: /* Normal format. */ 2342 if (use_prefix) { 2343 prefix(ccw++, (struct PFX_eckd_data *) data, 2344 fdata->start_unit, fdata->stop_unit, 2345 DASD_ECKD_CCW_WRITE_CKD, base, startdev); 2346 /* grant subsystem permission to format R0 */ 2347 if (r0_perm) 2348 ((struct PFX_eckd_data *)data) 2349 ->define_extent.ga_extended |= 0x04; 2350 data += sizeof(struct PFX_eckd_data); 2351 } else { 2352 define_extent(ccw++, (struct DE_eckd_data *) data, 2353 fdata->start_unit, fdata->stop_unit, 2354 DASD_ECKD_CCW_WRITE_CKD, startdev, 0); 2355 /* grant subsystem permission to format R0 */ 2356 if (r0_perm) 2357 ((struct DE_eckd_data *) data) 2358 ->ga_extended |= 0x04; 2359 data += sizeof(struct DE_eckd_data); 2360 } 2361 ccw[-1].flags |= CCW_FLAG_CC; 2362 locate_record(ccw++, (struct LO_eckd_data *) data, 2363 fdata->start_unit, 0, rpt*nr_tracks, 2364 DASD_ECKD_CCW_WRITE_CKD, base, 2365 fdata->blksize); 2366 data += sizeof(struct LO_eckd_data); 2367 break; 2368 case 0x01: /* Write record zero + format track. */ 2369 if (use_prefix) { 2370 prefix(ccw++, (struct PFX_eckd_data *) data, 2371 fdata->start_unit, fdata->stop_unit, 2372 DASD_ECKD_CCW_WRITE_RECORD_ZERO, 2373 base, startdev); 2374 data += sizeof(struct PFX_eckd_data); 2375 } else { 2376 define_extent(ccw++, (struct DE_eckd_data *) data, 2377 fdata->start_unit, fdata->stop_unit, 2378 DASD_ECKD_CCW_WRITE_RECORD_ZERO, startdev, 0); 2379 data += sizeof(struct DE_eckd_data); 2380 } 2381 ccw[-1].flags |= CCW_FLAG_CC; 2382 locate_record(ccw++, (struct LO_eckd_data *) data, 2383 fdata->start_unit, 0, rpt * nr_tracks + 1, 2384 DASD_ECKD_CCW_WRITE_RECORD_ZERO, base, 2385 base->block->bp_block); 2386 data += sizeof(struct LO_eckd_data); 2387 break; 2388 case 0x04: /* Invalidate track. */ 2389 if (use_prefix) { 2390 prefix(ccw++, (struct PFX_eckd_data *) data, 2391 fdata->start_unit, fdata->stop_unit, 2392 DASD_ECKD_CCW_WRITE_CKD, base, startdev); 2393 data += sizeof(struct PFX_eckd_data); 2394 } else { 2395 define_extent(ccw++, (struct DE_eckd_data *) data, 2396 fdata->start_unit, fdata->stop_unit, 2397 DASD_ECKD_CCW_WRITE_CKD, startdev, 0); 2398 data += sizeof(struct DE_eckd_data); 2399 } 2400 ccw[-1].flags |= CCW_FLAG_CC; 2401 locate_record(ccw++, (struct LO_eckd_data *) data, 2402 fdata->start_unit, 0, 1, 2403 DASD_ECKD_CCW_WRITE_CKD, base, 8); 2404 data += sizeof(struct LO_eckd_data); 2405 break; 2406 } 2407 2408 for (j = 0; j < nr_tracks; j++) { 2409 /* calculate cylinder and head for the current track */ 2410 set_ch_t(&address, 2411 (fdata->start_unit + j) / 2412 base_priv->rdc_data.trk_per_cyl, 2413 (fdata->start_unit + j) % 2414 base_priv->rdc_data.trk_per_cyl); 2415 if (intensity & 0x01) { /* write record zero */ 2416 ect = (struct eckd_count *) data; 2417 data += sizeof(struct eckd_count); 2418 ect->cyl = address.cyl; 2419 ect->head = address.head; 2420 ect->record = 0; 2421 ect->kl = 0; 2422 ect->dl = 8; 2423 ccw[-1].flags |= CCW_FLAG_CC; 2424 ccw->cmd_code = DASD_ECKD_CCW_WRITE_RECORD_ZERO; 2425 ccw->flags = CCW_FLAG_SLI; 2426 ccw->count = 8; 2427 ccw->cda = (__u32)(addr_t) ect; 2428 ccw++; 2429 } 2430 if ((intensity & ~0x08) & 0x04) { /* erase track */ 2431 ect = (struct eckd_count *) data; 2432 data += sizeof(struct eckd_count); 2433 ect->cyl = address.cyl; 2434 ect->head = address.head; 2435 ect->record = 1; 2436 ect->kl = 0; 2437 ect->dl = 0; 2438 ccw[-1].flags |= CCW_FLAG_CC; 2439 ccw->cmd_code = DASD_ECKD_CCW_WRITE_CKD; 2440 ccw->flags = CCW_FLAG_SLI; 2441 ccw->count = 8; 2442 ccw->cda = (__u32)(addr_t) ect; 2443 } else { /* write remaining records */ 2444 for (i = 0; i < rpt; i++) { 2445 ect = (struct eckd_count *) data; 2446 data += sizeof(struct eckd_count); 2447 ect->cyl = address.cyl; 2448 ect->head = address.head; 2449 ect->record = i + 1; 2450 ect->kl = 0; 2451 ect->dl = fdata->blksize; 2452 /* 2453 * Check for special tracks 0-1 2454 * when formatting CDL 2455 */ 2456 if ((intensity & 0x08) && 2457 address.cyl == 0 && address.head == 0) { 2458 if (i < 3) { 2459 ect->kl = 4; 2460 ect->dl = sizes_trk0[i] - 4; 2461 } 2462 } 2463 if ((intensity & 0x08) && 2464 address.cyl == 0 && address.head == 1) { 2465 ect->kl = 44; 2466 ect->dl = LABEL_SIZE - 44; 2467 } 2468 ccw[-1].flags |= CCW_FLAG_CC; 2469 if (i != 0 || j == 0) 2470 ccw->cmd_code = 2471 DASD_ECKD_CCW_WRITE_CKD; 2472 else 2473 ccw->cmd_code = 2474 DASD_ECKD_CCW_WRITE_CKD_MT; 2475 ccw->flags = CCW_FLAG_SLI; 2476 ccw->count = 8; 2477 ccw->cda = (__u32)(addr_t) ect; 2478 ccw++; 2479 } 2480 } 2481 } 2482 2483 fcp->startdev = startdev; 2484 fcp->memdev = startdev; 2485 fcp->basedev = base; 2486 fcp->retries = 256; 2487 fcp->expires = startdev->default_expires * HZ; 2488 fcp->buildclk = get_tod_clock(); 2489 fcp->status = DASD_CQR_FILLED; 2490 2491 return fcp; 2492 } 2493 2494 /* 2495 * Wrapper function to build a CCW request depending on input data 2496 */ 2497 static struct dasd_ccw_req * 2498 dasd_eckd_format_build_ccw_req(struct dasd_device *base, 2499 struct format_data_t *fdata, int enable_pav, 2500 int tpm, struct eckd_count *fmt_buffer, int rpt) 2501 { 2502 struct dasd_ccw_req *ccw_req; 2503 2504 if (!fmt_buffer) { 2505 ccw_req = dasd_eckd_build_format(base, fdata, enable_pav); 2506 } else { 2507 if (tpm) 2508 ccw_req = dasd_eckd_build_check_tcw(base, fdata, 2509 enable_pav, 2510 fmt_buffer, rpt); 2511 else 2512 ccw_req = dasd_eckd_build_check(base, fdata, enable_pav, 2513 fmt_buffer, rpt); 2514 } 2515 2516 return ccw_req; 2517 } 2518 2519 /* 2520 * Sanity checks on format_data 2521 */ 2522 static int dasd_eckd_format_sanity_checks(struct dasd_device *base, 2523 struct format_data_t *fdata) 2524 { 2525 struct dasd_eckd_private *private = base->private; 2526 2527 if (fdata->start_unit >= 2528 (private->real_cyl * private->rdc_data.trk_per_cyl)) { 2529 dev_warn(&base->cdev->dev, 2530 "Start track number %u used in formatting is too big\n", 2531 fdata->start_unit); 2532 return -EINVAL; 2533 } 2534 if (fdata->stop_unit >= 2535 (private->real_cyl * private->rdc_data.trk_per_cyl)) { 2536 dev_warn(&base->cdev->dev, 2537 "Stop track number %u used in formatting is too big\n", 2538 fdata->stop_unit); 2539 return -EINVAL; 2540 } 2541 if (fdata->start_unit > fdata->stop_unit) { 2542 dev_warn(&base->cdev->dev, 2543 "Start track %u used in formatting exceeds end track\n", 2544 fdata->start_unit); 2545 return -EINVAL; 2546 } 2547 if (dasd_check_blocksize(fdata->blksize) != 0) { 2548 dev_warn(&base->cdev->dev, 2549 "The DASD cannot be formatted with block size %u\n", 2550 fdata->blksize); 2551 return -EINVAL; 2552 } 2553 return 0; 2554 } 2555 2556 /* 2557 * This function will process format_data originally coming from an IOCTL 2558 */ 2559 static int dasd_eckd_format_process_data(struct dasd_device *base, 2560 struct format_data_t *fdata, 2561 int enable_pav, int tpm, 2562 struct eckd_count *fmt_buffer, int rpt, 2563 struct irb *irb) 2564 { 2565 struct dasd_eckd_private *private = base->private; 2566 struct dasd_ccw_req *cqr, *n; 2567 struct list_head format_queue; 2568 struct dasd_device *device; 2569 char *sense = NULL; 2570 int old_start, old_stop, format_step; 2571 int step, retry; 2572 int rc; 2573 2574 rc = dasd_eckd_format_sanity_checks(base, fdata); 2575 if (rc) 2576 return rc; 2577 2578 INIT_LIST_HEAD(&format_queue); 2579 2580 old_start = fdata->start_unit; 2581 old_stop = fdata->stop_unit; 2582 2583 if (!tpm && fmt_buffer != NULL) { 2584 /* Command Mode / Format Check */ 2585 format_step = 1; 2586 } else if (tpm && fmt_buffer != NULL) { 2587 /* Transport Mode / Format Check */ 2588 format_step = DASD_CQR_MAX_CCW / rpt; 2589 } else { 2590 /* Normal Formatting */ 2591 format_step = DASD_CQR_MAX_CCW / 2592 recs_per_track(&private->rdc_data, 0, fdata->blksize); 2593 } 2594 2595 do { 2596 retry = 0; 2597 while (fdata->start_unit <= old_stop) { 2598 step = fdata->stop_unit - fdata->start_unit + 1; 2599 if (step > format_step) { 2600 fdata->stop_unit = 2601 fdata->start_unit + format_step - 1; 2602 } 2603 2604 cqr = dasd_eckd_format_build_ccw_req(base, fdata, 2605 enable_pav, tpm, 2606 fmt_buffer, rpt); 2607 if (IS_ERR(cqr)) { 2608 rc = PTR_ERR(cqr); 2609 if (rc == -ENOMEM) { 2610 if (list_empty(&format_queue)) 2611 goto out; 2612 /* 2613 * not enough memory available, start 2614 * requests retry after first requests 2615 * were finished 2616 */ 2617 retry = 1; 2618 break; 2619 } 2620 goto out_err; 2621 } 2622 list_add_tail(&cqr->blocklist, &format_queue); 2623 2624 if (fmt_buffer) { 2625 step = fdata->stop_unit - fdata->start_unit + 1; 2626 fmt_buffer += rpt * step; 2627 } 2628 fdata->start_unit = fdata->stop_unit + 1; 2629 fdata->stop_unit = old_stop; 2630 } 2631 2632 rc = dasd_sleep_on_queue(&format_queue); 2633 2634 out_err: 2635 list_for_each_entry_safe(cqr, n, &format_queue, blocklist) { 2636 device = cqr->startdev; 2637 private = device->private; 2638 2639 if (cqr->status == DASD_CQR_FAILED) { 2640 /* 2641 * Only get sense data if called by format 2642 * check 2643 */ 2644 if (fmt_buffer && irb) { 2645 sense = dasd_get_sense(&cqr->irb); 2646 memcpy(irb, &cqr->irb, sizeof(*irb)); 2647 } 2648 rc = -EIO; 2649 } 2650 list_del_init(&cqr->blocklist); 2651 dasd_sfree_request(cqr, device); 2652 private->count--; 2653 } 2654 2655 if (rc && rc != -EIO) 2656 goto out; 2657 if (rc == -EIO) { 2658 /* 2659 * In case fewer than the expected records are on the 2660 * track, we will most likely get a 'No Record Found' 2661 * error (in command mode) or a 'File Protected' error 2662 * (in transport mode). Those particular cases shouldn't 2663 * pass the -EIO to the IOCTL, therefore reset the rc 2664 * and continue. 2665 */ 2666 if (sense && 2667 (sense[1] & SNS1_NO_REC_FOUND || 2668 sense[1] & SNS1_FILE_PROTECTED)) 2669 retry = 1; 2670 else 2671 goto out; 2672 } 2673 2674 } while (retry); 2675 2676 out: 2677 fdata->start_unit = old_start; 2678 fdata->stop_unit = old_stop; 2679 2680 return rc; 2681 } 2682 2683 static int dasd_eckd_format_device(struct dasd_device *base, 2684 struct format_data_t *fdata, int enable_pav) 2685 { 2686 return dasd_eckd_format_process_data(base, fdata, enable_pav, 0, NULL, 2687 0, NULL); 2688 } 2689 2690 /* 2691 * Helper function to count consecutive records of a single track. 2692 */ 2693 static int dasd_eckd_count_records(struct eckd_count *fmt_buffer, int start, 2694 int max) 2695 { 2696 int head; 2697 int i; 2698 2699 head = fmt_buffer[start].head; 2700 2701 /* 2702 * There are 3 conditions where we stop counting: 2703 * - if data reoccurs (same head and record may reoccur), which may 2704 * happen due to the way DASD_ECKD_CCW_READ_COUNT works 2705 * - when the head changes, because we're iterating over several tracks 2706 * then (DASD_ECKD_CCW_READ_COUNT_MT) 2707 * - when we've reached the end of sensible data in the buffer (the 2708 * record will be 0 then) 2709 */ 2710 for (i = start; i < max; i++) { 2711 if (i > start) { 2712 if ((fmt_buffer[i].head == head && 2713 fmt_buffer[i].record == 1) || 2714 fmt_buffer[i].head != head || 2715 fmt_buffer[i].record == 0) 2716 break; 2717 } 2718 } 2719 2720 return i - start; 2721 } 2722 2723 /* 2724 * Evaluate a given range of tracks. Data like number of records, blocksize, 2725 * record ids, and key length are compared with expected data. 2726 * 2727 * If a mismatch occurs, the corresponding error bit is set, as well as 2728 * additional information, depending on the error. 2729 */ 2730 static void dasd_eckd_format_evaluate_tracks(struct eckd_count *fmt_buffer, 2731 struct format_check_t *cdata, 2732 int rpt_max, int rpt_exp, 2733 int trk_per_cyl, int tpm) 2734 { 2735 struct ch_t geo; 2736 int max_entries; 2737 int count = 0; 2738 int trkcount; 2739 int blksize; 2740 int pos = 0; 2741 int i, j; 2742 int kl; 2743 2744 trkcount = cdata->expect.stop_unit - cdata->expect.start_unit + 1; 2745 max_entries = trkcount * rpt_max; 2746 2747 for (i = cdata->expect.start_unit; i <= cdata->expect.stop_unit; i++) { 2748 /* Calculate the correct next starting position in the buffer */ 2749 if (tpm) { 2750 while (fmt_buffer[pos].record == 0 && 2751 fmt_buffer[pos].dl == 0) { 2752 if (pos++ > max_entries) 2753 break; 2754 } 2755 } else { 2756 if (i != cdata->expect.start_unit) 2757 pos += rpt_max - count; 2758 } 2759 2760 /* Calculate the expected geo values for the current track */ 2761 set_ch_t(&geo, i / trk_per_cyl, i % trk_per_cyl); 2762 2763 /* Count and check number of records */ 2764 count = dasd_eckd_count_records(fmt_buffer, pos, pos + rpt_max); 2765 2766 if (count < rpt_exp) { 2767 cdata->result = DASD_FMT_ERR_TOO_FEW_RECORDS; 2768 break; 2769 } 2770 if (count > rpt_exp) { 2771 cdata->result = DASD_FMT_ERR_TOO_MANY_RECORDS; 2772 break; 2773 } 2774 2775 for (j = 0; j < count; j++, pos++) { 2776 blksize = cdata->expect.blksize; 2777 kl = 0; 2778 2779 /* 2780 * Set special values when checking CDL formatted 2781 * devices. 2782 */ 2783 if ((cdata->expect.intensity & 0x08) && 2784 geo.cyl == 0 && geo.head == 0) { 2785 if (j < 3) { 2786 blksize = sizes_trk0[j] - 4; 2787 kl = 4; 2788 } 2789 } 2790 if ((cdata->expect.intensity & 0x08) && 2791 geo.cyl == 0 && geo.head == 1) { 2792 blksize = LABEL_SIZE - 44; 2793 kl = 44; 2794 } 2795 2796 /* Check blocksize */ 2797 if (fmt_buffer[pos].dl != blksize) { 2798 cdata->result = DASD_FMT_ERR_BLKSIZE; 2799 goto out; 2800 } 2801 /* Check if key length is 0 */ 2802 if (fmt_buffer[pos].kl != kl) { 2803 cdata->result = DASD_FMT_ERR_KEY_LENGTH; 2804 goto out; 2805 } 2806 /* Check if record_id is correct */ 2807 if (fmt_buffer[pos].cyl != geo.cyl || 2808 fmt_buffer[pos].head != geo.head || 2809 fmt_buffer[pos].record != (j + 1)) { 2810 cdata->result = DASD_FMT_ERR_RECORD_ID; 2811 goto out; 2812 } 2813 } 2814 } 2815 2816 out: 2817 /* 2818 * In case of no errors, we need to decrease by one 2819 * to get the correct positions. 2820 */ 2821 if (!cdata->result) { 2822 i--; 2823 pos--; 2824 } 2825 2826 cdata->unit = i; 2827 cdata->num_records = count; 2828 cdata->rec = fmt_buffer[pos].record; 2829 cdata->blksize = fmt_buffer[pos].dl; 2830 cdata->key_length = fmt_buffer[pos].kl; 2831 } 2832 2833 /* 2834 * Check the format of a range of tracks of a DASD. 2835 */ 2836 static int dasd_eckd_check_device_format(struct dasd_device *base, 2837 struct format_check_t *cdata, 2838 int enable_pav) 2839 { 2840 struct dasd_eckd_private *private = base->private; 2841 struct eckd_count *fmt_buffer; 2842 struct irb irb; 2843 int rpt_max, rpt_exp; 2844 int fmt_buffer_size; 2845 int trk_per_cyl; 2846 int trkcount; 2847 int tpm = 0; 2848 int rc; 2849 2850 trk_per_cyl = private->rdc_data.trk_per_cyl; 2851 2852 /* Get maximum and expected amount of records per track */ 2853 rpt_max = recs_per_track(&private->rdc_data, 0, 512) + 1; 2854 rpt_exp = recs_per_track(&private->rdc_data, 0, cdata->expect.blksize); 2855 2856 trkcount = cdata->expect.stop_unit - cdata->expect.start_unit + 1; 2857 fmt_buffer_size = trkcount * rpt_max * sizeof(struct eckd_count); 2858 2859 fmt_buffer = kzalloc(fmt_buffer_size, GFP_KERNEL | GFP_DMA); 2860 if (!fmt_buffer) 2861 return -ENOMEM; 2862 2863 /* 2864 * A certain FICON feature subset is needed to operate in transport 2865 * mode. Additionally, the support for transport mode is implicitly 2866 * checked by comparing the buffer size with fcx_max_data. As long as 2867 * the buffer size is smaller we can operate in transport mode and 2868 * process multiple tracks. If not, only one track at once is being 2869 * processed using command mode. 2870 */ 2871 if ((private->features.feature[40] & 0x04) && 2872 fmt_buffer_size <= private->fcx_max_data) 2873 tpm = 1; 2874 2875 rc = dasd_eckd_format_process_data(base, &cdata->expect, enable_pav, 2876 tpm, fmt_buffer, rpt_max, &irb); 2877 if (rc && rc != -EIO) 2878 goto out; 2879 if (rc == -EIO) { 2880 /* 2881 * If our first attempt with transport mode enabled comes back 2882 * with an incorrect length error, we're going to retry the 2883 * check with command mode. 2884 */ 2885 if (tpm && scsw_cstat(&irb.scsw) == 0x40) { 2886 tpm = 0; 2887 rc = dasd_eckd_format_process_data(base, &cdata->expect, 2888 enable_pav, tpm, 2889 fmt_buffer, rpt_max, 2890 &irb); 2891 if (rc) 2892 goto out; 2893 } else { 2894 goto out; 2895 } 2896 } 2897 2898 dasd_eckd_format_evaluate_tracks(fmt_buffer, cdata, rpt_max, rpt_exp, 2899 trk_per_cyl, tpm); 2900 2901 out: 2902 kfree(fmt_buffer); 2903 2904 return rc; 2905 } 2906 2907 static void dasd_eckd_handle_terminated_request(struct dasd_ccw_req *cqr) 2908 { 2909 if (cqr->retries < 0) { 2910 cqr->status = DASD_CQR_FAILED; 2911 return; 2912 } 2913 cqr->status = DASD_CQR_FILLED; 2914 if (cqr->block && (cqr->startdev != cqr->block->base)) { 2915 dasd_eckd_reset_ccw_to_base_io(cqr); 2916 cqr->startdev = cqr->block->base; 2917 cqr->lpm = dasd_path_get_opm(cqr->block->base); 2918 } 2919 }; 2920 2921 static dasd_erp_fn_t 2922 dasd_eckd_erp_action(struct dasd_ccw_req * cqr) 2923 { 2924 struct dasd_device *device = (struct dasd_device *) cqr->startdev; 2925 struct ccw_device *cdev = device->cdev; 2926 2927 switch (cdev->id.cu_type) { 2928 case 0x3990: 2929 case 0x2105: 2930 case 0x2107: 2931 case 0x1750: 2932 return dasd_3990_erp_action; 2933 case 0x9343: 2934 case 0x3880: 2935 default: 2936 return dasd_default_erp_action; 2937 } 2938 } 2939 2940 static dasd_erp_fn_t 2941 dasd_eckd_erp_postaction(struct dasd_ccw_req * cqr) 2942 { 2943 return dasd_default_erp_postaction; 2944 } 2945 2946 static void dasd_eckd_check_for_device_change(struct dasd_device *device, 2947 struct dasd_ccw_req *cqr, 2948 struct irb *irb) 2949 { 2950 char mask; 2951 char *sense = NULL; 2952 struct dasd_eckd_private *private = device->private; 2953 2954 /* first of all check for state change pending interrupt */ 2955 mask = DEV_STAT_ATTENTION | DEV_STAT_DEV_END | DEV_STAT_UNIT_EXCEP; 2956 if ((scsw_dstat(&irb->scsw) & mask) == mask) { 2957 /* 2958 * for alias only, not in offline processing 2959 * and only if not suspended 2960 */ 2961 if (!device->block && private->lcu && 2962 device->state == DASD_STATE_ONLINE && 2963 !test_bit(DASD_FLAG_OFFLINE, &device->flags) && 2964 !test_bit(DASD_FLAG_SUSPENDED, &device->flags)) { 2965 /* schedule worker to reload device */ 2966 dasd_reload_device(device); 2967 } 2968 dasd_generic_handle_state_change(device); 2969 return; 2970 } 2971 2972 sense = dasd_get_sense(irb); 2973 if (!sense) 2974 return; 2975 2976 /* summary unit check */ 2977 if ((sense[27] & DASD_SENSE_BIT_0) && (sense[7] == 0x0D) && 2978 (scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK)) { 2979 if (test_and_set_bit(DASD_FLAG_SUC, &device->flags)) { 2980 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 2981 "eckd suc: device already notified"); 2982 return; 2983 } 2984 sense = dasd_get_sense(irb); 2985 if (!sense) { 2986 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 2987 "eckd suc: no reason code available"); 2988 clear_bit(DASD_FLAG_SUC, &device->flags); 2989 return; 2990 2991 } 2992 private->suc_reason = sense[8]; 2993 DBF_DEV_EVENT(DBF_NOTICE, device, "%s %x", 2994 "eckd handle summary unit check: reason", 2995 private->suc_reason); 2996 dasd_get_device(device); 2997 if (!schedule_work(&device->suc_work)) 2998 dasd_put_device(device); 2999 3000 return; 3001 } 3002 3003 /* service information message SIM */ 3004 if (!cqr && !(sense[27] & DASD_SENSE_BIT_0) && 3005 ((sense[6] & DASD_SIM_SENSE) == DASD_SIM_SENSE)) { 3006 dasd_3990_erp_handle_sim(device, sense); 3007 return; 3008 } 3009 3010 /* loss of device reservation is handled via base devices only 3011 * as alias devices may be used with several bases 3012 */ 3013 if (device->block && (sense[27] & DASD_SENSE_BIT_0) && 3014 (sense[7] == 0x3F) && 3015 (scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK) && 3016 test_bit(DASD_FLAG_IS_RESERVED, &device->flags)) { 3017 if (device->features & DASD_FEATURE_FAILONSLCK) 3018 set_bit(DASD_FLAG_LOCK_STOLEN, &device->flags); 3019 clear_bit(DASD_FLAG_IS_RESERVED, &device->flags); 3020 dev_err(&device->cdev->dev, 3021 "The device reservation was lost\n"); 3022 } 3023 } 3024 3025 static struct dasd_ccw_req *dasd_eckd_build_cp_cmd_single( 3026 struct dasd_device *startdev, 3027 struct dasd_block *block, 3028 struct request *req, 3029 sector_t first_rec, 3030 sector_t last_rec, 3031 sector_t first_trk, 3032 sector_t last_trk, 3033 unsigned int first_offs, 3034 unsigned int last_offs, 3035 unsigned int blk_per_trk, 3036 unsigned int blksize) 3037 { 3038 struct dasd_eckd_private *private; 3039 unsigned long *idaws; 3040 struct LO_eckd_data *LO_data; 3041 struct dasd_ccw_req *cqr; 3042 struct ccw1 *ccw; 3043 struct req_iterator iter; 3044 struct bio_vec bv; 3045 char *dst; 3046 unsigned int off; 3047 int count, cidaw, cplength, datasize; 3048 sector_t recid; 3049 unsigned char cmd, rcmd; 3050 int use_prefix; 3051 struct dasd_device *basedev; 3052 3053 basedev = block->base; 3054 private = basedev->private; 3055 if (rq_data_dir(req) == READ) 3056 cmd = DASD_ECKD_CCW_READ_MT; 3057 else if (rq_data_dir(req) == WRITE) 3058 cmd = DASD_ECKD_CCW_WRITE_MT; 3059 else 3060 return ERR_PTR(-EINVAL); 3061 3062 /* Check struct bio and count the number of blocks for the request. */ 3063 count = 0; 3064 cidaw = 0; 3065 rq_for_each_segment(bv, req, iter) { 3066 if (bv.bv_len & (blksize - 1)) 3067 /* Eckd can only do full blocks. */ 3068 return ERR_PTR(-EINVAL); 3069 count += bv.bv_len >> (block->s2b_shift + 9); 3070 if (idal_is_needed (page_address(bv.bv_page), bv.bv_len)) 3071 cidaw += bv.bv_len >> (block->s2b_shift + 9); 3072 } 3073 /* Paranoia. */ 3074 if (count != last_rec - first_rec + 1) 3075 return ERR_PTR(-EINVAL); 3076 3077 /* use the prefix command if available */ 3078 use_prefix = private->features.feature[8] & 0x01; 3079 if (use_prefix) { 3080 /* 1x prefix + number of blocks */ 3081 cplength = 2 + count; 3082 /* 1x prefix + cidaws*sizeof(long) */ 3083 datasize = sizeof(struct PFX_eckd_data) + 3084 sizeof(struct LO_eckd_data) + 3085 cidaw * sizeof(unsigned long); 3086 } else { 3087 /* 1x define extent + 1x locate record + number of blocks */ 3088 cplength = 2 + count; 3089 /* 1x define extent + 1x locate record + cidaws*sizeof(long) */ 3090 datasize = sizeof(struct DE_eckd_data) + 3091 sizeof(struct LO_eckd_data) + 3092 cidaw * sizeof(unsigned long); 3093 } 3094 /* Find out the number of additional locate record ccws for cdl. */ 3095 if (private->uses_cdl && first_rec < 2*blk_per_trk) { 3096 if (last_rec >= 2*blk_per_trk) 3097 count = 2*blk_per_trk - first_rec; 3098 cplength += count; 3099 datasize += count*sizeof(struct LO_eckd_data); 3100 } 3101 /* Allocate the ccw request. */ 3102 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, 3103 startdev); 3104 if (IS_ERR(cqr)) 3105 return cqr; 3106 ccw = cqr->cpaddr; 3107 /* First ccw is define extent or prefix. */ 3108 if (use_prefix) { 3109 if (prefix(ccw++, cqr->data, first_trk, 3110 last_trk, cmd, basedev, startdev) == -EAGAIN) { 3111 /* Clock not in sync and XRC is enabled. 3112 * Try again later. 3113 */ 3114 dasd_sfree_request(cqr, startdev); 3115 return ERR_PTR(-EAGAIN); 3116 } 3117 idaws = (unsigned long *) (cqr->data + 3118 sizeof(struct PFX_eckd_data)); 3119 } else { 3120 if (define_extent(ccw++, cqr->data, first_trk, 3121 last_trk, cmd, basedev, 0) == -EAGAIN) { 3122 /* Clock not in sync and XRC is enabled. 3123 * Try again later. 3124 */ 3125 dasd_sfree_request(cqr, startdev); 3126 return ERR_PTR(-EAGAIN); 3127 } 3128 idaws = (unsigned long *) (cqr->data + 3129 sizeof(struct DE_eckd_data)); 3130 } 3131 /* Build locate_record+read/write/ccws. */ 3132 LO_data = (struct LO_eckd_data *) (idaws + cidaw); 3133 recid = first_rec; 3134 if (private->uses_cdl == 0 || recid > 2*blk_per_trk) { 3135 /* Only standard blocks so there is just one locate record. */ 3136 ccw[-1].flags |= CCW_FLAG_CC; 3137 locate_record(ccw++, LO_data++, first_trk, first_offs + 1, 3138 last_rec - recid + 1, cmd, basedev, blksize); 3139 } 3140 rq_for_each_segment(bv, req, iter) { 3141 dst = page_address(bv.bv_page) + bv.bv_offset; 3142 if (dasd_page_cache) { 3143 char *copy = kmem_cache_alloc(dasd_page_cache, 3144 GFP_DMA | __GFP_NOWARN); 3145 if (copy && rq_data_dir(req) == WRITE) 3146 memcpy(copy + bv.bv_offset, dst, bv.bv_len); 3147 if (copy) 3148 dst = copy + bv.bv_offset; 3149 } 3150 for (off = 0; off < bv.bv_len; off += blksize) { 3151 sector_t trkid = recid; 3152 unsigned int recoffs = sector_div(trkid, blk_per_trk); 3153 rcmd = cmd; 3154 count = blksize; 3155 /* Locate record for cdl special block ? */ 3156 if (private->uses_cdl && recid < 2*blk_per_trk) { 3157 if (dasd_eckd_cdl_special(blk_per_trk, recid)){ 3158 rcmd |= 0x8; 3159 count = dasd_eckd_cdl_reclen(recid); 3160 if (count < blksize && 3161 rq_data_dir(req) == READ) 3162 memset(dst + count, 0xe5, 3163 blksize - count); 3164 } 3165 ccw[-1].flags |= CCW_FLAG_CC; 3166 locate_record(ccw++, LO_data++, 3167 trkid, recoffs + 1, 3168 1, rcmd, basedev, count); 3169 } 3170 /* Locate record for standard blocks ? */ 3171 if (private->uses_cdl && recid == 2*blk_per_trk) { 3172 ccw[-1].flags |= CCW_FLAG_CC; 3173 locate_record(ccw++, LO_data++, 3174 trkid, recoffs + 1, 3175 last_rec - recid + 1, 3176 cmd, basedev, count); 3177 } 3178 /* Read/write ccw. */ 3179 ccw[-1].flags |= CCW_FLAG_CC; 3180 ccw->cmd_code = rcmd; 3181 ccw->count = count; 3182 if (idal_is_needed(dst, blksize)) { 3183 ccw->cda = (__u32)(addr_t) idaws; 3184 ccw->flags = CCW_FLAG_IDA; 3185 idaws = idal_create_words(idaws, dst, blksize); 3186 } else { 3187 ccw->cda = (__u32)(addr_t) dst; 3188 ccw->flags = 0; 3189 } 3190 ccw++; 3191 dst += blksize; 3192 recid++; 3193 } 3194 } 3195 if (blk_noretry_request(req) || 3196 block->base->features & DASD_FEATURE_FAILFAST) 3197 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 3198 cqr->startdev = startdev; 3199 cqr->memdev = startdev; 3200 cqr->block = block; 3201 cqr->expires = startdev->default_expires * HZ; /* default 5 minutes */ 3202 cqr->lpm = dasd_path_get_ppm(startdev); 3203 cqr->retries = startdev->default_retries; 3204 cqr->buildclk = get_tod_clock(); 3205 cqr->status = DASD_CQR_FILLED; 3206 return cqr; 3207 } 3208 3209 static struct dasd_ccw_req *dasd_eckd_build_cp_cmd_track( 3210 struct dasd_device *startdev, 3211 struct dasd_block *block, 3212 struct request *req, 3213 sector_t first_rec, 3214 sector_t last_rec, 3215 sector_t first_trk, 3216 sector_t last_trk, 3217 unsigned int first_offs, 3218 unsigned int last_offs, 3219 unsigned int blk_per_trk, 3220 unsigned int blksize) 3221 { 3222 unsigned long *idaws; 3223 struct dasd_ccw_req *cqr; 3224 struct ccw1 *ccw; 3225 struct req_iterator iter; 3226 struct bio_vec bv; 3227 char *dst, *idaw_dst; 3228 unsigned int cidaw, cplength, datasize; 3229 unsigned int tlf; 3230 sector_t recid; 3231 unsigned char cmd; 3232 struct dasd_device *basedev; 3233 unsigned int trkcount, count, count_to_trk_end; 3234 unsigned int idaw_len, seg_len, part_len, len_to_track_end; 3235 unsigned char new_track, end_idaw; 3236 sector_t trkid; 3237 unsigned int recoffs; 3238 3239 basedev = block->base; 3240 if (rq_data_dir(req) == READ) 3241 cmd = DASD_ECKD_CCW_READ_TRACK_DATA; 3242 else if (rq_data_dir(req) == WRITE) 3243 cmd = DASD_ECKD_CCW_WRITE_TRACK_DATA; 3244 else 3245 return ERR_PTR(-EINVAL); 3246 3247 /* Track based I/O needs IDAWs for each page, and not just for 3248 * 64 bit addresses. We need additional idals for pages 3249 * that get filled from two tracks, so we use the number 3250 * of records as upper limit. 3251 */ 3252 cidaw = last_rec - first_rec + 1; 3253 trkcount = last_trk - first_trk + 1; 3254 3255 /* 1x prefix + one read/write ccw per track */ 3256 cplength = 1 + trkcount; 3257 3258 datasize = sizeof(struct PFX_eckd_data) + cidaw * sizeof(unsigned long); 3259 3260 /* Allocate the ccw request. */ 3261 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, 3262 startdev); 3263 if (IS_ERR(cqr)) 3264 return cqr; 3265 ccw = cqr->cpaddr; 3266 /* transfer length factor: how many bytes to read from the last track */ 3267 if (first_trk == last_trk) 3268 tlf = last_offs - first_offs + 1; 3269 else 3270 tlf = last_offs + 1; 3271 tlf *= blksize; 3272 3273 if (prefix_LRE(ccw++, cqr->data, first_trk, 3274 last_trk, cmd, basedev, startdev, 3275 1 /* format */, first_offs + 1, 3276 trkcount, blksize, 3277 tlf) == -EAGAIN) { 3278 /* Clock not in sync and XRC is enabled. 3279 * Try again later. 3280 */ 3281 dasd_sfree_request(cqr, startdev); 3282 return ERR_PTR(-EAGAIN); 3283 } 3284 3285 /* 3286 * The translation of request into ccw programs must meet the 3287 * following conditions: 3288 * - all idaws but the first and the last must address full pages 3289 * (or 2K blocks on 31-bit) 3290 * - the scope of a ccw and it's idal ends with the track boundaries 3291 */ 3292 idaws = (unsigned long *) (cqr->data + sizeof(struct PFX_eckd_data)); 3293 recid = first_rec; 3294 new_track = 1; 3295 end_idaw = 0; 3296 len_to_track_end = 0; 3297 idaw_dst = NULL; 3298 idaw_len = 0; 3299 rq_for_each_segment(bv, req, iter) { 3300 dst = page_address(bv.bv_page) + bv.bv_offset; 3301 seg_len = bv.bv_len; 3302 while (seg_len) { 3303 if (new_track) { 3304 trkid = recid; 3305 recoffs = sector_div(trkid, blk_per_trk); 3306 count_to_trk_end = blk_per_trk - recoffs; 3307 count = min((last_rec - recid + 1), 3308 (sector_t)count_to_trk_end); 3309 len_to_track_end = count * blksize; 3310 ccw[-1].flags |= CCW_FLAG_CC; 3311 ccw->cmd_code = cmd; 3312 ccw->count = len_to_track_end; 3313 ccw->cda = (__u32)(addr_t)idaws; 3314 ccw->flags = CCW_FLAG_IDA; 3315 ccw++; 3316 recid += count; 3317 new_track = 0; 3318 /* first idaw for a ccw may start anywhere */ 3319 if (!idaw_dst) 3320 idaw_dst = dst; 3321 } 3322 /* If we start a new idaw, we must make sure that it 3323 * starts on an IDA_BLOCK_SIZE boundary. 3324 * If we continue an idaw, we must make sure that the 3325 * current segment begins where the so far accumulated 3326 * idaw ends 3327 */ 3328 if (!idaw_dst) { 3329 if (__pa(dst) & (IDA_BLOCK_SIZE-1)) { 3330 dasd_sfree_request(cqr, startdev); 3331 return ERR_PTR(-ERANGE); 3332 } else 3333 idaw_dst = dst; 3334 } 3335 if ((idaw_dst + idaw_len) != dst) { 3336 dasd_sfree_request(cqr, startdev); 3337 return ERR_PTR(-ERANGE); 3338 } 3339 part_len = min(seg_len, len_to_track_end); 3340 seg_len -= part_len; 3341 dst += part_len; 3342 idaw_len += part_len; 3343 len_to_track_end -= part_len; 3344 /* collected memory area ends on an IDA_BLOCK border, 3345 * -> create an idaw 3346 * idal_create_words will handle cases where idaw_len 3347 * is larger then IDA_BLOCK_SIZE 3348 */ 3349 if (!(__pa(idaw_dst + idaw_len) & (IDA_BLOCK_SIZE-1))) 3350 end_idaw = 1; 3351 /* We also need to end the idaw at track end */ 3352 if (!len_to_track_end) { 3353 new_track = 1; 3354 end_idaw = 1; 3355 } 3356 if (end_idaw) { 3357 idaws = idal_create_words(idaws, idaw_dst, 3358 idaw_len); 3359 idaw_dst = NULL; 3360 idaw_len = 0; 3361 end_idaw = 0; 3362 } 3363 } 3364 } 3365 3366 if (blk_noretry_request(req) || 3367 block->base->features & DASD_FEATURE_FAILFAST) 3368 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 3369 cqr->startdev = startdev; 3370 cqr->memdev = startdev; 3371 cqr->block = block; 3372 cqr->expires = startdev->default_expires * HZ; /* default 5 minutes */ 3373 cqr->lpm = dasd_path_get_ppm(startdev); 3374 cqr->retries = startdev->default_retries; 3375 cqr->buildclk = get_tod_clock(); 3376 cqr->status = DASD_CQR_FILLED; 3377 return cqr; 3378 } 3379 3380 static int prepare_itcw(struct itcw *itcw, 3381 unsigned int trk, unsigned int totrk, int cmd, 3382 struct dasd_device *basedev, 3383 struct dasd_device *startdev, 3384 unsigned int rec_on_trk, int count, 3385 unsigned int blksize, 3386 unsigned int total_data_size, 3387 unsigned int tlf, 3388 unsigned int blk_per_trk) 3389 { 3390 struct PFX_eckd_data pfxdata; 3391 struct dasd_eckd_private *basepriv, *startpriv; 3392 struct DE_eckd_data *dedata; 3393 struct LRE_eckd_data *lredata; 3394 struct dcw *dcw; 3395 3396 u32 begcyl, endcyl; 3397 u16 heads, beghead, endhead; 3398 u8 pfx_cmd; 3399 3400 int rc = 0; 3401 int sector = 0; 3402 int dn, d; 3403 3404 3405 /* setup prefix data */ 3406 basepriv = basedev->private; 3407 startpriv = startdev->private; 3408 dedata = &pfxdata.define_extent; 3409 lredata = &pfxdata.locate_record; 3410 3411 memset(&pfxdata, 0, sizeof(pfxdata)); 3412 pfxdata.format = 1; /* PFX with LRE */ 3413 pfxdata.base_address = basepriv->ned->unit_addr; 3414 pfxdata.base_lss = basepriv->ned->ID; 3415 pfxdata.validity.define_extent = 1; 3416 3417 /* private uid is kept up to date, conf_data may be outdated */ 3418 if (startpriv->uid.type != UA_BASE_DEVICE) { 3419 pfxdata.validity.verify_base = 1; 3420 if (startpriv->uid.type == UA_HYPER_PAV_ALIAS) 3421 pfxdata.validity.hyper_pav = 1; 3422 } 3423 3424 switch (cmd) { 3425 case DASD_ECKD_CCW_READ_TRACK_DATA: 3426 dedata->mask.perm = 0x1; 3427 dedata->attributes.operation = basepriv->attrib.operation; 3428 dedata->blk_size = blksize; 3429 dedata->ga_extended |= 0x42; 3430 lredata->operation.orientation = 0x0; 3431 lredata->operation.operation = 0x0C; 3432 lredata->auxiliary.check_bytes = 0x01; 3433 pfx_cmd = DASD_ECKD_CCW_PFX_READ; 3434 break; 3435 case DASD_ECKD_CCW_WRITE_TRACK_DATA: 3436 dedata->mask.perm = 0x02; 3437 dedata->attributes.operation = basepriv->attrib.operation; 3438 dedata->blk_size = blksize; 3439 rc = check_XRC(NULL, dedata, basedev); 3440 dedata->ga_extended |= 0x42; 3441 lredata->operation.orientation = 0x0; 3442 lredata->operation.operation = 0x3F; 3443 lredata->extended_operation = 0x23; 3444 lredata->auxiliary.check_bytes = 0x2; 3445 /* 3446 * If XRC is supported the System Time Stamp is set. The 3447 * validity of the time stamp must be reflected in the prefix 3448 * data as well. 3449 */ 3450 if (dedata->ga_extended & 0x08 && dedata->ga_extended & 0x02) 3451 pfxdata.validity.time_stamp = 1; /* 'Time Stamp Valid' */ 3452 pfx_cmd = DASD_ECKD_CCW_PFX; 3453 break; 3454 case DASD_ECKD_CCW_READ_COUNT_MT: 3455 dedata->mask.perm = 0x1; 3456 dedata->attributes.operation = DASD_BYPASS_CACHE; 3457 dedata->ga_extended |= 0x42; 3458 dedata->blk_size = blksize; 3459 lredata->operation.orientation = 0x2; 3460 lredata->operation.operation = 0x16; 3461 lredata->auxiliary.check_bytes = 0x01; 3462 pfx_cmd = DASD_ECKD_CCW_PFX_READ; 3463 break; 3464 default: 3465 DBF_DEV_EVENT(DBF_ERR, basedev, 3466 "prepare itcw, unknown opcode 0x%x", cmd); 3467 BUG(); 3468 break; 3469 } 3470 if (rc) 3471 return rc; 3472 3473 dedata->attributes.mode = 0x3; /* ECKD */ 3474 3475 heads = basepriv->rdc_data.trk_per_cyl; 3476 begcyl = trk / heads; 3477 beghead = trk % heads; 3478 endcyl = totrk / heads; 3479 endhead = totrk % heads; 3480 3481 /* check for sequential prestage - enhance cylinder range */ 3482 if (dedata->attributes.operation == DASD_SEQ_PRESTAGE || 3483 dedata->attributes.operation == DASD_SEQ_ACCESS) { 3484 3485 if (endcyl + basepriv->attrib.nr_cyl < basepriv->real_cyl) 3486 endcyl += basepriv->attrib.nr_cyl; 3487 else 3488 endcyl = (basepriv->real_cyl - 1); 3489 } 3490 3491 set_ch_t(&dedata->beg_ext, begcyl, beghead); 3492 set_ch_t(&dedata->end_ext, endcyl, endhead); 3493 3494 dedata->ep_format = 0x20; /* records per track is valid */ 3495 dedata->ep_rec_per_track = blk_per_trk; 3496 3497 if (rec_on_trk) { 3498 switch (basepriv->rdc_data.dev_type) { 3499 case 0x3390: 3500 dn = ceil_quot(blksize + 6, 232); 3501 d = 9 + ceil_quot(blksize + 6 * (dn + 1), 34); 3502 sector = (49 + (rec_on_trk - 1) * (10 + d)) / 8; 3503 break; 3504 case 0x3380: 3505 d = 7 + ceil_quot(blksize + 12, 32); 3506 sector = (39 + (rec_on_trk - 1) * (8 + d)) / 7; 3507 break; 3508 } 3509 } 3510 3511 if (cmd == DASD_ECKD_CCW_READ_COUNT_MT) { 3512 lredata->auxiliary.length_valid = 0; 3513 lredata->auxiliary.length_scope = 0; 3514 lredata->sector = 0xff; 3515 } else { 3516 lredata->auxiliary.length_valid = 1; 3517 lredata->auxiliary.length_scope = 1; 3518 lredata->sector = sector; 3519 } 3520 lredata->auxiliary.imbedded_ccw_valid = 1; 3521 lredata->length = tlf; 3522 lredata->imbedded_ccw = cmd; 3523 lredata->count = count; 3524 set_ch_t(&lredata->seek_addr, begcyl, beghead); 3525 lredata->search_arg.cyl = lredata->seek_addr.cyl; 3526 lredata->search_arg.head = lredata->seek_addr.head; 3527 lredata->search_arg.record = rec_on_trk; 3528 3529 dcw = itcw_add_dcw(itcw, pfx_cmd, 0, 3530 &pfxdata, sizeof(pfxdata), total_data_size); 3531 return PTR_RET(dcw); 3532 } 3533 3534 static struct dasd_ccw_req *dasd_eckd_build_cp_tpm_track( 3535 struct dasd_device *startdev, 3536 struct dasd_block *block, 3537 struct request *req, 3538 sector_t first_rec, 3539 sector_t last_rec, 3540 sector_t first_trk, 3541 sector_t last_trk, 3542 unsigned int first_offs, 3543 unsigned int last_offs, 3544 unsigned int blk_per_trk, 3545 unsigned int blksize) 3546 { 3547 struct dasd_ccw_req *cqr; 3548 struct req_iterator iter; 3549 struct bio_vec bv; 3550 char *dst; 3551 unsigned int trkcount, ctidaw; 3552 unsigned char cmd; 3553 struct dasd_device *basedev; 3554 unsigned int tlf; 3555 struct itcw *itcw; 3556 struct tidaw *last_tidaw = NULL; 3557 int itcw_op; 3558 size_t itcw_size; 3559 u8 tidaw_flags; 3560 unsigned int seg_len, part_len, len_to_track_end; 3561 unsigned char new_track; 3562 sector_t recid, trkid; 3563 unsigned int offs; 3564 unsigned int count, count_to_trk_end; 3565 int ret; 3566 3567 basedev = block->base; 3568 if (rq_data_dir(req) == READ) { 3569 cmd = DASD_ECKD_CCW_READ_TRACK_DATA; 3570 itcw_op = ITCW_OP_READ; 3571 } else if (rq_data_dir(req) == WRITE) { 3572 cmd = DASD_ECKD_CCW_WRITE_TRACK_DATA; 3573 itcw_op = ITCW_OP_WRITE; 3574 } else 3575 return ERR_PTR(-EINVAL); 3576 3577 /* trackbased I/O needs address all memory via TIDAWs, 3578 * not just for 64 bit addresses. This allows us to map 3579 * each segment directly to one tidaw. 3580 * In the case of write requests, additional tidaws may 3581 * be needed when a segment crosses a track boundary. 3582 */ 3583 trkcount = last_trk - first_trk + 1; 3584 ctidaw = 0; 3585 rq_for_each_segment(bv, req, iter) { 3586 ++ctidaw; 3587 } 3588 if (rq_data_dir(req) == WRITE) 3589 ctidaw += (last_trk - first_trk); 3590 3591 /* Allocate the ccw request. */ 3592 itcw_size = itcw_calc_size(0, ctidaw, 0); 3593 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 0, itcw_size, startdev); 3594 if (IS_ERR(cqr)) 3595 return cqr; 3596 3597 /* transfer length factor: how many bytes to read from the last track */ 3598 if (first_trk == last_trk) 3599 tlf = last_offs - first_offs + 1; 3600 else 3601 tlf = last_offs + 1; 3602 tlf *= blksize; 3603 3604 itcw = itcw_init(cqr->data, itcw_size, itcw_op, 0, ctidaw, 0); 3605 if (IS_ERR(itcw)) { 3606 ret = -EINVAL; 3607 goto out_error; 3608 } 3609 cqr->cpaddr = itcw_get_tcw(itcw); 3610 if (prepare_itcw(itcw, first_trk, last_trk, 3611 cmd, basedev, startdev, 3612 first_offs + 1, 3613 trkcount, blksize, 3614 (last_rec - first_rec + 1) * blksize, 3615 tlf, blk_per_trk) == -EAGAIN) { 3616 /* Clock not in sync and XRC is enabled. 3617 * Try again later. 3618 */ 3619 ret = -EAGAIN; 3620 goto out_error; 3621 } 3622 len_to_track_end = 0; 3623 /* 3624 * A tidaw can address 4k of memory, but must not cross page boundaries 3625 * We can let the block layer handle this by setting 3626 * blk_queue_segment_boundary to page boundaries and 3627 * blk_max_segment_size to page size when setting up the request queue. 3628 * For write requests, a TIDAW must not cross track boundaries, because 3629 * we have to set the CBC flag on the last tidaw for each track. 3630 */ 3631 if (rq_data_dir(req) == WRITE) { 3632 new_track = 1; 3633 recid = first_rec; 3634 rq_for_each_segment(bv, req, iter) { 3635 dst = page_address(bv.bv_page) + bv.bv_offset; 3636 seg_len = bv.bv_len; 3637 while (seg_len) { 3638 if (new_track) { 3639 trkid = recid; 3640 offs = sector_div(trkid, blk_per_trk); 3641 count_to_trk_end = blk_per_trk - offs; 3642 count = min((last_rec - recid + 1), 3643 (sector_t)count_to_trk_end); 3644 len_to_track_end = count * blksize; 3645 recid += count; 3646 new_track = 0; 3647 } 3648 part_len = min(seg_len, len_to_track_end); 3649 seg_len -= part_len; 3650 len_to_track_end -= part_len; 3651 /* We need to end the tidaw at track end */ 3652 if (!len_to_track_end) { 3653 new_track = 1; 3654 tidaw_flags = TIDAW_FLAGS_INSERT_CBC; 3655 } else 3656 tidaw_flags = 0; 3657 last_tidaw = itcw_add_tidaw(itcw, tidaw_flags, 3658 dst, part_len); 3659 if (IS_ERR(last_tidaw)) { 3660 ret = -EINVAL; 3661 goto out_error; 3662 } 3663 dst += part_len; 3664 } 3665 } 3666 } else { 3667 rq_for_each_segment(bv, req, iter) { 3668 dst = page_address(bv.bv_page) + bv.bv_offset; 3669 last_tidaw = itcw_add_tidaw(itcw, 0x00, 3670 dst, bv.bv_len); 3671 if (IS_ERR(last_tidaw)) { 3672 ret = -EINVAL; 3673 goto out_error; 3674 } 3675 } 3676 } 3677 last_tidaw->flags |= TIDAW_FLAGS_LAST; 3678 last_tidaw->flags &= ~TIDAW_FLAGS_INSERT_CBC; 3679 itcw_finalize(itcw); 3680 3681 if (blk_noretry_request(req) || 3682 block->base->features & DASD_FEATURE_FAILFAST) 3683 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 3684 cqr->cpmode = 1; 3685 cqr->startdev = startdev; 3686 cqr->memdev = startdev; 3687 cqr->block = block; 3688 cqr->expires = startdev->default_expires * HZ; /* default 5 minutes */ 3689 cqr->lpm = dasd_path_get_ppm(startdev); 3690 cqr->retries = startdev->default_retries; 3691 cqr->buildclk = get_tod_clock(); 3692 cqr->status = DASD_CQR_FILLED; 3693 return cqr; 3694 out_error: 3695 dasd_sfree_request(cqr, startdev); 3696 return ERR_PTR(ret); 3697 } 3698 3699 static struct dasd_ccw_req *dasd_eckd_build_cp(struct dasd_device *startdev, 3700 struct dasd_block *block, 3701 struct request *req) 3702 { 3703 int cmdrtd, cmdwtd; 3704 int use_prefix; 3705 int fcx_multitrack; 3706 struct dasd_eckd_private *private; 3707 struct dasd_device *basedev; 3708 sector_t first_rec, last_rec; 3709 sector_t first_trk, last_trk; 3710 unsigned int first_offs, last_offs; 3711 unsigned int blk_per_trk, blksize; 3712 int cdlspecial; 3713 unsigned int data_size; 3714 struct dasd_ccw_req *cqr; 3715 3716 basedev = block->base; 3717 private = basedev->private; 3718 3719 /* Calculate number of blocks/records per track. */ 3720 blksize = block->bp_block; 3721 blk_per_trk = recs_per_track(&private->rdc_data, 0, blksize); 3722 if (blk_per_trk == 0) 3723 return ERR_PTR(-EINVAL); 3724 /* Calculate record id of first and last block. */ 3725 first_rec = first_trk = blk_rq_pos(req) >> block->s2b_shift; 3726 first_offs = sector_div(first_trk, blk_per_trk); 3727 last_rec = last_trk = 3728 (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift; 3729 last_offs = sector_div(last_trk, blk_per_trk); 3730 cdlspecial = (private->uses_cdl && first_rec < 2*blk_per_trk); 3731 3732 fcx_multitrack = private->features.feature[40] & 0x20; 3733 data_size = blk_rq_bytes(req); 3734 if (data_size % blksize) 3735 return ERR_PTR(-EINVAL); 3736 /* tpm write request add CBC data on each track boundary */ 3737 if (rq_data_dir(req) == WRITE) 3738 data_size += (last_trk - first_trk) * 4; 3739 3740 /* is read track data and write track data in command mode supported? */ 3741 cmdrtd = private->features.feature[9] & 0x20; 3742 cmdwtd = private->features.feature[12] & 0x40; 3743 use_prefix = private->features.feature[8] & 0x01; 3744 3745 cqr = NULL; 3746 if (cdlspecial || dasd_page_cache) { 3747 /* do nothing, just fall through to the cmd mode single case */ 3748 } else if ((data_size <= private->fcx_max_data) 3749 && (fcx_multitrack || (first_trk == last_trk))) { 3750 cqr = dasd_eckd_build_cp_tpm_track(startdev, block, req, 3751 first_rec, last_rec, 3752 first_trk, last_trk, 3753 first_offs, last_offs, 3754 blk_per_trk, blksize); 3755 if (IS_ERR(cqr) && (PTR_ERR(cqr) != -EAGAIN) && 3756 (PTR_ERR(cqr) != -ENOMEM)) 3757 cqr = NULL; 3758 } else if (use_prefix && 3759 (((rq_data_dir(req) == READ) && cmdrtd) || 3760 ((rq_data_dir(req) == WRITE) && cmdwtd))) { 3761 cqr = dasd_eckd_build_cp_cmd_track(startdev, block, req, 3762 first_rec, last_rec, 3763 first_trk, last_trk, 3764 first_offs, last_offs, 3765 blk_per_trk, blksize); 3766 if (IS_ERR(cqr) && (PTR_ERR(cqr) != -EAGAIN) && 3767 (PTR_ERR(cqr) != -ENOMEM)) 3768 cqr = NULL; 3769 } 3770 if (!cqr) 3771 cqr = dasd_eckd_build_cp_cmd_single(startdev, block, req, 3772 first_rec, last_rec, 3773 first_trk, last_trk, 3774 first_offs, last_offs, 3775 blk_per_trk, blksize); 3776 return cqr; 3777 } 3778 3779 static struct dasd_ccw_req *dasd_eckd_build_cp_raw(struct dasd_device *startdev, 3780 struct dasd_block *block, 3781 struct request *req) 3782 { 3783 sector_t start_padding_sectors, end_sector_offset, end_padding_sectors; 3784 unsigned int seg_len, len_to_track_end; 3785 unsigned int cidaw, cplength, datasize; 3786 sector_t first_trk, last_trk, sectors; 3787 struct dasd_eckd_private *base_priv; 3788 struct dasd_device *basedev; 3789 struct req_iterator iter; 3790 struct dasd_ccw_req *cqr; 3791 unsigned int first_offs; 3792 unsigned int trkcount; 3793 unsigned long *idaws; 3794 unsigned int size; 3795 unsigned char cmd; 3796 struct bio_vec bv; 3797 struct ccw1 *ccw; 3798 int use_prefix; 3799 void *data; 3800 char *dst; 3801 3802 /* 3803 * raw track access needs to be mutiple of 64k and on 64k boundary 3804 * For read requests we can fix an incorrect alignment by padding 3805 * the request with dummy pages. 3806 */ 3807 start_padding_sectors = blk_rq_pos(req) % DASD_RAW_SECTORS_PER_TRACK; 3808 end_sector_offset = (blk_rq_pos(req) + blk_rq_sectors(req)) % 3809 DASD_RAW_SECTORS_PER_TRACK; 3810 end_padding_sectors = (DASD_RAW_SECTORS_PER_TRACK - end_sector_offset) % 3811 DASD_RAW_SECTORS_PER_TRACK; 3812 basedev = block->base; 3813 if ((start_padding_sectors || end_padding_sectors) && 3814 (rq_data_dir(req) == WRITE)) { 3815 DBF_DEV_EVENT(DBF_ERR, basedev, 3816 "raw write not track aligned (%lu,%lu) req %p", 3817 start_padding_sectors, end_padding_sectors, req); 3818 return ERR_PTR(-EINVAL); 3819 } 3820 3821 first_trk = blk_rq_pos(req) / DASD_RAW_SECTORS_PER_TRACK; 3822 last_trk = (blk_rq_pos(req) + blk_rq_sectors(req) - 1) / 3823 DASD_RAW_SECTORS_PER_TRACK; 3824 trkcount = last_trk - first_trk + 1; 3825 first_offs = 0; 3826 3827 if (rq_data_dir(req) == READ) 3828 cmd = DASD_ECKD_CCW_READ_TRACK; 3829 else if (rq_data_dir(req) == WRITE) 3830 cmd = DASD_ECKD_CCW_WRITE_FULL_TRACK; 3831 else 3832 return ERR_PTR(-EINVAL); 3833 3834 /* 3835 * Raw track based I/O needs IDAWs for each page, 3836 * and not just for 64 bit addresses. 3837 */ 3838 cidaw = trkcount * DASD_RAW_BLOCK_PER_TRACK; 3839 3840 /* 3841 * struct PFX_eckd_data and struct LRE_eckd_data can have up to 2 bytes 3842 * of extended parameter. This is needed for write full track. 3843 */ 3844 base_priv = basedev->private; 3845 use_prefix = base_priv->features.feature[8] & 0x01; 3846 if (use_prefix) { 3847 cplength = 1 + trkcount; 3848 size = sizeof(struct PFX_eckd_data) + 2; 3849 } else { 3850 cplength = 2 + trkcount; 3851 size = sizeof(struct DE_eckd_data) + 3852 sizeof(struct LRE_eckd_data) + 2; 3853 } 3854 size = ALIGN(size, 8); 3855 3856 datasize = size + cidaw * sizeof(unsigned long); 3857 3858 /* Allocate the ccw request. */ 3859 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, 3860 datasize, startdev); 3861 if (IS_ERR(cqr)) 3862 return cqr; 3863 3864 ccw = cqr->cpaddr; 3865 data = cqr->data; 3866 3867 if (use_prefix) { 3868 prefix_LRE(ccw++, data, first_trk, last_trk, cmd, basedev, 3869 startdev, 1, first_offs + 1, trkcount, 0, 0); 3870 } else { 3871 define_extent(ccw++, data, first_trk, last_trk, cmd, basedev, 0); 3872 ccw[-1].flags |= CCW_FLAG_CC; 3873 3874 data += sizeof(struct DE_eckd_data); 3875 locate_record_ext(ccw++, data, first_trk, first_offs + 1, 3876 trkcount, cmd, basedev, 0, 0); 3877 } 3878 3879 idaws = (unsigned long *)(cqr->data + size); 3880 len_to_track_end = 0; 3881 if (start_padding_sectors) { 3882 ccw[-1].flags |= CCW_FLAG_CC; 3883 ccw->cmd_code = cmd; 3884 /* maximum 3390 track size */ 3885 ccw->count = 57326; 3886 /* 64k map to one track */ 3887 len_to_track_end = 65536 - start_padding_sectors * 512; 3888 ccw->cda = (__u32)(addr_t)idaws; 3889 ccw->flags |= CCW_FLAG_IDA; 3890 ccw->flags |= CCW_FLAG_SLI; 3891 ccw++; 3892 for (sectors = 0; sectors < start_padding_sectors; sectors += 8) 3893 idaws = idal_create_words(idaws, rawpadpage, PAGE_SIZE); 3894 } 3895 rq_for_each_segment(bv, req, iter) { 3896 dst = page_address(bv.bv_page) + bv.bv_offset; 3897 seg_len = bv.bv_len; 3898 if (cmd == DASD_ECKD_CCW_READ_TRACK) 3899 memset(dst, 0, seg_len); 3900 if (!len_to_track_end) { 3901 ccw[-1].flags |= CCW_FLAG_CC; 3902 ccw->cmd_code = cmd; 3903 /* maximum 3390 track size */ 3904 ccw->count = 57326; 3905 /* 64k map to one track */ 3906 len_to_track_end = 65536; 3907 ccw->cda = (__u32)(addr_t)idaws; 3908 ccw->flags |= CCW_FLAG_IDA; 3909 ccw->flags |= CCW_FLAG_SLI; 3910 ccw++; 3911 } 3912 len_to_track_end -= seg_len; 3913 idaws = idal_create_words(idaws, dst, seg_len); 3914 } 3915 for (sectors = 0; sectors < end_padding_sectors; sectors += 8) 3916 idaws = idal_create_words(idaws, rawpadpage, PAGE_SIZE); 3917 if (blk_noretry_request(req) || 3918 block->base->features & DASD_FEATURE_FAILFAST) 3919 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 3920 cqr->startdev = startdev; 3921 cqr->memdev = startdev; 3922 cqr->block = block; 3923 cqr->expires = startdev->default_expires * HZ; 3924 cqr->lpm = dasd_path_get_ppm(startdev); 3925 cqr->retries = startdev->default_retries; 3926 cqr->buildclk = get_tod_clock(); 3927 cqr->status = DASD_CQR_FILLED; 3928 3929 return cqr; 3930 } 3931 3932 3933 static int 3934 dasd_eckd_free_cp(struct dasd_ccw_req *cqr, struct request *req) 3935 { 3936 struct dasd_eckd_private *private; 3937 struct ccw1 *ccw; 3938 struct req_iterator iter; 3939 struct bio_vec bv; 3940 char *dst, *cda; 3941 unsigned int blksize, blk_per_trk, off; 3942 sector_t recid; 3943 int status; 3944 3945 if (!dasd_page_cache) 3946 goto out; 3947 private = cqr->block->base->private; 3948 blksize = cqr->block->bp_block; 3949 blk_per_trk = recs_per_track(&private->rdc_data, 0, blksize); 3950 recid = blk_rq_pos(req) >> cqr->block->s2b_shift; 3951 ccw = cqr->cpaddr; 3952 /* Skip over define extent & locate record. */ 3953 ccw++; 3954 if (private->uses_cdl == 0 || recid > 2*blk_per_trk) 3955 ccw++; 3956 rq_for_each_segment(bv, req, iter) { 3957 dst = page_address(bv.bv_page) + bv.bv_offset; 3958 for (off = 0; off < bv.bv_len; off += blksize) { 3959 /* Skip locate record. */ 3960 if (private->uses_cdl && recid <= 2*blk_per_trk) 3961 ccw++; 3962 if (dst) { 3963 if (ccw->flags & CCW_FLAG_IDA) 3964 cda = *((char **)((addr_t) ccw->cda)); 3965 else 3966 cda = (char *)((addr_t) ccw->cda); 3967 if (dst != cda) { 3968 if (rq_data_dir(req) == READ) 3969 memcpy(dst, cda, bv.bv_len); 3970 kmem_cache_free(dasd_page_cache, 3971 (void *)((addr_t)cda & PAGE_MASK)); 3972 } 3973 dst = NULL; 3974 } 3975 ccw++; 3976 recid++; 3977 } 3978 } 3979 out: 3980 status = cqr->status == DASD_CQR_DONE; 3981 dasd_sfree_request(cqr, cqr->memdev); 3982 return status; 3983 } 3984 3985 /* 3986 * Modify ccw/tcw in cqr so it can be started on a base device. 3987 * 3988 * Note that this is not enough to restart the cqr! 3989 * Either reset cqr->startdev as well (summary unit check handling) 3990 * or restart via separate cqr (as in ERP handling). 3991 */ 3992 void dasd_eckd_reset_ccw_to_base_io(struct dasd_ccw_req *cqr) 3993 { 3994 struct ccw1 *ccw; 3995 struct PFX_eckd_data *pfxdata; 3996 struct tcw *tcw; 3997 struct tccb *tccb; 3998 struct dcw *dcw; 3999 4000 if (cqr->cpmode == 1) { 4001 tcw = cqr->cpaddr; 4002 tccb = tcw_get_tccb(tcw); 4003 dcw = (struct dcw *)&tccb->tca[0]; 4004 pfxdata = (struct PFX_eckd_data *)&dcw->cd[0]; 4005 pfxdata->validity.verify_base = 0; 4006 pfxdata->validity.hyper_pav = 0; 4007 } else { 4008 ccw = cqr->cpaddr; 4009 pfxdata = cqr->data; 4010 if (ccw->cmd_code == DASD_ECKD_CCW_PFX) { 4011 pfxdata->validity.verify_base = 0; 4012 pfxdata->validity.hyper_pav = 0; 4013 } 4014 } 4015 } 4016 4017 #define DASD_ECKD_CHANQ_MAX_SIZE 4 4018 4019 static struct dasd_ccw_req *dasd_eckd_build_alias_cp(struct dasd_device *base, 4020 struct dasd_block *block, 4021 struct request *req) 4022 { 4023 struct dasd_eckd_private *private; 4024 struct dasd_device *startdev; 4025 unsigned long flags; 4026 struct dasd_ccw_req *cqr; 4027 4028 startdev = dasd_alias_get_start_dev(base); 4029 if (!startdev) 4030 startdev = base; 4031 private = startdev->private; 4032 if (private->count >= DASD_ECKD_CHANQ_MAX_SIZE) 4033 return ERR_PTR(-EBUSY); 4034 4035 spin_lock_irqsave(get_ccwdev_lock(startdev->cdev), flags); 4036 private->count++; 4037 if ((base->features & DASD_FEATURE_USERAW)) 4038 cqr = dasd_eckd_build_cp_raw(startdev, block, req); 4039 else 4040 cqr = dasd_eckd_build_cp(startdev, block, req); 4041 if (IS_ERR(cqr)) 4042 private->count--; 4043 spin_unlock_irqrestore(get_ccwdev_lock(startdev->cdev), flags); 4044 return cqr; 4045 } 4046 4047 static int dasd_eckd_free_alias_cp(struct dasd_ccw_req *cqr, 4048 struct request *req) 4049 { 4050 struct dasd_eckd_private *private; 4051 unsigned long flags; 4052 4053 spin_lock_irqsave(get_ccwdev_lock(cqr->memdev->cdev), flags); 4054 private = cqr->memdev->private; 4055 private->count--; 4056 spin_unlock_irqrestore(get_ccwdev_lock(cqr->memdev->cdev), flags); 4057 return dasd_eckd_free_cp(cqr, req); 4058 } 4059 4060 static int 4061 dasd_eckd_fill_info(struct dasd_device * device, 4062 struct dasd_information2_t * info) 4063 { 4064 struct dasd_eckd_private *private = device->private; 4065 4066 info->label_block = 2; 4067 info->FBA_layout = private->uses_cdl ? 0 : 1; 4068 info->format = private->uses_cdl ? DASD_FORMAT_CDL : DASD_FORMAT_LDL; 4069 info->characteristics_size = sizeof(private->rdc_data); 4070 memcpy(info->characteristics, &private->rdc_data, 4071 sizeof(private->rdc_data)); 4072 info->confdata_size = min((unsigned long)private->conf_len, 4073 sizeof(info->configuration_data)); 4074 memcpy(info->configuration_data, private->conf_data, 4075 info->confdata_size); 4076 return 0; 4077 } 4078 4079 /* 4080 * SECTION: ioctl functions for eckd devices. 4081 */ 4082 4083 /* 4084 * Release device ioctl. 4085 * Buils a channel programm to releases a prior reserved 4086 * (see dasd_eckd_reserve) device. 4087 */ 4088 static int 4089 dasd_eckd_release(struct dasd_device *device) 4090 { 4091 struct dasd_ccw_req *cqr; 4092 int rc; 4093 struct ccw1 *ccw; 4094 int useglobal; 4095 4096 if (!capable(CAP_SYS_ADMIN)) 4097 return -EACCES; 4098 4099 useglobal = 0; 4100 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device); 4101 if (IS_ERR(cqr)) { 4102 mutex_lock(&dasd_reserve_mutex); 4103 useglobal = 1; 4104 cqr = &dasd_reserve_req->cqr; 4105 memset(cqr, 0, sizeof(*cqr)); 4106 memset(&dasd_reserve_req->ccw, 0, 4107 sizeof(dasd_reserve_req->ccw)); 4108 cqr->cpaddr = &dasd_reserve_req->ccw; 4109 cqr->data = &dasd_reserve_req->data; 4110 cqr->magic = DASD_ECKD_MAGIC; 4111 } 4112 ccw = cqr->cpaddr; 4113 ccw->cmd_code = DASD_ECKD_CCW_RELEASE; 4114 ccw->flags |= CCW_FLAG_SLI; 4115 ccw->count = 32; 4116 ccw->cda = (__u32)(addr_t) cqr->data; 4117 cqr->startdev = device; 4118 cqr->memdev = device; 4119 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 4120 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 4121 cqr->retries = 2; /* set retry counter to enable basic ERP */ 4122 cqr->expires = 2 * HZ; 4123 cqr->buildclk = get_tod_clock(); 4124 cqr->status = DASD_CQR_FILLED; 4125 4126 rc = dasd_sleep_on_immediatly(cqr); 4127 if (!rc) 4128 clear_bit(DASD_FLAG_IS_RESERVED, &device->flags); 4129 4130 if (useglobal) 4131 mutex_unlock(&dasd_reserve_mutex); 4132 else 4133 dasd_sfree_request(cqr, cqr->memdev); 4134 return rc; 4135 } 4136 4137 /* 4138 * Reserve device ioctl. 4139 * Options are set to 'synchronous wait for interrupt' and 4140 * 'timeout the request'. This leads to a terminate IO if 4141 * the interrupt is outstanding for a certain time. 4142 */ 4143 static int 4144 dasd_eckd_reserve(struct dasd_device *device) 4145 { 4146 struct dasd_ccw_req *cqr; 4147 int rc; 4148 struct ccw1 *ccw; 4149 int useglobal; 4150 4151 if (!capable(CAP_SYS_ADMIN)) 4152 return -EACCES; 4153 4154 useglobal = 0; 4155 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device); 4156 if (IS_ERR(cqr)) { 4157 mutex_lock(&dasd_reserve_mutex); 4158 useglobal = 1; 4159 cqr = &dasd_reserve_req->cqr; 4160 memset(cqr, 0, sizeof(*cqr)); 4161 memset(&dasd_reserve_req->ccw, 0, 4162 sizeof(dasd_reserve_req->ccw)); 4163 cqr->cpaddr = &dasd_reserve_req->ccw; 4164 cqr->data = &dasd_reserve_req->data; 4165 cqr->magic = DASD_ECKD_MAGIC; 4166 } 4167 ccw = cqr->cpaddr; 4168 ccw->cmd_code = DASD_ECKD_CCW_RESERVE; 4169 ccw->flags |= CCW_FLAG_SLI; 4170 ccw->count = 32; 4171 ccw->cda = (__u32)(addr_t) cqr->data; 4172 cqr->startdev = device; 4173 cqr->memdev = device; 4174 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 4175 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 4176 cqr->retries = 2; /* set retry counter to enable basic ERP */ 4177 cqr->expires = 2 * HZ; 4178 cqr->buildclk = get_tod_clock(); 4179 cqr->status = DASD_CQR_FILLED; 4180 4181 rc = dasd_sleep_on_immediatly(cqr); 4182 if (!rc) 4183 set_bit(DASD_FLAG_IS_RESERVED, &device->flags); 4184 4185 if (useglobal) 4186 mutex_unlock(&dasd_reserve_mutex); 4187 else 4188 dasd_sfree_request(cqr, cqr->memdev); 4189 return rc; 4190 } 4191 4192 /* 4193 * Steal lock ioctl - unconditional reserve device. 4194 * Buils a channel programm to break a device's reservation. 4195 * (unconditional reserve) 4196 */ 4197 static int 4198 dasd_eckd_steal_lock(struct dasd_device *device) 4199 { 4200 struct dasd_ccw_req *cqr; 4201 int rc; 4202 struct ccw1 *ccw; 4203 int useglobal; 4204 4205 if (!capable(CAP_SYS_ADMIN)) 4206 return -EACCES; 4207 4208 useglobal = 0; 4209 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device); 4210 if (IS_ERR(cqr)) { 4211 mutex_lock(&dasd_reserve_mutex); 4212 useglobal = 1; 4213 cqr = &dasd_reserve_req->cqr; 4214 memset(cqr, 0, sizeof(*cqr)); 4215 memset(&dasd_reserve_req->ccw, 0, 4216 sizeof(dasd_reserve_req->ccw)); 4217 cqr->cpaddr = &dasd_reserve_req->ccw; 4218 cqr->data = &dasd_reserve_req->data; 4219 cqr->magic = DASD_ECKD_MAGIC; 4220 } 4221 ccw = cqr->cpaddr; 4222 ccw->cmd_code = DASD_ECKD_CCW_SLCK; 4223 ccw->flags |= CCW_FLAG_SLI; 4224 ccw->count = 32; 4225 ccw->cda = (__u32)(addr_t) cqr->data; 4226 cqr->startdev = device; 4227 cqr->memdev = device; 4228 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 4229 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 4230 cqr->retries = 2; /* set retry counter to enable basic ERP */ 4231 cqr->expires = 2 * HZ; 4232 cqr->buildclk = get_tod_clock(); 4233 cqr->status = DASD_CQR_FILLED; 4234 4235 rc = dasd_sleep_on_immediatly(cqr); 4236 if (!rc) 4237 set_bit(DASD_FLAG_IS_RESERVED, &device->flags); 4238 4239 if (useglobal) 4240 mutex_unlock(&dasd_reserve_mutex); 4241 else 4242 dasd_sfree_request(cqr, cqr->memdev); 4243 return rc; 4244 } 4245 4246 /* 4247 * SNID - Sense Path Group ID 4248 * This ioctl may be used in situations where I/O is stalled due to 4249 * a reserve, so if the normal dasd_smalloc_request fails, we use the 4250 * preallocated dasd_reserve_req. 4251 */ 4252 static int dasd_eckd_snid(struct dasd_device *device, 4253 void __user *argp) 4254 { 4255 struct dasd_ccw_req *cqr; 4256 int rc; 4257 struct ccw1 *ccw; 4258 int useglobal; 4259 struct dasd_snid_ioctl_data usrparm; 4260 4261 if (!capable(CAP_SYS_ADMIN)) 4262 return -EACCES; 4263 4264 if (copy_from_user(&usrparm, argp, sizeof(usrparm))) 4265 return -EFAULT; 4266 4267 useglobal = 0; 4268 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 4269 sizeof(struct dasd_snid_data), device); 4270 if (IS_ERR(cqr)) { 4271 mutex_lock(&dasd_reserve_mutex); 4272 useglobal = 1; 4273 cqr = &dasd_reserve_req->cqr; 4274 memset(cqr, 0, sizeof(*cqr)); 4275 memset(&dasd_reserve_req->ccw, 0, 4276 sizeof(dasd_reserve_req->ccw)); 4277 cqr->cpaddr = &dasd_reserve_req->ccw; 4278 cqr->data = &dasd_reserve_req->data; 4279 cqr->magic = DASD_ECKD_MAGIC; 4280 } 4281 ccw = cqr->cpaddr; 4282 ccw->cmd_code = DASD_ECKD_CCW_SNID; 4283 ccw->flags |= CCW_FLAG_SLI; 4284 ccw->count = 12; 4285 ccw->cda = (__u32)(addr_t) cqr->data; 4286 cqr->startdev = device; 4287 cqr->memdev = device; 4288 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 4289 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 4290 set_bit(DASD_CQR_ALLOW_SLOCK, &cqr->flags); 4291 cqr->retries = 5; 4292 cqr->expires = 10 * HZ; 4293 cqr->buildclk = get_tod_clock(); 4294 cqr->status = DASD_CQR_FILLED; 4295 cqr->lpm = usrparm.path_mask; 4296 4297 rc = dasd_sleep_on_immediatly(cqr); 4298 /* verify that I/O processing didn't modify the path mask */ 4299 if (!rc && usrparm.path_mask && (cqr->lpm != usrparm.path_mask)) 4300 rc = -EIO; 4301 if (!rc) { 4302 usrparm.data = *((struct dasd_snid_data *)cqr->data); 4303 if (copy_to_user(argp, &usrparm, sizeof(usrparm))) 4304 rc = -EFAULT; 4305 } 4306 4307 if (useglobal) 4308 mutex_unlock(&dasd_reserve_mutex); 4309 else 4310 dasd_sfree_request(cqr, cqr->memdev); 4311 return rc; 4312 } 4313 4314 /* 4315 * Read performance statistics 4316 */ 4317 static int 4318 dasd_eckd_performance(struct dasd_device *device, void __user *argp) 4319 { 4320 struct dasd_psf_prssd_data *prssdp; 4321 struct dasd_rssd_perf_stats_t *stats; 4322 struct dasd_ccw_req *cqr; 4323 struct ccw1 *ccw; 4324 int rc; 4325 4326 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */, 4327 (sizeof(struct dasd_psf_prssd_data) + 4328 sizeof(struct dasd_rssd_perf_stats_t)), 4329 device); 4330 if (IS_ERR(cqr)) { 4331 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 4332 "Could not allocate initialization request"); 4333 return PTR_ERR(cqr); 4334 } 4335 cqr->startdev = device; 4336 cqr->memdev = device; 4337 cqr->retries = 0; 4338 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 4339 cqr->expires = 10 * HZ; 4340 4341 /* Prepare for Read Subsystem Data */ 4342 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 4343 memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data)); 4344 prssdp->order = PSF_ORDER_PRSSD; 4345 prssdp->suborder = 0x01; /* Performance Statistics */ 4346 prssdp->varies[1] = 0x01; /* Perf Statistics for the Subsystem */ 4347 4348 ccw = cqr->cpaddr; 4349 ccw->cmd_code = DASD_ECKD_CCW_PSF; 4350 ccw->count = sizeof(struct dasd_psf_prssd_data); 4351 ccw->flags |= CCW_FLAG_CC; 4352 ccw->cda = (__u32)(addr_t) prssdp; 4353 4354 /* Read Subsystem Data - Performance Statistics */ 4355 stats = (struct dasd_rssd_perf_stats_t *) (prssdp + 1); 4356 memset(stats, 0, sizeof(struct dasd_rssd_perf_stats_t)); 4357 4358 ccw++; 4359 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 4360 ccw->count = sizeof(struct dasd_rssd_perf_stats_t); 4361 ccw->cda = (__u32)(addr_t) stats; 4362 4363 cqr->buildclk = get_tod_clock(); 4364 cqr->status = DASD_CQR_FILLED; 4365 rc = dasd_sleep_on(cqr); 4366 if (rc == 0) { 4367 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 4368 stats = (struct dasd_rssd_perf_stats_t *) (prssdp + 1); 4369 if (copy_to_user(argp, stats, 4370 sizeof(struct dasd_rssd_perf_stats_t))) 4371 rc = -EFAULT; 4372 } 4373 dasd_sfree_request(cqr, cqr->memdev); 4374 return rc; 4375 } 4376 4377 /* 4378 * Get attributes (cache operations) 4379 * Returnes the cache attributes used in Define Extend (DE). 4380 */ 4381 static int 4382 dasd_eckd_get_attrib(struct dasd_device *device, void __user *argp) 4383 { 4384 struct dasd_eckd_private *private = device->private; 4385 struct attrib_data_t attrib = private->attrib; 4386 int rc; 4387 4388 if (!capable(CAP_SYS_ADMIN)) 4389 return -EACCES; 4390 if (!argp) 4391 return -EINVAL; 4392 4393 rc = 0; 4394 if (copy_to_user(argp, (long *) &attrib, 4395 sizeof(struct attrib_data_t))) 4396 rc = -EFAULT; 4397 4398 return rc; 4399 } 4400 4401 /* 4402 * Set attributes (cache operations) 4403 * Stores the attributes for cache operation to be used in Define Extend (DE). 4404 */ 4405 static int 4406 dasd_eckd_set_attrib(struct dasd_device *device, void __user *argp) 4407 { 4408 struct dasd_eckd_private *private = device->private; 4409 struct attrib_data_t attrib; 4410 4411 if (!capable(CAP_SYS_ADMIN)) 4412 return -EACCES; 4413 if (!argp) 4414 return -EINVAL; 4415 4416 if (copy_from_user(&attrib, argp, sizeof(struct attrib_data_t))) 4417 return -EFAULT; 4418 private->attrib = attrib; 4419 4420 dev_info(&device->cdev->dev, 4421 "The DASD cache mode was set to %x (%i cylinder prestage)\n", 4422 private->attrib.operation, private->attrib.nr_cyl); 4423 return 0; 4424 } 4425 4426 /* 4427 * Issue syscall I/O to EMC Symmetrix array. 4428 * CCWs are PSF and RSSD 4429 */ 4430 static int dasd_symm_io(struct dasd_device *device, void __user *argp) 4431 { 4432 struct dasd_symmio_parms usrparm; 4433 char *psf_data, *rssd_result; 4434 struct dasd_ccw_req *cqr; 4435 struct ccw1 *ccw; 4436 char psf0, psf1; 4437 int rc; 4438 4439 if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO)) 4440 return -EACCES; 4441 psf0 = psf1 = 0; 4442 4443 /* Copy parms from caller */ 4444 rc = -EFAULT; 4445 if (copy_from_user(&usrparm, argp, sizeof(usrparm))) 4446 goto out; 4447 if (is_compat_task()) { 4448 /* Make sure pointers are sane even on 31 bit. */ 4449 rc = -EINVAL; 4450 if ((usrparm.psf_data >> 32) != 0) 4451 goto out; 4452 if ((usrparm.rssd_result >> 32) != 0) 4453 goto out; 4454 usrparm.psf_data &= 0x7fffffffULL; 4455 usrparm.rssd_result &= 0x7fffffffULL; 4456 } 4457 /* alloc I/O data area */ 4458 psf_data = kzalloc(usrparm.psf_data_len, GFP_KERNEL | GFP_DMA); 4459 rssd_result = kzalloc(usrparm.rssd_result_len, GFP_KERNEL | GFP_DMA); 4460 if (!psf_data || !rssd_result) { 4461 rc = -ENOMEM; 4462 goto out_free; 4463 } 4464 4465 /* get syscall header from user space */ 4466 rc = -EFAULT; 4467 if (copy_from_user(psf_data, 4468 (void __user *)(unsigned long) usrparm.psf_data, 4469 usrparm.psf_data_len)) 4470 goto out_free; 4471 psf0 = psf_data[0]; 4472 psf1 = psf_data[1]; 4473 4474 /* setup CCWs for PSF + RSSD */ 4475 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 2 , 0, device); 4476 if (IS_ERR(cqr)) { 4477 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 4478 "Could not allocate initialization request"); 4479 rc = PTR_ERR(cqr); 4480 goto out_free; 4481 } 4482 4483 cqr->startdev = device; 4484 cqr->memdev = device; 4485 cqr->retries = 3; 4486 cqr->expires = 10 * HZ; 4487 cqr->buildclk = get_tod_clock(); 4488 cqr->status = DASD_CQR_FILLED; 4489 4490 /* Build the ccws */ 4491 ccw = cqr->cpaddr; 4492 4493 /* PSF ccw */ 4494 ccw->cmd_code = DASD_ECKD_CCW_PSF; 4495 ccw->count = usrparm.psf_data_len; 4496 ccw->flags |= CCW_FLAG_CC; 4497 ccw->cda = (__u32)(addr_t) psf_data; 4498 4499 ccw++; 4500 4501 /* RSSD ccw */ 4502 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 4503 ccw->count = usrparm.rssd_result_len; 4504 ccw->flags = CCW_FLAG_SLI ; 4505 ccw->cda = (__u32)(addr_t) rssd_result; 4506 4507 rc = dasd_sleep_on(cqr); 4508 if (rc) 4509 goto out_sfree; 4510 4511 rc = -EFAULT; 4512 if (copy_to_user((void __user *)(unsigned long) usrparm.rssd_result, 4513 rssd_result, usrparm.rssd_result_len)) 4514 goto out_sfree; 4515 rc = 0; 4516 4517 out_sfree: 4518 dasd_sfree_request(cqr, cqr->memdev); 4519 out_free: 4520 kfree(rssd_result); 4521 kfree(psf_data); 4522 out: 4523 DBF_DEV_EVENT(DBF_WARNING, device, 4524 "Symmetrix ioctl (0x%02x 0x%02x): rc=%d", 4525 (int) psf0, (int) psf1, rc); 4526 return rc; 4527 } 4528 4529 static int 4530 dasd_eckd_ioctl(struct dasd_block *block, unsigned int cmd, void __user *argp) 4531 { 4532 struct dasd_device *device = block->base; 4533 4534 switch (cmd) { 4535 case BIODASDGATTR: 4536 return dasd_eckd_get_attrib(device, argp); 4537 case BIODASDSATTR: 4538 return dasd_eckd_set_attrib(device, argp); 4539 case BIODASDPSRD: 4540 return dasd_eckd_performance(device, argp); 4541 case BIODASDRLSE: 4542 return dasd_eckd_release(device); 4543 case BIODASDRSRV: 4544 return dasd_eckd_reserve(device); 4545 case BIODASDSLCK: 4546 return dasd_eckd_steal_lock(device); 4547 case BIODASDSNID: 4548 return dasd_eckd_snid(device, argp); 4549 case BIODASDSYMMIO: 4550 return dasd_symm_io(device, argp); 4551 default: 4552 return -ENOTTY; 4553 } 4554 } 4555 4556 /* 4557 * Dump the range of CCWs into 'page' buffer 4558 * and return number of printed chars. 4559 */ 4560 static int 4561 dasd_eckd_dump_ccw_range(struct ccw1 *from, struct ccw1 *to, char *page) 4562 { 4563 int len, count; 4564 char *datap; 4565 4566 len = 0; 4567 while (from <= to) { 4568 len += sprintf(page + len, PRINTK_HEADER 4569 " CCW %p: %08X %08X DAT:", 4570 from, ((int *) from)[0], ((int *) from)[1]); 4571 4572 /* get pointer to data (consider IDALs) */ 4573 if (from->flags & CCW_FLAG_IDA) 4574 datap = (char *) *((addr_t *) (addr_t) from->cda); 4575 else 4576 datap = (char *) ((addr_t) from->cda); 4577 4578 /* dump data (max 32 bytes) */ 4579 for (count = 0; count < from->count && count < 32; count++) { 4580 if (count % 8 == 0) len += sprintf(page + len, " "); 4581 if (count % 4 == 0) len += sprintf(page + len, " "); 4582 len += sprintf(page + len, "%02x", datap[count]); 4583 } 4584 len += sprintf(page + len, "\n"); 4585 from++; 4586 } 4587 return len; 4588 } 4589 4590 static void 4591 dasd_eckd_dump_sense_dbf(struct dasd_device *device, struct irb *irb, 4592 char *reason) 4593 { 4594 u64 *sense; 4595 u64 *stat; 4596 4597 sense = (u64 *) dasd_get_sense(irb); 4598 stat = (u64 *) &irb->scsw; 4599 if (sense) { 4600 DBF_DEV_EVENT(DBF_EMERG, device, "%s: %016llx %08x : " 4601 "%016llx %016llx %016llx %016llx", 4602 reason, *stat, *((u32 *) (stat + 1)), 4603 sense[0], sense[1], sense[2], sense[3]); 4604 } else { 4605 DBF_DEV_EVENT(DBF_EMERG, device, "%s: %016llx %08x : %s", 4606 reason, *stat, *((u32 *) (stat + 1)), 4607 "NO VALID SENSE"); 4608 } 4609 } 4610 4611 /* 4612 * Print sense data and related channel program. 4613 * Parts are printed because printk buffer is only 1024 bytes. 4614 */ 4615 static void dasd_eckd_dump_sense_ccw(struct dasd_device *device, 4616 struct dasd_ccw_req *req, struct irb *irb) 4617 { 4618 char *page; 4619 struct ccw1 *first, *last, *fail, *from, *to; 4620 int len, sl, sct; 4621 4622 page = (char *) get_zeroed_page(GFP_ATOMIC); 4623 if (page == NULL) { 4624 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 4625 "No memory to dump sense data\n"); 4626 return; 4627 } 4628 /* dump the sense data */ 4629 len = sprintf(page, PRINTK_HEADER 4630 " I/O status report for device %s:\n", 4631 dev_name(&device->cdev->dev)); 4632 len += sprintf(page + len, PRINTK_HEADER 4633 " in req: %p CC:%02X FC:%02X AC:%02X SC:%02X DS:%02X " 4634 "CS:%02X RC:%d\n", 4635 req, scsw_cc(&irb->scsw), scsw_fctl(&irb->scsw), 4636 scsw_actl(&irb->scsw), scsw_stctl(&irb->scsw), 4637 scsw_dstat(&irb->scsw), scsw_cstat(&irb->scsw), 4638 req ? req->intrc : 0); 4639 len += sprintf(page + len, PRINTK_HEADER 4640 " device %s: Failing CCW: %p\n", 4641 dev_name(&device->cdev->dev), 4642 (void *) (addr_t) irb->scsw.cmd.cpa); 4643 if (irb->esw.esw0.erw.cons) { 4644 for (sl = 0; sl < 4; sl++) { 4645 len += sprintf(page + len, PRINTK_HEADER 4646 " Sense(hex) %2d-%2d:", 4647 (8 * sl), ((8 * sl) + 7)); 4648 4649 for (sct = 0; sct < 8; sct++) { 4650 len += sprintf(page + len, " %02x", 4651 irb->ecw[8 * sl + sct]); 4652 } 4653 len += sprintf(page + len, "\n"); 4654 } 4655 4656 if (irb->ecw[27] & DASD_SENSE_BIT_0) { 4657 /* 24 Byte Sense Data */ 4658 sprintf(page + len, PRINTK_HEADER 4659 " 24 Byte: %x MSG %x, " 4660 "%s MSGb to SYSOP\n", 4661 irb->ecw[7] >> 4, irb->ecw[7] & 0x0f, 4662 irb->ecw[1] & 0x10 ? "" : "no"); 4663 } else { 4664 /* 32 Byte Sense Data */ 4665 sprintf(page + len, PRINTK_HEADER 4666 " 32 Byte: Format: %x " 4667 "Exception class %x\n", 4668 irb->ecw[6] & 0x0f, irb->ecw[22] >> 4); 4669 } 4670 } else { 4671 sprintf(page + len, PRINTK_HEADER 4672 " SORRY - NO VALID SENSE AVAILABLE\n"); 4673 } 4674 printk(KERN_ERR "%s", page); 4675 4676 if (req) { 4677 /* req == NULL for unsolicited interrupts */ 4678 /* dump the Channel Program (max 140 Bytes per line) */ 4679 /* Count CCW and print first CCWs (maximum 1024 % 140 = 7) */ 4680 first = req->cpaddr; 4681 for (last = first; last->flags & (CCW_FLAG_CC | CCW_FLAG_DC); last++); 4682 to = min(first + 6, last); 4683 len = sprintf(page, PRINTK_HEADER 4684 " Related CP in req: %p\n", req); 4685 dasd_eckd_dump_ccw_range(first, to, page + len); 4686 printk(KERN_ERR "%s", page); 4687 4688 /* print failing CCW area (maximum 4) */ 4689 /* scsw->cda is either valid or zero */ 4690 len = 0; 4691 from = ++to; 4692 fail = (struct ccw1 *)(addr_t) 4693 irb->scsw.cmd.cpa; /* failing CCW */ 4694 if (from < fail - 2) { 4695 from = fail - 2; /* there is a gap - print header */ 4696 len += sprintf(page, PRINTK_HEADER "......\n"); 4697 } 4698 to = min(fail + 1, last); 4699 len += dasd_eckd_dump_ccw_range(from, to, page + len); 4700 4701 /* print last CCWs (maximum 2) */ 4702 from = max(from, ++to); 4703 if (from < last - 1) { 4704 from = last - 1; /* there is a gap - print header */ 4705 len += sprintf(page + len, PRINTK_HEADER "......\n"); 4706 } 4707 len += dasd_eckd_dump_ccw_range(from, last, page + len); 4708 if (len > 0) 4709 printk(KERN_ERR "%s", page); 4710 } 4711 free_page((unsigned long) page); 4712 } 4713 4714 4715 /* 4716 * Print sense data from a tcw. 4717 */ 4718 static void dasd_eckd_dump_sense_tcw(struct dasd_device *device, 4719 struct dasd_ccw_req *req, struct irb *irb) 4720 { 4721 char *page; 4722 int len, sl, sct, residual; 4723 struct tsb *tsb; 4724 u8 *sense, *rcq; 4725 4726 page = (char *) get_zeroed_page(GFP_ATOMIC); 4727 if (page == NULL) { 4728 DBF_DEV_EVENT(DBF_WARNING, device, " %s", 4729 "No memory to dump sense data"); 4730 return; 4731 } 4732 /* dump the sense data */ 4733 len = sprintf(page, PRINTK_HEADER 4734 " I/O status report for device %s:\n", 4735 dev_name(&device->cdev->dev)); 4736 len += sprintf(page + len, PRINTK_HEADER 4737 " in req: %p CC:%02X FC:%02X AC:%02X SC:%02X DS:%02X " 4738 "CS:%02X fcxs:%02X schxs:%02X RC:%d\n", 4739 req, scsw_cc(&irb->scsw), scsw_fctl(&irb->scsw), 4740 scsw_actl(&irb->scsw), scsw_stctl(&irb->scsw), 4741 scsw_dstat(&irb->scsw), scsw_cstat(&irb->scsw), 4742 irb->scsw.tm.fcxs, 4743 (irb->scsw.tm.ifob << 7) | irb->scsw.tm.sesq, 4744 req ? req->intrc : 0); 4745 len += sprintf(page + len, PRINTK_HEADER 4746 " device %s: Failing TCW: %p\n", 4747 dev_name(&device->cdev->dev), 4748 (void *) (addr_t) irb->scsw.tm.tcw); 4749 4750 tsb = NULL; 4751 sense = NULL; 4752 if (irb->scsw.tm.tcw && (irb->scsw.tm.fcxs & 0x01)) 4753 tsb = tcw_get_tsb( 4754 (struct tcw *)(unsigned long)irb->scsw.tm.tcw); 4755 4756 if (tsb) { 4757 len += sprintf(page + len, PRINTK_HEADER 4758 " tsb->length %d\n", tsb->length); 4759 len += sprintf(page + len, PRINTK_HEADER 4760 " tsb->flags %x\n", tsb->flags); 4761 len += sprintf(page + len, PRINTK_HEADER 4762 " tsb->dcw_offset %d\n", tsb->dcw_offset); 4763 len += sprintf(page + len, PRINTK_HEADER 4764 " tsb->count %d\n", tsb->count); 4765 residual = tsb->count - 28; 4766 len += sprintf(page + len, PRINTK_HEADER 4767 " residual %d\n", residual); 4768 4769 switch (tsb->flags & 0x07) { 4770 case 1: /* tsa_iostat */ 4771 len += sprintf(page + len, PRINTK_HEADER 4772 " tsb->tsa.iostat.dev_time %d\n", 4773 tsb->tsa.iostat.dev_time); 4774 len += sprintf(page + len, PRINTK_HEADER 4775 " tsb->tsa.iostat.def_time %d\n", 4776 tsb->tsa.iostat.def_time); 4777 len += sprintf(page + len, PRINTK_HEADER 4778 " tsb->tsa.iostat.queue_time %d\n", 4779 tsb->tsa.iostat.queue_time); 4780 len += sprintf(page + len, PRINTK_HEADER 4781 " tsb->tsa.iostat.dev_busy_time %d\n", 4782 tsb->tsa.iostat.dev_busy_time); 4783 len += sprintf(page + len, PRINTK_HEADER 4784 " tsb->tsa.iostat.dev_act_time %d\n", 4785 tsb->tsa.iostat.dev_act_time); 4786 sense = tsb->tsa.iostat.sense; 4787 break; 4788 case 2: /* ts_ddpc */ 4789 len += sprintf(page + len, PRINTK_HEADER 4790 " tsb->tsa.ddpc.rc %d\n", tsb->tsa.ddpc.rc); 4791 for (sl = 0; sl < 2; sl++) { 4792 len += sprintf(page + len, PRINTK_HEADER 4793 " tsb->tsa.ddpc.rcq %2d-%2d: ", 4794 (8 * sl), ((8 * sl) + 7)); 4795 rcq = tsb->tsa.ddpc.rcq; 4796 for (sct = 0; sct < 8; sct++) { 4797 len += sprintf(page + len, " %02x", 4798 rcq[8 * sl + sct]); 4799 } 4800 len += sprintf(page + len, "\n"); 4801 } 4802 sense = tsb->tsa.ddpc.sense; 4803 break; 4804 case 3: /* tsa_intrg */ 4805 len += sprintf(page + len, PRINTK_HEADER 4806 " tsb->tsa.intrg.: not supported yet\n"); 4807 break; 4808 } 4809 4810 if (sense) { 4811 for (sl = 0; sl < 4; sl++) { 4812 len += sprintf(page + len, PRINTK_HEADER 4813 " Sense(hex) %2d-%2d:", 4814 (8 * sl), ((8 * sl) + 7)); 4815 for (sct = 0; sct < 8; sct++) { 4816 len += sprintf(page + len, " %02x", 4817 sense[8 * sl + sct]); 4818 } 4819 len += sprintf(page + len, "\n"); 4820 } 4821 4822 if (sense[27] & DASD_SENSE_BIT_0) { 4823 /* 24 Byte Sense Data */ 4824 sprintf(page + len, PRINTK_HEADER 4825 " 24 Byte: %x MSG %x, " 4826 "%s MSGb to SYSOP\n", 4827 sense[7] >> 4, sense[7] & 0x0f, 4828 sense[1] & 0x10 ? "" : "no"); 4829 } else { 4830 /* 32 Byte Sense Data */ 4831 sprintf(page + len, PRINTK_HEADER 4832 " 32 Byte: Format: %x " 4833 "Exception class %x\n", 4834 sense[6] & 0x0f, sense[22] >> 4); 4835 } 4836 } else { 4837 sprintf(page + len, PRINTK_HEADER 4838 " SORRY - NO VALID SENSE AVAILABLE\n"); 4839 } 4840 } else { 4841 sprintf(page + len, PRINTK_HEADER 4842 " SORRY - NO TSB DATA AVAILABLE\n"); 4843 } 4844 printk(KERN_ERR "%s", page); 4845 free_page((unsigned long) page); 4846 } 4847 4848 static void dasd_eckd_dump_sense(struct dasd_device *device, 4849 struct dasd_ccw_req *req, struct irb *irb) 4850 { 4851 u8 *sense = dasd_get_sense(irb); 4852 4853 if (scsw_is_tm(&irb->scsw)) { 4854 /* 4855 * In some cases the 'File Protected' or 'Incorrect Length' 4856 * error might be expected and log messages shouldn't be written 4857 * then. Check if the according suppress bit is set. 4858 */ 4859 if (sense && (sense[1] & SNS1_FILE_PROTECTED) && 4860 test_bit(DASD_CQR_SUPPRESS_FP, &req->flags)) 4861 return; 4862 if (scsw_cstat(&irb->scsw) == 0x40 && 4863 test_bit(DASD_CQR_SUPPRESS_IL, &req->flags)) 4864 return; 4865 4866 dasd_eckd_dump_sense_tcw(device, req, irb); 4867 } else { 4868 /* 4869 * In some cases the 'Command Reject' or 'No Record Found' 4870 * error might be expected and log messages shouldn't be 4871 * written then. Check if the according suppress bit is set. 4872 */ 4873 if (sense && sense[0] & SNS0_CMD_REJECT && 4874 test_bit(DASD_CQR_SUPPRESS_CR, &req->flags)) 4875 return; 4876 4877 if (sense && sense[1] & SNS1_NO_REC_FOUND && 4878 test_bit(DASD_CQR_SUPPRESS_NRF, &req->flags)) 4879 return; 4880 4881 dasd_eckd_dump_sense_ccw(device, req, irb); 4882 } 4883 } 4884 4885 static int dasd_eckd_pm_freeze(struct dasd_device *device) 4886 { 4887 /* 4888 * the device should be disconnected from our LCU structure 4889 * on restore we will reconnect it and reread LCU specific 4890 * information like PAV support that might have changed 4891 */ 4892 dasd_alias_remove_device(device); 4893 dasd_alias_disconnect_device_from_lcu(device); 4894 4895 return 0; 4896 } 4897 4898 static int dasd_eckd_restore_device(struct dasd_device *device) 4899 { 4900 struct dasd_eckd_private *private = device->private; 4901 struct dasd_eckd_characteristics temp_rdc_data; 4902 int rc; 4903 struct dasd_uid temp_uid; 4904 unsigned long flags; 4905 unsigned long cqr_flags = 0; 4906 4907 /* Read Configuration Data */ 4908 rc = dasd_eckd_read_conf(device); 4909 if (rc) { 4910 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 4911 "Read configuration data failed, rc=%d", rc); 4912 goto out_err; 4913 } 4914 4915 dasd_eckd_get_uid(device, &temp_uid); 4916 /* Generate device unique id */ 4917 rc = dasd_eckd_generate_uid(device); 4918 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 4919 if (memcmp(&private->uid, &temp_uid, sizeof(struct dasd_uid)) != 0) 4920 dev_err(&device->cdev->dev, "The UID of the DASD has " 4921 "changed\n"); 4922 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 4923 if (rc) 4924 goto out_err; 4925 4926 /* register lcu with alias handling, enable PAV if this is a new lcu */ 4927 rc = dasd_alias_make_device_known_to_lcu(device); 4928 if (rc) 4929 goto out_err; 4930 4931 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr_flags); 4932 dasd_eckd_validate_server(device, cqr_flags); 4933 4934 /* RE-Read Configuration Data */ 4935 rc = dasd_eckd_read_conf(device); 4936 if (rc) { 4937 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 4938 "Read configuration data failed, rc=%d", rc); 4939 goto out_err2; 4940 } 4941 4942 /* Read Feature Codes */ 4943 dasd_eckd_read_features(device); 4944 4945 /* Read Device Characteristics */ 4946 rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC, 4947 &temp_rdc_data, 64); 4948 if (rc) { 4949 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 4950 "Read device characteristic failed, rc=%d", rc); 4951 goto out_err2; 4952 } 4953 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 4954 memcpy(&private->rdc_data, &temp_rdc_data, sizeof(temp_rdc_data)); 4955 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 4956 4957 /* add device to alias management */ 4958 dasd_alias_add_device(device); 4959 4960 return 0; 4961 4962 out_err2: 4963 dasd_alias_disconnect_device_from_lcu(device); 4964 out_err: 4965 return -1; 4966 } 4967 4968 static int dasd_eckd_reload_device(struct dasd_device *device) 4969 { 4970 struct dasd_eckd_private *private = device->private; 4971 int rc, old_base; 4972 char print_uid[60]; 4973 struct dasd_uid uid; 4974 unsigned long flags; 4975 4976 /* 4977 * remove device from alias handling to prevent new requests 4978 * from being scheduled on the wrong alias device 4979 */ 4980 dasd_alias_remove_device(device); 4981 4982 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 4983 old_base = private->uid.base_unit_addr; 4984 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 4985 4986 /* Read Configuration Data */ 4987 rc = dasd_eckd_read_conf(device); 4988 if (rc) 4989 goto out_err; 4990 4991 rc = dasd_eckd_generate_uid(device); 4992 if (rc) 4993 goto out_err; 4994 /* 4995 * update unit address configuration and 4996 * add device to alias management 4997 */ 4998 dasd_alias_update_add_device(device); 4999 5000 dasd_eckd_get_uid(device, &uid); 5001 5002 if (old_base != uid.base_unit_addr) { 5003 if (strlen(uid.vduit) > 0) 5004 snprintf(print_uid, sizeof(print_uid), 5005 "%s.%s.%04x.%02x.%s", uid.vendor, uid.serial, 5006 uid.ssid, uid.base_unit_addr, uid.vduit); 5007 else 5008 snprintf(print_uid, sizeof(print_uid), 5009 "%s.%s.%04x.%02x", uid.vendor, uid.serial, 5010 uid.ssid, uid.base_unit_addr); 5011 5012 dev_info(&device->cdev->dev, 5013 "An Alias device was reassigned to a new base device " 5014 "with UID: %s\n", print_uid); 5015 } 5016 return 0; 5017 5018 out_err: 5019 return -1; 5020 } 5021 5022 static int dasd_eckd_read_message_buffer(struct dasd_device *device, 5023 struct dasd_rssd_messages *messages, 5024 __u8 lpum) 5025 { 5026 struct dasd_rssd_messages *message_buf; 5027 struct dasd_psf_prssd_data *prssdp; 5028 struct dasd_ccw_req *cqr; 5029 struct ccw1 *ccw; 5030 int rc; 5031 5032 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */, 5033 (sizeof(struct dasd_psf_prssd_data) + 5034 sizeof(struct dasd_rssd_messages)), 5035 device); 5036 if (IS_ERR(cqr)) { 5037 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 5038 "Could not allocate read message buffer request"); 5039 return PTR_ERR(cqr); 5040 } 5041 5042 cqr->lpm = lpum; 5043 retry: 5044 cqr->startdev = device; 5045 cqr->memdev = device; 5046 cqr->block = NULL; 5047 cqr->expires = 10 * HZ; 5048 set_bit(DASD_CQR_VERIFY_PATH, &cqr->flags); 5049 /* dasd_sleep_on_immediatly does not do complex error 5050 * recovery so clear erp flag and set retry counter to 5051 * do basic erp */ 5052 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 5053 cqr->retries = 256; 5054 5055 /* Prepare for Read Subsystem Data */ 5056 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 5057 memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data)); 5058 prssdp->order = PSF_ORDER_PRSSD; 5059 prssdp->suborder = 0x03; /* Message Buffer */ 5060 /* all other bytes of prssdp must be zero */ 5061 5062 ccw = cqr->cpaddr; 5063 ccw->cmd_code = DASD_ECKD_CCW_PSF; 5064 ccw->count = sizeof(struct dasd_psf_prssd_data); 5065 ccw->flags |= CCW_FLAG_CC; 5066 ccw->flags |= CCW_FLAG_SLI; 5067 ccw->cda = (__u32)(addr_t) prssdp; 5068 5069 /* Read Subsystem Data - message buffer */ 5070 message_buf = (struct dasd_rssd_messages *) (prssdp + 1); 5071 memset(message_buf, 0, sizeof(struct dasd_rssd_messages)); 5072 5073 ccw++; 5074 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 5075 ccw->count = sizeof(struct dasd_rssd_messages); 5076 ccw->flags |= CCW_FLAG_SLI; 5077 ccw->cda = (__u32)(addr_t) message_buf; 5078 5079 cqr->buildclk = get_tod_clock(); 5080 cqr->status = DASD_CQR_FILLED; 5081 rc = dasd_sleep_on_immediatly(cqr); 5082 if (rc == 0) { 5083 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 5084 message_buf = (struct dasd_rssd_messages *) 5085 (prssdp + 1); 5086 memcpy(messages, message_buf, 5087 sizeof(struct dasd_rssd_messages)); 5088 } else if (cqr->lpm) { 5089 /* 5090 * on z/VM we might not be able to do I/O on the requested path 5091 * but instead we get the required information on any path 5092 * so retry with open path mask 5093 */ 5094 cqr->lpm = 0; 5095 goto retry; 5096 } else 5097 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 5098 "Reading messages failed with rc=%d\n" 5099 , rc); 5100 dasd_sfree_request(cqr, cqr->memdev); 5101 return rc; 5102 } 5103 5104 static int dasd_eckd_query_host_access(struct dasd_device *device, 5105 struct dasd_psf_query_host_access *data) 5106 { 5107 struct dasd_eckd_private *private = device->private; 5108 struct dasd_psf_query_host_access *host_access; 5109 struct dasd_psf_prssd_data *prssdp; 5110 struct dasd_ccw_req *cqr; 5111 struct ccw1 *ccw; 5112 int rc; 5113 5114 /* not available for HYPER PAV alias devices */ 5115 if (!device->block && private->lcu->pav == HYPER_PAV) 5116 return -EOPNOTSUPP; 5117 5118 /* may not be supported by the storage server */ 5119 if (!(private->features.feature[14] & 0x80)) 5120 return -EOPNOTSUPP; 5121 5122 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */, 5123 sizeof(struct dasd_psf_prssd_data) + 1, 5124 device); 5125 if (IS_ERR(cqr)) { 5126 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 5127 "Could not allocate read message buffer request"); 5128 return PTR_ERR(cqr); 5129 } 5130 host_access = kzalloc(sizeof(*host_access), GFP_KERNEL | GFP_DMA); 5131 if (!host_access) { 5132 dasd_sfree_request(cqr, device); 5133 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 5134 "Could not allocate host_access buffer"); 5135 return -ENOMEM; 5136 } 5137 cqr->startdev = device; 5138 cqr->memdev = device; 5139 cqr->block = NULL; 5140 cqr->retries = 256; 5141 cqr->expires = 10 * HZ; 5142 5143 /* Prepare for Read Subsystem Data */ 5144 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 5145 memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data)); 5146 prssdp->order = PSF_ORDER_PRSSD; 5147 prssdp->suborder = PSF_SUBORDER_QHA; /* query host access */ 5148 /* LSS and Volume that will be queried */ 5149 prssdp->lss = private->ned->ID; 5150 prssdp->volume = private->ned->unit_addr; 5151 /* all other bytes of prssdp must be zero */ 5152 5153 ccw = cqr->cpaddr; 5154 ccw->cmd_code = DASD_ECKD_CCW_PSF; 5155 ccw->count = sizeof(struct dasd_psf_prssd_data); 5156 ccw->flags |= CCW_FLAG_CC; 5157 ccw->flags |= CCW_FLAG_SLI; 5158 ccw->cda = (__u32)(addr_t) prssdp; 5159 5160 /* Read Subsystem Data - query host access */ 5161 ccw++; 5162 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 5163 ccw->count = sizeof(struct dasd_psf_query_host_access); 5164 ccw->flags |= CCW_FLAG_SLI; 5165 ccw->cda = (__u32)(addr_t) host_access; 5166 5167 cqr->buildclk = get_tod_clock(); 5168 cqr->status = DASD_CQR_FILLED; 5169 /* the command might not be supported, suppress error message */ 5170 __set_bit(DASD_CQR_SUPPRESS_CR, &cqr->flags); 5171 rc = dasd_sleep_on_interruptible(cqr); 5172 if (rc == 0) { 5173 *data = *host_access; 5174 } else { 5175 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, 5176 "Reading host access data failed with rc=%d\n", 5177 rc); 5178 rc = -EOPNOTSUPP; 5179 } 5180 5181 dasd_sfree_request(cqr, cqr->memdev); 5182 kfree(host_access); 5183 return rc; 5184 } 5185 /* 5186 * return number of grouped devices 5187 */ 5188 static int dasd_eckd_host_access_count(struct dasd_device *device) 5189 { 5190 struct dasd_psf_query_host_access *access; 5191 struct dasd_ckd_path_group_entry *entry; 5192 struct dasd_ckd_host_information *info; 5193 int count = 0; 5194 int rc, i; 5195 5196 access = kzalloc(sizeof(*access), GFP_NOIO); 5197 if (!access) { 5198 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 5199 "Could not allocate access buffer"); 5200 return -ENOMEM; 5201 } 5202 rc = dasd_eckd_query_host_access(device, access); 5203 if (rc) { 5204 kfree(access); 5205 return rc; 5206 } 5207 5208 info = (struct dasd_ckd_host_information *) 5209 access->host_access_information; 5210 for (i = 0; i < info->entry_count; i++) { 5211 entry = (struct dasd_ckd_path_group_entry *) 5212 (info->entry + i * info->entry_size); 5213 if (entry->status_flags & DASD_ECKD_PG_GROUPED) 5214 count++; 5215 } 5216 5217 kfree(access); 5218 return count; 5219 } 5220 5221 /* 5222 * write host access information to a sequential file 5223 */ 5224 static int dasd_hosts_print(struct dasd_device *device, struct seq_file *m) 5225 { 5226 struct dasd_psf_query_host_access *access; 5227 struct dasd_ckd_path_group_entry *entry; 5228 struct dasd_ckd_host_information *info; 5229 char sysplex[9] = ""; 5230 int rc, i, j; 5231 5232 access = kzalloc(sizeof(*access), GFP_NOIO); 5233 if (!access) { 5234 DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s", 5235 "Could not allocate access buffer"); 5236 return -ENOMEM; 5237 } 5238 rc = dasd_eckd_query_host_access(device, access); 5239 if (rc) { 5240 kfree(access); 5241 return rc; 5242 } 5243 5244 info = (struct dasd_ckd_host_information *) 5245 access->host_access_information; 5246 for (i = 0; i < info->entry_count; i++) { 5247 entry = (struct dasd_ckd_path_group_entry *) 5248 (info->entry + i * info->entry_size); 5249 /* PGID */ 5250 seq_puts(m, "pgid "); 5251 for (j = 0; j < 11; j++) 5252 seq_printf(m, "%02x", entry->pgid[j]); 5253 seq_putc(m, '\n'); 5254 /* FLAGS */ 5255 seq_printf(m, "status_flags %02x\n", entry->status_flags); 5256 /* SYSPLEX NAME */ 5257 memcpy(&sysplex, &entry->sysplex_name, sizeof(sysplex) - 1); 5258 EBCASC(sysplex, sizeof(sysplex)); 5259 seq_printf(m, "sysplex_name %8s\n", sysplex); 5260 /* SUPPORTED CYLINDER */ 5261 seq_printf(m, "supported_cylinder %d\n", entry->cylinder); 5262 /* TIMESTAMP */ 5263 seq_printf(m, "timestamp %lu\n", (unsigned long) 5264 entry->timestamp); 5265 } 5266 kfree(access); 5267 5268 return 0; 5269 } 5270 5271 /* 5272 * Perform Subsystem Function - CUIR response 5273 */ 5274 static int 5275 dasd_eckd_psf_cuir_response(struct dasd_device *device, int response, 5276 __u32 message_id, __u8 lpum) 5277 { 5278 struct dasd_psf_cuir_response *psf_cuir; 5279 int pos = pathmask_to_pos(lpum); 5280 struct dasd_ccw_req *cqr; 5281 struct ccw1 *ccw; 5282 int rc; 5283 5284 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ , 5285 sizeof(struct dasd_psf_cuir_response), 5286 device); 5287 5288 if (IS_ERR(cqr)) { 5289 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 5290 "Could not allocate PSF-CUIR request"); 5291 return PTR_ERR(cqr); 5292 } 5293 5294 psf_cuir = (struct dasd_psf_cuir_response *)cqr->data; 5295 psf_cuir->order = PSF_ORDER_CUIR_RESPONSE; 5296 psf_cuir->cc = response; 5297 psf_cuir->chpid = device->path[pos].chpid; 5298 psf_cuir->message_id = message_id; 5299 psf_cuir->cssid = device->path[pos].cssid; 5300 psf_cuir->ssid = device->path[pos].ssid; 5301 ccw = cqr->cpaddr; 5302 ccw->cmd_code = DASD_ECKD_CCW_PSF; 5303 ccw->cda = (__u32)(addr_t)psf_cuir; 5304 ccw->flags = CCW_FLAG_SLI; 5305 ccw->count = sizeof(struct dasd_psf_cuir_response); 5306 5307 cqr->startdev = device; 5308 cqr->memdev = device; 5309 cqr->block = NULL; 5310 cqr->retries = 256; 5311 cqr->expires = 10*HZ; 5312 cqr->buildclk = get_tod_clock(); 5313 cqr->status = DASD_CQR_FILLED; 5314 set_bit(DASD_CQR_VERIFY_PATH, &cqr->flags); 5315 5316 rc = dasd_sleep_on(cqr); 5317 5318 dasd_sfree_request(cqr, cqr->memdev); 5319 return rc; 5320 } 5321 5322 /* 5323 * return configuration data that is referenced by record selector 5324 * if a record selector is specified or per default return the 5325 * conf_data pointer for the path specified by lpum 5326 */ 5327 static struct dasd_conf_data *dasd_eckd_get_ref_conf(struct dasd_device *device, 5328 __u8 lpum, 5329 struct dasd_cuir_message *cuir) 5330 { 5331 struct dasd_conf_data *conf_data; 5332 int path, pos; 5333 5334 if (cuir->record_selector == 0) 5335 goto out; 5336 for (path = 0x80, pos = 0; path; path >>= 1, pos++) { 5337 conf_data = device->path[pos].conf_data; 5338 if (conf_data->gneq.record_selector == 5339 cuir->record_selector) 5340 return conf_data; 5341 } 5342 out: 5343 return device->path[pathmask_to_pos(lpum)].conf_data; 5344 } 5345 5346 /* 5347 * This function determines the scope of a reconfiguration request by 5348 * analysing the path and device selection data provided in the CUIR request. 5349 * Returns a path mask containing CUIR affected paths for the give device. 5350 * 5351 * If the CUIR request does not contain the required information return the 5352 * path mask of the path the attention message for the CUIR request was reveived 5353 * on. 5354 */ 5355 static int dasd_eckd_cuir_scope(struct dasd_device *device, __u8 lpum, 5356 struct dasd_cuir_message *cuir) 5357 { 5358 struct dasd_conf_data *ref_conf_data; 5359 unsigned long bitmask = 0, mask = 0; 5360 struct dasd_conf_data *conf_data; 5361 unsigned int pos, path; 5362 char *ref_gneq, *gneq; 5363 char *ref_ned, *ned; 5364 int tbcpm = 0; 5365 5366 /* if CUIR request does not specify the scope use the path 5367 the attention message was presented on */ 5368 if (!cuir->ned_map || 5369 !(cuir->neq_map[0] | cuir->neq_map[1] | cuir->neq_map[2])) 5370 return lpum; 5371 5372 /* get reference conf data */ 5373 ref_conf_data = dasd_eckd_get_ref_conf(device, lpum, cuir); 5374 /* reference ned is determined by ned_map field */ 5375 pos = 8 - ffs(cuir->ned_map); 5376 ref_ned = (char *)&ref_conf_data->neds[pos]; 5377 ref_gneq = (char *)&ref_conf_data->gneq; 5378 /* transfer 24 bit neq_map to mask */ 5379 mask = cuir->neq_map[2]; 5380 mask |= cuir->neq_map[1] << 8; 5381 mask |= cuir->neq_map[0] << 16; 5382 5383 for (path = 0; path < 8; path++) { 5384 /* initialise data per path */ 5385 bitmask = mask; 5386 conf_data = device->path[path].conf_data; 5387 pos = 8 - ffs(cuir->ned_map); 5388 ned = (char *) &conf_data->neds[pos]; 5389 /* compare reference ned and per path ned */ 5390 if (memcmp(ref_ned, ned, sizeof(*ned)) != 0) 5391 continue; 5392 gneq = (char *)&conf_data->gneq; 5393 /* compare reference gneq and per_path gneq under 5394 24 bit mask where mask bit 0 equals byte 7 of 5395 the gneq and mask bit 24 equals byte 31 */ 5396 while (bitmask) { 5397 pos = ffs(bitmask) - 1; 5398 if (memcmp(&ref_gneq[31 - pos], &gneq[31 - pos], 1) 5399 != 0) 5400 break; 5401 clear_bit(pos, &bitmask); 5402 } 5403 if (bitmask) 5404 continue; 5405 /* device and path match the reference values 5406 add path to CUIR scope */ 5407 tbcpm |= 0x80 >> path; 5408 } 5409 return tbcpm; 5410 } 5411 5412 static void dasd_eckd_cuir_notify_user(struct dasd_device *device, 5413 unsigned long paths, int action) 5414 { 5415 int pos; 5416 5417 while (paths) { 5418 /* get position of bit in mask */ 5419 pos = 8 - ffs(paths); 5420 /* get channel path descriptor from this position */ 5421 if (action == CUIR_QUIESCE) 5422 pr_warn("Service on the storage server caused path %x.%02x to go offline", 5423 device->path[pos].cssid, 5424 device->path[pos].chpid); 5425 else if (action == CUIR_RESUME) 5426 pr_info("Path %x.%02x is back online after service on the storage server", 5427 device->path[pos].cssid, 5428 device->path[pos].chpid); 5429 clear_bit(7 - pos, &paths); 5430 } 5431 } 5432 5433 static int dasd_eckd_cuir_remove_path(struct dasd_device *device, __u8 lpum, 5434 struct dasd_cuir_message *cuir) 5435 { 5436 unsigned long tbcpm; 5437 5438 tbcpm = dasd_eckd_cuir_scope(device, lpum, cuir); 5439 /* nothing to do if path is not in use */ 5440 if (!(dasd_path_get_opm(device) & tbcpm)) 5441 return 0; 5442 if (!(dasd_path_get_opm(device) & ~tbcpm)) { 5443 /* no path would be left if the CUIR action is taken 5444 return error */ 5445 return -EINVAL; 5446 } 5447 /* remove device from operational path mask */ 5448 dasd_path_remove_opm(device, tbcpm); 5449 dasd_path_add_cuirpm(device, tbcpm); 5450 return tbcpm; 5451 } 5452 5453 /* 5454 * walk through all devices and build a path mask to quiesce them 5455 * return an error if the last path to a device would be removed 5456 * 5457 * if only part of the devices are quiesced and an error 5458 * occurs no onlining necessary, the storage server will 5459 * notify the already set offline devices again 5460 */ 5461 static int dasd_eckd_cuir_quiesce(struct dasd_device *device, __u8 lpum, 5462 struct dasd_cuir_message *cuir) 5463 { 5464 struct dasd_eckd_private *private = device->private; 5465 struct alias_pav_group *pavgroup, *tempgroup; 5466 struct dasd_device *dev, *n; 5467 unsigned long paths = 0; 5468 unsigned long flags; 5469 int tbcpm; 5470 5471 /* active devices */ 5472 list_for_each_entry_safe(dev, n, &private->lcu->active_devices, 5473 alias_list) { 5474 spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags); 5475 tbcpm = dasd_eckd_cuir_remove_path(dev, lpum, cuir); 5476 spin_unlock_irqrestore(get_ccwdev_lock(dev->cdev), flags); 5477 if (tbcpm < 0) 5478 goto out_err; 5479 paths |= tbcpm; 5480 } 5481 /* inactive devices */ 5482 list_for_each_entry_safe(dev, n, &private->lcu->inactive_devices, 5483 alias_list) { 5484 spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags); 5485 tbcpm = dasd_eckd_cuir_remove_path(dev, lpum, cuir); 5486 spin_unlock_irqrestore(get_ccwdev_lock(dev->cdev), flags); 5487 if (tbcpm < 0) 5488 goto out_err; 5489 paths |= tbcpm; 5490 } 5491 /* devices in PAV groups */ 5492 list_for_each_entry_safe(pavgroup, tempgroup, 5493 &private->lcu->grouplist, group) { 5494 list_for_each_entry_safe(dev, n, &pavgroup->baselist, 5495 alias_list) { 5496 spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags); 5497 tbcpm = dasd_eckd_cuir_remove_path(dev, lpum, cuir); 5498 spin_unlock_irqrestore( 5499 get_ccwdev_lock(dev->cdev), flags); 5500 if (tbcpm < 0) 5501 goto out_err; 5502 paths |= tbcpm; 5503 } 5504 list_for_each_entry_safe(dev, n, &pavgroup->aliaslist, 5505 alias_list) { 5506 spin_lock_irqsave(get_ccwdev_lock(dev->cdev), flags); 5507 tbcpm = dasd_eckd_cuir_remove_path(dev, lpum, cuir); 5508 spin_unlock_irqrestore( 5509 get_ccwdev_lock(dev->cdev), flags); 5510 if (tbcpm < 0) 5511 goto out_err; 5512 paths |= tbcpm; 5513 } 5514 } 5515 /* notify user about all paths affected by CUIR action */ 5516 dasd_eckd_cuir_notify_user(device, paths, CUIR_QUIESCE); 5517 return 0; 5518 out_err: 5519 return tbcpm; 5520 } 5521 5522 static int dasd_eckd_cuir_resume(struct dasd_device *device, __u8 lpum, 5523 struct dasd_cuir_message *cuir) 5524 { 5525 struct dasd_eckd_private *private = device->private; 5526 struct alias_pav_group *pavgroup, *tempgroup; 5527 struct dasd_device *dev, *n; 5528 unsigned long paths = 0; 5529 int tbcpm; 5530 5531 /* 5532 * the path may have been added through a generic path event before 5533 * only trigger path verification if the path is not already in use 5534 */ 5535 list_for_each_entry_safe(dev, n, 5536 &private->lcu->active_devices, 5537 alias_list) { 5538 tbcpm = dasd_eckd_cuir_scope(dev, lpum, cuir); 5539 paths |= tbcpm; 5540 if (!(dasd_path_get_opm(dev) & tbcpm)) { 5541 dasd_path_add_tbvpm(dev, tbcpm); 5542 dasd_schedule_device_bh(dev); 5543 } 5544 } 5545 list_for_each_entry_safe(dev, n, 5546 &private->lcu->inactive_devices, 5547 alias_list) { 5548 tbcpm = dasd_eckd_cuir_scope(dev, lpum, cuir); 5549 paths |= tbcpm; 5550 if (!(dasd_path_get_opm(dev) & tbcpm)) { 5551 dasd_path_add_tbvpm(dev, tbcpm); 5552 dasd_schedule_device_bh(dev); 5553 } 5554 } 5555 /* devices in PAV groups */ 5556 list_for_each_entry_safe(pavgroup, tempgroup, 5557 &private->lcu->grouplist, 5558 group) { 5559 list_for_each_entry_safe(dev, n, 5560 &pavgroup->baselist, 5561 alias_list) { 5562 tbcpm = dasd_eckd_cuir_scope(dev, lpum, cuir); 5563 paths |= tbcpm; 5564 if (!(dasd_path_get_opm(dev) & tbcpm)) { 5565 dasd_path_add_tbvpm(dev, tbcpm); 5566 dasd_schedule_device_bh(dev); 5567 } 5568 } 5569 list_for_each_entry_safe(dev, n, 5570 &pavgroup->aliaslist, 5571 alias_list) { 5572 tbcpm = dasd_eckd_cuir_scope(dev, lpum, cuir); 5573 paths |= tbcpm; 5574 if (!(dasd_path_get_opm(dev) & tbcpm)) { 5575 dasd_path_add_tbvpm(dev, tbcpm); 5576 dasd_schedule_device_bh(dev); 5577 } 5578 } 5579 } 5580 /* notify user about all paths affected by CUIR action */ 5581 dasd_eckd_cuir_notify_user(device, paths, CUIR_RESUME); 5582 return 0; 5583 } 5584 5585 static void dasd_eckd_handle_cuir(struct dasd_device *device, void *messages, 5586 __u8 lpum) 5587 { 5588 struct dasd_cuir_message *cuir = messages; 5589 int response; 5590 5591 DBF_DEV_EVENT(DBF_WARNING, device, 5592 "CUIR request: %016llx %016llx %016llx %08x", 5593 ((u64 *)cuir)[0], ((u64 *)cuir)[1], ((u64 *)cuir)[2], 5594 ((u32 *)cuir)[3]); 5595 5596 if (cuir->code == CUIR_QUIESCE) { 5597 /* quiesce */ 5598 if (dasd_eckd_cuir_quiesce(device, lpum, cuir)) 5599 response = PSF_CUIR_LAST_PATH; 5600 else 5601 response = PSF_CUIR_COMPLETED; 5602 } else if (cuir->code == CUIR_RESUME) { 5603 /* resume */ 5604 dasd_eckd_cuir_resume(device, lpum, cuir); 5605 response = PSF_CUIR_COMPLETED; 5606 } else 5607 response = PSF_CUIR_NOT_SUPPORTED; 5608 5609 dasd_eckd_psf_cuir_response(device, response, 5610 cuir->message_id, lpum); 5611 DBF_DEV_EVENT(DBF_WARNING, device, 5612 "CUIR response: %d on message ID %08x", response, 5613 cuir->message_id); 5614 /* to make sure there is no attention left schedule work again */ 5615 device->discipline->check_attention(device, lpum); 5616 } 5617 5618 static void dasd_eckd_check_attention_work(struct work_struct *work) 5619 { 5620 struct check_attention_work_data *data; 5621 struct dasd_rssd_messages *messages; 5622 struct dasd_device *device; 5623 int rc; 5624 5625 data = container_of(work, struct check_attention_work_data, worker); 5626 device = data->device; 5627 messages = kzalloc(sizeof(*messages), GFP_KERNEL); 5628 if (!messages) { 5629 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 5630 "Could not allocate attention message buffer"); 5631 goto out; 5632 } 5633 rc = dasd_eckd_read_message_buffer(device, messages, data->lpum); 5634 if (rc) 5635 goto out; 5636 if (messages->length == ATTENTION_LENGTH_CUIR && 5637 messages->format == ATTENTION_FORMAT_CUIR) 5638 dasd_eckd_handle_cuir(device, messages, data->lpum); 5639 out: 5640 dasd_put_device(device); 5641 kfree(messages); 5642 kfree(data); 5643 } 5644 5645 static int dasd_eckd_check_attention(struct dasd_device *device, __u8 lpum) 5646 { 5647 struct check_attention_work_data *data; 5648 5649 data = kzalloc(sizeof(*data), GFP_ATOMIC); 5650 if (!data) 5651 return -ENOMEM; 5652 INIT_WORK(&data->worker, dasd_eckd_check_attention_work); 5653 dasd_get_device(device); 5654 data->device = device; 5655 data->lpum = lpum; 5656 schedule_work(&data->worker); 5657 return 0; 5658 } 5659 5660 static int dasd_eckd_disable_hpf_path(struct dasd_device *device, __u8 lpum) 5661 { 5662 if (~lpum & dasd_path_get_opm(device)) { 5663 dasd_path_add_nohpfpm(device, lpum); 5664 dasd_path_remove_opm(device, lpum); 5665 dev_err(&device->cdev->dev, 5666 "Channel path %02X lost HPF functionality and is disabled\n", 5667 lpum); 5668 return 1; 5669 } 5670 return 0; 5671 } 5672 5673 static void dasd_eckd_disable_hpf_device(struct dasd_device *device) 5674 { 5675 struct dasd_eckd_private *private = device->private; 5676 5677 dev_err(&device->cdev->dev, 5678 "High Performance FICON disabled\n"); 5679 private->fcx_max_data = 0; 5680 } 5681 5682 static int dasd_eckd_hpf_enabled(struct dasd_device *device) 5683 { 5684 struct dasd_eckd_private *private = device->private; 5685 5686 return private->fcx_max_data ? 1 : 0; 5687 } 5688 5689 static void dasd_eckd_handle_hpf_error(struct dasd_device *device, 5690 struct irb *irb) 5691 { 5692 struct dasd_eckd_private *private = device->private; 5693 5694 if (!private->fcx_max_data) { 5695 /* sanity check for no HPF, the error makes no sense */ 5696 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 5697 "Trying to disable HPF for a non HPF device"); 5698 return; 5699 } 5700 if (irb->scsw.tm.sesq == SCSW_SESQ_DEV_NOFCX) { 5701 dasd_eckd_disable_hpf_device(device); 5702 } else if (irb->scsw.tm.sesq == SCSW_SESQ_PATH_NOFCX) { 5703 if (dasd_eckd_disable_hpf_path(device, irb->esw.esw1.lpum)) 5704 return; 5705 dasd_eckd_disable_hpf_device(device); 5706 dasd_path_set_tbvpm(device, 5707 dasd_path_get_hpfpm(device)); 5708 } 5709 /* 5710 * prevent that any new I/O ist started on the device and schedule a 5711 * requeue of existing requests 5712 */ 5713 dasd_device_set_stop_bits(device, DASD_STOPPED_NOT_ACC); 5714 dasd_schedule_requeue(device); 5715 } 5716 5717 static struct ccw_driver dasd_eckd_driver = { 5718 .driver = { 5719 .name = "dasd-eckd", 5720 .owner = THIS_MODULE, 5721 }, 5722 .ids = dasd_eckd_ids, 5723 .probe = dasd_eckd_probe, 5724 .remove = dasd_generic_remove, 5725 .set_offline = dasd_generic_set_offline, 5726 .set_online = dasd_eckd_set_online, 5727 .notify = dasd_generic_notify, 5728 .path_event = dasd_generic_path_event, 5729 .shutdown = dasd_generic_shutdown, 5730 .freeze = dasd_generic_pm_freeze, 5731 .thaw = dasd_generic_restore_device, 5732 .restore = dasd_generic_restore_device, 5733 .uc_handler = dasd_generic_uc_handler, 5734 .int_class = IRQIO_DAS, 5735 }; 5736 5737 /* 5738 * max_blocks is dependent on the amount of storage that is available 5739 * in the static io buffer for each device. Currently each device has 5740 * 8192 bytes (=2 pages). For 64 bit one dasd_mchunkt_t structure has 5741 * 24 bytes, the struct dasd_ccw_req has 136 bytes and each block can use 5742 * up to 16 bytes (8 for the ccw and 8 for the idal pointer). In 5743 * addition we have one define extent ccw + 16 bytes of data and one 5744 * locate record ccw + 16 bytes of data. That makes: 5745 * (8192 - 24 - 136 - 8 - 16 - 8 - 16) / 16 = 499 blocks at maximum. 5746 * We want to fit two into the available memory so that we can immediately 5747 * start the next request if one finishes off. That makes 249.5 blocks 5748 * for one request. Give a little safety and the result is 240. 5749 */ 5750 static struct dasd_discipline dasd_eckd_discipline = { 5751 .owner = THIS_MODULE, 5752 .name = "ECKD", 5753 .ebcname = "ECKD", 5754 .max_blocks = 190, 5755 .check_device = dasd_eckd_check_characteristics, 5756 .uncheck_device = dasd_eckd_uncheck_device, 5757 .do_analysis = dasd_eckd_do_analysis, 5758 .verify_path = dasd_eckd_verify_path, 5759 .basic_to_ready = dasd_eckd_basic_to_ready, 5760 .online_to_ready = dasd_eckd_online_to_ready, 5761 .basic_to_known = dasd_eckd_basic_to_known, 5762 .fill_geometry = dasd_eckd_fill_geometry, 5763 .start_IO = dasd_start_IO, 5764 .term_IO = dasd_term_IO, 5765 .handle_terminated_request = dasd_eckd_handle_terminated_request, 5766 .format_device = dasd_eckd_format_device, 5767 .check_device_format = dasd_eckd_check_device_format, 5768 .erp_action = dasd_eckd_erp_action, 5769 .erp_postaction = dasd_eckd_erp_postaction, 5770 .check_for_device_change = dasd_eckd_check_for_device_change, 5771 .build_cp = dasd_eckd_build_alias_cp, 5772 .free_cp = dasd_eckd_free_alias_cp, 5773 .dump_sense = dasd_eckd_dump_sense, 5774 .dump_sense_dbf = dasd_eckd_dump_sense_dbf, 5775 .fill_info = dasd_eckd_fill_info, 5776 .ioctl = dasd_eckd_ioctl, 5777 .freeze = dasd_eckd_pm_freeze, 5778 .restore = dasd_eckd_restore_device, 5779 .reload = dasd_eckd_reload_device, 5780 .get_uid = dasd_eckd_get_uid, 5781 .kick_validate = dasd_eckd_kick_validate_server, 5782 .check_attention = dasd_eckd_check_attention, 5783 .host_access_count = dasd_eckd_host_access_count, 5784 .hosts_print = dasd_hosts_print, 5785 .handle_hpf_error = dasd_eckd_handle_hpf_error, 5786 .disable_hpf = dasd_eckd_disable_hpf_device, 5787 .hpf_enabled = dasd_eckd_hpf_enabled, 5788 .reset_path = dasd_eckd_reset_path, 5789 }; 5790 5791 static int __init 5792 dasd_eckd_init(void) 5793 { 5794 int ret; 5795 5796 ASCEBC(dasd_eckd_discipline.ebcname, 4); 5797 dasd_reserve_req = kmalloc(sizeof(*dasd_reserve_req), 5798 GFP_KERNEL | GFP_DMA); 5799 if (!dasd_reserve_req) 5800 return -ENOMEM; 5801 path_verification_worker = kmalloc(sizeof(*path_verification_worker), 5802 GFP_KERNEL | GFP_DMA); 5803 if (!path_verification_worker) { 5804 kfree(dasd_reserve_req); 5805 return -ENOMEM; 5806 } 5807 rawpadpage = (void *)__get_free_page(GFP_KERNEL); 5808 if (!rawpadpage) { 5809 kfree(path_verification_worker); 5810 kfree(dasd_reserve_req); 5811 return -ENOMEM; 5812 } 5813 ret = ccw_driver_register(&dasd_eckd_driver); 5814 if (!ret) 5815 wait_for_device_probe(); 5816 else { 5817 kfree(path_verification_worker); 5818 kfree(dasd_reserve_req); 5819 free_page((unsigned long)rawpadpage); 5820 } 5821 return ret; 5822 } 5823 5824 static void __exit 5825 dasd_eckd_cleanup(void) 5826 { 5827 ccw_driver_unregister(&dasd_eckd_driver); 5828 kfree(path_verification_worker); 5829 kfree(dasd_reserve_req); 5830 free_page((unsigned long)rawpadpage); 5831 } 5832 5833 module_init(dasd_eckd_init); 5834 module_exit(dasd_eckd_cleanup); 5835