Skip to content

L
linux-davinci
Commit 975f24bd authored by Christoph Hellwig's avatar Christoph Hellwig Committed by James Bottomley
Browse files
Options

[SCSI] aiclib remove dead 

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: default avatarChristoph Hellwig <hch@lst.de>
Signed-off-by: default avatarJames Bottomley <James.Bottomley@SteelEye.com>
parent 85a46523
Show whitespace changes
Inline Side-by-side
Showing with 0 additions and 2124 deletions
drivers/scsi/aic7xxx/aiclib.c
View file @ 975f24bd
...@@ -30,1162 +30,8 @@ ...@@ -30,1162 +30,8 @@
* $Id$ * $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 "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" * Table of syncrates that don't follow the "divisible by 4"
...@@ -1229,108 +75,6 @@ aic_calc_syncsrate(u_int period_factor) ...@@ -1229,108 +75,6 @@ aic_calc_syncsrate(u_int period_factor)
return (10000000 / (period_factor * 4 * 10)); 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 * char *
aic_parse_brace_option(char *opt_name, char *opt_arg, char *end, int depth, aic_parse_brace_option(char *opt_name, char *opt_arg, char *end, int depth,
aic_option_callback_t *callback, u_long callback_arg) aic_option_callback_t *callback, u_long callback_arg)
......
drivers/scsi/aic7xxx/aiclib.h
View file @ 975f24bd
...@@ -57,121 +57,6 @@ ...@@ -57,121 +57,6 @@
#ifndef _AICLIB_H #ifndef _AICLIB_H
#define _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 struct scsi_sense
{ {
uint8_t opcode; uint8_t opcode;
...@@ -181,537 +66,12 @@ struct scsi_sense ...@@ -181,537 +66,12 @@ struct scsi_sense
uint8_t control; 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_0 0
#define SCSI_REV_CCS 1 #define SCSI_REV_CCS 1
#define SCSI_REV_2 2 #define SCSI_REV_2 2
#define SCSI_REV_SPC 3 #define SCSI_REV_SPC 3
#define SCSI_REV_SPC2 4 #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 struct scsi_sense_data
{ {
uint8_t error_code; uint8_t error_code;
...@@ -757,41 +117,6 @@ struct scsi_sense_data ...@@ -757,41 +117,6 @@ struct scsi_sense_data
#define SSD_FULL_SIZE sizeof(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 * Status Byte
*/ */
...@@ -807,76 +132,7 @@ struct scsi_mode_blk_desc ...@@ -807,76 +132,7 @@ struct scsi_mode_blk_desc
#define SCSI_STATUS_ACA_ACTIVE 0x30 #define SCSI_STATUS_ACA_ACTIVE 0x30
#define SCSI_STATUS_TASK_ABORTED 0x40 #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 ********************************/ /************************* 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 static __inline int
aic_sector_div(sector_t capacity, int heads, int sectors) aic_sector_div(sector_t capacity, int heads, int sectors)
{ {
...@@ -884,7 +140,6 @@ 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)); sector_div(capacity, (heads * sectors));
return (int)capacity; return (int)capacity;
} }
#endif
/**************************** Module Library Hack *****************************/ /**************************** Module Library Hack *****************************/
/* /*
...@@ -899,138 +154,15 @@ aic_sector_div(sector_t capacity, int heads, int sectors) ...@@ -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_EXPAND(x, prefix) AIC_LIB_ENTRY_CONCAT(x, prefix)
#define AIC_LIB_ENTRY(x) AIC_LIB_ENTRY_EXPAND(x, AIC_LIB_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_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_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); typedef void aic_option_callback_t(u_long, int, int, int32_t);
char * aic_parse_brace_option(char *opt_name, char *opt_arg, char * aic_parse_brace_option(char *opt_name, char *opt_arg,
char *end, int depth, char *end, int depth,
aic_option_callback_t *, u_long); 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 static __inline uint32_t
scsi_4btoul(uint8_t *bytes) scsi_4btoul(uint8_t *bytes)
{ {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment