projects / unix-history / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Increase the timeout from 2000 counts to 6000 counts, reported by someone
[unix-history] / sys / scsi / sg.c
/*
* Contributed by HD Associates (hd@world.std.com).
* Copyright (c) 1992, 1993 HD Associates
*
* Berkeley style copyright. I've just snarfed it out of stdio.h:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*/
#include <sys/types.h>
#include <sys/errno.h>
#include <sys/param.h>
#include <sys/malloc.h>
#include <sys/buf.h>
#include <sys/proc.h>
#include <scsi/scsi_all.h>
#include <scsi/scsiconf.h>
#include <scsi/scsi_generic.h>
#include "sg.h"
#include <sys/sgio.h>
#define SGOUTSTANDING 2
#define SG_RETRIES 2
#define SPLSG splbio
/* Use one of the implementation defined spare bits
* to indicate the escape op:
*/
#define DSRQ_ESCAPE DSRQ_CTRL1
struct sg
{
int flags;
struct scsi_switch *sc_sw;
int ctlr;
long int ad_info; /* info about the adapter */
int cmdscount; /* cmds allowed outstanding by the board */
struct scsi_xfer *free_xfer;
int free_xfer_wait;
};
/* This is used to associate a struct dsreq and a struct buf.
*/
typedef struct dsbuf
{
dsreq_t *dsreq;
struct buf buf;
/* I think this is a portable way to get back to the base of
* the enclosing structure:
*/
# define DSBUF_P(BP) ((dsbuf_t *)((caddr_t)(BP) - (caddr_t)&((dsbuf_t *)0)->buf))
int magic;
# define DSBUF_MAGIC 0xDBFACDBF
} dsbuf_t;
#if NSG > 4
/* The host adapter unit is encoded in the upper 2 bits of the minor number
* (the SGI flag bits).
*/
#error "NSG can't be > 4 unless the method of encoding the board unit changes"
#endif
struct sg *sgs[NSG];
#define SG(DEV) sgs[G_SCSI_UNIT(DEV)]
struct sg *sg_new(int lun)
{
struct sg *sg = (struct sg *)malloc(sizeof(*sg),M_TEMP, M_NOWAIT);
if (sg == 0)
return 0;
bzero(sg, sizeof(struct sg));
return sg;
}
int sg_attach(ctlr, scsi_addr, scsi_switch)
int ctlr,scsi_addr;
struct scsi_switch *scsi_switch;
{
struct sg *sg;
int i;
struct scsi_xfer *scsi_xfer;
static int next_sg_unit = 0;
int unit = next_sg_unit++;
if (unit >= NSG)
{
printf("Too many generic SCSIs (%d > %d); reconfigure the kernel.\n",
unit+1, NSG);
if (NSG == 4)
printf(
"You have hit the max of 4. You will have to change the driver.\n");
return 0;
}
if ((sg = sg_new(0)) == 0)
return 0;
sgs[unit] = sg;
sg->sc_sw = scsi_switch;
sg->ctlr = ctlr;
/* This is a bit confusing. It looks like Julian calls back into the
* adapter to find out how many outstanding transactions it can
* handle. How does he handle a tape/disk combo?
*/
if (sg->sc_sw->adapter_info)
{
sg->ad_info = ( (*(sg->sc_sw->adapter_info))(unit));
sg->cmdscount = sg->ad_info & AD_INF_MAX_CMDS;
if(sg->cmdscount > SGOUTSTANDING)
sg->cmdscount = SGOUTSTANDING;
}
else
{
sg->ad_info = 1;
sg->cmdscount = 1;
}
i = sg->cmdscount;
scsi_xfer = (struct scsi_xfer *)malloc(sizeof(struct scsi_xfer) *
i, M_TEMP, M_NOWAIT);
if (scsi_xfer == 0)
{
printf("scsi_generic: Can't malloc.\n");
return 0;
}
while (i--)
{
scsi_xfer->next = sg->free_xfer;
sg->free_xfer = scsi_xfer;
scsi_xfer++;
}
#ifndef EMBEDDED
if (unit == 0)
printf(" /dev/gs%d (instance 0) generic SCSI via controller %d\n",
scsi_addr, sg->ctlr);
else
printf(" /dev/gs%d-%d generic SCSI via controller %d\n",
unit, scsi_addr, sg->ctlr);
#endif
return 1;
}
/* It is trivial to add support for processor target devices
* here - enable target mode on open and disable on close
* if a flag bit is set in the minor number
*/
int sgopen(dev_t dev)
{
if (SG(dev) == 0)
return ENXIO;
return 0;
}
int sgclose(dev_t dev)
{
return 0;
}
/* Free a scsi_xfer, wake processes waiting for it
*/
void sg_free_xs(dev_t dev, struct scsi_xfer *xs, int flags)
{
int s;
struct sg *sg = SG(dev);
if(flags & SCSI_NOMASK)
{
if (sg->free_xfer_wait)
{
printf("sg_free_xs: doing a wakeup from NOMASK mode!\n");
wakeup((caddr_t)&sg->free_xfer);
}
xs->next = sg->free_xfer;
sg->free_xfer = xs;
}
else
{
s = SPLSG();
if (sg->free_xfer_wait)
wakeup((caddr_t)&sg->free_xfer);
xs->next = sg->free_xfer;
sg->free_xfer = xs;
splx(s);
}
}
/* Get ownership of a scsi_xfer
* If need be, sleep on it, until it comes free
*/
struct scsi_xfer *sg_get_xs(dev_t dev, int flags)
{
struct scsi_xfer *xs;
int s;
struct sg *sg = SG(dev);
if(flags & (SCSI_NOSLEEP | SCSI_NOMASK))
{
if (xs = sg->free_xfer)
{
sg->free_xfer = xs->next;
xs->flags = 0;
}
}
else
{
s = SPLSG();
while (!(xs = sg->free_xfer))
{
sg->free_xfer_wait++; /* someone waiting! */
sleep((caddr_t)&sg->free_xfer, PRIBIO+1);
sg->free_xfer_wait--;
}
sg->free_xfer = xs->next;
splx(s);
xs->flags = 0;
}
return xs;
}
/* We let the user interpret his own sense in the
* generic scsi world
*/
int sg_interpret_sense(dev_t dev, struct scsi_xfer *xs, int *flag_p)
{
return 0;
}
/* ITSDONE is really used for things that are marked one
* in the interrupt. I'll leave the logic in in case I want
* to move done processing (and therefore have a start queue)
* back into the interrupt.
* BUG: No start queue.
*/
int sg_done(dev_t dev,
struct scsi_xfer *xs)
{
xs->flags |= ITSDONE;
wakeup(xs);
return 0;
}
int sg_submit_cmd(dev_t dev, struct scsi_xfer *xs, dsreq_t *dsreq)
{
int retval;
struct sg *sg = SG(dev);
retry:
xs->error = XS_NOERROR;
xs->bp = 0; /* This bp doesn't seem to be used except to
* disable sleeping in the host adapter code.
* "st" does set it up, though.
*/
retval = (*(sg->sc_sw->scsi_cmd))(xs);
switch(retval)
{
case SUCCESSFULLY_QUEUED:
while(!(xs->flags & ITSDONE))
sleep(xs,PRIBIO+1);
/* Fall through... */
case HAD_ERROR:
if (dsreq)
dsreq->ds_status = xs->status;
switch(xs->error)
{
case XS_NOERROR:
if (dsreq)
dsreq->ds_datasent = dsreq->ds_datalen - xs->resid;
retval = 0;
break;
case XS_SENSE:
retval = (sg_interpret_sense(dev ,xs, (int *)0));
if (dsreq)
{
dsreq->ds_sensesent = sizeof(xs->sense);
dsreq->ds_ret = DSRT_SENSE;
}
retval = 0;
break;
case XS_DRIVER_STUFFUP:
if (dsreq)
dsreq->ds_ret = DSRT_HOST;
printf("sg%d: host adapter code inconsistency\n" ,G_SCSI_UNIT(dev));
retval = EIO;
break;
case XS_TIMEOUT:
if (dsreq)
dsreq->ds_ret = DSRT_TIMEOUT;
retval = ETIMEDOUT;
break;
case XS_BUSY:
if(xs->retries-- )
{
xs->flags &= ~ITSDONE;
goto retry;
}
retval = EBUSY;
break;
default:
printf("sg%d: unknown error category from host adapter code\n"
,G_SCSI_UNIT(dev));
retval = EIO;
break;
}
break;
case COMPLETE:
if (dsreq)
dsreq->ds_datasent = dsreq->ds_datalen - xs->resid;
retval = 0;
break;
case TRY_AGAIN_LATER:
if(xs->retries-- )
{
xs->flags &= ~ITSDONE;
goto retry;
}
retval = EBUSY;
break;
case ESCAPE_NOT_SUPPORTED:
retval = ENOSYS; /* "Function not implemented" */
break;
default:
printf("sg%d: illegal return from host adapter code\n",
G_SCSI_UNIT(dev));
retval = EIO;
break;
}
return retval;
}
/* sg_escape: Do a generic SCSI escape
*/
int sg_escape(dev_t dev, int op_code, u_char *b, int nb)
{
int retval;
struct scsi_generic scsi_generic;
int flags = SCSI_ESCAPE;
struct scsi_xfer *xs;
struct sg *sg = SG(dev);
xs = sg_get_xs(dev, flags);
if (xs == 0)
{
printf("sg_target%d: controller busy"
" (this should never happen)\n",G_SCSI_UNIT(dev));
return EBUSY;
}
scsi_generic.opcode = op_code;
bcopy(b, scsi_generic.bytes, nb);
/* Fill out the scsi_xfer structure
*/
xs->flags = (flags|INUSE);
xs->adapter = sg->ctlr;
xs->cmd = &scsi_generic;
xs->targ = G_SCSI_ID(dev);
xs->lu = G_SCSI_LUN(dev);
xs->retries = SG_RETRIES;
xs->timeout = 100;
xs->when_done = (flags & SCSI_NOMASK)
?(int (*)())0
:(int (*)())sg_done;
xs->done_arg = dev;
xs->done_arg2 = (int)xs;
xs->status = 0;
retval = sg_submit_cmd(dev, xs, 0);
bcopy(scsi_generic.bytes, b, nb);
sg_free_xs(dev,xs,flags);
return retval;
}
/* sg_target: Turn on / off target mode
*/
int sg_target(dev_t dev, int enable)
{
u_char b0 = enable;
return sg_escape(dev, SCSI_OP_TARGET, &b0, 1);
}
#ifdef EMBEDDED
/* This should REALLY be a select call!
* This is used in a stand alone system without an O/S. I didn't
* have the time to add select, which the system was missing,
* so I added this stuff to poll for the async arrival of
* connections for target mode.
*/
int sg_poll(dev_t dev, int *send, int *recv)
{
scsi_op_poll_t s;
int ret;
ret = sg_escape(dev, SCSI_OP_POLL, (u_char *)&s, sizeof(s));
if (ret == 0)
{
*send = s.send;
*recv = s.recv;
}
return ret;
}
#endif /* EMBEDDED */
int sg_scsi_cmd(dev_t dev,
dsreq_t *dsreq,
struct scsi_generic *scsi_cmd,
u_char *d_addr,
long d_count,
struct scsi_sense_data *scsi_sense)
{
int retval;
int flags = 0;
struct scsi_xfer *xs;
struct sg *sg = SG(dev);
if (sg->sc_sw == 0)
return ENODEV;
dsreq->ds_status = 0;
dsreq->ds_sensesent = 0;
if (dsreq->ds_flags & DSRQ_READ)
flags |= SCSI_DATA_IN;
if (dsreq->ds_flags & DSRQ_WRITE)
flags |= SCSI_DATA_OUT;
if (dsreq->ds_flags & DSRQ_TARGET)
flags |= SCSI_TARGET;
if (dsreq->ds_flags & DSRQ_ESCAPE)
flags |= SCSI_ESCAPE;
#ifdef SCSI_PHYSADDR
if (dsreq->ds_flags & DSRQ_PHYSADDR)
flags |= SCSI_PHYSADDR;
#endif
xs = sg_get_xs(dev, flags);
if (xs == 0)
{
printf("sg_scsi_cmd%d: controller busy"
" (this should never happen)\n",G_SCSI_UNIT(dev));
return EBUSY;
}
/* Fill out the scsi_xfer structure
*/
xs->flags |= (flags|INUSE);
xs->adapter = sg->ctlr;
xs->targ = G_SCSI_ID(dev);
xs->lu = G_SCSI_LUN(dev);
xs->retries = SG_RETRIES;
xs->timeout = dsreq->ds_time;
xs->cmd = scsi_cmd;
xs->cmdlen = dsreq->ds_cmdlen;
xs->data = d_addr;
xs->datalen = d_count;
xs->resid = d_count;
xs->when_done = (flags & SCSI_NOMASK)
?(int (*)())0
:(int (*)())sg_done;
xs->done_arg = dev;
xs->done_arg2 = (int)xs;
xs->req_sense_length = (dsreq->ds_senselen < sizeof(struct scsi_sense_data))
? dsreq->ds_senselen
: sizeof(struct scsi_sense_data);
xs->status = 0;
retval = sg_submit_cmd(dev, xs, dsreq);
if (dsreq->ds_ret == DSRT_SENSE)
bcopy(&(xs->sense), scsi_sense, sizeof(xs->sense));
sg_free_xs(dev,xs,flags);
return retval;
}
void sgerr(struct buf *bp, int err)
{
bp->b_error = err;
bp->b_flags |= B_ERROR;
iodone(bp);
}
/* strategy function
*
* Should I reorganize this so it returns to physio instead
* of sleeping in sg_scsi_cmd? Is there any advantage, other
* than avoiding the probable duplicate wakeup in iodone?
*
* Don't create a block device entry point for this
* driver without making some fixes:
* you have to be able to go from the bp to the dsreq somehow.
*/
void sgstrategy(struct buf *bp)
{
int err;
struct scsi_generic scsi_generic;
struct scsi_sense_data scsi_sense;
int lun = G_SCSI_LUN(bp->b_dev);
dsbuf_t *dsbuf = DSBUF_P(bp);
dsreq_t *dsreq;
if (dsbuf->magic != DSBUF_MAGIC)
{
printf("sgstrategy: struct buf not magic.\n");
sgerr(bp, EFAULT);
return;
}
dsreq = dsbuf->dsreq;
/* We're in trouble if physio tried to break up the
* transfer:
*/
if (bp->b_bcount != dsreq->ds_datalen)
{
printf("sgstrategy unit%d: Transfer broken up.\n",
G_SCSI_UNIT(bp->b_dev));
sgerr(bp, EIO);
return;
}
dsreq->ds_ret = DSRT_OK;
/* Reject 0 length timeouts.
*/
if (dsreq->ds_time == 0)
{
sgerr(bp, EINVAL);
return;
}
if (dsreq->ds_cmdlen > sizeof(struct scsi_generic))
{
sgerr(bp, EFAULT);
return;
}
copyin(dsreq->ds_cmdbuf, (char *)&scsi_generic, dsreq->ds_cmdlen);
/* Use device unit for the LUN. Using the one the user provided
* would be a huge security problem.
*/
if ((dsreq->ds_flags & DSRQ_ESCAPE) == 0)
scsi_generic.bytes[0] = (scsi_generic.bytes[0] & 0x1F) | (lun << 5);
err = sg_scsi_cmd(bp->b_dev, dsreq,
&scsi_generic,
(u_char *)bp->b_un.b_addr,
bp->b_bcount,
&scsi_sense);
if (dsreq->ds_sensesent)
{
if (dsreq->ds_sensesent > dsreq->ds_senselen)
dsreq->ds_sensesent = dsreq->ds_senselen;
copyout(&scsi_sense, dsreq->ds_sensebuf, dsreq->ds_sensesent);
}
if (err)
{
if (dsreq->ds_ret == DSRT_OK)
dsreq->ds_ret = DSRT_DEVSCSI;
sgerr(bp, err);
return;
}
/* This is a fake. It would be nice to know if the
* command was sent or not instead of pretending it was if
* we get this far. That would involve adding "sent" members
* to the xs so it could be set up down in the host adapter code.
*/
dsreq->ds_cmdsent = dsreq->ds_cmdlen;
if (dsreq->ds_ret == 0)
dsreq->ds_ret = DSRT_OK;
iodone(bp); /* Shouldn't this iodone be done in the interrupt?
*/
return;
}
void sgminphys(struct buf *bp)
{
}
int sgioctl(dev_t dev, int cmd, caddr_t addr, int f)
{
int ret = 0;
int phys;
switch(cmd)
{
case DS_ENTER:
{
dsreq_t *dsreq = (dsreq_t *)addr;
int rwflag = (dsreq->ds_flags & DSRQ_READ) ? B_READ : B_WRITE;
struct dsbuf dsbuf;
struct buf *bp = &dsbuf.buf;
bzero(&dsbuf, sizeof(dsbuf));
dsbuf.dsreq = dsreq;
dsbuf.magic = DSBUF_MAGIC;
#ifdef SCSI_PHYSADDR /* Physical memory addressing option */
phys = (dsreq->ds_flags & DSRQ_PHYSADDR);
#else
phys = 0;
#endif
if (phys)
{
bp->b_un.b_addr = dsreq->ds_databuf;
bp->b_bcount = dsreq->ds_datalen;
bp->b_dev = dev;
bp->b_flags = rwflag;
sgstrategy(bp);
ret = bp->b_error;
}
else if (dsreq->ds_datalen)
{
struct uio uio;
struct iovec iovec;
iovec.iov_base = dsreq->ds_databuf;
iovec.iov_len = dsreq->ds_datalen;
uio.uio_offset = 0;
uio.uio_resid = dsreq->ds_datalen;
uio.uio_segflg = UIO_USERSPACE;
uio.uio_procp = curproc;
uio.uio_rw = (rwflag == B_READ) ? UIO_READ : UIO_WRITE;
uio.uio_iov = &iovec;
uio.uio_iovcnt = 1;
if ((ret = rawio(dev, &uio, bp)) == 0)
ret = bp->b_error;
}
else
{
bp->b_un.b_addr = 0;
bp->b_bcount = 0;
bp->b_dev = dev;
bp->b_flags = 0;
sgstrategy(bp);
ret = bp->b_error;
}
}
break;
case DS_TARGET:
ret = sg_target(dev, *(int *)addr);
break;
default:
ret = ENOTTY;
break;
}
return ret;
}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.