1 /* 2 * File...........: linux/drivers/s390/block/dasd_eckd.c 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/init.h> 22 23 #include <asm/debug.h> 24 #include <asm/idals.h> 25 #include <asm/ebcdic.h> 26 #include <asm/io.h> 27 #include <asm/todclk.h> 28 #include <asm/uaccess.h> 29 #include <asm/cio.h> 30 #include <asm/ccwdev.h> 31 #include <asm/itcw.h> 32 33 #include "dasd_int.h" 34 #include "dasd_eckd.h" 35 #include "../cio/chsc.h" 36 37 38 #ifdef PRINTK_HEADER 39 #undef PRINTK_HEADER 40 #endif /* PRINTK_HEADER */ 41 #define PRINTK_HEADER "dasd(eckd):" 42 43 #define ECKD_C0(i) (i->home_bytes) 44 #define ECKD_F(i) (i->formula) 45 #define ECKD_F1(i) (ECKD_F(i)==0x01?(i->factors.f_0x01.f1):\ 46 (i->factors.f_0x02.f1)) 47 #define ECKD_F2(i) (ECKD_F(i)==0x01?(i->factors.f_0x01.f2):\ 48 (i->factors.f_0x02.f2)) 49 #define ECKD_F3(i) (ECKD_F(i)==0x01?(i->factors.f_0x01.f3):\ 50 (i->factors.f_0x02.f3)) 51 #define ECKD_F4(i) (ECKD_F(i)==0x02?(i->factors.f_0x02.f4):0) 52 #define ECKD_F5(i) (ECKD_F(i)==0x02?(i->factors.f_0x02.f5):0) 53 #define ECKD_F6(i) (i->factor6) 54 #define ECKD_F7(i) (i->factor7) 55 #define ECKD_F8(i) (i->factor8) 56 57 MODULE_LICENSE("GPL"); 58 59 static struct dasd_discipline dasd_eckd_discipline; 60 61 /* The ccw bus type uses this table to find devices that it sends to 62 * dasd_eckd_probe */ 63 static struct ccw_device_id dasd_eckd_ids[] = { 64 { CCW_DEVICE_DEVTYPE (0x3990, 0, 0x3390, 0), .driver_info = 0x1}, 65 { CCW_DEVICE_DEVTYPE (0x2105, 0, 0x3390, 0), .driver_info = 0x2}, 66 { CCW_DEVICE_DEVTYPE (0x3880, 0, 0x3390, 0), .driver_info = 0x3}, 67 { CCW_DEVICE_DEVTYPE (0x3990, 0, 0x3380, 0), .driver_info = 0x4}, 68 { CCW_DEVICE_DEVTYPE (0x2105, 0, 0x3380, 0), .driver_info = 0x5}, 69 { CCW_DEVICE_DEVTYPE (0x9343, 0, 0x9345, 0), .driver_info = 0x6}, 70 { CCW_DEVICE_DEVTYPE (0x2107, 0, 0x3390, 0), .driver_info = 0x7}, 71 { CCW_DEVICE_DEVTYPE (0x2107, 0, 0x3380, 0), .driver_info = 0x8}, 72 { CCW_DEVICE_DEVTYPE (0x1750, 0, 0x3390, 0), .driver_info = 0x9}, 73 { CCW_DEVICE_DEVTYPE (0x1750, 0, 0x3380, 0), .driver_info = 0xa}, 74 { /* end of list */ }, 75 }; 76 77 MODULE_DEVICE_TABLE(ccw, dasd_eckd_ids); 78 79 static struct ccw_driver dasd_eckd_driver; /* see below */ 80 81 /* initial attempt at a probe function. this can be simplified once 82 * the other detection code is gone */ 83 static int 84 dasd_eckd_probe (struct ccw_device *cdev) 85 { 86 int ret; 87 88 /* set ECKD specific ccw-device options */ 89 ret = ccw_device_set_options(cdev, CCWDEV_ALLOW_FORCE | 90 CCWDEV_DO_PATHGROUP | CCWDEV_DO_MULTIPATH); 91 if (ret) { 92 DBF_EVENT(DBF_WARNING, 93 "dasd_eckd_probe: could not set ccw-device options " 94 "for %s\n", dev_name(&cdev->dev)); 95 return ret; 96 } 97 ret = dasd_generic_probe(cdev, &dasd_eckd_discipline); 98 return ret; 99 } 100 101 static int 102 dasd_eckd_set_online(struct ccw_device *cdev) 103 { 104 return dasd_generic_set_online(cdev, &dasd_eckd_discipline); 105 } 106 107 static const int sizes_trk0[] = { 28, 148, 84 }; 108 #define LABEL_SIZE 140 109 110 static inline unsigned int 111 round_up_multiple(unsigned int no, unsigned int mult) 112 { 113 int rem = no % mult; 114 return (rem ? no - rem + mult : no); 115 } 116 117 static inline unsigned int 118 ceil_quot(unsigned int d1, unsigned int d2) 119 { 120 return (d1 + (d2 - 1)) / d2; 121 } 122 123 static unsigned int 124 recs_per_track(struct dasd_eckd_characteristics * rdc, 125 unsigned int kl, unsigned int dl) 126 { 127 int dn, kn; 128 129 switch (rdc->dev_type) { 130 case 0x3380: 131 if (kl) 132 return 1499 / (15 + 7 + ceil_quot(kl + 12, 32) + 133 ceil_quot(dl + 12, 32)); 134 else 135 return 1499 / (15 + ceil_quot(dl + 12, 32)); 136 case 0x3390: 137 dn = ceil_quot(dl + 6, 232) + 1; 138 if (kl) { 139 kn = ceil_quot(kl + 6, 232) + 1; 140 return 1729 / (10 + 9 + ceil_quot(kl + 6 * kn, 34) + 141 9 + ceil_quot(dl + 6 * dn, 34)); 142 } else 143 return 1729 / (10 + 9 + ceil_quot(dl + 6 * dn, 34)); 144 case 0x9345: 145 dn = ceil_quot(dl + 6, 232) + 1; 146 if (kl) { 147 kn = ceil_quot(kl + 6, 232) + 1; 148 return 1420 / (18 + 7 + ceil_quot(kl + 6 * kn, 34) + 149 ceil_quot(dl + 6 * dn, 34)); 150 } else 151 return 1420 / (18 + 7 + ceil_quot(dl + 6 * dn, 34)); 152 } 153 return 0; 154 } 155 156 static void set_ch_t(struct ch_t *geo, __u32 cyl, __u8 head) 157 { 158 geo->cyl = (__u16) cyl; 159 geo->head = cyl >> 16; 160 geo->head <<= 4; 161 geo->head |= head; 162 } 163 164 static int 165 check_XRC (struct ccw1 *de_ccw, 166 struct DE_eckd_data *data, 167 struct dasd_device *device) 168 { 169 struct dasd_eckd_private *private; 170 int rc; 171 172 private = (struct dasd_eckd_private *) device->private; 173 if (!private->rdc_data.facilities.XRC_supported) 174 return 0; 175 176 /* switch on System Time Stamp - needed for XRC Support */ 177 data->ga_extended |= 0x08; /* switch on 'Time Stamp Valid' */ 178 data->ga_extended |= 0x02; /* switch on 'Extended Parameter' */ 179 180 rc = get_sync_clock(&data->ep_sys_time); 181 /* Ignore return code if sync clock is switched off. */ 182 if (rc == -ENOSYS || rc == -EACCES) 183 rc = 0; 184 185 de_ccw->count = sizeof(struct DE_eckd_data); 186 de_ccw->flags |= CCW_FLAG_SLI; 187 return rc; 188 } 189 190 static int 191 define_extent(struct ccw1 *ccw, struct DE_eckd_data *data, unsigned int trk, 192 unsigned int totrk, int cmd, struct dasd_device *device) 193 { 194 struct dasd_eckd_private *private; 195 u32 begcyl, endcyl; 196 u16 heads, beghead, endhead; 197 int rc = 0; 198 199 private = (struct dasd_eckd_private *) device->private; 200 201 ccw->cmd_code = DASD_ECKD_CCW_DEFINE_EXTENT; 202 ccw->flags = 0; 203 ccw->count = 16; 204 ccw->cda = (__u32) __pa(data); 205 206 memset(data, 0, sizeof(struct DE_eckd_data)); 207 switch (cmd) { 208 case DASD_ECKD_CCW_READ_HOME_ADDRESS: 209 case DASD_ECKD_CCW_READ_RECORD_ZERO: 210 case DASD_ECKD_CCW_READ: 211 case DASD_ECKD_CCW_READ_MT: 212 case DASD_ECKD_CCW_READ_CKD: 213 case DASD_ECKD_CCW_READ_CKD_MT: 214 case DASD_ECKD_CCW_READ_KD: 215 case DASD_ECKD_CCW_READ_KD_MT: 216 case DASD_ECKD_CCW_READ_COUNT: 217 data->mask.perm = 0x1; 218 data->attributes.operation = private->attrib.operation; 219 break; 220 case DASD_ECKD_CCW_WRITE: 221 case DASD_ECKD_CCW_WRITE_MT: 222 case DASD_ECKD_CCW_WRITE_KD: 223 case DASD_ECKD_CCW_WRITE_KD_MT: 224 data->mask.perm = 0x02; 225 data->attributes.operation = private->attrib.operation; 226 rc = check_XRC (ccw, data, device); 227 break; 228 case DASD_ECKD_CCW_WRITE_CKD: 229 case DASD_ECKD_CCW_WRITE_CKD_MT: 230 data->attributes.operation = DASD_BYPASS_CACHE; 231 rc = check_XRC (ccw, data, device); 232 break; 233 case DASD_ECKD_CCW_ERASE: 234 case DASD_ECKD_CCW_WRITE_HOME_ADDRESS: 235 case DASD_ECKD_CCW_WRITE_RECORD_ZERO: 236 data->mask.perm = 0x3; 237 data->mask.auth = 0x1; 238 data->attributes.operation = DASD_BYPASS_CACHE; 239 rc = check_XRC (ccw, data, device); 240 break; 241 default: 242 dev_err(&device->cdev->dev, 243 "0x%x is not a known command\n", cmd); 244 break; 245 } 246 247 data->attributes.mode = 0x3; /* ECKD */ 248 249 if ((private->rdc_data.cu_type == 0x2105 || 250 private->rdc_data.cu_type == 0x2107 || 251 private->rdc_data.cu_type == 0x1750) 252 && !(private->uses_cdl && trk < 2)) 253 data->ga_extended |= 0x40; /* Regular Data Format Mode */ 254 255 heads = private->rdc_data.trk_per_cyl; 256 begcyl = trk / heads; 257 beghead = trk % heads; 258 endcyl = totrk / heads; 259 endhead = totrk % heads; 260 261 /* check for sequential prestage - enhance cylinder range */ 262 if (data->attributes.operation == DASD_SEQ_PRESTAGE || 263 data->attributes.operation == DASD_SEQ_ACCESS) { 264 265 if (endcyl + private->attrib.nr_cyl < private->real_cyl) 266 endcyl += private->attrib.nr_cyl; 267 else 268 endcyl = (private->real_cyl - 1); 269 } 270 271 set_ch_t(&data->beg_ext, begcyl, beghead); 272 set_ch_t(&data->end_ext, endcyl, endhead); 273 return rc; 274 } 275 276 static int check_XRC_on_prefix(struct PFX_eckd_data *pfxdata, 277 struct dasd_device *device) 278 { 279 struct dasd_eckd_private *private; 280 int rc; 281 282 private = (struct dasd_eckd_private *) device->private; 283 if (!private->rdc_data.facilities.XRC_supported) 284 return 0; 285 286 /* switch on System Time Stamp - needed for XRC Support */ 287 pfxdata->define_extent.ga_extended |= 0x08; /* 'Time Stamp Valid' */ 288 pfxdata->define_extent.ga_extended |= 0x02; /* 'Extended Parameter' */ 289 pfxdata->validity.time_stamp = 1; /* 'Time Stamp Valid' */ 290 291 rc = get_sync_clock(&pfxdata->define_extent.ep_sys_time); 292 /* Ignore return code if sync clock is switched off. */ 293 if (rc == -ENOSYS || rc == -EACCES) 294 rc = 0; 295 return rc; 296 } 297 298 static void fill_LRE_data(struct LRE_eckd_data *data, unsigned int trk, 299 unsigned int rec_on_trk, int count, int cmd, 300 struct dasd_device *device, unsigned int reclen, 301 unsigned int tlf) 302 { 303 struct dasd_eckd_private *private; 304 int sector; 305 int dn, d; 306 307 private = (struct dasd_eckd_private *) device->private; 308 309 memset(data, 0, sizeof(*data)); 310 sector = 0; 311 if (rec_on_trk) { 312 switch (private->rdc_data.dev_type) { 313 case 0x3390: 314 dn = ceil_quot(reclen + 6, 232); 315 d = 9 + ceil_quot(reclen + 6 * (dn + 1), 34); 316 sector = (49 + (rec_on_trk - 1) * (10 + d)) / 8; 317 break; 318 case 0x3380: 319 d = 7 + ceil_quot(reclen + 12, 32); 320 sector = (39 + (rec_on_trk - 1) * (8 + d)) / 7; 321 break; 322 } 323 } 324 data->sector = sector; 325 /* note: meaning of count depends on the operation 326 * for record based I/O it's the number of records, but for 327 * track based I/O it's the number of tracks 328 */ 329 data->count = count; 330 switch (cmd) { 331 case DASD_ECKD_CCW_WRITE_HOME_ADDRESS: 332 data->operation.orientation = 0x3; 333 data->operation.operation = 0x03; 334 break; 335 case DASD_ECKD_CCW_READ_HOME_ADDRESS: 336 data->operation.orientation = 0x3; 337 data->operation.operation = 0x16; 338 break; 339 case DASD_ECKD_CCW_WRITE_RECORD_ZERO: 340 data->operation.orientation = 0x1; 341 data->operation.operation = 0x03; 342 data->count++; 343 break; 344 case DASD_ECKD_CCW_READ_RECORD_ZERO: 345 data->operation.orientation = 0x3; 346 data->operation.operation = 0x16; 347 data->count++; 348 break; 349 case DASD_ECKD_CCW_WRITE: 350 case DASD_ECKD_CCW_WRITE_MT: 351 case DASD_ECKD_CCW_WRITE_KD: 352 case DASD_ECKD_CCW_WRITE_KD_MT: 353 data->auxiliary.length_valid = 0x1; 354 data->length = reclen; 355 data->operation.operation = 0x01; 356 break; 357 case DASD_ECKD_CCW_WRITE_CKD: 358 case DASD_ECKD_CCW_WRITE_CKD_MT: 359 data->auxiliary.length_valid = 0x1; 360 data->length = reclen; 361 data->operation.operation = 0x03; 362 break; 363 case DASD_ECKD_CCW_WRITE_TRACK_DATA: 364 data->auxiliary.length_valid = 0x1; 365 data->length = reclen; /* not tlf, as one might think */ 366 data->operation.operation = 0x3F; 367 data->extended_operation = 0x23; 368 break; 369 case DASD_ECKD_CCW_READ: 370 case DASD_ECKD_CCW_READ_MT: 371 case DASD_ECKD_CCW_READ_KD: 372 case DASD_ECKD_CCW_READ_KD_MT: 373 data->auxiliary.length_valid = 0x1; 374 data->length = reclen; 375 data->operation.operation = 0x06; 376 break; 377 case DASD_ECKD_CCW_READ_CKD: 378 case DASD_ECKD_CCW_READ_CKD_MT: 379 data->auxiliary.length_valid = 0x1; 380 data->length = reclen; 381 data->operation.operation = 0x16; 382 break; 383 case DASD_ECKD_CCW_READ_COUNT: 384 data->operation.operation = 0x06; 385 break; 386 case DASD_ECKD_CCW_READ_TRACK_DATA: 387 data->auxiliary.length_valid = 0x1; 388 data->length = tlf; 389 data->operation.operation = 0x0C; 390 break; 391 case DASD_ECKD_CCW_ERASE: 392 data->length = reclen; 393 data->auxiliary.length_valid = 0x1; 394 data->operation.operation = 0x0b; 395 break; 396 default: 397 DBF_DEV_EVENT(DBF_ERR, device, 398 "fill LRE unknown opcode 0x%x", cmd); 399 BUG(); 400 } 401 set_ch_t(&data->seek_addr, 402 trk / private->rdc_data.trk_per_cyl, 403 trk % private->rdc_data.trk_per_cyl); 404 data->search_arg.cyl = data->seek_addr.cyl; 405 data->search_arg.head = data->seek_addr.head; 406 data->search_arg.record = rec_on_trk; 407 } 408 409 static int prefix_LRE(struct ccw1 *ccw, struct PFX_eckd_data *pfxdata, 410 unsigned int trk, unsigned int totrk, int cmd, 411 struct dasd_device *basedev, struct dasd_device *startdev, 412 unsigned char format, unsigned int rec_on_trk, int count, 413 unsigned int blksize, unsigned int tlf) 414 { 415 struct dasd_eckd_private *basepriv, *startpriv; 416 struct DE_eckd_data *dedata; 417 struct LRE_eckd_data *lredata; 418 u32 begcyl, endcyl; 419 u16 heads, beghead, endhead; 420 int rc = 0; 421 422 basepriv = (struct dasd_eckd_private *) basedev->private; 423 startpriv = (struct dasd_eckd_private *) startdev->private; 424 dedata = &pfxdata->define_extent; 425 lredata = &pfxdata->locate_record; 426 427 ccw->cmd_code = DASD_ECKD_CCW_PFX; 428 ccw->flags = 0; 429 ccw->count = sizeof(*pfxdata); 430 ccw->cda = (__u32) __pa(pfxdata); 431 432 memset(pfxdata, 0, sizeof(*pfxdata)); 433 /* prefix data */ 434 if (format > 1) { 435 DBF_DEV_EVENT(DBF_ERR, basedev, 436 "PFX LRE unknown format 0x%x", format); 437 BUG(); 438 return -EINVAL; 439 } 440 pfxdata->format = format; 441 pfxdata->base_address = basepriv->ned->unit_addr; 442 pfxdata->base_lss = basepriv->ned->ID; 443 pfxdata->validity.define_extent = 1; 444 445 /* private uid is kept up to date, conf_data may be outdated */ 446 if (startpriv->uid.type != UA_BASE_DEVICE) { 447 pfxdata->validity.verify_base = 1; 448 if (startpriv->uid.type == UA_HYPER_PAV_ALIAS) 449 pfxdata->validity.hyper_pav = 1; 450 } 451 452 /* define extend data (mostly)*/ 453 switch (cmd) { 454 case DASD_ECKD_CCW_READ_HOME_ADDRESS: 455 case DASD_ECKD_CCW_READ_RECORD_ZERO: 456 case DASD_ECKD_CCW_READ: 457 case DASD_ECKD_CCW_READ_MT: 458 case DASD_ECKD_CCW_READ_CKD: 459 case DASD_ECKD_CCW_READ_CKD_MT: 460 case DASD_ECKD_CCW_READ_KD: 461 case DASD_ECKD_CCW_READ_KD_MT: 462 case DASD_ECKD_CCW_READ_COUNT: 463 dedata->mask.perm = 0x1; 464 dedata->attributes.operation = basepriv->attrib.operation; 465 break; 466 case DASD_ECKD_CCW_READ_TRACK_DATA: 467 dedata->mask.perm = 0x1; 468 dedata->attributes.operation = basepriv->attrib.operation; 469 dedata->blk_size = 0; 470 break; 471 case DASD_ECKD_CCW_WRITE: 472 case DASD_ECKD_CCW_WRITE_MT: 473 case DASD_ECKD_CCW_WRITE_KD: 474 case DASD_ECKD_CCW_WRITE_KD_MT: 475 dedata->mask.perm = 0x02; 476 dedata->attributes.operation = basepriv->attrib.operation; 477 rc = check_XRC_on_prefix(pfxdata, basedev); 478 break; 479 case DASD_ECKD_CCW_WRITE_CKD: 480 case DASD_ECKD_CCW_WRITE_CKD_MT: 481 dedata->attributes.operation = DASD_BYPASS_CACHE; 482 rc = check_XRC_on_prefix(pfxdata, basedev); 483 break; 484 case DASD_ECKD_CCW_ERASE: 485 case DASD_ECKD_CCW_WRITE_HOME_ADDRESS: 486 case DASD_ECKD_CCW_WRITE_RECORD_ZERO: 487 dedata->mask.perm = 0x3; 488 dedata->mask.auth = 0x1; 489 dedata->attributes.operation = DASD_BYPASS_CACHE; 490 rc = check_XRC_on_prefix(pfxdata, basedev); 491 break; 492 case DASD_ECKD_CCW_WRITE_TRACK_DATA: 493 dedata->mask.perm = 0x02; 494 dedata->attributes.operation = basepriv->attrib.operation; 495 dedata->blk_size = blksize; 496 rc = check_XRC_on_prefix(pfxdata, basedev); 497 break; 498 default: 499 DBF_DEV_EVENT(DBF_ERR, basedev, 500 "PFX LRE unknown opcode 0x%x", cmd); 501 BUG(); 502 return -EINVAL; 503 } 504 505 dedata->attributes.mode = 0x3; /* ECKD */ 506 507 if ((basepriv->rdc_data.cu_type == 0x2105 || 508 basepriv->rdc_data.cu_type == 0x2107 || 509 basepriv->rdc_data.cu_type == 0x1750) 510 && !(basepriv->uses_cdl && trk < 2)) 511 dedata->ga_extended |= 0x40; /* Regular Data Format Mode */ 512 513 heads = basepriv->rdc_data.trk_per_cyl; 514 begcyl = trk / heads; 515 beghead = trk % heads; 516 endcyl = totrk / heads; 517 endhead = totrk % heads; 518 519 /* check for sequential prestage - enhance cylinder range */ 520 if (dedata->attributes.operation == DASD_SEQ_PRESTAGE || 521 dedata->attributes.operation == DASD_SEQ_ACCESS) { 522 523 if (endcyl + basepriv->attrib.nr_cyl < basepriv->real_cyl) 524 endcyl += basepriv->attrib.nr_cyl; 525 else 526 endcyl = (basepriv->real_cyl - 1); 527 } 528 529 set_ch_t(&dedata->beg_ext, begcyl, beghead); 530 set_ch_t(&dedata->end_ext, endcyl, endhead); 531 532 if (format == 1) { 533 fill_LRE_data(lredata, trk, rec_on_trk, count, cmd, 534 basedev, blksize, tlf); 535 } 536 537 return rc; 538 } 539 540 static int prefix(struct ccw1 *ccw, struct PFX_eckd_data *pfxdata, 541 unsigned int trk, unsigned int totrk, int cmd, 542 struct dasd_device *basedev, struct dasd_device *startdev) 543 { 544 return prefix_LRE(ccw, pfxdata, trk, totrk, cmd, basedev, startdev, 545 0, 0, 0, 0, 0); 546 } 547 548 static void 549 locate_record(struct ccw1 *ccw, struct LO_eckd_data *data, unsigned int trk, 550 unsigned int rec_on_trk, int no_rec, int cmd, 551 struct dasd_device * device, int reclen) 552 { 553 struct dasd_eckd_private *private; 554 int sector; 555 int dn, d; 556 557 private = (struct dasd_eckd_private *) device->private; 558 559 DBF_DEV_EVENT(DBF_INFO, device, 560 "Locate: trk %d, rec %d, no_rec %d, cmd %d, reclen %d", 561 trk, rec_on_trk, no_rec, cmd, reclen); 562 563 ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD; 564 ccw->flags = 0; 565 ccw->count = 16; 566 ccw->cda = (__u32) __pa(data); 567 568 memset(data, 0, sizeof(struct LO_eckd_data)); 569 sector = 0; 570 if (rec_on_trk) { 571 switch (private->rdc_data.dev_type) { 572 case 0x3390: 573 dn = ceil_quot(reclen + 6, 232); 574 d = 9 + ceil_quot(reclen + 6 * (dn + 1), 34); 575 sector = (49 + (rec_on_trk - 1) * (10 + d)) / 8; 576 break; 577 case 0x3380: 578 d = 7 + ceil_quot(reclen + 12, 32); 579 sector = (39 + (rec_on_trk - 1) * (8 + d)) / 7; 580 break; 581 } 582 } 583 data->sector = sector; 584 data->count = no_rec; 585 switch (cmd) { 586 case DASD_ECKD_CCW_WRITE_HOME_ADDRESS: 587 data->operation.orientation = 0x3; 588 data->operation.operation = 0x03; 589 break; 590 case DASD_ECKD_CCW_READ_HOME_ADDRESS: 591 data->operation.orientation = 0x3; 592 data->operation.operation = 0x16; 593 break; 594 case DASD_ECKD_CCW_WRITE_RECORD_ZERO: 595 data->operation.orientation = 0x1; 596 data->operation.operation = 0x03; 597 data->count++; 598 break; 599 case DASD_ECKD_CCW_READ_RECORD_ZERO: 600 data->operation.orientation = 0x3; 601 data->operation.operation = 0x16; 602 data->count++; 603 break; 604 case DASD_ECKD_CCW_WRITE: 605 case DASD_ECKD_CCW_WRITE_MT: 606 case DASD_ECKD_CCW_WRITE_KD: 607 case DASD_ECKD_CCW_WRITE_KD_MT: 608 data->auxiliary.last_bytes_used = 0x1; 609 data->length = reclen; 610 data->operation.operation = 0x01; 611 break; 612 case DASD_ECKD_CCW_WRITE_CKD: 613 case DASD_ECKD_CCW_WRITE_CKD_MT: 614 data->auxiliary.last_bytes_used = 0x1; 615 data->length = reclen; 616 data->operation.operation = 0x03; 617 break; 618 case DASD_ECKD_CCW_READ: 619 case DASD_ECKD_CCW_READ_MT: 620 case DASD_ECKD_CCW_READ_KD: 621 case DASD_ECKD_CCW_READ_KD_MT: 622 data->auxiliary.last_bytes_used = 0x1; 623 data->length = reclen; 624 data->operation.operation = 0x06; 625 break; 626 case DASD_ECKD_CCW_READ_CKD: 627 case DASD_ECKD_CCW_READ_CKD_MT: 628 data->auxiliary.last_bytes_used = 0x1; 629 data->length = reclen; 630 data->operation.operation = 0x16; 631 break; 632 case DASD_ECKD_CCW_READ_COUNT: 633 data->operation.operation = 0x06; 634 break; 635 case DASD_ECKD_CCW_ERASE: 636 data->length = reclen; 637 data->auxiliary.last_bytes_used = 0x1; 638 data->operation.operation = 0x0b; 639 break; 640 default: 641 DBF_DEV_EVENT(DBF_ERR, device, "unknown locate record " 642 "opcode 0x%x", cmd); 643 } 644 set_ch_t(&data->seek_addr, 645 trk / private->rdc_data.trk_per_cyl, 646 trk % private->rdc_data.trk_per_cyl); 647 data->search_arg.cyl = data->seek_addr.cyl; 648 data->search_arg.head = data->seek_addr.head; 649 data->search_arg.record = rec_on_trk; 650 } 651 652 /* 653 * Returns 1 if the block is one of the special blocks that needs 654 * to get read/written with the KD variant of the command. 655 * That is DASD_ECKD_READ_KD_MT instead of DASD_ECKD_READ_MT and 656 * DASD_ECKD_WRITE_KD_MT instead of DASD_ECKD_WRITE_MT. 657 * Luckily the KD variants differ only by one bit (0x08) from the 658 * normal variant. So don't wonder about code like: 659 * if (dasd_eckd_cdl_special(blk_per_trk, recid)) 660 * ccw->cmd_code |= 0x8; 661 */ 662 static inline int 663 dasd_eckd_cdl_special(int blk_per_trk, int recid) 664 { 665 if (recid < 3) 666 return 1; 667 if (recid < blk_per_trk) 668 return 0; 669 if (recid < 2 * blk_per_trk) 670 return 1; 671 return 0; 672 } 673 674 /* 675 * Returns the record size for the special blocks of the cdl format. 676 * Only returns something useful if dasd_eckd_cdl_special is true 677 * for the recid. 678 */ 679 static inline int 680 dasd_eckd_cdl_reclen(int recid) 681 { 682 if (recid < 3) 683 return sizes_trk0[recid]; 684 return LABEL_SIZE; 685 } 686 687 /* 688 * Generate device unique id that specifies the physical device. 689 */ 690 static int dasd_eckd_generate_uid(struct dasd_device *device, 691 struct dasd_uid *uid) 692 { 693 struct dasd_eckd_private *private; 694 int count; 695 696 private = (struct dasd_eckd_private *) device->private; 697 if (!private) 698 return -ENODEV; 699 if (!private->ned || !private->gneq) 700 return -ENODEV; 701 702 memset(uid, 0, sizeof(struct dasd_uid)); 703 memcpy(uid->vendor, private->ned->HDA_manufacturer, 704 sizeof(uid->vendor) - 1); 705 EBCASC(uid->vendor, sizeof(uid->vendor) - 1); 706 memcpy(uid->serial, private->ned->HDA_location, 707 sizeof(uid->serial) - 1); 708 EBCASC(uid->serial, sizeof(uid->serial) - 1); 709 uid->ssid = private->gneq->subsystemID; 710 uid->real_unit_addr = private->ned->unit_addr; 711 if (private->sneq) { 712 uid->type = private->sneq->sua_flags; 713 if (uid->type == UA_BASE_PAV_ALIAS) 714 uid->base_unit_addr = private->sneq->base_unit_addr; 715 } else { 716 uid->type = UA_BASE_DEVICE; 717 } 718 if (private->vdsneq) { 719 for (count = 0; count < 16; count++) { 720 sprintf(uid->vduit+2*count, "%02x", 721 private->vdsneq->uit[count]); 722 } 723 } 724 return 0; 725 } 726 727 static struct dasd_ccw_req *dasd_eckd_build_rcd_lpm(struct dasd_device *device, 728 void *rcd_buffer, 729 struct ciw *ciw, __u8 lpm) 730 { 731 struct dasd_ccw_req *cqr; 732 struct ccw1 *ccw; 733 734 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* RCD */, ciw->count, 735 device); 736 737 if (IS_ERR(cqr)) { 738 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 739 "Could not allocate RCD request"); 740 return cqr; 741 } 742 743 ccw = cqr->cpaddr; 744 ccw->cmd_code = ciw->cmd; 745 ccw->cda = (__u32)(addr_t)rcd_buffer; 746 ccw->count = ciw->count; 747 748 cqr->startdev = device; 749 cqr->memdev = device; 750 cqr->block = NULL; 751 cqr->expires = 10*HZ; 752 cqr->lpm = lpm; 753 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 754 cqr->retries = 2; 755 cqr->buildclk = get_clock(); 756 cqr->status = DASD_CQR_FILLED; 757 return cqr; 758 } 759 760 static int dasd_eckd_read_conf_lpm(struct dasd_device *device, 761 void **rcd_buffer, 762 int *rcd_buffer_size, __u8 lpm) 763 { 764 struct ciw *ciw; 765 char *rcd_buf = NULL; 766 int ret; 767 struct dasd_ccw_req *cqr; 768 769 /* 770 * scan for RCD command in extended SenseID data 771 */ 772 ciw = ccw_device_get_ciw(device->cdev, CIW_TYPE_RCD); 773 if (!ciw || ciw->cmd == 0) { 774 ret = -EOPNOTSUPP; 775 goto out_error; 776 } 777 rcd_buf = kzalloc(ciw->count, GFP_KERNEL | GFP_DMA); 778 if (!rcd_buf) { 779 ret = -ENOMEM; 780 goto out_error; 781 } 782 783 /* 784 * buffer has to start with EBCDIC "V1.0" to show 785 * support for virtual device SNEQ 786 */ 787 rcd_buf[0] = 0xE5; 788 rcd_buf[1] = 0xF1; 789 rcd_buf[2] = 0x4B; 790 rcd_buf[3] = 0xF0; 791 cqr = dasd_eckd_build_rcd_lpm(device, rcd_buf, ciw, lpm); 792 if (IS_ERR(cqr)) { 793 ret = PTR_ERR(cqr); 794 goto out_error; 795 } 796 ret = dasd_sleep_on(cqr); 797 /* 798 * on success we update the user input parms 799 */ 800 dasd_sfree_request(cqr, cqr->memdev); 801 if (ret) 802 goto out_error; 803 804 *rcd_buffer_size = ciw->count; 805 *rcd_buffer = rcd_buf; 806 return 0; 807 out_error: 808 kfree(rcd_buf); 809 *rcd_buffer = NULL; 810 *rcd_buffer_size = 0; 811 return ret; 812 } 813 814 static int dasd_eckd_identify_conf_parts(struct dasd_eckd_private *private) 815 { 816 817 struct dasd_sneq *sneq; 818 int i, count; 819 820 private->ned = NULL; 821 private->sneq = NULL; 822 private->vdsneq = NULL; 823 private->gneq = NULL; 824 count = private->conf_len / sizeof(struct dasd_sneq); 825 sneq = (struct dasd_sneq *)private->conf_data; 826 for (i = 0; i < count; ++i) { 827 if (sneq->flags.identifier == 1 && sneq->format == 1) 828 private->sneq = sneq; 829 else if (sneq->flags.identifier == 1 && sneq->format == 4) 830 private->vdsneq = (struct vd_sneq *)sneq; 831 else if (sneq->flags.identifier == 2) 832 private->gneq = (struct dasd_gneq *)sneq; 833 else if (sneq->flags.identifier == 3 && sneq->res1 == 1) 834 private->ned = (struct dasd_ned *)sneq; 835 sneq++; 836 } 837 if (!private->ned || !private->gneq) { 838 private->ned = NULL; 839 private->sneq = NULL; 840 private->vdsneq = NULL; 841 private->gneq = NULL; 842 return -EINVAL; 843 } 844 return 0; 845 846 }; 847 848 static unsigned char dasd_eckd_path_access(void *conf_data, int conf_len) 849 { 850 struct dasd_gneq *gneq; 851 int i, count, found; 852 853 count = conf_len / sizeof(*gneq); 854 gneq = (struct dasd_gneq *)conf_data; 855 found = 0; 856 for (i = 0; i < count; ++i) { 857 if (gneq->flags.identifier == 2) { 858 found = 1; 859 break; 860 } 861 gneq++; 862 } 863 if (found) 864 return ((char *)gneq)[18] & 0x07; 865 else 866 return 0; 867 } 868 869 static int dasd_eckd_read_conf(struct dasd_device *device) 870 { 871 void *conf_data; 872 int conf_len, conf_data_saved; 873 int rc; 874 __u8 lpm; 875 struct dasd_eckd_private *private; 876 struct dasd_eckd_path *path_data; 877 878 private = (struct dasd_eckd_private *) device->private; 879 path_data = (struct dasd_eckd_path *) &private->path_data; 880 path_data->opm = ccw_device_get_path_mask(device->cdev); 881 lpm = 0x80; 882 conf_data_saved = 0; 883 /* get configuration data per operational path */ 884 for (lpm = 0x80; lpm; lpm>>= 1) { 885 if (lpm & path_data->opm){ 886 rc = dasd_eckd_read_conf_lpm(device, &conf_data, 887 &conf_len, lpm); 888 if (rc && rc != -EOPNOTSUPP) { /* -EOPNOTSUPP is ok */ 889 DBF_EVENT(DBF_WARNING, 890 "Read configuration data returned " 891 "error %d for device: %s", rc, 892 dev_name(&device->cdev->dev)); 893 return rc; 894 } 895 if (conf_data == NULL) { 896 DBF_EVENT(DBF_WARNING, "No configuration " 897 "data retrieved for device: %s", 898 dev_name(&device->cdev->dev)); 899 continue; /* no error */ 900 } 901 /* save first valid configuration data */ 902 if (!conf_data_saved) { 903 kfree(private->conf_data); 904 private->conf_data = conf_data; 905 private->conf_len = conf_len; 906 if (dasd_eckd_identify_conf_parts(private)) { 907 private->conf_data = NULL; 908 private->conf_len = 0; 909 kfree(conf_data); 910 continue; 911 } 912 conf_data_saved++; 913 } 914 switch (dasd_eckd_path_access(conf_data, conf_len)) { 915 case 0x02: 916 path_data->npm |= lpm; 917 break; 918 case 0x03: 919 path_data->ppm |= lpm; 920 break; 921 } 922 if (conf_data != private->conf_data) 923 kfree(conf_data); 924 } 925 } 926 return 0; 927 } 928 929 static int dasd_eckd_read_features(struct dasd_device *device) 930 { 931 struct dasd_psf_prssd_data *prssdp; 932 struct dasd_rssd_features *features; 933 struct dasd_ccw_req *cqr; 934 struct ccw1 *ccw; 935 int rc; 936 struct dasd_eckd_private *private; 937 938 private = (struct dasd_eckd_private *) device->private; 939 memset(&private->features, 0, sizeof(struct dasd_rssd_features)); 940 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */, 941 (sizeof(struct dasd_psf_prssd_data) + 942 sizeof(struct dasd_rssd_features)), 943 device); 944 if (IS_ERR(cqr)) { 945 DBF_EVENT(DBF_WARNING, "Could not allocate initialization " 946 "request for device: %s", 947 dev_name(&device->cdev->dev)); 948 return PTR_ERR(cqr); 949 } 950 cqr->startdev = device; 951 cqr->memdev = device; 952 cqr->block = NULL; 953 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 954 cqr->retries = 5; 955 cqr->expires = 10 * HZ; 956 957 /* Prepare for Read Subsystem Data */ 958 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 959 memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data)); 960 prssdp->order = PSF_ORDER_PRSSD; 961 prssdp->suborder = 0x41; /* Read Feature Codes */ 962 /* all other bytes of prssdp must be zero */ 963 964 ccw = cqr->cpaddr; 965 ccw->cmd_code = DASD_ECKD_CCW_PSF; 966 ccw->count = sizeof(struct dasd_psf_prssd_data); 967 ccw->flags |= CCW_FLAG_CC; 968 ccw->cda = (__u32)(addr_t) prssdp; 969 970 /* Read Subsystem Data - feature codes */ 971 features = (struct dasd_rssd_features *) (prssdp + 1); 972 memset(features, 0, sizeof(struct dasd_rssd_features)); 973 974 ccw++; 975 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 976 ccw->count = sizeof(struct dasd_rssd_features); 977 ccw->cda = (__u32)(addr_t) features; 978 979 cqr->buildclk = get_clock(); 980 cqr->status = DASD_CQR_FILLED; 981 rc = dasd_sleep_on(cqr); 982 if (rc == 0) { 983 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 984 features = (struct dasd_rssd_features *) (prssdp + 1); 985 memcpy(&private->features, features, 986 sizeof(struct dasd_rssd_features)); 987 } else 988 dev_warn(&device->cdev->dev, "Reading device feature codes" 989 " failed with rc=%d\n", rc); 990 dasd_sfree_request(cqr, cqr->memdev); 991 return rc; 992 } 993 994 995 /* 996 * Build CP for Perform Subsystem Function - SSC. 997 */ 998 static struct dasd_ccw_req *dasd_eckd_build_psf_ssc(struct dasd_device *device, 999 int enable_pav) 1000 { 1001 struct dasd_ccw_req *cqr; 1002 struct dasd_psf_ssc_data *psf_ssc_data; 1003 struct ccw1 *ccw; 1004 1005 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ , 1006 sizeof(struct dasd_psf_ssc_data), 1007 device); 1008 1009 if (IS_ERR(cqr)) { 1010 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 1011 "Could not allocate PSF-SSC request"); 1012 return cqr; 1013 } 1014 psf_ssc_data = (struct dasd_psf_ssc_data *)cqr->data; 1015 psf_ssc_data->order = PSF_ORDER_SSC; 1016 psf_ssc_data->suborder = 0x40; 1017 if (enable_pav) { 1018 psf_ssc_data->suborder |= 0x88; 1019 psf_ssc_data->reserved[0] = 0x88; 1020 } 1021 ccw = cqr->cpaddr; 1022 ccw->cmd_code = DASD_ECKD_CCW_PSF; 1023 ccw->cda = (__u32)(addr_t)psf_ssc_data; 1024 ccw->count = 66; 1025 1026 cqr->startdev = device; 1027 cqr->memdev = device; 1028 cqr->block = NULL; 1029 cqr->expires = 10*HZ; 1030 cqr->buildclk = get_clock(); 1031 cqr->status = DASD_CQR_FILLED; 1032 return cqr; 1033 } 1034 1035 /* 1036 * Perform Subsystem Function. 1037 * It is necessary to trigger CIO for channel revalidation since this 1038 * call might change behaviour of DASD devices. 1039 */ 1040 static int 1041 dasd_eckd_psf_ssc(struct dasd_device *device, int enable_pav) 1042 { 1043 struct dasd_ccw_req *cqr; 1044 int rc; 1045 1046 cqr = dasd_eckd_build_psf_ssc(device, enable_pav); 1047 if (IS_ERR(cqr)) 1048 return PTR_ERR(cqr); 1049 1050 rc = dasd_sleep_on(cqr); 1051 if (!rc) 1052 /* trigger CIO to reprobe devices */ 1053 css_schedule_reprobe(); 1054 dasd_sfree_request(cqr, cqr->memdev); 1055 return rc; 1056 } 1057 1058 /* 1059 * Valide storage server of current device. 1060 */ 1061 static int dasd_eckd_validate_server(struct dasd_device *device) 1062 { 1063 int rc; 1064 struct dasd_eckd_private *private; 1065 int enable_pav; 1066 1067 if (dasd_nopav || MACHINE_IS_VM) 1068 enable_pav = 0; 1069 else 1070 enable_pav = 1; 1071 rc = dasd_eckd_psf_ssc(device, enable_pav); 1072 /* may be requested feature is not available on server, 1073 * therefore just report error and go ahead */ 1074 private = (struct dasd_eckd_private *) device->private; 1075 DBF_EVENT(DBF_WARNING, "PSF-SSC on storage subsystem %s.%s.%04x " 1076 "returned rc=%d for device: %s", 1077 private->uid.vendor, private->uid.serial, 1078 private->uid.ssid, rc, dev_name(&device->cdev->dev)); 1079 /* RE-Read Configuration Data */ 1080 return dasd_eckd_read_conf(device); 1081 } 1082 1083 /* 1084 * Check device characteristics. 1085 * If the device is accessible using ECKD discipline, the device is enabled. 1086 */ 1087 static int 1088 dasd_eckd_check_characteristics(struct dasd_device *device) 1089 { 1090 struct dasd_eckd_private *private; 1091 struct dasd_block *block; 1092 int is_known, rc; 1093 1094 if (!ccw_device_is_pathgroup(device->cdev)) { 1095 dev_warn(&device->cdev->dev, 1096 "A channel path group could not be established\n"); 1097 return -EIO; 1098 } 1099 if (!ccw_device_is_multipath(device->cdev)) { 1100 dev_info(&device->cdev->dev, 1101 "The DASD is not operating in multipath mode\n"); 1102 } 1103 private = (struct dasd_eckd_private *) device->private; 1104 if (!private) { 1105 private = kzalloc(sizeof(*private), GFP_KERNEL | GFP_DMA); 1106 if (!private) { 1107 dev_warn(&device->cdev->dev, 1108 "Allocating memory for private DASD data " 1109 "failed\n"); 1110 return -ENOMEM; 1111 } 1112 device->private = (void *) private; 1113 } else { 1114 memset(private, 0, sizeof(*private)); 1115 } 1116 /* Invalidate status of initial analysis. */ 1117 private->init_cqr_status = -1; 1118 /* Set default cache operations. */ 1119 private->attrib.operation = DASD_NORMAL_CACHE; 1120 private->attrib.nr_cyl = 0; 1121 1122 /* Read Configuration Data */ 1123 rc = dasd_eckd_read_conf(device); 1124 if (rc) 1125 goto out_err1; 1126 1127 /* Generate device unique id and register in devmap */ 1128 rc = dasd_eckd_generate_uid(device, &private->uid); 1129 if (rc) 1130 goto out_err1; 1131 dasd_set_uid(device->cdev, &private->uid); 1132 1133 if (private->uid.type == UA_BASE_DEVICE) { 1134 block = dasd_alloc_block(); 1135 if (IS_ERR(block)) { 1136 DBF_EVENT(DBF_WARNING, "could not allocate dasd " 1137 "block structure for device: %s", 1138 dev_name(&device->cdev->dev)); 1139 rc = PTR_ERR(block); 1140 goto out_err1; 1141 } 1142 device->block = block; 1143 block->base = device; 1144 } 1145 1146 /* register lcu with alias handling, enable PAV if this is a new lcu */ 1147 is_known = dasd_alias_make_device_known_to_lcu(device); 1148 if (is_known < 0) { 1149 rc = is_known; 1150 goto out_err2; 1151 } 1152 if (!is_known) { 1153 /* new lcu found */ 1154 rc = dasd_eckd_validate_server(device); /* will switch pav on */ 1155 if (rc) 1156 goto out_err3; 1157 } 1158 1159 /* Read Feature Codes */ 1160 dasd_eckd_read_features(device); 1161 1162 /* Read Device Characteristics */ 1163 rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC, 1164 &private->rdc_data, 64); 1165 if (rc) { 1166 DBF_EVENT(DBF_WARNING, 1167 "Read device characteristics failed, rc=%d for " 1168 "device: %s", rc, dev_name(&device->cdev->dev)); 1169 goto out_err3; 1170 } 1171 /* find the vaild cylinder size */ 1172 if (private->rdc_data.no_cyl == LV_COMPAT_CYL && 1173 private->rdc_data.long_no_cyl) 1174 private->real_cyl = private->rdc_data.long_no_cyl; 1175 else 1176 private->real_cyl = private->rdc_data.no_cyl; 1177 1178 dev_info(&device->cdev->dev, "New DASD %04X/%02X (CU %04X/%02X) " 1179 "with %d cylinders, %d heads, %d sectors\n", 1180 private->rdc_data.dev_type, 1181 private->rdc_data.dev_model, 1182 private->rdc_data.cu_type, 1183 private->rdc_data.cu_model.model, 1184 private->real_cyl, 1185 private->rdc_data.trk_per_cyl, 1186 private->rdc_data.sec_per_trk); 1187 return 0; 1188 1189 out_err3: 1190 dasd_alias_disconnect_device_from_lcu(device); 1191 out_err2: 1192 dasd_free_block(device->block); 1193 device->block = NULL; 1194 out_err1: 1195 kfree(private->conf_data); 1196 kfree(device->private); 1197 device->private = NULL; 1198 return rc; 1199 } 1200 1201 static void dasd_eckd_uncheck_device(struct dasd_device *device) 1202 { 1203 struct dasd_eckd_private *private; 1204 1205 private = (struct dasd_eckd_private *) device->private; 1206 dasd_alias_disconnect_device_from_lcu(device); 1207 private->ned = NULL; 1208 private->sneq = NULL; 1209 private->vdsneq = NULL; 1210 private->gneq = NULL; 1211 private->conf_len = 0; 1212 kfree(private->conf_data); 1213 private->conf_data = NULL; 1214 } 1215 1216 static struct dasd_ccw_req * 1217 dasd_eckd_analysis_ccw(struct dasd_device *device) 1218 { 1219 struct dasd_eckd_private *private; 1220 struct eckd_count *count_data; 1221 struct LO_eckd_data *LO_data; 1222 struct dasd_ccw_req *cqr; 1223 struct ccw1 *ccw; 1224 int cplength, datasize; 1225 int i; 1226 1227 private = (struct dasd_eckd_private *) device->private; 1228 1229 cplength = 8; 1230 datasize = sizeof(struct DE_eckd_data) + 2*sizeof(struct LO_eckd_data); 1231 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, device); 1232 if (IS_ERR(cqr)) 1233 return cqr; 1234 ccw = cqr->cpaddr; 1235 /* Define extent for the first 3 tracks. */ 1236 define_extent(ccw++, cqr->data, 0, 2, 1237 DASD_ECKD_CCW_READ_COUNT, device); 1238 LO_data = cqr->data + sizeof(struct DE_eckd_data); 1239 /* Locate record for the first 4 records on track 0. */ 1240 ccw[-1].flags |= CCW_FLAG_CC; 1241 locate_record(ccw++, LO_data++, 0, 0, 4, 1242 DASD_ECKD_CCW_READ_COUNT, device, 0); 1243 1244 count_data = private->count_area; 1245 for (i = 0; i < 4; i++) { 1246 ccw[-1].flags |= CCW_FLAG_CC; 1247 ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT; 1248 ccw->flags = 0; 1249 ccw->count = 8; 1250 ccw->cda = (__u32)(addr_t) count_data; 1251 ccw++; 1252 count_data++; 1253 } 1254 1255 /* Locate record for the first record on track 2. */ 1256 ccw[-1].flags |= CCW_FLAG_CC; 1257 locate_record(ccw++, LO_data++, 2, 0, 1, 1258 DASD_ECKD_CCW_READ_COUNT, device, 0); 1259 /* Read count ccw. */ 1260 ccw[-1].flags |= CCW_FLAG_CC; 1261 ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT; 1262 ccw->flags = 0; 1263 ccw->count = 8; 1264 ccw->cda = (__u32)(addr_t) count_data; 1265 1266 cqr->block = NULL; 1267 cqr->startdev = device; 1268 cqr->memdev = device; 1269 cqr->retries = 0; 1270 cqr->buildclk = get_clock(); 1271 cqr->status = DASD_CQR_FILLED; 1272 return cqr; 1273 } 1274 1275 /* 1276 * This is the callback function for the init_analysis cqr. It saves 1277 * the status of the initial analysis ccw before it frees it and kicks 1278 * the device to continue the startup sequence. This will call 1279 * dasd_eckd_do_analysis again (if the devices has not been marked 1280 * for deletion in the meantime). 1281 */ 1282 static void 1283 dasd_eckd_analysis_callback(struct dasd_ccw_req *init_cqr, void *data) 1284 { 1285 struct dasd_eckd_private *private; 1286 struct dasd_device *device; 1287 1288 device = init_cqr->startdev; 1289 private = (struct dasd_eckd_private *) device->private; 1290 private->init_cqr_status = init_cqr->status; 1291 dasd_sfree_request(init_cqr, device); 1292 dasd_kick_device(device); 1293 } 1294 1295 static int 1296 dasd_eckd_start_analysis(struct dasd_block *block) 1297 { 1298 struct dasd_eckd_private *private; 1299 struct dasd_ccw_req *init_cqr; 1300 1301 private = (struct dasd_eckd_private *) block->base->private; 1302 init_cqr = dasd_eckd_analysis_ccw(block->base); 1303 if (IS_ERR(init_cqr)) 1304 return PTR_ERR(init_cqr); 1305 init_cqr->callback = dasd_eckd_analysis_callback; 1306 init_cqr->callback_data = NULL; 1307 init_cqr->expires = 5*HZ; 1308 dasd_add_request_head(init_cqr); 1309 return -EAGAIN; 1310 } 1311 1312 static int 1313 dasd_eckd_end_analysis(struct dasd_block *block) 1314 { 1315 struct dasd_device *device; 1316 struct dasd_eckd_private *private; 1317 struct eckd_count *count_area; 1318 unsigned int sb, blk_per_trk; 1319 int status, i; 1320 1321 device = block->base; 1322 private = (struct dasd_eckd_private *) device->private; 1323 status = private->init_cqr_status; 1324 private->init_cqr_status = -1; 1325 if (status != DASD_CQR_DONE) { 1326 dev_warn(&device->cdev->dev, 1327 "The DASD is not formatted\n"); 1328 return -EMEDIUMTYPE; 1329 } 1330 1331 private->uses_cdl = 1; 1332 /* Check Track 0 for Compatible Disk Layout */ 1333 count_area = NULL; 1334 for (i = 0; i < 3; i++) { 1335 if (private->count_area[i].kl != 4 || 1336 private->count_area[i].dl != dasd_eckd_cdl_reclen(i) - 4) { 1337 private->uses_cdl = 0; 1338 break; 1339 } 1340 } 1341 if (i == 3) 1342 count_area = &private->count_area[4]; 1343 1344 if (private->uses_cdl == 0) { 1345 for (i = 0; i < 5; i++) { 1346 if ((private->count_area[i].kl != 0) || 1347 (private->count_area[i].dl != 1348 private->count_area[0].dl)) 1349 break; 1350 } 1351 if (i == 5) 1352 count_area = &private->count_area[0]; 1353 } else { 1354 if (private->count_area[3].record == 1) 1355 dev_warn(&device->cdev->dev, 1356 "Track 0 has no records following the VTOC\n"); 1357 } 1358 if (count_area != NULL && count_area->kl == 0) { 1359 /* we found notthing violating our disk layout */ 1360 if (dasd_check_blocksize(count_area->dl) == 0) 1361 block->bp_block = count_area->dl; 1362 } 1363 if (block->bp_block == 0) { 1364 dev_warn(&device->cdev->dev, 1365 "The disk layout of the DASD is not supported\n"); 1366 return -EMEDIUMTYPE; 1367 } 1368 block->s2b_shift = 0; /* bits to shift 512 to get a block */ 1369 for (sb = 512; sb < block->bp_block; sb = sb << 1) 1370 block->s2b_shift++; 1371 1372 blk_per_trk = recs_per_track(&private->rdc_data, 0, block->bp_block); 1373 block->blocks = (private->real_cyl * 1374 private->rdc_data.trk_per_cyl * 1375 blk_per_trk); 1376 1377 dev_info(&device->cdev->dev, 1378 "DASD with %d KB/block, %d KB total size, %d KB/track, " 1379 "%s\n", (block->bp_block >> 10), 1380 ((private->real_cyl * 1381 private->rdc_data.trk_per_cyl * 1382 blk_per_trk * (block->bp_block >> 9)) >> 1), 1383 ((blk_per_trk * block->bp_block) >> 10), 1384 private->uses_cdl ? 1385 "compatible disk layout" : "linux disk layout"); 1386 1387 return 0; 1388 } 1389 1390 static int dasd_eckd_do_analysis(struct dasd_block *block) 1391 { 1392 struct dasd_eckd_private *private; 1393 1394 private = (struct dasd_eckd_private *) block->base->private; 1395 if (private->init_cqr_status < 0) 1396 return dasd_eckd_start_analysis(block); 1397 else 1398 return dasd_eckd_end_analysis(block); 1399 } 1400 1401 static int dasd_eckd_ready_to_online(struct dasd_device *device) 1402 { 1403 return dasd_alias_add_device(device); 1404 }; 1405 1406 static int dasd_eckd_online_to_ready(struct dasd_device *device) 1407 { 1408 return dasd_alias_remove_device(device); 1409 }; 1410 1411 static int 1412 dasd_eckd_fill_geometry(struct dasd_block *block, struct hd_geometry *geo) 1413 { 1414 struct dasd_eckd_private *private; 1415 1416 private = (struct dasd_eckd_private *) block->base->private; 1417 if (dasd_check_blocksize(block->bp_block) == 0) { 1418 geo->sectors = recs_per_track(&private->rdc_data, 1419 0, block->bp_block); 1420 } 1421 geo->cylinders = private->rdc_data.no_cyl; 1422 geo->heads = private->rdc_data.trk_per_cyl; 1423 return 0; 1424 } 1425 1426 static struct dasd_ccw_req * 1427 dasd_eckd_format_device(struct dasd_device * device, 1428 struct format_data_t * fdata) 1429 { 1430 struct dasd_eckd_private *private; 1431 struct dasd_ccw_req *fcp; 1432 struct eckd_count *ect; 1433 struct ccw1 *ccw; 1434 void *data; 1435 int rpt; 1436 struct ch_t address; 1437 int cplength, datasize; 1438 int i; 1439 int intensity = 0; 1440 int r0_perm; 1441 1442 private = (struct dasd_eckd_private *) device->private; 1443 rpt = recs_per_track(&private->rdc_data, 0, fdata->blksize); 1444 set_ch_t(&address, 1445 fdata->start_unit / private->rdc_data.trk_per_cyl, 1446 fdata->start_unit % private->rdc_data.trk_per_cyl); 1447 1448 /* Sanity checks. */ 1449 if (fdata->start_unit >= 1450 (private->real_cyl * private->rdc_data.trk_per_cyl)) { 1451 dev_warn(&device->cdev->dev, "Start track number %d used in " 1452 "formatting is too big\n", fdata->start_unit); 1453 return ERR_PTR(-EINVAL); 1454 } 1455 if (fdata->start_unit > fdata->stop_unit) { 1456 dev_warn(&device->cdev->dev, "Start track %d used in " 1457 "formatting exceeds end track\n", fdata->start_unit); 1458 return ERR_PTR(-EINVAL); 1459 } 1460 if (dasd_check_blocksize(fdata->blksize) != 0) { 1461 dev_warn(&device->cdev->dev, 1462 "The DASD cannot be formatted with block size %d\n", 1463 fdata->blksize); 1464 return ERR_PTR(-EINVAL); 1465 } 1466 1467 /* 1468 * fdata->intensity is a bit string that tells us what to do: 1469 * Bit 0: write record zero 1470 * Bit 1: write home address, currently not supported 1471 * Bit 2: invalidate tracks 1472 * Bit 3: use OS/390 compatible disk layout (cdl) 1473 * Bit 4: do not allow storage subsystem to modify record zero 1474 * Only some bit combinations do make sense. 1475 */ 1476 if (fdata->intensity & 0x10) { 1477 r0_perm = 0; 1478 intensity = fdata->intensity & ~0x10; 1479 } else { 1480 r0_perm = 1; 1481 intensity = fdata->intensity; 1482 } 1483 switch (intensity) { 1484 case 0x00: /* Normal format */ 1485 case 0x08: /* Normal format, use cdl. */ 1486 cplength = 2 + rpt; 1487 datasize = sizeof(struct DE_eckd_data) + 1488 sizeof(struct LO_eckd_data) + 1489 rpt * sizeof(struct eckd_count); 1490 break; 1491 case 0x01: /* Write record zero and format track. */ 1492 case 0x09: /* Write record zero and format track, use cdl. */ 1493 cplength = 3 + rpt; 1494 datasize = sizeof(struct DE_eckd_data) + 1495 sizeof(struct LO_eckd_data) + 1496 sizeof(struct eckd_count) + 1497 rpt * sizeof(struct eckd_count); 1498 break; 1499 case 0x04: /* Invalidate track. */ 1500 case 0x0c: /* Invalidate track, use cdl. */ 1501 cplength = 3; 1502 datasize = sizeof(struct DE_eckd_data) + 1503 sizeof(struct LO_eckd_data) + 1504 sizeof(struct eckd_count); 1505 break; 1506 default: 1507 dev_warn(&device->cdev->dev, "An I/O control call used " 1508 "incorrect flags 0x%x\n", fdata->intensity); 1509 return ERR_PTR(-EINVAL); 1510 } 1511 /* Allocate the format ccw request. */ 1512 fcp = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, device); 1513 if (IS_ERR(fcp)) 1514 return fcp; 1515 1516 data = fcp->data; 1517 ccw = fcp->cpaddr; 1518 1519 switch (intensity & ~0x08) { 1520 case 0x00: /* Normal format. */ 1521 define_extent(ccw++, (struct DE_eckd_data *) data, 1522 fdata->start_unit, fdata->start_unit, 1523 DASD_ECKD_CCW_WRITE_CKD, device); 1524 /* grant subsystem permission to format R0 */ 1525 if (r0_perm) 1526 ((struct DE_eckd_data *)data)->ga_extended |= 0x04; 1527 data += sizeof(struct DE_eckd_data); 1528 ccw[-1].flags |= CCW_FLAG_CC; 1529 locate_record(ccw++, (struct LO_eckd_data *) data, 1530 fdata->start_unit, 0, rpt, 1531 DASD_ECKD_CCW_WRITE_CKD, device, 1532 fdata->blksize); 1533 data += sizeof(struct LO_eckd_data); 1534 break; 1535 case 0x01: /* Write record zero + format track. */ 1536 define_extent(ccw++, (struct DE_eckd_data *) data, 1537 fdata->start_unit, fdata->start_unit, 1538 DASD_ECKD_CCW_WRITE_RECORD_ZERO, 1539 device); 1540 data += sizeof(struct DE_eckd_data); 1541 ccw[-1].flags |= CCW_FLAG_CC; 1542 locate_record(ccw++, (struct LO_eckd_data *) data, 1543 fdata->start_unit, 0, rpt + 1, 1544 DASD_ECKD_CCW_WRITE_RECORD_ZERO, device, 1545 device->block->bp_block); 1546 data += sizeof(struct LO_eckd_data); 1547 break; 1548 case 0x04: /* Invalidate track. */ 1549 define_extent(ccw++, (struct DE_eckd_data *) data, 1550 fdata->start_unit, fdata->start_unit, 1551 DASD_ECKD_CCW_WRITE_CKD, device); 1552 data += sizeof(struct DE_eckd_data); 1553 ccw[-1].flags |= CCW_FLAG_CC; 1554 locate_record(ccw++, (struct LO_eckd_data *) data, 1555 fdata->start_unit, 0, 1, 1556 DASD_ECKD_CCW_WRITE_CKD, device, 8); 1557 data += sizeof(struct LO_eckd_data); 1558 break; 1559 } 1560 if (intensity & 0x01) { /* write record zero */ 1561 ect = (struct eckd_count *) data; 1562 data += sizeof(struct eckd_count); 1563 ect->cyl = address.cyl; 1564 ect->head = address.head; 1565 ect->record = 0; 1566 ect->kl = 0; 1567 ect->dl = 8; 1568 ccw[-1].flags |= CCW_FLAG_CC; 1569 ccw->cmd_code = DASD_ECKD_CCW_WRITE_RECORD_ZERO; 1570 ccw->flags = CCW_FLAG_SLI; 1571 ccw->count = 8; 1572 ccw->cda = (__u32)(addr_t) ect; 1573 ccw++; 1574 } 1575 if ((intensity & ~0x08) & 0x04) { /* erase track */ 1576 ect = (struct eckd_count *) data; 1577 data += sizeof(struct eckd_count); 1578 ect->cyl = address.cyl; 1579 ect->head = address.head; 1580 ect->record = 1; 1581 ect->kl = 0; 1582 ect->dl = 0; 1583 ccw[-1].flags |= CCW_FLAG_CC; 1584 ccw->cmd_code = DASD_ECKD_CCW_WRITE_CKD; 1585 ccw->flags = CCW_FLAG_SLI; 1586 ccw->count = 8; 1587 ccw->cda = (__u32)(addr_t) ect; 1588 } else { /* write remaining records */ 1589 for (i = 0; i < rpt; i++) { 1590 ect = (struct eckd_count *) data; 1591 data += sizeof(struct eckd_count); 1592 ect->cyl = address.cyl; 1593 ect->head = address.head; 1594 ect->record = i + 1; 1595 ect->kl = 0; 1596 ect->dl = fdata->blksize; 1597 /* Check for special tracks 0-1 when formatting CDL */ 1598 if ((intensity & 0x08) && 1599 fdata->start_unit == 0) { 1600 if (i < 3) { 1601 ect->kl = 4; 1602 ect->dl = sizes_trk0[i] - 4; 1603 } 1604 } 1605 if ((intensity & 0x08) && 1606 fdata->start_unit == 1) { 1607 ect->kl = 44; 1608 ect->dl = LABEL_SIZE - 44; 1609 } 1610 ccw[-1].flags |= CCW_FLAG_CC; 1611 ccw->cmd_code = DASD_ECKD_CCW_WRITE_CKD; 1612 ccw->flags = CCW_FLAG_SLI; 1613 ccw->count = 8; 1614 ccw->cda = (__u32)(addr_t) ect; 1615 ccw++; 1616 } 1617 } 1618 fcp->startdev = device; 1619 fcp->memdev = device; 1620 clear_bit(DASD_CQR_FLAGS_USE_ERP, &fcp->flags); 1621 fcp->retries = 5; /* set retry counter to enable default ERP */ 1622 fcp->buildclk = get_clock(); 1623 fcp->status = DASD_CQR_FILLED; 1624 return fcp; 1625 } 1626 1627 static void dasd_eckd_handle_terminated_request(struct dasd_ccw_req *cqr) 1628 { 1629 cqr->status = DASD_CQR_FILLED; 1630 if (cqr->block && (cqr->startdev != cqr->block->base)) { 1631 dasd_eckd_reset_ccw_to_base_io(cqr); 1632 cqr->startdev = cqr->block->base; 1633 } 1634 }; 1635 1636 static dasd_erp_fn_t 1637 dasd_eckd_erp_action(struct dasd_ccw_req * cqr) 1638 { 1639 struct dasd_device *device = (struct dasd_device *) cqr->startdev; 1640 struct ccw_device *cdev = device->cdev; 1641 1642 switch (cdev->id.cu_type) { 1643 case 0x3990: 1644 case 0x2105: 1645 case 0x2107: 1646 case 0x1750: 1647 return dasd_3990_erp_action; 1648 case 0x9343: 1649 case 0x3880: 1650 default: 1651 return dasd_default_erp_action; 1652 } 1653 } 1654 1655 static dasd_erp_fn_t 1656 dasd_eckd_erp_postaction(struct dasd_ccw_req * cqr) 1657 { 1658 return dasd_default_erp_postaction; 1659 } 1660 1661 1662 static void dasd_eckd_handle_unsolicited_interrupt(struct dasd_device *device, 1663 struct irb *irb) 1664 { 1665 char mask; 1666 char *sense = NULL; 1667 1668 /* first of all check for state change pending interrupt */ 1669 mask = DEV_STAT_ATTENTION | DEV_STAT_DEV_END | DEV_STAT_UNIT_EXCEP; 1670 if ((scsw_dstat(&irb->scsw) & mask) == mask) { 1671 dasd_generic_handle_state_change(device); 1672 return; 1673 } 1674 1675 /* summary unit check */ 1676 if ((scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK) && 1677 (irb->ecw[7] == 0x0D)) { 1678 dasd_alias_handle_summary_unit_check(device, irb); 1679 return; 1680 } 1681 1682 sense = dasd_get_sense(irb); 1683 /* service information message SIM */ 1684 if (sense && !(sense[27] & DASD_SENSE_BIT_0) && 1685 ((sense[6] & DASD_SIM_SENSE) == DASD_SIM_SENSE)) { 1686 dasd_3990_erp_handle_sim(device, sense); 1687 dasd_schedule_device_bh(device); 1688 return; 1689 } 1690 1691 if ((scsw_cc(&irb->scsw) == 1) && 1692 (scsw_fctl(&irb->scsw) & SCSW_FCTL_START_FUNC) && 1693 (scsw_actl(&irb->scsw) & SCSW_ACTL_START_PEND) && 1694 (scsw_stctl(&irb->scsw) & SCSW_STCTL_STATUS_PEND)) { 1695 /* fake irb do nothing, they are handled elsewhere */ 1696 dasd_schedule_device_bh(device); 1697 return; 1698 } 1699 1700 if (!sense) { 1701 /* just report other unsolicited interrupts */ 1702 DBF_DEV_EVENT(DBF_ERR, device, "%s", 1703 "unsolicited interrupt received"); 1704 } else { 1705 DBF_DEV_EVENT(DBF_ERR, device, "%s", 1706 "unsolicited interrupt received " 1707 "(sense available)"); 1708 device->discipline->dump_sense_dbf(device, irb, "unsolicited"); 1709 } 1710 1711 dasd_schedule_device_bh(device); 1712 return; 1713 }; 1714 1715 1716 static struct dasd_ccw_req *dasd_eckd_build_cp_cmd_single( 1717 struct dasd_device *startdev, 1718 struct dasd_block *block, 1719 struct request *req, 1720 sector_t first_rec, 1721 sector_t last_rec, 1722 sector_t first_trk, 1723 sector_t last_trk, 1724 unsigned int first_offs, 1725 unsigned int last_offs, 1726 unsigned int blk_per_trk, 1727 unsigned int blksize) 1728 { 1729 struct dasd_eckd_private *private; 1730 unsigned long *idaws; 1731 struct LO_eckd_data *LO_data; 1732 struct dasd_ccw_req *cqr; 1733 struct ccw1 *ccw; 1734 struct req_iterator iter; 1735 struct bio_vec *bv; 1736 char *dst; 1737 unsigned int off; 1738 int count, cidaw, cplength, datasize; 1739 sector_t recid; 1740 unsigned char cmd, rcmd; 1741 int use_prefix; 1742 struct dasd_device *basedev; 1743 1744 basedev = block->base; 1745 private = (struct dasd_eckd_private *) basedev->private; 1746 if (rq_data_dir(req) == READ) 1747 cmd = DASD_ECKD_CCW_READ_MT; 1748 else if (rq_data_dir(req) == WRITE) 1749 cmd = DASD_ECKD_CCW_WRITE_MT; 1750 else 1751 return ERR_PTR(-EINVAL); 1752 1753 /* Check struct bio and count the number of blocks for the request. */ 1754 count = 0; 1755 cidaw = 0; 1756 rq_for_each_segment(bv, req, iter) { 1757 if (bv->bv_len & (blksize - 1)) 1758 /* Eckd can only do full blocks. */ 1759 return ERR_PTR(-EINVAL); 1760 count += bv->bv_len >> (block->s2b_shift + 9); 1761 #if defined(CONFIG_64BIT) 1762 if (idal_is_needed (page_address(bv->bv_page), bv->bv_len)) 1763 cidaw += bv->bv_len >> (block->s2b_shift + 9); 1764 #endif 1765 } 1766 /* Paranoia. */ 1767 if (count != last_rec - first_rec + 1) 1768 return ERR_PTR(-EINVAL); 1769 1770 /* use the prefix command if available */ 1771 use_prefix = private->features.feature[8] & 0x01; 1772 if (use_prefix) { 1773 /* 1x prefix + number of blocks */ 1774 cplength = 2 + count; 1775 /* 1x prefix + cidaws*sizeof(long) */ 1776 datasize = sizeof(struct PFX_eckd_data) + 1777 sizeof(struct LO_eckd_data) + 1778 cidaw * sizeof(unsigned long); 1779 } else { 1780 /* 1x define extent + 1x locate record + number of blocks */ 1781 cplength = 2 + count; 1782 /* 1x define extent + 1x locate record + cidaws*sizeof(long) */ 1783 datasize = sizeof(struct DE_eckd_data) + 1784 sizeof(struct LO_eckd_data) + 1785 cidaw * sizeof(unsigned long); 1786 } 1787 /* Find out the number of additional locate record ccws for cdl. */ 1788 if (private->uses_cdl && first_rec < 2*blk_per_trk) { 1789 if (last_rec >= 2*blk_per_trk) 1790 count = 2*blk_per_trk - first_rec; 1791 cplength += count; 1792 datasize += count*sizeof(struct LO_eckd_data); 1793 } 1794 /* Allocate the ccw request. */ 1795 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, 1796 startdev); 1797 if (IS_ERR(cqr)) 1798 return cqr; 1799 ccw = cqr->cpaddr; 1800 /* First ccw is define extent or prefix. */ 1801 if (use_prefix) { 1802 if (prefix(ccw++, cqr->data, first_trk, 1803 last_trk, cmd, basedev, startdev) == -EAGAIN) { 1804 /* Clock not in sync and XRC is enabled. 1805 * Try again later. 1806 */ 1807 dasd_sfree_request(cqr, startdev); 1808 return ERR_PTR(-EAGAIN); 1809 } 1810 idaws = (unsigned long *) (cqr->data + 1811 sizeof(struct PFX_eckd_data)); 1812 } else { 1813 if (define_extent(ccw++, cqr->data, first_trk, 1814 last_trk, cmd, startdev) == -EAGAIN) { 1815 /* Clock not in sync and XRC is enabled. 1816 * Try again later. 1817 */ 1818 dasd_sfree_request(cqr, startdev); 1819 return ERR_PTR(-EAGAIN); 1820 } 1821 idaws = (unsigned long *) (cqr->data + 1822 sizeof(struct DE_eckd_data)); 1823 } 1824 /* Build locate_record+read/write/ccws. */ 1825 LO_data = (struct LO_eckd_data *) (idaws + cidaw); 1826 recid = first_rec; 1827 if (private->uses_cdl == 0 || recid > 2*blk_per_trk) { 1828 /* Only standard blocks so there is just one locate record. */ 1829 ccw[-1].flags |= CCW_FLAG_CC; 1830 locate_record(ccw++, LO_data++, first_trk, first_offs + 1, 1831 last_rec - recid + 1, cmd, basedev, blksize); 1832 } 1833 rq_for_each_segment(bv, req, iter) { 1834 dst = page_address(bv->bv_page) + bv->bv_offset; 1835 if (dasd_page_cache) { 1836 char *copy = kmem_cache_alloc(dasd_page_cache, 1837 GFP_DMA | __GFP_NOWARN); 1838 if (copy && rq_data_dir(req) == WRITE) 1839 memcpy(copy + bv->bv_offset, dst, bv->bv_len); 1840 if (copy) 1841 dst = copy + bv->bv_offset; 1842 } 1843 for (off = 0; off < bv->bv_len; off += blksize) { 1844 sector_t trkid = recid; 1845 unsigned int recoffs = sector_div(trkid, blk_per_trk); 1846 rcmd = cmd; 1847 count = blksize; 1848 /* Locate record for cdl special block ? */ 1849 if (private->uses_cdl && recid < 2*blk_per_trk) { 1850 if (dasd_eckd_cdl_special(blk_per_trk, recid)){ 1851 rcmd |= 0x8; 1852 count = dasd_eckd_cdl_reclen(recid); 1853 if (count < blksize && 1854 rq_data_dir(req) == READ) 1855 memset(dst + count, 0xe5, 1856 blksize - count); 1857 } 1858 ccw[-1].flags |= CCW_FLAG_CC; 1859 locate_record(ccw++, LO_data++, 1860 trkid, recoffs + 1, 1861 1, rcmd, basedev, count); 1862 } 1863 /* Locate record for standard blocks ? */ 1864 if (private->uses_cdl && recid == 2*blk_per_trk) { 1865 ccw[-1].flags |= CCW_FLAG_CC; 1866 locate_record(ccw++, LO_data++, 1867 trkid, recoffs + 1, 1868 last_rec - recid + 1, 1869 cmd, basedev, count); 1870 } 1871 /* Read/write ccw. */ 1872 ccw[-1].flags |= CCW_FLAG_CC; 1873 ccw->cmd_code = rcmd; 1874 ccw->count = count; 1875 if (idal_is_needed(dst, blksize)) { 1876 ccw->cda = (__u32)(addr_t) idaws; 1877 ccw->flags = CCW_FLAG_IDA; 1878 idaws = idal_create_words(idaws, dst, blksize); 1879 } else { 1880 ccw->cda = (__u32)(addr_t) dst; 1881 ccw->flags = 0; 1882 } 1883 ccw++; 1884 dst += blksize; 1885 recid++; 1886 } 1887 } 1888 if (blk_noretry_request(req) || 1889 block->base->features & DASD_FEATURE_FAILFAST) 1890 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 1891 cqr->startdev = startdev; 1892 cqr->memdev = startdev; 1893 cqr->block = block; 1894 cqr->expires = 5 * 60 * HZ; /* 5 minutes */ 1895 cqr->lpm = private->path_data.ppm; 1896 cqr->retries = 256; 1897 cqr->buildclk = get_clock(); 1898 cqr->status = DASD_CQR_FILLED; 1899 return cqr; 1900 } 1901 1902 static struct dasd_ccw_req *dasd_eckd_build_cp_cmd_track( 1903 struct dasd_device *startdev, 1904 struct dasd_block *block, 1905 struct request *req, 1906 sector_t first_rec, 1907 sector_t last_rec, 1908 sector_t first_trk, 1909 sector_t last_trk, 1910 unsigned int first_offs, 1911 unsigned int last_offs, 1912 unsigned int blk_per_trk, 1913 unsigned int blksize) 1914 { 1915 struct dasd_eckd_private *private; 1916 unsigned long *idaws; 1917 struct dasd_ccw_req *cqr; 1918 struct ccw1 *ccw; 1919 struct req_iterator iter; 1920 struct bio_vec *bv; 1921 char *dst, *idaw_dst; 1922 unsigned int cidaw, cplength, datasize; 1923 unsigned int tlf; 1924 sector_t recid; 1925 unsigned char cmd; 1926 struct dasd_device *basedev; 1927 unsigned int trkcount, count, count_to_trk_end; 1928 unsigned int idaw_len, seg_len, part_len, len_to_track_end; 1929 unsigned char new_track, end_idaw; 1930 sector_t trkid; 1931 unsigned int recoffs; 1932 1933 basedev = block->base; 1934 private = (struct dasd_eckd_private *) basedev->private; 1935 if (rq_data_dir(req) == READ) 1936 cmd = DASD_ECKD_CCW_READ_TRACK_DATA; 1937 else if (rq_data_dir(req) == WRITE) 1938 cmd = DASD_ECKD_CCW_WRITE_TRACK_DATA; 1939 else 1940 return ERR_PTR(-EINVAL); 1941 1942 /* Track based I/O needs IDAWs for each page, and not just for 1943 * 64 bit addresses. We need additional idals for pages 1944 * that get filled from two tracks, so we use the number 1945 * of records as upper limit. 1946 */ 1947 cidaw = last_rec - first_rec + 1; 1948 trkcount = last_trk - first_trk + 1; 1949 1950 /* 1x prefix + one read/write ccw per track */ 1951 cplength = 1 + trkcount; 1952 1953 /* on 31-bit we need space for two 32 bit addresses per page 1954 * on 64-bit one 64 bit address 1955 */ 1956 datasize = sizeof(struct PFX_eckd_data) + 1957 cidaw * sizeof(unsigned long long); 1958 1959 /* Allocate the ccw request. */ 1960 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize, 1961 startdev); 1962 if (IS_ERR(cqr)) 1963 return cqr; 1964 ccw = cqr->cpaddr; 1965 /* transfer length factor: how many bytes to read from the last track */ 1966 if (first_trk == last_trk) 1967 tlf = last_offs - first_offs + 1; 1968 else 1969 tlf = last_offs + 1; 1970 tlf *= blksize; 1971 1972 if (prefix_LRE(ccw++, cqr->data, first_trk, 1973 last_trk, cmd, basedev, startdev, 1974 1 /* format */, first_offs + 1, 1975 trkcount, blksize, 1976 tlf) == -EAGAIN) { 1977 /* Clock not in sync and XRC is enabled. 1978 * Try again later. 1979 */ 1980 dasd_sfree_request(cqr, startdev); 1981 return ERR_PTR(-EAGAIN); 1982 } 1983 1984 /* 1985 * The translation of request into ccw programs must meet the 1986 * following conditions: 1987 * - all idaws but the first and the last must address full pages 1988 * (or 2K blocks on 31-bit) 1989 * - the scope of a ccw and it's idal ends with the track boundaries 1990 */ 1991 idaws = (unsigned long *) (cqr->data + sizeof(struct PFX_eckd_data)); 1992 recid = first_rec; 1993 new_track = 1; 1994 end_idaw = 0; 1995 len_to_track_end = 0; 1996 idaw_dst = 0; 1997 idaw_len = 0; 1998 rq_for_each_segment(bv, req, iter) { 1999 dst = page_address(bv->bv_page) + bv->bv_offset; 2000 seg_len = bv->bv_len; 2001 while (seg_len) { 2002 if (new_track) { 2003 trkid = recid; 2004 recoffs = sector_div(trkid, blk_per_trk); 2005 count_to_trk_end = blk_per_trk - recoffs; 2006 count = min((last_rec - recid + 1), 2007 (sector_t)count_to_trk_end); 2008 len_to_track_end = count * blksize; 2009 ccw[-1].flags |= CCW_FLAG_CC; 2010 ccw->cmd_code = cmd; 2011 ccw->count = len_to_track_end; 2012 ccw->cda = (__u32)(addr_t)idaws; 2013 ccw->flags = CCW_FLAG_IDA; 2014 ccw++; 2015 recid += count; 2016 new_track = 0; 2017 /* first idaw for a ccw may start anywhere */ 2018 if (!idaw_dst) 2019 idaw_dst = dst; 2020 } 2021 /* If we start a new idaw, we must make sure that it 2022 * starts on an IDA_BLOCK_SIZE boundary. 2023 * If we continue an idaw, we must make sure that the 2024 * current segment begins where the so far accumulated 2025 * idaw ends 2026 */ 2027 if (!idaw_dst) { 2028 if (__pa(dst) & (IDA_BLOCK_SIZE-1)) { 2029 dasd_sfree_request(cqr, startdev); 2030 return ERR_PTR(-ERANGE); 2031 } else 2032 idaw_dst = dst; 2033 } 2034 if ((idaw_dst + idaw_len) != dst) { 2035 dasd_sfree_request(cqr, startdev); 2036 return ERR_PTR(-ERANGE); 2037 } 2038 part_len = min(seg_len, len_to_track_end); 2039 seg_len -= part_len; 2040 dst += part_len; 2041 idaw_len += part_len; 2042 len_to_track_end -= part_len; 2043 /* collected memory area ends on an IDA_BLOCK border, 2044 * -> create an idaw 2045 * idal_create_words will handle cases where idaw_len 2046 * is larger then IDA_BLOCK_SIZE 2047 */ 2048 if (!(__pa(idaw_dst + idaw_len) & (IDA_BLOCK_SIZE-1))) 2049 end_idaw = 1; 2050 /* We also need to end the idaw at track end */ 2051 if (!len_to_track_end) { 2052 new_track = 1; 2053 end_idaw = 1; 2054 } 2055 if (end_idaw) { 2056 idaws = idal_create_words(idaws, idaw_dst, 2057 idaw_len); 2058 idaw_dst = 0; 2059 idaw_len = 0; 2060 end_idaw = 0; 2061 } 2062 } 2063 } 2064 2065 if (blk_noretry_request(req) || 2066 block->base->features & DASD_FEATURE_FAILFAST) 2067 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 2068 cqr->startdev = startdev; 2069 cqr->memdev = startdev; 2070 cqr->block = block; 2071 cqr->expires = 5 * 60 * HZ; /* 5 minutes */ 2072 cqr->lpm = private->path_data.ppm; 2073 cqr->retries = 256; 2074 cqr->buildclk = get_clock(); 2075 cqr->status = DASD_CQR_FILLED; 2076 return cqr; 2077 } 2078 2079 static int prepare_itcw(struct itcw *itcw, 2080 unsigned int trk, unsigned int totrk, int cmd, 2081 struct dasd_device *basedev, 2082 struct dasd_device *startdev, 2083 unsigned int rec_on_trk, int count, 2084 unsigned int blksize, 2085 unsigned int total_data_size, 2086 unsigned int tlf, 2087 unsigned int blk_per_trk) 2088 { 2089 struct PFX_eckd_data pfxdata; 2090 struct dasd_eckd_private *basepriv, *startpriv; 2091 struct DE_eckd_data *dedata; 2092 struct LRE_eckd_data *lredata; 2093 struct dcw *dcw; 2094 2095 u32 begcyl, endcyl; 2096 u16 heads, beghead, endhead; 2097 u8 pfx_cmd; 2098 2099 int rc = 0; 2100 int sector = 0; 2101 int dn, d; 2102 2103 2104 /* setup prefix data */ 2105 basepriv = (struct dasd_eckd_private *) basedev->private; 2106 startpriv = (struct dasd_eckd_private *) startdev->private; 2107 dedata = &pfxdata.define_extent; 2108 lredata = &pfxdata.locate_record; 2109 2110 memset(&pfxdata, 0, sizeof(pfxdata)); 2111 pfxdata.format = 1; /* PFX with LRE */ 2112 pfxdata.base_address = basepriv->ned->unit_addr; 2113 pfxdata.base_lss = basepriv->ned->ID; 2114 pfxdata.validity.define_extent = 1; 2115 2116 /* private uid is kept up to date, conf_data may be outdated */ 2117 if (startpriv->uid.type != UA_BASE_DEVICE) { 2118 pfxdata.validity.verify_base = 1; 2119 if (startpriv->uid.type == UA_HYPER_PAV_ALIAS) 2120 pfxdata.validity.hyper_pav = 1; 2121 } 2122 2123 switch (cmd) { 2124 case DASD_ECKD_CCW_READ_TRACK_DATA: 2125 dedata->mask.perm = 0x1; 2126 dedata->attributes.operation = basepriv->attrib.operation; 2127 dedata->blk_size = blksize; 2128 dedata->ga_extended |= 0x42; 2129 lredata->operation.orientation = 0x0; 2130 lredata->operation.operation = 0x0C; 2131 lredata->auxiliary.check_bytes = 0x01; 2132 pfx_cmd = DASD_ECKD_CCW_PFX_READ; 2133 break; 2134 case DASD_ECKD_CCW_WRITE_TRACK_DATA: 2135 dedata->mask.perm = 0x02; 2136 dedata->attributes.operation = basepriv->attrib.operation; 2137 dedata->blk_size = blksize; 2138 rc = check_XRC_on_prefix(&pfxdata, basedev); 2139 dedata->ga_extended |= 0x42; 2140 lredata->operation.orientation = 0x0; 2141 lredata->operation.operation = 0x3F; 2142 lredata->extended_operation = 0x23; 2143 lredata->auxiliary.check_bytes = 0x2; 2144 pfx_cmd = DASD_ECKD_CCW_PFX; 2145 break; 2146 default: 2147 DBF_DEV_EVENT(DBF_ERR, basedev, 2148 "prepare itcw, unknown opcode 0x%x", cmd); 2149 BUG(); 2150 break; 2151 } 2152 if (rc) 2153 return rc; 2154 2155 dedata->attributes.mode = 0x3; /* ECKD */ 2156 2157 heads = basepriv->rdc_data.trk_per_cyl; 2158 begcyl = trk / heads; 2159 beghead = trk % heads; 2160 endcyl = totrk / heads; 2161 endhead = totrk % heads; 2162 2163 /* check for sequential prestage - enhance cylinder range */ 2164 if (dedata->attributes.operation == DASD_SEQ_PRESTAGE || 2165 dedata->attributes.operation == DASD_SEQ_ACCESS) { 2166 2167 if (endcyl + basepriv->attrib.nr_cyl < basepriv->real_cyl) 2168 endcyl += basepriv->attrib.nr_cyl; 2169 else 2170 endcyl = (basepriv->real_cyl - 1); 2171 } 2172 2173 set_ch_t(&dedata->beg_ext, begcyl, beghead); 2174 set_ch_t(&dedata->end_ext, endcyl, endhead); 2175 2176 dedata->ep_format = 0x20; /* records per track is valid */ 2177 dedata->ep_rec_per_track = blk_per_trk; 2178 2179 if (rec_on_trk) { 2180 switch (basepriv->rdc_data.dev_type) { 2181 case 0x3390: 2182 dn = ceil_quot(blksize + 6, 232); 2183 d = 9 + ceil_quot(blksize + 6 * (dn + 1), 34); 2184 sector = (49 + (rec_on_trk - 1) * (10 + d)) / 8; 2185 break; 2186 case 0x3380: 2187 d = 7 + ceil_quot(blksize + 12, 32); 2188 sector = (39 + (rec_on_trk - 1) * (8 + d)) / 7; 2189 break; 2190 } 2191 } 2192 2193 lredata->auxiliary.length_valid = 1; 2194 lredata->auxiliary.length_scope = 1; 2195 lredata->auxiliary.imbedded_ccw_valid = 1; 2196 lredata->length = tlf; 2197 lredata->imbedded_ccw = cmd; 2198 lredata->count = count; 2199 lredata->sector = sector; 2200 set_ch_t(&lredata->seek_addr, begcyl, beghead); 2201 lredata->search_arg.cyl = lredata->seek_addr.cyl; 2202 lredata->search_arg.head = lredata->seek_addr.head; 2203 lredata->search_arg.record = rec_on_trk; 2204 2205 dcw = itcw_add_dcw(itcw, pfx_cmd, 0, 2206 &pfxdata, sizeof(pfxdata), total_data_size); 2207 2208 return rc; 2209 } 2210 2211 static struct dasd_ccw_req *dasd_eckd_build_cp_tpm_track( 2212 struct dasd_device *startdev, 2213 struct dasd_block *block, 2214 struct request *req, 2215 sector_t first_rec, 2216 sector_t last_rec, 2217 sector_t first_trk, 2218 sector_t last_trk, 2219 unsigned int first_offs, 2220 unsigned int last_offs, 2221 unsigned int blk_per_trk, 2222 unsigned int blksize) 2223 { 2224 struct dasd_eckd_private *private; 2225 struct dasd_ccw_req *cqr; 2226 struct req_iterator iter; 2227 struct bio_vec *bv; 2228 char *dst; 2229 unsigned int trkcount, ctidaw; 2230 unsigned char cmd; 2231 struct dasd_device *basedev; 2232 unsigned int tlf; 2233 struct itcw *itcw; 2234 struct tidaw *last_tidaw = NULL; 2235 int itcw_op; 2236 size_t itcw_size; 2237 2238 basedev = block->base; 2239 private = (struct dasd_eckd_private *) basedev->private; 2240 if (rq_data_dir(req) == READ) { 2241 cmd = DASD_ECKD_CCW_READ_TRACK_DATA; 2242 itcw_op = ITCW_OP_READ; 2243 } else if (rq_data_dir(req) == WRITE) { 2244 cmd = DASD_ECKD_CCW_WRITE_TRACK_DATA; 2245 itcw_op = ITCW_OP_WRITE; 2246 } else 2247 return ERR_PTR(-EINVAL); 2248 2249 /* trackbased I/O needs address all memory via TIDAWs, 2250 * not just for 64 bit addresses. This allows us to map 2251 * each segment directly to one tidaw. 2252 */ 2253 trkcount = last_trk - first_trk + 1; 2254 ctidaw = 0; 2255 rq_for_each_segment(bv, req, iter) { 2256 ++ctidaw; 2257 } 2258 2259 /* Allocate the ccw request. */ 2260 itcw_size = itcw_calc_size(0, ctidaw, 0); 2261 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 0, itcw_size, startdev); 2262 if (IS_ERR(cqr)) 2263 return cqr; 2264 2265 cqr->cpmode = 1; 2266 cqr->startdev = startdev; 2267 cqr->memdev = startdev; 2268 cqr->block = block; 2269 cqr->expires = 100*HZ; 2270 cqr->buildclk = get_clock(); 2271 cqr->status = DASD_CQR_FILLED; 2272 cqr->retries = 10; 2273 2274 /* transfer length factor: how many bytes to read from the last track */ 2275 if (first_trk == last_trk) 2276 tlf = last_offs - first_offs + 1; 2277 else 2278 tlf = last_offs + 1; 2279 tlf *= blksize; 2280 2281 itcw = itcw_init(cqr->data, itcw_size, itcw_op, 0, ctidaw, 0); 2282 cqr->cpaddr = itcw_get_tcw(itcw); 2283 2284 if (prepare_itcw(itcw, first_trk, last_trk, 2285 cmd, basedev, startdev, 2286 first_offs + 1, 2287 trkcount, blksize, 2288 (last_rec - first_rec + 1) * blksize, 2289 tlf, blk_per_trk) == -EAGAIN) { 2290 /* Clock not in sync and XRC is enabled. 2291 * Try again later. 2292 */ 2293 dasd_sfree_request(cqr, startdev); 2294 return ERR_PTR(-EAGAIN); 2295 } 2296 2297 /* 2298 * A tidaw can address 4k of memory, but must not cross page boundaries 2299 * We can let the block layer handle this by setting 2300 * blk_queue_segment_boundary to page boundaries and 2301 * blk_max_segment_size to page size when setting up the request queue. 2302 */ 2303 rq_for_each_segment(bv, req, iter) { 2304 dst = page_address(bv->bv_page) + bv->bv_offset; 2305 last_tidaw = itcw_add_tidaw(itcw, 0x00, dst, bv->bv_len); 2306 if (IS_ERR(last_tidaw)) 2307 return (struct dasd_ccw_req *)last_tidaw; 2308 } 2309 2310 last_tidaw->flags |= 0x80; 2311 itcw_finalize(itcw); 2312 2313 if (blk_noretry_request(req) || 2314 block->base->features & DASD_FEATURE_FAILFAST) 2315 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 2316 cqr->startdev = startdev; 2317 cqr->memdev = startdev; 2318 cqr->block = block; 2319 cqr->expires = 5 * 60 * HZ; /* 5 minutes */ 2320 cqr->lpm = private->path_data.ppm; 2321 cqr->retries = 256; 2322 cqr->buildclk = get_clock(); 2323 cqr->status = DASD_CQR_FILLED; 2324 return cqr; 2325 } 2326 2327 static struct dasd_ccw_req *dasd_eckd_build_cp(struct dasd_device *startdev, 2328 struct dasd_block *block, 2329 struct request *req) 2330 { 2331 int tpm, cmdrtd, cmdwtd; 2332 int use_prefix; 2333 #if defined(CONFIG_64BIT) 2334 int fcx_in_css, fcx_in_gneq, fcx_in_features; 2335 #endif 2336 struct dasd_eckd_private *private; 2337 struct dasd_device *basedev; 2338 sector_t first_rec, last_rec; 2339 sector_t first_trk, last_trk; 2340 unsigned int first_offs, last_offs; 2341 unsigned int blk_per_trk, blksize; 2342 int cdlspecial; 2343 struct dasd_ccw_req *cqr; 2344 2345 basedev = block->base; 2346 private = (struct dasd_eckd_private *) basedev->private; 2347 2348 /* Calculate number of blocks/records per track. */ 2349 blksize = block->bp_block; 2350 blk_per_trk = recs_per_track(&private->rdc_data, 0, blksize); 2351 if (blk_per_trk == 0) 2352 return ERR_PTR(-EINVAL); 2353 /* Calculate record id of first and last block. */ 2354 first_rec = first_trk = blk_rq_pos(req) >> block->s2b_shift; 2355 first_offs = sector_div(first_trk, blk_per_trk); 2356 last_rec = last_trk = 2357 (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift; 2358 last_offs = sector_div(last_trk, blk_per_trk); 2359 cdlspecial = (private->uses_cdl && first_rec < 2*blk_per_trk); 2360 2361 /* is transport mode supported? */ 2362 #if defined(CONFIG_64BIT) 2363 fcx_in_css = css_general_characteristics.fcx; 2364 fcx_in_gneq = private->gneq->reserved2[7] & 0x04; 2365 fcx_in_features = private->features.feature[40] & 0x80; 2366 tpm = fcx_in_css && fcx_in_gneq && fcx_in_features; 2367 #else 2368 tpm = 0; 2369 #endif 2370 2371 /* is read track data and write track data in command mode supported? */ 2372 cmdrtd = private->features.feature[9] & 0x20; 2373 cmdwtd = private->features.feature[12] & 0x40; 2374 use_prefix = private->features.feature[8] & 0x01; 2375 2376 cqr = NULL; 2377 if (cdlspecial || dasd_page_cache) { 2378 /* do nothing, just fall through to the cmd mode single case */ 2379 } else if (!dasd_nofcx && tpm && (first_trk == last_trk)) { 2380 cqr = dasd_eckd_build_cp_tpm_track(startdev, block, req, 2381 first_rec, last_rec, 2382 first_trk, last_trk, 2383 first_offs, last_offs, 2384 blk_per_trk, blksize); 2385 if (IS_ERR(cqr) && PTR_ERR(cqr) != -EAGAIN) 2386 cqr = NULL; 2387 } else if (use_prefix && 2388 (((rq_data_dir(req) == READ) && cmdrtd) || 2389 ((rq_data_dir(req) == WRITE) && cmdwtd))) { 2390 cqr = dasd_eckd_build_cp_cmd_track(startdev, block, req, 2391 first_rec, last_rec, 2392 first_trk, last_trk, 2393 first_offs, last_offs, 2394 blk_per_trk, blksize); 2395 if (IS_ERR(cqr) && PTR_ERR(cqr) != -EAGAIN) 2396 cqr = NULL; 2397 } 2398 if (!cqr) 2399 cqr = dasd_eckd_build_cp_cmd_single(startdev, block, req, 2400 first_rec, last_rec, 2401 first_trk, last_trk, 2402 first_offs, last_offs, 2403 blk_per_trk, blksize); 2404 return cqr; 2405 } 2406 2407 static int 2408 dasd_eckd_free_cp(struct dasd_ccw_req *cqr, struct request *req) 2409 { 2410 struct dasd_eckd_private *private; 2411 struct ccw1 *ccw; 2412 struct req_iterator iter; 2413 struct bio_vec *bv; 2414 char *dst, *cda; 2415 unsigned int blksize, blk_per_trk, off; 2416 sector_t recid; 2417 int status; 2418 2419 if (!dasd_page_cache) 2420 goto out; 2421 private = (struct dasd_eckd_private *) cqr->block->base->private; 2422 blksize = cqr->block->bp_block; 2423 blk_per_trk = recs_per_track(&private->rdc_data, 0, blksize); 2424 recid = blk_rq_pos(req) >> cqr->block->s2b_shift; 2425 ccw = cqr->cpaddr; 2426 /* Skip over define extent & locate record. */ 2427 ccw++; 2428 if (private->uses_cdl == 0 || recid > 2*blk_per_trk) 2429 ccw++; 2430 rq_for_each_segment(bv, req, iter) { 2431 dst = page_address(bv->bv_page) + bv->bv_offset; 2432 for (off = 0; off < bv->bv_len; off += blksize) { 2433 /* Skip locate record. */ 2434 if (private->uses_cdl && recid <= 2*blk_per_trk) 2435 ccw++; 2436 if (dst) { 2437 if (ccw->flags & CCW_FLAG_IDA) 2438 cda = *((char **)((addr_t) ccw->cda)); 2439 else 2440 cda = (char *)((addr_t) ccw->cda); 2441 if (dst != cda) { 2442 if (rq_data_dir(req) == READ) 2443 memcpy(dst, cda, bv->bv_len); 2444 kmem_cache_free(dasd_page_cache, 2445 (void *)((addr_t)cda & PAGE_MASK)); 2446 } 2447 dst = NULL; 2448 } 2449 ccw++; 2450 recid++; 2451 } 2452 } 2453 out: 2454 status = cqr->status == DASD_CQR_DONE; 2455 dasd_sfree_request(cqr, cqr->memdev); 2456 return status; 2457 } 2458 2459 /* 2460 * Modify ccw/tcw in cqr so it can be started on a base device. 2461 * 2462 * Note that this is not enough to restart the cqr! 2463 * Either reset cqr->startdev as well (summary unit check handling) 2464 * or restart via separate cqr (as in ERP handling). 2465 */ 2466 void dasd_eckd_reset_ccw_to_base_io(struct dasd_ccw_req *cqr) 2467 { 2468 struct ccw1 *ccw; 2469 struct PFX_eckd_data *pfxdata; 2470 struct tcw *tcw; 2471 struct tccb *tccb; 2472 struct dcw *dcw; 2473 2474 if (cqr->cpmode == 1) { 2475 tcw = cqr->cpaddr; 2476 tccb = tcw_get_tccb(tcw); 2477 dcw = (struct dcw *)&tccb->tca[0]; 2478 pfxdata = (struct PFX_eckd_data *)&dcw->cd[0]; 2479 pfxdata->validity.verify_base = 0; 2480 pfxdata->validity.hyper_pav = 0; 2481 } else { 2482 ccw = cqr->cpaddr; 2483 pfxdata = cqr->data; 2484 if (ccw->cmd_code == DASD_ECKD_CCW_PFX) { 2485 pfxdata->validity.verify_base = 0; 2486 pfxdata->validity.hyper_pav = 0; 2487 } 2488 } 2489 } 2490 2491 #define DASD_ECKD_CHANQ_MAX_SIZE 4 2492 2493 static struct dasd_ccw_req *dasd_eckd_build_alias_cp(struct dasd_device *base, 2494 struct dasd_block *block, 2495 struct request *req) 2496 { 2497 struct dasd_eckd_private *private; 2498 struct dasd_device *startdev; 2499 unsigned long flags; 2500 struct dasd_ccw_req *cqr; 2501 2502 startdev = dasd_alias_get_start_dev(base); 2503 if (!startdev) 2504 startdev = base; 2505 private = (struct dasd_eckd_private *) startdev->private; 2506 if (private->count >= DASD_ECKD_CHANQ_MAX_SIZE) 2507 return ERR_PTR(-EBUSY); 2508 2509 spin_lock_irqsave(get_ccwdev_lock(startdev->cdev), flags); 2510 private->count++; 2511 cqr = dasd_eckd_build_cp(startdev, block, req); 2512 if (IS_ERR(cqr)) 2513 private->count--; 2514 spin_unlock_irqrestore(get_ccwdev_lock(startdev->cdev), flags); 2515 return cqr; 2516 } 2517 2518 static int dasd_eckd_free_alias_cp(struct dasd_ccw_req *cqr, 2519 struct request *req) 2520 { 2521 struct dasd_eckd_private *private; 2522 unsigned long flags; 2523 2524 spin_lock_irqsave(get_ccwdev_lock(cqr->memdev->cdev), flags); 2525 private = (struct dasd_eckd_private *) cqr->memdev->private; 2526 private->count--; 2527 spin_unlock_irqrestore(get_ccwdev_lock(cqr->memdev->cdev), flags); 2528 return dasd_eckd_free_cp(cqr, req); 2529 } 2530 2531 static int 2532 dasd_eckd_fill_info(struct dasd_device * device, 2533 struct dasd_information2_t * info) 2534 { 2535 struct dasd_eckd_private *private; 2536 2537 private = (struct dasd_eckd_private *) device->private; 2538 info->label_block = 2; 2539 info->FBA_layout = private->uses_cdl ? 0 : 1; 2540 info->format = private->uses_cdl ? DASD_FORMAT_CDL : DASD_FORMAT_LDL; 2541 info->characteristics_size = sizeof(struct dasd_eckd_characteristics); 2542 memcpy(info->characteristics, &private->rdc_data, 2543 sizeof(struct dasd_eckd_characteristics)); 2544 info->confdata_size = min((unsigned long)private->conf_len, 2545 sizeof(info->configuration_data)); 2546 memcpy(info->configuration_data, private->conf_data, 2547 info->confdata_size); 2548 return 0; 2549 } 2550 2551 /* 2552 * SECTION: ioctl functions for eckd devices. 2553 */ 2554 2555 /* 2556 * Release device ioctl. 2557 * Buils a channel programm to releases a prior reserved 2558 * (see dasd_eckd_reserve) device. 2559 */ 2560 static int 2561 dasd_eckd_release(struct dasd_device *device) 2562 { 2563 struct dasd_ccw_req *cqr; 2564 int rc; 2565 struct ccw1 *ccw; 2566 2567 if (!capable(CAP_SYS_ADMIN)) 2568 return -EACCES; 2569 2570 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device); 2571 if (IS_ERR(cqr)) { 2572 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 2573 "Could not allocate initialization request"); 2574 return PTR_ERR(cqr); 2575 } 2576 ccw = cqr->cpaddr; 2577 ccw->cmd_code = DASD_ECKD_CCW_RELEASE; 2578 ccw->flags |= CCW_FLAG_SLI; 2579 ccw->count = 32; 2580 ccw->cda = (__u32)(addr_t) cqr->data; 2581 cqr->startdev = device; 2582 cqr->memdev = device; 2583 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 2584 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 2585 cqr->retries = 2; /* set retry counter to enable basic ERP */ 2586 cqr->expires = 2 * HZ; 2587 cqr->buildclk = get_clock(); 2588 cqr->status = DASD_CQR_FILLED; 2589 2590 rc = dasd_sleep_on_immediatly(cqr); 2591 2592 dasd_sfree_request(cqr, cqr->memdev); 2593 return rc; 2594 } 2595 2596 /* 2597 * Reserve device ioctl. 2598 * Options are set to 'synchronous wait for interrupt' and 2599 * 'timeout the request'. This leads to a terminate IO if 2600 * the interrupt is outstanding for a certain time. 2601 */ 2602 static int 2603 dasd_eckd_reserve(struct dasd_device *device) 2604 { 2605 struct dasd_ccw_req *cqr; 2606 int rc; 2607 struct ccw1 *ccw; 2608 2609 if (!capable(CAP_SYS_ADMIN)) 2610 return -EACCES; 2611 2612 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device); 2613 if (IS_ERR(cqr)) { 2614 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 2615 "Could not allocate initialization request"); 2616 return PTR_ERR(cqr); 2617 } 2618 ccw = cqr->cpaddr; 2619 ccw->cmd_code = DASD_ECKD_CCW_RESERVE; 2620 ccw->flags |= CCW_FLAG_SLI; 2621 ccw->count = 32; 2622 ccw->cda = (__u32)(addr_t) cqr->data; 2623 cqr->startdev = device; 2624 cqr->memdev = device; 2625 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 2626 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 2627 cqr->retries = 2; /* set retry counter to enable basic ERP */ 2628 cqr->expires = 2 * HZ; 2629 cqr->buildclk = get_clock(); 2630 cqr->status = DASD_CQR_FILLED; 2631 2632 rc = dasd_sleep_on_immediatly(cqr); 2633 2634 dasd_sfree_request(cqr, cqr->memdev); 2635 return rc; 2636 } 2637 2638 /* 2639 * Steal lock ioctl - unconditional reserve device. 2640 * Buils a channel programm to break a device's reservation. 2641 * (unconditional reserve) 2642 */ 2643 static int 2644 dasd_eckd_steal_lock(struct dasd_device *device) 2645 { 2646 struct dasd_ccw_req *cqr; 2647 int rc; 2648 struct ccw1 *ccw; 2649 2650 if (!capable(CAP_SYS_ADMIN)) 2651 return -EACCES; 2652 2653 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, 32, device); 2654 if (IS_ERR(cqr)) { 2655 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 2656 "Could not allocate initialization request"); 2657 return PTR_ERR(cqr); 2658 } 2659 ccw = cqr->cpaddr; 2660 ccw->cmd_code = DASD_ECKD_CCW_SLCK; 2661 ccw->flags |= CCW_FLAG_SLI; 2662 ccw->count = 32; 2663 ccw->cda = (__u32)(addr_t) cqr->data; 2664 cqr->startdev = device; 2665 cqr->memdev = device; 2666 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); 2667 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 2668 cqr->retries = 2; /* set retry counter to enable basic ERP */ 2669 cqr->expires = 2 * HZ; 2670 cqr->buildclk = get_clock(); 2671 cqr->status = DASD_CQR_FILLED; 2672 2673 rc = dasd_sleep_on_immediatly(cqr); 2674 2675 dasd_sfree_request(cqr, cqr->memdev); 2676 return rc; 2677 } 2678 2679 /* 2680 * Read performance statistics 2681 */ 2682 static int 2683 dasd_eckd_performance(struct dasd_device *device, void __user *argp) 2684 { 2685 struct dasd_psf_prssd_data *prssdp; 2686 struct dasd_rssd_perf_stats_t *stats; 2687 struct dasd_ccw_req *cqr; 2688 struct ccw1 *ccw; 2689 int rc; 2690 2691 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1 /* PSF */ + 1 /* RSSD */, 2692 (sizeof(struct dasd_psf_prssd_data) + 2693 sizeof(struct dasd_rssd_perf_stats_t)), 2694 device); 2695 if (IS_ERR(cqr)) { 2696 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 2697 "Could not allocate initialization request"); 2698 return PTR_ERR(cqr); 2699 } 2700 cqr->startdev = device; 2701 cqr->memdev = device; 2702 cqr->retries = 0; 2703 cqr->expires = 10 * HZ; 2704 2705 /* Prepare for Read Subsystem Data */ 2706 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 2707 memset(prssdp, 0, sizeof(struct dasd_psf_prssd_data)); 2708 prssdp->order = PSF_ORDER_PRSSD; 2709 prssdp->suborder = 0x01; /* Performance Statistics */ 2710 prssdp->varies[1] = 0x01; /* Perf Statistics for the Subsystem */ 2711 2712 ccw = cqr->cpaddr; 2713 ccw->cmd_code = DASD_ECKD_CCW_PSF; 2714 ccw->count = sizeof(struct dasd_psf_prssd_data); 2715 ccw->flags |= CCW_FLAG_CC; 2716 ccw->cda = (__u32)(addr_t) prssdp; 2717 2718 /* Read Subsystem Data - Performance Statistics */ 2719 stats = (struct dasd_rssd_perf_stats_t *) (prssdp + 1); 2720 memset(stats, 0, sizeof(struct dasd_rssd_perf_stats_t)); 2721 2722 ccw++; 2723 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 2724 ccw->count = sizeof(struct dasd_rssd_perf_stats_t); 2725 ccw->cda = (__u32)(addr_t) stats; 2726 2727 cqr->buildclk = get_clock(); 2728 cqr->status = DASD_CQR_FILLED; 2729 rc = dasd_sleep_on(cqr); 2730 if (rc == 0) { 2731 prssdp = (struct dasd_psf_prssd_data *) cqr->data; 2732 stats = (struct dasd_rssd_perf_stats_t *) (prssdp + 1); 2733 if (copy_to_user(argp, stats, 2734 sizeof(struct dasd_rssd_perf_stats_t))) 2735 rc = -EFAULT; 2736 } 2737 dasd_sfree_request(cqr, cqr->memdev); 2738 return rc; 2739 } 2740 2741 /* 2742 * Get attributes (cache operations) 2743 * Returnes the cache attributes used in Define Extend (DE). 2744 */ 2745 static int 2746 dasd_eckd_get_attrib(struct dasd_device *device, void __user *argp) 2747 { 2748 struct dasd_eckd_private *private = 2749 (struct dasd_eckd_private *)device->private; 2750 struct attrib_data_t attrib = private->attrib; 2751 int rc; 2752 2753 if (!capable(CAP_SYS_ADMIN)) 2754 return -EACCES; 2755 if (!argp) 2756 return -EINVAL; 2757 2758 rc = 0; 2759 if (copy_to_user(argp, (long *) &attrib, 2760 sizeof(struct attrib_data_t))) 2761 rc = -EFAULT; 2762 2763 return rc; 2764 } 2765 2766 /* 2767 * Set attributes (cache operations) 2768 * Stores the attributes for cache operation to be used in Define Extend (DE). 2769 */ 2770 static int 2771 dasd_eckd_set_attrib(struct dasd_device *device, void __user *argp) 2772 { 2773 struct dasd_eckd_private *private = 2774 (struct dasd_eckd_private *)device->private; 2775 struct attrib_data_t attrib; 2776 2777 if (!capable(CAP_SYS_ADMIN)) 2778 return -EACCES; 2779 if (!argp) 2780 return -EINVAL; 2781 2782 if (copy_from_user(&attrib, argp, sizeof(struct attrib_data_t))) 2783 return -EFAULT; 2784 private->attrib = attrib; 2785 2786 dev_info(&device->cdev->dev, 2787 "The DASD cache mode was set to %x (%i cylinder prestage)\n", 2788 private->attrib.operation, private->attrib.nr_cyl); 2789 return 0; 2790 } 2791 2792 /* 2793 * Issue syscall I/O to EMC Symmetrix array. 2794 * CCWs are PSF and RSSD 2795 */ 2796 static int dasd_symm_io(struct dasd_device *device, void __user *argp) 2797 { 2798 struct dasd_symmio_parms usrparm; 2799 char *psf_data, *rssd_result; 2800 struct dasd_ccw_req *cqr; 2801 struct ccw1 *ccw; 2802 int rc; 2803 2804 /* Copy parms from caller */ 2805 rc = -EFAULT; 2806 if (copy_from_user(&usrparm, argp, sizeof(usrparm))) 2807 goto out; 2808 #ifndef CONFIG_64BIT 2809 /* Make sure pointers are sane even on 31 bit. */ 2810 if ((usrparm.psf_data >> 32) != 0 || (usrparm.rssd_result >> 32) != 0) { 2811 rc = -EINVAL; 2812 goto out; 2813 } 2814 #endif 2815 /* alloc I/O data area */ 2816 psf_data = kzalloc(usrparm.psf_data_len, GFP_KERNEL | GFP_DMA); 2817 rssd_result = kzalloc(usrparm.rssd_result_len, GFP_KERNEL | GFP_DMA); 2818 if (!psf_data || !rssd_result) { 2819 rc = -ENOMEM; 2820 goto out_free; 2821 } 2822 2823 /* get syscall header from user space */ 2824 rc = -EFAULT; 2825 if (copy_from_user(psf_data, 2826 (void __user *)(unsigned long) usrparm.psf_data, 2827 usrparm.psf_data_len)) 2828 goto out_free; 2829 2830 /* sanity check on syscall header */ 2831 if (psf_data[0] != 0x17 && psf_data[1] != 0xce) { 2832 rc = -EINVAL; 2833 goto out_free; 2834 } 2835 2836 /* setup CCWs for PSF + RSSD */ 2837 cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 2 , 0, device); 2838 if (IS_ERR(cqr)) { 2839 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 2840 "Could not allocate initialization request"); 2841 rc = PTR_ERR(cqr); 2842 goto out_free; 2843 } 2844 2845 cqr->startdev = device; 2846 cqr->memdev = device; 2847 cqr->retries = 3; 2848 cqr->expires = 10 * HZ; 2849 cqr->buildclk = get_clock(); 2850 cqr->status = DASD_CQR_FILLED; 2851 2852 /* Build the ccws */ 2853 ccw = cqr->cpaddr; 2854 2855 /* PSF ccw */ 2856 ccw->cmd_code = DASD_ECKD_CCW_PSF; 2857 ccw->count = usrparm.psf_data_len; 2858 ccw->flags |= CCW_FLAG_CC; 2859 ccw->cda = (__u32)(addr_t) psf_data; 2860 2861 ccw++; 2862 2863 /* RSSD ccw */ 2864 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 2865 ccw->count = usrparm.rssd_result_len; 2866 ccw->flags = CCW_FLAG_SLI ; 2867 ccw->cda = (__u32)(addr_t) rssd_result; 2868 2869 rc = dasd_sleep_on(cqr); 2870 if (rc) 2871 goto out_sfree; 2872 2873 rc = -EFAULT; 2874 if (copy_to_user((void __user *)(unsigned long) usrparm.rssd_result, 2875 rssd_result, usrparm.rssd_result_len)) 2876 goto out_sfree; 2877 rc = 0; 2878 2879 out_sfree: 2880 dasd_sfree_request(cqr, cqr->memdev); 2881 out_free: 2882 kfree(rssd_result); 2883 kfree(psf_data); 2884 out: 2885 DBF_DEV_EVENT(DBF_WARNING, device, "Symmetrix ioctl: rc=%d", rc); 2886 return rc; 2887 } 2888 2889 static int 2890 dasd_eckd_ioctl(struct dasd_block *block, unsigned int cmd, void __user *argp) 2891 { 2892 struct dasd_device *device = block->base; 2893 2894 switch (cmd) { 2895 case BIODASDGATTR: 2896 return dasd_eckd_get_attrib(device, argp); 2897 case BIODASDSATTR: 2898 return dasd_eckd_set_attrib(device, argp); 2899 case BIODASDPSRD: 2900 return dasd_eckd_performance(device, argp); 2901 case BIODASDRLSE: 2902 return dasd_eckd_release(device); 2903 case BIODASDRSRV: 2904 return dasd_eckd_reserve(device); 2905 case BIODASDSLCK: 2906 return dasd_eckd_steal_lock(device); 2907 case BIODASDSYMMIO: 2908 return dasd_symm_io(device, argp); 2909 default: 2910 return -ENOIOCTLCMD; 2911 } 2912 } 2913 2914 /* 2915 * Dump the range of CCWs into 'page' buffer 2916 * and return number of printed chars. 2917 */ 2918 static int 2919 dasd_eckd_dump_ccw_range(struct ccw1 *from, struct ccw1 *to, char *page) 2920 { 2921 int len, count; 2922 char *datap; 2923 2924 len = 0; 2925 while (from <= to) { 2926 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 2927 " CCW %p: %08X %08X DAT:", 2928 from, ((int *) from)[0], ((int *) from)[1]); 2929 2930 /* get pointer to data (consider IDALs) */ 2931 if (from->flags & CCW_FLAG_IDA) 2932 datap = (char *) *((addr_t *) (addr_t) from->cda); 2933 else 2934 datap = (char *) ((addr_t) from->cda); 2935 2936 /* dump data (max 32 bytes) */ 2937 for (count = 0; count < from->count && count < 32; count++) { 2938 if (count % 8 == 0) len += sprintf(page + len, " "); 2939 if (count % 4 == 0) len += sprintf(page + len, " "); 2940 len += sprintf(page + len, "%02x", datap[count]); 2941 } 2942 len += sprintf(page + len, "\n"); 2943 from++; 2944 } 2945 return len; 2946 } 2947 2948 static void 2949 dasd_eckd_dump_sense_dbf(struct dasd_device *device, struct irb *irb, 2950 char *reason) 2951 { 2952 u64 *sense; 2953 2954 sense = (u64 *) dasd_get_sense(irb); 2955 if (sense) { 2956 DBF_DEV_EVENT(DBF_EMERG, device, 2957 "%s: %s %02x%02x%02x %016llx %016llx %016llx " 2958 "%016llx", reason, 2959 scsw_is_tm(&irb->scsw) ? "t" : "c", 2960 scsw_cc(&irb->scsw), scsw_cstat(&irb->scsw), 2961 scsw_dstat(&irb->scsw), sense[0], sense[1], 2962 sense[2], sense[3]); 2963 } else { 2964 DBF_DEV_EVENT(DBF_EMERG, device, "%s", 2965 "SORRY - NO VALID SENSE AVAILABLE\n"); 2966 } 2967 } 2968 2969 /* 2970 * Print sense data and related channel program. 2971 * Parts are printed because printk buffer is only 1024 bytes. 2972 */ 2973 static void dasd_eckd_dump_sense_ccw(struct dasd_device *device, 2974 struct dasd_ccw_req *req, struct irb *irb) 2975 { 2976 char *page; 2977 struct ccw1 *first, *last, *fail, *from, *to; 2978 int len, sl, sct; 2979 2980 page = (char *) get_zeroed_page(GFP_ATOMIC); 2981 if (page == NULL) { 2982 DBF_DEV_EVENT(DBF_WARNING, device, "%s", 2983 "No memory to dump sense data\n"); 2984 return; 2985 } 2986 /* dump the sense data */ 2987 len = sprintf(page, KERN_ERR PRINTK_HEADER 2988 " I/O status report for device %s:\n", 2989 dev_name(&device->cdev->dev)); 2990 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 2991 " in req: %p CS: 0x%02X DS: 0x%02X CC: 0x%02X RC: %d\n", 2992 req, scsw_cstat(&irb->scsw), scsw_dstat(&irb->scsw), 2993 scsw_cc(&irb->scsw), req->intrc); 2994 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 2995 " device %s: Failing CCW: %p\n", 2996 dev_name(&device->cdev->dev), 2997 (void *) (addr_t) irb->scsw.cmd.cpa); 2998 if (irb->esw.esw0.erw.cons) { 2999 for (sl = 0; sl < 4; sl++) { 3000 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3001 " Sense(hex) %2d-%2d:", 3002 (8 * sl), ((8 * sl) + 7)); 3003 3004 for (sct = 0; sct < 8; sct++) { 3005 len += sprintf(page + len, " %02x", 3006 irb->ecw[8 * sl + sct]); 3007 } 3008 len += sprintf(page + len, "\n"); 3009 } 3010 3011 if (irb->ecw[27] & DASD_SENSE_BIT_0) { 3012 /* 24 Byte Sense Data */ 3013 sprintf(page + len, KERN_ERR PRINTK_HEADER 3014 " 24 Byte: %x MSG %x, " 3015 "%s MSGb to SYSOP\n", 3016 irb->ecw[7] >> 4, irb->ecw[7] & 0x0f, 3017 irb->ecw[1] & 0x10 ? "" : "no"); 3018 } else { 3019 /* 32 Byte Sense Data */ 3020 sprintf(page + len, KERN_ERR PRINTK_HEADER 3021 " 32 Byte: Format: %x " 3022 "Exception class %x\n", 3023 irb->ecw[6] & 0x0f, irb->ecw[22] >> 4); 3024 } 3025 } else { 3026 sprintf(page + len, KERN_ERR PRINTK_HEADER 3027 " SORRY - NO VALID SENSE AVAILABLE\n"); 3028 } 3029 printk("%s", page); 3030 3031 if (req) { 3032 /* req == NULL for unsolicited interrupts */ 3033 /* dump the Channel Program (max 140 Bytes per line) */ 3034 /* Count CCW and print first CCWs (maximum 1024 % 140 = 7) */ 3035 first = req->cpaddr; 3036 for (last = first; last->flags & (CCW_FLAG_CC | CCW_FLAG_DC); last++); 3037 to = min(first + 6, last); 3038 len = sprintf(page, KERN_ERR PRINTK_HEADER 3039 " Related CP in req: %p\n", req); 3040 dasd_eckd_dump_ccw_range(first, to, page + len); 3041 printk("%s", page); 3042 3043 /* print failing CCW area (maximum 4) */ 3044 /* scsw->cda is either valid or zero */ 3045 len = 0; 3046 from = ++to; 3047 fail = (struct ccw1 *)(addr_t) 3048 irb->scsw.cmd.cpa; /* failing CCW */ 3049 if (from < fail - 2) { 3050 from = fail - 2; /* there is a gap - print header */ 3051 len += sprintf(page, KERN_ERR PRINTK_HEADER "......\n"); 3052 } 3053 to = min(fail + 1, last); 3054 len += dasd_eckd_dump_ccw_range(from, to, page + len); 3055 3056 /* print last CCWs (maximum 2) */ 3057 from = max(from, ++to); 3058 if (from < last - 1) { 3059 from = last - 1; /* there is a gap - print header */ 3060 len += sprintf(page + len, KERN_ERR PRINTK_HEADER "......\n"); 3061 } 3062 len += dasd_eckd_dump_ccw_range(from, last, page + len); 3063 if (len > 0) 3064 printk("%s", page); 3065 } 3066 free_page((unsigned long) page); 3067 } 3068 3069 3070 /* 3071 * Print sense data from a tcw. 3072 */ 3073 static void dasd_eckd_dump_sense_tcw(struct dasd_device *device, 3074 struct dasd_ccw_req *req, struct irb *irb) 3075 { 3076 char *page; 3077 int len, sl, sct, residual; 3078 3079 struct tsb *tsb; 3080 u8 *sense; 3081 3082 3083 page = (char *) get_zeroed_page(GFP_ATOMIC); 3084 if (page == NULL) { 3085 DBF_DEV_EVENT(DBF_WARNING, device, " %s", 3086 "No memory to dump sense data"); 3087 return; 3088 } 3089 /* dump the sense data */ 3090 len = sprintf(page, KERN_ERR PRINTK_HEADER 3091 " I/O status report for device %s:\n", 3092 dev_name(&device->cdev->dev)); 3093 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3094 " in req: %p CS: 0x%02X DS: 0x%02X CC: 0x%02X RC: %d " 3095 "fcxs: 0x%02X schxs: 0x%02X\n", req, 3096 scsw_cstat(&irb->scsw), scsw_dstat(&irb->scsw), 3097 scsw_cc(&irb->scsw), req->intrc, 3098 irb->scsw.tm.fcxs, irb->scsw.tm.schxs); 3099 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3100 " device %s: Failing TCW: %p\n", 3101 dev_name(&device->cdev->dev), 3102 (void *) (addr_t) irb->scsw.tm.tcw); 3103 3104 tsb = NULL; 3105 sense = NULL; 3106 if (irb->scsw.tm.tcw) 3107 tsb = tcw_get_tsb( 3108 (struct tcw *)(unsigned long)irb->scsw.tm.tcw); 3109 3110 if (tsb && (irb->scsw.tm.fcxs == 0x01)) { 3111 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3112 " tsb->length %d\n", tsb->length); 3113 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3114 " tsb->flags %x\n", tsb->flags); 3115 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3116 " tsb->dcw_offset %d\n", tsb->dcw_offset); 3117 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3118 " tsb->count %d\n", tsb->count); 3119 residual = tsb->count - 28; 3120 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3121 " residual %d\n", residual); 3122 3123 switch (tsb->flags & 0x07) { 3124 case 1: /* tsa_iostat */ 3125 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3126 " tsb->tsa.iostat.dev_time %d\n", 3127 tsb->tsa.iostat.dev_time); 3128 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3129 " tsb->tsa.iostat.def_time %d\n", 3130 tsb->tsa.iostat.def_time); 3131 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3132 " tsb->tsa.iostat.queue_time %d\n", 3133 tsb->tsa.iostat.queue_time); 3134 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3135 " tsb->tsa.iostat.dev_busy_time %d\n", 3136 tsb->tsa.iostat.dev_busy_time); 3137 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3138 " tsb->tsa.iostat.dev_act_time %d\n", 3139 tsb->tsa.iostat.dev_act_time); 3140 sense = tsb->tsa.iostat.sense; 3141 break; 3142 case 2: /* ts_ddpc */ 3143 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3144 " tsb->tsa.ddpc.rc %d\n", tsb->tsa.ddpc.rc); 3145 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3146 " tsb->tsa.ddpc.rcq: "); 3147 for (sl = 0; sl < 16; sl++) { 3148 for (sct = 0; sct < 8; sct++) { 3149 len += sprintf(page + len, " %02x", 3150 tsb->tsa.ddpc.rcq[sl]); 3151 } 3152 len += sprintf(page + len, "\n"); 3153 } 3154 sense = tsb->tsa.ddpc.sense; 3155 break; 3156 case 3: /* tsa_intrg */ 3157 len += sprintf(page + len, KERN_ERR PRINTK_HEADER 3158 " tsb->tsa.intrg.: not supportet yet \n"); 3159 break; 3160 } 3161 3162 if (sense) { 3163 for (sl = 0; sl < 4; sl++) { 3164 len += sprintf(page + len, 3165 KERN_ERR PRINTK_HEADER 3166 " Sense(hex) %2d-%2d:", 3167 (8 * sl), ((8 * sl) + 7)); 3168 for (sct = 0; sct < 8; sct++) { 3169 len += sprintf(page + len, " %02x", 3170 sense[8 * sl + sct]); 3171 } 3172 len += sprintf(page + len, "\n"); 3173 } 3174 3175 if (sense[27] & DASD_SENSE_BIT_0) { 3176 /* 24 Byte Sense Data */ 3177 sprintf(page + len, KERN_ERR PRINTK_HEADER 3178 " 24 Byte: %x MSG %x, " 3179 "%s MSGb to SYSOP\n", 3180 sense[7] >> 4, sense[7] & 0x0f, 3181 sense[1] & 0x10 ? "" : "no"); 3182 } else { 3183 /* 32 Byte Sense Data */ 3184 sprintf(page + len, KERN_ERR PRINTK_HEADER 3185 " 32 Byte: Format: %x " 3186 "Exception class %x\n", 3187 sense[6] & 0x0f, sense[22] >> 4); 3188 } 3189 } else { 3190 sprintf(page + len, KERN_ERR PRINTK_HEADER 3191 " SORRY - NO VALID SENSE AVAILABLE\n"); 3192 } 3193 } else { 3194 sprintf(page + len, KERN_ERR PRINTK_HEADER 3195 " SORRY - NO TSB DATA AVAILABLE\n"); 3196 } 3197 printk("%s", page); 3198 free_page((unsigned long) page); 3199 } 3200 3201 static void dasd_eckd_dump_sense(struct dasd_device *device, 3202 struct dasd_ccw_req *req, struct irb *irb) 3203 { 3204 if (req && scsw_is_tm(&req->irb.scsw)) 3205 dasd_eckd_dump_sense_tcw(device, req, irb); 3206 else 3207 dasd_eckd_dump_sense_ccw(device, req, irb); 3208 } 3209 3210 int dasd_eckd_pm_freeze(struct dasd_device *device) 3211 { 3212 /* 3213 * the device should be disconnected from our LCU structure 3214 * on restore we will reconnect it and reread LCU specific 3215 * information like PAV support that might have changed 3216 */ 3217 dasd_alias_remove_device(device); 3218 dasd_alias_disconnect_device_from_lcu(device); 3219 3220 return 0; 3221 } 3222 3223 int dasd_eckd_restore_device(struct dasd_device *device) 3224 { 3225 struct dasd_eckd_private *private; 3226 struct dasd_eckd_characteristics temp_rdc_data; 3227 int is_known, rc; 3228 struct dasd_uid temp_uid; 3229 unsigned long flags; 3230 3231 private = (struct dasd_eckd_private *) device->private; 3232 3233 /* Read Configuration Data */ 3234 rc = dasd_eckd_read_conf(device); 3235 if (rc) 3236 goto out_err; 3237 3238 /* Generate device unique id and register in devmap */ 3239 rc = dasd_eckd_generate_uid(device, &private->uid); 3240 dasd_get_uid(device->cdev, &temp_uid); 3241 if (memcmp(&private->uid, &temp_uid, sizeof(struct dasd_uid)) != 0) 3242 dev_err(&device->cdev->dev, "The UID of the DASD has " 3243 "changed\n"); 3244 if (rc) 3245 goto out_err; 3246 dasd_set_uid(device->cdev, &private->uid); 3247 3248 /* register lcu with alias handling, enable PAV if this is a new lcu */ 3249 is_known = dasd_alias_make_device_known_to_lcu(device); 3250 if (is_known < 0) 3251 return is_known; 3252 if (!is_known) { 3253 /* new lcu found */ 3254 rc = dasd_eckd_validate_server(device); /* will switch pav on */ 3255 if (rc) 3256 goto out_err; 3257 } 3258 3259 /* Read Feature Codes */ 3260 dasd_eckd_read_features(device); 3261 3262 /* Read Device Characteristics */ 3263 rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC, 3264 &temp_rdc_data, 64); 3265 if (rc) { 3266 DBF_EVENT(DBF_WARNING, 3267 "Read device characteristics failed, rc=%d for " 3268 "device: %s", rc, dev_name(&device->cdev->dev)); 3269 goto out_err; 3270 } 3271 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags); 3272 memcpy(&private->rdc_data, &temp_rdc_data, sizeof(temp_rdc_data)); 3273 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags); 3274 3275 /* add device to alias management */ 3276 dasd_alias_add_device(device); 3277 3278 return 0; 3279 3280 out_err: 3281 return -1; 3282 } 3283 3284 static struct ccw_driver dasd_eckd_driver = { 3285 .name = "dasd-eckd", 3286 .owner = THIS_MODULE, 3287 .ids = dasd_eckd_ids, 3288 .probe = dasd_eckd_probe, 3289 .remove = dasd_generic_remove, 3290 .set_offline = dasd_generic_set_offline, 3291 .set_online = dasd_eckd_set_online, 3292 .notify = dasd_generic_notify, 3293 .freeze = dasd_generic_pm_freeze, 3294 .thaw = dasd_generic_restore_device, 3295 .restore = dasd_generic_restore_device, 3296 }; 3297 3298 /* 3299 * max_blocks is dependent on the amount of storage that is available 3300 * in the static io buffer for each device. Currently each device has 3301 * 8192 bytes (=2 pages). For 64 bit one dasd_mchunkt_t structure has 3302 * 24 bytes, the struct dasd_ccw_req has 136 bytes and each block can use 3303 * up to 16 bytes (8 for the ccw and 8 for the idal pointer). In 3304 * addition we have one define extent ccw + 16 bytes of data and one 3305 * locate record ccw + 16 bytes of data. That makes: 3306 * (8192 - 24 - 136 - 8 - 16 - 8 - 16) / 16 = 499 blocks at maximum. 3307 * We want to fit two into the available memory so that we can immediately 3308 * start the next request if one finishes off. That makes 249.5 blocks 3309 * for one request. Give a little safety and the result is 240. 3310 */ 3311 static struct dasd_discipline dasd_eckd_discipline = { 3312 .owner = THIS_MODULE, 3313 .name = "ECKD", 3314 .ebcname = "ECKD", 3315 .max_blocks = 240, 3316 .check_device = dasd_eckd_check_characteristics, 3317 .uncheck_device = dasd_eckd_uncheck_device, 3318 .do_analysis = dasd_eckd_do_analysis, 3319 .ready_to_online = dasd_eckd_ready_to_online, 3320 .online_to_ready = dasd_eckd_online_to_ready, 3321 .fill_geometry = dasd_eckd_fill_geometry, 3322 .start_IO = dasd_start_IO, 3323 .term_IO = dasd_term_IO, 3324 .handle_terminated_request = dasd_eckd_handle_terminated_request, 3325 .format_device = dasd_eckd_format_device, 3326 .erp_action = dasd_eckd_erp_action, 3327 .erp_postaction = dasd_eckd_erp_postaction, 3328 .handle_unsolicited_interrupt = dasd_eckd_handle_unsolicited_interrupt, 3329 .build_cp = dasd_eckd_build_alias_cp, 3330 .free_cp = dasd_eckd_free_alias_cp, 3331 .dump_sense = dasd_eckd_dump_sense, 3332 .dump_sense_dbf = dasd_eckd_dump_sense_dbf, 3333 .fill_info = dasd_eckd_fill_info, 3334 .ioctl = dasd_eckd_ioctl, 3335 .freeze = dasd_eckd_pm_freeze, 3336 .restore = dasd_eckd_restore_device, 3337 }; 3338 3339 static int __init 3340 dasd_eckd_init(void) 3341 { 3342 int ret; 3343 3344 ASCEBC(dasd_eckd_discipline.ebcname, 4); 3345 ret = ccw_driver_register(&dasd_eckd_driver); 3346 if (!ret) 3347 wait_for_device_probe(); 3348 3349 return ret; 3350 } 3351 3352 static void __exit 3353 dasd_eckd_cleanup(void) 3354 { 3355 ccw_driver_unregister(&dasd_eckd_driver); 3356 } 3357 3358 module_init(dasd_eckd_init); 3359 module_exit(dasd_eckd_cleanup); 3360