Subversion Repositories or1k

/*

  SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying

  file README.st for more information.

  History:

  OnStream SCSI Tape support (osst) cloned from st.c by

  Willem Riede (osst@riede.org) Feb 2000

  Fixes ... Kurt Garloff <garloff@suse.de> Mar 2000

  Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara.

  Contribution and ideas from several people including (in alphabetical

  order) Klaus Ehrenfried, Wolfgang Denk, Steve Hirsch, Andreas Koppenh"ofer,

  Michael Leodolter, Eyal Lebedinsky, J"org Weule, and Eric Youngdale.

  Copyright 1992 - 2000 Kai Makisara

                 email Kai.Makisara@metla.fi

  $Header: /home/marcus/revision_ctrl_test/oc_cvs/cvs/or1k/linux/linux-2.4/drivers/scsi/osst.c,v 1.1.1.1 2004-04-15 02:11:46 phoenix Exp $

  Microscopic alterations - Rik Ling, 2000/12/21

  Last modified: Wed Feb  2 22:04:05 2000 by makisara@kai.makisara.local

  Some small formal changes - aeb, 950809

*/

static const char * cvsid = "$Id: osst.c,v 1.1.1.1 2004-04-15 02:11:46 phoenix Exp $";

const char * osst_version = "0.9.14";

/* The "failure to reconnect" firmware bug */

#define OSST_FW_NEED_POLL_MIN 10601 /*(107A)*/

#define OSST_FW_NEED_POLL_MAX 10704 /*(108D)*/

#define OSST_FW_NEED_POLL(x,d) ((x) >= OSST_FW_NEED_POLL_MIN && (x) <= OSST_FW_NEED_POLL_MAX && d->host->this_id != 7)

#include <linux/module.h>

#include <linux/fs.h>

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/proc_fs.h>

#include <linux/mm.h>

#include <linux/init.h>

#include <linux/string.h>

#include <linux/errno.h>

#include <linux/mtio.h>

#include <linux/ioctl.h>

#include <linux/fcntl.h>

#include <linux/spinlock.h>

#include <linux/vmalloc.h>

#include <linux/version.h>

#include <asm/uaccess.h>

#include <asm/dma.h>

#include <asm/system.h>

/* The driver prints some debugging information on the console if DEBUG

   is defined and non-zero. */

#define DEBUG 0

/* The message level for the debug messages is currently set to KERN_NOTICE

   so that people can easily see the messages. Later when the debugging messages

   in the drivers are more widely classified, this may be changed to KERN_DEBUG. */

#define OSST_DEB_MSG  KERN_NOTICE

#define MAJOR_NR OSST_MAJOR

#include <linux/blk.h>

#include "scsi.h"

#include "hosts.h"

#include <scsi/scsi_ioctl.h>

#define ST_KILOBYTE 1024

#include "st.h"

#include "osst.h"

#include "osst_options.h"

#include "osst_detect.h"

#include "constants.h"

static int max_dev = 0;

static int write_threshold_kbs = 0;

static int max_sg_segs = 0;

#ifdef MODULE

MODULE_AUTHOR("Willem Riede");

MODULE_DESCRIPTION("OnStream SCSI Tape Driver");

MODULE_LICENSE("GPL");

MODULE_PARM(max_dev, "i");

MODULE_PARM(write_threshold_kbs, "i");

MODULE_PARM(max_sg_segs, "i");

#else

static struct osst_dev_parm {

       char   *name;

       int    *val;

} parms[] __initdata = {

       { "max_dev",             &max_dev             },

       { "write_threshold_kbs", &write_threshold_kbs },

       { "max_sg_segs",         &max_sg_segs         }

       };

#endif

/* Some default definitions have been moved to osst_options.h */

#define OSST_BUFFER_SIZE (OSST_BUFFER_BLOCKS * ST_KILOBYTE)

#define OSST_WRITE_THRESHOLD (OSST_WRITE_THRESHOLD_BLOCKS * ST_KILOBYTE)

/* The buffer size should fit into the 24 bits for length in the

   6-byte SCSI read and write commands. */

#if OSST_BUFFER_SIZE >= (2 << 24 - 1)

#error "Buffer size should not exceed (2 << 24 - 1) bytes!"

#endif

#if DEBUG

static int debugging = 1;

/* uncomment define below to test error recovery */

// #define OSST_INJECT_ERRORS 1 

#endif

#define MAX_RETRIES 2

#define MAX_READ_RETRIES 0

#define MAX_WRITE_RETRIES 0

#define MAX_READY_RETRIES 0

#define NO_TAPE  NOT_READY

#define OSST_WAIT_POSITION_COMPLETE   (HZ > 200 ? HZ / 200 : 1)

#define OSST_WAIT_WRITE_COMPLETE      (HZ / 12)

#define OSST_WAIT_LONG_WRITE_COMPLETE (HZ / 2)

#define OSST_TIMEOUT (200 * HZ)

#define OSST_LONG_TIMEOUT (1800 * HZ)

#define TAPE_NR(x) (MINOR(x) & ~(128 | ST_MODE_MASK))

#define TAPE_MODE(x) ((MINOR(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)

/* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower

   24 bits) */

#define SET_DENS_AND_BLK 0x10001

static int osst_nbr_buffers;

static int osst_buffer_size       = OSST_BUFFER_SIZE;

static int osst_write_threshold   = OSST_WRITE_THRESHOLD;

static int osst_max_buffers       = OSST_MAX_BUFFERS;

static int osst_max_sg_segs       = OSST_MAX_SG;

static int osst_max_dev           = OSST_MAX_TAPES;

static OS_Scsi_Tape **os_scsi_tapes = NULL;

static OSST_buffer  **osst_buffers  = NULL;

static int modes_defined = FALSE;

static OSST_buffer *new_tape_buffer(int, int);

static int enlarge_buffer(OSST_buffer *, int, int);

static void normalize_buffer(OSST_buffer *);

static int append_to_buffer(const char *, OSST_buffer *, int);

static int from_buffer(OSST_buffer *, char *, int);

static int osst_zero_buffer_tail(OSST_buffer *);

static int osst_copy_to_buffer(OSST_buffer *, unsigned char *);

static int osst_copy_from_buffer(OSST_buffer *, unsigned char *);

static int osst_init(void);

static int osst_attach(Scsi_Device *);

static int osst_detect(Scsi_Device *);

static void osst_detach(Scsi_Device *);

struct Scsi_Device_Template osst_template =

{

       name:            "OnStream tape",

       tag:             "osst",

       scsi_type:       TYPE_TAPE,

       major:           OSST_MAJOR,

       detect:          osst_detect,

       init:            osst_init,

       attach:          osst_attach,

       detach:          osst_detach

};

static int osst_int_ioctl(OS_Scsi_Tape *STp, Scsi_Request ** aSRpnt, unsigned int cmd_in,unsigned long arg);

static int osst_set_frame_position(OS_Scsi_Tape *STp, Scsi_Request ** aSRpnt, int frame, int skip);

static int osst_get_frame_position(OS_Scsi_Tape *STp, Scsi_Request ** aSRpnt);

static int osst_flush_write_buffer(OS_Scsi_Tape *STp, Scsi_Request ** aSRpnt);

static int osst_write_error_recovery(OS_Scsi_Tape * STp, Scsi_Request ** aSRpnt, int pending);

/* Routines that handle the interaction with mid-layer SCSI routines */

/* Convert the result to success code */

static int osst_chk_result(OS_Scsi_Tape * STp, Scsi_Request * SRpnt)

{

        int dev = TAPE_NR(STp->devt);

        int result = SRpnt->sr_result;

        unsigned char * sense = SRpnt->sr_sense_buffer, scode;

#if DEBUG

        const char *stp;

#endif

        if (!result) {

                sense[0] = 0;    /* We don't have sense data if this byte is zero */

                return 0;

        }

        if (driver_byte(result) & DRIVER_SENSE)

                scode = sense[2] & 0x0f;

        else {

                sense[0] = 0;    /* We don't have sense data if this byte is zero */

                scode = 0;

        }

#if DEBUG

        if (debugging) {

                printk(OSST_DEB_MSG "osst%d:D: Error: %x, cmd: %x %x %x %x %x %x Len: %d\n",

                   dev, result,

                   SRpnt->sr_cmnd[0], SRpnt->sr_cmnd[1], SRpnt->sr_cmnd[2],

                   SRpnt->sr_cmnd[3], SRpnt->sr_cmnd[4], SRpnt->sr_cmnd[5],

                   SRpnt->sr_bufflen);

                if (driver_byte(result) & DRIVER_SENSE)

                        print_req_sense("osst", SRpnt);

        }

        else

#endif

        if (!(driver_byte(result) & DRIVER_SENSE) ||

                ((sense[0] & 0x70) == 0x70 &&

                 scode != NO_SENSE &&

                 scode != RECOVERED_ERROR &&

/*               scode != UNIT_ATTENTION && */

                 scode != BLANK_CHECK &&

                 scode != VOLUME_OVERFLOW &&

                 SRpnt->sr_cmnd[0] != MODE_SENSE &&

                 SRpnt->sr_cmnd[0] != TEST_UNIT_READY)) { /* Abnormal conditions for tape */

                if (driver_byte(result) & DRIVER_SENSE) {

                        printk(KERN_WARNING "osst%d:W: Command with sense data: ", dev);

                        print_req_sense("osst:", SRpnt);

                }

                else {

                        static  int     notyetprinted = 1;

                        printk(KERN_WARNING

                             "osst%d:W: Warning %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n",

                             dev, result, suggestion(result), driver_byte(result) & DRIVER_MASK,

                             host_byte(result));

                        if (notyetprinted) {

                                notyetprinted = 0;

                                printk(KERN_INFO

                                        "osst%d:I: This warning may be caused by your scsi controller,\n", dev);

                                printk(KERN_INFO

                                        "osst%d:I: it has been reported with some Buslogic cards.\n", dev);

                        }

                }

        }

        if ((sense[0] & 0x70) == 0x70 &&

             scode == RECOVERED_ERROR) {

                STp->recover_count++;

                STp->recover_erreg++;

#if DEBUG

                if (debugging) {

                        if (SRpnt->sr_cmnd[0] == READ_6)

                                stp = "read";

                        else if (SRpnt->sr_cmnd[0] == WRITE_6)

                                stp = "write";

                        else

                                stp = "ioctl";

                        printk(OSST_DEB_MSG "osst%d:D: Recovered %s error (%d).\n", dev, stp,

                                             os_scsi_tapes[dev]->recover_count);

                }

#endif

                if ((sense[2] & 0xe0) == 0)

                        return 0;

        }

        return (-EIO);

}

/* Wakeup from interrupt */

static void osst_sleep_done (Scsi_Cmnd * SCpnt)

{

        unsigned int dev = TAPE_NR(SCpnt->request.rq_dev);

        OS_Scsi_Tape * STp;

        if (os_scsi_tapes && (STp = os_scsi_tapes[dev])) {

                if ((STp->buffer)->writing &&

                    (SCpnt->sense_buffer[0] & 0x70) == 0x70 &&

                    (SCpnt->sense_buffer[2] & 0x40)) {

                        /* EOM at write-behind, has all been written? */

                        if ((SCpnt->sense_buffer[2] & 0x0f) == VOLUME_OVERFLOW)

                                (STp->buffer)->midlevel_result = SCpnt->result; /* Error */

                        else

                                (STp->buffer)->midlevel_result = INT_MAX;       /* OK */

                }

                else

                        (STp->buffer)->midlevel_result = SCpnt->result;

                SCpnt->request.rq_status = RQ_SCSI_DONE;

                (STp->buffer)->last_SRpnt = SCpnt->sc_request;

#if DEBUG

                STp->write_pending = 0;

#endif

                complete(SCpnt->request.waiting);

        }

#if DEBUG

        else if (debugging)

                printk(OSST_DEB_MSG "osst?:D: Illegal interrupt device %x\n", dev);

#endif

}

/* Do the scsi command. Waits until command performed if do_wait is true.

   Otherwise osst_write_behind_check() is used to check that the command

   has finished. */

static  Scsi_Request * osst_do_scsi(Scsi_Request *SRpnt, OS_Scsi_Tape *STp,

        unsigned char *cmd, int bytes, int direction, int timeout, int retries, int do_wait)

{

        unsigned char *bp;

#ifdef OSST_INJECT_ERRORS

        static   int   inject = 0;

        static   int   repeat = 0;

#endif

        if (SRpnt == NULL) {

                if ((SRpnt = scsi_allocate_request(STp->device)) == NULL) {

                        printk(KERN_ERR "osst%d:E: Can't get SCSI request.\n", TAPE_NR(STp->devt));

                        if (signal_pending(current))

                                (STp->buffer)->syscall_result = (-EINTR);

                        else

                                (STp->buffer)->syscall_result = (-EBUSY);

                        return NULL;

                }

        }

        if (SRpnt->sr_device->scsi_level <= SCSI_2)

                cmd[1] |= (SRpnt->sr_device->lun << 5) & 0xe0;

        init_completion(&STp->wait);

        SRpnt->sr_use_sg = (bytes > (STp->buffer)->sg[0].length) ?

                                    (STp->buffer)->use_sg : 0;

        if (SRpnt->sr_use_sg) {

                bp = (char *)&(STp->buffer->sg[0]);

                if (STp->buffer->sg_segs < SRpnt->sr_use_sg)

                        SRpnt->sr_use_sg = STp->buffer->sg_segs;

        }

        else

                bp = (STp->buffer)->b_data;

        SRpnt->sr_data_direction = direction;

        SRpnt->sr_cmd_len = 0;

        SRpnt->sr_request.waiting = &(STp->wait);

        SRpnt->sr_request.rq_status = RQ_SCSI_BUSY;

        SRpnt->sr_request.rq_dev = STp->devt;

        scsi_do_req(SRpnt, (void *)cmd, bp, bytes, osst_sleep_done, timeout, retries);

        if (do_wait) {

                wait_for_completion(SRpnt->sr_request.waiting);

                SRpnt->sr_request.waiting = NULL;

                STp->buffer->syscall_result = osst_chk_result(STp, SRpnt);

#ifdef OSST_INJECT_ERRORS

                if (STp->buffer->syscall_result == 0 &&

                    cmd[0] == READ_6 &&

                    cmd[4] &&

                    ( (++ inject % 83) == 29  ||

                      (STp->first_frame_position == 240

                                 /* or STp->read_error_frame to fail again on the block calculated above */ &&

                                 ++repeat < 3))) {

                        printk(OSST_DEB_MSG "osst%d:D: Injecting read error\n", TAPE_NR(STp->devt));

                        STp->buffer->last_result_fatal = 1;

                }

#endif

        }

        return SRpnt;

}

/* Handle the write-behind checking (downs the semaphore) */

static void osst_write_behind_check(OS_Scsi_Tape *STp)

{

        OSST_buffer * STbuffer;

        STbuffer = STp->buffer;

#if DEBUG

        if (STp->write_pending)

                STp->nbr_waits++;

        else

                STp->nbr_finished++;

#endif

        wait_for_completion(&(STp->wait));

        (STp->buffer)->last_SRpnt->sr_request.waiting = NULL;

        STp->buffer->syscall_result = osst_chk_result(STp, STp->buffer->last_SRpnt);

        if ((STp->buffer)->syscall_result)

                (STp->buffer)->syscall_result =

                        osst_write_error_recovery(STp, &((STp->buffer)->last_SRpnt), 1);

        else

                STp->first_frame_position++;

        scsi_release_request((STp->buffer)->last_SRpnt);

        if (STbuffer->writing < STbuffer->buffer_bytes)

                printk(KERN_WARNING "osst:A: write_behind_check: something left in buffer!\n");

        STbuffer->buffer_bytes -= STbuffer->writing;

        STbuffer->writing = 0;

        return;

}

/* Onstream specific Routines */

/*

 * Initialize the OnStream AUX

 */

static void osst_init_aux(OS_Scsi_Tape * STp, int frame_type, int frame_seq_number,

                                         int logical_blk_num, int blk_sz, int blk_cnt)

{

        os_aux_t       *aux = STp->buffer->aux;

        os_partition_t *par = &aux->partition;

        os_dat_t       *dat = &aux->dat;

        if (STp->raw) return;

        memset(aux, 0, sizeof(*aux));

        aux->format_id = htonl(0);

        memcpy(aux->application_sig, "LIN4", 4);

        aux->hdwr = htonl(0);

        aux->frame_type = frame_type;

        switch (frame_type) {

          case  OS_FRAME_TYPE_HEADER:

                aux->update_frame_cntr    = htonl(STp->update_frame_cntr);

                par->partition_num        = OS_CONFIG_PARTITION;

                par->par_desc_ver         = OS_PARTITION_VERSION;

                par->wrt_pass_cntr        = htons(0xffff);

                /* 0-4 = reserved, 5-9 = header, 2990-2994 = header, 2995-2999 = reserved */

                par->first_frame_ppos     = htonl(0);

                par->last_frame_ppos      = htonl(0xbb7);

                aux->frame_seq_num        = htonl(0);

                aux->logical_blk_num_high = htonl(0);

                aux->logical_blk_num      = htonl(0);

                aux->next_mark_ppos       = htonl(STp->first_mark_ppos);

                break;

          case  OS_FRAME_TYPE_DATA:

          case  OS_FRAME_TYPE_MARKER:

                dat->dat_sz = 8;

                dat->reserved1 = 0;

                dat->entry_cnt = 1;

                dat->reserved3 = 0;

                dat->dat_list[0].blk_sz   = htonl(blk_sz);

                dat->dat_list[0].blk_cnt  = htons(blk_cnt);

                dat->dat_list[0].flags    = frame_type==OS_FRAME_TYPE_MARKER?

                                                        OS_DAT_FLAGS_MARK:OS_DAT_FLAGS_DATA;

                dat->dat_list[0].reserved = 0;

          case  OS_FRAME_TYPE_EOD:

                aux->update_frame_cntr    = htonl(0);

                par->partition_num        = OS_DATA_PARTITION;

                par->par_desc_ver         = OS_PARTITION_VERSION;

                par->wrt_pass_cntr        = htons(STp->wrt_pass_cntr);

                par->first_frame_ppos     = htonl(STp->first_data_ppos);

                par->last_frame_ppos      = htonl(STp->capacity);

                aux->frame_seq_num        = htonl(frame_seq_number);

                aux->logical_blk_num_high = htonl(0);

                aux->logical_blk_num      = htonl(logical_blk_num);

                break;

          default: ; /* probably FILL */

        }

        aux->filemark_cnt = ntohl(STp->filemark_cnt);

        aux->phys_fm = ntohl(0xffffffff);

        aux->last_mark_ppos = ntohl(STp->last_mark_ppos);

        aux->last_mark_lbn  = ntohl(STp->last_mark_lbn);

}

/*

 * Verify that we have the correct tape frame

 */

static int osst_verify_frame(OS_Scsi_Tape * STp, int frame_seq_number, int quiet)

{

        os_aux_t       * aux  = STp->buffer->aux;

        os_partition_t * par  = &(aux->partition);

        ST_partstat    * STps = &(STp->ps[STp->partition]);

        int              dev  = TAPE_NR(STp->devt);

        int              blk_cnt, blk_sz, i;

        if (STp->raw) {

                if (STp->buffer->syscall_result) {

                        for (i=0; i < STp->buffer->sg_segs; i++)

                                memset(STp->buffer->sg[i].address, 0, STp->buffer->sg[i].length);

                        strcpy(STp->buffer->b_data, "READ ERROR ON FRAME");

                } else

                        STp->buffer->buffer_bytes = OS_FRAME_SIZE;

                return 1;

        }

        if (STp->buffer->syscall_result) {

#if DEBUG

                printk(OSST_DEB_MSG "osst%d:D: Skipping frame, read error\n", dev);

#endif

                return 0;

        }

        if (ntohl(aux->format_id) != 0) {

#if DEBUG

                printk(OSST_DEB_MSG "osst%d:D: Skipping frame, format_id %u\n", dev, ntohl(aux->format_id));

#endif

                goto err_out;

        }

        if (memcmp(aux->application_sig, STp->application_sig, 4) != 0 &&

            (memcmp(aux->application_sig, "LIN3", 4) != 0 || STp->linux_media_version != 4)) {

#if DEBUG

                printk(OSST_DEB_MSG "osst%d:D: Skipping frame, incorrect application signature\n", dev);

#endif

                goto err_out;

        }

        if (par->partition_num != OS_DATA_PARTITION) {

                if (!STp->linux_media || STp->linux_media_version != 2) {

#if DEBUG

                        printk(OSST_DEB_MSG "osst%d:D: Skipping frame, partition num %d\n",

                                            dev, par->partition_num);

#endif

                        goto err_out;

                }

        }

        if (par->par_desc_ver != OS_PARTITION_VERSION) {

#if DEBUG

                printk(OSST_DEB_MSG "osst%d:D: Skipping frame, partition version %d\n", dev, par->par_desc_ver);

#endif

                goto err_out;

        }

        if (ntohs(par->wrt_pass_cntr) != STp->wrt_pass_cntr) {

#if DEBUG

                printk(OSST_DEB_MSG "osst%d:D: Skipping frame, wrt_pass_cntr %d (expected %d)\n",

                                    dev, ntohs(par->wrt_pass_cntr), STp->wrt_pass_cntr);

#endif

                goto err_out;

        }

        if (aux->frame_type != OS_FRAME_TYPE_DATA &&

            aux->frame_type != OS_FRAME_TYPE_EOD &&

            aux->frame_type != OS_FRAME_TYPE_MARKER) {

                if (!quiet)

#if DEBUG

                        printk(OSST_DEB_MSG "osst%d:D: Skipping frame, frame type %x\n", dev, aux->frame_type);

#endif

                goto err_out;

        }

        if (aux->frame_type == OS_FRAME_TYPE_EOD &&

            STp->first_frame_position < STp->eod_frame_ppos) {

                printk(KERN_INFO "osst%d:I: Skipping premature EOD frame %d\n", dev,

                                 STp->first_frame_position);

                goto err_out;

        }

        if (frame_seq_number != -1 && ntohl(aux->frame_seq_num) != frame_seq_number) {

                if (!quiet)

#if DEBUG

                        printk(OSST_DEB_MSG "osst%d:D: Skipping frame, sequence number %u (expected %d)\n",

                                            dev, ntohl(aux->frame_seq_num), frame_seq_number);

#endif

                goto err_out;

        }

        if (aux->frame_type == OS_FRAME_TYPE_MARKER) {

                STps->eof = ST_FM_HIT;

                i = ntohl(aux->filemark_cnt);

                if (STp->header_cache != NULL && i < OS_FM_TAB_MAX && (i > STp->filemark_cnt ||

                    STp->first_frame_position - 1 != ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[i]))) {

#if DEBUG

                        printk(OSST_DEB_MSG "osst%d:D: %s filemark %d at frame pos %d\n", dev,

                                  STp->header_cache->dat_fm_tab.fm_tab_ent[i] == 0?"Learned":"Corrected",

                                  i, STp->first_frame_position - 1);

#endif

                        STp->header_cache->dat_fm_tab.fm_tab_ent[i] = htonl(STp->first_frame_position - 1);

                        if (i >= STp->filemark_cnt)

                                 STp->filemark_cnt = i+1;

                }

        }

        if (aux->frame_type == OS_FRAME_TYPE_EOD) {

                STps->eof = ST_EOD_1;

                STp->frame_in_buffer = 1;

        }

        if (aux->frame_type == OS_FRAME_TYPE_DATA) {

                blk_cnt = ntohs(aux->dat.dat_list[0].blk_cnt);

                blk_sz  = ntohl(aux->dat.dat_list[0].blk_sz);

                STp->buffer->buffer_bytes = blk_cnt * blk_sz;

                STp->buffer->read_pointer = 0;

                STp->frame_in_buffer = 1;

                /* See what block size was used to write file */

                if (STp->block_size != blk_sz && blk_sz > 0) {

                        printk(KERN_INFO

                "osst%d:I: File was written with block size %d%c, currently %d%c, adjusted to match.\n",

                                dev, blk_sz<1024?blk_sz:blk_sz/1024,blk_sz<1024?'b':'k',

                                STp->block_size<1024?STp->block_size:STp->block_size/1024,

                                STp->block_size<1024?'b':'k');

                        STp->block_size            = blk_sz;

                        STp->buffer->buffer_blocks = OS_DATA_SIZE / blk_sz;

                }

                STps->eof = ST_NOEOF;

        }

        STp->frame_seq_number = ntohl(aux->frame_seq_num);

        STp->logical_blk_num  = ntohl(aux->logical_blk_num);

        return 1;

err_out:

        if (STp->read_error_frame == 0)

                STp->read_error_frame = STp->first_frame_position - 1;

        return 0;

}

/*

 * Wait for the unit to become Ready

 */

static int osst_wait_ready(OS_Scsi_Tape * STp, Scsi_Request ** aSRpnt, unsigned timeout, int initial_delay)

{

        unsigned char   cmd[MAX_COMMAND_SIZE];

        Scsi_Request  * SRpnt;

        long            startwait = jiffies;

#if DEBUG

        int             dbg = debugging;

        int             dev = TAPE_NR(STp->devt);

        printk(OSST_DEB_MSG "osst%d:D: Reached onstream wait ready\n", dev);

#endif

        if (initial_delay > 0) {

                set_current_state(TASK_INTERRUPTIBLE);

                schedule_timeout(initial_delay);

        }

        memset(cmd, 0, MAX_COMMAND_SIZE);

        cmd[0] = TEST_UNIT_READY;

        SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, SCSI_DATA_NONE, STp->timeout, MAX_READY_RETRIES, TRUE);

        *aSRpnt = SRpnt;

        if (!SRpnt) return (-EBUSY);

        while ( STp->buffer->syscall_result && time_before(jiffies, startwait + timeout*HZ) &&