drivers/s390/char/tape_34xx.c

   1 /*
   2  *  drivers/s390/char/tape_34xx.c
   3  *    tape device discipline for 3480/3490 tapes.
   4  *
   5  *    Copyright IBM Corp. 2001, 2009
   6  *    Author(s): Carsten Otte <cotte@de.ibm.com>
   7  *               Tuan Ngo-Anh <ngoanh@de.ibm.com>
   8  *               Martin Schwidefsky <schwidefsky@de.ibm.com>
   9  */
  10
  11 #define KMSG_COMPONENT "tape_34xx"
  12 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  13
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/bio.h>
  17 #include <linux/workqueue.h>
  18
  19 #define TAPE_DBF_AREA   tape_34xx_dbf
  20
  21 #include "tape.h"
  22 #include "tape_std.h"
  23
  24 /*
  25  * Pointer to debug area.
  26  */
  27 debug_info_t *TAPE_DBF_AREA = NULL;
  28 EXPORT_SYMBOL(TAPE_DBF_AREA);
  29
  30 #define TAPE34XX_FMT_3480       0
  31 #define TAPE34XX_FMT_3480_2_XF  1
  32 #define TAPE34XX_FMT_3480_XF    2
  33
  34 struct tape_34xx_block_id {
  35         unsigned int    wrap            : 1;
  36         unsigned int    segment         : 7;
  37         unsigned int    format          : 2;
  38         unsigned int    block           : 22;
  39 };
  40
  41 /*
  42  * A list of block ID's is used to faster seek blocks.
  43  */
  44 struct tape_34xx_sbid {
  45         struct list_head                list;
  46         struct tape_34xx_block_id       bid;
  47 };
  48
  49 static void tape_34xx_delete_sbid_from(struct tape_device *, int);
  50
  51 /*
  52  * Medium sense for 34xx tapes. There is no 'real' medium sense call.
  53  * So we just do a normal sense.
  54  */
  55 static int
  56 tape_34xx_medium_sense(struct tape_device *device)
  57 {
  58         struct tape_request *request;
  59         unsigned char       *sense;
  60         int                  rc;
  61
  62         request = tape_alloc_request(1, 32);
  63         if (IS_ERR(request)) {
  64                 DBF_EXCEPTION(6, "MSEN fail\n");
  65                 return PTR_ERR(request);
  66         }
  67
  68         request->op = TO_MSEN;
  69         tape_ccw_end(request->cpaddr, SENSE, 32, request->cpdata);
  70
  71         rc = tape_do_io_interruptible(device, request);
  72         if (request->rc == 0) {
  73                 sense = request->cpdata;
  74
  75                 /*
  76                  * This isn't quite correct. But since INTERVENTION_REQUIRED
  77                  * means that the drive is 'neither ready nor on-line' it is
  78                  * only slightly inaccurate to say there is no tape loaded if
  79                  * the drive isn't online...
  80                  */
  81                 if (sense[0] & SENSE_INTERVENTION_REQUIRED)
  82                         tape_med_state_set(device, MS_UNLOADED);
  83                 else
  84                         tape_med_state_set(device, MS_LOADED);
  85
  86                 if (sense[1] & SENSE_WRITE_PROTECT)
  87                         device->tape_generic_status |= GMT_WR_PROT(~0);
  88                 else
  89                         device->tape_generic_status &= ~GMT_WR_PROT(~0);
  90         } else {
  91                 DBF_EVENT(4, "tape_34xx: medium sense failed with rc=%d\n",
  92                         request->rc);
  93         }
  94         tape_free_request(request);
  95
  96         return rc;
  97 }
  98
  99 struct tape_34xx_work {
 100         struct tape_device      *device;
 101         enum tape_op             op;
 102         struct work_struct       work;
 103 };
 104
 105 /*
 106  * These functions are currently used only to schedule a medium_sense for
 107  * later execution. This is because we get an interrupt whenever a medium
 108  * is inserted but cannot call tape_do_io* from an interrupt context.
 109  * Maybe that's useful for other actions we want to start from the
 110  * interrupt handler.
 111  */
 112 static void
 113 tape_34xx_work_handler(struct work_struct *work)
 114 {
 115         struct tape_34xx_work *p =
 116                 container_of(work, struct tape_34xx_work, work);
 117         struct tape_device *device = p->device;
 118
 119         switch(p->op) {
 120                 case TO_MSEN:
 121                         tape_34xx_medium_sense(device);
 122                         break;
 123                 default:
 124                         DBF_EVENT(3, "T34XX: internal error: unknown work\n");
 125         }
 126         tape_put_device(device);
 127         kfree(p);
 128 }
 129
 130 static int
 131 tape_34xx_schedule_work(struct tape_device *device, enum tape_op op)
 132 {
 133         struct tape_34xx_work *p;
 134
 135         if ((p = kzalloc(sizeof(*p), GFP_ATOMIC)) == NULL)
 136                 return -ENOMEM;
 137
 138         INIT_WORK(&p->work, tape_34xx_work_handler);
 139
 140         p->device = tape_get_device(device);
 141         p->op     = op;
 142
 143         schedule_work(&p->work);
 144         return 0;
 145 }
 146
 147 /*
 148  * Done Handler is called when dev stat = DEVICE-END (successful operation)
 149  */
 150 static inline int
 151 tape_34xx_done(struct tape_request *request)
 152 {
 153         DBF_EVENT(6, "%s done\n", tape_op_verbose[request->op]);
 154
 155         switch (request->op) {
 156                 case TO_DSE:
 157                 case TO_RUN:
 158                 case TO_WRI:
 159                 case TO_WTM:
 160                 case TO_ASSIGN:
 161                 case TO_UNASSIGN:
 162                         tape_34xx_delete_sbid_from(request->device, 0);
 163                         break;
 164                 default:
 165                         ;
 166         }
 167         return TAPE_IO_SUCCESS;
 168 }
 169
 170 static inline int
 171 tape_34xx_erp_failed(struct tape_request *request, int rc)
 172 {
 173         DBF_EVENT(3, "Error recovery failed for %s (RC=%d)\n",
 174                   tape_op_verbose[request->op], rc);
 175         return rc;
 176 }
 177
 178 static inline int
 179 tape_34xx_erp_succeeded(struct tape_request *request)
 180 {
 181         DBF_EVENT(3, "Error Recovery successful for %s\n",
 182                   tape_op_verbose[request->op]);
 183         return tape_34xx_done(request);
 184 }
 185
 186 static inline int
 187 tape_34xx_erp_retry(struct tape_request *request)
 188 {
 189         DBF_EVENT(3, "xerp retr %s\n", tape_op_verbose[request->op]);
 190         return TAPE_IO_RETRY;
 191 }
 192
 193 /*
 194  * This function is called, when no request is outstanding and we get an
 195  * interrupt
 196  */
 197 static int
 198 tape_34xx_unsolicited_irq(struct tape_device *device, struct irb *irb)
 199 {
 200         if (irb->scsw.cmd.dstat == 0x85) { /* READY */
 201                 /* A medium was inserted in the drive. */
 202                 DBF_EVENT(6, "xuud med\n");
 203                 tape_34xx_delete_sbid_from(device, 0);
 204                 tape_34xx_schedule_work(device, TO_MSEN);
 205         } else {
 206                 DBF_EVENT(3, "unsol.irq! dev end: %08x\n", device->cdev_id);
 207                 tape_dump_sense_dbf(device, NULL, irb);
 208         }
 209         return TAPE_IO_SUCCESS;
 210 }
 211
 212 /*
 213  * Read Opposite Error Recovery Function:
 214  * Used, when Read Forward does not work
 215  */
 216 static int
 217 tape_34xx_erp_read_opposite(struct tape_device *device,
 218                             struct tape_request *request)
 219 {
 220         if (request->op == TO_RFO) {
 221                 /*
 222                  * We did read forward, but the data could not be read
 223                  * *correctly*. We transform the request to a read backward
 224                  * and try again.
 225                  */
 226                 tape_std_read_backward(device, request);
 227                 return tape_34xx_erp_retry(request);
 228         }
 229
 230         /*
 231          * We tried to read forward and backward, but hat no
 232          * success -> failed.
 233          */
 234         return tape_34xx_erp_failed(request, -EIO);
 235 }
 236
 237 static int
 238 tape_34xx_erp_bug(struct tape_device *device, struct tape_request *request,
 239                   struct irb *irb, int no)
 240 {
 241         if (request->op != TO_ASSIGN) {
 242                 dev_err(&device->cdev->dev, "An unexpected condition %d "
 243                         "occurred in tape error recovery\n", no);
 244                 tape_dump_sense_dbf(device, request, irb);
 245         }
 246         return tape_34xx_erp_failed(request, -EIO);
 247 }
 248
 249 /*
 250  * Handle data overrun between cu and drive. The channel speed might
 251  * be too slow.
 252  */
 253 static int
 254 tape_34xx_erp_overrun(struct tape_device *device, struct tape_request *request,
 255                       struct irb *irb)
 256 {
 257         if (irb->ecw[3] == 0x40) {
 258                 dev_warn (&device->cdev->dev, "A data overrun occurred between"
 259                         " the control unit and tape unit\n");
 260                 return tape_34xx_erp_failed(request, -EIO);
 261         }
 262         return tape_34xx_erp_bug(device, request, irb, -1);
 263 }
 264
 265 /*
 266  * Handle record sequence error.
 267  */
 268 static int
 269 tape_34xx_erp_sequence(struct tape_device *device,
 270                        struct tape_request *request, struct irb *irb)
 271 {
 272         if (irb->ecw[3] == 0x41) {
 273                 /*
 274                  * cu detected incorrect block-id sequence on tape.
 275                  */
 276                 dev_warn (&device->cdev->dev, "The block ID sequence on the "
 277                         "tape is incorrect\n");
 278                 return tape_34xx_erp_failed(request, -EIO);
 279         }
 280         /*
 281          * Record sequence error bit is set, but erpa does not
 282          * show record sequence error.
 283          */
 284         return tape_34xx_erp_bug(device, request, irb, -2);
 285 }
 286
 287 /*
 288  * This function analyses the tape's sense-data in case of a unit-check.
 289  * If possible, it tries to recover from the error. Else the user is
 290  * informed about the problem.
 291  */
 292 static int
 293 tape_34xx_unit_check(struct tape_device *device, struct tape_request *request,
 294                      struct irb *irb)
 295 {
 296         int inhibit_cu_recovery;
 297         __u8* sense;
 298
 299         inhibit_cu_recovery = (*device->modeset_byte & 0x80) ? 1 : 0;
 300         sense = irb->ecw;
 301
 302 #ifdef CONFIG_S390_TAPE_BLOCK
 303         if (request->op == TO_BLOCK) {
 304                 /*
 305                  * Recovery for block device requests. Set the block_position
 306                  * to something invalid and retry.
 307                  */
 308                 device->blk_data.block_position = -1;
 309                 if (request->retries-- <= 0)
 310                         return tape_34xx_erp_failed(request, -EIO);
 311                 else
 312                         return tape_34xx_erp_retry(request);
 313         }
 314 #endif
 315
 316         if (
 317                 sense[0] & SENSE_COMMAND_REJECT &&
 318                 sense[1] & SENSE_WRITE_PROTECT
 319         ) {
 320                 if (
 321                         request->op == TO_DSE ||
 322                         request->op == TO_WRI ||
 323                         request->op == TO_WTM
 324                 ) {
 325                         /* medium is write protected */
 326                         return tape_34xx_erp_failed(request, -EACCES);
 327                 } else {
 328                         return tape_34xx_erp_bug(device, request, irb, -3);
 329                 }
 330         }
 331
 332         /*
 333          * Special cases for various tape-states when reaching
 334          * end of recorded area
 335          *
 336          * FIXME: Maybe a special case of the special case:
 337          *        sense[0] == SENSE_EQUIPMENT_CHECK &&
 338          *        sense[1] == SENSE_DRIVE_ONLINE    &&
 339          *        sense[3] == 0x47 (Volume Fenced)
 340          *
 341          *        This was caused by continued FSF or FSR after an
 342          *        'End Of Data'.
 343          */
 344         if ((
 345                 sense[0] == SENSE_DATA_CHECK      ||
 346                 sense[0] == SENSE_EQUIPMENT_CHECK ||
 347                 sense[0] == SENSE_EQUIPMENT_CHECK + SENSE_DEFERRED_UNIT_CHECK
 348         ) && (
 349                 sense[1] == SENSE_DRIVE_ONLINE ||
 350                 sense[1] == SENSE_BEGINNING_OF_TAPE + SENSE_WRITE_MODE
 351         )) {
 352                 switch (request->op) {
 353                 /*
 354                  * sense[0] == SENSE_DATA_CHECK   &&
 355                  * sense[1] == SENSE_DRIVE_ONLINE
 356                  * sense[3] == 0x36 (End Of Data)
 357                  *
 358                  * Further seeks might return a 'Volume Fenced'.
 359                  */
 360                 case TO_FSF:
 361                 case TO_FSB:
 362                         /* Trying to seek beyond end of recorded area */
 363                         return tape_34xx_erp_failed(request, -ENOSPC);
 364                 case TO_BSB:
 365                         return tape_34xx_erp_retry(request);
 366
 367                 /*
 368                  * sense[0] == SENSE_DATA_CHECK   &&
 369                  * sense[1] == SENSE_DRIVE_ONLINE &&
 370                  * sense[3] == 0x36 (End Of Data)
 371                  */
 372                 case TO_LBL:
 373                         /* Block could not be located. */
 374                         tape_34xx_delete_sbid_from(device, 0);
 375                         return tape_34xx_erp_failed(request, -EIO);
 376
 377                 case TO_RFO:
 378                         /* Read beyond end of recorded area -> 0 bytes read */
 379                         return tape_34xx_erp_failed(request, 0);
 380
 381                 /*
 382                  * sense[0] == SENSE_EQUIPMENT_CHECK &&
 383                  * sense[1] == SENSE_DRIVE_ONLINE    &&
 384                  * sense[3] == 0x38 (Physical End Of Volume)
 385                  */
 386                 case TO_WRI:
 387                         /* Writing at physical end of volume */
 388                         return tape_34xx_erp_failed(request, -ENOSPC);
 389                 default:
 390                         return tape_34xx_erp_failed(request, 0);
 391                 }
 392         }
 393
 394         /* Sensing special bits */
 395         if (sense[0] & SENSE_BUS_OUT_CHECK)
 396                 return tape_34xx_erp_retry(request);
 397
 398         if (sense[0] & SENSE_DATA_CHECK) {
 399                 /*
 400                  * hardware failure, damaged tape or improper
 401                  * operating conditions
 402                  */
 403                 switch (sense[3]) {
 404                 case 0x23:
 405                         /* a read data check occurred */
 406                         if ((sense[2] & SENSE_TAPE_SYNC_MODE) ||
 407                             inhibit_cu_recovery)
 408                                 // data check is not permanent, may be
 409                                 // recovered. We always use async-mode with
 410                                 // cu-recovery, so this should *never* happen.
 411                                 return tape_34xx_erp_bug(device, request,
 412                                                          irb, -4);
 413
 414                         /* data check is permanent, CU recovery has failed */
 415                         dev_warn (&device->cdev->dev, "A read error occurred "
 416                                 "that cannot be recovered\n");
 417                         return tape_34xx_erp_failed(request, -EIO);
 418                 case 0x25:
 419                         // a write data check occurred
 420                         if ((sense[2] & SENSE_TAPE_SYNC_MODE) ||
 421                             inhibit_cu_recovery)
 422                                 // data check is not permanent, may be
 423                                 // recovered. We always use async-mode with
 424                                 // cu-recovery, so this should *never* happen.
 425                                 return tape_34xx_erp_bug(device, request,
 426                                                          irb, -5);
 427
 428                         // data check is permanent, cu-recovery has failed
 429                         dev_warn (&device->cdev->dev, "A write error on the "
 430                                 "tape cannot be recovered\n");
 431                         return tape_34xx_erp_failed(request, -EIO);
 432                 case 0x26:
 433                         /* Data Check (read opposite) occurred. */
 434                         return tape_34xx_erp_read_opposite(device, request);
 435                 case 0x28:
 436                         /* ID-Mark at tape start couldn't be written */
 437                         dev_warn (&device->cdev->dev, "Writing the ID-mark "
 438                                 "failed\n");
 439                         return tape_34xx_erp_failed(request, -EIO);
 440                 case 0x31:
 441                         /* Tape void. Tried to read beyond end of device. */
 442                         dev_warn (&device->cdev->dev, "Reading the tape beyond"
 443                                 " the end of the recorded area failed\n");
 444                         return tape_34xx_erp_failed(request, -ENOSPC);
 445                 case 0x41:
 446                         /* Record sequence error. */
 447                         dev_warn (&device->cdev->dev, "The tape contains an "
 448                                 "incorrect block ID sequence\n");
 449                         return tape_34xx_erp_failed(request, -EIO);
 450                 default:
 451                         /* all data checks for 3480 should result in one of
 452                          * the above erpa-codes. For 3490, other data-check
 453                          * conditions do exist. */
 454                         if (device->cdev->id.driver_info == tape_3480)
 455                                 return tape_34xx_erp_bug(device, request,
 456                                                          irb, -6);
 457                 }
 458         }
 459
 460         if (sense[0] & SENSE_OVERRUN)
 461                 return tape_34xx_erp_overrun(device, request, irb);
 462
 463         if (sense[1] & SENSE_RECORD_SEQUENCE_ERR)
 464                 return tape_34xx_erp_sequence(device, request, irb);
 465
 466         /* Sensing erpa codes */
 467         switch (sense[3]) {
 468         case 0x00:
 469                 /* Unit check with erpa code 0. Report and ignore. */
 470                 return TAPE_IO_SUCCESS;
 471         case 0x21:
 472                 /*
 473                  * Data streaming not operational. CU will switch to
 474                  * interlock mode. Reissue the command.
 475                  */
 476                 return tape_34xx_erp_retry(request);
 477         case 0x22:
 478                 /*
 479                  * Path equipment check. Might be drive adapter error, buffer
 480                  * error on the lower interface, internal path not usable,
 481                  * or error during cartridge load.
 482                  */
 483                 dev_warn (&device->cdev->dev, "A path equipment check occurred"
 484                         " for the tape device\n");
 485                 return tape_34xx_erp_failed(request, -EIO);
 486         case 0x24:
 487                 /*
 488                  * Load display check. Load display was command was issued,
 489                  * but the drive is displaying a drive check message. Can
 490                  * be threated as "device end".
 491                  */
 492                 return tape_34xx_erp_succeeded(request);
 493         case 0x27:
 494                 /*
 495                  * Command reject. May indicate illegal channel program or
 496                  * buffer over/underrun. Since all channel programs are
 497                  * issued by this driver and ought be correct, we assume a
 498                  * over/underrun situation and retry the channel program.
 499                  */
 500                 return tape_34xx_erp_retry(request);
 501         case 0x29:
 502                 /*
 503                  * Function incompatible. Either the tape is idrc compressed
 504                  * but the hardware isn't capable to do idrc, or a perform
 505                  * subsystem func is issued and the CU is not on-line.
 506                  */
 507                 return tape_34xx_erp_failed(request, -EIO);
 508         case 0x2a:
 509                 /*
 510                  * Unsolicited environmental data. An internal counter
 511                  * overflows, we can ignore this and reissue the cmd.
 512                  */
 513                 return tape_34xx_erp_retry(request);
 514         case 0x2b:
 515                 /*
 516                  * Environmental data present. Indicates either unload
 517                  * completed ok or read buffered log command completed ok.
 518                  */
 519                 if (request->op == TO_RUN) {
 520                         /* Rewind unload completed ok. */
 521                         tape_med_state_set(device, MS_UNLOADED);
 522                         return tape_34xx_erp_succeeded(request);
 523                 }
 524                 /* tape_34xx doesn't use read buffered log commands. */
 525                 return tape_34xx_erp_bug(device, request, irb, sense[3]);
 526         case 0x2c:
 527                 /*
 528                  * Permanent equipment check. CU has tried recovery, but
 529                  * did not succeed.
 530                  */
 531                 return tape_34xx_erp_failed(request, -EIO);
 532         case 0x2d:
 533                 /* Data security erase failure. */
 534                 if (request->op == TO_DSE)
 535                         return tape_34xx_erp_failed(request, -EIO);
 536                 /* Data security erase failure, but no such command issued. */
 537                 return tape_34xx_erp_bug(device, request, irb, sense[3]);
 538         case 0x2e:
 539                 /*
 540                  * Not capable. This indicates either that the drive fails
 541                  * reading the format id mark or that that format specified
 542                  * is not supported by the drive.
 543                  */
 544                 dev_warn (&device->cdev->dev, "The tape unit cannot process "
 545                         "the tape format\n");
 546                 return tape_34xx_erp_failed(request, -EMEDIUMTYPE);
 547         case 0x30:
 548                 /* The medium is write protected. */
 549                 dev_warn (&device->cdev->dev, "The tape medium is write-"
 550                         "protected\n");
 551                 return tape_34xx_erp_failed(request, -EACCES);
 552         case 0x32:
 553                 // Tension loss. We cannot recover this, it's an I/O error.
 554                 dev_warn (&device->cdev->dev, "The tape does not have the "
 555                         "required tape tension\n");
 556                 return tape_34xx_erp_failed(request, -EIO);
 557         case 0x33:
 558                 /*
 559                  * Load Failure. The cartridge was not inserted correctly or
 560                  * the tape is not threaded correctly.
 561                  */
 562                 dev_warn (&device->cdev->dev, "The tape unit failed to load"
 563                         " the cartridge\n");
 564                 tape_34xx_delete_sbid_from(device, 0);
 565                 return tape_34xx_erp_failed(request, -EIO);
 566         case 0x34:
 567                 /*
 568                  * Unload failure. The drive cannot maintain tape tension
 569                  * and control tape movement during an unload operation.
 570                  */
 571                 dev_warn (&device->cdev->dev, "Automatic unloading of the tape"
 572                         " cartridge failed\n");
 573                 if (request->op == TO_RUN)
 574                         return tape_34xx_erp_failed(request, -EIO);
 575                 return tape_34xx_erp_bug(device, request, irb, sense[3]);
 576         case 0x35:
 577                 /*
 578                  * Drive equipment check. One of the following:
 579                  * - cu cannot recover from a drive detected error
 580                  * - a check code message is shown on drive display
 581                  * - the cartridge loader does not respond correctly
 582                  * - a failure occurs during an index, load, or unload cycle
 583                  */
 584                 dev_warn (&device->cdev->dev, "An equipment check has occurred"
 585                         " on the tape unit\n");
 586                 return tape_34xx_erp_failed(request, -EIO);
 587         case 0x36:
 588                 if (device->cdev->id.driver_info == tape_3490)
 589                         /* End of data. */
 590                         return tape_34xx_erp_failed(request, -EIO);
 591                 /* This erpa is reserved for 3480 */
 592                 return tape_34xx_erp_bug(device, request, irb, sense[3]);
 593         case 0x37:
 594                 /*
 595                  * Tape length error. The tape is shorter than reported in
 596                  * the beginning-of-tape data.
 597                  */
 598                 dev_warn (&device->cdev->dev, "The tape information states an"
 599                         " incorrect length\n");
 600                 return tape_34xx_erp_failed(request, -EIO);
 601         case 0x38:
 602                 /*
 603                  * Physical end of tape. A read/write operation reached
 604                  * the physical end of tape.
 605                  */
 606                 if (request->op==TO_WRI ||
 607                     request->op==TO_DSE ||
 608                     request->op==TO_WTM)
 609                         return tape_34xx_erp_failed(request, -ENOSPC);
 610                 return tape_34xx_erp_failed(request, -EIO);
 611         case 0x39:
 612                 /* Backward at Beginning of tape. */
 613                 return tape_34xx_erp_failed(request, -EIO);
 614         case 0x3a:
 615                 /* Drive switched to not ready. */
 616                 dev_warn (&device->cdev->dev, "The tape unit is not ready\n");
 617                 return tape_34xx_erp_failed(request, -EIO);
 618         case 0x3b:
 619                 /* Manual rewind or unload. This causes an I/O error. */
 620                 dev_warn (&device->cdev->dev, "The tape medium has been "
 621                         "rewound or unloaded manually\n");
 622                 tape_34xx_delete_sbid_from(device, 0);
 623                 return tape_34xx_erp_failed(request, -EIO);
 624         case 0x42:
 625                 /*
 626                  * Degraded mode. A condition that can cause degraded
 627                  * performance is detected.
 628                  */
 629                 dev_warn (&device->cdev->dev, "The tape subsystem is running "
 630                         "in degraded mode\n");
 631                 return tape_34xx_erp_retry(request);
 632         case 0x43:
 633                 /* Drive not ready. */
 634                 tape_34xx_delete_sbid_from(device, 0);
 635                 tape_med_state_set(device, MS_UNLOADED);
 636                 /* Some commands commands are successful even in this case */
 637                 if (sense[1] & SENSE_DRIVE_ONLINE) {
 638                         switch(request->op) {
 639                                 case TO_ASSIGN:
 640                                 case TO_UNASSIGN:
 641                                 case TO_DIS:
 642                                 case TO_NOP:
 643                                         return tape_34xx_done(request);
 644                                         break;
 645                                 default:
 646                                         break;
 647                         }
 648                 }
 649                 return tape_34xx_erp_failed(request, -ENOMEDIUM);
 650         case 0x44:
 651                 /* Locate Block unsuccessful. */
 652                 if (request->op != TO_BLOCK && request->op != TO_LBL)
 653                         /* No locate block was issued. */
 654                         return tape_34xx_erp_bug(device, request,
 655                                                  irb, sense[3]);
 656                 return tape_34xx_erp_failed(request, -EIO);
 657         case 0x45:
 658                 /* The drive is assigned to a different channel path. */
 659                 dev_warn (&device->cdev->dev, "The tape unit is already "
 660                         "assigned\n");
 661                 return tape_34xx_erp_failed(request, -EIO);
 662         case 0x46:
 663                 /*
 664                  * Drive not on-line. Drive may be switched offline,
 665                  * the power supply may be switched off or
 666                  * the drive address may not be set correctly.
 667                  */
 668                 dev_warn (&device->cdev->dev, "The tape unit is not online\n");
 669                 return tape_34xx_erp_failed(request, -EIO);
 670         case 0x47:
 671                 /* Volume fenced. CU reports volume integrity is lost. */
 672                 dev_warn (&device->cdev->dev, "The control unit has fenced "
 673                         "access to the tape volume\n");
 674                 tape_34xx_delete_sbid_from(device, 0);
 675                 return tape_34xx_erp_failed(request, -EIO);
 676         case 0x48:
 677                 /* Log sense data and retry request. */
 678                 return tape_34xx_erp_retry(request);
 679         case 0x49:
 680                 /* Bus out check. A parity check error on the bus was found. */
 681                 dev_warn (&device->cdev->dev, "A parity error occurred on the "
 682                         "tape bus\n");
 683                 return tape_34xx_erp_failed(request, -EIO);
 684         case 0x4a:
 685                 /* Control unit erp failed. */
 686                 dev_warn (&device->cdev->dev, "I/O error recovery failed on "
 687                         "the tape control unit\n");
 688                 return tape_34xx_erp_failed(request, -EIO);
 689         case 0x4b:
 690                 /*
 691                  * CU and drive incompatible. The drive requests micro-program
 692                  * patches, which are not available on the CU.
 693                  */
 694                 dev_warn (&device->cdev->dev, "The tape unit requires a "
 695                         "firmware update\n");
 696                 return tape_34xx_erp_failed(request, -EIO);
 697         case 0x4c:
 698                 /*
 699                  * Recovered Check-One failure. Cu develops a hardware error,
 700                  * but is able to recover.
 701                  */
 702                 return tape_34xx_erp_retry(request);
 703         case 0x4d:
 704                 if (device->cdev->id.driver_info == tape_3490)
 705                         /*
 706                          * Resetting event received. Since the driver does
 707                          * not support resetting event recovery (which has to
 708                          * be handled by the I/O Layer), retry our command.
 709                          */
 710                         return tape_34xx_erp_retry(request);
 711                 /* This erpa is reserved for 3480. */
 712                 return tape_34xx_erp_bug(device, request, irb, sense[3]);
 713         case 0x4e:
 714                 if (device->cdev->id.driver_info == tape_3490) {
 715                         /*
 716                          * Maximum block size exceeded. This indicates, that
 717                          * the block to be written is larger than allowed for
 718                          * buffered mode.
 719                          */
 720                         dev_warn (&device->cdev->dev, "The maximum block size"
 721                                 " for buffered mode is exceeded\n");
 722                         return tape_34xx_erp_failed(request, -ENOBUFS);
 723                 }
 724                 /* This erpa is reserved for 3480. */
 725                 return tape_34xx_erp_bug(device, request, irb, sense[3]);
 726         case 0x50:
 727                 /*
 728                  * Read buffered log (Overflow). CU is running in extended
 729                  * buffered log mode, and a counter overflows. This should
 730                  * never happen, since we're never running in extended
 731                  * buffered log mode.
 732                  */
 733                 return tape_34xx_erp_retry(request);
 734         case 0x51:
 735                 /*
 736                  * Read buffered log (EOV). EOF processing occurs while the
 737                  * CU is in extended buffered log mode. This should never
 738                  * happen, since we're never running in extended buffered
 739                  * log mode.
 740                  */
 741                 return tape_34xx_erp_retry(request);
 742         case 0x52:
 743                 /* End of Volume complete. Rewind unload completed ok. */
 744                 if (request->op == TO_RUN) {
 745                         tape_med_state_set(device, MS_UNLOADED);
 746                         tape_34xx_delete_sbid_from(device, 0);
 747                         return tape_34xx_erp_succeeded(request);
 748                 }
 749                 return tape_34xx_erp_bug(device, request, irb, sense[3]);
 750         case 0x53:
 751                 /* Global command intercept. */
 752                 return tape_34xx_erp_retry(request);
 753         case 0x54:
 754                 /* Channel interface recovery (temporary). */
 755                 return tape_34xx_erp_retry(request);
 756         case 0x55:
 757                 /* Channel interface recovery (permanent). */
 758                 dev_warn (&device->cdev->dev, "A channel interface error cannot be"
 759                         " recovered\n");
 760                 return tape_34xx_erp_failed(request, -EIO);
 761         case 0x56:
 762                 /* Channel protocol error. */
 763                 dev_warn (&device->cdev->dev, "A channel protocol error "
 764                         "occurred\n");
 765                 return tape_34xx_erp_failed(request, -EIO);
 766         case 0x57:
 767                 if (device->cdev->id.driver_info == tape_3480) {
 768                         /* Attention intercept. */
 769                         return tape_34xx_erp_retry(request);
 770                 } else {
 771                         /* Global status intercept. */
 772                         return tape_34xx_erp_retry(request);
 773                 }
 774         case 0x5a:
 775                 /*
 776                  * Tape length incompatible. The tape inserted is too long,
 777                  * which could cause damage to the tape or the drive.
 778                  */
 779                 dev_warn (&device->cdev->dev, "The tape unit does not support "
 780                         "the tape length\n");
 781                 return tape_34xx_erp_failed(request, -EIO);
 782         case 0x5b:
 783                 /* Format 3480 XF incompatible */
 784                 if (sense[1] & SENSE_BEGINNING_OF_TAPE)
 785                         /* The tape will get overwritten. */
 786                         return tape_34xx_erp_retry(request);
 787                 dev_warn (&device->cdev->dev, "The tape unit does not support"
 788                         " format 3480 XF\n");
 789                 return tape_34xx_erp_failed(request, -EIO);
 790         case 0x5c:
 791                 /* Format 3480-2 XF incompatible */
 792                 dev_warn (&device->cdev->dev, "The tape unit does not support tape "
 793                         "format 3480-2 XF\n");
 794                 return tape_34xx_erp_failed(request, -EIO);
 795         case 0x5d:
 796                 /* Tape length violation. */
 797                 dev_warn (&device->cdev->dev, "The tape unit does not support"
 798                         " the current tape length\n");
 799                 return tape_34xx_erp_failed(request, -EMEDIUMTYPE);
 800         case 0x5e:
 801                 /* Compaction algorithm incompatible. */
 802                 dev_warn (&device->cdev->dev, "The tape unit does not support"
 803                         " the compaction algorithm\n");
 804                 return tape_34xx_erp_failed(request, -EMEDIUMTYPE);
 805
 806                 /* The following erpas should have been covered earlier. */
 807         case 0x23: /* Read data check. */
 808         case 0x25: /* Write data check. */
 809         case 0x26: /* Data check (read opposite). */
 810         case 0x28: /* Write id mark check. */
 811         case 0x31: /* Tape void. */
 812         case 0x40: /* Overrun error. */
 813         case 0x41: /* Record sequence error. */
 814                 /* All other erpas are reserved for future use. */
 815         default:
 816                 return tape_34xx_erp_bug(device, request, irb, sense[3]);
 817         }
 818 }
 819
 820 /*
 821  * 3480/3490 interrupt handler
 822  */
 823 static int
 824 tape_34xx_irq(struct tape_device *device, struct tape_request *request,
 825               struct irb *irb)
 826 {
 827         if (request == NULL)
 828                 return tape_34xx_unsolicited_irq(device, irb);
 829
 830         if ((irb->scsw.cmd.dstat & DEV_STAT_UNIT_EXCEP) &&
 831             (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) &&
 832             (request->op == TO_WRI)) {
 833                 /* Write at end of volume */
 834                 return tape_34xx_erp_failed(request, -ENOSPC);
 835         }
 836
 837         if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK)
 838                 return tape_34xx_unit_check(device, request, irb);
 839
 840         if (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) {
 841                 /*
 842                  * A unit exception occurs on skipping over a tapemark block.
 843                  */
 844                 if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_EXCEP) {
 845                         if (request->op == TO_BSB || request->op == TO_FSB)
 846                                 request->rescnt++;
 847                         else
 848                                 DBF_EVENT(5, "Unit Exception!\n");
 849                 }
 850                 return tape_34xx_done(request);
 851         }
 852
 853         DBF_EVENT(6, "xunknownirq\n");
 854         tape_dump_sense_dbf(device, request, irb);
 855         return TAPE_IO_STOP;
 856 }
 857
 858 /*
 859  * ioctl_overload
 860  */
 861 static int
 862 tape_34xx_ioctl(struct tape_device *device, unsigned int cmd, unsigned long arg)
 863 {
 864         if (cmd == TAPE390_DISPLAY) {
 865                 struct display_struct disp;
 866
 867                 if (copy_from_user(&disp, (char __user *) arg, sizeof(disp)) != 0)
 868                         return -EFAULT;
 869
 870                 return tape_std_display(device, &disp);
 871         } else
 872                 return -EINVAL;
 873 }
 874
 875 static inline void
 876 tape_34xx_append_new_sbid(struct tape_34xx_block_id bid, struct list_head *l)
 877 {
 878         struct tape_34xx_sbid * new_sbid;
 879
 880         new_sbid = kmalloc(sizeof(*new_sbid), GFP_ATOMIC);
 881         if (!new_sbid)
 882                 return;
 883
 884         new_sbid->bid = bid;
 885         list_add(&new_sbid->list, l);
 886 }
 887
 888 /*
 889  * Build up the search block ID list. The block ID consists of a logical
 890  * block number and a hardware specific part. The hardware specific part
 891  * helps the tape drive to speed up searching for a specific block.
 892  */
 893 static void
 894 tape_34xx_add_sbid(struct tape_device *device, struct tape_34xx_block_id bid)
 895 {
 896         struct list_head *      sbid_list;
 897         struct tape_34xx_sbid * sbid;
 898         struct list_head *      l;
 899
 900         /*
 901          * immediately return if there is no list at all or the block to add
 902          * is located in segment 1 of wrap 0 because this position is used
 903          * if no hardware position data is supplied.
 904          */
 905         sbid_list = (struct list_head *) device->discdata;
 906         if (!sbid_list || (bid.segment < 2 && bid.wrap == 0))
 907                 return;
 908
 909         /*
 910          * Search the position where to insert the new entry. Hardware
 911          * acceleration uses only the segment and wrap number. So we
 912          * need only one entry for a specific wrap/segment combination.
 913          * If there is a block with a lower number but the same hard-
 914          * ware position data we just update the block number in the
 915          * existing entry.
 916          */
 917         list_for_each(l, sbid_list) {
 918                 sbid = list_entry(l, struct tape_34xx_sbid, list);
 919
 920                 if (
 921                         (sbid->bid.segment == bid.segment) &&
 922                         (sbid->bid.wrap    == bid.wrap)
 923                 ) {
 924                         if (bid.block < sbid->bid.block)
 925                                 sbid->bid = bid;
 926                         else return;
 927                         break;
 928                 }
 929
 930                 /* Sort in according to logical block number. */
 931                 if (bid.block < sbid->bid.block) {
 932                         tape_34xx_append_new_sbid(bid, l->prev);
 933                         break;
 934                 }
 935         }
 936         /* List empty or new block bigger than last entry. */
 937         if (l == sbid_list)
 938                 tape_34xx_append_new_sbid(bid, l->prev);
 939
 940         DBF_LH(4, "Current list is:\n");
 941         list_for_each(l, sbid_list) {
 942                 sbid = list_entry(l, struct tape_34xx_sbid, list);
 943                 DBF_LH(4, "%d:%03d@%05d\n",
 944                         sbid->bid.wrap,
 945                         sbid->bid.segment,
 946                         sbid->bid.block
 947                 );
 948         }
 949 }
 950
 951 /*
 952  * Delete all entries from the search block ID list that belong to tape blocks
 953  * equal or higher than the given number.
 954  */
 955 static void
 956 tape_34xx_delete_sbid_from(struct tape_device *device, int from)
 957 {
 958         struct list_head *      sbid_list;
 959         struct tape_34xx_sbid * sbid;
 960         struct list_head *      l;
 961         struct list_head *      n;
 962
 963         sbid_list = (struct list_head *) device->discdata;
 964         if (!sbid_list)
 965                 return;
 966
 967         list_for_each_safe(l, n, sbid_list) {
 968                 sbid = list_entry(l, struct tape_34xx_sbid, list);
 969                 if (sbid->bid.block >= from) {
 970                         DBF_LH(4, "Delete sbid %d:%03d@%05d\n",
 971                                 sbid->bid.wrap,
 972                                 sbid->bid.segment,
 973                                 sbid->bid.block
 974                         );
 975                         list_del(l);
 976                         kfree(sbid);
 977                 }
 978         }
 979 }
 980
 981 /*
 982  * Merge hardware position data into a block id.
 983  */
 984 static void
 985 tape_34xx_merge_sbid(
 986         struct tape_device *            device,
 987         struct tape_34xx_block_id *     bid
 988 ) {
 989         struct tape_34xx_sbid * sbid;
 990         struct tape_34xx_sbid * sbid_to_use;
 991         struct list_head *      sbid_list;
 992         struct list_head *      l;
 993
 994         sbid_list = (struct list_head *) device->discdata;
 995         bid->wrap    = 0;
 996         bid->segment = 1;
 997
 998         if (!sbid_list || list_empty(sbid_list))
 999                 return;
1000
1001         sbid_to_use = NULL;
1002         list_for_each(l, sbid_list) {
1003                 sbid = list_entry(l, struct tape_34xx_sbid, list);
1004
1005                 if (sbid->bid.block >= bid->block)
1006                         break;
1007                 sbid_to_use = sbid;
1008         }
1009         if (sbid_to_use) {
1010                 bid->wrap    = sbid_to_use->bid.wrap;
1011                 bid->segment = sbid_to_use->bid.segment;
1012                 DBF_LH(4, "Use %d:%03d@%05d for %05d\n",
1013                         sbid_to_use->bid.wrap,
1014                         sbid_to_use->bid.segment,
1015                         sbid_to_use->bid.block,
1016                         bid->block
1017                 );
1018         }
1019 }
1020
1021 static int
1022 tape_34xx_setup_device(struct tape_device * device)
1023 {
1024         int                     rc;
1025         struct list_head *      discdata;
1026
1027         DBF_EVENT(6, "34xx device setup\n");
1028         if ((rc = tape_std_assign(device)) == 0) {
1029                 if ((rc = tape_34xx_medium_sense(device)) != 0) {
1030                         DBF_LH(3, "34xx medium sense returned %d\n", rc);
1031                 }
1032         }
1033         discdata = kmalloc(sizeof(struct list_head), GFP_KERNEL);
1034         if (discdata) {
1035                         INIT_LIST_HEAD(discdata);
1036                         device->discdata = discdata;
1037         }
1038
1039         return rc;
1040 }
1041
1042 static void
1043 tape_34xx_cleanup_device(struct tape_device *device)
1044 {
1045         tape_std_unassign(device);
1046
1047         if (device->discdata) {
1048                 tape_34xx_delete_sbid_from(device, 0);
1049                 kfree(device->discdata);
1050                 device->discdata = NULL;
1051         }
1052 }
1053
1054
1055 /*
1056  * MTTELL: Tell block. Return the number of block relative to current file.
1057  */
1058 static int
1059 tape_34xx_mttell(struct tape_device *device, int mt_count)
1060 {
1061         struct {
1062                 struct tape_34xx_block_id       cbid;
1063                 struct tape_34xx_block_id       dbid;
1064         } __attribute__ ((packed)) block_id;
1065         int rc;
1066
1067         rc = tape_std_read_block_id(device, (__u64 *) &block_id);
1068         if (rc)
1069                 return rc;
1070
1071         tape_34xx_add_sbid(device, block_id.cbid);
1072         return block_id.cbid.block;
1073 }
1074
1075 /*
1076  * MTSEEK: seek to the specified block.
1077  */
1078 static int
1079 tape_34xx_mtseek(struct tape_device *device, int mt_count)
1080 {
1081         struct tape_request *request;
1082         struct tape_34xx_block_id *     bid;
1083
1084         if (mt_count > 0x3fffff) {
1085                 DBF_EXCEPTION(6, "xsee parm\n");
1086                 return -EINVAL;
1087         }
1088         request = tape_alloc_request(3, 4);
1089         if (IS_ERR(request))
1090                 return PTR_ERR(request);
1091
1092         /* setup ccws */
1093         request->op = TO_LBL;
1094         bid         = (struct tape_34xx_block_id *) request->cpdata;
1095         bid->format = (*device->modeset_byte & 0x08) ?
1096                         TAPE34XX_FMT_3480_XF : TAPE34XX_FMT_3480;
1097         bid->block  = mt_count;
1098         tape_34xx_merge_sbid(device, bid);
1099
1100         tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
1101         tape_ccw_cc(request->cpaddr + 1, LOCATE, 4, request->cpdata);
1102         tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
1103
1104         /* execute it */
1105         return tape_do_io_free(device, request);
1106 }
1107
1108 #ifdef CONFIG_S390_TAPE_BLOCK
1109 /*
1110  * Tape block read for 34xx.
1111  */
1112 static struct tape_request *
1113 tape_34xx_bread(struct tape_device *device, struct request *req)
1114 {
1115         struct tape_request *request;
1116         struct ccw1 *ccw;
1117         int count = 0;
1118         unsigned off;
1119         char *dst;
1120         struct bio_vec *bv;
1121         struct req_iterator iter;
1122         struct tape_34xx_block_id *     start_block;
1123
1124         DBF_EVENT(6, "xBREDid:");
1125
1126         /* Count the number of blocks for the request. */
1127         rq_for_each_segment(bv, req, iter)
1128                 count += bv->bv_len >> (TAPEBLOCK_HSEC_S2B + 9);
1129
1130         /* Allocate the ccw request. */
1131         request = tape_alloc_request(3+count+1, 8);
1132         if (IS_ERR(request))
1133                 return request;
1134
1135         /* Setup ccws. */
1136         request->op = TO_BLOCK;
1137         start_block = (struct tape_34xx_block_id *) request->cpdata;
1138         start_block->block = blk_rq_pos(req) >> TAPEBLOCK_HSEC_S2B;
1139         DBF_EVENT(6, "start_block = %i\n", start_block->block);
1140
1141         ccw = request->cpaddr;
1142         ccw = tape_ccw_cc(ccw, MODE_SET_DB, 1, device->modeset_byte);
1143
1144         /*
1145          * We always setup a nop after the mode set ccw. This slot is
1146          * used in tape_std_check_locate to insert a locate ccw if the
1147          * current tape position doesn't match the start block to be read.
1148          * The second nop will be filled with a read block id which is in
1149          * turn used by tape_34xx_free_bread to populate the segment bid
1150          * table.
1151          */
1152         ccw = tape_ccw_cc(ccw, NOP, 0, NULL);
1153         ccw = tape_ccw_cc(ccw, NOP, 0, NULL);
1154
1155         rq_for_each_segment(bv, req, iter) {
1156                 dst = kmap(bv->bv_page) + bv->bv_offset;
1157                 for (off = 0; off < bv->bv_len; off += TAPEBLOCK_HSEC_SIZE) {
1158                         ccw->flags = CCW_FLAG_CC;
1159                         ccw->cmd_code = READ_FORWARD;
1160                         ccw->count = TAPEBLOCK_HSEC_SIZE;
1161                         set_normalized_cda(ccw, (void*) __pa(dst));
1162                         ccw++;
1163                         dst += TAPEBLOCK_HSEC_SIZE;
1164                 }
1165         }
1166
1167         ccw = tape_ccw_end(ccw, NOP, 0, NULL);
1168         DBF_EVENT(6, "xBREDccwg\n");
1169         return request;
1170 }
1171
1172 static void
1173 tape_34xx_free_bread (struct tape_request *request)
1174 {
1175         struct ccw1* ccw;
1176
1177         ccw = request->cpaddr;
1178         if ((ccw + 2)->cmd_code == READ_BLOCK_ID) {
1179                 struct {
1180                         struct tape_34xx_block_id       cbid;
1181                         struct tape_34xx_block_id       dbid;
1182                 } __attribute__ ((packed)) *rbi_data;
1183
1184                 rbi_data = request->cpdata;
1185
1186                 if (request->device)
1187                         tape_34xx_add_sbid(request->device, rbi_data->cbid);
1188         }
1189
1190         /* Last ccw is a nop and doesn't need clear_normalized_cda */
1191         for (; ccw->flags & CCW_FLAG_CC; ccw++)
1192                 if (ccw->cmd_code == READ_FORWARD)
1193                         clear_normalized_cda(ccw);
1194         tape_free_request(request);
1195 }
1196
1197 /*
1198  * check_locate is called just before the tape request is passed to
1199  * the common io layer for execution. It has to check the current
1200  * tape position and insert a locate ccw if it doesn't match the
1201  * start block for the request.
1202  */
1203 static void
1204 tape_34xx_check_locate(struct tape_device *device, struct tape_request *request)
1205 {
1206         struct tape_34xx_block_id *     start_block;
1207
1208         start_block = (struct tape_34xx_block_id *) request->cpdata;
1209         if (start_block->block == device->blk_data.block_position)
1210                 return;
1211
1212         DBF_LH(4, "Block seek(%06d+%06d)\n", start_block->block, device->bof);
1213         start_block->wrap    = 0;
1214         start_block->segment = 1;
1215         start_block->format  = (*device->modeset_byte & 0x08) ?
1216                                 TAPE34XX_FMT_3480_XF :
1217                                 TAPE34XX_FMT_3480;
1218         start_block->block   = start_block->block + device->bof;
1219         tape_34xx_merge_sbid(device, start_block);
1220         tape_ccw_cc(request->cpaddr + 1, LOCATE, 4, request->cpdata);
1221         tape_ccw_cc(request->cpaddr + 2, READ_BLOCK_ID, 8, request->cpdata);
1222 }
1223 #endif
1224
1225 /*
1226  * List of 3480/3490 magnetic tape commands.
1227  */
1228 static tape_mtop_fn tape_34xx_mtop[TAPE_NR_MTOPS] = {
1229         [MTRESET]        = tape_std_mtreset,
1230         [MTFSF]          = tape_std_mtfsf,
1231         [MTBSF]          = tape_std_mtbsf,
1232         [MTFSR]          = tape_std_mtfsr,
1233         [MTBSR]          = tape_std_mtbsr,
1234         [MTWEOF]         = tape_std_mtweof,
1235         [MTREW]          = tape_std_mtrew,
1236         [MTOFFL]         = tape_std_mtoffl,
1237         [MTNOP]          = tape_std_mtnop,
1238         [MTRETEN]        = tape_std_mtreten,
1239         [MTBSFM]         = tape_std_mtbsfm,
1240         [MTFSFM]         = tape_std_mtfsfm,
1241         [MTEOM]          = tape_std_mteom,
1242         [MTERASE]        = tape_std_mterase,
1243         [MTRAS1]         = NULL,
1244         [MTRAS2]         = NULL,
1245         [MTRAS3]         = NULL,
1246         [MTSETBLK]       = tape_std_mtsetblk,
1247         [MTSETDENSITY]   = NULL,
1248         [MTSEEK]         = tape_34xx_mtseek,
1249         [MTTELL]         = tape_34xx_mttell,
1250         [MTSETDRVBUFFER] = NULL,
1251         [MTFSS]          = NULL,
1252         [MTBSS]          = NULL,
1253         [MTWSM]          = NULL,
1254         [MTLOCK]         = NULL,
1255         [MTUNLOCK]       = NULL,
1256         [MTLOAD]         = tape_std_mtload,
1257         [MTUNLOAD]       = tape_std_mtunload,
1258         [MTCOMPRESSION]  = tape_std_mtcompression,
1259         [MTSETPART]      = NULL,
1260         [MTMKPART]       = NULL
1261 };
1262
1263 /*
1264  * Tape discipline structure for 3480 and 3490.
1265  */
1266 static struct tape_discipline tape_discipline_34xx = {
1267         .owner = THIS_MODULE,
1268         .setup_device = tape_34xx_setup_device,
1269         .cleanup_device = tape_34xx_cleanup_device,
1270         .process_eov = tape_std_process_eov,
1271         .irq = tape_34xx_irq,
1272         .read_block = tape_std_read_block,
1273         .write_block = tape_std_write_block,
1274 #ifdef CONFIG_S390_TAPE_BLOCK
1275         .bread = tape_34xx_bread,
1276         .free_bread = tape_34xx_free_bread,
1277         .check_locate = tape_34xx_check_locate,
1278 #endif
1279         .ioctl_fn = tape_34xx_ioctl,
1280         .mtop_array = tape_34xx_mtop
1281 };
1282
1283 static struct ccw_device_id tape_34xx_ids[] = {
1284         { CCW_DEVICE_DEVTYPE(0x3480, 0, 0x3480, 0), .driver_info = tape_3480},
1285         { CCW_DEVICE_DEVTYPE(0x3490, 0, 0x3490, 0), .driver_info = tape_3490},
1286         { /* end of list */ },
1287 };
1288
1289 static int
1290 tape_34xx_online(struct ccw_device *cdev)
1291 {
1292         return tape_generic_online(
1293                 dev_get_drvdata(&cdev->dev),
1294                 &tape_discipline_34xx
1295         );
1296 }
1297
1298 static struct ccw_driver tape_34xx_driver = {
1299         .name = "tape_34xx",
1300         .owner = THIS_MODULE,
1301         .ids = tape_34xx_ids,
1302         .probe = tape_generic_probe,
1303         .remove = tape_generic_remove,
1304         .set_online = tape_34xx_online,
1305         .set_offline = tape_generic_offline,
1306         .freeze = tape_generic_pm_suspend,
1307 };
1308
1309 static int
1310 tape_34xx_init (void)
1311 {
1312         int rc;
1313
1314         TAPE_DBF_AREA = debug_register ( "tape_34xx", 2, 2, 4*sizeof(long));
1315         debug_register_view(TAPE_DBF_AREA, &debug_sprintf_view);
1316 #ifdef DBF_LIKE_HELL
1317         debug_set_level(TAPE_DBF_AREA, 6);
1318 #endif
1319
1320         DBF_EVENT(3, "34xx init\n");
1321         /* Register driver for 3480/3490 tapes. */
1322         rc = ccw_driver_register(&tape_34xx_driver);
1323         if (rc)
1324                 DBF_EVENT(3, "34xx init failed\n");
1325         else
1326                 DBF_EVENT(3, "34xx registered\n");
1327         return rc;
1328 }
1329
1330 static void
1331 tape_34xx_exit(void)
1332 {
1333         ccw_driver_unregister(&tape_34xx_driver);
1334
1335         debug_unregister(TAPE_DBF_AREA);
1336 }
1337
1338 MODULE_DEVICE_TABLE(ccw, tape_34xx_ids);
1339 MODULE_AUTHOR("(C) 2001-2002 IBM Deutschland Entwicklung GmbH");
1340 MODULE_DESCRIPTION("Linux on zSeries channel attached 3480 tape device driver");
1341 MODULE_LICENSE("GPL");
1342
1343 module_init(tape_34xx_init);
1344 module_exit(tape_34xx_exit);