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