759 lines
15 KiB
C
759 lines
15 KiB
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;
|
|
}
|