OSCL-LXR linux-6.0.1/​drivers/​s390/​char/​tape_34xx.c	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 // SPDX-License-Identifier: GPL-2.0
 /*
  *    tape device discipline for 3480/3490 tapes.
  *
  *    Copyright IBM Corp. 2001, 2009
  *    Author(s): Carsten Otte <cotte@de.ibm.com>
  *       Tuan Ngo-Anh <ngoanh@de.ibm.com>
  *       Martin Schwidefsky <schwidefsky@de.ibm.com>
  */
 
 #define KMSG_COMPONENT "tape_34xx"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/bio.h>
 #include <linux/workqueue.h>
 #include <linux/slab.h>
 
 #define TAPE_DBF_AREA   tape_34xx_dbf
 
 #include "tape.h"
 #include "tape_std.h"
 
 /*
  * Pointer to debug area.
  */
 debug_info_t *TAPE_DBF_AREA = NULL;
 EXPORT_SYMBOL(TAPE_DBF_AREA);
 
 #define TAPE34XX_FMT_3480   0
 #define TAPE34XX_FMT_3480_2_XF  1
 #define TAPE34XX_FMT_3480_XF    2
 
 struct tape_34xx_block_id {
     unsigned int    wrap        : 1;
     unsigned int    segment     : 7;
     unsigned int    format      : 2;
     unsigned int    block       : 22;
 };
 
 /*
  * A list of block ID's is used to faster seek blocks.
  */
 struct tape_34xx_sbid {
     struct list_head        list;
     struct tape_34xx_block_id   bid;
 };
 
 static void tape_34xx_delete_sbid_from(struct tape_device *, int);
 
 /*
  * Medium sense for 34xx tapes. There is no 'real' medium sense call.
  * So we just do a normal sense.
  */
 static void __tape_34xx_medium_sense(struct tape_request *request)
 {
     struct tape_device *device = request->device;
     unsigned char *sense;
 
     if (request->rc == 0) {
         sense = request->cpdata;
 
         /*
          * This isn't quite correct. But since INTERVENTION_REQUIRED
          * means that the drive is 'neither ready nor on-line' it is
          * only slightly inaccurate to say there is no tape loaded if
          * the drive isn't online...
          */
         if (sense[0] & SENSE_INTERVENTION_REQUIRED)
             tape_med_state_set(device, MS_UNLOADED);
         else
             tape_med_state_set(device, MS_LOADED);
 
         if (sense[1] & SENSE_WRITE_PROTECT)
             device->tape_generic_status |= GMT_WR_PROT(~0);
         else
             device->tape_generic_status &= ~GMT_WR_PROT(~0);
     } else
         DBF_EVENT(4, "tape_34xx: medium sense failed with rc=%d\n",
             request->rc);
     tape_free_request(request);
 }
 
 static int tape_34xx_medium_sense(struct tape_device *device)
 {
     struct tape_request *request;
     int rc;
 
     request = tape_alloc_request(1, 32);
     if (IS_ERR(request)) {
         DBF_EXCEPTION(6, "MSEN fail\n");
         return PTR_ERR(request);
     }
 
     request->op = TO_MSEN;
     tape_ccw_end(request->cpaddr, SENSE, 32, request->cpdata);
     rc = tape_do_io_interruptible(device, request);
     __tape_34xx_medium_sense(request);
     return rc;
 }
 
 static void tape_34xx_medium_sense_async(struct tape_device *device)
 {
     struct tape_request *request;
 
     request = tape_alloc_request(1, 32);
     if (IS_ERR(request)) {
         DBF_EXCEPTION(6, "MSEN fail\n");
         return;
     }
 
     request->op = TO_MSEN;
     tape_ccw_end(request->cpaddr, SENSE, 32, request->cpdata);
     request->callback = (void *) __tape_34xx_medium_sense;
     request->callback_data = NULL;
     tape_do_io_async(device, request);
 }
 
 struct tape_34xx_work {
     struct tape_device  *device;
     enum tape_op         op;
     struct work_struct   work;
 };
 
 /*
  * These functions are currently used only to schedule a medium_sense for
  * later execution. This is because we get an interrupt whenever a medium
  * is inserted but cannot call tape_do_io* from an interrupt context.
  * Maybe that's useful for other actions we want to start from the
  * interrupt handler.
  * Note: the work handler is called by the system work queue. The tape
  * commands started by the handler need to be asynchrounous, otherwise
  * a deadlock can occur e.g. in case of a deferred cc=1 (see __tape_do_irq).
  */
 static void
 tape_34xx_work_handler(struct work_struct *work)
 {
     struct tape_34xx_work *p =
         container_of(work, struct tape_34xx_work, work);
     struct tape_device *device = p->device;
 
     switch(p->op) {
         case TO_MSEN:
             tape_34xx_medium_sense_async(device);
             break;
         default:
             DBF_EVENT(3, "T34XX: internal error: unknown work\n");
     }
     tape_put_device(device);
     kfree(p);
 }
 
 static int
 tape_34xx_schedule_work(struct tape_device *device, enum tape_op op)
 {
     struct tape_34xx_work *p;
 
     if ((p = kzalloc(sizeof(*p), GFP_ATOMIC)) == NULL)
         return -ENOMEM;
 
     INIT_WORK(&p->work, tape_34xx_work_handler);
 
     p->device = tape_get_device(device);
     p->op     = op;
 
     schedule_work(&p->work);
     return 0;
 }
 
 /*
  * Done Handler is called when dev stat = DEVICE-END (successful operation)
  */
 static inline int
 tape_34xx_done(struct tape_request *request)
 {
     DBF_EVENT(6, "%s done\n", tape_op_verbose[request->op]);
 
     switch (request->op) {
         case TO_DSE:
         case TO_RUN:
         case TO_WRI:
         case TO_WTM:
         case TO_ASSIGN:
         case TO_UNASSIGN:
             tape_34xx_delete_sbid_from(request->device, 0);
             break;
         default:
             ;
     }
     return TAPE_IO_SUCCESS;
 }
 
 static inline int
 tape_34xx_erp_failed(struct tape_request *request, int rc)
 {
     DBF_EVENT(3, "Error recovery failed for %s (RC=%d)\n",
           tape_op_verbose[request->op], rc);
     return rc;
 }
 
 static inline int
 tape_34xx_erp_succeeded(struct tape_request *request)
 {
     DBF_EVENT(3, "Error Recovery successful for %s\n",
           tape_op_verbose[request->op]);
     return tape_34xx_done(request);
 }
 
 static inline int
 tape_34xx_erp_retry(struct tape_request *request)
 {
     DBF_EVENT(3, "xerp retr %s\n", tape_op_verbose[request->op]);
     return TAPE_IO_RETRY;
 }
 
 /*
  * This function is called, when no request is outstanding and we get an
  * interrupt
  */
 static int
 tape_34xx_unsolicited_irq(struct tape_device *device, struct irb *irb)
 {
     if (irb->scsw.cmd.dstat == 0x85) { /* READY */
         /* A medium was inserted in the drive. */
         DBF_EVENT(6, "xuud med\n");
         tape_34xx_delete_sbid_from(device, 0);
         tape_34xx_schedule_work(device, TO_MSEN);
     } else {
         DBF_EVENT(3, "unsol.irq! dev end: %08x\n", device->cdev_id);
         tape_dump_sense_dbf(device, NULL, irb);
     }
     return TAPE_IO_SUCCESS;
 }
 
 /*
  * Read Opposite Error Recovery Function:
  * Used, when Read Forward does not work
  */
 static int
 tape_34xx_erp_read_opposite(struct tape_device *device,
                 struct tape_request *request)
 {
     if (request->op == TO_RFO) {
         /*
          * We did read forward, but the data could not be read
          * *correctly*. We transform the request to a read backward
          * and try again.
          */
         tape_std_read_backward(device, request);
         return tape_34xx_erp_retry(request);
     }
 
     /*
      * We tried to read forward and backward, but hat no
      * success -> failed.
      */
     return tape_34xx_erp_failed(request, -EIO);
 }
 
 static int
 tape_34xx_erp_bug(struct tape_device *device, struct tape_request *request,
           struct irb *irb, int no)
 {
     if (request->op != TO_ASSIGN) {
         dev_err(&device->cdev->dev, "An unexpected condition %d "
             "occurred in tape error recovery\n", no);
         tape_dump_sense_dbf(device, request, irb);
     }
     return tape_34xx_erp_failed(request, -EIO);
 }
 
 /*
  * Handle data overrun between cu and drive. The channel speed might
  * be too slow.
  */
 static int
 tape_34xx_erp_overrun(struct tape_device *device, struct tape_request *request,
               struct irb *irb)
 {
     if (irb->ecw[3] == 0x40) {
         dev_warn (&device->cdev->dev, "A data overrun occurred between"
             " the control unit and tape unit\n");
         return tape_34xx_erp_failed(request, -EIO);
     }
     return tape_34xx_erp_bug(device, request, irb, -1);
 }
 
 /*
  * Handle record sequence error.
  */
 static int
 tape_34xx_erp_sequence(struct tape_device *device,
                struct tape_request *request, struct irb *irb)
 {
     if (irb->ecw[3] == 0x41) {
         /*
          * cu detected incorrect block-id sequence on tape.
          */
         dev_warn (&device->cdev->dev, "The block ID sequence on the "
             "tape is incorrect\n");
         return tape_34xx_erp_failed(request, -EIO);
     }
     /*
      * Record sequence error bit is set, but erpa does not
      * show record sequence error.
      */
     return tape_34xx_erp_bug(device, request, irb, -2);
 }
 
 /*
  * This function analyses the tape's sense-data in case of a unit-check.
  * If possible, it tries to recover from the error. Else the user is
  * informed about the problem.
  */
 static int
 tape_34xx_unit_check(struct tape_device *device, struct tape_request *request,
              struct irb *irb)
 {
     int inhibit_cu_recovery;
     __u8* sense;
 
     inhibit_cu_recovery = (*device->modeset_byte & 0x80) ? 1 : 0;
     sense = irb->ecw;
 
     if (
         sense[0] & SENSE_COMMAND_REJECT &&
         sense[1] & SENSE_WRITE_PROTECT
     ) {
         if (
             request->op == TO_DSE ||
             request->op == TO_WRI ||
             request->op == TO_WTM
         ) {
             /* medium is write protected */
             return tape_34xx_erp_failed(request, -EACCES);
         } else {
             return tape_34xx_erp_bug(device, request, irb, -3);
         }
     }
 
     /*
      * Special cases for various tape-states when reaching
      * end of recorded area
      *
      * FIXME: Maybe a special case of the special case:
      *        sense[0] == SENSE_EQUIPMENT_CHECK &&
      *        sense[1] == SENSE_DRIVE_ONLINE    &&
      *        sense[3] == 0x47 (Volume Fenced)
      *
      *        This was caused by continued FSF or FSR after an
      *        'End Of Data'.
      */
     if ((
         sense[0] == SENSE_DATA_CHECK      ||
         sense[0] == SENSE_EQUIPMENT_CHECK ||
         sense[0] == (SENSE_EQUIPMENT_CHECK | SENSE_DEFERRED_UNIT_CHECK)
     ) && (
         sense[1] == SENSE_DRIVE_ONLINE ||
         sense[1] == (SENSE_BEGINNING_OF_TAPE | SENSE_WRITE_MODE)
     )) {
         switch (request->op) {
         /*
          * sense[0] == SENSE_DATA_CHECK   &&
          * sense[1] == SENSE_DRIVE_ONLINE
          * sense[3] == 0x36 (End Of Data)
          *
          * Further seeks might return a 'Volume Fenced'.
          */
         case TO_FSF:
         case TO_FSB:
             /* Trying to seek beyond end of recorded area */
             return tape_34xx_erp_failed(request, -ENOSPC);
         case TO_BSB:
             return tape_34xx_erp_retry(request);
 
         /*
          * sense[0] == SENSE_DATA_CHECK   &&
          * sense[1] == SENSE_DRIVE_ONLINE &&
          * sense[3] == 0x36 (End Of Data)
          */
         case TO_LBL:
             /* Block could not be located. */
             tape_34xx_delete_sbid_from(device, 0);
             return tape_34xx_erp_failed(request, -EIO);
 
         case TO_RFO:
             /* Read beyond end of recorded area -> 0 bytes read */
             return tape_34xx_erp_failed(request, 0);
 
         /*
          * sense[0] == SENSE_EQUIPMENT_CHECK &&
          * sense[1] == SENSE_DRIVE_ONLINE    &&
          * sense[3] == 0x38 (Physical End Of Volume)
          */
         case TO_WRI:
             /* Writing at physical end of volume */
             return tape_34xx_erp_failed(request, -ENOSPC);
         default:
             return tape_34xx_erp_failed(request, 0);
         }
     }
 
     /* Sensing special bits */
     if (sense[0] & SENSE_BUS_OUT_CHECK)
         return tape_34xx_erp_retry(request);
 
     if (sense[0] & SENSE_DATA_CHECK) {
         /*
          * hardware failure, damaged tape or improper
          * operating conditions
          */
         switch (sense[3]) {
         case 0x23:
             /* a read data check occurred */
             if ((sense[2] & SENSE_TAPE_SYNC_MODE) ||
                 inhibit_cu_recovery)
                 // data check is not permanent, may be
                 // recovered. We always use async-mode with
                 // cu-recovery, so this should *never* happen.
                 return tape_34xx_erp_bug(device, request,
                              irb, -4);
 
             /* data check is permanent, CU recovery has failed */
             dev_warn (&device->cdev->dev, "A read error occurred "
                 "that cannot be recovered\n");
             return tape_34xx_erp_failed(request, -EIO);
         case 0x25:
             // a write data check occurred
             if ((sense[2] & SENSE_TAPE_SYNC_MODE) ||
                 inhibit_cu_recovery)
                 // data check is not permanent, may be
                 // recovered. We always use async-mode with
                 // cu-recovery, so this should *never* happen.
                 return tape_34xx_erp_bug(device, request,
                              irb, -5);
 
             // data check is permanent, cu-recovery has failed
             dev_warn (&device->cdev->dev, "A write error on the "
                 "tape cannot be recovered\n");
             return tape_34xx_erp_failed(request, -EIO);
         case 0x26:
             /* Data Check (read opposite) occurred. */
             return tape_34xx_erp_read_opposite(device, request);
         case 0x28:
             /* ID-Mark at tape start couldn't be written */
             dev_warn (&device->cdev->dev, "Writing the ID-mark "
                 "failed\n");
             return tape_34xx_erp_failed(request, -EIO);
         case 0x31:
             /* Tape void. Tried to read beyond end of device. */
             dev_warn (&device->cdev->dev, "Reading the tape beyond"
                 " the end of the recorded area failed\n");
             return tape_34xx_erp_failed(request, -ENOSPC);
         case 0x41:
             /* Record sequence error. */
             dev_warn (&device->cdev->dev, "The tape contains an "
                 "incorrect block ID sequence\n");
             return tape_34xx_erp_failed(request, -EIO);
         default:
             /* all data checks for 3480 should result in one of
              * the above erpa-codes. For 3490, other data-check
              * conditions do exist. */
             if (device->cdev->id.driver_info == tape_3480)
                 return tape_34xx_erp_bug(device, request,
                              irb, -6);
         }
     }
 
     if (sense[0] & SENSE_OVERRUN)
         return tape_34xx_erp_overrun(device, request, irb);
 
     if (sense[1] & SENSE_RECORD_SEQUENCE_ERR)
         return tape_34xx_erp_sequence(device, request, irb);
 
     /* Sensing erpa codes */
     switch (sense[3]) {
     case 0x00:
         /* Unit check with erpa code 0. Report and ignore. */
         return TAPE_IO_SUCCESS;
     case 0x21:
         /*
          * Data streaming not operational. CU will switch to
          * interlock mode. Reissue the command.
          */
         return tape_34xx_erp_retry(request);
     case 0x22:
         /*
          * Path equipment check. Might be drive adapter error, buffer
          * error on the lower interface, internal path not usable,
          * or error during cartridge load.
          */
         dev_warn (&device->cdev->dev, "A path equipment check occurred"
             " for the tape device\n");
         return tape_34xx_erp_failed(request, -EIO);
     case 0x24:
         /*
          * Load display check. Load display was command was issued,
          * but the drive is displaying a drive check message. Can
          * be threated as "device end".
          */
         return tape_34xx_erp_succeeded(request);
     case 0x27:
         /*
          * Command reject. May indicate illegal channel program or
          * buffer over/underrun. Since all channel programs are
          * issued by this driver and ought be correct, we assume a
          * over/underrun situation and retry the channel program.
          */
         return tape_34xx_erp_retry(request);
     case 0x29:
         /*
          * Function incompatible. Either the tape is idrc compressed
          * but the hardware isn't capable to do idrc, or a perform
          * subsystem func is issued and the CU is not on-line.
          */
         return tape_34xx_erp_failed(request, -EIO);
     case 0x2a:
         /*
          * Unsolicited environmental data. An internal counter
          * overflows, we can ignore this and reissue the cmd.
          */
         return tape_34xx_erp_retry(request);
     case 0x2b:
         /*
          * Environmental data present. Indicates either unload
          * completed ok or read buffered log command completed ok.
          */
         if (request->op == TO_RUN) {
             /* Rewind unload completed ok. */
             tape_med_state_set(device, MS_UNLOADED);
             return tape_34xx_erp_succeeded(request);
         }
         /* tape_34xx doesn't use read buffered log commands. */
         return tape_34xx_erp_bug(device, request, irb, sense[3]);
     case 0x2c:
         /*
          * Permanent equipment check. CU has tried recovery, but
          * did not succeed.
          */
         return tape_34xx_erp_failed(request, -EIO);
     case 0x2d:
         /* Data security erase failure. */
         if (request->op == TO_DSE)
             return tape_34xx_erp_failed(request, -EIO);
         /* Data security erase failure, but no such command issued. */
         return tape_34xx_erp_bug(device, request, irb, sense[3]);
     case 0x2e:
         /*
          * Not capable. This indicates either that the drive fails
          * reading the format id mark or that format specified
          * is not supported by the drive.
          */
         dev_warn (&device->cdev->dev, "The tape unit cannot process "
             "the tape format\n");
         return tape_34xx_erp_failed(request, -EMEDIUMTYPE);
     case 0x30:
         /* The medium is write protected. */
         dev_warn (&device->cdev->dev, "The tape medium is write-"
             "protected\n");
         return tape_34xx_erp_failed(request, -EACCES);
     case 0x32:
         // Tension loss. We cannot recover this, it's an I/O error.
         dev_warn (&device->cdev->dev, "The tape does not have the "
             "required tape tension\n");
         return tape_34xx_erp_failed(request, -EIO);
     case 0x33:
         /*
          * Load Failure. The cartridge was not inserted correctly or
          * the tape is not threaded correctly.
          */
         dev_warn (&device->cdev->dev, "The tape unit failed to load"
             " the cartridge\n");
         tape_34xx_delete_sbid_from(device, 0);
         return tape_34xx_erp_failed(request, -EIO);
     case 0x34:
         /*
          * Unload failure. The drive cannot maintain tape tension
          * and control tape movement during an unload operation.
          */
         dev_warn (&device->cdev->dev, "Automatic unloading of the tape"
             " cartridge failed\n");
         if (request->op == TO_RUN)
             return tape_34xx_erp_failed(request, -EIO);
         return tape_34xx_erp_bug(device, request, irb, sense[3]);
     case 0x35:
         /*
          * Drive equipment check. One of the following:
          * - cu cannot recover from a drive detected error
          * - a check code message is shown on drive display
          * - the cartridge loader does not respond correctly
          * - a failure occurs during an index, load, or unload cycle
          */
         dev_warn (&device->cdev->dev, "An equipment check has occurred"
             " on the tape unit\n");
         return tape_34xx_erp_failed(request, -EIO);
     case 0x36:
         if (device->cdev->id.driver_info == tape_3490)
             /* End of data. */
             return tape_34xx_erp_failed(request, -EIO);
         /* This erpa is reserved for 3480 */
         return tape_34xx_erp_bug(device, request, irb, sense[3]);
     case 0x37:
         /*
          * Tape length error. The tape is shorter than reported in
          * the beginning-of-tape data.
          */
         dev_warn (&device->cdev->dev, "The tape information states an"
             " incorrect length\n");
         return tape_34xx_erp_failed(request, -EIO);
     case 0x38:
         /*
          * Physical end of tape. A read/write operation reached
          * the physical end of tape.
          */
         if (request->op==TO_WRI ||
             request->op==TO_DSE ||
             request->op==TO_WTM)
             return tape_34xx_erp_failed(request, -ENOSPC);
         return tape_34xx_erp_failed(request, -EIO);
     case 0x39:
         /* Backward at Beginning of tape. */
         return tape_34xx_erp_failed(request, -EIO);
     case 0x3a:
         /* Drive switched to not ready. */
         dev_warn (&device->cdev->dev, "The tape unit is not ready\n");
         return tape_34xx_erp_failed(request, -EIO);
     case 0x3b:
         /* Manual rewind or unload. This causes an I/O error. */
         dev_warn (&device->cdev->dev, "The tape medium has been "
             "rewound or unloaded manually\n");
         tape_34xx_delete_sbid_from(device, 0);
         return tape_34xx_erp_failed(request, -EIO);
     case 0x42:
         /*
          * Degraded mode. A condition that can cause degraded
          * performance is detected.
          */
         dev_warn (&device->cdev->dev, "The tape subsystem is running "
             "in degraded mode\n");
         return tape_34xx_erp_retry(request);
     case 0x43:
         /* Drive not ready. */
         tape_34xx_delete_sbid_from(device, 0);
         tape_med_state_set(device, MS_UNLOADED);
         /* Some commands commands are successful even in this case */
         if (sense[1] & SENSE_DRIVE_ONLINE) {
             switch(request->op) {
                 case TO_ASSIGN:
                 case TO_UNASSIGN:
                 case TO_DIS:
                 case TO_NOP:
                     return tape_34xx_done(request);
                     break;
                 default:
                     break;
             }
         }
         return tape_34xx_erp_failed(request, -ENOMEDIUM);
     case 0x44:
         /* Locate Block unsuccessful. */
         if (request->op != TO_BLOCK && request->op != TO_LBL)
             /* No locate block was issued. */
             return tape_34xx_erp_bug(device, request,
                          irb, sense[3]);
         return tape_34xx_erp_failed(request, -EIO);
     case 0x45:
         /* The drive is assigned to a different channel path. */
         dev_warn (&device->cdev->dev, "The tape unit is already "
             "assigned\n");
         return tape_34xx_erp_failed(request, -EIO);
     case 0x46:
         /*
          * Drive not on-line. Drive may be switched offline,
          * the power supply may be switched off or
          * the drive address may not be set correctly.
          */
         dev_warn (&device->cdev->dev, "The tape unit is not online\n");
         return tape_34xx_erp_failed(request, -EIO);
     case 0x47:
         /* Volume fenced. CU reports volume integrity is lost. */
         dev_warn (&device->cdev->dev, "The control unit has fenced "
             "access to the tape volume\n");
         tape_34xx_delete_sbid_from(device, 0);
         return tape_34xx_erp_failed(request, -EIO);
     case 0x48:
         /* Log sense data and retry request. */
         return tape_34xx_erp_retry(request);
     case 0x49:
         /* Bus out check. A parity check error on the bus was found. */
         dev_warn (&device->cdev->dev, "A parity error occurred on the "
             "tape bus\n");
         return tape_34xx_erp_failed(request, -EIO);
     case 0x4a:
         /* Control unit erp failed. */
         dev_warn (&device->cdev->dev, "I/O error recovery failed on "
             "the tape control unit\n");
         return tape_34xx_erp_failed(request, -EIO);
     case 0x4b:
         /*
          * CU and drive incompatible. The drive requests micro-program
          * patches, which are not available on the CU.
          */
         dev_warn (&device->cdev->dev, "The tape unit requires a "
             "firmware update\n");
         return tape_34xx_erp_failed(request, -EIO);
     case 0x4c:
         /*
          * Recovered Check-One failure. Cu develops a hardware error,
          * but is able to recover.
          */
         return tape_34xx_erp_retry(request);
     case 0x4d:
         if (device->cdev->id.driver_info == tape_3490)
             /*
              * Resetting event received. Since the driver does
              * not support resetting event recovery (which has to
              * be handled by the I/O Layer), retry our command.
              */
             return tape_34xx_erp_retry(request);
         /* This erpa is reserved for 3480. */
         return tape_34xx_erp_bug(device, request, irb, sense[3]);
     case 0x4e:
         if (device->cdev->id.driver_info == tape_3490) {
             /*
              * Maximum block size exceeded. This indicates, that
              * the block to be written is larger than allowed for
              * buffered mode.
              */
             dev_warn (&device->cdev->dev, "The maximum block size"
                 " for buffered mode is exceeded\n");
             return tape_34xx_erp_failed(request, -ENOBUFS);
         }
         /* This erpa is reserved for 3480. */
         return tape_34xx_erp_bug(device, request, irb, sense[3]);
     case 0x50:
         /*
          * Read buffered log (Overflow). CU is running in extended
          * buffered log mode, and a counter overflows. This should
          * never happen, since we're never running in extended
          * buffered log mode.
          */
         return tape_34xx_erp_retry(request);
     case 0x51:
         /*
          * Read buffered log (EOV). EOF processing occurs while the
          * CU is in extended buffered log mode. This should never
          * happen, since we're never running in extended buffered
          * log mode.
          */
         return tape_34xx_erp_retry(request);
     case 0x52:
         /* End of Volume complete. Rewind unload completed ok. */
         if (request->op == TO_RUN) {
             tape_med_state_set(device, MS_UNLOADED);
             tape_34xx_delete_sbid_from(device, 0);
             return tape_34xx_erp_succeeded(request);
         }
         return tape_34xx_erp_bug(device, request, irb, sense[3]);
     case 0x53:
         /* Global command intercept. */
         return tape_34xx_erp_retry(request);
     case 0x54:
         /* Channel interface recovery (temporary). */
         return tape_34xx_erp_retry(request);
     case 0x55:
         /* Channel interface recovery (permanent). */
         dev_warn (&device->cdev->dev, "A channel interface error cannot be"
             " recovered\n");
         return tape_34xx_erp_failed(request, -EIO);
     case 0x56:
         /* Channel protocol error. */
         dev_warn (&device->cdev->dev, "A channel protocol error "
             "occurred\n");
         return tape_34xx_erp_failed(request, -EIO);
     case 0x57:
         /*
          * 3480: Attention intercept.
          * 3490: Global status intercept.
          */
         return tape_34xx_erp_retry(request);
     case 0x5a:
         /*
          * Tape length incompatible. The tape inserted is too long,
          * which could cause damage to the tape or the drive.
          */
         dev_warn (&device->cdev->dev, "The tape unit does not support "
             "the tape length\n");
         return tape_34xx_erp_failed(request, -EIO);
     case 0x5b:
         /* Format 3480 XF incompatible */
         if (sense[1] & SENSE_BEGINNING_OF_TAPE)
             /* The tape will get overwritten. */
             return tape_34xx_erp_retry(request);
         dev_warn (&device->cdev->dev, "The tape unit does not support"
             " format 3480 XF\n");
         return tape_34xx_erp_failed(request, -EIO);
     case 0x5c:
         /* Format 3480-2 XF incompatible */
         dev_warn (&device->cdev->dev, "The tape unit does not support tape "
             "format 3480-2 XF\n");
         return tape_34xx_erp_failed(request, -EIO);
     case 0x5d:
         /* Tape length violation. */
         dev_warn (&device->cdev->dev, "The tape unit does not support"
             " the current tape length\n");
         return tape_34xx_erp_failed(request, -EMEDIUMTYPE);
     case 0x5e:
         /* Compaction algorithm incompatible. */
         dev_warn (&device->cdev->dev, "The tape unit does not support"
             " the compaction algorithm\n");
         return tape_34xx_erp_failed(request, -EMEDIUMTYPE);
 
         /* The following erpas should have been covered earlier. */
     case 0x23: /* Read data check. */
     case 0x25: /* Write data check. */
     case 0x26: /* Data check (read opposite). */
     case 0x28: /* Write id mark check. */
     case 0x31: /* Tape void. */
     case 0x40: /* Overrun error. */
     case 0x41: /* Record sequence error. */
         /* All other erpas are reserved for future use. */
     default:
         return tape_34xx_erp_bug(device, request, irb, sense[3]);
     }
 }
 
 /*
  * 3480/3490 interrupt handler
  */
 static int
 tape_34xx_irq(struct tape_device *device, struct tape_request *request,
           struct irb *irb)
 {
     if (request == NULL)
         return tape_34xx_unsolicited_irq(device, irb);
 
     if ((irb->scsw.cmd.dstat & DEV_STAT_UNIT_EXCEP) &&
         (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) &&
         (request->op == TO_WRI)) {
         /* Write at end of volume */
         return tape_34xx_erp_failed(request, -ENOSPC);
     }
 
     if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK)
         return tape_34xx_unit_check(device, request, irb);
 
     if (irb->scsw.cmd.dstat & DEV_STAT_DEV_END) {
         /*
          * A unit exception occurs on skipping over a tapemark block.
          */
         if (irb->scsw.cmd.dstat & DEV_STAT_UNIT_EXCEP) {
             if (request->op == TO_BSB || request->op == TO_FSB)
                 request->rescnt++;
             else
                 DBF_EVENT(5, "Unit Exception!\n");
         }
         return tape_34xx_done(request);
     }
 
     DBF_EVENT(6, "xunknownirq\n");
     tape_dump_sense_dbf(device, request, irb);
     return TAPE_IO_STOP;
 }
 
 /*
  * ioctl_overload
  */
 static int
 tape_34xx_ioctl(struct tape_device *device, unsigned int cmd, unsigned long arg)
 {
     if (cmd == TAPE390_DISPLAY) {
         struct display_struct disp;
 
         if (copy_from_user(&disp, (char __user *) arg, sizeof(disp)) != 0)
             return -EFAULT;
 
         return tape_std_display(device, &disp);
     } else
         return -EINVAL;
 }
 
 static inline void
 tape_34xx_append_new_sbid(struct tape_34xx_block_id bid, struct list_head *l)
 {
     struct tape_34xx_sbid * new_sbid;
 
     new_sbid = kmalloc(sizeof(*new_sbid), GFP_ATOMIC);
     if (!new_sbid)
         return;
 
     new_sbid->bid = bid;
     list_add(&new_sbid->list, l);
 }
 
 /*
  * Build up the search block ID list. The block ID consists of a logical
  * block number and a hardware specific part. The hardware specific part
  * helps the tape drive to speed up searching for a specific block.
  */
 static void
 tape_34xx_add_sbid(struct tape_device *device, struct tape_34xx_block_id bid)
 {
     struct list_head *  sbid_list;
     struct tape_34xx_sbid * sbid;
     struct list_head *  l;
 
     /*
      * immediately return if there is no list at all or the block to add
      * is located in segment 1 of wrap 0 because this position is used
      * if no hardware position data is supplied.
      */
     sbid_list = (struct list_head *) device->discdata;
     if (!sbid_list || (bid.segment < 2 && bid.wrap == 0))
         return;
 
     /*
      * Search the position where to insert the new entry. Hardware
      * acceleration uses only the segment and wrap number. So we
      * need only one entry for a specific wrap/segment combination.
      * If there is a block with a lower number but the same hard-
      * ware position data we just update the block number in the
      * existing entry.
      */
     list_for_each(l, sbid_list) {
         sbid = list_entry(l, struct tape_34xx_sbid, list);
 
         if (
             (sbid->bid.segment == bid.segment) &&
             (sbid->bid.wrap    == bid.wrap)
         ) {
             if (bid.block < sbid->bid.block)
                 sbid->bid = bid;
             else return;
             break;
         }
 
         /* Sort in according to logical block number. */
         if (bid.block < sbid->bid.block) {
             tape_34xx_append_new_sbid(bid, l->prev);
             break;
         }
     }
     /* List empty or new block bigger than last entry. */
     if (l == sbid_list)
         tape_34xx_append_new_sbid(bid, l->prev);
 
     DBF_LH(4, "Current list is:\n");
     list_for_each(l, sbid_list) {
         sbid = list_entry(l, struct tape_34xx_sbid, list);
         DBF_LH(4, "%d:%03d@%05d\n",
             sbid->bid.wrap,
             sbid->bid.segment,
             sbid->bid.block
         );
     }
 }
 
 /*
  * Delete all entries from the search block ID list that belong to tape blocks
  * equal or higher than the given number.
  */
 static void
 tape_34xx_delete_sbid_from(struct tape_device *device, int from)
 {
     struct list_head *  sbid_list;
     struct tape_34xx_sbid * sbid;
     struct list_head *  l;
     struct list_head *  n;
 
     sbid_list = (struct list_head *) device->discdata;
     if (!sbid_list)
         return;
 
     list_for_each_safe(l, n, sbid_list) {
         sbid = list_entry(l, struct tape_34xx_sbid, list);
         if (sbid->bid.block >= from) {
             DBF_LH(4, "Delete sbid %d:%03d@%05d\n",
                 sbid->bid.wrap,
                 sbid->bid.segment,
                 sbid->bid.block
             );
             list_del(l);
             kfree(sbid);
         }
     }
 }
 
 /*
  * Merge hardware position data into a block id.
  */
 static void
 tape_34xx_merge_sbid(
     struct tape_device *        device,
     struct tape_34xx_block_id * bid
 ) {
     struct tape_34xx_sbid * sbid;
     struct tape_34xx_sbid * sbid_to_use;
     struct list_head *  sbid_list;
     struct list_head *  l;
 
     sbid_list = (struct list_head *) device->discdata;
     bid->wrap    = 0;
     bid->segment = 1;
 
     if (!sbid_list || list_empty(sbid_list))
         return;
 
     sbid_to_use = NULL;
     list_for_each(l, sbid_list) {
         sbid = list_entry(l, struct tape_34xx_sbid, list);
 
         if (sbid->bid.block >= bid->block)
             break;
         sbid_to_use = sbid;
     }
     if (sbid_to_use) {
         bid->wrap    = sbid_to_use->bid.wrap;
         bid->segment = sbid_to_use->bid.segment;
         DBF_LH(4, "Use %d:%03d@%05d for %05d\n",
             sbid_to_use->bid.wrap,
             sbid_to_use->bid.segment,
             sbid_to_use->bid.block,
             bid->block
         );
     }
 }
 
 static int
 tape_34xx_setup_device(struct tape_device * device)
 {
     int         rc;
     struct list_head *  discdata;
 
     DBF_EVENT(6, "34xx device setup\n");
     if ((rc = tape_std_assign(device)) == 0) {
         if ((rc = tape_34xx_medium_sense(device)) != 0) {
             DBF_LH(3, "34xx medium sense returned %d\n", rc);
         }
     }
     discdata = kmalloc(sizeof(struct list_head), GFP_KERNEL);
     if (discdata) {
             INIT_LIST_HEAD(discdata);
             device->discdata = discdata;
     }
 
     return rc;
 }
 
 static void
 tape_34xx_cleanup_device(struct tape_device *device)
 {
     tape_std_unassign(device);
     
     if (device->discdata) {
         tape_34xx_delete_sbid_from(device, 0);
         kfree(device->discdata);
         device->discdata = NULL;
     }
 }
 
 
 /*
  * MTTELL: Tell block. Return the number of block relative to current file.
  */
 static int
 tape_34xx_mttell(struct tape_device *device, int mt_count)
 {
     struct {
         struct tape_34xx_block_id   cbid;
         struct tape_34xx_block_id   dbid;
     } __attribute__ ((packed)) block_id;
     int rc;
 
     rc = tape_std_read_block_id(device, (__u64 *) &block_id);
     if (rc)
         return rc;
 
     tape_34xx_add_sbid(device, block_id.cbid);
     return block_id.cbid.block;
 }
 
 /*
  * MTSEEK: seek to the specified block.
  */
 static int
 tape_34xx_mtseek(struct tape_device *device, int mt_count)
 {
     struct tape_request *request;
     struct tape_34xx_block_id * bid;
 
     if (mt_count > 0x3fffff) {
         DBF_EXCEPTION(6, "xsee parm\n");
         return -EINVAL;
     }
     request = tape_alloc_request(3, 4);
     if (IS_ERR(request))
         return PTR_ERR(request);
 
     /* setup ccws */
     request->op = TO_LBL;
     bid         = (struct tape_34xx_block_id *) request->cpdata;
     bid->format = (*device->modeset_byte & 0x08) ?
             TAPE34XX_FMT_3480_XF : TAPE34XX_FMT_3480;
     bid->block  = mt_count;
     tape_34xx_merge_sbid(device, bid);
 
     tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
     tape_ccw_cc(request->cpaddr + 1, LOCATE, 4, request->cpdata);
     tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
 
     /* execute it */
     return tape_do_io_free(device, request);
 }
 
 /*
  * List of 3480/3490 magnetic tape commands.
  */
 static tape_mtop_fn tape_34xx_mtop[TAPE_NR_MTOPS] = {
     [MTRESET]    = tape_std_mtreset,
     [MTFSF]      = tape_std_mtfsf,
     [MTBSF]      = tape_std_mtbsf,
     [MTFSR]      = tape_std_mtfsr,
     [MTBSR]      = tape_std_mtbsr,
     [MTWEOF]     = tape_std_mtweof,
     [MTREW]      = tape_std_mtrew,
     [MTOFFL]     = tape_std_mtoffl,
     [MTNOP]      = tape_std_mtnop,
     [MTRETEN]    = tape_std_mtreten,
     [MTBSFM]     = tape_std_mtbsfm,
     [MTFSFM]     = tape_std_mtfsfm,
     [MTEOM]      = tape_std_mteom,
     [MTERASE]    = tape_std_mterase,
     [MTRAS1]     = NULL,
     [MTRAS2]     = NULL,
     [MTRAS3]     = NULL,
     [MTSETBLK]   = tape_std_mtsetblk,
     [MTSETDENSITY]   = NULL,
     [MTSEEK]     = tape_34xx_mtseek,
     [MTTELL]     = tape_34xx_mttell,
     [MTSETDRVBUFFER] = NULL,
     [MTFSS]      = NULL,
     [MTBSS]      = NULL,
     [MTWSM]      = NULL,
     [MTLOCK]     = NULL,
     [MTUNLOCK]   = NULL,
     [MTLOAD]     = tape_std_mtload,
     [MTUNLOAD]   = tape_std_mtunload,
     [MTCOMPRESSION]  = tape_std_mtcompression,
     [MTSETPART]  = NULL,
     [MTMKPART]   = NULL
 };
 
 /*
  * Tape discipline structure for 3480 and 3490.
  */
 static struct tape_discipline tape_discipline_34xx = {
     .owner = THIS_MODULE,
     .setup_device = tape_34xx_setup_device,
     .cleanup_device = tape_34xx_cleanup_device,
     .process_eov = tape_std_process_eov,
     .irq = tape_34xx_irq,
     .read_block = tape_std_read_block,
     .write_block = tape_std_write_block,
     .ioctl_fn = tape_34xx_ioctl,
     .mtop_array = tape_34xx_mtop
 };
 
 static struct ccw_device_id tape_34xx_ids[] = {
     { CCW_DEVICE_DEVTYPE(0x3480, 0, 0x3480, 0), .driver_info = tape_3480},
     { CCW_DEVICE_DEVTYPE(0x3490, 0, 0x3490, 0), .driver_info = tape_3490},
     { /* end of list */ },
 };
 
 static int
 tape_34xx_online(struct ccw_device *cdev)
 {
     return tape_generic_online(
         dev_get_drvdata(&cdev->dev),
         &tape_discipline_34xx
     );
 }
 
 static struct ccw_driver tape_34xx_driver = {
     .driver = {
         .name = "tape_34xx",
         .owner = THIS_MODULE,
     },
     .ids = tape_34xx_ids,
     .probe = tape_generic_probe,
     .remove = tape_generic_remove,
     .set_online = tape_34xx_online,
     .set_offline = tape_generic_offline,
     .int_class = IRQIO_TAP,
 };
 
 static int
 tape_34xx_init (void)
 {
     int rc;
 
     TAPE_DBF_AREA = debug_register ( "tape_34xx", 2, 2, 4*sizeof(long));
     debug_register_view(TAPE_DBF_AREA, &debug_sprintf_view);
 #ifdef DBF_LIKE_HELL
     debug_set_level(TAPE_DBF_AREA, 6);
 #endif
 
     DBF_EVENT(3, "34xx init\n");
     /* Register driver for 3480/3490 tapes. */
     rc = ccw_driver_register(&tape_34xx_driver);
     if (rc)
         DBF_EVENT(3, "34xx init failed\n");
     else
         DBF_EVENT(3, "34xx registered\n");
     return rc;
 }
 
 static void
 tape_34xx_exit(void)
 {
     ccw_driver_unregister(&tape_34xx_driver);
 
     debug_unregister(TAPE_DBF_AREA);
 }
 
 MODULE_DEVICE_TABLE(ccw, tape_34xx_ids);
 MODULE_AUTHOR("(C) 2001-2002 IBM Deutschland Entwicklung GmbH");
 MODULE_DESCRIPTION("Linux on zSeries channel attached 3480 tape device driver");
 MODULE_LICENSE("GPL");
 
 module_init(tape_34xx_init);
 module_exit(tape_34xx_exit);

This page was automatically generated by the 2.1.0 LXR engine. The LXR team