[SCSI] st: convert test_ready to use st_scsi_kern_execute

[mv-sheeva.git] / drivers / scsi / st.c

diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index c959bdc55f4f765d7a02c096a6b1be64ca30c0c8..c200496e90fec8cd881fde263ba468437502bf29 100644 (file)
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -451,9 +451,23 @@ static void st_sleep_done(void *data, char *sense, int result, int resid)
                complete(SRpnt->waiting);
 }
 
-static struct st_request *st_allocate_request(void)
+static struct st_request *st_allocate_request(struct scsi_tape *stp)
 {
-       return kzalloc(sizeof(struct st_request), GFP_KERNEL);
+       struct st_request *streq;
+
+       streq = kzalloc(sizeof(*streq), GFP_KERNEL);
+       if (streq)
+               streq->stp = stp;
+       else {
+               DEBC(printk(KERN_ERR "%s: Can't get SCSI request.\n",
+                           tape_name(stp)););
+               if (signal_pending(current))
+                       stp->buffer->syscall_result = -EINTR;
+               else
+                       stp->buffer->syscall_result = -EBUSY;
+       }
+
+       return streq;
 }
 
 static void st_release_request(struct st_request *streq)
@@ -481,18 +495,10 @@ st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd
                return NULL;
        }
 
-       if (SRpnt == NULL) {
-               SRpnt = st_allocate_request();
-               if (SRpnt == NULL) {
-                       DEBC( printk(KERN_ERR "%s: Can't get SCSI request.\n",
-                                    tape_name(STp)); );
-                       if (signal_pending(current))
-                               (STp->buffer)->syscall_result = (-EINTR);
-                       else
-                               (STp->buffer)->syscall_result = (-EBUSY);
+       if (!SRpnt) {
+               SRpnt = st_allocate_request(STp);
+               if (!SRpnt)
                        return NULL;
-               }
-               SRpnt->stp = STp;
        }
 
        /* If async IO, set last_SRpnt. This ptr tells write_behind_check
@@ -527,6 +533,28 @@ st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd
        return SRpnt;
 }
 
+static int st_scsi_kern_execute(struct st_request *streq,
+                               const unsigned char *cmd, int data_direction,
+                               void *buffer, unsigned bufflen, int timeout,
+                               int retries)
+{
+       struct scsi_tape *stp = streq->stp;
+       int ret, resid;
+
+       stp->buffer->cmdstat.have_sense = 0;
+       memcpy(streq->cmd, cmd, sizeof(streq->cmd));
+
+       ret = scsi_execute(stp->device, cmd, data_direction, buffer, bufflen,
+                          streq->sense, timeout, retries, 0, &resid);
+       if (driver_byte(ret) & DRIVER_ERROR)
+               return -EBUSY;
+
+       stp->buffer->cmdstat.midlevel_result = streq->result = ret;
+       stp->buffer->cmdstat.residual = resid;
+       stp->buffer->syscall_result = st_chk_result(stp, streq);
+
+       return 0;
+}
 
 /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
    write has been correct but EOM early warning reached, -EIO if write ended in
@@ -613,7 +641,8 @@ static int cross_eof(struct scsi_tape * STp, int forward)
                   tape_name(STp), forward ? "forward" : "backward"));
 
        SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
-                          STp->device->timeout, MAX_RETRIES, 1);
+                          STp->device->request_queue->rq_timeout,
+                          MAX_RETRIES, 1);
        if (!SRpnt)
                return (STp->buffer)->syscall_result;
 
@@ -657,7 +686,8 @@ static int st_flush_write_buffer(struct scsi_tape * STp)
                cmd[4] = blks;
 
                SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
-                                  STp->device->timeout, MAX_WRITE_RETRIES, 1);
+                                  STp->device->request_queue->rq_timeout,
+                                  MAX_WRITE_RETRIES, 1);
                if (!SRpnt)
                        return (STp->buffer)->syscall_result;
 
@@ -844,21 +874,24 @@ static int test_ready(struct scsi_tape *STp, int do_wait)
        int attentions, waits, max_wait, scode;
        int retval = CHKRES_READY, new_session = 0;
        unsigned char cmd[MAX_COMMAND_SIZE];
-       struct st_request *SRpnt = NULL;
+       struct st_request *SRpnt;
        struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
 
+       SRpnt = st_allocate_request(STp);
+       if (!SRpnt)
+               return STp->buffer->syscall_result;
+
        max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
 
        for (attentions=waits=0; ; ) {
                memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
                cmd[0] = TEST_UNIT_READY;
-               SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
-                                  STp->long_timeout, MAX_READY_RETRIES, 1);
 
-               if (!SRpnt) {
-                       retval = (STp->buffer)->syscall_result;
+               retval = st_scsi_kern_execute(SRpnt, cmd, DMA_NONE, NULL, 0,
+                                             STp->long_timeout,
+                                             MAX_READY_RETRIES);
+               if (retval)
                        break;
-               }
 
                if (cmdstatp->have_sense) {
 
@@ -902,8 +935,8 @@ static int test_ready(struct scsi_tape *STp, int do_wait)
                break;
        }
 
-       if (SRpnt != NULL)
-               st_release_request(SRpnt);
+       st_release_request(SRpnt);
+
        return retval;
 }
 
@@ -987,7 +1020,8 @@ static int check_tape(struct scsi_tape *STp, struct file *filp)
                cmd[0] = READ_BLOCK_LIMITS;
 
                SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
-                                  STp->device->timeout, MAX_READY_RETRIES, 1);
+                                  STp->device->request_queue->rq_timeout,
+                                  MAX_READY_RETRIES, 1);
                if (!SRpnt) {
                        retval = (STp->buffer)->syscall_result;
                        goto err_out;
@@ -1014,7 +1048,8 @@ static int check_tape(struct scsi_tape *STp, struct file *filp)
        cmd[4] = 12;
 
        SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
-                       STp->device->timeout, MAX_READY_RETRIES, 1);
+                          STp->device->request_queue->rq_timeout,
+                          MAX_READY_RETRIES, 1);
        if (!SRpnt) {
                retval = (STp->buffer)->syscall_result;
                goto err_out;
@@ -1247,7 +1282,8 @@ static int st_flush(struct file *filp, fl_owner_t id)
                cmd[4] = 1 + STp->two_fm;
 
                SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
-                                  STp->device->timeout, MAX_WRITE_RETRIES, 1);
+                                  STp->device->request_queue->rq_timeout,
+                                  MAX_WRITE_RETRIES, 1);
                if (!SRpnt) {
                        result = (STp->buffer)->syscall_result;
                        goto out;
@@ -1634,7 +1670,8 @@ st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
                cmd[4] = blks;
 
                SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
-                                  STp->device->timeout, MAX_WRITE_RETRIES, !async_write);
+                                  STp->device->request_queue->rq_timeout,
+                                  MAX_WRITE_RETRIES, !async_write);
                if (!SRpnt) {
                        retval = STbp->syscall_result;
                        goto out;
@@ -1804,7 +1841,8 @@ static long read_tape(struct scsi_tape *STp, long count,
 
        SRpnt = *aSRpnt;
        SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
-                          STp->device->timeout, MAX_RETRIES, 1);
+                          STp->device->request_queue->rq_timeout,
+                          MAX_RETRIES, 1);
        release_buffering(STp, 1);
        *aSRpnt = SRpnt;
        if (!SRpnt)
@@ -2213,7 +2251,8 @@ static int st_set_options(struct scsi_tape *STp, long options)
                        DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
                               (value & ~MT_ST_SET_LONG_TIMEOUT)));
                } else {
-                       STp->device->timeout = value * HZ;
+                       blk_queue_rq_timeout(STp->device->request_queue,
+                                            value * HZ);
                        DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
                                name, value) );
                }
@@ -2321,7 +2360,7 @@ static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
        cmd[4] = 255;
 
        SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE,
-                          STp->device->timeout, 0, 1);
+                          STp->device->request_queue->rq_timeout, 0, 1);
        if (SRpnt == NULL)
                return (STp->buffer)->syscall_result;
 
@@ -2352,7 +2391,7 @@ static int write_mode_page(struct scsi_tape *STp, int page, int slow)
        (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
 
        SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE,
-                          (slow ? STp->long_timeout : STp->device->timeout), 0, 1);
+                          (slow ? STp->long_timeout : STp->device->request_queue->rq_timeout), 0, 1);
        if (SRpnt == NULL)
                return (STp->buffer)->syscall_result;
 
@@ -2464,7 +2503,7 @@ static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_cod
        }
        if (STp->immediate) {
                cmd[1] = 1;     /* Don't wait for completion */
-               timeout = STp->device->timeout;
+               timeout = STp->device->request_queue->rq_timeout;
        }
        else
                timeout = STp->long_timeout;
@@ -2638,7 +2677,7 @@ static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned lon
                cmd[2] = (arg >> 16);
                cmd[3] = (arg >> 8);
                cmd[4] = arg;
-               timeout = STp->device->timeout;
+               timeout = STp->device->request_queue->rq_timeout;
                 DEBC(
                      if (cmd_in == MTWEOF)
                                printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
@@ -2656,7 +2695,7 @@ static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned lon
                cmd[0] = REZERO_UNIT;
                if (STp->immediate) {
                        cmd[1] = 1;     /* Don't wait for completion */
-                       timeout = STp->device->timeout;
+                       timeout = STp->device->request_queue->rq_timeout;
                }
                 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
                fileno = blkno = at_sm = 0;
@@ -2669,7 +2708,7 @@ static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned lon
                cmd[0] = START_STOP;
                if (STp->immediate) {
                        cmd[1] = 1;     /* Don't wait for completion */
-                       timeout = STp->device->timeout;
+                       timeout = STp->device->request_queue->rq_timeout;
                }
                cmd[4] = 3;
                 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
@@ -2702,7 +2741,7 @@ static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned lon
                cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
                if (STp->immediate) {
                        cmd[1] |= 2;    /* Don't wait for completion */
-                       timeout = STp->device->timeout;
+                       timeout = STp->device->request_queue->rq_timeout;
                }
                else
                        timeout = STp->long_timeout * 8;
@@ -2754,7 +2793,7 @@ static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned lon
                (STp->buffer)->b_data[9] = (ltmp >> 16);
                (STp->buffer)->b_data[10] = (ltmp >> 8);
                (STp->buffer)->b_data[11] = ltmp;
-               timeout = STp->device->timeout;
+               timeout = STp->device->request_queue->rq_timeout;
                 DEBC(
                        if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
                                printk(ST_DEB_MSG
@@ -2944,7 +2983,8 @@ static int get_location(struct scsi_tape *STp, unsigned int *block, int *partiti
                        scmd[1] = 1;
        }
        SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
-                       STp->device->timeout, MAX_READY_RETRIES, 1);
+                          STp->device->request_queue->rq_timeout,
+                          MAX_READY_RETRIES, 1);
        if (!SRpnt)
                return (STp->buffer)->syscall_result;
 
@@ -3045,7 +3085,7 @@ static int set_location(struct scsi_tape *STp, unsigned int block, int partition
        }
        if (STp->immediate) {
                scmd[1] |= 1;           /* Don't wait for completion */
-               timeout = STp->device->timeout;
+               timeout = STp->device->request_queue->rq_timeout;
        }
 
        SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
@@ -4029,7 +4069,7 @@ static int st_probe(struct device *dev)
        tpnt->partition = 0;
        tpnt->new_partition = 0;
        tpnt->nbr_partitions = 0;
-       tpnt->device->timeout = ST_TIMEOUT;
+       blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
        tpnt->long_timeout = ST_LONG_TIMEOUT;
        tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;