]> pilppa.com Git - linux-2.6-omap-h63xx.git/commitdiff
[SCSI] aiclib remove dead
authorChristoph Hellwig <hch@lst.de>
Mon, 15 Aug 2005 11:29:55 +0000 (13:29 +0200)
committerJames Bottomley <jejb@mulgrave.(none)>
Mon, 15 Aug 2005 14:19:23 +0000 (09:19 -0500)
remove lots of completely dead code from aiclib, there's not a lot left
and even what's left is rather useless.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
drivers/scsi/aic7xxx/aiclib.c
drivers/scsi/aic7xxx/aiclib.h

index 7c5a6db0e6724c5a0aa933575f57bc603090609b..4d44a9211185db7ce9486076377693818f6cccda 100644 (file)
  * $Id$
  */
 
-#include <linux/blkdev.h>
-#include <linux/delay.h>
-#include <linux/version.h>
-
-/* Core SCSI definitions */
-#include <scsi/scsi_host.h>
 #include "aiclib.h"
-#include "cam.h"
-
-#ifndef FALSE
-#define FALSE   0
-#endif /* FALSE */
-#ifndef TRUE
-#define TRUE    1
-#endif /* TRUE */
-#ifndef ERESTART
-#define ERESTART        -1              /* restart syscall */
-#endif
-#ifndef EJUSTRETURN
-#define EJUSTRETURN     -2              /* don't modify regs, just return */
-#endif
-
-static int     ascentrycomp(const void *key, const void *member);
-static int     senseentrycomp(const void *key, const void *member);
-static void    fetchtableentries(int sense_key, int asc, int ascq,
-                                 struct scsi_inquiry_data *,
-                                 const struct sense_key_table_entry **,
-                                 const struct asc_table_entry **);
-static void *  scsibsearch(const void *key, const void *base, size_t nmemb,
-                           size_t size,
-                           int (*compar)(const void *, const void *));
-typedef int (cam_quirkmatch_t)(caddr_t, caddr_t);
-static int     cam_strmatch(const u_int8_t *str, const u_int8_t *pattern,
-                            int str_len);
-static caddr_t cam_quirkmatch(caddr_t target, caddr_t quirk_table,
-                              int num_entries, int entry_size,
-                              cam_quirkmatch_t *comp_func);
-
-#define SCSI_NO_SENSE_STRINGS 1
-#if !defined(SCSI_NO_SENSE_STRINGS)
-#define SST(asc, ascq, action, desc) \
-       asc, ascq, action, desc
-#else 
-static const char empty_string[] = "";
-
-#define SST(asc, ascq, action, desc) \
-       asc, ascq, action, empty_string
-#endif 
-
-static const struct sense_key_table_entry sense_key_table[] = 
-{
-       { SSD_KEY_NO_SENSE, SS_NOP, "NO SENSE" },
-       { SSD_KEY_RECOVERED_ERROR, SS_NOP|SSQ_PRINT_SENSE, "RECOVERED ERROR" },
-       {
-         SSD_KEY_NOT_READY, SS_TUR|SSQ_MANY|SSQ_DECREMENT_COUNT|EBUSY,
-         "NOT READY"
-       },
-       { SSD_KEY_MEDIUM_ERROR, SS_RDEF, "MEDIUM ERROR" },
-       { SSD_KEY_HARDWARE_ERROR, SS_RDEF, "HARDWARE FAILURE" },
-       { SSD_KEY_ILLEGAL_REQUEST, SS_FATAL|EINVAL, "ILLEGAL REQUEST" },
-       { SSD_KEY_UNIT_ATTENTION, SS_FATAL|ENXIO, "UNIT ATTENTION" },
-       { SSD_KEY_DATA_PROTECT, SS_FATAL|EACCES, "DATA PROTECT" },
-       { SSD_KEY_BLANK_CHECK, SS_FATAL|ENOSPC, "BLANK CHECK" },
-       { SSD_KEY_Vendor_Specific, SS_FATAL|EIO, "Vendor Specific" },
-       { SSD_KEY_COPY_ABORTED, SS_FATAL|EIO, "COPY ABORTED" },
-       { SSD_KEY_ABORTED_COMMAND, SS_RDEF, "ABORTED COMMAND" },
-       { SSD_KEY_EQUAL, SS_NOP, "EQUAL" },
-       { SSD_KEY_VOLUME_OVERFLOW, SS_FATAL|EIO, "VOLUME OVERFLOW" },
-       { SSD_KEY_MISCOMPARE, SS_NOP, "MISCOMPARE" },
-       { SSD_KEY_RESERVED, SS_FATAL|EIO, "RESERVED" }
-};
-
-static const int sense_key_table_size =
-    sizeof(sense_key_table)/sizeof(sense_key_table[0]);
-
-static struct asc_table_entry quantum_fireball_entries[] = {
-       {SST(0x04, 0x0b, SS_START|SSQ_DECREMENT_COUNT|ENXIO, 
-            "Logical unit not ready, initializing cmd. required")}
-};
-
-static struct asc_table_entry sony_mo_entries[] = {
-       {SST(0x04, 0x00, SS_START|SSQ_DECREMENT_COUNT|ENXIO,
-            "Logical unit not ready, cause not reportable")}
-};
-
-static struct scsi_sense_quirk_entry sense_quirk_table[] = {
-       {
-               /*
-                * The Quantum Fireball ST and SE like to return 0x04 0x0b when
-                * they really should return 0x04 0x02.  0x04,0x0b isn't
-                * defined in any SCSI spec, and it isn't mentioned in the
-                * hardware manual for these drives.
-                */
-               {T_DIRECT, SIP_MEDIA_FIXED, "QUANTUM", "FIREBALL S*", "*"},
-               /*num_sense_keys*/0,
-               sizeof(quantum_fireball_entries)/sizeof(struct asc_table_entry),
-               /*sense key entries*/NULL,
-               quantum_fireball_entries
-       },
-       {
-               /*
-                * This Sony MO drive likes to return 0x04, 0x00 when it
-                * isn't spun up.
-                */
-               {T_DIRECT, SIP_MEDIA_REMOVABLE, "SONY", "SMO-*", "*"},
-               /*num_sense_keys*/0,
-               sizeof(sony_mo_entries)/sizeof(struct asc_table_entry),
-               /*sense key entries*/NULL,
-               sony_mo_entries
-       }
-};
-
-static const int sense_quirk_table_size =
-    sizeof(sense_quirk_table)/sizeof(sense_quirk_table[0]);
-
-static struct asc_table_entry asc_table[] = {
-/*
- * From File: ASC-NUM.TXT
- * SCSI ASC/ASCQ Assignments
- * Numeric Sorted Listing
- * as of  5/12/97
- *
- * D - DIRECT ACCESS DEVICE (SBC)                     device column key
- * .T - SEQUENTIAL ACCESS DEVICE (SSC)               -------------------
- * . L - PRINTER DEVICE (SSC)                           blank = reserved
- * .  P - PROCESSOR DEVICE (SPC)                     not blank = allowed
- * .  .W - WRITE ONCE READ MULTIPLE DEVICE (SBC)
- * .  . R - CD DEVICE (MMC)
- * .  .  S - SCANNER DEVICE (SGC)
- * .  .  .O - OPTICAL MEMORY DEVICE (SBC)
- * .  .  . M - MEDIA CHANGER DEVICE (SMC)
- * .  .  .  C - COMMUNICATION DEVICE (SSC)
- * .  .  .  .A - STORAGE ARRAY DEVICE (SCC)
- * .  .  .  . E - ENCLOSURE SERVICES DEVICE (SES)
- * DTLPWRSOMCAE        ASC   ASCQ  Action  Description
- * ------------        ----  ----  ------  -----------------------------------*/
-/* DTLPWRSOMCAE */{SST(0x00, 0x00, SS_NOP,
-                       "No additional sense information") },
-/*  T    S      */{SST(0x00, 0x01, SS_RDEF,
-                       "Filemark detected") },
-/*  T    S      */{SST(0x00, 0x02, SS_RDEF,
-                       "End-of-partition/medium detected") },
-/*  T           */{SST(0x00, 0x03, SS_RDEF,
-                       "Setmark detected") },
-/*  T    S      */{SST(0x00, 0x04, SS_RDEF,
-                       "Beginning-of-partition/medium detected") },
-/*  T    S      */{SST(0x00, 0x05, SS_RDEF,
-                       "End-of-data detected") },
-/* DTLPWRSOMCAE */{SST(0x00, 0x06, SS_RDEF,
-                       "I/O process terminated") },
-/*      R       */{SST(0x00, 0x11, SS_FATAL|EBUSY,
-                       "Audio play operation in progress") },
-/*      R       */{SST(0x00, 0x12, SS_NOP,
-                       "Audio play operation paused") },
-/*      R       */{SST(0x00, 0x13, SS_NOP,
-                       "Audio play operation successfully completed") },
-/*      R       */{SST(0x00, 0x14, SS_RDEF,
-                       "Audio play operation stopped due to error") },
-/*      R       */{SST(0x00, 0x15, SS_NOP,
-                       "No current audio status to return") },
-/* DTLPWRSOMCAE */{SST(0x00, 0x16, SS_FATAL|EBUSY,
-                       "Operation in progress") },
-/* DTL WRSOM AE */{SST(0x00, 0x17, SS_RDEF,
-                       "Cleaning requested") },
-/* D   W  O     */{SST(0x01, 0x00, SS_RDEF,
-                       "No index/sector signal") },
-/* D   WR OM    */{SST(0x02, 0x00, SS_RDEF,
-                       "No seek complete") },
-/* DTL W SO     */{SST(0x03, 0x00, SS_RDEF,
-                       "Peripheral device write fault") },
-/*  T           */{SST(0x03, 0x01, SS_RDEF,
-                       "No write current") },
-/*  T           */{SST(0x03, 0x02, SS_RDEF,
-                       "Excessive write errors") },
-/* DTLPWRSOMCAE */{SST(0x04, 0x00,
-                       SS_TUR|SSQ_DELAY|SSQ_MANY|SSQ_DECREMENT_COUNT|EIO,
-                       "Logical unit not ready, cause not reportable") },
-/* DTLPWRSOMCAE */{SST(0x04, 0x01,
-                       SS_TUR|SSQ_DELAY|SSQ_MANY|SSQ_DECREMENT_COUNT|EBUSY,
-                       "Logical unit is in process of becoming ready") },
-/* DTLPWRSOMCAE */{SST(0x04, 0x02, SS_START|SSQ_DECREMENT_COUNT|ENXIO,
-                       "Logical unit not ready, initializing cmd. required") },
-/* DTLPWRSOMCAE */{SST(0x04, 0x03, SS_FATAL|ENXIO,
-                       "Logical unit not ready, manual intervention required")},
-/* DTL    O     */{SST(0x04, 0x04, SS_FATAL|EBUSY,
-                       "Logical unit not ready, format in progress") },
-/* DT  W  OMCA  */{SST(0x04, 0x05, SS_FATAL|EBUSY,
-                       "Logical unit not ready, rebuild in progress") },
-/* DT  W  OMCA  */{SST(0x04, 0x06, SS_FATAL|EBUSY,
-                       "Logical unit not ready, recalculation in progress") },
-/* DTLPWRSOMCAE */{SST(0x04, 0x07, SS_FATAL|EBUSY,
-                       "Logical unit not ready, operation in progress") },
-/*      R       */{SST(0x04, 0x08, SS_FATAL|EBUSY,
-                       "Logical unit not ready, long write in progress") },
-/* DTL WRSOMCAE */{SST(0x05, 0x00, SS_RDEF,
-                       "Logical unit does not respond to selection") },
-/* D   WR OM    */{SST(0x06, 0x00, SS_RDEF,
-                       "No reference position found") },
-/* DTL WRSOM    */{SST(0x07, 0x00, SS_RDEF,
-                       "Multiple peripheral devices selected") },
-/* DTL WRSOMCAE */{SST(0x08, 0x00, SS_RDEF,
-                       "Logical unit communication failure") },
-/* DTL WRSOMCAE */{SST(0x08, 0x01, SS_RDEF,
-                       "Logical unit communication time-out") },
-/* DTL WRSOMCAE */{SST(0x08, 0x02, SS_RDEF,
-                       "Logical unit communication parity error") },
-/* DT   R OM    */{SST(0x08, 0x03, SS_RDEF,
-                       "Logical unit communication crc error (ultra-dma/32)")},
-/* DT  WR O     */{SST(0x09, 0x00, SS_RDEF,
-                       "Track following error") },
-/*     WR O     */{SST(0x09, 0x01, SS_RDEF,
-                       "Tracking servo failure") },
-/*     WR O     */{SST(0x09, 0x02, SS_RDEF,
-                       "Focus servo failure") },
-/*     WR O     */{SST(0x09, 0x03, SS_RDEF,
-                       "Spindle servo failure") },
-/* DT  WR O     */{SST(0x09, 0x04, SS_RDEF,
-                       "Head select fault") },
-/* DTLPWRSOMCAE */{SST(0x0A, 0x00, SS_FATAL|ENOSPC,
-                       "Error log overflow") },
-/* DTLPWRSOMCAE */{SST(0x0B, 0x00, SS_RDEF,
-                       "Warning") },
-/* DTLPWRSOMCAE */{SST(0x0B, 0x01, SS_RDEF,
-                       "Specified temperature exceeded") },
-/* DTLPWRSOMCAE */{SST(0x0B, 0x02, SS_RDEF,
-                       "Enclosure degraded") },
-/*  T   RS      */{SST(0x0C, 0x00, SS_RDEF,
-                       "Write error") },
-/* D   W  O     */{SST(0x0C, 0x01, SS_NOP|SSQ_PRINT_SENSE,
-                       "Write error - recovered with auto reallocation") },
-/* D   W  O     */{SST(0x0C, 0x02, SS_RDEF,
-                       "Write error - auto reallocation failed") },
-/* D   W  O     */{SST(0x0C, 0x03, SS_RDEF,
-                       "Write error - recommend reassignment") },
-/* DT  W  O     */{SST(0x0C, 0x04, SS_RDEF,
-                       "Compression check miscompare error") },
-/* DT  W  O     */{SST(0x0C, 0x05, SS_RDEF,
-                       "Data expansion occurred during compression") },
-/* DT  W  O     */{SST(0x0C, 0x06, SS_RDEF,
-                       "Block not compressible") },
-/*      R       */{SST(0x0C, 0x07, SS_RDEF,
-                       "Write error - recovery needed") },
-/*      R       */{SST(0x0C, 0x08, SS_RDEF,
-                       "Write error - recovery failed") },
-/*      R       */{SST(0x0C, 0x09, SS_RDEF,
-                       "Write error - loss of streaming") },
-/*      R       */{SST(0x0C, 0x0A, SS_RDEF,
-                       "Write error - padding blocks added") },
-/* D   W  O     */{SST(0x10, 0x00, SS_RDEF,
-                       "ID CRC or ECC error") },
-/* DT  WRSO     */{SST(0x11, 0x00, SS_RDEF,
-                       "Unrecovered read error") },
-/* DT  W SO     */{SST(0x11, 0x01, SS_RDEF,
-                       "Read retries exhausted") },
-/* DT  W SO     */{SST(0x11, 0x02, SS_RDEF,
-                       "Error too long to correct") },
-/* DT  W SO     */{SST(0x11, 0x03, SS_RDEF,
-                       "Multiple read errors") },
-/* D   W  O     */{SST(0x11, 0x04, SS_RDEF,
-                       "Unrecovered read error - auto reallocate failed") },
-/*     WR O     */{SST(0x11, 0x05, SS_RDEF,
-                       "L-EC uncorrectable error") },
-/*     WR O     */{SST(0x11, 0x06, SS_RDEF,
-                       "CIRC unrecovered error") },
-/*     W  O     */{SST(0x11, 0x07, SS_RDEF,
-                       "Data re-synchronization error") },
-/*  T           */{SST(0x11, 0x08, SS_RDEF,
-                       "Incomplete block read") },
-/*  T           */{SST(0x11, 0x09, SS_RDEF,
-                       "No gap found") },
-/* DT     O     */{SST(0x11, 0x0A, SS_RDEF,
-                       "Miscorrected error") },
-/* D   W  O     */{SST(0x11, 0x0B, SS_RDEF,
-                       "Unrecovered read error - recommend reassignment") },
-/* D   W  O     */{SST(0x11, 0x0C, SS_RDEF,
-                       "Unrecovered read error - recommend rewrite the data")},
-/* DT  WR O     */{SST(0x11, 0x0D, SS_RDEF,
-                       "De-compression CRC error") },
-/* DT  WR O     */{SST(0x11, 0x0E, SS_RDEF,
-                       "Cannot decompress using declared algorithm") },
-/*      R       */{SST(0x11, 0x0F, SS_RDEF,
-                       "Error reading UPC/EAN number") },
-/*      R       */{SST(0x11, 0x10, SS_RDEF,
-                       "Error reading ISRC number") },
-/*      R       */{SST(0x11, 0x11, SS_RDEF,
-                       "Read error - loss of streaming") },
-/* D   W  O     */{SST(0x12, 0x00, SS_RDEF,
-                       "Address mark not found for id field") },
-/* D   W  O     */{SST(0x13, 0x00, SS_RDEF,
-                       "Address mark not found for data field") },
-/* DTL WRSO     */{SST(0x14, 0x00, SS_RDEF,
-                       "Recorded entity not found") },
-/* DT  WR O     */{SST(0x14, 0x01, SS_RDEF,
-                       "Record not found") },
-/*  T           */{SST(0x14, 0x02, SS_RDEF,
-                       "Filemark or setmark not found") },
-/*  T           */{SST(0x14, 0x03, SS_RDEF,
-                       "End-of-data not found") },
-/*  T           */{SST(0x14, 0x04, SS_RDEF,
-                       "Block sequence error") },
-/* DT  W  O     */{SST(0x14, 0x05, SS_RDEF,
-                       "Record not found - recommend reassignment") },
-/* DT  W  O     */{SST(0x14, 0x06, SS_RDEF,
-                       "Record not found - data auto-reallocated") },
-/* DTL WRSOM    */{SST(0x15, 0x00, SS_RDEF,
-                       "Random positioning error") },
-/* DTL WRSOM    */{SST(0x15, 0x01, SS_RDEF,
-                       "Mechanical positioning error") },
-/* DT  WR O     */{SST(0x15, 0x02, SS_RDEF,
-                       "Positioning error detected by read of medium") },
-/* D   W  O     */{SST(0x16, 0x00, SS_RDEF,
-                       "Data synchronization mark error") },
-/* D   W  O     */{SST(0x16, 0x01, SS_RDEF,
-                       "Data sync error - data rewritten") },
-/* D   W  O     */{SST(0x16, 0x02, SS_RDEF,
-                       "Data sync error - recommend rewrite") },
-/* D   W  O     */{SST(0x16, 0x03, SS_NOP|SSQ_PRINT_SENSE,
-                       "Data sync error - data auto-reallocated") },
-/* D   W  O     */{SST(0x16, 0x04, SS_RDEF,
-                       "Data sync error - recommend reassignment") },
-/* DT  WRSO     */{SST(0x17, 0x00, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data with no error correction applied") },
-/* DT  WRSO     */{SST(0x17, 0x01, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data with retries") },
-/* DT  WR O     */{SST(0x17, 0x02, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data with positive head offset") },
-/* DT  WR O     */{SST(0x17, 0x03, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data with negative head offset") },
-/*     WR O     */{SST(0x17, 0x04, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data with retries and/or CIRC applied") },
-/* D   WR O     */{SST(0x17, 0x05, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data using previous sector id") },
-/* D   W  O     */{SST(0x17, 0x06, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data without ECC - data auto-reallocated") },
-/* D   W  O     */{SST(0x17, 0x07, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data without ECC - recommend reassignment")},
-/* D   W  O     */{SST(0x17, 0x08, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data without ECC - recommend rewrite") },
-/* D   W  O     */{SST(0x17, 0x09, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data without ECC - data rewritten") },
-/* D   W  O     */{SST(0x18, 0x00, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data with error correction applied") },
-/* D   WR O     */{SST(0x18, 0x01, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data with error corr. & retries applied") },
-/* D   WR O     */{SST(0x18, 0x02, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data - data auto-reallocated") },
-/*      R       */{SST(0x18, 0x03, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data with CIRC") },
-/*      R       */{SST(0x18, 0x04, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data with L-EC") },
-/* D   WR O     */{SST(0x18, 0x05, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data - recommend reassignment") },
-/* D   WR O     */{SST(0x18, 0x06, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data - recommend rewrite") },
-/* D   W  O     */{SST(0x18, 0x07, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered data with ECC - data rewritten") },
-/* D      O     */{SST(0x19, 0x00, SS_RDEF,
-                       "Defect list error") },
-/* D      O     */{SST(0x19, 0x01, SS_RDEF,
-                       "Defect list not available") },
-/* D      O     */{SST(0x19, 0x02, SS_RDEF,
-                       "Defect list error in primary list") },
-/* D      O     */{SST(0x19, 0x03, SS_RDEF,
-                       "Defect list error in grown list") },
-/* DTLPWRSOMCAE */{SST(0x1A, 0x00, SS_RDEF,
-                       "Parameter list length error") },
-/* DTLPWRSOMCAE */{SST(0x1B, 0x00, SS_RDEF,
-                       "Synchronous data transfer error") },
-/* D      O     */{SST(0x1C, 0x00, SS_RDEF,
-                       "Defect list not found") },
-/* D      O     */{SST(0x1C, 0x01, SS_RDEF,
-                       "Primary defect list not found") },
-/* D      O     */{SST(0x1C, 0x02, SS_RDEF,
-                       "Grown defect list not found") },
-/* D   W  O     */{SST(0x1D, 0x00, SS_FATAL,
-                       "Miscompare during verify operation" )},
-/* D   W  O     */{SST(0x1E, 0x00, SS_NOP|SSQ_PRINT_SENSE,
-                       "Recovered id with ecc correction") },
-/* D      O     */{SST(0x1F, 0x00, SS_RDEF,
-                       "Partial defect list transfer") },
-/* DTLPWRSOMCAE */{SST(0x20, 0x00, SS_FATAL|EINVAL,
-                       "Invalid command operation code") },
-/* DT  WR OM    */{SST(0x21, 0x00, SS_FATAL|EINVAL,
-                       "Logical block address out of range" )},
-/* DT  WR OM    */{SST(0x21, 0x01, SS_FATAL|EINVAL,
-                       "Invalid element address") },
-/* D            */{SST(0x22, 0x00, SS_FATAL|EINVAL,
-                       "Illegal function") }, /* Deprecated. Use 20 00, 24 00, or 26 00 instead */
-/* DTLPWRSOMCAE */{SST(0x24, 0x00, SS_FATAL|EINVAL,
-                       "Invalid field in CDB") },
-/* DTLPWRSOMCAE */{SST(0x25, 0x00, SS_FATAL|ENXIO,
-                       "Logical unit not supported") },
-/* DTLPWRSOMCAE */{SST(0x26, 0x00, SS_FATAL|EINVAL,
-                       "Invalid field in parameter list") },
-/* DTLPWRSOMCAE */{SST(0x26, 0x01, SS_FATAL|EINVAL,
-                       "Parameter not supported") },
-/* DTLPWRSOMCAE */{SST(0x26, 0x02, SS_FATAL|EINVAL,
-                       "Parameter value invalid") },
-/* DTLPWRSOMCAE */{SST(0x26, 0x03, SS_FATAL|EINVAL,
-                       "Threshold parameters not supported") },
-/* DTLPWRSOMCAE */{SST(0x26, 0x04, SS_FATAL|EINVAL,
-                       "Invalid release of active persistent reservation") },
-/* DT  W  O     */{SST(0x27, 0x00, SS_FATAL|EACCES,
-                       "Write protected") },
-/* DT  W  O     */{SST(0x27, 0x01, SS_FATAL|EACCES,
-                       "Hardware write protected") },
-/* DT  W  O     */{SST(0x27, 0x02, SS_FATAL|EACCES,
-                       "Logical unit software write protected") },
-/*  T           */{SST(0x27, 0x03, SS_FATAL|EACCES,
-                       "Associated write protect") },
-/*  T           */{SST(0x27, 0x04, SS_FATAL|EACCES,
-                       "Persistent write protect") },
-/*  T           */{SST(0x27, 0x05, SS_FATAL|EACCES,
-                       "Permanent write protect") },
-/* DTLPWRSOMCAE */{SST(0x28, 0x00, SS_RDEF,
-                       "Not ready to ready change, medium may have changed") },
-/* DTLPWRSOMCAE */{SST(0x28, 0x01, SS_FATAL|ENXIO,
-                       "Import or export element accessed") },
-/*
- * XXX JGibbs - All of these should use the same errno, but I don't think
- * ENXIO is the correct choice.  Should we borrow from the networking
- * errnos?  ECONNRESET anyone?
- */
-/* DTLPWRSOMCAE */{SST(0x29, 0x00, SS_RDEF,
-                       "Power on, reset, or bus device reset occurred") },
-/* DTLPWRSOMCAE */{SST(0x29, 0x01, SS_RDEF,
-                       "Power on occurred") },
-/* DTLPWRSOMCAE */{SST(0x29, 0x02, SS_RDEF,
-                       "Scsi bus reset occurred") },
-/* DTLPWRSOMCAE */{SST(0x29, 0x03, SS_RDEF,
-                       "Bus device reset function occurred") },
-/* DTLPWRSOMCAE */{SST(0x29, 0x04, SS_RDEF,
-                       "Device internal reset") },
-/* DTLPWRSOMCAE */{SST(0x29, 0x05, SS_RDEF,
-                       "Transceiver mode changed to single-ended") },
-/* DTLPWRSOMCAE */{SST(0x29, 0x06, SS_RDEF,
-                       "Transceiver mode changed to LVD") },
-/* DTL WRSOMCAE */{SST(0x2A, 0x00, SS_RDEF,
-                       "Parameters changed") },
-/* DTL WRSOMCAE */{SST(0x2A, 0x01, SS_RDEF,
-                       "Mode parameters changed") },
-/* DTL WRSOMCAE */{SST(0x2A, 0x02, SS_RDEF,
-                       "Log parameters changed") },
-/* DTLPWRSOMCAE */{SST(0x2A, 0x03, SS_RDEF,
-                       "Reservations preempted") },
-/* DTLPWRSO C   */{SST(0x2B, 0x00, SS_RDEF,
-                       "Copy cannot execute since host cannot disconnect") },
-/* DTLPWRSOMCAE */{SST(0x2C, 0x00, SS_RDEF,
-                       "Command sequence error") },
-/*       S      */{SST(0x2C, 0x01, SS_RDEF,
-                       "Too many windows specified") },
-/*       S      */{SST(0x2C, 0x02, SS_RDEF,
-                       "Invalid combination of windows specified") },
-/*      R       */{SST(0x2C, 0x03, SS_RDEF,
-                       "Current program area is not empty") },
-/*      R       */{SST(0x2C, 0x04, SS_RDEF,
-                       "Current program area is empty") },
-/*  T           */{SST(0x2D, 0x00, SS_RDEF,
-                       "Overwrite error on update in place") },
-/* DTLPWRSOMCAE */{SST(0x2F, 0x00, SS_RDEF,
-                       "Commands cleared by another initiator") },
-/* DT  WR OM    */{SST(0x30, 0x00, SS_RDEF,
-                       "Incompatible medium installed") },
-/* DT  WR O     */{SST(0x30, 0x01, SS_RDEF,
-                       "Cannot read medium - unknown format") },
-/* DT  WR O     */{SST(0x30, 0x02, SS_RDEF,
-                       "Cannot read medium - incompatible format") },
-/* DT           */{SST(0x30, 0x03, SS_RDEF,
-                       "Cleaning cartridge installed") },
-/* DT  WR O     */{SST(0x30, 0x04, SS_RDEF,
-                       "Cannot write medium - unknown format") },
-/* DT  WR O     */{SST(0x30, 0x05, SS_RDEF,
-                       "Cannot write medium - incompatible format") },
-/* DT  W  O     */{SST(0x30, 0x06, SS_RDEF,
-                       "Cannot format medium - incompatible medium") },
-/* DTL WRSOM AE */{SST(0x30, 0x07, SS_RDEF,
-                       "Cleaning failure") },
-/*      R       */{SST(0x30, 0x08, SS_RDEF,
-                       "Cannot write - application code mismatch") },
-/*      R       */{SST(0x30, 0x09, SS_RDEF,
-                       "Current session not fixated for append") },
-/* DT  WR O     */{SST(0x31, 0x00, SS_RDEF,
-                       "Medium format corrupted") },
-/* D L  R O     */{SST(0x31, 0x01, SS_RDEF,
-                       "Format command failed") },
-/* D   W  O     */{SST(0x32, 0x00, SS_RDEF,
-                       "No defect spare location available") },
-/* D   W  O     */{SST(0x32, 0x01, SS_RDEF,
-                       "Defect list update failure") },
-/*  T           */{SST(0x33, 0x00, SS_RDEF,
-                       "Tape length error") },
-/* DTLPWRSOMCAE */{SST(0x34, 0x00, SS_RDEF,
-                       "Enclosure failure") },
-/* DTLPWRSOMCAE */{SST(0x35, 0x00, SS_RDEF,
-                       "Enclosure services failure") },
-/* DTLPWRSOMCAE */{SST(0x35, 0x01, SS_RDEF,
-                       "Unsupported enclosure function") },
-/* DTLPWRSOMCAE */{SST(0x35, 0x02, SS_RDEF,
-                       "Enclosure services unavailable") },
-/* DTLPWRSOMCAE */{SST(0x35, 0x03, SS_RDEF,
-                       "Enclosure services transfer failure") },
-/* DTLPWRSOMCAE */{SST(0x35, 0x04, SS_RDEF,
-                       "Enclosure services transfer refused") },
-/*   L          */{SST(0x36, 0x00, SS_RDEF,
-                       "Ribbon, ink, or toner failure") },
-/* DTL WRSOMCAE */{SST(0x37, 0x00, SS_RDEF,
-                       "Rounded parameter") },
-/* DTL WRSOMCAE */{SST(0x39, 0x00, SS_RDEF,
-                       "Saving parameters not supported") },
-/* DTL WRSOM    */{SST(0x3A, 0x00, SS_NOP,
-                       "Medium not present") },
-/* DT  WR OM    */{SST(0x3A, 0x01, SS_NOP,
-                       "Medium not present - tray closed") },
-/* DT  WR OM    */{SST(0x3A, 0x01, SS_NOP,
-                       "Medium not present - tray open") },
-/* DT  WR OM    */{SST(0x3A, 0x03, SS_NOP,
-                       "Medium not present - Loadable") },
-/* DT  WR OM    */{SST(0x3A, 0x04, SS_NOP,
-                       "Medium not present - medium auxiliary "
-                       "memory accessible") },
-/* DT  WR OM    */{SST(0x3A, 0xFF, SS_NOP, NULL) },/* Range 0x05->0xFF */
-/*  TL          */{SST(0x3B, 0x00, SS_RDEF,
-                       "Sequential positioning error") },
-/*  T           */{SST(0x3B, 0x01, SS_RDEF,
-                       "Tape position error at beginning-of-medium") },
-/*  T           */{SST(0x3B, 0x02, SS_RDEF,
-                       "Tape position error at end-of-medium") },
-/*   L          */{SST(0x3B, 0x03, SS_RDEF,
-                       "Tape or electronic vertical forms unit not ready") },
-/*   L          */{SST(0x3B, 0x04, SS_RDEF,
-                       "Slew failure") },
-/*   L          */{SST(0x3B, 0x05, SS_RDEF,
-                       "Paper jam") },
-/*   L          */{SST(0x3B, 0x06, SS_RDEF,
-                       "Failed to sense top-of-form") },
-/*   L          */{SST(0x3B, 0x07, SS_RDEF,
-                       "Failed to sense bottom-of-form") },
-/*  T           */{SST(0x3B, 0x08, SS_RDEF,
-                       "Reposition error") },
-/*       S      */{SST(0x3B, 0x09, SS_RDEF,
-                       "Read past end of medium") },
-/*       S      */{SST(0x3B, 0x0A, SS_RDEF,
-                       "Read past beginning of medium") },
-/*       S      */{SST(0x3B, 0x0B, SS_RDEF,
-                       "Position past end of medium") },
-/*  T    S      */{SST(0x3B, 0x0C, SS_RDEF,
-                       "Position past beginning of medium") },
-/* DT  WR OM    */{SST(0x3B, 0x0D, SS_FATAL|ENOSPC,
-                       "Medium destination element full") },
-/* DT  WR OM    */{SST(0x3B, 0x0E, SS_RDEF,
-                       "Medium source element empty") },
-/*      R       */{SST(0x3B, 0x0F, SS_RDEF,
-                       "End of medium reached") },
-/* DT  WR OM    */{SST(0x3B, 0x11, SS_RDEF,
-                       "Medium magazine not accessible") },
-/* DT  WR OM    */{SST(0x3B, 0x12, SS_RDEF,
-                       "Medium magazine removed") },
-/* DT  WR OM    */{SST(0x3B, 0x13, SS_RDEF,
-                       "Medium magazine inserted") },
-/* DT  WR OM    */{SST(0x3B, 0x14, SS_RDEF,
-                       "Medium magazine locked") },
-/* DT  WR OM    */{SST(0x3B, 0x15, SS_RDEF,
-                       "Medium magazine unlocked") },
-/* DTLPWRSOMCAE */{SST(0x3D, 0x00, SS_RDEF,
-                       "Invalid bits in identify message") },
-/* DTLPWRSOMCAE */{SST(0x3E, 0x00, SS_RDEF,
-                       "Logical unit has not self-configured yet") },
-/* DTLPWRSOMCAE */{SST(0x3E, 0x01, SS_RDEF,
-                       "Logical unit failure") },
-/* DTLPWRSOMCAE */{SST(0x3E, 0x02, SS_RDEF,
-                       "Timeout on logical unit") },
-/* DTLPWRSOMCAE */{SST(0x3F, 0x00, SS_RDEF,
-                       "Target operating conditions have changed") },
-/* DTLPWRSOMCAE */{SST(0x3F, 0x01, SS_RDEF,
-                       "Microcode has been changed") },
-/* DTLPWRSOMC   */{SST(0x3F, 0x02, SS_RDEF,
-                       "Changed operating definition") },
-/* DTLPWRSOMCAE */{SST(0x3F, 0x03, SS_INQ_REFRESH|SSQ_DECREMENT_COUNT,
-                       "Inquiry data has changed") },
-/* DT  WR OMCAE */{SST(0x3F, 0x04, SS_RDEF,
-                       "Component device attached") },
-/* DT  WR OMCAE */{SST(0x3F, 0x05, SS_RDEF,
-                       "Device identifier changed") },
-/* DT  WR OMCAE */{SST(0x3F, 0x06, SS_RDEF,
-                       "Redundancy group created or modified") },
-/* DT  WR OMCAE */{SST(0x3F, 0x07, SS_RDEF,
-                       "Redundancy group deleted") },
-/* DT  WR OMCAE */{SST(0x3F, 0x08, SS_RDEF,
-                       "Spare created or modified") },
-/* DT  WR OMCAE */{SST(0x3F, 0x09, SS_RDEF,
-                       "Spare deleted") },
-/* DT  WR OMCAE */{SST(0x3F, 0x0A, SS_RDEF,
-                       "Volume set created or modified") },
-/* DT  WR OMCAE */{SST(0x3F, 0x0B, SS_RDEF,
-                       "Volume set deleted") },
-/* DT  WR OMCAE */{SST(0x3F, 0x0C, SS_RDEF,
-                       "Volume set deassigned") },
-/* DT  WR OMCAE */{SST(0x3F, 0x0D, SS_RDEF,
-                       "Volume set reassigned") },
-/* DTLPWRSOMCAE */{SST(0x3F, 0x0E, SS_RDEF,
-                       "Reported luns data has changed") },
-/* DTLPWRSOMCAE */{SST(0x3F, 0x0F, SS_RETRY|SSQ_DECREMENT_COUNT
-                                | SSQ_DELAY_RANDOM|EBUSY,
-                       "Echo buffer overwritten") },
-/* DT  WR OM   B*/{SST(0x3F, 0x0F, SS_RDEF, "Medium Loadable") },
-/* DT  WR OM   B*/{SST(0x3F, 0x0F, SS_RDEF,
-                       "Medium auxiliary memory accessible") },
-/* D            */{SST(0x40, 0x00, SS_RDEF,
-                       "Ram failure") }, /* deprecated - use 40 NN instead */
-/* DTLPWRSOMCAE */{SST(0x40, 0x80, SS_RDEF,
-                       "Diagnostic failure: ASCQ = Component ID") },
-/* DTLPWRSOMCAE */{SST(0x40, 0xFF, SS_RDEF|SSQ_RANGE,
-                       NULL) },/* Range 0x80->0xFF */
-/* D            */{SST(0x41, 0x00, SS_RDEF,
-                       "Data path failure") }, /* deprecated - use 40 NN instead */
-/* D            */{SST(0x42, 0x00, SS_RDEF,
-                       "Power-on or self-test failure") }, /* deprecated - use 40 NN instead */
-/* DTLPWRSOMCAE */{SST(0x43, 0x00, SS_RDEF,
-                       "Message error") },
-/* DTLPWRSOMCAE */{SST(0x44, 0x00, SS_RDEF,
-                       "Internal target failure") },
-/* DTLPWRSOMCAE */{SST(0x45, 0x00, SS_RDEF,
-                       "Select or reselect failure") },
-/* DTLPWRSOMC   */{SST(0x46, 0x00, SS_RDEF,
-                       "Unsuccessful soft reset") },
-/* DTLPWRSOMCAE */{SST(0x47, 0x00, SS_RDEF|SSQ_FALLBACK,
-                       "SCSI parity error") },
-/* DTLPWRSOMCAE */{SST(0x47, 0x01, SS_RDEF|SSQ_FALLBACK,
-                       "Data Phase CRC error detected") },
-/* DTLPWRSOMCAE */{SST(0x47, 0x02, SS_RDEF|SSQ_FALLBACK,
-                       "SCSI parity error detected during ST data phase") },
-/* DTLPWRSOMCAE */{SST(0x47, 0x03, SS_RDEF|SSQ_FALLBACK,
-                       "Information Unit iuCRC error") },
-/* DTLPWRSOMCAE */{SST(0x47, 0x04, SS_RDEF|SSQ_FALLBACK,
-                       "Asynchronous information protection error detected") },
-/* DTLPWRSOMCAE */{SST(0x47, 0x05, SS_RDEF|SSQ_FALLBACK,
-                       "Protocol server CRC error") },
-/* DTLPWRSOMCAE */{SST(0x48, 0x00, SS_RDEF|SSQ_FALLBACK,
-                       "Initiator detected error message received") },
-/* DTLPWRSOMCAE */{SST(0x49, 0x00, SS_RDEF,
-                       "Invalid message error") },
-/* DTLPWRSOMCAE */{SST(0x4A, 0x00, SS_RDEF,
-                       "Command phase error") },
-/* DTLPWRSOMCAE */{SST(0x4B, 0x00, SS_RDEF,
-                       "Data phase error") },
-/* DTLPWRSOMCAE */{SST(0x4C, 0x00, SS_RDEF,
-                       "Logical unit failed self-configuration") },
-/* DTLPWRSOMCAE */{SST(0x4D, 0x00, SS_RDEF,
-                       "Tagged overlapped commands: ASCQ = Queue tag ID") },
-/* DTLPWRSOMCAE */{SST(0x4D, 0xFF, SS_RDEF|SSQ_RANGE,
-                       NULL)}, /* Range 0x00->0xFF */
-/* DTLPWRSOMCAE */{SST(0x4E, 0x00, SS_RDEF,
-                       "Overlapped commands attempted") },
-/*  T           */{SST(0x50, 0x00, SS_RDEF,
-                       "Write append error") },
-/*  T           */{SST(0x50, 0x01, SS_RDEF,
-                       "Write append position error") },
-/*  T           */{SST(0x50, 0x02, SS_RDEF,
-                       "Position error related to timing") },
-/*  T     O     */{SST(0x51, 0x00, SS_RDEF,
-                       "Erase failure") },
-/*  T           */{SST(0x52, 0x00, SS_RDEF,
-                       "Cartridge fault") },
-/* DTL WRSOM    */{SST(0x53, 0x00, SS_RDEF,
-                       "Media load or eject failed") },
-/*  T           */{SST(0x53, 0x01, SS_RDEF,
-                       "Unload tape failure") },
-/* DT  WR OM    */{SST(0x53, 0x02, SS_RDEF,
-                       "Medium removal prevented") },
-/*    P         */{SST(0x54, 0x00, SS_RDEF,
-                       "Scsi to host system interface failure") },
-/*    P         */{SST(0x55, 0x00, SS_RDEF,
-                       "System resource failure") },
-/* D      O     */{SST(0x55, 0x01, SS_FATAL|ENOSPC,
-                       "System buffer full") },
-/*      R       */{SST(0x57, 0x00, SS_RDEF,
-                       "Unable to recover table-of-contents") },
-/*        O     */{SST(0x58, 0x00, SS_RDEF,
-                       "Generation does not exist") },
-/*        O     */{SST(0x59, 0x00, SS_RDEF,
-                       "Updated block read") },
-/* DTLPWRSOM    */{SST(0x5A, 0x00, SS_RDEF,
-                       "Operator request or state change input") },
-/* DT  WR OM    */{SST(0x5A, 0x01, SS_RDEF,
-                       "Operator medium removal request") },
-/* DT  W  O     */{SST(0x5A, 0x02, SS_RDEF,
-                       "Operator selected write protect") },
-/* DT  W  O     */{SST(0x5A, 0x03, SS_RDEF,
-                       "Operator selected write permit") },
-/* DTLPWRSOM    */{SST(0x5B, 0x00, SS_RDEF,
-                       "Log exception") },
-/* DTLPWRSOM    */{SST(0x5B, 0x01, SS_RDEF,
-                       "Threshold condition met") },
-/* DTLPWRSOM    */{SST(0x5B, 0x02, SS_RDEF,
-                       "Log counter at maximum") },
-/* DTLPWRSOM    */{SST(0x5B, 0x03, SS_RDEF,
-                       "Log list codes exhausted") },
-/* D      O     */{SST(0x5C, 0x00, SS_RDEF,
-                       "RPL status change") },
-/* D      O     */{SST(0x5C, 0x01, SS_NOP|SSQ_PRINT_SENSE,
-                       "Spindles synchronized") },
-/* D      O     */{SST(0x5C, 0x02, SS_RDEF,
-                       "Spindles not synchronized") },
-/* DTLPWRSOMCAE */{SST(0x5D, 0x00, SS_RDEF,
-                       "Failure prediction threshold exceeded") },
-/* DTLPWRSOMCAE */{SST(0x5D, 0xFF, SS_RDEF,
-                       "Failure prediction threshold exceeded (false)") },
-/* DTLPWRSO CA  */{SST(0x5E, 0x00, SS_RDEF,
-                       "Low power condition on") },
-/* DTLPWRSO CA  */{SST(0x5E, 0x01, SS_RDEF,
-                       "Idle condition activated by timer") },
-/* DTLPWRSO CA  */{SST(0x5E, 0x02, SS_RDEF,
-                       "Standby condition activated by timer") },
-/* DTLPWRSO CA  */{SST(0x5E, 0x03, SS_RDEF,
-                       "Idle condition activated by command") },
-/* DTLPWRSO CA  */{SST(0x5E, 0x04, SS_RDEF,
-                       "Standby condition activated by command") },
-/*       S      */{SST(0x60, 0x00, SS_RDEF,
-                       "Lamp failure") },
-/*       S      */{SST(0x61, 0x00, SS_RDEF,
-                       "Video acquisition error") },
-/*       S      */{SST(0x61, 0x01, SS_RDEF,
-                       "Unable to acquire video") },
-/*       S      */{SST(0x61, 0x02, SS_RDEF,
-                       "Out of focus") },
-/*       S      */{SST(0x62, 0x00, SS_RDEF,
-                       "Scan head positioning error") },
-/*      R       */{SST(0x63, 0x00, SS_RDEF,
-                       "End of user area encountered on this track") },
-/*      R       */{SST(0x63, 0x01, SS_FATAL|ENOSPC,
-                       "Packet does not fit in available space") },
-/*      R       */{SST(0x64, 0x00, SS_RDEF,
-                       "Illegal mode for this track") },
-/*      R       */{SST(0x64, 0x01, SS_RDEF,
-                       "Invalid packet size") },
-/* DTLPWRSOMCAE */{SST(0x65, 0x00, SS_RDEF,
-                       "Voltage fault") },
-/*       S      */{SST(0x66, 0x00, SS_RDEF,
-                       "Automatic document feeder cover up") },
-/*       S      */{SST(0x66, 0x01, SS_RDEF,
-                       "Automatic document feeder lift up") },
-/*       S      */{SST(0x66, 0x02, SS_RDEF,
-                       "Document jam in automatic document feeder") },
-/*       S      */{SST(0x66, 0x03, SS_RDEF,
-                       "Document miss feed automatic in document feeder") },
-/*           A  */{SST(0x67, 0x00, SS_RDEF,
-                       "Configuration failure") },
-/*           A  */{SST(0x67, 0x01, SS_RDEF,
-                       "Configuration of incapable logical units failed") },
-/*           A  */{SST(0x67, 0x02, SS_RDEF,
-                       "Add logical unit failed") },
-/*           A  */{SST(0x67, 0x03, SS_RDEF,
-                       "Modification of logical unit failed") },
-/*           A  */{SST(0x67, 0x04, SS_RDEF,
-                       "Exchange of logical unit failed") },
-/*           A  */{SST(0x67, 0x05, SS_RDEF,
-                       "Remove of logical unit failed") },
-/*           A  */{SST(0x67, 0x06, SS_RDEF,
-                       "Attachment of logical unit failed") },
-/*           A  */{SST(0x67, 0x07, SS_RDEF,
-                       "Creation of logical unit failed") },
-/*           A  */{SST(0x68, 0x00, SS_RDEF,
-                       "Logical unit not configured") },
-/*           A  */{SST(0x69, 0x00, SS_RDEF,
-                       "Data loss on logical unit") },
-/*           A  */{SST(0x69, 0x01, SS_RDEF,
-                       "Multiple logical unit failures") },
-/*           A  */{SST(0x69, 0x02, SS_RDEF,
-                       "Parity/data mismatch") },
-/*           A  */{SST(0x6A, 0x00, SS_RDEF,
-                       "Informational, refer to log") },
-/*           A  */{SST(0x6B, 0x00, SS_RDEF,
-                       "State change has occurred") },
-/*           A  */{SST(0x6B, 0x01, SS_RDEF,
-                       "Redundancy level got better") },
-/*           A  */{SST(0x6B, 0x02, SS_RDEF,
-                       "Redundancy level got worse") },
-/*           A  */{SST(0x6C, 0x00, SS_RDEF,
-                       "Rebuild failure occurred") },
-/*           A  */{SST(0x6D, 0x00, SS_RDEF,
-                       "Recalculate failure occurred") },
-/*           A  */{SST(0x6E, 0x00, SS_RDEF,
-                       "Command to logical unit failed") },
-/*  T           */{SST(0x70, 0x00, SS_RDEF,
-                       "Decompression exception short: ASCQ = Algorithm ID") },
-/*  T           */{SST(0x70, 0xFF, SS_RDEF|SSQ_RANGE,
-                       NULL) }, /* Range 0x00 -> 0xFF */
-/*  T           */{SST(0x71, 0x00, SS_RDEF,
-                       "Decompression exception long: ASCQ = Algorithm ID") },
-/*  T           */{SST(0x71, 0xFF, SS_RDEF|SSQ_RANGE,
-                       NULL) }, /* Range 0x00 -> 0xFF */       
-/*      R       */{SST(0x72, 0x00, SS_RDEF,
-                       "Session fixation error") },
-/*      R       */{SST(0x72, 0x01, SS_RDEF,
-                       "Session fixation error writing lead-in") },
-/*      R       */{SST(0x72, 0x02, SS_RDEF,
-                       "Session fixation error writing lead-out") },
-/*      R       */{SST(0x72, 0x03, SS_RDEF,
-                       "Session fixation error - incomplete track in session") },
-/*      R       */{SST(0x72, 0x04, SS_RDEF,
-                       "Empty or partially written reserved track") },
-/*      R       */{SST(0x73, 0x00, SS_RDEF,
-                       "CD control error") },
-/*      R       */{SST(0x73, 0x01, SS_RDEF,
-                       "Power calibration area almost full") },
-/*      R       */{SST(0x73, 0x02, SS_FATAL|ENOSPC,
-                       "Power calibration area is full") },
-/*      R       */{SST(0x73, 0x03, SS_RDEF,
-                       "Power calibration area error") },
-/*      R       */{SST(0x73, 0x04, SS_RDEF,
-                       "Program memory area update failure") },
-/*      R       */{SST(0x73, 0x05, SS_RDEF,
-                       "program memory area is full") }
-};
-
-static const int asc_table_size = sizeof(asc_table)/sizeof(asc_table[0]);
-
-struct asc_key
-{
-       int asc;
-       int ascq;
-};
-
-static int
-ascentrycomp(const void *key, const void *member)
-{
-       int asc;
-       int ascq;
-       const struct asc_table_entry *table_entry;
-
-       asc = ((const struct asc_key *)key)->asc;
-       ascq = ((const struct asc_key *)key)->ascq;
-       table_entry = (const struct asc_table_entry *)member;
-
-       if (asc >= table_entry->asc) {
-
-               if (asc > table_entry->asc)
-                       return (1);
-
-               if (ascq <= table_entry->ascq) {
-                       /* Check for ranges */
-                       if (ascq == table_entry->ascq
-                        || ((table_entry->action & SSQ_RANGE) != 0
-                          && ascq >= (table_entry - 1)->ascq))
-                               return (0);
-                       return (-1);
-               }
-               return (1);
-       }
-       return (-1);
-}
-
-static int
-senseentrycomp(const void *key, const void *member)
-{
-       int sense_key;
-       const struct sense_key_table_entry *table_entry;
-
-       sense_key = *((const int *)key);
-       table_entry = (const struct sense_key_table_entry *)member;
-
-       if (sense_key >= table_entry->sense_key) {
-               if (sense_key == table_entry->sense_key)
-                       return (0);
-               return (1);
-       }
-       return (-1);
-}
-
-static void
-fetchtableentries(int sense_key, int asc, int ascq,
-                 struct scsi_inquiry_data *inq_data,
-                 const struct sense_key_table_entry **sense_entry,
-                 const struct asc_table_entry **asc_entry)
-{
-       void *match;
-       const struct asc_table_entry *asc_tables[2];
-       const struct sense_key_table_entry *sense_tables[2];
-       struct asc_key asc_ascq;
-       size_t asc_tables_size[2];
-       size_t sense_tables_size[2];
-       int num_asc_tables;
-       int num_sense_tables;
-       int i;
-
-       /* Default to failure */
-       *sense_entry = NULL;
-       *asc_entry = NULL;
-       match = NULL;
-       if (inq_data != NULL)
-               match = cam_quirkmatch((void *)inq_data,
-                                      (void *)sense_quirk_table,
-                                      sense_quirk_table_size,
-                                      sizeof(*sense_quirk_table),
-                                      aic_inquiry_match);
-
-       if (match != NULL) {
-               struct scsi_sense_quirk_entry *quirk;
-
-               quirk = (struct scsi_sense_quirk_entry *)match;
-               asc_tables[0] = quirk->asc_info;
-               asc_tables_size[0] = quirk->num_ascs;
-               asc_tables[1] = asc_table;
-               asc_tables_size[1] = asc_table_size;
-               num_asc_tables = 2;
-               sense_tables[0] = quirk->sense_key_info;
-               sense_tables_size[0] = quirk->num_sense_keys;
-               sense_tables[1] = sense_key_table;
-               sense_tables_size[1] = sense_key_table_size;
-               num_sense_tables = 2;
-       } else {
-               asc_tables[0] = asc_table;
-               asc_tables_size[0] = asc_table_size;
-               num_asc_tables = 1;
-               sense_tables[0] = sense_key_table;
-               sense_tables_size[0] = sense_key_table_size;
-               num_sense_tables = 1;
-       }
-
-       asc_ascq.asc = asc;
-       asc_ascq.ascq = ascq;
-       for (i = 0; i < num_asc_tables; i++) {
-               void *found_entry;
-
-               found_entry = scsibsearch(&asc_ascq, asc_tables[i],
-                                         asc_tables_size[i],
-                                         sizeof(**asc_tables),
-                                         ascentrycomp);
-
-               if (found_entry) {
-                       *asc_entry = (struct asc_table_entry *)found_entry;
-                       break;
-               }
-       }
-
-       for (i = 0; i < num_sense_tables; i++) {
-               void *found_entry;
-
-               found_entry = scsibsearch(&sense_key, sense_tables[i],
-                                         sense_tables_size[i],
-                                         sizeof(**sense_tables),
-                                         senseentrycomp);
-
-               if (found_entry) {
-                       *sense_entry =
-                           (struct sense_key_table_entry *)found_entry;
-                       break;
-               }
-       }
-}
-
-static void *
-scsibsearch(const void *key, const void *base, size_t nmemb, size_t size,
-                int (*compar)(const void *, const void *))
-{
-       const void *entry;
-       u_int l;
-       u_int u;
-       u_int m;
-
-       l = -1;
-       u = nmemb;
-       while (l + 1 != u) {
-               m = (l + u) / 2;
-               entry = base + m * size;
-               if (compar(key, entry) > 0)
-                       l = m;
-               else
-                       u = m;
-       }
-
-       entry = base + u * size;
-       if (u == nmemb
-        || compar(key, entry) != 0)
-               return (NULL);
 
-       return ((void *)entry);
-}
-
-/*
- * Compare string with pattern, returning 0 on match.
- * Short pattern matches trailing blanks in name,
- * wildcard '*' in pattern matches rest of name,
- * wildcard '?' matches a single non-space character.
- */
-static int
-cam_strmatch(const uint8_t *str, const uint8_t *pattern, int str_len)
-{
-
-       while (*pattern != '\0'&& str_len > 0) {  
-
-               if (*pattern == '*') {
-                       return (0);
-               }
-               if ((*pattern != *str)
-                && (*pattern != '?' || *str == ' ')) {
-                       return (1);
-               }
-               pattern++;
-               str++;
-               str_len--;
-       }
-       while (str_len > 0 && *str++ == ' ')
-               str_len--;
-
-       return (str_len);
-}
-
-static caddr_t
-cam_quirkmatch(caddr_t target, caddr_t quirk_table, int num_entries,
-              int entry_size, cam_quirkmatch_t *comp_func)
-{
-       for (; num_entries > 0; num_entries--, quirk_table += entry_size) {
-               if ((*comp_func)(target, quirk_table) == 0)
-                       return (quirk_table);
-       }
-       return (NULL);
-}
-
-void
-aic_sense_desc(int sense_key, int asc, int ascq,
-              struct scsi_inquiry_data *inq_data,
-              const char **sense_key_desc, const char **asc_desc)
-{
-       const struct asc_table_entry *asc_entry;
-       const struct sense_key_table_entry *sense_entry;
-
-       fetchtableentries(sense_key, asc, ascq,
-                         inq_data,
-                         &sense_entry,
-                         &asc_entry);
-
-       *sense_key_desc = sense_entry->desc;
-
-       if (asc_entry != NULL)
-               *asc_desc = asc_entry->desc;
-       else if (asc >= 0x80 && asc <= 0xff)
-               *asc_desc = "Vendor Specific ASC";
-       else if (ascq >= 0x80 && ascq <= 0xff)
-               *asc_desc = "Vendor Specific ASCQ";
-       else
-               *asc_desc = "Reserved ASC/ASCQ pair";
-}
-
-/*
- * Given sense and device type information, return the appropriate action.
- * If we do not understand the specific error as identified by the ASC/ASCQ
- * pair, fall back on the more generic actions derived from the sense key.
- */
-aic_sense_action
-aic_sense_error_action(struct scsi_sense_data *sense_data,
-                      struct scsi_inquiry_data *inq_data, uint32_t sense_flags)
-{
-       const struct asc_table_entry *asc_entry;
-       const struct sense_key_table_entry *sense_entry;
-       int error_code, sense_key, asc, ascq;
-       aic_sense_action action;
-
-       scsi_extract_sense(sense_data, &error_code, &sense_key, &asc, &ascq);
-
-       if (error_code == SSD_DEFERRED_ERROR) {
-               /*
-                * XXX dufault@FreeBSD.org
-                * This error doesn't relate to the command associated
-                * with this request sense.  A deferred error is an error
-                * for a command that has already returned GOOD status
-                * (see SCSI2 8.2.14.2).
-                *
-                * By my reading of that section, it looks like the current
-                * command has been cancelled, we should now clean things up
-                * (hopefully recovering any lost data) and then retry the
-                * current command.  There are two easy choices, both wrong:
-                *
-                * 1. Drop through (like we had been doing), thus treating
-                *    this as if the error were for the current command and
-                *    return and stop the current command.
-                * 
-                * 2. Issue a retry (like I made it do) thus hopefully
-                *    recovering the current transfer, and ignoring the
-                *    fact that we've dropped a command.
-                *
-                * These should probably be handled in a device specific
-                * sense handler or punted back up to a user mode daemon
-                */
-               action = SS_RETRY|SSQ_DECREMENT_COUNT|SSQ_PRINT_SENSE;
-       } else {
-               fetchtableentries(sense_key, asc, ascq,
-                                 inq_data,
-                                 &sense_entry,
-                                 &asc_entry);
-
-               /*
-                * Override the 'No additional Sense' entry (0,0)
-                * with the error action of the sense key.
-                */
-               if (asc_entry != NULL
-                && (asc != 0 || ascq != 0))
-                       action = asc_entry->action;
-               else
-                       action = sense_entry->action;
-
-               if (sense_key == SSD_KEY_RECOVERED_ERROR) {
-                       /*
-                        * The action succeeded but the device wants
-                        * the user to know that some recovery action
-                        * was required.
-                        */
-                       action &= ~(SS_MASK|SSQ_MASK|SS_ERRMASK);
-                       action |= SS_NOP|SSQ_PRINT_SENSE;
-               } else if (sense_key == SSD_KEY_ILLEGAL_REQUEST) {
-                       if ((sense_flags & SF_QUIET_IR) != 0)
-                               action &= ~SSQ_PRINT_SENSE;
-               } else if (sense_key == SSD_KEY_UNIT_ATTENTION) {
-                       if ((sense_flags & SF_RETRY_UA) != 0
-                        && (action & SS_MASK) == SS_FAIL) {
-                               action &= ~(SS_MASK|SSQ_MASK);
-                               action |= SS_RETRY|SSQ_DECREMENT_COUNT|
-                                         SSQ_PRINT_SENSE;
-                       }
-               }
-       }
-
-       if ((sense_flags & SF_PRINT_ALWAYS) != 0)
-               action |= SSQ_PRINT_SENSE;
-       else if ((sense_flags & SF_NO_PRINT) != 0)
-               action &= ~SSQ_PRINT_SENSE;
-
-       return (action);
-}
-
-/*      
- * Try make as good a match as possible with
- * available sub drivers
- */
-int
-aic_inquiry_match(caddr_t inqbuffer, caddr_t table_entry)
-{
-       struct scsi_inquiry_pattern *entry;
-       struct scsi_inquiry_data *inq;
-       entry = (struct scsi_inquiry_pattern *)table_entry;
-       inq = (struct scsi_inquiry_data *)inqbuffer;
-
-       if (((SID_TYPE(inq) == entry->type)
-         || (entry->type == T_ANY))
-        && (SID_IS_REMOVABLE(inq) ? entry->media_type & SIP_MEDIA_REMOVABLE
-                                  : entry->media_type & SIP_MEDIA_FIXED)
-        && (cam_strmatch(inq->vendor, entry->vendor, sizeof(inq->vendor)) == 0)
-        && (cam_strmatch(inq->product, entry->product,
-                         sizeof(inq->product)) == 0)
-        && (cam_strmatch(inq->revision, entry->revision,
-                         sizeof(inq->revision)) == 0)) {
-               return (0);
-       }
-        return (-1);
-}
 
 /*
  * Table of syncrates that don't follow the "divisible by 4"
@@ -1229,108 +75,6 @@ aic_calc_syncsrate(u_int period_factor)
        return (10000000 / (period_factor * 4 * 10));
 }
 
-/*
- * Return speed in KB/s.
- */
-u_int
-aic_calc_speed(u_int width, u_int period, u_int offset, u_int min_rate)
-{
-       u_int freq;
-
-       if (offset != 0 && period < min_rate)
-               freq  = aic_calc_syncsrate(period);
-       else
-               /* Roughly 3.3MB/s for async */
-               freq  = 3300;
-       freq <<= width;
-       return (freq);
-}
-
-uint32_t
-aic_error_action(struct scsi_cmnd *cmd, struct scsi_inquiry_data *inq_data,
-                cam_status status, u_int scsi_status)
-{
-       aic_sense_action  err_action;
-       int               sense;
-
-       sense  = (cmd->result >> 24) == DRIVER_SENSE;
-
-       switch (status) {
-       case CAM_REQ_CMP:
-               err_action = SS_NOP;
-               break;
-       case CAM_AUTOSENSE_FAIL:
-       case CAM_SCSI_STATUS_ERROR:
-
-               switch (scsi_status) {
-               case SCSI_STATUS_OK:
-               case SCSI_STATUS_COND_MET:
-               case SCSI_STATUS_INTERMED:
-               case SCSI_STATUS_INTERMED_COND_MET:
-                       err_action = SS_NOP;
-                       break;
-               case SCSI_STATUS_CMD_TERMINATED:
-               case SCSI_STATUS_CHECK_COND:
-                       if (sense != 0) {
-                               struct scsi_sense_data *sense;
-
-                               sense = (struct scsi_sense_data *)
-                                   &cmd->sense_buffer;
-                               err_action =
-                                   aic_sense_error_action(sense, inq_data, 0);
-
-                       } else {
-                               err_action = SS_RETRY|SSQ_FALLBACK
-                                          | SSQ_DECREMENT_COUNT|EIO;
-                       }
-                       break;
-               case SCSI_STATUS_QUEUE_FULL:
-               case SCSI_STATUS_BUSY:
-                       err_action = SS_RETRY|SSQ_DELAY|SSQ_MANY
-                                  | SSQ_DECREMENT_COUNT|EBUSY;
-                       break;
-               case SCSI_STATUS_RESERV_CONFLICT:
-               default:
-                       err_action = SS_FAIL|EBUSY;
-                       break;
-               }
-               break;
-       case CAM_CMD_TIMEOUT:
-       case CAM_REQ_CMP_ERR:
-       case CAM_UNEXP_BUSFREE:
-       case CAM_UNCOR_PARITY:
-       case CAM_DATA_RUN_ERR:
-               err_action = SS_RETRY|SSQ_FALLBACK|EIO;
-               break;
-       case CAM_UA_ABORT:
-       case CAM_UA_TERMIO:
-       case CAM_MSG_REJECT_REC:
-       case CAM_SEL_TIMEOUT:
-               err_action = SS_FAIL|EIO;
-               break;
-       case CAM_REQ_INVALID:
-       case CAM_PATH_INVALID:
-       case CAM_DEV_NOT_THERE:
-       case CAM_NO_HBA:
-       case CAM_PROVIDE_FAIL:
-       case CAM_REQ_TOO_BIG:           
-       case CAM_RESRC_UNAVAIL:
-       case CAM_BUSY:
-       default:
-               /* panic??  These should never occur in our application. */
-               err_action = SS_FAIL|EIO;
-               break;
-       case CAM_SCSI_BUS_RESET:
-       case CAM_BDR_SENT:              
-       case CAM_REQUEUE_REQ:
-               /* Unconditional requeue */
-               err_action = SS_RETRY;
-               break;
-       }
-
-       return (err_action);
-}
-
 char *
 aic_parse_brace_option(char *opt_name, char *opt_arg, char *end, int depth,
                       aic_option_callback_t *callback, u_long callback_arg)
index bfe6f954d3c4092b58029c3424424b1b5c4350ba..e7d94cbaf2a8043adef71bdd05760084933ba664 100644 (file)
 #ifndef        _AICLIB_H
 #define _AICLIB_H
 
-/*
- * Linux Interrupt Support.
- */
-#ifndef IRQ_RETVAL
-typedef void irqreturn_t;
-#define        IRQ_RETVAL(x)
-#endif
-
-/*
- * SCSI command format
- */
-
-/*
- * Define dome bits that are in ALL (or a lot of) scsi commands
- */
-#define SCSI_CTL_LINK          0x01
-#define SCSI_CTL_FLAG          0x02
-#define SCSI_CTL_VENDOR                0xC0
-#define        SCSI_CMD_LUN            0xA0    /* these two should not be needed */
-#define        SCSI_CMD_LUN_SHIFT      5       /* LUN in the cmd is no longer SCSI */
-
-#define SCSI_MAX_CDBLEN                16      /* 
-                                        * 16 byte commands are in the 
-                                        * SCSI-3 spec 
-                                        */
-/* 6byte CDBs special case 0 length to be 256 */
-#define SCSI_CDB6_LEN(len)     ((len) == 0 ? 256 : len)
-
-/*
- * This type defines actions to be taken when a particular sense code is
- * received.  Right now, these flags are only defined to take up 16 bits,
- * but can be expanded in the future if necessary.
- */
-typedef enum {
-       SS_NOP          = 0x000000, /* Do nothing */
-       SS_RETRY        = 0x010000, /* Retry the command */
-       SS_FAIL         = 0x020000, /* Bail out */
-       SS_START        = 0x030000, /* Send a Start Unit command to the device,
-                                    * then retry the original command.
-                                    */
-       SS_TUR          = 0x040000, /* Send a Test Unit Ready command to the
-                                    * device, then retry the original command.
-                                    */
-       SS_REQSENSE     = 0x050000, /* Send a RequestSense command to the
-                                    * device, then retry the original command.
-                                    */
-       SS_INQ_REFRESH  = 0x060000,
-       SS_MASK         = 0xff0000
-} aic_sense_action;
-
-typedef enum {
-       SSQ_NONE                = 0x0000,
-       SSQ_DECREMENT_COUNT     = 0x0100,  /* Decrement the retry count */
-       SSQ_MANY                = 0x0200,  /* send lots of recovery commands */
-       SSQ_RANGE               = 0x0400,  /*
-                                           * This table entry represents the
-                                           * end of a range of ASCQs that
-                                           * have identical error actions
-                                           * and text.
-                                           */
-       SSQ_PRINT_SENSE         = 0x0800,
-       SSQ_DELAY               = 0x1000,  /* Delay before retry. */
-       SSQ_DELAY_RANDOM        = 0x2000,  /* Randomized delay before retry. */
-       SSQ_FALLBACK            = 0x4000,  /* Do a speed fallback to recover */
-       SSQ_MASK                = 0xff00
-} aic_sense_action_qualifier;
-
-/* Mask for error status values */
-#define SS_ERRMASK     0xff
-
-/* The default, retyable, error action */
-#define SS_RDEF                SS_RETRY|SSQ_DECREMENT_COUNT|SSQ_PRINT_SENSE|EIO
-
-/* The retyable, error action, with table specified error code */
-#define SS_RET         SS_RETRY|SSQ_DECREMENT_COUNT|SSQ_PRINT_SENSE
-
-/* Fatal error action, with table specified error code */
-#define SS_FATAL       SS_FAIL|SSQ_PRINT_SENSE
-
-struct scsi_generic
-{
-       uint8_t opcode;
-       uint8_t bytes[11];
-};
-
-struct scsi_request_sense
-{
-       uint8_t opcode;
-       uint8_t byte2;
-       uint8_t unused[2];
-       uint8_t length;
-       uint8_t control;
-};
-
-struct scsi_test_unit_ready
-{
-       uint8_t opcode;
-       uint8_t byte2;
-       uint8_t unused[3];
-       uint8_t control;
-};
-
-struct scsi_send_diag
-{
-       uint8_t opcode;
-       uint8_t byte2;
-#define        SSD_UOL         0x01
-#define        SSD_DOL         0x02
-#define        SSD_SELFTEST    0x04
-#define        SSD_PF          0x10
-       uint8_t unused[1];
-       uint8_t paramlen[2];
-       uint8_t control;
-};
-
 struct scsi_sense
 {
        uint8_t opcode;
@@ -181,537 +66,12 @@ struct scsi_sense
        uint8_t control;
 };
 
-struct scsi_inquiry
-{
-       uint8_t opcode;
-       uint8_t byte2;
-#define        SI_EVPD 0x01
-       uint8_t page_code;
-       uint8_t reserved;
-       uint8_t length;
-       uint8_t control;
-};
-
-struct scsi_mode_sense_6
-{
-       uint8_t opcode;
-       uint8_t byte2;
-#define        SMS_DBD                         0x08
-       uint8_t page;
-#define        SMS_PAGE_CODE                   0x3F
-#define SMS_VENDOR_SPECIFIC_PAGE       0x00
-#define SMS_DISCONNECT_RECONNECT_PAGE  0x02
-#define SMS_PERIPHERAL_DEVICE_PAGE     0x09
-#define SMS_CONTROL_MODE_PAGE          0x0A
-#define SMS_ALL_PAGES_PAGE             0x3F
-#define        SMS_PAGE_CTRL_MASK              0xC0
-#define        SMS_PAGE_CTRL_CURRENT           0x00
-#define        SMS_PAGE_CTRL_CHANGEABLE        0x40
-#define        SMS_PAGE_CTRL_DEFAULT           0x80
-#define        SMS_PAGE_CTRL_SAVED             0xC0
-       uint8_t unused;
-       uint8_t length;
-       uint8_t control;
-};
-
-struct scsi_mode_sense_10
-{
-       uint8_t opcode;
-       uint8_t byte2;          /* same bits as small version */
-       uint8_t page;           /* same bits as small version */
-       uint8_t unused[4];
-       uint8_t length[2];
-       uint8_t control;
-};
-
-struct scsi_mode_select_6
-{
-       uint8_t opcode;
-       uint8_t byte2;
-#define        SMS_SP  0x01
-#define        SMS_PF  0x10
-       uint8_t unused[2];
-       uint8_t length;
-       uint8_t control;
-};
-
-struct scsi_mode_select_10
-{
-       uint8_t opcode;
-       uint8_t byte2;          /* same bits as small version */
-       uint8_t unused[5];
-       uint8_t length[2];
-       uint8_t control;
-};
-
-/*
- * When sending a mode select to a tape drive, the medium type must be 0.
- */
-struct scsi_mode_hdr_6
-{
-       uint8_t datalen;
-       uint8_t medium_type;
-       uint8_t dev_specific;
-       uint8_t block_descr_len;
-};
-
-struct scsi_mode_hdr_10
-{
-       uint8_t datalen[2];
-       uint8_t medium_type;
-       uint8_t dev_specific;
-       uint8_t reserved[2];
-       uint8_t block_descr_len[2];
-};
-
-struct scsi_mode_block_descr
-{
-       uint8_t density_code;
-       uint8_t num_blocks[3];
-       uint8_t reserved;
-       uint8_t block_len[3];
-};
-
-struct scsi_log_sense
-{
-       uint8_t opcode;
-       uint8_t byte2;
-#define        SLS_SP                          0x01
-#define        SLS_PPC                         0x02
-       uint8_t page;
-#define        SLS_PAGE_CODE                   0x3F
-#define        SLS_ALL_PAGES_PAGE              0x00
-#define        SLS_OVERRUN_PAGE                0x01
-#define        SLS_ERROR_WRITE_PAGE            0x02
-#define        SLS_ERROR_READ_PAGE             0x03
-#define        SLS_ERROR_READREVERSE_PAGE      0x04
-#define        SLS_ERROR_VERIFY_PAGE           0x05
-#define        SLS_ERROR_NONMEDIUM_PAGE        0x06
-#define        SLS_ERROR_LASTN_PAGE            0x07
-#define        SLS_PAGE_CTRL_MASK              0xC0
-#define        SLS_PAGE_CTRL_THRESHOLD         0x00
-#define        SLS_PAGE_CTRL_CUMULATIVE        0x40
-#define        SLS_PAGE_CTRL_THRESH_DEFAULT    0x80
-#define        SLS_PAGE_CTRL_CUMUL_DEFAULT     0xC0
-       uint8_t reserved[2];
-       uint8_t paramptr[2];
-       uint8_t length[2];
-       uint8_t control;
-};
-
-struct scsi_log_select
-{
-       uint8_t opcode;
-       uint8_t byte2;
-/*     SLS_SP                          0x01 */
-#define        SLS_PCR                         0x02
-       uint8_t page;
-/*     SLS_PAGE_CTRL_MASK              0xC0 */
-/*     SLS_PAGE_CTRL_THRESHOLD         0x00 */
-/*     SLS_PAGE_CTRL_CUMULATIVE        0x40 */
-/*     SLS_PAGE_CTRL_THRESH_DEFAULT    0x80 */
-/*     SLS_PAGE_CTRL_CUMUL_DEFAULT     0xC0 */
-       uint8_t reserved[4];
-       uint8_t length[2];
-       uint8_t control;
-};
-
-struct scsi_log_header
-{
-       uint8_t page;
-       uint8_t reserved;
-       uint8_t datalen[2];
-};
-
-struct scsi_log_param_header {
-       uint8_t param_code[2];
-       uint8_t param_control;
-#define        SLP_LP                          0x01
-#define        SLP_LBIN                        0x02
-#define        SLP_TMC_MASK                    0x0C
-#define        SLP_TMC_ALWAYS                  0x00
-#define        SLP_TMC_EQUAL                   0x04
-#define        SLP_TMC_NOTEQUAL                0x08
-#define        SLP_TMC_GREATER                 0x0C
-#define        SLP_ETC                         0x10
-#define        SLP_TSD                         0x20
-#define        SLP_DS                          0x40
-#define        SLP_DU                          0x80
-       uint8_t param_len;
-};
-
-struct scsi_control_page {
-       uint8_t page_code;
-       uint8_t page_length;
-       uint8_t rlec;
-#define SCB_RLEC                       0x01    /*Report Log Exception Cond*/
-       uint8_t queue_flags;
-#define SCP_QUEUE_ALG_MASK             0xF0
-#define SCP_QUEUE_ALG_RESTRICTED       0x00
-#define SCP_QUEUE_ALG_UNRESTRICTED     0x10
-#define SCP_QUEUE_ERR                  0x02    /*Queued I/O aborted for CACs*/
-#define SCP_QUEUE_DQUE                 0x01    /*Queued I/O disabled*/
-       uint8_t eca_and_aen;
-#define SCP_EECA                       0x80    /*Enable Extended CA*/
-#define SCP_RAENP                      0x04    /*Ready AEN Permission*/
-#define SCP_UAAENP                     0x02    /*UA AEN Permission*/
-#define SCP_EAENP                      0x01    /*Error AEN Permission*/
-       uint8_t reserved;
-       uint8_t aen_holdoff_period[2];
-};
-
-struct scsi_reserve
-{
-       uint8_t opcode;
-       uint8_t byte2;
-       uint8_t unused[2];
-       uint8_t length;
-       uint8_t control;
-};
-
-struct scsi_release
-{
-       uint8_t opcode;
-       uint8_t byte2;
-       uint8_t unused[2];
-       uint8_t length;
-       uint8_t control;
-};
-
-struct scsi_prevent
-{
-       uint8_t opcode;
-       uint8_t byte2;
-       uint8_t unused[2];
-       uint8_t how;
-       uint8_t control;
-};
-#define        PR_PREVENT 0x01
-#define PR_ALLOW   0x00
-
-struct scsi_sync_cache
-{
-       uint8_t opcode;
-       uint8_t byte2;
-       uint8_t begin_lba[4];
-       uint8_t reserved;
-       uint8_t lb_count[2];
-       uint8_t control;        
-};
-
-
-struct scsi_changedef
-{
-       uint8_t opcode;
-       uint8_t byte2;
-       uint8_t unused1;
-       uint8_t how;
-       uint8_t unused[4];
-       uint8_t datalen;
-       uint8_t control;
-};
-
-struct scsi_read_buffer
-{
-       uint8_t opcode;
-       uint8_t byte2;
-#define        RWB_MODE                0x07
-#define        RWB_MODE_HDR_DATA       0x00
-#define        RWB_MODE_DATA           0x02
-#define        RWB_MODE_DOWNLOAD       0x04
-#define        RWB_MODE_DOWNLOAD_SAVE  0x05
-        uint8_t buffer_id;
-        uint8_t offset[3];
-        uint8_t length[3];
-        uint8_t control;
-};
-
-struct scsi_write_buffer
-{
-       uint8_t opcode;
-       uint8_t byte2;
-       uint8_t buffer_id;
-       uint8_t offset[3];
-       uint8_t length[3];
-       uint8_t control;
-};
-
-struct scsi_rw_6
-{
-       uint8_t opcode;
-       uint8_t addr[3];
-/* only 5 bits are valid in the MSB address byte */
-#define        SRW_TOPADDR     0x1F
-       uint8_t length;
-       uint8_t control;
-};
-
-struct scsi_rw_10
-{
-       uint8_t opcode;
-#define        SRW10_RELADDR   0x01
-#define SRW10_FUA      0x08
-#define        SRW10_DPO       0x10
-       uint8_t byte2;
-       uint8_t addr[4];
-       uint8_t reserved;
-       uint8_t length[2];
-       uint8_t control;
-};
-
-struct scsi_rw_12
-{
-       uint8_t opcode;
-#define        SRW12_RELADDR   0x01
-#define SRW12_FUA      0x08
-#define        SRW12_DPO       0x10
-       uint8_t byte2;
-       uint8_t addr[4];
-       uint8_t length[4];
-       uint8_t reserved;
-       uint8_t control;
-};
-
-struct scsi_start_stop_unit
-{
-       uint8_t opcode;
-       uint8_t byte2;
-#define        SSS_IMMED               0x01
-       uint8_t reserved[2];
-       uint8_t how;
-#define        SSS_START               0x01
-#define        SSS_LOEJ                0x02
-       uint8_t control;
-};
-
-#define SC_SCSI_1 0x01
-#define SC_SCSI_2 0x03
-
-/*
- * Opcodes
- */
-
-#define        TEST_UNIT_READY         0x00
-#define REQUEST_SENSE          0x03
-#define        READ_6                  0x08
-#define WRITE_6                        0x0a
-#define INQUIRY                        0x12
-#define MODE_SELECT_6          0x15
-#define MODE_SENSE_6           0x1a
-#define START_STOP_UNIT                0x1b
-#define START_STOP             0x1b
-#define RESERVE                0x16
-#define RELEASE                0x17
-#define        RECEIVE_DIAGNOSTIC      0x1c
-#define        SEND_DIAGNOSTIC         0x1d
-#define PREVENT_ALLOW          0x1e
-#define        READ_CAPACITY           0x25
-#define        READ_10                 0x28
-#define WRITE_10               0x2a
-#define POSITION_TO_ELEMENT    0x2b
-#define        SYNCHRONIZE_CACHE       0x35
-#define        WRITE_BUFFER            0x3b
-#define        READ_BUFFER             0x3c
-#define        CHANGE_DEFINITION       0x40
-#define        LOG_SELECT              0x4c
-#define        LOG_SENSE               0x4d
-#ifdef XXXCAM
-#define        MODE_SENSE_10           0x5A
-#endif
-#define        MODE_SELECT_10          0x55
-#define MOVE_MEDIUM            0xa5
-#define READ_12                        0xa8
-#define WRITE_12               0xaa
-#define READ_ELEMENT_STATUS    0xb8
-
-
-/*
- * Device Types
- */
-#define T_DIRECT       0x00
-#define T_SEQUENTIAL   0x01
-#define T_PRINTER      0x02
-#define T_PROCESSOR    0x03
-#define T_WORM         0x04
-#define T_CDROM                0x05
-#define T_SCANNER      0x06
-#define T_OPTICAL      0x07
-#define T_CHANGER      0x08
-#define T_COMM         0x09
-#define T_ASC0         0x0a
-#define T_ASC1         0x0b
-#define        T_STORARRAY     0x0c
-#define        T_ENCLOSURE     0x0d
-#define        T_RBC           0x0e
-#define        T_OCRW          0x0f
-#define T_NODEVICE     0x1F
-#define        T_ANY           0xFF    /* Used in Quirk table matches */
-
-#define T_REMOV                1
-#define        T_FIXED         0
-
-/*
- * This length is the initial inquiry length used by the probe code, as    
- * well as the legnth necessary for aic_print_inquiry() to function 
- * correctly.  If either use requires a different length in the future, 
- * the two values should be de-coupled.
- */
-#define        SHORT_INQUIRY_LENGTH    36
-
-struct scsi_inquiry_data
-{
-       uint8_t device;
-#define        SID_TYPE(inq_data) ((inq_data)->device & 0x1f)
-#define        SID_QUAL(inq_data) (((inq_data)->device & 0xE0) >> 5)
-#define        SID_QUAL_LU_CONNECTED   0x00    /*
-                                        * The specified peripheral device
-                                        * type is currently connected to
-                                        * logical unit.  If the target cannot
-                                        * determine whether or not a physical
-                                        * device is currently connected, it
-                                        * shall also use this peripheral
-                                        * qualifier when returning the INQUIRY
-                                        * data.  This peripheral qualifier
-                                        * does not mean that the device is
-                                        * ready for access by the initiator.
-                                        */
-#define        SID_QUAL_LU_OFFLINE     0x01    /*
-                                        * The target is capable of supporting
-                                        * the specified peripheral device type
-                                        * on this logical unit; however, the
-                                        * physical device is not currently
-                                        * connected to this logical unit.
-                                        */
-#define SID_QUAL_RSVD          0x02
-#define        SID_QUAL_BAD_LU         0x03    /*
-                                        * The target is not capable of
-                                        * supporting a physical device on
-                                        * this logical unit. For this
-                                        * peripheral qualifier the peripheral
-                                        * device type shall be set to 1Fh to
-                                        * provide compatibility with previous
-                                        * versions of SCSI. All other
-                                        * peripheral device type values are
-                                        * reserved for this peripheral
-                                        * qualifier.
-                                        */
-#define        SID_QUAL_IS_VENDOR_UNIQUE(inq_data) ((SID_QUAL(inq_data) & 0x08) != 0)
-       uint8_t dev_qual2;
-#define        SID_QUAL2       0x7F
-#define        SID_IS_REMOVABLE(inq_data) (((inq_data)->dev_qual2 & 0x80) != 0)
-       uint8_t version;
-#define SID_ANSI_REV(inq_data) ((inq_data)->version & 0x07)
 #define                SCSI_REV_0              0
 #define                SCSI_REV_CCS            1
 #define                SCSI_REV_2              2
 #define                SCSI_REV_SPC            3
 #define                SCSI_REV_SPC2           4
 
-#define SID_ECMA       0x38
-#define SID_ISO                0xC0
-       uint8_t response_format;
-#define SID_AENC       0x80
-#define SID_TrmIOP     0x40
-       uint8_t additional_length;
-       uint8_t reserved[2];
-       uint8_t flags;
-#define        SID_SftRe       0x01
-#define        SID_CmdQue      0x02
-#define        SID_Linked      0x08
-#define        SID_Sync        0x10
-#define        SID_WBus16      0x20
-#define        SID_WBus32      0x40
-#define        SID_RelAdr      0x80
-#define SID_VENDOR_SIZE   8
-       char     vendor[SID_VENDOR_SIZE];
-#define SID_PRODUCT_SIZE  16
-       char     product[SID_PRODUCT_SIZE];
-#define SID_REVISION_SIZE 4
-       char     revision[SID_REVISION_SIZE];
-       /*
-        * The following fields were taken from SCSI Primary Commands - 2
-        * (SPC-2) Revision 14, Dated 11 November 1999
-        */
-#define        SID_VENDOR_SPECIFIC_0_SIZE      20
-       uint8_t vendor_specific0[SID_VENDOR_SPECIFIC_0_SIZE];
-       /*
-        * An extension of SCSI Parallel Specific Values
-        */
-#define        SID_SPI_IUS             0x01
-#define        SID_SPI_QAS             0x02
-#define        SID_SPI_CLOCK_ST        0x00
-#define        SID_SPI_CLOCK_DT        0x04
-#define        SID_SPI_CLOCK_DT_ST     0x0C
-#define        SID_SPI_MASK            0x0F
-       uint8_t spi3data;
-       uint8_t reserved2;
-       /*
-        * Version Descriptors, stored 2 byte values.
-        */
-       uint8_t version1[2];
-       uint8_t version2[2];
-       uint8_t version3[2];
-       uint8_t version4[2];
-       uint8_t version5[2];
-       uint8_t version6[2];
-       uint8_t version7[2];
-       uint8_t version8[2];
-
-       uint8_t reserved3[22];
-
-#define        SID_VENDOR_SPECIFIC_1_SIZE      160
-       uint8_t vendor_specific1[SID_VENDOR_SPECIFIC_1_SIZE];
-};
-
-struct scsi_vpd_unit_serial_number
-{
-       uint8_t device;
-       uint8_t page_code;
-#define SVPD_UNIT_SERIAL_NUMBER        0x80
-       uint8_t reserved;
-       uint8_t length; /* serial number length */
-#define SVPD_SERIAL_NUM_SIZE 251
-       uint8_t serial_num[SVPD_SERIAL_NUM_SIZE];
-};
-
-struct scsi_read_capacity
-{
-       uint8_t opcode;
-       uint8_t byte2;
-       uint8_t addr[4];
-       uint8_t unused[3];
-       uint8_t control;
-};
-
-struct scsi_read_capacity_data
-{
-       uint8_t addr[4];
-       uint8_t length[4];
-};
-
-struct scsi_report_luns
-{
-       uint8_t opcode;
-       uint8_t byte2;
-       uint8_t unused[3];
-       uint8_t addr[4];
-       uint8_t control;
-};
-
-struct scsi_report_luns_data {
-       uint8_t length[4];      /* length of LUN inventory, in bytes */
-       uint8_t reserved[4];    /* unused */
-       /*
-        * LUN inventory- we only support the type zero form for now.
-        */
-       struct {
-               uint8_t lundata[8];
-       } luns[1];
-};
-#define        RPL_LUNDATA_ATYP_MASK   0xc0    /* MBZ for type 0 lun */
-#define        RPL_LUNDATA_T0LUN       1       /* @ lundata[1] */
-
-
 struct scsi_sense_data
 {
        uint8_t error_code;
@@ -757,41 +117,6 @@ struct scsi_sense_data
 #define SSD_FULL_SIZE sizeof(struct scsi_sense_data)
 };
 
-struct scsi_mode_header_6
-{
-       uint8_t data_length;    /* Sense data length */
-       uint8_t medium_type;
-       uint8_t dev_spec;
-       uint8_t blk_desc_len;
-};
-
-struct scsi_mode_header_10
-{
-       uint8_t data_length[2];/* Sense data length */
-       uint8_t medium_type;
-       uint8_t dev_spec;
-       uint8_t unused[2];
-       uint8_t blk_desc_len[2];
-};
-
-struct scsi_mode_page_header
-{
-       uint8_t page_code;
-       uint8_t page_length;
-};
-
-struct scsi_mode_blk_desc
-{
-       uint8_t density;
-       uint8_t nblocks[3];
-       uint8_t reserved;
-       uint8_t blklen[3];
-};
-
-#define        SCSI_DEFAULT_DENSITY    0x00    /* use 'default' density */
-#define        SCSI_SAME_DENSITY       0x7f    /* use 'same' density- >= SCSI-2 only */
-
-
 /*
  * Status Byte
  */
@@ -807,76 +132,7 @@ struct scsi_mode_blk_desc
 #define SCSI_STATUS_ACA_ACTIVE         0x30
 #define SCSI_STATUS_TASK_ABORTED       0x40
 
-struct scsi_inquiry_pattern {
-       uint8_t   type;
-       uint8_t   media_type;
-#define        SIP_MEDIA_REMOVABLE     0x01
-#define        SIP_MEDIA_FIXED         0x02
-       const char *vendor;
-       const char *product;
-       const char *revision;
-}; 
-
-struct scsi_static_inquiry_pattern {
-       uint8_t   type;
-       uint8_t   media_type;
-       char       vendor[SID_VENDOR_SIZE+1];
-       char       product[SID_PRODUCT_SIZE+1];
-       char       revision[SID_REVISION_SIZE+1];
-};
-
-struct scsi_sense_quirk_entry {
-       struct scsi_inquiry_pattern     inq_pat;
-       int                             num_sense_keys;
-       int                             num_ascs;
-       struct sense_key_table_entry    *sense_key_info;
-       struct asc_table_entry          *asc_info;
-};
-
-struct sense_key_table_entry {
-       uint8_t    sense_key;
-       uint32_t   action;
-       const char *desc;
-};
-
-struct asc_table_entry {
-       uint8_t    asc;
-       uint8_t    ascq;
-       uint32_t   action;
-       const char *desc;
-};
-
-struct op_table_entry {
-       uint8_t    opcode;
-       uint16_t   opmask;
-       const char  *desc;
-};
-
-struct scsi_op_quirk_entry {
-       struct scsi_inquiry_pattern     inq_pat;
-       int                             num_ops;
-       struct op_table_entry           *op_table;
-};
-
-typedef enum {
-       SSS_FLAG_NONE           = 0x00,
-       SSS_FLAG_PRINT_COMMAND  = 0x01
-} scsi_sense_string_flags;
-
-extern const char *scsi_sense_key_text[];
-
 /************************* Large Disk Handling ********************************/
-#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
-static __inline int aic_sector_div(u_long capacity, int heads, int sectors);
-
-static __inline int
-aic_sector_div(u_long capacity, int heads, int sectors)
-{
-       return (capacity / (heads * sectors));
-}
-#else
-static __inline int aic_sector_div(sector_t capacity, int heads, int sectors);
-
 static __inline int
 aic_sector_div(sector_t capacity, int heads, int sectors)
 {
@@ -884,7 +140,6 @@ aic_sector_div(sector_t capacity, int heads, int sectors)
        sector_div(capacity, (heads * sectors));
        return (int)capacity;
 }
-#endif
 
 /**************************** Module Library Hack *****************************/
 /*
@@ -899,138 +154,15 @@ aic_sector_div(sector_t capacity, int heads, int sectors)
 #define        AIC_LIB_ENTRY_EXPAND(x, prefix) AIC_LIB_ENTRY_CONCAT(x, prefix)
 #define AIC_LIB_ENTRY(x)               AIC_LIB_ENTRY_EXPAND(x, AIC_LIB_PREFIX)
 
-#define        aic_sense_desc                  AIC_LIB_ENTRY(_sense_desc)
-#define        aic_sense_error_action          AIC_LIB_ENTRY(_sense_error_action)
-#define        aic_error_action                AIC_LIB_ENTRY(_error_action)
-#define        aic_op_desc                     AIC_LIB_ENTRY(_op_desc)
-#define        aic_cdb_string                  AIC_LIB_ENTRY(_cdb_string)
-#define aic_print_inquiry              AIC_LIB_ENTRY(_print_inquiry)
 #define aic_calc_syncsrate             AIC_LIB_ENTRY(_calc_syncrate)
-#define        aic_calc_syncparam              AIC_LIB_ENTRY(_calc_syncparam)
-#define        aic_calc_speed                  AIC_LIB_ENTRY(_calc_speed)
-#define        aic_inquiry_match               AIC_LIB_ENTRY(_inquiry_match)
-#define        aic_static_inquiry_match        AIC_LIB_ENTRY(_static_inquiry_match)
-#define        aic_parse_brace_option          AIC_LIB_ENTRY(_parse_brace_option)
-
-/******************************************************************************/
-
-void                   aic_sense_desc(int /*sense_key*/, int /*asc*/,
-                                      int /*ascq*/, struct scsi_inquiry_data*,
-                                      const char** /*sense_key_desc*/,
-                                      const char** /*asc_desc*/);
-aic_sense_action       aic_sense_error_action(struct scsi_sense_data*,
-                                              struct scsi_inquiry_data*,
-                                              uint32_t /*sense_flags*/);
-uint32_t               aic_error_action(struct scsi_cmnd *,
-                                        struct scsi_inquiry_data *,
-                                        cam_status, u_int);
-
-#define        SF_RETRY_UA     0x01
-#define SF_NO_PRINT    0x02
-#define SF_QUIET_IR    0x04    /* Be quiet about Illegal Request reponses */
-#define SF_PRINT_ALWAYS        0x08
-
-
-const char *   aic_op_desc(uint16_t /*opcode*/, struct scsi_inquiry_data*);
-char *         aic_cdb_string(uint8_t* /*cdb_ptr*/, char* /*cdb_string*/,
-                              size_t /*len*/);
-void           aic_print_inquiry(struct scsi_inquiry_data*);
 
 u_int          aic_calc_syncsrate(u_int /*period_factor*/);
-u_int          aic_calc_syncparam(u_int /*period*/);
-u_int          aic_calc_speed(u_int width, u_int period, u_int offset,
-                              u_int min_rate);
-       
-int            aic_inquiry_match(caddr_t /*inqbuffer*/,
-                                 caddr_t /*table_entry*/);
-int            aic_static_inquiry_match(caddr_t /*inqbuffer*/,
-                                        caddr_t /*table_entry*/);
 
 typedef void aic_option_callback_t(u_long, int, int, int32_t);
 char *         aic_parse_brace_option(char *opt_name, char *opt_arg,
                                       char *end, int depth,
                                       aic_option_callback_t *, u_long);
 
-static __inline void    scsi_extract_sense(struct scsi_sense_data *sense,
-                                           int *error_code, int *sense_key,
-                                           int *asc, int *ascq);
-static __inline void    scsi_ulto2b(uint32_t val, uint8_t *bytes);
-static __inline void    scsi_ulto3b(uint32_t val, uint8_t *bytes);
-static __inline void    scsi_ulto4b(uint32_t val, uint8_t *bytes);
-static __inline uint32_t scsi_2btoul(uint8_t *bytes);
-static __inline uint32_t scsi_3btoul(uint8_t *bytes);
-static __inline int32_t         scsi_3btol(uint8_t *bytes);
-static __inline uint32_t scsi_4btoul(uint8_t *bytes);
-
-static __inline void scsi_extract_sense(struct scsi_sense_data *sense,
-                                      int *error_code, int *sense_key,
-                                      int *asc, int *ascq)
-{
-       *error_code = sense->error_code & SSD_ERRCODE;
-       *sense_key = sense->flags & SSD_KEY;
-       *asc = (sense->extra_len >= 5) ? sense->add_sense_code : 0;
-       *ascq = (sense->extra_len >= 6) ? sense->add_sense_code_qual : 0;
-}
-
-static __inline void
-scsi_ulto2b(uint32_t val, uint8_t *bytes)
-{
-
-       bytes[0] = (val >> 8) & 0xff;
-       bytes[1] = val & 0xff;
-}
-
-static __inline void
-scsi_ulto3b(uint32_t val, uint8_t *bytes)
-{
-
-       bytes[0] = (val >> 16) & 0xff;
-       bytes[1] = (val >> 8) & 0xff;
-       bytes[2] = val & 0xff;
-}
-
-static __inline void
-scsi_ulto4b(uint32_t val, uint8_t *bytes)
-{
-
-       bytes[0] = (val >> 24) & 0xff;
-       bytes[1] = (val >> 16) & 0xff;
-       bytes[2] = (val >> 8) & 0xff;
-       bytes[3] = val & 0xff;
-}
-
-static __inline uint32_t
-scsi_2btoul(uint8_t *bytes)
-{
-       uint32_t rv;
-
-       rv = (bytes[0] << 8) |
-            bytes[1];
-       return (rv);
-}
-
-static __inline uint32_t
-scsi_3btoul(uint8_t *bytes)
-{
-       uint32_t rv;
-
-       rv = (bytes[0] << 16) |
-            (bytes[1] << 8) |
-            bytes[2];
-       return (rv);
-}
-
-static __inline int32_t 
-scsi_3btol(uint8_t *bytes)
-{
-       uint32_t rc = scsi_3btoul(bytes);
-       if (rc & 0x00800000)
-               rc |= 0xff000000;
-
-       return (int32_t) rc;
-}
-
 static __inline uint32_t
 scsi_4btoul(uint8_t *bytes)
 {