/*      $NetBSD: scsipiconf.h,v 1.133 2024/10/29 15:50:07 nat Exp $     */

/*-
 * Copyright (c) 1998, 1999, 2000, 2004 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Charles M. Hannum; by Jason R. Thorpe of the Numerical Aerospace
 * Simulation Facility, NASA Ames Research Center.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
 */

/*
 * Originally written by Julian Elischer (julian@tfs.com)
 * for TRW Financial Systems for use under the MACH(2.5) operating system.
 *
 * TRW Financial Systems, in accordance with their agreement with Carnegie
 * Mellon University, makes this software available to CMU to distribute
 * or use in any manner that they see fit as long as this message is kept with
 * the software. For this reason TFS also grants any other persons or
 * organisations permission to use or modify this software.
 *
 * TFS supplies this software to be publicly redistributed
 * on the understanding that TFS is not responsible for the correct
 * functioning of this software in any circumstances.
 *
 * Ported to run under 386BSD by Julian Elischer (julian@tfs.com) Sept 1992
 */

#ifndef _DEV_SCSIPI_SCSIPICONF_H_
#define _DEV_SCSIPI_SCSIPICONF_H_

typedef int     boolean;

#include <sys/callout.h>
#include <sys/queue.h>
#include <sys/condvar.h>
#include <dev/scsipi/scsi_spc.h>
#include <dev/scsipi/scsipi_debug.h>

struct buf;
struct proc;
struct device;
struct scsipi_channel;
struct scsipi_periph;
struct scsipi_xfer;

/*
 * The following defines the scsipi_xfer queue.
 */
TAILQ_HEAD(scsipi_xfer_queue, scsipi_xfer);

struct scsipi_generic {
        u_int8_t opcode;
        u_int8_t bytes[15];
};


/*
 * scsipi_async_event_t:
 *
 *      Asynchronous events from the adapter to the mid-layer and
 *      peripheral.
 *
 *      Arguments:
 *
 *      ASYNC_EVENT_MAX_OPENINGS        scsipi_max_openings * -- max
 *                                      openings, device specified in
 *                                      parameters
 *
 *      ASYNC_EVENT_XFER_MODE           scsipi_xfer_mode * -- xfer mode
 *                                      parameters changed for I_T Nexus
 *      ASYNC_EVENT_RESET               NULL - channel has been reset
 */
typedef enum {
        ASYNC_EVENT_MAX_OPENINGS,       /* set max openings on periph */
        ASYNC_EVENT_XFER_MODE,          /* xfer mode update for I_T */
        ASYNC_EVENT_RESET               /* channel reset */
} scsipi_async_event_t;

/*
 * scsipi_max_openings:
 *
 *      Argument for an ASYNC_EVENT_MAX_OPENINGS event.
 */
struct scsipi_max_openings {
        int     mo_target;              /* openings are for this target... */
        int     mo_lun;                 /* ...and this lun */
        int     mo_openings;            /* openings value */
};

/*
 * scsipi_xfer_mode:
 *
 *      Argument for an ASYNC_EVENT_XFER_MODE event.
 */
struct scsipi_xfer_mode {
        int     xm_target;              /* target, for I_T Nexus */
        int     xm_mode;                /* PERIPH_CAP* bits */
        int     xm_period;              /* sync period */
        int     xm_offset;              /* sync offset */
};


/*
 * scsipi_adapter_req_t:
 *
 *      Requests that can be made of an adapter.
 *
 *      Arguments:
 *
 *      ADAPTER_REQ_RUN_XFER            scsipi_xfer * -- the xfer which
 *                                      is to be run
 *
 *      ADAPTER_REQ_GROW_RESOURCES      no argument
 *
 *      ADAPTER_REQ_SET_XFER_MODE       scsipi_xfer_mode * -- set the xfer
 *                                      mode for the I_T Nexus according to
 *                                      this
 */
typedef enum {
        ADAPTER_REQ_RUN_XFER,           /* run a scsipi_xfer */
        ADAPTER_REQ_GROW_RESOURCES,     /* grow xfer execution resources */
        ADAPTER_REQ_SET_XFER_MODE       /* set xfer mode */
} scsipi_adapter_req_t;

#ifdef _KERNEL
/*
 * scsipi_periphsw:
 *
 *      Callbacks into periph driver from midlayer.
 *
 *      psw_error       Called by the bustype's interpret-sense routine
 *                      to do periph-specific sense handling.
 *
 *      psw_start       Called by midlayer to restart a device once
 *                      more command openings become available.
 *
 *      psw_async       Called by midlayer when an asynchronous event
 *                      from the adapter occurs.
 *
 *      psw_done        Called by the midlayer when an xfer has completed.
 */
struct scsipi_periphsw {
        int     (*psw_error)(struct scsipi_xfer *);
        void    (*psw_start)(struct scsipi_periph *);
        int     (*psw_async)(struct scsipi_periph *,
                    scsipi_async_event_t, void *);
        void    (*psw_done)(struct scsipi_xfer *, int);
};

struct disk_parms;
struct scsipi_inquiry_pattern;

/*
 * scsipi_adapter:
 *
 *      This structure describes an instance of a SCSIPI adapter.
 *
 *      Note that `adapt_openings' is used by (the common case of) adapters
 *      which have per-adapter resources.  If an adapter's command resources
 *      are associated with a channel, then the `chan_openings' below will
 *      be used instead.
 *
 *      Note that all adapter entry points take a pointer to a channel,
 *      as an adapter may have more than one channel, and the channel
 *      structure contains the channel number.
 */
struct scsipi_adapter {
        device_t adapt_dev;     /* pointer to adapter's device */
        int     adapt_nchannels;        /* number of adapter channels */
        volatile int    adapt_refcnt;           /* adapter's reference count */
        int     adapt_openings;         /* total # of command openings */
        int     adapt_max_periph;       /* max openings per periph */
        int     adapt_flags;

        void    (*adapt_request)(struct scsipi_channel *,
                    scsipi_adapter_req_t, void *);
        void    (*adapt_minphys)(struct buf *);
        int     (*adapt_ioctl)(struct scsipi_channel *, u_long,
                    void *, int, struct proc *);
        int     (*adapt_enable)(device_t, int);
        int     (*adapt_getgeom)(struct scsipi_periph *,
                        struct disk_parms *, u_long);
        int     (*adapt_accesschk)(struct scsipi_periph *,
                        struct scsipi_inquiry_pattern *);

        kmutex_t adapt_mtx;
        volatile int    adapt_running;  /* how many users of mutex */
};

/* adapt_flags */
#define SCSIPI_ADAPT_POLL_ONLY  0x01 /* Adaptor can't do interrupts. */
#define SCSIPI_ADAPT_MPSAFE     0x02 /* Adaptor doesn't need kernel lock */

void scsipi_adapter_minphys(struct scsipi_channel *, struct buf *);
void scsipi_adapter_request(struct scsipi_channel *,
        scsipi_adapter_req_t, void *);
int scsipi_adapter_ioctl(struct scsipi_channel *, u_long,
        void *, int, struct proc *);
int scsipi_adapter_enable(struct scsipi_adapter *, int);
#endif


/*
 * scsipi_bustype:
 *
 *      This structure describes a SCSIPI bus type.
 *      The bustype_type member is shared with struct ata_bustype
 *      (because we can ata, atapi or scsi busses to the same controller)
 */
struct scsipi_bustype {
        int     bustype_type;           /* symbolic name of type */

        void    (*bustype_cmd)(struct scsipi_xfer *);
        int     (*bustype_interpret_sense)(struct scsipi_xfer *);
        void    (*bustype_printaddr)(struct scsipi_periph *);
        void    (*bustype_kill_pending)(struct scsipi_periph *);
        void    (*bustype_async_event_xfer_mode)(struct scsipi_channel *,
                    void *);
};

/* bustype_type */
/* type is stored in the first byte */
#define SCSIPI_BUSTYPE_TYPE_SHIFT 0
#define SCSIPI_BUSTYPE_TYPE(x) (((x) >> SCSIPI_BUSTYPE_TYPE_SHIFT) & 0xff)
#define SCSIPI_BUSTYPE_SCSI     0 /* parallel SCSI */
#define SCSIPI_BUSTYPE_ATAPI    1
/* #define SCSIPI_BUSTYPE_ATA   2 */
/* subtype is stored in the second byte */
#define SCSIPI_BUSTYPE_SUBTYPE_SHIFT 8
#define SCSIPI_BUSTYPE_SUBTYPE(x) (((x) >> SCSIPI_BUSTYPE_SUBTYPE_SHIFT) & 0xff)

#define SCSIPI_BUSTYPE_BUSTYPE(t, s) \
    ((t) << SCSIPI_BUSTYPE_TYPE_SHIFT | (s) << SCSIPI_BUSTYPE_SUBTYPE_SHIFT)
/* subtypes are defined in each bus type headers */

/*
 * scsipi_channel:
 *
 *      This structure describes a single channel of a SCSIPI adapter.
 *      An adapter may have one or more channels.  See the comment above
 *      regarding the resource counter.
 *      Note: chan_bustype has to be first member, as its bustype_type member
 *      is shared with the aa_bustype member of struct ata_atapi_attach.
 */

#define SCSIPI_CHAN_PERIPH_BUCKETS      16
#define SCSIPI_CHAN_PERIPH_HASHMASK     (SCSIPI_CHAN_PERIPH_BUCKETS - 1)

#ifdef _KERNEL
struct scsipi_channel {
        const struct scsipi_bustype *chan_bustype; /* channel's bus type */
        const char *chan_name;  /* this channel's name */

        struct scsipi_adapter *chan_adapter; /* pointer to our adapter */

        /* Periphs for this channel. */
        LIST_HEAD(, scsipi_periph) chan_periphtab[SCSIPI_CHAN_PERIPH_BUCKETS];

        int     chan_channel;           /* channel number */
        int     chan_flags;             /* channel flags */
        int     chan_openings;          /* number of command openings */
        int     chan_max_periph;        /* max openings per periph */

        int     chan_ntargets;          /* number of targets */
        int     chan_nluns;             /* number of luns */
        int     chan_id;                /* adapter's ID for this channel */

        int     chan_defquirks;         /* default device's quirks */

        struct lwp *chan_dthread;       /* discovery thread */
        struct lwp *chan_thread;        /* completion thread */
        int     chan_tflags;            /* flags for the completion thread */

        int     chan_qfreeze;           /* freeze count for queue */

        /* Job queue for this channel. */
        struct scsipi_xfer_queue chan_queue;

        /* Completed (async) jobs. */
        struct scsipi_xfer_queue chan_complete;

        /* callback we may have to call from completion thread */
        void (*chan_callback)(struct scsipi_channel *, void *);
        void *chan_callback_arg;

        /* callback we may have to call after forking the kthread */
        void (*chan_init_cb)(struct scsipi_channel *, void *);
        void *chan_init_cb_arg;

        kcondvar_t chan_cv_comp;
        kcondvar_t chan_cv_thr;
        kcondvar_t chan_cv_xs;

#define chan_cv_complete(ch) (&(ch)->chan_cv_comp)
#define chan_cv_thread(ch) (&(ch)->chan_cv_thr)
};

#define chan_running(ch) ((ch)->chan_adapter->adapt_running)
#define chan_mtx(ch) (&(ch)->chan_adapter->adapt_mtx)
#endif

/* chan_flags */
#define SCSIPI_CHAN_OPENINGS    0x01    /* use chan_openings */
#define SCSIPI_CHAN_CANGROW     0x02    /* channel can grow resources */
#define SCSIPI_CHAN_NOSETTLE    0x04    /* don't wait for devices to settle */
#define SCSIPI_CHAN_TACTIVE     0x08    /* completion thread is active */

/* chan thread flags (chan_tflags) */
#define SCSIPI_CHANT_SHUTDOWN   0x01    /* channel is shutting down */
#define SCSIPI_CHANT_CALLBACK   0x02    /* has to call chan_callback() */
#define SCSIPI_CHANT_KICK       0x04    /* need to run queues */
#define SCSIPI_CHANT_GROWRES    0x08    /* call ADAPTER_REQ_GROW_RESOURCES */

#define SCSIPI_CHAN_MAX_PERIPH(chan)                                    \
        (((chan)->chan_flags & SCSIPI_CHAN_OPENINGS) ?                  \
         (chan)->chan_max_periph : (chan)->chan_adapter->adapt_max_periph)


#define scsipi_printaddr(periph)                                        \
        (*(periph)->periph_channel->chan_bustype->bustype_printaddr)((periph))

#define scsipi_periph_bustype(periph)                                   \
        (periph)->periph_channel->chan_bustype->bustype_type


/*
 * Number of tag words in a periph structure:
 *
 *      n_tag_words = ((256 / NBBY) / sizeof(u_int32_t))
 */
#define PERIPH_NTAGWORDS        ((256 / 8) / sizeof(u_int32_t))

#ifdef _KERNEL
/*
 * scsipi_opcodes:
 *      This optionally allocated structure documents
 *      valid opcodes and timeout values for the respective
 *      opcodes overriding the requested timeouts.
 *      It is created when SCSI_MAINTENANCE_IN/
 *      RSOC_REPORT_SUPPORTED_OPCODES can provide information
 *      at attach time.
 */
struct scsipi_opcodes 
{
        struct scsipi_opinfo
        {
                long          ti_timeout;       /* timeout in seconds (> 0 => VALID) */
                unsigned long ti_flags;
#define SCSIPI_TI_VALID  0x0001         /* valid op code */
#define SCSIPI_TI_LOGGED 0x8000         /* override logged during debug */
        } opcode_info[0x100];
};

/*
 * scsipi_periph:
 *
 *      This structure describes the path between a peripheral device
 *      and an adapter.  It contains a pointer to the adapter channel
 *      which in turn contains a pointer to the adapter.
 *
 * XXX Given the way NetBSD's autoconfiguration works, this is ...
 * XXX nasty.
 *
 *      Well, it's a lot nicer than it used to be, but there could
 *      still be an improvement.
 */
struct scsipi_periph {
        device_t periph_dev;    /* pointer to peripheral's device */
        struct scsipi_channel *periph_channel; /* channel we're connected to */

                                        /* link in channel's table of periphs */
        LIST_ENTRY(scsipi_periph) periph_hash;

        const struct scsipi_periphsw *periph_switch; /* peripheral's entry
                                                        points */
        int     periph_openings;        /* max # of outstanding commands */
        int     periph_active;          /* current # of outstanding commands */
        int     periph_sent;            /* current # of commands sent to adapt*/

        int     periph_mode;            /* operation modes, CAP bits */
        int     periph_period;          /* sync period (factor) */
        int     periph_offset;          /* sync offset */

        /*
         * Information gleaned from the inquiry data.
         */
        u_int8_t periph_type;           /* basic device type */
        int     periph_cap;             /* capabilities */
        int     periph_quirks;          /* device's quirks */

        int     periph_flags;           /* misc. flags */
        int     periph_dbflags;         /* debugging flags */

        int     periph_target;          /* target ID (drive # on ATAPI) */
        int     periph_lun;             /* LUN (not used on ATAPI) */

        int     periph_version;         /* ANSI SCSI version */

        int     periph_qfreeze;         /* queue freeze count */

        /* available opcodes and timeout information */
        struct scsipi_opcodes *periph_opcs;
        
        /* Bitmap of free command tags. */
        u_int32_t periph_freetags[PERIPH_NTAGWORDS];

        /* Pending scsipi_xfers on this peripheral. */
        struct scsipi_xfer_queue periph_xferq;

        callout_t periph_callout;

        /* xfer which has a pending CHECK_CONDITION */
        struct scsipi_xfer *periph_xscheck;

        kcondvar_t periph_cv;
#define periph_cv_periph(p) (&(p)->periph_cv)
#define periph_cv_active(p) (&(p)->periph_cv)
};
#endif

/*
 * Macro to return the current xfer mode of a periph.
 */
#define PERIPH_XFER_MODE(periph)                                        \
        (((periph)->periph_flags & PERIPH_MODE_VALID) ?                 \
         (periph)->periph_mode : 0)

/* periph_cap */
#define PERIPH_CAP_ANEC         0x0001  /* async event notification */
#define PERIPH_CAP_TERMIOP      0x0002  /* terminate i/o proc. messages */
#define PERIPH_CAP_RELADR       0x0004  /* relative addressing */
#define PERIPH_CAP_WIDE32       0x0008  /* wide-32 transfers */
#define PERIPH_CAP_WIDE16       0x0010  /* wide-16 transfers */
                /*      XXX     0x0020     reserved for ATAPI_CFG_DRQ_MASK */
                /*      XXX     0x0040     reserved for ATAPI_CFG_DRQ_MASK */
#define PERIPH_CAP_SYNC         0x0080  /* synchronous transfers */
#define PERIPH_CAP_LINKCMDS     0x0100  /* linked commands */
#define PERIPH_CAP_TQING        0x0200  /* tagged queueing */
#define PERIPH_CAP_SFTRESET     0x0400  /* soft RESET condition response */
#define PERIPH_CAP_CMD16        0x0800  /* 16 byte commands (ATAPI) */
#define PERIPH_CAP_DT           0x1000  /* supports DT clock */
#define PERIPH_CAP_QAS          0x2000  /* supports quick arbit. and select. */
#define PERIPH_CAP_IUS          0x4000  /* supports information unit xfers */

/* periph_flags */
#define PERIPH_REMOVABLE        0x0001  /* media is removable */
#define PERIPH_MEDIA_LOADED     0x0002  /* media is loaded */
#define PERIPH_WAITING          0x0004  /* process waiting for opening */
#define PERIPH_OPEN             0x0008  /* device is open */
#define PERIPH_WAITDRAIN        0x0010  /* waiting for pending xfers to drain */
#define PERIPH_GROW_OPENINGS    0x0020  /* allow openings to grow */
#define PERIPH_MODE_VALID       0x0040  /* periph_mode is valid */
#define PERIPH_RECOVERING       0x0080  /* periph is recovering */
#define PERIPH_RECOVERY_ACTIVE  0x0100  /* a recovery command is active */
#define PERIPH_KEEP_LABEL       0x0200  /* retain label after 'full' close */
#define PERIPH_SENSE            0x0400  /* periph has sense pending */
#define PERIPH_UNTAG            0x0800  /* untagged command running */

/* periph_quirks */
#define PQUIRK_AUTOSAVE         0x00000001      /* do implicit SAVE POINTERS */
#define PQUIRK_NOSYNC           0x00000002      /* does not grok SDTR */
#define PQUIRK_NOWIDE           0x00000004      /* does not grok WDTR */
#define PQUIRK_NOTAG            0x00000008      /* does not grok tagged cmds */
#define PQUIRK_NOLUNS           0x00000010      /* DTWT with LUNs */
#define PQUIRK_FORCELUNS        0x00000020      /* prehistoric device groks
                                                   LUNs */
#define PQUIRK_NOMODESENSE      0x00000040      /* device doesn't do MODE SENSE
                                                   properly */
#define PQUIRK_NOSYNCCACHE      0x00000100      /* do not issue SYNC CACHE */
#define PQUIRK_LITTLETOC        0x00000400      /* audio TOC is little-endian */
#define PQUIRK_NOCAPACITY       0x00000800      /* no READ CD CAPACITY */
#define PQUIRK_NOTUR            0x00001000      /* no TEST UNIT READY */
#define PQUIRK_NODOORLOCK       0x00002000      /* can't lock door */
#define PQUIRK_NOSENSE          0x00004000      /* can't REQUEST SENSE */
#define PQUIRK_ONLYBIG          0x00008000      /* only use SCSI_{R,W}_BIG */
#define PQUIRK_NOBIGMODESENSE   0x00040000      /* has no big mode-sense op */
#define PQUIRK_CAP_SYNC         0x00080000      /* SCSI device with ST sync op*/
#define PQUIRK_CAP_WIDE16       0x00100000      /* SCSI device with ST wide op*/
#define PQUIRK_CAP_NODT         0x00200000      /* signals DT, but can't. */
#define PQUIRK_START            0x00400000      /* needs start before tur */
#define PQUIRK_NOFUA            0x00800000      /* does not grok FUA */
#define PQUIRK_NOREPSUPPOPC     0x01000000      /* does not grok
                                                   REPORT SUPPORTED OPCODES
                                                   to fetch device timeouts */
#define PQUIRK_NOREADDISCINFO   0x02000000      /* device doesn't do
                                                   READ_DISCINFO properly */
/*
 * Error values an adapter driver may return
 */
typedef enum {
        XS_NOERROR,             /* there is no error, (sense is invalid)  */
        XS_SENSE,               /* Check the returned sense for the error */
        XS_SHORTSENSE,          /* Check the ATAPI sense for the error    */
        XS_DRIVER_STUFFUP,      /* Driver failed to perform operation     */
        XS_RESOURCE_SHORTAGE,   /* adapter resource shortage              */
        XS_SELTIMEOUT,          /* The device timed out.. turned off?     */
        XS_TIMEOUT,             /* The Timeout reported was caught by SW  */
        XS_BUSY,                /* The device busy, try again later?      */
        XS_RESET,               /* bus was reset; possible retry command  */
        XS_REQUEUE              /* requeue this command */
} scsipi_xfer_result_t;

#ifdef _KERNEL
/*
 * Each scsipi transaction is fully described by one of these structures
 * It includes information about the source of the command and also the
 * device and adapter for which the command is destined.
 *
 * Before the HBA is given this transaction, channel_q is the linkage on
 * the related channel's chan_queue.
 *
 * When the this transaction is taken off the channel's chan_queue and
 * the HBA's request entry point is called with this transaction, the
 * HBA can use the channel_q tag for whatever it likes until it calls
 * scsipi_done for this transaction, at which time it has to stop
 * using channel_q.
 *
 * After scsipi_done is called with this transaction and if there was an
 * error on it, channel_q then becomes the linkage on the related channel's
 * chan_complete cqueue.
 *
 * The device_q member is maintained by the scsipi middle layer.  When
 * a device issues a command, the xfer is placed on that device's
 * pending commands queue.  When an xfer is done and freed, it is taken
 * off the device's queue.  This allows for a device to wait for all of
 * its pending commands to complete.
 */
struct scsipi_xfer {
        TAILQ_ENTRY(scsipi_xfer) channel_q; /* entry on channel queue */
        TAILQ_ENTRY(scsipi_xfer) device_q;  /* device's pending xfers */
        callout_t xs_callout;           /* callout for adapter use */
        int     xs_control;             /* control flags */
        volatile int xs_status;         /* status flags */
        struct scsipi_periph *xs_periph;/* peripheral doing the xfer */
        int     xs_retries;             /* the number of times to retry */
        int     xs_requeuecnt;          /* number of requeues */
        int     timeout;                /* in milliseconds */
        struct  scsipi_generic *cmd;    /* The scsipi command to execute */
        int     cmdlen;                 /* how long it is */
        u_char  *data;                  /* DMA address OR a uio address */
        int     datalen;                /* data len (blank if uio) */
        int     resid;                  /* how much buffer was not touched */
        scsipi_xfer_result_t error;     /* an error value */
        struct  buf *bp;                /* If we need to associate with */
                                        /* a buf */
        union {
                struct  scsi_sense_data scsi_sense; /* 32 bytes */
                u_int32_t atapi_sense;
        } sense;

        struct scsipi_xfer *xs_sensefor;/* we are requesting sense for this */
                                        /* xfer */

        u_int8_t status;                /* SCSI status */

        /*
         * Info for tagged command queueing.  This may or may not
         * be used by a given adapter driver.  These are the same
         * as the bytes in the tag message.
         */
        u_int8_t xs_tag_type;           /* tag type */
        u_int8_t xs_tag_id;             /* tag ID */

        struct  scsipi_generic cmdstore
            __aligned(4);               /* stash the command in here */

#define xs_cv(xs) (&(xs)->xs_periph->periph_channel->chan_cv_xs)
};
#endif

/*
 * scsipi_xfer control flags
 *
 * To do:
 *
 *      - figure out what to do with XS_CTL_ESCAPE
 *
 *      - replace XS_CTL_URGENT with an `xs_priority' field?
 */
#define XS_CTL_NOSLEEP          0x00000001      /* don't sleep */
#define XS_CTL_POLL             0x00000002      /* poll for completion */
#define XS_CTL_DISCOVERY        0x00000004      /* doing device discovery */
#define XS_CTL_ASYNC            0x00000008      /* command completes
                                                   asynchronously */
#define XS_CTL_USERCMD          0x00000010      /* user issued command */
#define XS_CTL_SILENT           0x00000020      /* don't print sense info */
#define XS_CTL_IGNORE_NOT_READY 0x00000040      /* ignore NOT READY */
#define XS_CTL_IGNORE_MEDIA_CHANGE                                      \
                                0x00000080      /* ignore media change */
#define XS_CTL_IGNORE_ILLEGAL_REQUEST                                   \
                                0x00000100      /* ignore ILLEGAL REQUEST */
#define XS_CTL_SILENT_NODEV     0x00000200      /* don't print sense info
                                                   if sense info is nodev */
#define XS_CTL_RESET            0x00000400      /* reset the device */
#define XS_CTL_DATA_UIO         0x00000800      /* xs_data points to uio */
#define XS_CTL_DATA_IN          0x00001000      /* data coming into memory */
#define XS_CTL_DATA_OUT         0x00002000      /* data going out of memory */
#define XS_CTL_TARGET           0x00004000      /* target mode operation */
#define XS_CTL_ESCAPE           0x00008000      /* escape operation */
#define XS_CTL_URGENT           0x00010000      /* urgent (recovery)
                                                   operation */
#define XS_CTL_SIMPLE_TAG       0x00020000      /* use a Simple Tag */
#define XS_CTL_ORDERED_TAG      0x00040000      /* use an Ordered Tag */
#define XS_CTL_HEAD_TAG         0x00080000      /* use a Head of Queue Tag */
#define XS_CTL_THAW_PERIPH      0x00100000      /* thaw periph once enqueued */
#define XS_CTL_FREEZE_PERIPH    0x00200000      /* freeze periph when done */
#define XS_CTL_REQSENSE         0x00800000      /* xfer is a request sense */

#define XS_CTL_TAGMASK  (XS_CTL_SIMPLE_TAG|XS_CTL_ORDERED_TAG|XS_CTL_HEAD_TAG)

#define XS_CTL_TAGTYPE(xs)      ((xs)->xs_control & XS_CTL_TAGMASK)

/*
 * scsipi_xfer status flags
 */
#define XS_STS_DONE             0x00000001      /* scsipi_xfer is done */
#define XS_STS_PRIVATE          0xf0000000      /* reserved for HBA's use */

/*
 * This describes matching information for scsipi_inqmatch().  The more things
 * match, the higher the configuration priority.
 */
struct scsipi_inquiry_pattern {
        u_int8_t type;
        boolean removable;
        const char *vendor;
        const char *product;
        const char *revision;
};

/*
 * This is used to pass information from the high-level configuration code
 * to the device-specific drivers.
 */
struct scsipibus_attach_args {
        struct scsipi_periph *sa_periph;
        struct scsipi_inquiry_pattern sa_inqbuf;
        struct scsipi_inquiry_data *sa_inqptr;
        union {                         /* bus-type specific infos */
                u_int8_t scsi_version;  /* SCSI version */
        } scsipi_info;
};

/*
 * this describes a quirk entry
 */
struct scsi_quirk_inquiry_pattern {
        struct scsipi_inquiry_pattern pattern;
        int quirks;
};

/*
 * Default number of retries, used for generic routines.
 */
#define SCSIPIRETRIES 4


#ifdef _KERNEL
void    scsipi_init(void);
void    scsipi_ioctl_init(void);
void    scsipi_load_verbose(void);
int     scsipi_command(struct scsipi_periph *, struct scsipi_generic *, int,
            u_char *, int, int, int, struct buf *, int);
void    scsipi_create_completion_thread(void *);
const void *scsipi_inqmatch(struct scsipi_inquiry_pattern *, const void *,
            size_t, size_t, int *);
const char *scsipi_dtype(int);
int     scsipi_execute_xs(struct scsipi_xfer *);
int     scsipi_test_unit_ready(struct scsipi_periph *, int);
int     scsipi_prevent(struct scsipi_periph *, int, int);
int     scsipi_inquire(struct scsipi_periph *,
            struct scsipi_inquiry_data *, int);
int     scsipi_mode_select(struct scsipi_periph *, int,
            struct scsi_mode_parameter_header_6 *, int, int, int, int);
int     scsipi_mode_select_big(struct scsipi_periph *, int,
            struct scsi_mode_parameter_header_10 *, int, int, int, int);
int     scsipi_mode_sense(struct scsipi_periph *, int, int,
            struct scsi_mode_parameter_header_6 *, int, int, int, int);
int     scsipi_mode_sense_big(struct scsipi_periph *, int, int,
            struct scsi_mode_parameter_header_10 *, int, int, int, int);
int     scsipi_start(struct scsipi_periph *, int, int);
void    scsipi_done(struct scsipi_xfer *);
void    scsipi_user_done(struct scsipi_xfer *);
int     scsipi_interpret_sense(struct scsipi_xfer *);
void    scsipi_wait_drain(struct scsipi_periph *);
void    scsipi_kill_pending(struct scsipi_periph *);
void    scsipi_get_opcodeinfo(struct scsipi_periph *periph);
void    scsipi_free_opcodeinfo(struct scsipi_periph *periph);
struct scsipi_periph *scsipi_alloc_periph(int);
void    scsipi_free_periph(struct scsipi_periph *);

/* Function pointers for scsiverbose module */
extern int      (*scsipi_print_sense)(struct scsipi_xfer *, int);
extern void     (*scsipi_print_sense_data)(struct scsi_sense_data *, int);

int     scsipi_print_sense_stub(struct scsipi_xfer *, int);
void    scsipi_print_sense_data_stub(struct scsi_sense_data *, int);

extern int      scsi_verbose_loaded;

void    scsipi_print_cdb(struct scsipi_generic *cmd);
int     scsipi_thread_call_callback(struct scsipi_channel *,
            void (*callback)(struct scsipi_channel *, void *),
            void *);
void    scsipi_async_event(struct scsipi_channel *,
            scsipi_async_event_t, void *);
int     scsipi_do_ioctl(struct scsipi_periph *, dev_t, u_long, void *,
            int, struct lwp *);

void    scsipi_set_xfer_mode(struct scsipi_channel *, int, int);

int     scsipi_channel_init(struct scsipi_channel *);
void    scsipi_channel_shutdown(struct scsipi_channel *);

void    scsipi_insert_periph(struct scsipi_channel *,
            struct scsipi_periph *);
void    scsipi_remove_periph(struct scsipi_channel *,
            struct scsipi_periph *);
struct scsipi_periph *scsipi_lookup_periph(struct scsipi_channel *,
            int, int);
struct scsipi_periph *scsipi_lookup_periph_locked(struct scsipi_channel *,
            int, int);
int     scsipi_target_detach(struct scsipi_channel *, int, int, int);

int     scsipi_adapter_addref(struct scsipi_adapter *);
void    scsipi_adapter_delref(struct scsipi_adapter *);

void    scsipi_channel_freeze(struct scsipi_channel *, int);
void    scsipi_channel_thaw(struct scsipi_channel *, int);
void    scsipi_channel_timed_thaw(void *);

void    scsipi_periph_freeze(struct scsipi_periph *, int);
void    scsipi_periph_thaw(struct scsipi_periph *, int);
void    scsipi_periph_timed_thaw(void *);

void    scsipi_periph_freeze_locked(struct scsipi_periph *, int);
void    scsipi_periph_thaw_locked(struct scsipi_periph *, int);

int     scsipi_sync_period_to_factor(int);
int     scsipi_sync_factor_to_period(int);
int     scsipi_sync_factor_to_freq(int);

void    show_scsipi_xs(struct scsipi_xfer *);
void    show_scsipi_cmd(struct scsipi_xfer *);
void    show_mem(u_char *, int);
#endif /* _KERNEL */

static __inline void
_lto2b(u_int32_t val, u_int8_t *bytes)
{

        bytes[0] = (val >> 8) & 0xff;
        bytes[1] = val & 0xff;
}

static __inline void
_lto3b(u_int32_t val, u_int8_t *bytes)
{

        bytes[0] = (val >> 16) & 0xff;
        bytes[1] = (val >> 8) & 0xff;
        bytes[2] = val & 0xff;
}

static __inline void
_lto4b(u_int32_t val, u_int8_t *bytes)
{

        bytes[0] = (val >> 24) & 0xff;
        bytes[1] = (val >> 16) & 0xff;
        bytes[2] = (val >> 8) & 0xff;
        bytes[3] = val & 0xff;
}

static __inline void
_lto8b(u_int64_t val, u_int8_t *bytes)
{

        bytes[0] = (val >> 56) & 0xff;
        bytes[1] = (val >> 48) & 0xff;
        bytes[2] = (val >> 40) & 0xff;
        bytes[3] = (val >> 32) & 0xff;
        bytes[4] = (val >> 24) & 0xff;
        bytes[5] = (val >> 16) & 0xff;
        bytes[6] = (val >> 8)  & 0xff;
        bytes[7] = val         & 0xff;
}

static __inline u_int32_t
_2btol(const u_int8_t *bytes)
{
        u_int32_t rv;

        rv = (bytes[0] << 8) |
             bytes[1];
        return (rv);
}

static __inline u_int32_t
_3btol(const u_int8_t *bytes)
{
        u_int32_t rv;

        rv = (bytes[0] << 16) |
             (bytes[1] << 8) |
             bytes[2];
        return (rv);
}

static __inline u_int32_t
_4btol(const u_int8_t *bytes)
{
        u_int32_t rv;

        rv = ((u_int32_t)bytes[0] << 24) |
             ((u_int32_t)bytes[1] << 16) |
             ((u_int32_t)bytes[2] << 8) |
             (u_int32_t)bytes[3];
        return (rv);
}

static __inline u_int64_t
_5btol(const u_int8_t *bytes)
{
        u_int64_t rv;

        rv = ((u_int64_t)bytes[0] << 32) |
             ((u_int64_t)bytes[1] << 24) |
             ((u_int64_t)bytes[2] << 16) |
             ((u_int64_t)bytes[3] << 8) |
             (u_int64_t)bytes[4];
        return (rv);
}

static __inline u_int64_t
_8btol(const u_int8_t *bytes)
{
        u_int64_t rv;

        rv = ((u_int64_t)bytes[0] << 56) |
             ((u_int64_t)bytes[1] << 48) |
             ((u_int64_t)bytes[2] << 40) |
             ((u_int64_t)bytes[3] << 32) |
             ((u_int64_t)bytes[4] << 24) |
             ((u_int64_t)bytes[5] << 16) |
             ((u_int64_t)bytes[6] << 8) |
             (u_int64_t)bytes[7];
        return (rv);
}

static __inline void
_lto2l(u_int32_t val, u_int8_t *bytes)
{

        bytes[0] = val & 0xff;
        bytes[1] = (val >> 8) & 0xff;
}

static __inline void
_lto3l(u_int32_t val, u_int8_t *bytes)
{

        bytes[0] = val & 0xff;
        bytes[1] = (val >> 8) & 0xff;
        bytes[2] = (val >> 16) & 0xff;
}

static __inline void
_lto4l(u_int32_t val, u_int8_t *bytes)
{

        bytes[0] = val & 0xff;
        bytes[1] = (val >> 8) & 0xff;
        bytes[2] = (val >> 16) & 0xff;
        bytes[3] = (val >> 24) & 0xff;
}

static __inline u_int32_t
_2ltol(const u_int8_t *bytes)
{
        u_int32_t rv;

        rv = bytes[0] |
             (bytes[1] << 8);
        return (rv);
}

static __inline u_int32_t
_3ltol(const u_int8_t *bytes)
{
        u_int32_t rv;

        rv = bytes[0] |
             (bytes[1] << 8) |
             (bytes[2] << 16);
        return (rv);
}

static __inline u_int32_t
_4ltol(const u_int8_t *bytes)
{
        u_int32_t rv;

        rv = (u_int32_t)bytes[0] |
             ((u_int32_t)bytes[1] << 8) |
             ((u_int32_t)bytes[2] << 16) |
             ((u_int32_t)bytes[3] << 24);
        return (rv);
}

#endif /* _DEV_SCSIPI_SCSIPICONF_H_ */