/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _SYS_SCSI_TARGETS_STDEF_H
#define _SYS_SCSI_TARGETS_STDEF_H

#include <sys/sunddi.h>
#include <sys/note.h>
#include <sys/condvar.h>
#include <sys/kstat.h>
#include <sys/int_limits.h>
#include <sys/scsi/scsi_types.h>
#include <sys/scsi/generic/sense.h>
#include <sys/mtio.h>
#include <sys/taskq.h>
#include <sys/taskq_impl.h>

#ifdef  __cplusplus
extern "C" {
#endif

/*
 * Defines for SCSI tape drives.
 */

/*
 * Maximum variable length record size for a single request
 */
#define ST_MAXRECSIZE_VARIABLE  65535

/*
 * If the requested record size exceeds ST_MAXRECSIZE_VARIABLE,
 * then the following define is used.
 */
#define ST_MAXRECSIZE_VARIABLE_LIMIT    65534

#define ST_MAXRECSIZE_FIXED     (63<<10)        /* maximum fixed record size */
#define INF 1000000000  /* old external count backwards from this from EOF */
#define LASTBLK (-1)    /* new internal count backwards from EOF */

/*
 * Supported tape device types plus default type for opening.
 * Types 10 - 13, are special (ancient too) drives - *NOT SUPPORTED*
 * Types 14 - 1f, are 1/4-inch cartridge drives.
 * Types 20 - 28, are 1/2-inch cartridge or reel drives.
 * Types 28+, are rdat (vcr) drives.
 */
#define ST_TYPE_INVALID         0x00

#define ST_TYPE_SYSGEN1 MT_ISSYSGEN11   /* Sysgen with QIC-11 only */
#define ST_TYPE_SYSGEN  MT_ISSYSGEN     /* Sysgen with QIC-24 and QIC-11 */

#define ST_TYPE_DEFAULT MT_ISDEFAULT    /* Generic 1/4" or undetermined  */
#define ST_TYPE_EMULEX  MT_ISMT02       /* Emulex MT-02 */
#define ST_TYPE_ARCHIVE MT_ISVIPER1     /* Archive QIC-150 */
#define ST_TYPE_WANGTEK MT_ISWANGTEK1   /* Wangtek QIC-150 */

#define ST_TYPE_CDC     MT_ISCDC        /* CDC - (not tested) */
#define ST_TYPE_FUJI    MT_ISFUJI       /* Fujitsu - (not tested) */
#define ST_TYPE_KENNEDY MT_ISKENNEDY    /* Kennedy */
#define ST_TYPE_ANRITSU MT_ISANRITSU    /* Anritsu */
#define ST_TYPE_HP      MT_ISHP         /* HP */
#define ST_TYPE_HIC     MT_ISCCS23      /* Generic 1/2" Cartridge */
#define ST_TYPE_REEL    MT_ISCCS24      /* Generic 1/2" Reel Tape */
#define ST_TYPE_DAT     MT_ISCCS28      /* Generic DAT Tape */

#define ST_TYPE_EXABYTE MT_ISEXABYTE    /* Exabyte 8200 */
#define ST_TYPE_EXB8500 MT_ISEXB8500    /* Exabyte 8500 */
#define ST_TYPE_WANGTHS MT_ISWANGTHS    /* Wangtek 6130HS */
#define ST_TYPE_WANGDAT MT_ISWANGDAT    /* WangDAT */
#define ST_TYPE_PYTHON  MT_ISPYTHON     /* Archive Python DAT */
#define ST_TYPE_STC3490 MT_ISSTC        /* IBM STC 3490 */
#define ST_TYPE_TAND25G MT_ISTAND25G    /* TANDBERG 2.5G */
#define ST_TYPE_DLT     MT_ISDLT        /* DLT */
#define ST_TYPE_STK9840 MT_ISSTK9840    /* StorageTek 9840, 9940, 9840B */
#define ST_TYPE_BMDLT1  MT_ISBMDLT1     /* Benchmark DTL1 */
#define ST_TYPE_LTO     MT_LTO          /* sun: LTO's by HP, Seagate, IBM.. */
#define ST_TYPE_AIT     MT_ISAIT        /* Sony AIT I, II, III and SAIT */
#define ST_LAST_TYPE    ST_TYPE_AIT     /* Add new above type and change this */


/* Internal flags */
#define ST_DYNAMIC              0x2000  /* Device name has been dynamically */
                                        /* alloc'ed from the st.conf entry, */
                                        /* instead of being used from the */
                                        /* st_drivetypes array. */

/*
 * Defines for supported drive options
 *
 * WARNING : THESE OPTIONS SHOULD NEVER BE CHANGED, AS OLDER CONFIGURATIONS
 *              WILL DEPEND ON THE FLAG VALUES REMAINING THE SAME
 */
#define ST_VARIABLE             0x001   /* Device supports variable     */
                                        /* length record sizes          */
#define ST_QIC                  0x002   /* QIC tape device              */
#define ST_REEL                 0x004   /* 1/2-inch reel tape device    */
#define ST_BSF                  0x008   /* Device supports backspace    */
                                        /* file as in mt(1) bsf :       */
                                        /* backspace over EOF marks.    */
                                        /* Devices not supporting bsf   */
                                        /* will fail with ENOTTY upon   */
                                        /* use of bsf                   */
#define ST_BSR                  0x010   /* Device supports backspace    */
                                        /* record as in mt(1) bsr :     */
                                        /* backspace over records. If   */
                                        /* the device does not support  */
                                        /* bsr, the st driver emulates  */
                                        /* the action by rewinding the  */
                                        /* tape and using forward space */
                                        /* file (fsf) to the correct    */
                                        /* file and then uses forward   */
                                        /* space record (fsr) to the    */
                                        /* correct  record              */
#define ST_LONG_ERASE           0x020   /* Device needs a longer time   */
                                        /* than normal to erase         */
#define ST_AUTODEN_OVERRIDE     0x040   /* Auto-Density override flag   */
                                        /* Device can figure out the    */
                                        /* tape density automatically,  */
                                        /* without issuing a            */
                                        /* mode-select/mode-sense       */
#define ST_NOBUF                0x080   /* Don't use buffered mode.     */
                                        /* This disables the device's   */
                                        /* ability for buffered writes  */
                                        /* I.e. The device acknowledges */
                                        /* write completion after the   */
                                        /* data is written to the       */
                                        /* device's buffer, but before  */
                                        /* all the data is actually     */
                                        /* written to tape              */
#define ST_RESERVED_BIT1        0x100   /* reserved bit                 */
                                        /* parity while talking to it.  */
#define ST_KNOWS_EOD            0x200   /* Device knows when EOD (End   */
                                        /* of Data) has been reached.   */
                                        /* If the device knows EOD, st  */
                                        /* uses fast file skipping.     */
                                        /* If it does not know EOD,     */
                                        /* file skipping happens one    */
                                        /* file at a time.              */
#define ST_UNLOADABLE           0x400   /* Device will not complain if  */
                                        /* the st driver is unloaded &  */
                                        /* loaded again; e.g. will      */
                                        /* return the correct inquiry   */
                                        /* string                       */
#define ST_SOFT_ERROR_REPORTING 0x800   /* Do request or log sense on   */
                                        /* close to report soft errors. */
                                        /* Currently only Exabyte and   */
                                        /* DAT drives support this      */
                                        /* feature.                     */
#define ST_LONG_TIMEOUTS        0x1000  /* Device needs 5 times longer  */
                                        /* timeouts for normal          */
                                        /* operation                    */
#define ST_BUFFERED_WRITES      0x4000  /* The data is buffered in the  */
                                        /* driver and pre-acked to the  */
                                        /* application                  */
#define ST_NO_RECSIZE_LIMIT     0x8000  /* For variable record size     */
                                        /* devices only. If flag is     */
                                        /* set, then don't limit        */
                                        /* record size to 64k as in     */
                                        /* pre-Solaris 2.4 releases.    */
                                        /* The only limit on the        */
                                        /* record size will be the max  */
                                        /* record size the device can   */
                                        /* handle or the max DMA        */
                                        /* transfer size of the         */
                                        /* machine, which ever is       */
                                        /* smaller. Beware of           */
                                        /* incompatabilities with       */
                                        /* tapes of pre-Solaris 2.4     */
                                        /* OS's written with large      */
                                        /* (>64k) block sizes, as       */
                                        /* their true block size is     */
                                        /* a max of approx 64k          */
#define ST_MODE_SEL_COMP        0x10000 /* use mode select of device    */
                                        /* configuration page (0x10) to */
                                        /* enable/disable compression   */
                                        /* instead of density codes for */
                                        /* the "c" and "u" devices      */
#define ST_NO_RESERVE_RELEASE   0x20000 /* For devices which do not     */
                                        /* support RESERVE/RELEASE SCSI */
                                        /* command. If this is enabled  */
                                        /* then reserve/release would   */
                                        /* not be used during open/     */
                                        /* close for High Availability  */
#define ST_READ_IGNORE_ILI      0x40000 /* This flag is only applicable */
                                        /* to variable block devices    */
                                        /* which support the SILI bit   */
                                        /* option. It indicates that    */
                                        /* the SILI bit will be ignored */
                                        /* during reads                 */
#define ST_READ_IGNORE_EOFS     0x80000 /* When this flag is set two    */
                                        /* EOF marks do not indicate an */
                                        /* EOM. This option is only     */
                                        /* supported on 1/2" reel tapes */
#define ST_SHORT_FILEMARKS      0x100000 /* This option applies only to */
                                        /* EXABYTE 8mm tape drives      */
                                        /* which support short          */
                                        /* filemarks. When this flag    */
                                        /* is set, short filemarks      */
                                        /* will be used for writing     */
                                        /* filemarks.                   */
#define ST_EJECT_ON_CHANGER_FAILURE 0x200000 /* When this flag is set   */
                                        /* and the tape is trapped in   */
                                        /* the medium changer, the tape */
                                        /* is automatically ejected     */
#define ST_RETRY_ON_RECOVERED_DEFERRED_ERROR 0x400000
                                        /* This option applies only to  */
                                        /* IBM MAGSTAR 3590. If this    */
                                        /* flag is set, the st driver   */
                                        /* will retry the last cmd if   */
                                        /* the last error cause a check */
                                        /* condition with error code    */
                                        /* 0x71 and sense code 0x01     */
#define ST_KNOWS_MEDIA          0x800000 /* Use configured media type   */
                                        /* detected to select correct   */
                                        /* density code.                */
#define ST_WORMABLE             0x1000000
                                        /* Drive is capable of doing    */
                                        /* Write Appends only at EOM    */
                                        /* if WORM media type is loaded */
#define ST_CLN_TYPE_1           0x10000000 /* When this flag is set,    */
                                        /* the tape drive provides the  */
                                        /* clean bit information in     */
                                        /* byte 21, bitmask 0x08 of     */
                                        /* Request Sense data           */
#define ST_CLN_TYPE_2           0x20000000 /* When this flag is set,    */
                                        /* the tape drive provides the  */
                                        /* clean bit information in     */
                                        /* byte 70, bitmask 0xc0 of     */
                                        /* Request Sense data           */
#define ST_CLN_TYPE_3           0x40000000 /* When this flag is set,    */
                                        /* the tape drive provides the  */
                                        /* clean bit information in     */
                                        /* byte 18, bitmask 0x01 of     */
                                        /* Request Sense data           */

#define ST_CLN_MASK     (ST_CLN_TYPE_1 | ST_CLN_TYPE_2 | ST_CLN_TYPE_3)
#define ST_VALID_OPTS   (ST_VARIABLE | ST_QIC | ST_REEL | ST_BSF | ST_BSR |\
        ST_LONG_ERASE | ST_AUTODEN_OVERRIDE | ST_NOBUF | ST_KNOWS_EOD |\
        ST_UNLOADABLE | ST_SOFT_ERROR_REPORTING | ST_LONG_TIMEOUTS |\
        ST_NO_RECSIZE_LIMIT | ST_MODE_SEL_COMP | ST_NO_RESERVE_RELEASE |\
        ST_READ_IGNORE_ILI | ST_READ_IGNORE_EOFS | ST_SHORT_FILEMARKS |\
        ST_EJECT_ON_CHANGER_FAILURE | ST_RETRY_ON_RECOVERED_DEFERRED_ERROR |\
        ST_WORMABLE | ST_CLN_TYPE_1 | ST_CLN_TYPE_2 | ST_CLN_TYPE_3)

#define NDENSITIES      MT_NDENSITIES
#define NSPEEDS         MT_NSPEEDS

/*
 * defines for Log Sense Pages
 */
#define SUPPORTED_LOG_PAGES_PAGE        0x00
#define TAPE_SEQUENTIAL_PAGE            0x0c
#define TAPE_ALERT_PAGE                 0x2e

/*
 * Log Page Control definitions
 */
#define CURRENT_THRESHOLD_VALUES        0x00
#define CURRENT_CUMULATIVE_VALUES       0x40
#define DEFAULT_THRESHOLD_VALUES        0x80
#define DEFAULT_CUMULATIVE_VALUES       0xC0

/*
 * Tape Alert Flag definitions
 */
typedef enum {
        TAF_READ_WARN                   = 0x01,
        TAF_WRITE_WARN                  = 0x02,
        TAF_HARD_ERR                    = 0x03,
        TAF_MEDIA_ERR                   = 0x04,
        TAF_READ_FAIL                   = 0x05,
        TAF_WRITE_FAIL                  = 0x06,
        TAF_MEDIA_LIFE                  = 0x07,
        TAF_MEDIA_NOT_DATA_GRADE        = 0x08,
        TAF_WRITE_PROTECTED             = 0x09,
        TAF_NO_MEDIA_REMOVE             = 0x0A,
        TAF_CLEANING_MEDIA              = 0x0B,
        TAF_UNSUPPERTED_FORMAT          = 0x0C,
        TAF_RECOVERED_TAPE_BREAK        = 0x0D,
        TAF_TAPE_BREAK_FAUL             = 0x0E,
        TAF_CART_MEM_FAIL               = 0x0F,
        TAF_FORCED_EJECT                = 0x10,
        TAF_READ_ONLY_FORMAT            = 0x11,
        TAF_TAPE_DIR_CORRUPT            = 0x12,
        TAF_NEARING_MEDIA_LIFE          = 0x13,
        TAF_CLEAN_NOW                   = 0x14,
        TAF_CLEAN_PERIODIC              = 0x15,
        TAF_EXP_CLEAN_CART              = 0x16,
        TAF_INVALID_CLEAN_MEDIA         = 0x17,
        TAF_RETENSION_REQUEST           = 0x18,
        TAF_DUAL_PORT_INTERFACE_ERR     = 0x19,
        TAF_COOLING_FAN_FAIL            = 0x1A,
        TAF_POWER_SUPPLY_FAIL           = 0x1B,
        TAF_POWER_CONSUMPTION           = 0x1C,
        TAF_DRIVE_MAINT_REQUEST         = 0x1D,
        TAF_HARDWARE_A                  = 0x1E,
        TAF_HARDWARE_B                  = 0x1F,
        TAF_INTERFACE                   = 0x20,
        TAF_EJECT_MEDIA                 = 0x21,
        TAF_DOWNLOAD_FAIL               = 0x22,
        TAF_DRIVE_HUMIDITY              = 0x23,
        TAF_DRIVE_TEMP                  = 0x24,
        TAF_DRIVE_VOLTAGE               = 0x25,
        TAF_PREDICTIVE_FAIL             = 0x26,
        TAF_DIAG_REQUIRED               = 0x27,
        TAF_LOADER_HDWR_A               = 0x28,
        TAF_LOADER_STRAY_TAPE           = 0x29,
        TAF_LOADER_HDWR_B               = 0x2A,
        TAF_LOADER_DOOR                 = 0x2B,
        TAF_LOADER_HDWR_C               = 0x2C,
        TAF_LOADER_MAGAZINE             = 0x2D,
        TAF_LOADER_PREDICTIVE_FAIL      = 0x2E,
        TAF_LOST_STATISTICS             = 0x32,
        TAF_TAPE_DIR_CURRUPT_UNLOAD     = 0x33,
        TAF_TAPE_SYS_WRT_FAIL           = 0x34,
        TAF_TAPE_SYS_RD_FAIL            = 0x35,
        TAF_NO_START_OF_DATA            = 0x36,
        TAF_WORM_INTEGRITY              = 0x3B,
        TAF_WORM_OVRWRT_ATTEMPT         = 0x3C
}tape_alert_flags;

/*
 * For ST_TYPE_STK9840 drives only. STK drive doesn't support retension
 * so they reuse TAF_RETENSION_REQUEST.
 */
#define CLEAN_FOR_ERRORS                 0x18


#define TAPE_ALERT_SUPPORT_UNKNOWN      0x00
#define TAPE_ALERT_NOT_SUPPORTED        0x01
#define TAPE_ALERT_SUPPORTED            0x02
#define TAPE_ALERT_STILL_DIRTY          0x04
#define TAPE_SEQUENTIAL_SUPPORTED       0x08
#define TAPE_PREVIOUSLY_DIRTY           0x10

#define TAPE_ALERT_MAX_PARA             64
#define TAPE_SEQUENTIAL_PAGE_PARA       64      /* way more then really used */
#define SEQUENTIAL_NEED_CLN             0x0100

/*
 * Parameters
 */
#define ST_NAMESIZE     44      /* size of pretty string for vid/pid */
#define VIDLEN          8       /* size of vendor identifier length */
#define PIDLEN          16      /* size of product identifier length */
#define VIDPIDLEN       (VIDLEN + PIDLEN)


struct st_drivetype {
        char    name[ST_NAMESIZE];      /* Name, for debug */
        char    length;                 /* Length of vendor id */
        char    vid[VIDPIDLEN];         /* Vendor id and model (product) id */
        char    type;                   /* Drive type for driver */
        int     bsize;                  /* Block size */
        int     options;                /* Drive options */
        int     max_rretries;           /* Max read retries */
        int     max_wretries;           /* Max write retries */
        uchar_t densities[NDENSITIES];  /* density codes, low->hi */
        uchar_t default_density;        /* default density for this drive */
        uchar_t mediatype[NDENSITIES];  /* was speed. mediatype for density. */
        ushort_t non_motion_timeout;    /* Inquiry type commands */
        ushort_t io_timeout;            /* I/O timeout in seconds */
        ushort_t rewind_timeout;        /* rewind timeout in seconds */
        ushort_t space_timeout;         /* space cmd timeout in seconds */
        ushort_t load_timeout;          /* load tape time in seconds */
        ushort_t unload_timeout;        /* unload tape time in seconds */
        ushort_t erase_timeout;         /* erase timeout. seconds */
};

#define MINUTES(val)    ((val) * 60)

struct comp_mode_page {
#if defined(_BIT_FIELDS_LTOH)
        uchar_t :               6,
                dcc:            1,      /* Data Compression Capable */
                dce:            1;      /* Data Compression Enable */
        uchar_t :               5,
                red:            2,      /* Report Exceptions on Decompress */
                dde:            1;      /* Data Decompression Enabled */
        uchar_t comp_alg_msb;           /* Compression Algorithm */
        uchar_t comp_alg_high;
        uchar_t comp_alg_low;
        uchar_t comp_alg_lsb;
        uchar_t decomp_alg_msb;         /* Decompression Algorithm */
        uchar_t decomp_alg_high;
        uchar_t decomp_alg_low;
        uchar_t decomp_alg_lsb;
        uchar_t reservered0;
        uchar_t reservered1;
        uchar_t reservered2;
        uchar_t reservered3;

#elif defined(_BIT_FIELDS_HTOL)
        uchar_t dce:            1,      /* Data Compression Enable */
                dcc:            1,      /* Data Compression Capable */
                :               6;
        uchar_t dde:            1,      /* Data Decompression Enabled */
                red:            2,      /* Report Exceptions on Decompress */
                :               5;
        uchar_t comp_alg_msb;           /* Compression Algorithm */
        uchar_t comp_alg_high;
        uchar_t comp_alg_low;
        uchar_t comp_alg_lsb;
        uchar_t decomp_alg_msb;         /* Decompression Algorithm */
        uchar_t decomp_alg_high;
        uchar_t decomp_alg_low;
        uchar_t decomp_alg_lsb;
        uchar_t reservered0;
        uchar_t reservered1;
        uchar_t reservered2;
        uchar_t reservered3;
#endif
};

struct dev_mode_page {
#if defined(_BIT_FIELDS_LTOH)
        uchar_t act_format:     5,      /* active format */
                caf:            1,      /* Change Active Format */
                cap:            1,      /* Change Active Partition OBSOLETE */
                :               1;
        uchar_t act_partition;          /* active partition */
        uchar_t wrt_buf_full_ratio;     /* write buffer full ratio */
        uchar_t rd_buf_full_ratio;      /* read buffer full ratio */
        uchar_t wrt_delay_time_msb;     /* write delay time MSB */
        uchar_t wrt_delay_time_lsb;     /* write delay time LSB */
        uchar_t rew:            1,      /* Report Early Warning */
                robo:           1,      /* Reverse Object Buffer Order */
                socf:           2,      /* Stop On Consecutive Filemarks */
                avc:            1,      /* Automatic Velocity Control */
                rsmk:           1,      /* Report SetMarKs OBSOLETE */
                lois:           1,      /* Logical Object Identifiers Support */
                obr:            1;      /* Object Buffer Recovery */
        uchar_t gap_size;               /* OBSOLETE */
        uchar_t bam:            1,      /* Block Address Mode */
                bmal:           1,      /* Block Address Mode Lock */
                swp:            1,      /* Software Write Protection */
                sew:            1,      /* Sync data after Early Warning */
                eeg:            1,      /* Enable Early Waring */
                eod_defined:    3;
        uchar_t buf_size_leot_msb;      /* Buffer size after early warning */
        uchar_t buf_size_leot_mid;
        uchar_t buf_size_leot_lsb;
        uchar_t comp_alg;               /* Compression Algorithm (enable) */
        uchar_t prmwp:          1,      /* PeRManent Write Protect */
                perswp:         1,      /* persistant write protection */
                asocwp:         1,      /* associated write protect */
                rew_on_rst:     2,      /* rewind on reset */
                oir:            1,      /* Only If Reserved */
                wtre:           2;      /* Worm Tamper Read Enable */

#elif defined(_BIT_FIELDS_HTOL)
        uchar_t :               1,
                cap:            1,      /* Change Active Partition OBSOLETE */
                caf:            1,      /* Change Active Format */
                act_format:     5;      /* active format */
        uchar_t act_partition;          /* active partition */
        uchar_t wrt_buf_full_ratio;     /* write buffer full ratio */
        uchar_t rd_buf_full_ratio;      /* read buffer full ratio */
        uchar_t wrt_delay_time_msb;     /* write delay time MSB */
        uchar_t wrt_delay_time_lsb;     /* write delay time LSB */
        uchar_t obr:            1,      /* Object Buffer Recovery */
                lois:           1,      /* Logical Object Identifiers Support */
                rsmk:           1,      /* Report SetMarKs OBSOLETE */
                avc:            1,      /* Automatic Velocity Control */
                socf:           2,      /* Stop On Consecutive Filemarks */
                robo:           1,      /* Reverse Object Buffer Order */
                rew:            1;      /* Report Early Warning */
        uchar_t gap_size;               /* OBSELETE */
        uchar_t eod_defined:    3,
                eeg:            1,      /* Enable Early Waring */
                sew:            1,      /* Sync data after Early Warning */
                swp:            1,      /* Software Write Protection */
                bmal:           1,      /* Block Address Mode Lock */
                bam:            1;      /* Block Address Mode */
        uchar_t buf_size_leot_msb;      /* Buffer size after early warning */
        uchar_t buf_size_leot_mid;
        uchar_t buf_size_leot_lsb;
        uchar_t comp_alg;               /* Compression Algorithm (enable) */
        uchar_t wtre:           2,      /* Worm Tamper Read Enable */
                oir:            1,      /* Only If Reserved */
                rew_on_rst:     2,      /* rewind on reset */
                asocwp:         1,      /* associated write protect */
                perswp:         1,      /* persistant write protection */
                prmwp:          1;      /* PeRManent Write Protect */
#endif
};

struct sas_lun_mode {
#if defined(_BIT_FIELDS_HTOL)
        uchar_t :               3,
                tran_layer_ret: 1,
                protocol_id:    4;
        uchar_t reserved[5];
#elif defined(_BIT_FIELDS_LTOH)
        uchar_t protocol_id:    4,
                tran_layer_ret: 1,
                :               3;
        uchar_t reserved[5];
#endif
};
typedef union {
        struct comp_mode_page   comp;
        struct dev_mode_page    dev;
        struct sas_lun_mode     saslun;
}modepage;

/*
 *
 * Parameter list for the MODE_SELECT and MODE_SENSE commands.
 * The parameter list contains a header, followed by zero or more
 * block descriptors, followed by vendor unique parameters, if any.
 *
 */
#define MSIZE   0x0c            /* Size without additional pages */
struct seq_mode {
#if defined(_BIT_FIELDS_LTOH)
        uchar_t data_len;       /* sense data length, sense only */
        uchar_t media_type;     /* medium type, sense only */
        uchar_t speed   :4,     /* speed */
                bufm    :3,     /* buffered mode */
                wp      :1;     /* write protected, sense only */
        uchar_t bd_len;         /* block length in bytes */
        uchar_t density;        /* density code */
        uchar_t high_nb;        /* number of logical blocks on the medium */
        uchar_t mid_nb;         /* that are to be formatted with the density */
        uchar_t low_nb;         /* code and block length in block descriptor */
        uchar_t reserved;       /* reserved */
        uchar_t high_bl;        /* block length */
        uchar_t mid_bl;         /*   "      "   */
        uchar_t low_bl;         /*   "      "   */
        uchar_t page_code:      6,
                :               1,
                ps:             1; /* Page Savable sense only */
        uchar_t page_len;
        modepage page;

#elif defined(_BIT_FIELDS_HTOL)
        uchar_t data_len;       /* sense data length, sense only */
        uchar_t media_type;     /* medium type, sense only */
        uchar_t wp      :1,     /* write protected, sense only */
                bufm    :3,     /* buffered mode */
                speed   :4;     /* speed */
        uchar_t bd_len;         /* block length in bytes */
        uchar_t density;        /* density code */
        uchar_t high_nb;        /* number of logical blocks on the medium */
        uchar_t mid_nb;         /* that are to be formatted with the density */
        uchar_t low_nb;         /* code and block length in block descriptor */
        uchar_t reserved;       /* reserved */
        uchar_t high_bl;        /* block length */
        uchar_t mid_bl;         /*   "      "   */
        uchar_t low_bl;         /*   "      "   */
        uchar_t ps:             1, /* Page Savable sense only */
                :               1,
                page_code:      6;
        uchar_t page_len;
        modepage page;
#else
#error  One of _BIT_FIELDS_LTOH or _BIT_FIELDS_HTOL must be defined
#endif  /* _BIT_FIELDS_LTOH */
};

/*
 * One_command parameter data for REPORT SUPPORTED OPERATION CODES.
 */
struct one_com_des {
#if defined(_BIT_FIELDS_LTOH)
        uchar_t reserved0;
        uchar_t support:        3,      /* support value */
                reserved1:      4,
                ctdp:           1;      /* cmd timeouts descriptor present */
        ushort_t cdb_size;              /* cdb size */
        uchar_t usage[CDB_GROUP4];      /* 16 bytes, the largest CDB group */
#elif defined(_BIT_FIELDS_HTOL)
        uchar_t reserved0;
        uchar_t ctdp:           1,      /* cmd timeouts descriptor present */
                reserved1:      4,
                support:        3;      /* support value */
        ushort_t cdb_size;              /* cdb size */
        uchar_t usage[CDB_GROUP4];      /* 16 bytes, the largest CDB group */
#else
#error  One of _BIT_FIELDS_LTOH or _BIT_FIELDS_HTOL must be defined
#endif /* _BIT_FIELDS_LTOH */
};

/*
 * Command timeouts descriptor
 */
struct com_timeout_des {
        ushort_t des_len;       /* descriptor length */
        uchar_t reserved;
        uchar_t com_spe;        /* command specific */
        uint_t nom_timeout;     /* nominal command processing timeout */
        uint_t rec_timeout;     /* recommended command timeout */
};

/*
 * Reporting options
 */
#define ALL_COMMAND_DATA_FORMAT                 0
#define ONE_COMMAND_NO_SERVICE_DATA_FORMAT      1
#define ONE_COMMAND_DATA_FORMAT                 2

/*
 * Support values in One_command parameter data
 */
#define SUPPORT_VALUES_NOT_AVAILABLE            0
#define SUPPORT_VALUES_NOT_SUPPORT              1
#define SUPPORT_VALUES_SUPPORT_SCSI             3
#define SUPPORT_VALUES_SUPPORT_VENDOR           5

/*
 * Parameter data for REPORT DENSITY SUPPORT command
 */
struct report_density_header {
        ushort_t ava_dens_len;          /* available density support length */
        uchar_t reserved0;
        uchar_t reserved1;
};

struct report_density_desc {
#if defined(_BIT_FIELDS_LTOH)
        uchar_t pri_den;                /* primary density code */
        uchar_t sec_den;                /* secondary density code */
        uchar_t dlv:1;                  /* descriptor length valid */
        uchar_t reserved:4;
        uchar_t deflt:1;                /* is default density */
        uchar_t dup:1;                  /* pri density has one descriptor */
        uchar_t wrtok:1;                /* support writing to media */
        uchar_t desc_len_hi;            /* descriptor length high */
        uchar_t desc_len_low;           /* descriptor length low */
        uchar_t bits_per_mm[3];         /* bits per mm */
        uchar_t media_width_hi;         /* media width high */
        uchar_t media_width_low;        /* media width low */
        ushort_t tracks;                /* tracks */
        uint_t capacity;                /* capacity */
        uchar_t ass_org[8];             /* assigning organization */
        uchar_t den_name[8];            /* density name */
        uchar_t description[20];        /* description */
#elif defined(_BIT_FIELDS_HTOL)
        uchar_t pri_den;                /* primary density code */
        uchar_t sec_den;                /* secondary density code */
        uchar_t wrtok:1;                /* support writing to media */
        uchar_t dup:1;                  /* pri density has one descriptor */
        uchar_t deflt:1;                /* is default density */
        uchar_t reserved:4;
        uchar_t dlv:1;                  /* descriptor length valid */
        uchar_t desc_len_hi;            /* descriptor length high */
        uchar_t desc_len_low;           /* descriptor length low */
        uchar_t bits_per_mm[3];         /* bits per mm */
        uchar_t media_width_hi;         /* media width high */
        uchar_t media_width_low;        /* media width low */
        ushort_t tracks;                /* tracks */
        uint_t capacity;                /* capacity */
        uchar_t ass_org[8];             /* assigning organization */
        uchar_t den_name[8];            /* density name */
        uchar_t description[20];        /* description */
#else
#error  One of _BIT_FIELDS_LTOH or _BIT_FIELDS_HTOL must be defined
#endif  /* _BIT_FIELDS_LTOH */
};

/*
 * Data returned from the READ BLOCK LIMITS command.
 */

#define RBLSIZE (sizeof (struct read_blklim))
struct read_blklim {
#if defined(_BIT_FIELDS_HTOL)
        uchar_t reserved:       3;      /* reserved */
        uchar_t granularity:    5;      /* Minimum Modularity */
#elif defined(_BIT_FIELDS_LTOH)
        uchar_t granularity:    5;      /* Minimum Modularity */
        uchar_t reserved:       3;      /* reserved */
#endif
        uchar_t max_hi;                 /* Maximum block length, high byte */
        uchar_t max_mid;                /* Maximum block length, middle byte */
        uchar_t max_lo;                 /* Maximum block length, low byte */
        uchar_t min_hi;                 /* Minimum block length, high byte */
        uchar_t min_lo;                 /* Minimum block length, low byte */
};

/*
 * operation codes
 */
typedef enum {
        ST_OP_NIL,
        ST_OP_CTL,
        ST_OP_READ,
        ST_OP_WRITE,
        ST_OP_WEOF
}optype;

/*
 * eof/eot/eom codes.
 */
typedef enum {
        ST_NO_EOF,
        ST_EOF_PENDING,         /* filemark pending */
        ST_EOF,                 /* at filemark */
        ST_EOT_PENDING,         /* logical eot pending */
        ST_EOT,                 /* at logical eot */
        ST_EOM,                 /* at physical eot */
        ST_WRITE_AFTER_EOM      /* flag for allowing writes after EOM */
}pstatus;

typedef enum { invalid, legacy, logical } posmode;

typedef struct tapepos {
        uint64_t lgclblkno;
        int32_t fileno;
        int32_t blkno;
        int32_t partition;
        pstatus eof;                    /* eof states */
        posmode pmode;
        uint32_t: 32;
}tapepos_t;

/* byte 1 of cdb for type of read position command */
typedef enum {
        SHORT_POS       = 0,
        LONG_POS        = 6,
        EXT_POS         = 8,
        NO_POS          = 0xff  /* Drive doesn't support read position */
} read_p_types;


/*
 * Data returned from the READ POSITION command.
 */

typedef struct tape_position {
#if defined(_BIT_FIELDS_HTOL)
        uchar_t begin_of_part:  1;
        uchar_t end_of_part:    1;
        uchar_t blk_cnt_unkwn:  1;
        uchar_t byte_cnt_unkwn: 1;
        uchar_t reserved0:      1;
        uchar_t blk_posi_unkwn: 1;
        uchar_t posi_err:       1;
        uchar_t reserved1:      1;
#elif defined(_BIT_FIELDS_LTOH)
        uchar_t reserved1:      1;
        uchar_t posi_err:       1;
        uchar_t blk_posi_unkwn: 1;
        uchar_t reserved0:      1;
        uchar_t byte_cnt_unkwn: 1;
        uchar_t blk_cnt_unkwn:  1;
        uchar_t end_of_part:    1;
        uchar_t begin_of_part:  1;
#endif
        uchar_t partition_number;
        uchar_t reserved2[2];
        uint32_t host_block;
        uint32_t media_block;
        uchar_t reserved3;
        uchar_t block_in_buff[3];
        uint32_t byte_in_buff;
}tape_position_t;


typedef struct tape_position_long {
#if defined(_BIT_FIELDS_HTOL)
        uint32_t begin_of_part: 1;
        uint32_t end_of_part:   1;
        uint32_t reserved0:     2;
        uint32_t mrk_posi_unkwn:1;
        uint32_t blk_posi_unkwn:1;
        uint32_t reserved1:     2;
#elif defined(_BIT_FIELDS_LTOH)
        uint32_t reserved1:     2;
        uint32_t blk_posi_unkwn:1;
        uint32_t mrk_posi_unkwn:1;
        uint32_t reserved0:     2;
        uint32_t end_of_part:   1;
        uint32_t begin_of_part: 1;
#endif
        uint32_t reserved2:     24;
        uint32_t partition;
        uint64_t block_number;
        uint64_t file_number;
        uint64_t set_number;
}tape_position_long_t;

typedef struct tape_position_ext {
#if defined(_BIT_FIELDS_HTOL)
        uchar_t begin_of_part:  1;
        uchar_t end_of_part:    1;
        uchar_t blk_cnt_unkwn:  1;
        uchar_t byte_cnt_unkwn: 1;
        uchar_t mrk_posi_unkwn: 1;
        uchar_t blk_posi_unkwn: 1;
        uchar_t posi_err:       1;
        uchar_t reserved0:      1;

        uchar_t partition;
        uint16_t parameter_len;
/* start next word */
        uint32_t reserved1:     8;
        uint32_t blks_in_buf:   24;
#elif defined(_BIT_FIELDS_LTOH)
        uchar_t reserved0:      1;
        uchar_t posi_err:       1;
        uchar_t blk_posi_unkwn: 1;
        uchar_t mrk_posi_unkwn: 1;
        uchar_t byte_cnt_unkwn: 1;
        uchar_t blk_cnt_unkwn:  1;
        uchar_t end_of_part:    1;
        uchar_t begin_of_part:  1;

        uchar_t partition;
        uint16_t parameter_len;
/* start next word */
        uint32_t blks_in_buf:   24;
        uint32_t reserved1:     8;
#endif
        uint64_t host_block;
        uint64_t media_block;
        uint64_t byte_in_buf;
}tape_position_ext_t;

typedef union {
        tape_position_t srt;
        tape_position_ext_t ext;
        tape_position_long_t lng;
}read_pos_data_t;

typedef struct {
        unsigned char cmd;
        unsigned char
                requires_reserve:       1,      /* reserve must be done */
                retriable:              1,      /* can be retried */
                chg_tape_pos:           1,      /* position will change */
                chg_tape_data:          1,      /* data on media will change */
                explicit_cmd_set:       1,      /* explicit command set */
                /*
                 * 0 doesn't, 1 forward,
                 * 2 back, 3 either
                 */
                chg_tape_direction:     2;      /* direction of pos change */
#define DIR_NONE        0
#define DIR_FORW        1
#define DIR_REVC        2
#define DIR_EITH        3
        unsigned char
                /*
                 * 0 doesn't 1 read, 2 write
                 */
                transfers_data:         2,
#define TRAN_NONE       0
#define TRAN_READ       1
#define TRAN_WRTE       2
                recov_pos_type:         1,
#define POS_EXPECTED    0
#define POS_STARTING    1
                do_not_recover:         1;
        uchar_t reserve_byte;
        uint32_t reserve_mask;
        uint64_t (*get_cnt)(uchar_t *);
        uint64_t (*get_lba)(uchar_t *);
}cmd_attribute;

typedef struct {
        buf_t *cmd_bp;
        size_t privatelen;
        int str_retry_cnt;
        int pkt_retry_cnt;
}pkt_info;

typedef struct {
        buf_t *cmd_bp;
        size_t privatelen;
        int str_retry_cnt;
        int pkt_retry_cnt;
        tapepos_t pos;
        const cmd_attribute *cmd_attrib;
}recov_info;

#ifdef _KERNEL

#ifdef  __x86
/* Data structure used in big block I/O on x86/x64 platform */

/*
 * alloc more than one contig_mem, so mutiple I/O can be
 * on-going simultaneously
 */
#define ST_MAX_CONTIG_MEM_NUM   3

struct contig_mem {
        struct contig_mem *cm_next;
        size_t cm_len;
        caddr_t cm_addr;
        ddi_acc_handle_t cm_acc_hdl;
        struct buf *cm_bp;
        int cm_use_sbuf;
};

#endif

#endif /* _KERNEL */

/*
 * driver states..
 */
typedef enum {
        ST_STATE_CLOSED,
        ST_STATE_OFFLINE,
        ST_STATE_INITIALIZING,
        ST_STATE_OPENING,
        ST_STATE_OPEN_PENDING_IO,
        ST_STATE_APPEND_TESTING,
        ST_STATE_OPEN,
        ST_STATE_RESOURCE_WAIT,
        ST_STATE_CLOSING,
        ST_STATE_SENSING,
        ST_STATE_CLOSE_PENDING_OPEN
}st_states;

typedef enum { RDWR, RDONLY, WORM, RDWORM, FAILED } writablity;
typedef enum {
        TLR_NOT_KNOWN,
        TLR_NOT_SUPPORTED,
        TLR_SAS_ONE_DEVICE,
        TLR_SAS_TWO_DEVICE
}st_tlr_state;


/*
 * Private info for scsi tapes. Pointed to by the un_private pointer
 * of one of the SCSI_DEVICE chains.
 */

struct scsi_tape {
        struct scsi_device *un_sd;      /* back pointer to SCSI_DEVICE */
        struct scsi_pkt *un_rqs;        /* ptr to request sense command */
        struct scsi_pkt *un_mkr_pkt;    /* ptr to marker packet */
        kcondvar_t un_sbuf_cv;          /* cv on ownership of special buf */
        kcondvar_t un_queue_cv;         /* cv on all queued commands */
        struct  buf *un_sbufp;          /* for use in special io */
        char    *un_srqbufp;            /* sense buffer for special io */
        kcondvar_t un_clscv;            /* closing cv */
        struct  buf *un_quef;           /* head of wait queue */
        struct  buf *un_quel;           /* tail of wait queue */
        struct  buf *un_runqf;          /* head of run queue */
        struct  buf *un_runql;          /* tail of run queue */
        struct seq_mode *un_mspl;       /* ptr to mode select info */
        struct st_drivetype *un_dp;     /* ptr to drive table entry */
        uint_t  un_dp_size;             /* size of un_dp alloc'ed */
        caddr_t un_tmpbuf;              /* buf for append, autodens ops */
        tapepos_t un_pos;               /* Current tape position */
        int     un_oflags;              /* open flags */
        tapepos_t un_err_pos;           /* block in file where err occurred */
        uint_t  un_err_resid;           /* resid from last error */
        short   un_fmneeded;            /* filemarks to be written - HP only */
        dev_t   un_dev;                 /* unix device */
        uchar_t un_attached;            /* unit known && attached */
        int     un_pwr_mgmt;            /* power management state */
        uchar_t un_density_known;       /* density is known */
        uchar_t un_curdens;             /* index into density table */
        optype  un_lastop;              /* last I/O was: read/write/ctl */
        st_states un_laststate;         /* last state */
        st_states un_state;             /* current state */
        uchar_t un_status;              /* status from last sense */
        uchar_t un_retry_ct;            /* retry count */
        writablity un_read_only;        /* RDWR, RDONLY, WORM, RDWORM */
        uchar_t un_test_append;         /* check writing at end of tape */
        uchar_t un_arq_enabled;         /* auto request sense enabled */
        uchar_t un_untagged_qing;       /* hba has untagged quing */
        uchar_t un_allow_large_xfer;    /* allow >64k xfers if requested */
        uchar_t un_sbuf_busy;           /* sbuf busy flag */
        uchar_t un_ncmds;               /* number of commands outstanding */
        uchar_t un_throttle;            /* curr. max number of cmds outst. */
        uchar_t un_last_throttle;       /* saved max number of cmds outst. */
        uchar_t un_max_throttle;        /* max poss. number cmds outstanding */
        uchar_t un_persistence;         /* 1 = persistence on, 0 off */
        uchar_t un_persist_errors;      /* 1 = persistenced flagged */
        uchar_t un_flush_on_errors;     /* HBA will flush all I/O's on a */
                                        /* check condidtion or error */
        uint_t  un_kbytes_xferred;      /* bytes (in K) counter */
        uint_t  un_last_resid;          /* keep last resid, for PE */
        uint_t  un_last_count;          /* keep last count, for PE */
        struct  kstat *un_stats;        /* for I/O statistics */
        struct buf *un_rqs_bp;          /* bp used in rqpkt */
        struct  buf *un_wf;             /* head of write queue */
        struct  buf *un_wl;             /* tail of write queue */
        struct  read_blklim *un_rbl;    /* ptr to read block limit info */
        int     un_maxdma;              /* max dma xfer allowed by HBA */
        uint_t  un_bsize;               /* block size currently being used */
        int     un_maxbsize;            /* max block size allowed by drive */
        uint_t  un_minbsize;            /* min block size allowed by drive */
        int     un_errno;               /* errno (b_error) */
        kcondvar_t      un_state_cv;    /* mediastate condition variable */
        enum mtio_state un_mediastate;  /* current media state */
        enum mtio_state un_specified_mediastate;        /* expected state */
        timeout_id_t    un_delay_tid;   /* delayed cv tid */
        timeout_id_t    un_hib_tid;     /* handle interrupt busy tid */
        opaque_t        un_swr_token;   /* scsi_watch request token */
        uchar_t un_comp_page;           /* compression page */
        uchar_t un_rsvd_status;         /* Reservation Status */
        kstat_t *un_errstats;           /* for error statistics */
        int     un_init_options;        /* Init time drive options */
        int     un_save_fileno;         /* Save here for recovery */
        daddr_t un_save_blkno;          /* Save here for recovery */
        uchar_t un_restore_pos;         /* Indication to do recovery */
        tapepos_t un_suspend_pos;       /* Save blkno for SUSPEND */
        uchar_t un_silent_skip;         /* to catch short reads */
        short   un_tids_at_suspend;     /* timeouts set at suspend */
        kcondvar_t un_tape_busy_cv;     /* busy cv */
        kcondvar_t un_suspend_cv;       /* busy cv */
                                        /* restore on close */
        uchar_t un_eject_tape_on_failure; /* 1 = eject tape, 0 = don't */
        uchar_t un_HeadClean;           /* support and need head cleaning? */
        uchar_t un_rqs_state;           /* see define below */
        struct scsi_extended_sense
            *un_uscsi_rqs_buf;          /* uscsi_rqs: buffer for RQS data */
        uchar_t un_data_mod;            /* Device required data mod */
        writablity (*un_wormable) (struct scsi_tape *un); /* worm test fuct */
        int un_max_cdb_sz;              /* max cdb size to use */
        read_p_types un_read_pos_type;
        read_pos_data_t *un_read_pos_data;
        struct mterror_entry_stack *un_error_entry_stk;
                                        /* latest sense cmd buffer */
#ifdef  __x86
        ddi_dma_handle_t un_contig_mem_hdl;
        struct contig_mem *un_contig_mem;
        int un_contig_mem_available_num;
        int un_contig_mem_total_num;
        size_t un_max_contig_mem_len;
        kcondvar_t un_contig_mem_cv;
        int un_maxdma_arch;             /* max dma xfer allowed by HBA & arch */
#endif
        caddr_t un_media_id;
        int un_media_id_len;
        int (*un_media_id_method)(struct scsi_tape *, int (*)());
        buf_t *un_recov_buf;            /* buf to recover failed commands */
        kcondvar_t un_recov_buf_cv;     /* cv for buf un_recov_buf */
        uchar_t un_recov_buf_busy;
#ifdef _KERNEL
        ddi_taskq_t *un_recov_taskq;
#else
        void *un_recov_taskq;
#endif
        tapepos_t un_running;
        uchar_t un_unit_attention_flags;
        uchar_t un_multipath;
        ulong_t un_last_path_instance;
        st_tlr_state un_tlr_flag;               /* tape support TLR flag */
};

typedef int (*bufunc_t)(struct scsi_tape *, int, int64_t, int);
typedef int (*ubufunc_t)(struct scsi_tape *, struct uscsi_cmd *, int);


/*
 * device error kstats
 */
struct st_errstats {
        struct kstat_named      st_softerrs;
        struct kstat_named      st_harderrs;
        struct kstat_named      st_transerrs;
        struct kstat_named      st_vid;
        struct kstat_named      st_pid;
        struct kstat_named      st_revision;
        struct kstat_named      st_serial;
};

/*
 * generic log page struct
 */
struct log_page {
#if defined(_BIT_FIELDS_LTOH)
        uchar_t code    :6,     /* page code number */
                        :2;     /* reserved */
#elif defined(_BIT_FIELDS_HTOL)
        uchar_t         :2,     /* reserved */
                code    :6;     /* page code number */
#endif  /* _BIT_FIELDS_LTOH */
        uchar_t reserved;       /* reserved */
        uchar_t length_hi;      /* length of bytes to follow (msb) */
        uchar_t length_lo;      /* length of bytes to follow (lsb) */
        /*
         * Log parameters follow right after this...
         */
};

/*
 * generic log page parameter struct
 */
struct log_param {
        uchar_t pc_hi;                  /* parameter code (msb) */
        uchar_t pc_lo;                  /* parameter code (lsb) */
#if defined(_BIT_FIELDS_LTOH)
        uchar_t         lp      : 1,    /* list parameter */
                                : 1,    /* reserved */
                        tmc     : 2,    /* threshold met criteria */
                        etc     : 1,    /* enable threshold comparison */
                        tsd     : 1,    /* target save disable */
                        ds      : 1,    /* disable save */
                        du      : 1;    /* disable update */
#elif defined(_BIT_FIELDS_HTOL)
        uchar_t         du      : 1,    /* disable update */
                        ds      : 1,    /* disable save */
                        tsd     : 1,    /* target save disable */
                        etc     : 1,    /* enable threshold comparison */
                        tmc     : 2,    /* threshold met criteria */
                                : 1,    /* reserved */
                        lp      : 1;    /* list parameter */
#endif  /* _BIT_FIELDS_LTOH */
        uchar_t length;         /* length of bytes to follow */
        /*
         * Parameter values follow right after this...
         */
};
/*
 * TapeAlert structures
 */

struct st_tape_alert_parameter {
        struct log_param log_param;
        uchar_t param_value;
};

struct st_tape_alert {
        struct log_page log_page;
        struct st_tape_alert_parameter param[TAPE_ALERT_MAX_PARA];
};

#define TAPE_ALERT_PARAMETER_LENGTH \
        (sizeof (struct st_tape_alert_parameter)) * TAPE_ALERT_MAX_PARA

struct log_sequential_page_parameter {
        struct log_param log_param;
        uchar_t param_value[8];
};

struct log_sequential_page {
        struct log_page log_page;
        struct log_sequential_page_parameter param[TAPE_SEQUENTIAL_PAGE_PARA];
};

#if !defined(__lint)
_NOTE(MUTEX_PROTECTS_DATA(scsi_device::sd_mutex, scsi_tape))
_NOTE(SCHEME_PROTECTS_DATA("stable data", scsi_tape::un_dp))
_NOTE(SCHEME_PROTECTS_DATA("stable data", scsi_tape::un_sd))
_NOTE(SCHEME_PROTECTS_DATA("not shared", scsi_tape::un_rqs))
_NOTE(SCHEME_PROTECTS_DATA("protected by cv", scsi_tape::un_sbufp))
_NOTE(DATA_READABLE_WITHOUT_LOCK(scsi_tape::un_bsize))
_NOTE(SCHEME_PROTECTS_DATA("not shared", scsi_arq_status))
_NOTE(SCHEME_PROTECTS_DATA("save sharing",
        scsi_tape::un_allow_large_xfer
        scsi_tape::un_maxbsize
        scsi_tape::un_maxdma
))
#ifdef  __x86
_NOTE(DATA_READABLE_WITHOUT_LOCK(scsi_tape::un_contig_mem_hdl))
_NOTE(SCHEME_PROTECTS_DATA("not shared", contig_mem))
#endif
#endif


/*
 * Power management state
 */
#define ST_PWR_NORMAL                           0
#define ST_PWR_SUSPENDED                        1


#define IN_EOF(pos)     (pos.eof == ST_EOF_PENDING || pos.eof == ST_EOF)

/* un_rqs_state codes */

#define ST_RQS_OVR              0x1     /* RQS data was overwritten */
#define ST_RQS_VALID            0x2     /* RQS data is valid */
#define ST_RQS_READ             0x4     /* RQS data was read */
#define ST_RQS_ERROR            0x8     /* RQS resulted in an EIO */

/*
 * st_intr codes
 */
typedef enum {
        COMMAND_DONE,
        COMMAND_DONE_ERROR,
        COMMAND_DONE_ERROR_RECOVERED,
        QUE_COMMAND,
        QUE_BUSY_COMMAND,
        QUE_SENSE,
        JUST_RETURN,
        COMMAND_DONE_EACCES,
        QUE_LAST_COMMAND,
        COMMAND_TIMEOUT,
        PATH_FAILED,
        DEVICE_RESET,
        DEVICE_TAMPER,
        ATTEMPT_RETRY
}errstate;
#ifdef _KERNEL
typedef struct {
        struct scsi_arq_status  ei_failing_status;
        tapepos_t               ei_expected_pos;
        errstate                ei_error_type;
        buf_t                   *ei_failing_bp;
        struct scsi_pkt         ei_failed_pkt;          /* must be last */
                                                        /* ...scsi_pkt_size() */
} st_err_info;
#define ST_ERR_INFO_SIZE        (sizeof (st_err_info) - \
                                sizeof (struct scsi_pkt) + scsi_pkt_size())
#endif


/*
 *      Reservation Status
 *
 * ST_INIT_RESERVE      -Used to check if the reservation has been lost
 *                       in between opens and also to indicate the reservation
 *                       has not been done till now.
 * ST_RELEASE           -Tape Unit is Released.
 * ST_RESERVE           -Tape Unit is Reserved.
 * ST_PRESERVE_RESERVE  -Reservation is to be preserved across opens.
 *
 */
#define ST_INIT_RESERVE                 0x001
#define ST_RELEASE                      0x002
#define ST_RESERVE                      0x004
#define ST_PRESERVE_RESERVE             0x008
#define ST_RESERVATION_CONFLICT         0x010
#define ST_LOST_RESERVE                 0x020
#define ST_APPLICATION_RESERVATIONS     0x040
#define ST_INITIATED_RESET              0x080
#define ST_LOST_RESERVE_BETWEEN_OPENS  \
                (ST_RESERVE | ST_LOST_RESERVE | ST_PRESERVE_RESERVE)

/*
 * Service action defines for Persistant Reservation Commands
 */
#define ST_SA_SCSI3_REGISTER                    0x00
#define ST_SA_SCSI3_RESERVE                     0x01
#define ST_SA_SCSI3_RELEASE                     0x02
#define ST_SA_SCSI3_CLEAR                       0x03
#define ST_SA_SCSI3_PREEMPT                     0x04
#define ST_SA_SCSI3_PREEMPTANDABORT             0x05
#define ST_SA_SCSI3_REGISTERANDIGNOREKEY        0x06
#define ST_SA_MASK                              0x1f

#define ST_RESERVATION_DELAY            500000

/*
 * Asynch I/O tunables
 */
#define ST_MAX_THROTTLE         4

/*
 * 60 minutes seems a reasonable amount of time
 * to wait for tape space operations to complete.
 *
 */
#define ST_SPACE_TIME   MINUTES(60)     /* 60 minutes per space operation */
#define ST_LONG_SPACE_TIME_X    5       /* multipiler for long space ops */

/*
 * 2 minutes seems a reasonable amount of time
 * to wait for tape i/o operations to complete.
 *
 */
#define ST_IO_TIME      MINUTES(2)      /* minutes per i/o */
#define ST_LONG_TIMEOUT_X       5       /* multiplier for very long timeouts */


/*
 * 10 seconds is what we'll wait if we get a Busy Status back
 */
#define ST_STATUS_BUSY_TIMEOUT  10*hz   /* seconds Busy Waiting */
#define ST_TRAN_BUSY_TIMEOUT    4*hz    /* seconds retry on TRAN_BSY */
#define ST_INTERRUPT_CONTEXT    1
#define ST_START_CONTEXT        2

/*
 * Number of times we'll retry a normal operation.
 *
 * XXX This includes retries due to transport failure as well as
 * XXX busy timeouts- Need to distinguish between Target and Transport
 * XXX failure.
 */

#define ST_RETRY_COUNT          20

/*
 * Number of times to retry a failed selection
 */
#define ST_SEL_RETRY_COUNT              2

/*
 * es_code value for deferred error
 * should be moved to sense.h
 */

#define ST_DEFERRED_ERROR               0x01

/*
 * Maximum number of units (determined by minor device byte)
 */
#define ST_MAXUNIT      128

/*
 * Time to wait for completion of a command before cancelling it.
 * For SUSPEND use only
 */
#define ST_WAIT_CMDS_COMPLETE           10      /* seconds */

#ifndef SECSIZE
#define SECSIZE 512
#endif
#ifndef SECDIV
#define SECDIV  9
#endif

/*
 * convenient defines
 */
#define ST_SCSI_DEVP            (un->un_sd)
#define ST_DEVINFO              (ST_SCSI_DEVP->sd_dev)
#define ST_INQUIRY              (ST_SCSI_DEVP->sd_inq)
#define ST_RQSENSE              (ST_SCSI_DEVP->sd_sense)
#define ST_MUTEX                (&ST_SCSI_DEVP->sd_mutex)
#define ROUTE                   (&ST_SCSI_DEVP->sd_address)

#define BSD_BEHAVIOR    (getminor(un->un_dev) & MT_BSD)
#define SVR4_BEHAVIOR   ((getminor(un->un_dev) & MT_BSD) == 0)
#define ST_STATUS_MASK  (STATUS_MASK | STATUS_TASK_ABORT)
#define SCBP(pkt)               ((struct scsi_status *)(pkt)->pkt_scbp)
#define SCBP_C(pkt)             ((*(pkt)->pkt_scbp) & ST_STATUS_MASK)
#define CDBP(pkt)               ((union scsi_cdb *)(pkt)->pkt_cdbp)
#define BP_PKT(bp)              ((struct scsi_pkt *)(bp)->av_back)
#define SET_BP_PKT(bp, pkt)     ((bp)->av_back = (struct buf *)(pkt))
#define BP_UCMD(bp)             ((struct uscsi_cmd *)(bp)->b_back)
#define USCSI_CMD(bp)   (((bp) == un->un_sbufp) && (BP_UCMD(bp)))

#define IS_CLOSING(un)  ((un)->un_state == ST_STATE_CLOSING || \
        ((un)->un_state == ST_STATE_SENSING && \
                (un)->un_laststate == ST_STATE_CLOSING))

#define ASYNC_CMD       0
#define SYNC_CMD        1

#define st_bioerror(bp, error) \
                { bioerror(bp, error); \
                un->un_errno = error; }

/*
 * Macros for internal coding of count for SPACE command:
 *
 * Top 3 bits of b_bcount define direction and type of space.
 * Since b_bcount (size_t) is 32 bits on 32 platforms and 64 bits on
 * 64 bit platforms different defines are used.
 * if SP_BACKSP is set direction is backward (toward BOP)
 * The type of space (Blocks, Filemark or sequential filemarks) is
 * carried in the next 2 bits. The remaining bits a signed count of
 * how many of that direction and type to do.
 */

#if (defined(__lock_lint))
/*
 * This is a workaround for warlock not being able to parse an #ULL constant.
 */
#undef  UINT64_MAX
#define UINT64_MAX      (18446744073709551615UL)
#endif /* __lock_lint */

#if (defined(__lock_lint) || (SIZE_MAX < UINT64_MAX))

#define SP_BLK          UINT32_C(0x00000000)
#define SP_FLM          UINT32_C(0x20000000)
#define SP_SQFLM        UINT32_C(0x40000000)
#define SP_EOD          UINT32_C(0x60000000)
#define SP_BACKSP       UINT32_C(0x80000000)
#define SP_CMD_MASK     UINT32_C(0x60000000)
#define SP_CNT_MASK     UINT32_C(0x1fffffff)

/* Macros to interpret space cmds */
#define SPACE_CNT(x)    (((x) & SP_BACKSP)? \
        (-((x)&(SP_CNT_MASK))):(x)&(SP_CNT_MASK))
#define SPACE_TYPE(x)   ((x & SP_CMD_MASK)>>29)

#else /* end of small size_t in buf_t */

#define SP_BLK          UINT64_C(0x0000000000000000)
#define SP_FLM          UINT64_C(0x2000000000000000)
#define SP_SQFLM        UINT64_C(0x4000000000000000)
#define SP_EOD          UINT64_C(0x6000000000000000)
#define SP_BACKSP       UINT64_C(0x8000000000000000)
#define SP_CMD_MASK     UINT64_C(0x6000000000000000)
#define SP_CNT_MASK     UINT64_C(0x1fffffffffffffff)

/* Macros to interpret space cmds */
#define SPACE_CNT(x)    (((x) & SP_BACKSP)? \
        (-((x)&(SP_CNT_MASK))):(x)&(SP_CNT_MASK))
#define SPACE_TYPE(x)   ((x & SP_CMD_MASK)>>61)

#endif /* end of big size_t in buf_t */

/* Macros to assemble space cmds */
#define SPACE(cmd, cnt) ((cnt < 0) ? (SP_BACKSP | (-(cnt)) | cmd) : (cmd | cnt))
#define Fmk(x)          SPACE(SP_FLM, x)
#define Blk(x)          SPACE(SP_BLK, x)



/* Defines for byte 4 of load/unload cmd */
#define LD_UNLOAD       0
#define LD_LOAD         1
#define LD_RETEN        2
#define LD_EOT          4
#define LD_HOLD         8

/* Defines for byte 4 of prevent/allow media removal */
#define MR_UNLOCK       0
#define MR_LOCK         1

#define GET_SOFT_STATE(dev)                                             \
        register struct scsi_tape *un;                                  \
        register int instance;                                          \
                                                                        \
        instance = MTUNIT(dev);                                         \
        if ((un = ddi_get_soft_state(st_state, instance)) == NULL)      \
                return (ENXIO);

/*
 * Debugging turned on via conditional compilation switch -DSTDEBUG
 */
#ifdef DEBUG
#define STDEBUG
#endif

#ifdef  STDEBUG
#define DEBUGGING\
        ((scsi_options & SCSI_DEBUG_TGT) || (st_debug & 0x7))

#define DEBLOCK(d) \
        int lev = CE_NOTE; \
        mutex_enter(&st_debug_mutex); \
        if (d == st_lastdev || d == 0) { \
                lev = CE_CONT; \
        } \
        mutex_exit(&st_debug_mutex);

#define DEBUNLOCK(d) \
        mutex_enter(&st_debug_mutex); \
        if (d != 0 && d != st_lastdev) { \
                st_lastdev = d; \
        } \
        mutex_exit(&st_debug_mutex);

        /* initialization */
#define ST_DEBUG1       if ((st_debug & 0x7) >= 1) scsi_log
#define ST_DEBUG        ST_DEBUG1

        /* errors and UA's */
#define ST_DEBUG2       if ((st_debug & 0x7) >= 2) scsi_log

        /* func calls */
#define ST_DEBUG3       if ((st_debug & 0x7) >= 3) scsi_log

        /* ioctl calls */
#define ST_DEBUG4       if ((st_debug & 0x7) >= 4) scsi_log

#define ST_DEBUG5       if ((st_debug & 0x7) >= 5) scsi_log

        /* full data tracking */
#define ST_DEBUG6       if ((st_debug & 0x7) >= 6) scsi_log

        /* debug error recovery */
#define ST_RECOV        if (st_debug & 0x8) scsi_log

        /* Entry Point Functions */
#define ST_ENTR(d, fn) if (st_debug & 0x10) { DEBLOCK(d) \
    scsi_log(d, st_label, lev, #fn); DEBUNLOCK(d) }

        /* Non-Entry Point Functions */
#define ST_FUNC(d, fn) if (st_debug & 0x20) { DEBLOCK(d) \
    scsi_log(d, st_label, lev, #fn); DEBUNLOCK(d) }

        /* Space Information */
#define ST_SPAC         if (st_debug & 0x40) scsi_log

        /* CDB's sent */
#define ST_CDB(d, cmnt, cdb) if (st_debug & 0x180) { DEBLOCK(d) \
    st_print_cdb(d, st_label, lev, cmnt, cdb); DEBUNLOCK(d) }

        /* sense data */
#define ST_SENSE(d, cmnt, sense, size) if (st_debug & 0x200) { DEBLOCK(d) \
    st_clean_print(d, st_label, lev, cmnt, sense, size); DEBUNLOCK(d) }

        /* position data */
#define ST_POS(d, cmnt, pdata) if (st_debug & 0x400) { DEBLOCK(d) \
    st_print_position(d, st_label, lev, cmnt, pdata); DEBUNLOCK(d) }


#else

#define st_debug        (0)
#define DEBUGGING       (0)
#define ST_DEBUG        if (0) scsi_log
#define ST_DEBUG1       if (0) scsi_log
#define ST_DEBUG2       if (0) scsi_log
#define ST_DEBUG3       if (0) scsi_log
#define ST_DEBUG4       if (0) scsi_log
#define ST_DEBUG5       if (0) scsi_log
#define ST_DEBUG6       if (0) scsi_log
#define ST_RECOV        if (0) scsi_log

#define ST_ENTR(d, fn)
#define ST_FUNC(d, fn)
#define ST_SPAC         if (0) scsi_log
#define ST_CDB(d, cmnt, cdb)
#define ST_SENSE(d, cmnt, sense, size)
#define ST_SENSE(d, cmnt, sense, size)
#define ST_POS(d, cmnt, pdata)

#endif

/*
 * Media access values
 */
#define MEDIA_ACCESS_DELAY 5000000      /* usecs wait for media state change */

/*
 * SCSI tape mode sense page information
 */
#define ST_DEV_CONFIG_PAGE      0x10    /* device config mode page */
#define ST_DEV_CONFIG_NO_COMP   0x00    /* use no compression */
#define ST_DEV_CONFIG_DEF_COMP  0x01    /* use default compression alg */
#define ST_COMPRESSION_DENSITY  3       /* compression minor number */

/*
 * SCSI tape data compression Page definition.
 */
#define ST_DEV_DATACOMP_PAGE    0x0F    /* data compression page */



/*
 * maxbsize values
 */
#define MAXBSIZE_UNKNOWN        -2      /*  not found yet */

#define ONE_MEG                 (1024 * 1024)

/*
 * generic soft error reporting
 *
 * What we are doing here is allowing a greater number of errors to occur on
 * smaller transfers (i.e. usually at the beginning of the tape), than on
 * the rest of the tape.
 *
 * A small transfer is defined as :
 * Transfers <= SOFT_ERROR_WARNING_THRESHOLD  allow about 1.5 times more errors
 *
 * A larget tranfer is defined as :
 * Transfers >  SOFT_ERROR_WARNING_THRESHOLD  allow normal amount
 *
 */
#define READ_SOFT_ERROR_WARNING_THRESHOLD    (25 * ONE_MEG)
#define WRITE_SOFT_ERROR_WARNING_THRESHOLD    (20 * ONE_MEG)

/*
 * soft error reporting for exabyte
 */
#define TAPE_SENSE_LENGTH       32      /* allows for softerror info */

#define SENSE_19_BITS  \
        "\20\10PF\07BPE\06FPE\05ME\04ECO\03TME\02TNP\01LBOT"
#define SENSE_20_BITS  \
        "\20\10RSVD\07RSVD\06WP\05FMKE\04URE\03WE1\02SSE\01FW"
#define SENSE_21_BITS  \
        "\20\10RSVD\07RSVD\06RRR\05CLND\04CLN\03PEOT\02WSEB\01WSE0"

/* these are defined in percentages */
#define EXABYTE_WRITE_ERROR_THRESHOLD   6
#define EXABYTE_READ_ERROR_THRESHOLD    3
/*
 * minumum amount of data transfer(MB) for checking soft error rate.
 */
#define EXABYTE_MIN_TRANSFER                    (25 * ONE_MEG)

#define CLN     0x8
#define CLND    0x10

/*
 * soft error reporting for Archive 4mm DAT
 */

#define LOG_SENSE_LENGTH                0xff
#define MIN_LOG_SENSE_LENGTH            0x2b
#define DAT_SMALL_WRITE_ERROR_THRESHOLD 40      /* retries per 20 mg */
#define DAT_LARGE_WRITE_ERROR_THRESHOLD 200     /* retries for more 20 mg */
#define DAT_SMALL_READ_ERROR_THRESHOLD  5       /* errors allowed */
#define DAT_LARGE_READ_ERROR_THRESHOLD  3       /* errors allowed */

/*
 * ST timeouts that need to be cancelled for suspend
 */
#define ST_HIB_TID      0x01
#define ST_DELAY_TID    0x02

#ifdef  __cplusplus
}
#endif

#endif  /* _SYS_SCSI_TARGETS_STDEF_H */