aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/aic7xxx/aiclib.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/scsi/aic7xxx/aiclib.c
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'drivers/scsi/aic7xxx/aiclib.c')
-rw-r--r--drivers/scsi/aic7xxx/aiclib.c1412
1 files changed, 1412 insertions, 0 deletions
diff --git a/drivers/scsi/aic7xxx/aiclib.c b/drivers/scsi/aic7xxx/aiclib.c
new file mode 100644
index 000000000000..79bfd9efd8ed
--- /dev/null
+++ b/drivers/scsi/aic7xxx/aiclib.c
@@ -0,0 +1,1412 @@
1/*
2 * Implementation of Utility functions for all SCSI device types.
3 *
4 * Copyright (c) 1997, 1998, 1999 Justin T. Gibbs.
5 * Copyright (c) 1997, 1998 Kenneth D. Merry.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions, and the following disclaimer,
13 * without modification, immediately at the beginning of the file.
14 * 2. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
21 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * $FreeBSD: src/sys/cam/scsi/scsi_all.c,v 1.38 2002/09/23 04:56:35 mjacob Exp $
30 * $Id$
31 */
32
33#include <linux/blkdev.h>
34#include <linux/delay.h>
35#include <linux/version.h>
36
37/* Core SCSI definitions */
38#include "scsi.h"
39#include <scsi/scsi_host.h>
40#include "aiclib.h"
41#include "cam.h"
42
43#ifndef FALSE
44#define FALSE 0
45#endif /* FALSE */
46#ifndef TRUE
47#define TRUE 1
48#endif /* TRUE */
49#ifndef ERESTART
50#define ERESTART -1 /* restart syscall */
51#endif
52#ifndef EJUSTRETURN
53#define EJUSTRETURN -2 /* don't modify regs, just return */
54#endif
55
56static int ascentrycomp(const void *key, const void *member);
57static int senseentrycomp(const void *key, const void *member);
58static void fetchtableentries(int sense_key, int asc, int ascq,
59 struct scsi_inquiry_data *,
60 const struct sense_key_table_entry **,
61 const struct asc_table_entry **);
62static void * scsibsearch(const void *key, const void *base, size_t nmemb,
63 size_t size,
64 int (*compar)(const void *, const void *));
65typedef int (cam_quirkmatch_t)(caddr_t, caddr_t);
66static int cam_strmatch(const u_int8_t *str, const u_int8_t *pattern,
67 int str_len);
68static caddr_t cam_quirkmatch(caddr_t target, caddr_t quirk_table,
69 int num_entries, int entry_size,
70 cam_quirkmatch_t *comp_func);
71
72#define SCSI_NO_SENSE_STRINGS 1
73#if !defined(SCSI_NO_SENSE_STRINGS)
74#define SST(asc, ascq, action, desc) \
75 asc, ascq, action, desc
76#else
77static const char empty_string[] = "";
78
79#define SST(asc, ascq, action, desc) \
80 asc, ascq, action, empty_string
81#endif
82
83static const struct sense_key_table_entry sense_key_table[] =
84{
85 { SSD_KEY_NO_SENSE, SS_NOP, "NO SENSE" },
86 { SSD_KEY_RECOVERED_ERROR, SS_NOP|SSQ_PRINT_SENSE, "RECOVERED ERROR" },
87 {
88 SSD_KEY_NOT_READY, SS_TUR|SSQ_MANY|SSQ_DECREMENT_COUNT|EBUSY,
89 "NOT READY"
90 },
91 { SSD_KEY_MEDIUM_ERROR, SS_RDEF, "MEDIUM ERROR" },
92 { SSD_KEY_HARDWARE_ERROR, SS_RDEF, "HARDWARE FAILURE" },
93 { SSD_KEY_ILLEGAL_REQUEST, SS_FATAL|EINVAL, "ILLEGAL REQUEST" },
94 { SSD_KEY_UNIT_ATTENTION, SS_FATAL|ENXIO, "UNIT ATTENTION" },
95 { SSD_KEY_DATA_PROTECT, SS_FATAL|EACCES, "DATA PROTECT" },
96 { SSD_KEY_BLANK_CHECK, SS_FATAL|ENOSPC, "BLANK CHECK" },
97 { SSD_KEY_Vendor_Specific, SS_FATAL|EIO, "Vendor Specific" },
98 { SSD_KEY_COPY_ABORTED, SS_FATAL|EIO, "COPY ABORTED" },
99 { SSD_KEY_ABORTED_COMMAND, SS_RDEF, "ABORTED COMMAND" },
100 { SSD_KEY_EQUAL, SS_NOP, "EQUAL" },
101 { SSD_KEY_VOLUME_OVERFLOW, SS_FATAL|EIO, "VOLUME OVERFLOW" },
102 { SSD_KEY_MISCOMPARE, SS_NOP, "MISCOMPARE" },
103 { SSD_KEY_RESERVED, SS_FATAL|EIO, "RESERVED" }
104};
105
106static const int sense_key_table_size =
107 sizeof(sense_key_table)/sizeof(sense_key_table[0]);
108
109static struct asc_table_entry quantum_fireball_entries[] = {
110 {SST(0x04, 0x0b, SS_START|SSQ_DECREMENT_COUNT|ENXIO,
111 "Logical unit not ready, initializing cmd. required")}
112};
113
114static struct asc_table_entry sony_mo_entries[] = {
115 {SST(0x04, 0x00, SS_START|SSQ_DECREMENT_COUNT|ENXIO,
116 "Logical unit not ready, cause not reportable")}
117};
118
119static struct scsi_sense_quirk_entry sense_quirk_table[] = {
120 {
121 /*
122 * The Quantum Fireball ST and SE like to return 0x04 0x0b when
123 * they really should return 0x04 0x02. 0x04,0x0b isn't
124 * defined in any SCSI spec, and it isn't mentioned in the
125 * hardware manual for these drives.
126 */
127 {T_DIRECT, SIP_MEDIA_FIXED, "QUANTUM", "FIREBALL S*", "*"},
128 /*num_sense_keys*/0,
129 sizeof(quantum_fireball_entries)/sizeof(struct asc_table_entry),
130 /*sense key entries*/NULL,
131 quantum_fireball_entries
132 },
133 {
134 /*
135 * This Sony MO drive likes to return 0x04, 0x00 when it
136 * isn't spun up.
137 */
138 {T_DIRECT, SIP_MEDIA_REMOVABLE, "SONY", "SMO-*", "*"},
139 /*num_sense_keys*/0,
140 sizeof(sony_mo_entries)/sizeof(struct asc_table_entry),
141 /*sense key entries*/NULL,
142 sony_mo_entries
143 }
144};
145
146static const int sense_quirk_table_size =
147 sizeof(sense_quirk_table)/sizeof(sense_quirk_table[0]);
148
149static struct asc_table_entry asc_table[] = {
150/*
151 * From File: ASC-NUM.TXT
152 * SCSI ASC/ASCQ Assignments
153 * Numeric Sorted Listing
154 * as of 5/12/97
155 *
156 * D - DIRECT ACCESS DEVICE (SBC) device column key
157 * .T - SEQUENTIAL ACCESS DEVICE (SSC) -------------------
158 * . L - PRINTER DEVICE (SSC) blank = reserved
159 * . P - PROCESSOR DEVICE (SPC) not blank = allowed
160 * . .W - WRITE ONCE READ MULTIPLE DEVICE (SBC)
161 * . . R - CD DEVICE (MMC)
162 * . . S - SCANNER DEVICE (SGC)
163 * . . .O - OPTICAL MEMORY DEVICE (SBC)
164 * . . . M - MEDIA CHANGER DEVICE (SMC)
165 * . . . C - COMMUNICATION DEVICE (SSC)
166 * . . . .A - STORAGE ARRAY DEVICE (SCC)
167 * . . . . E - ENCLOSURE SERVICES DEVICE (SES)
168 * DTLPWRSOMCAE ASC ASCQ Action Description
169 * ------------ ---- ---- ------ -----------------------------------*/
170/* DTLPWRSOMCAE */{SST(0x00, 0x00, SS_NOP,
171 "No additional sense information") },
172/* T S */{SST(0x00, 0x01, SS_RDEF,
173 "Filemark detected") },
174/* T S */{SST(0x00, 0x02, SS_RDEF,
175 "End-of-partition/medium detected") },
176/* T */{SST(0x00, 0x03, SS_RDEF,
177 "Setmark detected") },
178/* T S */{SST(0x00, 0x04, SS_RDEF,
179 "Beginning-of-partition/medium detected") },
180/* T S */{SST(0x00, 0x05, SS_RDEF,
181 "End-of-data detected") },
182/* DTLPWRSOMCAE */{SST(0x00, 0x06, SS_RDEF,
183 "I/O process terminated") },
184/* R */{SST(0x00, 0x11, SS_FATAL|EBUSY,
185 "Audio play operation in progress") },
186/* R */{SST(0x00, 0x12, SS_NOP,
187 "Audio play operation paused") },
188/* R */{SST(0x00, 0x13, SS_NOP,
189 "Audio play operation successfully completed") },
190/* R */{SST(0x00, 0x14, SS_RDEF,
191 "Audio play operation stopped due to error") },
192/* R */{SST(0x00, 0x15, SS_NOP,
193 "No current audio status to return") },
194/* DTLPWRSOMCAE */{SST(0x00, 0x16, SS_FATAL|EBUSY,
195 "Operation in progress") },
196/* DTL WRSOM AE */{SST(0x00, 0x17, SS_RDEF,
197 "Cleaning requested") },
198/* D W O */{SST(0x01, 0x00, SS_RDEF,
199 "No index/sector signal") },
200/* D WR OM */{SST(0x02, 0x00, SS_RDEF,
201 "No seek complete") },
202/* DTL W SO */{SST(0x03, 0x00, SS_RDEF,
203 "Peripheral device write fault") },
204/* T */{SST(0x03, 0x01, SS_RDEF,
205 "No write current") },
206/* T */{SST(0x03, 0x02, SS_RDEF,
207 "Excessive write errors") },
208/* DTLPWRSOMCAE */{SST(0x04, 0x00,
209 SS_TUR|SSQ_DELAY|SSQ_MANY|SSQ_DECREMENT_COUNT|EIO,
210 "Logical unit not ready, cause not reportable") },
211/* DTLPWRSOMCAE */{SST(0x04, 0x01,
212 SS_TUR|SSQ_DELAY|SSQ_MANY|SSQ_DECREMENT_COUNT|EBUSY,
213 "Logical unit is in process of becoming ready") },
214/* DTLPWRSOMCAE */{SST(0x04, 0x02, SS_START|SSQ_DECREMENT_COUNT|ENXIO,
215 "Logical unit not ready, initializing cmd. required") },
216/* DTLPWRSOMCAE */{SST(0x04, 0x03, SS_FATAL|ENXIO,
217 "Logical unit not ready, manual intervention required")},
218/* DTL O */{SST(0x04, 0x04, SS_FATAL|EBUSY,
219 "Logical unit not ready, format in progress") },
220/* DT W OMCA */{SST(0x04, 0x05, SS_FATAL|EBUSY,
221 "Logical unit not ready, rebuild in progress") },
222/* DT W OMCA */{SST(0x04, 0x06, SS_FATAL|EBUSY,
223 "Logical unit not ready, recalculation in progress") },
224/* DTLPWRSOMCAE */{SST(0x04, 0x07, SS_FATAL|EBUSY,
225 "Logical unit not ready, operation in progress") },
226/* R */{SST(0x04, 0x08, SS_FATAL|EBUSY,
227 "Logical unit not ready, long write in progress") },
228/* DTL WRSOMCAE */{SST(0x05, 0x00, SS_RDEF,
229 "Logical unit does not respond to selection") },
230/* D WR OM */{SST(0x06, 0x00, SS_RDEF,
231 "No reference position found") },
232/* DTL WRSOM */{SST(0x07, 0x00, SS_RDEF,
233 "Multiple peripheral devices selected") },
234/* DTL WRSOMCAE */{SST(0x08, 0x00, SS_RDEF,
235 "Logical unit communication failure") },
236/* DTL WRSOMCAE */{SST(0x08, 0x01, SS_RDEF,
237 "Logical unit communication time-out") },
238/* DTL WRSOMCAE */{SST(0x08, 0x02, SS_RDEF,
239 "Logical unit communication parity error") },
240/* DT R OM */{SST(0x08, 0x03, SS_RDEF,
241 "Logical unit communication crc error (ultra-dma/32)")},
242/* DT WR O */{SST(0x09, 0x00, SS_RDEF,
243 "Track following error") },
244/* WR O */{SST(0x09, 0x01, SS_RDEF,
245 "Tracking servo failure") },
246/* WR O */{SST(0x09, 0x02, SS_RDEF,
247 "Focus servo failure") },
248/* WR O */{SST(0x09, 0x03, SS_RDEF,
249 "Spindle servo failure") },
250/* DT WR O */{SST(0x09, 0x04, SS_RDEF,
251 "Head select fault") },
252/* DTLPWRSOMCAE */{SST(0x0A, 0x00, SS_FATAL|ENOSPC,
253 "Error log overflow") },
254/* DTLPWRSOMCAE */{SST(0x0B, 0x00, SS_RDEF,
255 "Warning") },
256/* DTLPWRSOMCAE */{SST(0x0B, 0x01, SS_RDEF,
257 "Specified temperature exceeded") },
258/* DTLPWRSOMCAE */{SST(0x0B, 0x02, SS_RDEF,
259 "Enclosure degraded") },
260/* T RS */{SST(0x0C, 0x00, SS_RDEF,
261 "Write error") },
262/* D W O */{SST(0x0C, 0x01, SS_NOP|SSQ_PRINT_SENSE,
263 "Write error - recovered with auto reallocation") },
264/* D W O */{SST(0x0C, 0x02, SS_RDEF,
265 "Write error - auto reallocation failed") },
266/* D W O */{SST(0x0C, 0x03, SS_RDEF,
267 "Write error - recommend reassignment") },
268/* DT W O */{SST(0x0C, 0x04, SS_RDEF,
269 "Compression check miscompare error") },
270/* DT W O */{SST(0x0C, 0x05, SS_RDEF,
271 "Data expansion occurred during compression") },
272/* DT W O */{SST(0x0C, 0x06, SS_RDEF,
273 "Block not compressible") },
274/* R */{SST(0x0C, 0x07, SS_RDEF,
275 "Write error - recovery needed") },
276/* R */{SST(0x0C, 0x08, SS_RDEF,
277 "Write error - recovery failed") },
278/* R */{SST(0x0C, 0x09, SS_RDEF,
279 "Write error - loss of streaming") },
280/* R */{SST(0x0C, 0x0A, SS_RDEF,
281 "Write error - padding blocks added") },
282/* D W O */{SST(0x10, 0x00, SS_RDEF,
283 "ID CRC or ECC error") },
284/* DT WRSO */{SST(0x11, 0x00, SS_RDEF,
285 "Unrecovered read error") },
286/* DT W SO */{SST(0x11, 0x01, SS_RDEF,
287 "Read retries exhausted") },
288/* DT W SO */{SST(0x11, 0x02, SS_RDEF,
289 "Error too long to correct") },
290/* DT W SO */{SST(0x11, 0x03, SS_RDEF,
291 "Multiple read errors") },
292/* D W O */{SST(0x11, 0x04, SS_RDEF,
293 "Unrecovered read error - auto reallocate failed") },
294/* WR O */{SST(0x11, 0x05, SS_RDEF,
295 "L-EC uncorrectable error") },
296/* WR O */{SST(0x11, 0x06, SS_RDEF,
297 "CIRC unrecovered error") },
298/* W O */{SST(0x11, 0x07, SS_RDEF,
299 "Data re-synchronization error") },
300/* T */{SST(0x11, 0x08, SS_RDEF,
301 "Incomplete block read") },
302/* T */{SST(0x11, 0x09, SS_RDEF,
303 "No gap found") },
304/* DT O */{SST(0x11, 0x0A, SS_RDEF,
305 "Miscorrected error") },
306/* D W O */{SST(0x11, 0x0B, SS_RDEF,
307 "Unrecovered read error - recommend reassignment") },
308/* D W O */{SST(0x11, 0x0C, SS_RDEF,
309 "Unrecovered read error - recommend rewrite the data")},
310/* DT WR O */{SST(0x11, 0x0D, SS_RDEF,
311 "De-compression CRC error") },
312/* DT WR O */{SST(0x11, 0x0E, SS_RDEF,
313 "Cannot decompress using declared algorithm") },
314/* R */{SST(0x11, 0x0F, SS_RDEF,
315 "Error reading UPC/EAN number") },
316/* R */{SST(0x11, 0x10, SS_RDEF,
317 "Error reading ISRC number") },
318/* R */{SST(0x11, 0x11, SS_RDEF,
319 "Read error - loss of streaming") },
320/* D W O */{SST(0x12, 0x00, SS_RDEF,
321 "Address mark not found for id field") },
322/* D W O */{SST(0x13, 0x00, SS_RDEF,
323 "Address mark not found for data field") },
324/* DTL WRSO */{SST(0x14, 0x00, SS_RDEF,
325 "Recorded entity not found") },
326/* DT WR O */{SST(0x14, 0x01, SS_RDEF,
327 "Record not found") },
328/* T */{SST(0x14, 0x02, SS_RDEF,
329 "Filemark or setmark not found") },
330/* T */{SST(0x14, 0x03, SS_RDEF,
331 "End-of-data not found") },
332/* T */{SST(0x14, 0x04, SS_RDEF,
333 "Block sequence error") },
334/* DT W O */{SST(0x14, 0x05, SS_RDEF,
335 "Record not found - recommend reassignment") },
336/* DT W O */{SST(0x14, 0x06, SS_RDEF,
337 "Record not found - data auto-reallocated") },
338/* DTL WRSOM */{SST(0x15, 0x00, SS_RDEF,
339 "Random positioning error") },
340/* DTL WRSOM */{SST(0x15, 0x01, SS_RDEF,
341 "Mechanical positioning error") },
342/* DT WR O */{SST(0x15, 0x02, SS_RDEF,
343 "Positioning error detected by read of medium") },
344/* D W O */{SST(0x16, 0x00, SS_RDEF,
345 "Data synchronization mark error") },
346/* D W O */{SST(0x16, 0x01, SS_RDEF,
347 "Data sync error - data rewritten") },
348/* D W O */{SST(0x16, 0x02, SS_RDEF,
349 "Data sync error - recommend rewrite") },
350/* D W O */{SST(0x16, 0x03, SS_NOP|SSQ_PRINT_SENSE,
351 "Data sync error - data auto-reallocated") },
352/* D W O */{SST(0x16, 0x04, SS_RDEF,
353 "Data sync error - recommend reassignment") },
354/* DT WRSO */{SST(0x17, 0x00, SS_NOP|SSQ_PRINT_SENSE,
355 "Recovered data with no error correction applied") },
356/* DT WRSO */{SST(0x17, 0x01, SS_NOP|SSQ_PRINT_SENSE,
357 "Recovered data with retries") },
358/* DT WR O */{SST(0x17, 0x02, SS_NOP|SSQ_PRINT_SENSE,
359 "Recovered data with positive head offset") },
360/* DT WR O */{SST(0x17, 0x03, SS_NOP|SSQ_PRINT_SENSE,
361 "Recovered data with negative head offset") },
362/* WR O */{SST(0x17, 0x04, SS_NOP|SSQ_PRINT_SENSE,
363 "Recovered data with retries and/or CIRC applied") },
364/* D WR O */{SST(0x17, 0x05, SS_NOP|SSQ_PRINT_SENSE,
365 "Recovered data using previous sector id") },
366/* D W O */{SST(0x17, 0x06, SS_NOP|SSQ_PRINT_SENSE,
367 "Recovered data without ECC - data auto-reallocated") },
368/* D W O */{SST(0x17, 0x07, SS_NOP|SSQ_PRINT_SENSE,
369 "Recovered data without ECC - recommend reassignment")},
370/* D W O */{SST(0x17, 0x08, SS_NOP|SSQ_PRINT_SENSE,
371 "Recovered data without ECC - recommend rewrite") },
372/* D W O */{SST(0x17, 0x09, SS_NOP|SSQ_PRINT_SENSE,
373 "Recovered data without ECC - data rewritten") },
374/* D W O */{SST(0x18, 0x00, SS_NOP|SSQ_PRINT_SENSE,
375 "Recovered data with error correction applied") },
376/* D WR O */{SST(0x18, 0x01, SS_NOP|SSQ_PRINT_SENSE,
377 "Recovered data with error corr. & retries applied") },
378/* D WR O */{SST(0x18, 0x02, SS_NOP|SSQ_PRINT_SENSE,
379 "Recovered data - data auto-reallocated") },
380/* R */{SST(0x18, 0x03, SS_NOP|SSQ_PRINT_SENSE,
381 "Recovered data with CIRC") },
382/* R */{SST(0x18, 0x04, SS_NOP|SSQ_PRINT_SENSE,
383 "Recovered data with L-EC") },
384/* D WR O */{SST(0x18, 0x05, SS_NOP|SSQ_PRINT_SENSE,
385 "Recovered data - recommend reassignment") },
386/* D WR O */{SST(0x18, 0x06, SS_NOP|SSQ_PRINT_SENSE,
387 "Recovered data - recommend rewrite") },
388/* D W O */{SST(0x18, 0x07, SS_NOP|SSQ_PRINT_SENSE,
389 "Recovered data with ECC - data rewritten") },
390/* D O */{SST(0x19, 0x00, SS_RDEF,
391 "Defect list error") },
392/* D O */{SST(0x19, 0x01, SS_RDEF,
393 "Defect list not available") },
394/* D O */{SST(0x19, 0x02, SS_RDEF,
395 "Defect list error in primary list") },
396/* D O */{SST(0x19, 0x03, SS_RDEF,
397 "Defect list error in grown list") },
398/* DTLPWRSOMCAE */{SST(0x1A, 0x00, SS_RDEF,
399 "Parameter list length error") },
400/* DTLPWRSOMCAE */{SST(0x1B, 0x00, SS_RDEF,
401 "Synchronous data transfer error") },
402/* D O */{SST(0x1C, 0x00, SS_RDEF,
403 "Defect list not found") },
404/* D O */{SST(0x1C, 0x01, SS_RDEF,
405 "Primary defect list not found") },
406/* D O */{SST(0x1C, 0x02, SS_RDEF,
407 "Grown defect list not found") },
408/* D W O */{SST(0x1D, 0x00, SS_FATAL,
409 "Miscompare during verify operation" )},
410/* D W O */{SST(0x1E, 0x00, SS_NOP|SSQ_PRINT_SENSE,
411 "Recovered id with ecc correction") },
412/* D O */{SST(0x1F, 0x00, SS_RDEF,
413 "Partial defect list transfer") },
414/* DTLPWRSOMCAE */{SST(0x20, 0x00, SS_FATAL|EINVAL,
415 "Invalid command operation code") },
416/* DT WR OM */{SST(0x21, 0x00, SS_FATAL|EINVAL,
417 "Logical block address out of range" )},
418/* DT WR OM */{SST(0x21, 0x01, SS_FATAL|EINVAL,
419 "Invalid element address") },
420/* D */{SST(0x22, 0x00, SS_FATAL|EINVAL,
421 "Illegal function") }, /* Deprecated. Use 20 00, 24 00, or 26 00 instead */
422/* DTLPWRSOMCAE */{SST(0x24, 0x00, SS_FATAL|EINVAL,
423 "Invalid field in CDB") },
424/* DTLPWRSOMCAE */{SST(0x25, 0x00, SS_FATAL|ENXIO,
425 "Logical unit not supported") },
426/* DTLPWRSOMCAE */{SST(0x26, 0x00, SS_FATAL|EINVAL,
427 "Invalid field in parameter list") },
428/* DTLPWRSOMCAE */{SST(0x26, 0x01, SS_FATAL|EINVAL,
429 "Parameter not supported") },
430/* DTLPWRSOMCAE */{SST(0x26, 0x02, SS_FATAL|EINVAL,
431 "Parameter value invalid") },
432/* DTLPWRSOMCAE */{SST(0x26, 0x03, SS_FATAL|EINVAL,
433 "Threshold parameters not supported") },
434/* DTLPWRSOMCAE */{SST(0x26, 0x04, SS_FATAL|EINVAL,
435 "Invalid release of active persistent reservation") },
436/* DT W O */{SST(0x27, 0x00, SS_FATAL|EACCES,
437 "Write protected") },
438/* DT W O */{SST(0x27, 0x01, SS_FATAL|EACCES,
439 "Hardware write protected") },
440/* DT W O */{SST(0x27, 0x02, SS_FATAL|EACCES,
441 "Logical unit software write protected") },
442/* T */{SST(0x27, 0x03, SS_FATAL|EACCES,
443 "Associated write protect") },
444/* T */{SST(0x27, 0x04, SS_FATAL|EACCES,
445 "Persistent write protect") },
446/* T */{SST(0x27, 0x05, SS_FATAL|EACCES,
447 "Permanent write protect") },
448/* DTLPWRSOMCAE */{SST(0x28, 0x00, SS_RDEF,
449 "Not ready to ready change, medium may have changed") },
450/* DTLPWRSOMCAE */{SST(0x28, 0x01, SS_FATAL|ENXIO,
451 "Import or export element accessed") },
452/*
453 * XXX JGibbs - All of these should use the same errno, but I don't think
454 * ENXIO is the correct choice. Should we borrow from the networking
455 * errnos? ECONNRESET anyone?
456 */
457/* DTLPWRSOMCAE */{SST(0x29, 0x00, SS_RDEF,
458 "Power on, reset, or bus device reset occurred") },
459/* DTLPWRSOMCAE */{SST(0x29, 0x01, SS_RDEF,
460 "Power on occurred") },
461/* DTLPWRSOMCAE */{SST(0x29, 0x02, SS_RDEF,
462 "Scsi bus reset occurred") },
463/* DTLPWRSOMCAE */{SST(0x29, 0x03, SS_RDEF,
464 "Bus device reset function occurred") },
465/* DTLPWRSOMCAE */{SST(0x29, 0x04, SS_RDEF,
466 "Device internal reset") },
467/* DTLPWRSOMCAE */{SST(0x29, 0x05, SS_RDEF,
468 "Transceiver mode changed to single-ended") },
469/* DTLPWRSOMCAE */{SST(0x29, 0x06, SS_RDEF,
470 "Transceiver mode changed to LVD") },
471/* DTL WRSOMCAE */{SST(0x2A, 0x00, SS_RDEF,
472 "Parameters changed") },
473/* DTL WRSOMCAE */{SST(0x2A, 0x01, SS_RDEF,
474 "Mode parameters changed") },
475/* DTL WRSOMCAE */{SST(0x2A, 0x02, SS_RDEF,
476 "Log parameters changed") },
477/* DTLPWRSOMCAE */{SST(0x2A, 0x03, SS_RDEF,
478 "Reservations preempted") },
479/* DTLPWRSO C */{SST(0x2B, 0x00, SS_RDEF,
480 "Copy cannot execute since host cannot disconnect") },
481/* DTLPWRSOMCAE */{SST(0x2C, 0x00, SS_RDEF,
482 "Command sequence error") },
483/* S */{SST(0x2C, 0x01, SS_RDEF,
484 "Too many windows specified") },
485/* S */{SST(0x2C, 0x02, SS_RDEF,
486 "Invalid combination of windows specified") },
487/* R */{SST(0x2C, 0x03, SS_RDEF,
488 "Current program area is not empty") },
489/* R */{SST(0x2C, 0x04, SS_RDEF,
490 "Current program area is empty") },
491/* T */{SST(0x2D, 0x00, SS_RDEF,
492 "Overwrite error on update in place") },
493/* DTLPWRSOMCAE */{SST(0x2F, 0x00, SS_RDEF,
494 "Commands cleared by another initiator") },
495/* DT WR OM */{SST(0x30, 0x00, SS_RDEF,
496 "Incompatible medium installed") },
497/* DT WR O */{SST(0x30, 0x01, SS_RDEF,
498 "Cannot read medium - unknown format") },
499/* DT WR O */{SST(0x30, 0x02, SS_RDEF,
500 "Cannot read medium - incompatible format") },
501/* DT */{SST(0x30, 0x03, SS_RDEF,
502 "Cleaning cartridge installed") },
503/* DT WR O */{SST(0x30, 0x04, SS_RDEF,
504 "Cannot write medium - unknown format") },
505/* DT WR O */{SST(0x30, 0x05, SS_RDEF,
506 "Cannot write medium - incompatible format") },
507/* DT W O */{SST(0x30, 0x06, SS_RDEF,
508 "Cannot format medium - incompatible medium") },
509/* DTL WRSOM AE */{SST(0x30, 0x07, SS_RDEF,
510 "Cleaning failure") },
511/* R */{SST(0x30, 0x08, SS_RDEF,
512 "Cannot write - application code mismatch") },
513/* R */{SST(0x30, 0x09, SS_RDEF,
514 "Current session not fixated for append") },
515/* DT WR O */{SST(0x31, 0x00, SS_RDEF,
516 "Medium format corrupted") },
517/* D L R O */{SST(0x31, 0x01, SS_RDEF,
518 "Format command failed") },
519/* D W O */{SST(0x32, 0x00, SS_RDEF,
520 "No defect spare location available") },
521/* D W O */{SST(0x32, 0x01, SS_RDEF,
522 "Defect list update failure") },
523/* T */{SST(0x33, 0x00, SS_RDEF,
524 "Tape length error") },
525/* DTLPWRSOMCAE */{SST(0x34, 0x00, SS_RDEF,
526 "Enclosure failure") },
527/* DTLPWRSOMCAE */{SST(0x35, 0x00, SS_RDEF,
528 "Enclosure services failure") },
529/* DTLPWRSOMCAE */{SST(0x35, 0x01, SS_RDEF,
530 "Unsupported enclosure function") },
531/* DTLPWRSOMCAE */{SST(0x35, 0x02, SS_RDEF,
532 "Enclosure services unavailable") },
533/* DTLPWRSOMCAE */{SST(0x35, 0x03, SS_RDEF,
534 "Enclosure services transfer failure") },
535/* DTLPWRSOMCAE */{SST(0x35, 0x04, SS_RDEF,
536 "Enclosure services transfer refused") },
537/* L */{SST(0x36, 0x00, SS_RDEF,
538 "Ribbon, ink, or toner failure") },
539/* DTL WRSOMCAE */{SST(0x37, 0x00, SS_RDEF,
540 "Rounded parameter") },
541/* DTL WRSOMCAE */{SST(0x39, 0x00, SS_RDEF,
542 "Saving parameters not supported") },
543/* DTL WRSOM */{SST(0x3A, 0x00, SS_NOP,
544 "Medium not present") },
545/* DT WR OM */{SST(0x3A, 0x01, SS_NOP,
546 "Medium not present - tray closed") },
547/* DT WR OM */{SST(0x3A, 0x01, SS_NOP,
548 "Medium not present - tray open") },
549/* DT WR OM */{SST(0x3A, 0x03, SS_NOP,
550 "Medium not present - Loadable") },
551/* DT WR OM */{SST(0x3A, 0x04, SS_NOP,
552 "Medium not present - medium auxiliary "
553 "memory accessible") },
554/* DT WR OM */{SST(0x3A, 0xFF, SS_NOP, NULL) },/* Range 0x05->0xFF */
555/* TL */{SST(0x3B, 0x00, SS_RDEF,
556 "Sequential positioning error") },
557/* T */{SST(0x3B, 0x01, SS_RDEF,
558 "Tape position error at beginning-of-medium") },
559/* T */{SST(0x3B, 0x02, SS_RDEF,
560 "Tape position error at end-of-medium") },
561/* L */{SST(0x3B, 0x03, SS_RDEF,
562 "Tape or electronic vertical forms unit not ready") },
563/* L */{SST(0x3B, 0x04, SS_RDEF,
564 "Slew failure") },
565/* L */{SST(0x3B, 0x05, SS_RDEF,
566 "Paper jam") },
567/* L */{SST(0x3B, 0x06, SS_RDEF,
568 "Failed to sense top-of-form") },
569/* L */{SST(0x3B, 0x07, SS_RDEF,
570 "Failed to sense bottom-of-form") },
571/* T */{SST(0x3B, 0x08, SS_RDEF,
572 "Reposition error") },
573/* S */{SST(0x3B, 0x09, SS_RDEF,
574 "Read past end of medium") },
575/* S */{SST(0x3B, 0x0A, SS_RDEF,
576 "Read past beginning of medium") },
577/* S */{SST(0x3B, 0x0B, SS_RDEF,
578 "Position past end of medium") },
579/* T S */{SST(0x3B, 0x0C, SS_RDEF,
580 "Position past beginning of medium") },
581/* DT WR OM */{SST(0x3B, 0x0D, SS_FATAL|ENOSPC,
582 "Medium destination element full") },
583/* DT WR OM */{SST(0x3B, 0x0E, SS_RDEF,
584 "Medium source element empty") },
585/* R */{SST(0x3B, 0x0F, SS_RDEF,
586 "End of medium reached") },
587/* DT WR OM */{SST(0x3B, 0x11, SS_RDEF,
588 "Medium magazine not accessible") },
589/* DT WR OM */{SST(0x3B, 0x12, SS_RDEF,
590 "Medium magazine removed") },
591/* DT WR OM */{SST(0x3B, 0x13, SS_RDEF,
592 "Medium magazine inserted") },
593/* DT WR OM */{SST(0x3B, 0x14, SS_RDEF,
594 "Medium magazine locked") },
595/* DT WR OM */{SST(0x3B, 0x15, SS_RDEF,
596 "Medium magazine unlocked") },
597/* DTLPWRSOMCAE */{SST(0x3D, 0x00, SS_RDEF,
598 "Invalid bits in identify message") },
599/* DTLPWRSOMCAE */{SST(0x3E, 0x00, SS_RDEF,
600 "Logical unit has not self-configured yet") },
601/* DTLPWRSOMCAE */{SST(0x3E, 0x01, SS_RDEF,
602 "Logical unit failure") },
603/* DTLPWRSOMCAE */{SST(0x3E, 0x02, SS_RDEF,
604 "Timeout on logical unit") },
605/* DTLPWRSOMCAE */{SST(0x3F, 0x00, SS_RDEF,
606 "Target operating conditions have changed") },
607/* DTLPWRSOMCAE */{SST(0x3F, 0x01, SS_RDEF,
608 "Microcode has been changed") },
609/* DTLPWRSOMC */{SST(0x3F, 0x02, SS_RDEF,
610 "Changed operating definition") },
611/* DTLPWRSOMCAE */{SST(0x3F, 0x03, SS_INQ_REFRESH|SSQ_DECREMENT_COUNT,
612 "Inquiry data has changed") },
613/* DT WR OMCAE */{SST(0x3F, 0x04, SS_RDEF,
614 "Component device attached") },
615/* DT WR OMCAE */{SST(0x3F, 0x05, SS_RDEF,
616 "Device identifier changed") },
617/* DT WR OMCAE */{SST(0x3F, 0x06, SS_RDEF,
618 "Redundancy group created or modified") },
619/* DT WR OMCAE */{SST(0x3F, 0x07, SS_RDEF,
620 "Redundancy group deleted") },
621/* DT WR OMCAE */{SST(0x3F, 0x08, SS_RDEF,
622 "Spare created or modified") },
623/* DT WR OMCAE */{SST(0x3F, 0x09, SS_RDEF,
624 "Spare deleted") },
625/* DT WR OMCAE */{SST(0x3F, 0x0A, SS_RDEF,
626 "Volume set created or modified") },
627/* DT WR OMCAE */{SST(0x3F, 0x0B, SS_RDEF,
628 "Volume set deleted") },
629/* DT WR OMCAE */{SST(0x3F, 0x0C, SS_RDEF,
630 "Volume set deassigned") },
631/* DT WR OMCAE */{SST(0x3F, 0x0D, SS_RDEF,
632 "Volume set reassigned") },
633/* DTLPWRSOMCAE */{SST(0x3F, 0x0E, SS_RDEF,
634 "Reported luns data has changed") },
635/* DTLPWRSOMCAE */{SST(0x3F, 0x0F, SS_RETRY|SSQ_DECREMENT_COUNT
636 | SSQ_DELAY_RANDOM|EBUSY,
637 "Echo buffer overwritten") },
638/* DT WR OM B*/{SST(0x3F, 0x0F, SS_RDEF, "Medium Loadable") },
639/* DT WR OM B*/{SST(0x3F, 0x0F, SS_RDEF,
640 "Medium auxiliary memory accessible") },
641/* D */{SST(0x40, 0x00, SS_RDEF,
642 "Ram failure") }, /* deprecated - use 40 NN instead */
643/* DTLPWRSOMCAE */{SST(0x40, 0x80, SS_RDEF,
644 "Diagnostic failure: ASCQ = Component ID") },
645/* DTLPWRSOMCAE */{SST(0x40, 0xFF, SS_RDEF|SSQ_RANGE,
646 NULL) },/* Range 0x80->0xFF */
647/* D */{SST(0x41, 0x00, SS_RDEF,
648 "Data path failure") }, /* deprecated - use 40 NN instead */
649/* D */{SST(0x42, 0x00, SS_RDEF,
650 "Power-on or self-test failure") }, /* deprecated - use 40 NN instead */
651/* DTLPWRSOMCAE */{SST(0x43, 0x00, SS_RDEF,
652 "Message error") },
653/* DTLPWRSOMCAE */{SST(0x44, 0x00, SS_RDEF,
654 "Internal target failure") },
655/* DTLPWRSOMCAE */{SST(0x45, 0x00, SS_RDEF,
656 "Select or reselect failure") },
657/* DTLPWRSOMC */{SST(0x46, 0x00, SS_RDEF,
658 "Unsuccessful soft reset") },
659/* DTLPWRSOMCAE */{SST(0x47, 0x00, SS_RDEF|SSQ_FALLBACK,
660 "SCSI parity error") },
661/* DTLPWRSOMCAE */{SST(0x47, 0x01, SS_RDEF|SSQ_FALLBACK,
662 "Data Phase CRC error detected") },
663/* DTLPWRSOMCAE */{SST(0x47, 0x02, SS_RDEF|SSQ_FALLBACK,
664 "SCSI parity error detected during ST data phase") },
665/* DTLPWRSOMCAE */{SST(0x47, 0x03, SS_RDEF|SSQ_FALLBACK,
666 "Information Unit iuCRC error") },
667/* DTLPWRSOMCAE */{SST(0x47, 0x04, SS_RDEF|SSQ_FALLBACK,
668 "Asynchronous information protection error detected") },
669/* DTLPWRSOMCAE */{SST(0x47, 0x05, SS_RDEF|SSQ_FALLBACK,
670 "Protocol server CRC error") },
671/* DTLPWRSOMCAE */{SST(0x48, 0x00, SS_RDEF|SSQ_FALLBACK,
672 "Initiator detected error message received") },
673/* DTLPWRSOMCAE */{SST(0x49, 0x00, SS_RDEF,
674 "Invalid message error") },
675/* DTLPWRSOMCAE */{SST(0x4A, 0x00, SS_RDEF,
676 "Command phase error") },
677/* DTLPWRSOMCAE */{SST(0x4B, 0x00, SS_RDEF,
678 "Data phase error") },
679/* DTLPWRSOMCAE */{SST(0x4C, 0x00, SS_RDEF,
680 "Logical unit failed self-configuration") },
681/* DTLPWRSOMCAE */{SST(0x4D, 0x00, SS_RDEF,
682 "Tagged overlapped commands: ASCQ = Queue tag ID") },
683/* DTLPWRSOMCAE */{SST(0x4D, 0xFF, SS_RDEF|SSQ_RANGE,
684 NULL)}, /* Range 0x00->0xFF */
685/* DTLPWRSOMCAE */{SST(0x4E, 0x00, SS_RDEF,
686 "Overlapped commands attempted") },
687/* T */{SST(0x50, 0x00, SS_RDEF,
688 "Write append error") },
689/* T */{SST(0x50, 0x01, SS_RDEF,
690 "Write append position error") },
691/* T */{SST(0x50, 0x02, SS_RDEF,
692 "Position error related to timing") },
693/* T O */{SST(0x51, 0x00, SS_RDEF,
694 "Erase failure") },
695/* T */{SST(0x52, 0x00, SS_RDEF,
696 "Cartridge fault") },
697/* DTL WRSOM */{SST(0x53, 0x00, SS_RDEF,
698 "Media load or eject failed") },
699/* T */{SST(0x53, 0x01, SS_RDEF,
700 "Unload tape failure") },
701/* DT WR OM */{SST(0x53, 0x02, SS_RDEF,
702 "Medium removal prevented") },
703/* P */{SST(0x54, 0x00, SS_RDEF,
704 "Scsi to host system interface failure") },
705/* P */{SST(0x55, 0x00, SS_RDEF,
706 "System resource failure") },
707/* D O */{SST(0x55, 0x01, SS_FATAL|ENOSPC,
708 "System buffer full") },
709/* R */{SST(0x57, 0x00, SS_RDEF,
710 "Unable to recover table-of-contents") },
711/* O */{SST(0x58, 0x00, SS_RDEF,
712 "Generation does not exist") },
713/* O */{SST(0x59, 0x00, SS_RDEF,
714 "Updated block read") },
715/* DTLPWRSOM */{SST(0x5A, 0x00, SS_RDEF,
716 "Operator request or state change input") },
717/* DT WR OM */{SST(0x5A, 0x01, SS_RDEF,
718 "Operator medium removal request") },
719/* DT W O */{SST(0x5A, 0x02, SS_RDEF,
720 "Operator selected write protect") },
721/* DT W O */{SST(0x5A, 0x03, SS_RDEF,
722 "Operator selected write permit") },
723/* DTLPWRSOM */{SST(0x5B, 0x00, SS_RDEF,
724 "Log exception") },
725/* DTLPWRSOM */{SST(0x5B, 0x01, SS_RDEF,
726 "Threshold condition met") },
727/* DTLPWRSOM */{SST(0x5B, 0x02, SS_RDEF,
728 "Log counter at maximum") },
729/* DTLPWRSOM */{SST(0x5B, 0x03, SS_RDEF,
730 "Log list codes exhausted") },
731/* D O */{SST(0x5C, 0x00, SS_RDEF,
732 "RPL status change") },
733/* D O */{SST(0x5C, 0x01, SS_NOP|SSQ_PRINT_SENSE,
734 "Spindles synchronized") },
735/* D O */{SST(0x5C, 0x02, SS_RDEF,
736 "Spindles not synchronized") },
737/* DTLPWRSOMCAE */{SST(0x5D, 0x00, SS_RDEF,
738 "Failure prediction threshold exceeded") },
739/* DTLPWRSOMCAE */{SST(0x5D, 0xFF, SS_RDEF,
740 "Failure prediction threshold exceeded (false)") },
741/* DTLPWRSO CA */{SST(0x5E, 0x00, SS_RDEF,
742 "Low power condition on") },
743/* DTLPWRSO CA */{SST(0x5E, 0x01, SS_RDEF,
744 "Idle condition activated by timer") },
745/* DTLPWRSO CA */{SST(0x5E, 0x02, SS_RDEF,
746 "Standby condition activated by timer") },
747/* DTLPWRSO CA */{SST(0x5E, 0x03, SS_RDEF,
748 "Idle condition activated by command") },
749/* DTLPWRSO CA */{SST(0x5E, 0x04, SS_RDEF,
750 "Standby condition activated by command") },
751/* S */{SST(0x60, 0x00, SS_RDEF,
752 "Lamp failure") },
753/* S */{SST(0x61, 0x00, SS_RDEF,
754 "Video acquisition error") },
755/* S */{SST(0x61, 0x01, SS_RDEF,
756 "Unable to acquire video") },
757/* S */{SST(0x61, 0x02, SS_RDEF,
758 "Out of focus") },
759/* S */{SST(0x62, 0x00, SS_RDEF,
760 "Scan head positioning error") },
761/* R */{SST(0x63, 0x00, SS_RDEF,
762 "End of user area encountered on this track") },
763/* R */{SST(0x63, 0x01, SS_FATAL|ENOSPC,
764 "Packet does not fit in available space") },
765/* R */{SST(0x64, 0x00, SS_RDEF,
766 "Illegal mode for this track") },
767/* R */{SST(0x64, 0x01, SS_RDEF,
768 "Invalid packet size") },
769/* DTLPWRSOMCAE */{SST(0x65, 0x00, SS_RDEF,
770 "Voltage fault") },
771/* S */{SST(0x66, 0x00, SS_RDEF,
772 "Automatic document feeder cover up") },
773/* S */{SST(0x66, 0x01, SS_RDEF,
774 "Automatic document feeder lift up") },
775/* S */{SST(0x66, 0x02, SS_RDEF,
776 "Document jam in automatic document feeder") },
777/* S */{SST(0x66, 0x03, SS_RDEF,
778 "Document miss feed automatic in document feeder") },
779/* A */{SST(0x67, 0x00, SS_RDEF,
780 "Configuration failure") },
781/* A */{SST(0x67, 0x01, SS_RDEF,
782 "Configuration of incapable logical units failed") },
783/* A */{SST(0x67, 0x02, SS_RDEF,
784 "Add logical unit failed") },
785/* A */{SST(0x67, 0x03, SS_RDEF,
786 "Modification of logical unit failed") },
787/* A */{SST(0x67, 0x04, SS_RDEF,
788 "Exchange of logical unit failed") },
789/* A */{SST(0x67, 0x05, SS_RDEF,
790 "Remove of logical unit failed") },
791/* A */{SST(0x67, 0x06, SS_RDEF,
792 "Attachment of logical unit failed") },
793/* A */{SST(0x67, 0x07, SS_RDEF,
794 "Creation of logical unit failed") },
795/* A */{SST(0x68, 0x00, SS_RDEF,
796 "Logical unit not configured") },
797/* A */{SST(0x69, 0x00, SS_RDEF,
798 "Data loss on logical unit") },
799/* A */{SST(0x69, 0x01, SS_RDEF,
800 "Multiple logical unit failures") },
801/* A */{SST(0x69, 0x02, SS_RDEF,
802 "Parity/data mismatch") },
803/* A */{SST(0x6A, 0x00, SS_RDEF,
804 "Informational, refer to log") },
805/* A */{SST(0x6B, 0x00, SS_RDEF,
806 "State change has occurred") },
807/* A */{SST(0x6B, 0x01, SS_RDEF,
808 "Redundancy level got better") },
809/* A */{SST(0x6B, 0x02, SS_RDEF,
810 "Redundancy level got worse") },
811/* A */{SST(0x6C, 0x00, SS_RDEF,
812 "Rebuild failure occurred") },
813/* A */{SST(0x6D, 0x00, SS_RDEF,
814 "Recalculate failure occurred") },
815/* A */{SST(0x6E, 0x00, SS_RDEF,
816 "Command to logical unit failed") },
817/* T */{SST(0x70, 0x00, SS_RDEF,
818 "Decompression exception short: ASCQ = Algorithm ID") },
819/* T */{SST(0x70, 0xFF, SS_RDEF|SSQ_RANGE,
820 NULL) }, /* Range 0x00 -> 0xFF */
821/* T */{SST(0x71, 0x00, SS_RDEF,
822 "Decompression exception long: ASCQ = Algorithm ID") },
823/* T */{SST(0x71, 0xFF, SS_RDEF|SSQ_RANGE,
824 NULL) }, /* Range 0x00 -> 0xFF */
825/* R */{SST(0x72, 0x00, SS_RDEF,
826 "Session fixation error") },
827/* R */{SST(0x72, 0x01, SS_RDEF,
828 "Session fixation error writing lead-in") },
829/* R */{SST(0x72, 0x02, SS_RDEF,
830 "Session fixation error writing lead-out") },
831/* R */{SST(0x72, 0x03, SS_RDEF,
832 "Session fixation error - incomplete track in session") },
833/* R */{SST(0x72, 0x04, SS_RDEF,
834 "Empty or partially written reserved track") },
835/* R */{SST(0x73, 0x00, SS_RDEF,
836 "CD control error") },
837/* R */{SST(0x73, 0x01, SS_RDEF,
838 "Power calibration area almost full") },
839/* R */{SST(0x73, 0x02, SS_FATAL|ENOSPC,
840 "Power calibration area is full") },
841/* R */{SST(0x73, 0x03, SS_RDEF,
842 "Power calibration area error") },
843/* R */{SST(0x73, 0x04, SS_RDEF,
844 "Program memory area update failure") },
845/* R */{SST(0x73, 0x05, SS_RDEF,
846 "program memory area is full") }
847};
848
849static const int asc_table_size = sizeof(asc_table)/sizeof(asc_table[0]);
850
851struct asc_key
852{
853 int asc;
854 int ascq;
855};
856
857static int
858ascentrycomp(const void *key, const void *member)
859{
860 int asc;
861 int ascq;
862 const struct asc_table_entry *table_entry;
863
864 asc = ((const struct asc_key *)key)->asc;
865 ascq = ((const struct asc_key *)key)->ascq;
866 table_entry = (const struct asc_table_entry *)member;
867
868 if (asc >= table_entry->asc) {
869
870 if (asc > table_entry->asc)
871 return (1);
872
873 if (ascq <= table_entry->ascq) {
874 /* Check for ranges */
875 if (ascq == table_entry->ascq
876 || ((table_entry->action & SSQ_RANGE) != 0
877 && ascq >= (table_entry - 1)->ascq))
878 return (0);
879 return (-1);
880 }
881 return (1);
882 }
883 return (-1);
884}
885
886static int
887senseentrycomp(const void *key, const void *member)
888{
889 int sense_key;
890 const struct sense_key_table_entry *table_entry;
891
892 sense_key = *((const int *)key);
893 table_entry = (const struct sense_key_table_entry *)member;
894
895 if (sense_key >= table_entry->sense_key) {
896 if (sense_key == table_entry->sense_key)
897 return (0);
898 return (1);
899 }
900 return (-1);
901}
902
903static void
904fetchtableentries(int sense_key, int asc, int ascq,
905 struct scsi_inquiry_data *inq_data,
906 const struct sense_key_table_entry **sense_entry,
907 const struct asc_table_entry **asc_entry)
908{
909 void *match;
910 const struct asc_table_entry *asc_tables[2];
911 const struct sense_key_table_entry *sense_tables[2];
912 struct asc_key asc_ascq;
913 size_t asc_tables_size[2];
914 size_t sense_tables_size[2];
915 int num_asc_tables;
916 int num_sense_tables;
917 int i;
918
919 /* Default to failure */
920 *sense_entry = NULL;
921 *asc_entry = NULL;
922 match = NULL;
923 if (inq_data != NULL)
924 match = cam_quirkmatch((void *)inq_data,
925 (void *)sense_quirk_table,
926 sense_quirk_table_size,
927 sizeof(*sense_quirk_table),
928 aic_inquiry_match);
929
930 if (match != NULL) {
931 struct scsi_sense_quirk_entry *quirk;
932
933 quirk = (struct scsi_sense_quirk_entry *)match;
934 asc_tables[0] = quirk->asc_info;
935 asc_tables_size[0] = quirk->num_ascs;
936 asc_tables[1] = asc_table;
937 asc_tables_size[1] = asc_table_size;
938 num_asc_tables = 2;
939 sense_tables[0] = quirk->sense_key_info;
940 sense_tables_size[0] = quirk->num_sense_keys;
941 sense_tables[1] = sense_key_table;
942 sense_tables_size[1] = sense_key_table_size;
943 num_sense_tables = 2;
944 } else {
945 asc_tables[0] = asc_table;
946 asc_tables_size[0] = asc_table_size;
947 num_asc_tables = 1;
948 sense_tables[0] = sense_key_table;
949 sense_tables_size[0] = sense_key_table_size;
950 num_sense_tables = 1;
951 }
952
953 asc_ascq.asc = asc;
954 asc_ascq.ascq = ascq;
955 for (i = 0; i < num_asc_tables; i++) {
956 void *found_entry;
957
958 found_entry = scsibsearch(&asc_ascq, asc_tables[i],
959 asc_tables_size[i],
960 sizeof(**asc_tables),
961 ascentrycomp);
962
963 if (found_entry) {
964 *asc_entry = (struct asc_table_entry *)found_entry;
965 break;
966 }
967 }
968
969 for (i = 0; i < num_sense_tables; i++) {
970 void *found_entry;
971
972 found_entry = scsibsearch(&sense_key, sense_tables[i],
973 sense_tables_size[i],
974 sizeof(**sense_tables),
975 senseentrycomp);
976
977 if (found_entry) {
978 *sense_entry =
979 (struct sense_key_table_entry *)found_entry;
980 break;
981 }
982 }
983}
984
985static void *
986scsibsearch(const void *key, const void *base, size_t nmemb, size_t size,
987 int (*compar)(const void *, const void *))
988{
989 const void *entry;
990 u_int l;
991 u_int u;
992 u_int m;
993
994 l = -1;
995 u = nmemb;
996 while (l + 1 != u) {
997 m = (l + u) / 2;
998 entry = base + m * size;
999 if (compar(key, entry) > 0)
1000 l = m;
1001 else
1002 u = m;
1003 }
1004
1005 entry = base + u * size;
1006 if (u == nmemb
1007 || compar(key, entry) != 0)
1008 return (NULL);
1009
1010 return ((void *)entry);
1011}
1012
1013/*
1014 * Compare string with pattern, returning 0 on match.
1015 * Short pattern matches trailing blanks in name,
1016 * wildcard '*' in pattern matches rest of name,
1017 * wildcard '?' matches a single non-space character.
1018 */
1019static int
1020cam_strmatch(const uint8_t *str, const uint8_t *pattern, int str_len)
1021{
1022
1023 while (*pattern != '\0'&& str_len > 0) {
1024
1025 if (*pattern == '*') {
1026 return (0);
1027 }
1028 if ((*pattern != *str)
1029 && (*pattern != '?' || *str == ' ')) {
1030 return (1);
1031 }
1032 pattern++;
1033 str++;
1034 str_len--;
1035 }
1036 while (str_len > 0 && *str++ == ' ')
1037 str_len--;
1038
1039 return (str_len);
1040}
1041
1042static caddr_t
1043cam_quirkmatch(caddr_t target, caddr_t quirk_table, int num_entries,
1044 int entry_size, cam_quirkmatch_t *comp_func)
1045{
1046 for (; num_entries > 0; num_entries--, quirk_table += entry_size) {
1047 if ((*comp_func)(target, quirk_table) == 0)
1048 return (quirk_table);
1049 }
1050 return (NULL);
1051}
1052
1053void
1054aic_sense_desc(int sense_key, int asc, int ascq,
1055 struct scsi_inquiry_data *inq_data,
1056 const char **sense_key_desc, const char **asc_desc)
1057{
1058 const struct asc_table_entry *asc_entry;
1059 const struct sense_key_table_entry *sense_entry;
1060
1061 fetchtableentries(sense_key, asc, ascq,
1062 inq_data,
1063 &sense_entry,
1064 &asc_entry);
1065
1066 *sense_key_desc = sense_entry->desc;
1067
1068 if (asc_entry != NULL)
1069 *asc_desc = asc_entry->desc;
1070 else if (asc >= 0x80 && asc <= 0xff)
1071 *asc_desc = "Vendor Specific ASC";
1072 else if (ascq >= 0x80 && ascq <= 0xff)
1073 *asc_desc = "Vendor Specific ASCQ";
1074 else
1075 *asc_desc = "Reserved ASC/ASCQ pair";
1076}
1077
1078/*
1079 * Given sense and device type information, return the appropriate action.
1080 * If we do not understand the specific error as identified by the ASC/ASCQ
1081 * pair, fall back on the more generic actions derived from the sense key.
1082 */
1083aic_sense_action
1084aic_sense_error_action(struct scsi_sense_data *sense_data,
1085 struct scsi_inquiry_data *inq_data, uint32_t sense_flags)
1086{
1087 const struct asc_table_entry *asc_entry;
1088 const struct sense_key_table_entry *sense_entry;
1089 int error_code, sense_key, asc, ascq;
1090 aic_sense_action action;
1091
1092 scsi_extract_sense(sense_data, &error_code, &sense_key, &asc, &ascq);
1093
1094 if (error_code == SSD_DEFERRED_ERROR) {
1095 /*
1096 * XXX dufault@FreeBSD.org
1097 * This error doesn't relate to the command associated
1098 * with this request sense. A deferred error is an error
1099 * for a command that has already returned GOOD status
1100 * (see SCSI2 8.2.14.2).
1101 *
1102 * By my reading of that section, it looks like the current
1103 * command has been cancelled, we should now clean things up
1104 * (hopefully recovering any lost data) and then retry the
1105 * current command. There are two easy choices, both wrong:
1106 *
1107 * 1. Drop through (like we had been doing), thus treating
1108 * this as if the error were for the current command and
1109 * return and stop the current command.
1110 *
1111 * 2. Issue a retry (like I made it do) thus hopefully
1112 * recovering the current transfer, and ignoring the
1113 * fact that we've dropped a command.
1114 *
1115 * These should probably be handled in a device specific
1116 * sense handler or punted back up to a user mode daemon
1117 */
1118 action = SS_RETRY|SSQ_DECREMENT_COUNT|SSQ_PRINT_SENSE;
1119 } else {
1120 fetchtableentries(sense_key, asc, ascq,
1121 inq_data,
1122 &sense_entry,
1123 &asc_entry);
1124
1125 /*
1126 * Override the 'No additional Sense' entry (0,0)
1127 * with the error action of the sense key.
1128 */
1129 if (asc_entry != NULL
1130 && (asc != 0 || ascq != 0))
1131 action = asc_entry->action;
1132 else
1133 action = sense_entry->action;
1134
1135 if (sense_key == SSD_KEY_RECOVERED_ERROR) {
1136 /*
1137 * The action succeeded but the device wants
1138 * the user to know that some recovery action
1139 * was required.
1140 */
1141 action &= ~(SS_MASK|SSQ_MASK|SS_ERRMASK);
1142 action |= SS_NOP|SSQ_PRINT_SENSE;
1143 } else if (sense_key == SSD_KEY_ILLEGAL_REQUEST) {
1144 if ((sense_flags & SF_QUIET_IR) != 0)
1145 action &= ~SSQ_PRINT_SENSE;
1146 } else if (sense_key == SSD_KEY_UNIT_ATTENTION) {
1147 if ((sense_flags & SF_RETRY_UA) != 0
1148 && (action & SS_MASK) == SS_FAIL) {
1149 action &= ~(SS_MASK|SSQ_MASK);
1150 action |= SS_RETRY|SSQ_DECREMENT_COUNT|
1151 SSQ_PRINT_SENSE;
1152 }
1153 }
1154 }
1155
1156 if ((sense_flags & SF_PRINT_ALWAYS) != 0)
1157 action |= SSQ_PRINT_SENSE;
1158 else if ((sense_flags & SF_NO_PRINT) != 0)
1159 action &= ~SSQ_PRINT_SENSE;
1160
1161 return (action);
1162}
1163
1164/*
1165 * Try make as good a match as possible with
1166 * available sub drivers
1167 */
1168int
1169aic_inquiry_match(caddr_t inqbuffer, caddr_t table_entry)
1170{
1171 struct scsi_inquiry_pattern *entry;
1172 struct scsi_inquiry_data *inq;
1173
1174 entry = (struct scsi_inquiry_pattern *)table_entry;
1175 inq = (struct scsi_inquiry_data *)inqbuffer;
1176
1177 if (((SID_TYPE(inq) == entry->type)
1178 || (entry->type == T_ANY))
1179 && (SID_IS_REMOVABLE(inq) ? entry->media_type & SIP_MEDIA_REMOVABLE
1180 : entry->media_type & SIP_MEDIA_FIXED)
1181 && (cam_strmatch(inq->vendor, entry->vendor, sizeof(inq->vendor)) == 0)
1182 && (cam_strmatch(inq->product, entry->product,
1183 sizeof(inq->product)) == 0)
1184 && (cam_strmatch(inq->revision, entry->revision,
1185 sizeof(inq->revision)) == 0)) {
1186 return (0);
1187 }
1188 return (-1);
1189}
1190
1191/*
1192 * Table of syncrates that don't follow the "divisible by 4"
1193 * rule. This table will be expanded in future SCSI specs.
1194 */
1195static struct {
1196 u_int period_factor;
1197 u_int period; /* in 100ths of ns */
1198} scsi_syncrates[] = {
1199 { 0x08, 625 }, /* FAST-160 */
1200 { 0x09, 1250 }, /* FAST-80 */
1201 { 0x0a, 2500 }, /* FAST-40 40MHz */
1202 { 0x0b, 3030 }, /* FAST-40 33MHz */
1203 { 0x0c, 5000 } /* FAST-20 */
1204};
1205
1206/*
1207 * Return the frequency in kHz corresponding to the given
1208 * sync period factor.
1209 */
1210u_int
1211aic_calc_syncsrate(u_int period_factor)
1212{
1213 int i;
1214 int num_syncrates;
1215
1216 num_syncrates = sizeof(scsi_syncrates) / sizeof(scsi_syncrates[0]);
1217 /* See if the period is in the "exception" table */
1218 for (i = 0; i < num_syncrates; i++) {
1219
1220 if (period_factor == scsi_syncrates[i].period_factor) {
1221 /* Period in kHz */
1222 return (100000000 / scsi_syncrates[i].period);
1223 }
1224 }
1225
1226 /*
1227 * Wasn't in the table, so use the standard
1228 * 4 times conversion.
1229 */
1230 return (10000000 / (period_factor * 4 * 10));
1231}
1232
1233/*
1234 * Return speed in KB/s.
1235 */
1236u_int
1237aic_calc_speed(u_int width, u_int period, u_int offset, u_int min_rate)
1238{
1239 u_int freq;
1240
1241 if (offset != 0 && period < min_rate)
1242 freq = aic_calc_syncsrate(period);
1243 else
1244 /* Roughly 3.3MB/s for async */
1245 freq = 3300;
1246 freq <<= width;
1247 return (freq);
1248}
1249
1250uint32_t
1251aic_error_action(struct scsi_cmnd *cmd, struct scsi_inquiry_data *inq_data,
1252 cam_status status, u_int scsi_status)
1253{
1254 aic_sense_action err_action;
1255 int sense;
1256
1257 sense = (cmd->result >> 24) == DRIVER_SENSE;
1258
1259 switch (status) {
1260 case CAM_REQ_CMP:
1261 err_action = SS_NOP;
1262 break;
1263 case CAM_AUTOSENSE_FAIL:
1264 case CAM_SCSI_STATUS_ERROR:
1265
1266 switch (scsi_status) {
1267 case SCSI_STATUS_OK:
1268 case SCSI_STATUS_COND_MET:
1269 case SCSI_STATUS_INTERMED:
1270 case SCSI_STATUS_INTERMED_COND_MET:
1271 err_action = SS_NOP;
1272 break;
1273 case SCSI_STATUS_CMD_TERMINATED:
1274 case SCSI_STATUS_CHECK_COND:
1275 if (sense != 0) {
1276 struct scsi_sense_data *sense;
1277
1278 sense = (struct scsi_sense_data *)
1279 &cmd->sense_buffer;
1280 err_action =
1281 aic_sense_error_action(sense, inq_data, 0);
1282
1283 } else {
1284 err_action = SS_RETRY|SSQ_FALLBACK
1285 | SSQ_DECREMENT_COUNT|EIO;
1286 }
1287 break;
1288 case SCSI_STATUS_QUEUE_FULL:
1289 case SCSI_STATUS_BUSY:
1290 err_action = SS_RETRY|SSQ_DELAY|SSQ_MANY
1291 | SSQ_DECREMENT_COUNT|EBUSY;
1292 break;
1293 case SCSI_STATUS_RESERV_CONFLICT:
1294 default:
1295 err_action = SS_FAIL|EBUSY;
1296 break;
1297 }
1298 break;
1299 case CAM_CMD_TIMEOUT:
1300 case CAM_REQ_CMP_ERR:
1301 case CAM_UNEXP_BUSFREE:
1302 case CAM_UNCOR_PARITY:
1303 case CAM_DATA_RUN_ERR:
1304 err_action = SS_RETRY|SSQ_FALLBACK|EIO;
1305 break;
1306 case CAM_UA_ABORT:
1307 case CAM_UA_TERMIO:
1308 case CAM_MSG_REJECT_REC:
1309 case CAM_SEL_TIMEOUT:
1310 err_action = SS_FAIL|EIO;
1311 break;
1312 case CAM_REQ_INVALID:
1313 case CAM_PATH_INVALID:
1314 case CAM_DEV_NOT_THERE:
1315 case CAM_NO_HBA:
1316 case CAM_PROVIDE_FAIL:
1317 case CAM_REQ_TOO_BIG:
1318 case CAM_RESRC_UNAVAIL:
1319 case CAM_BUSY:
1320 default:
1321 /* panic?? These should never occur in our application. */
1322 err_action = SS_FAIL|EIO;
1323 break;
1324 case CAM_SCSI_BUS_RESET:
1325 case CAM_BDR_SENT:
1326 case CAM_REQUEUE_REQ:
1327 /* Unconditional requeue */
1328 err_action = SS_RETRY;
1329 break;
1330 }
1331
1332 return (err_action);
1333}
1334
1335char *
1336aic_parse_brace_option(char *opt_name, char *opt_arg, char *end, int depth,
1337 aic_option_callback_t *callback, u_long callback_arg)
1338{
1339 char *tok_end;
1340 char *tok_end2;
1341 int i;
1342 int instance;
1343 int targ;
1344 int done;
1345 char tok_list[] = {'.', ',', '{', '}', '\0'};
1346
1347 /* All options use a ':' name/arg separator */
1348 if (*opt_arg != ':')
1349 return (opt_arg);
1350 opt_arg++;
1351 instance = -1;
1352 targ = -1;
1353 done = FALSE;
1354 /*
1355 * Restore separator that may be in
1356 * the middle of our option argument.
1357 */
1358 tok_end = strchr(opt_arg, '\0');
1359 if (tok_end < end)
1360 *tok_end = ',';
1361 while (!done) {
1362 switch (*opt_arg) {
1363 case '{':
1364 if (instance == -1) {
1365 instance = 0;
1366 } else {
1367 if (depth > 1) {
1368 if (targ == -1)
1369 targ = 0;
1370 } else {
1371 printf("Malformed Option %s\n",
1372 opt_name);
1373 done = TRUE;
1374 }
1375 }
1376 opt_arg++;
1377 break;
1378 case '}':
1379 if (targ != -1)
1380 targ = -1;
1381 else if (instance != -1)
1382 instance = -1;
1383 opt_arg++;
1384 break;
1385 case ',':
1386 case '.':
1387 if (instance == -1)
1388 done = TRUE;
1389 else if (targ >= 0)
1390 targ++;
1391 else if (instance >= 0)
1392 instance++;
1393 opt_arg++;
1394 break;
1395 case '\0':
1396 done = TRUE;
1397 break;
1398 default:
1399 tok_end = end;
1400 for (i = 0; tok_list[i]; i++) {
1401 tok_end2 = strchr(opt_arg, tok_list[i]);
1402 if ((tok_end2) && (tok_end2 < tok_end))
1403 tok_end = tok_end2;
1404 }
1405 callback(callback_arg, instance, targ,
1406 simple_strtol(opt_arg, NULL, 0));
1407 opt_arg = tok_end;
1408 break;
1409 }
1410 }
1411 return (opt_arg);
1412}
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-20 11:57:07 -0500