drivers/s390/block/dasd_eckd.c

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