Sync usage with man page.

[netbsd-mini2440.git] / sys / arch / mac68k / 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;
}