CoCalc -- scsi

GitHub Repository: freebsd/freebsd-src
Path: blob/main/sys/cam/scsi/scsi_all.c
¹⁰⁷⁶⁰⁹ views
1
/*-
2
 * Implementation of Utility functions for all SCSI device types.
3
 *
4
 * SPDX-License-Identifier: BSD-2-Clause
5
 *
6
 * Copyright (c) 1997, 1998, 1999 Justin T. Gibbs.
7
 * Copyright (c) 1997, 1998, 2003 Kenneth D. Merry.
8
 * All rights reserved.
9
 *
10
 * Redistribution and use in source and binary forms, with or without
11
 * modification, are permitted provided that the following conditions
12
 * are met:
13
 * 1. Redistributions of source code must retain the above copyright
14
 *    notice, this list of conditions, and the following disclaimer,
15
 *    without modification, immediately at the beginning of the file.
16
 * 2. The name of the author may not be used to endorse or promote products
17
 *    derived from this software without specific prior written permission.
18
 *
19
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
23
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29
 * SUCH DAMAGE.
30
 */
31

32
#include <sys/param.h>
33
#include <sys/types.h>
34
#include <sys/stdint.h>
35

36
#ifdef _KERNEL
37
#include "opt_scsi.h"
38

39
#include <sys/systm.h>
40
#include <sys/libkern.h>
41
#include <sys/kernel.h>
42
#include <sys/lock.h>
43
#include <sys/malloc.h>
44
#include <sys/mutex.h>
45
#include <sys/sysctl.h>
46
#include <sys/ctype.h>
47
#else
48
#include <errno.h>
49
#include <stdio.h>
50
#include <stdlib.h>
51
#include <string.h>
52
#include <ctype.h>
53
#endif
54

55
#include <cam/cam.h>
56
#include <cam/cam_ccb.h>
57
#include <cam/cam_queue.h>
58
#include <cam/cam_xpt.h>
59
#include <cam/scsi/scsi_all.h>
60
#include <sys/ata.h>
61
#include <sys/sbuf.h>
62

63
#ifdef _KERNEL
64
#include <cam/cam_periph.h>
65
#include <cam/cam_xpt_sim.h>
66
#include <cam/cam_xpt_periph.h>
67
#include <cam/cam_xpt_internal.h>
68
#else
69
#include <camlib.h>
70
#include <stddef.h>
71

72
#ifndef FALSE
73
#define FALSE   0
74
#endif /* FALSE */
75
#ifndef TRUE
76
#define TRUE    1
77
#endif /* TRUE */
78
#define ERESTART        -1              /* restart syscall */
79
#define EJUSTRETURN     -2              /* don't modify regs, just return */
80
#endif /* !_KERNEL */
81

82
/*
83
 * This is the default number of milliseconds we wait for devices to settle
84
 * after a SCSI bus reset.
85
 */
86
#ifndef SCSI_DELAY
87
#define SCSI_DELAY 2000
88
#endif
89
/*
90
 * All devices need _some_ sort of bus settle delay, so we'll set it to
91
 * a minimum value of 100ms. Note that this is pertinent only for SPI-
92
 * not transport like Fibre Channel or iSCSI where 'delay' is completely
93
 * meaningless.
94
 */
95
#ifndef SCSI_MIN_DELAY
96
#define SCSI_MIN_DELAY 100
97
#endif
98
/*
99
 * Make sure the user isn't using seconds instead of milliseconds.
100
 */
101
#if (SCSI_DELAY < SCSI_MIN_DELAY && SCSI_DELAY != 0)
102
#error "SCSI_DELAY is in milliseconds, not seconds!  Please use a larger value"
103
#endif
104

105
int scsi_delay;
106

107
static int	ascentrycomp(const void *key, const void *member);
108
static int	senseentrycomp(const void *key, const void *member);
109
static void	fetchtableentries(int sense_key, int asc, int ascq,
110
				  struct scsi_inquiry_data *,
111
				  const struct sense_key_table_entry **,
112
				  const struct asc_table_entry **);
113

114
#ifdef _KERNEL
115
static void	init_scsi_delay(void *);
116
static int	sysctl_scsi_delay(SYSCTL_HANDLER_ARGS);
117
static int	set_scsi_delay(int delay);
118
#endif
119

120
#if !defined(SCSI_NO_OP_STRINGS)
121

122
#define	D	(1 << T_DIRECT)
123
#define	T	(1 << T_SEQUENTIAL)
124
#define	L	(1 << T_PRINTER)
125
#define	P	(1 << T_PROCESSOR)
126
#define	W	(1 << T_WORM)
127
#define	R	(1 << T_CDROM)
128
#define	O	(1 << T_OPTICAL)
129
#define	M	(1 << T_CHANGER)
130
#define	A	(1 << T_STORARRAY)
131
#define	E	(1 << T_ENCLOSURE)
132
#define	B	(1 << T_RBC)
133
#define	K	(1 << T_OCRW)
134
#define	V	(1 << T_ADC)
135
#define	F	(1 << T_OSD)
136
#define	S	(1 << T_SCANNER)
137
#define	C	(1 << T_COMM)
138

139
#define ALL	(D | T | L | P | W | R | O | M | A | E | B | K | V | F | S | C)
140

141
static struct op_table_entry plextor_cd_ops[] = {
142
	{ 0xD8, R, "CD-DA READ" }
143
};
144

145
static struct scsi_op_quirk_entry scsi_op_quirk_table[] = {
146
	{
147
		/*
148
		 * I believe that 0xD8 is the Plextor proprietary command
149
		 * to read CD-DA data.  I'm not sure which Plextor CDROM
150
		 * models support the command, though.  I know for sure
151
		 * that the 4X, 8X, and 12X models do, and presumably the
152
		 * 12-20X does.  I don't know about any earlier models,
153
		 * though.  If anyone has any more complete information,
154
		 * feel free to change this quirk entry.
155
		 */
156
		{T_CDROM, SIP_MEDIA_REMOVABLE, "PLEXTOR", "CD-ROM PX*", "*"},
157
		nitems(plextor_cd_ops),
158
		plextor_cd_ops
159
	}
160
};
161

162
static struct op_table_entry scsi_op_codes[] = {
163
	/*
164
	 * From: http://www.t10.org/lists/op-num.txt
165
	 * Modifications by Kenneth Merry ([email protected])
166
	 *              and Jung-uk Kim ([email protected])
167
	 *
168
	 * Note:  order is important in this table, scsi_op_desc() currently
169
	 * depends on the opcodes in the table being in order to save
170
	 * search time.
171
	 * Note:  scanner and comm. devices are carried over from the previous
172
	 * version because they were removed in the latest spec.
173
	 */
174
	/* File: OP-NUM.TXT
175
	 *
176
	 * SCSI Operation Codes
177
	 * Numeric Sorted Listing
178
	 * as of  5/26/15
179
	 *
180
	 *     D - DIRECT ACCESS DEVICE (SBC-2)                device column key
181
	 *     .T - SEQUENTIAL ACCESS DEVICE (SSC-2)           -----------------
182
	 *     . L - PRINTER DEVICE (SSC)                      M = Mandatory
183
	 *     .  P - PROCESSOR DEVICE (SPC)                   O = Optional
184
	 *     .  .W - WRITE ONCE READ MULTIPLE DEVICE (SBC-2) V = Vendor spec.
185
	 *     .  . R - CD/DVE DEVICE (MMC-3)                  Z = Obsolete
186
	 *     .  .  O - OPTICAL MEMORY DEVICE (SBC-2)
187
	 *     .  .  .M - MEDIA CHANGER DEVICE (SMC-2)
188
	 *     .  .  . A - STORAGE ARRAY DEVICE (SCC-2)
189
	 *     .  .  . .E - ENCLOSURE SERVICES DEVICE (SES)
190
	 *     .  .  .  .B - SIMPLIFIED DIRECT-ACCESS DEVICE (RBC)
191
	 *     .  .  .  . K - OPTICAL CARD READER/WRITER DEVICE (OCRW)
192
	 *     .  .  .  .  V - AUTOMATION/DRIVE INTERFACE (ADC)
193
	 *     .  .  .  .  .F - OBJECT-BASED STORAGE (OSD)
194
	 * OP  DTLPWROMAEBKVF  Description
195
	 * --  --------------  ---------------------------------------------- */
196
	/* 00  MMMMMMMMMMMMMM  TEST UNIT READY */
197
	{ 0x00,	ALL, "TEST UNIT READY" },
198
	/* 01   M              REWIND */
199
	{ 0x01,	T, "REWIND" },
200
	/* 01  Z V ZZZZ        REZERO UNIT */
201
	{ 0x01,	D | W | R | O | M, "REZERO UNIT" },
202
	/* 02  VVVVVV V */
203
	/* 03  MMMMMMMMMMOMMM  REQUEST SENSE */
204
	{ 0x03,	ALL, "REQUEST SENSE" },
205
	/* 04  M    OO         FORMAT UNIT */
206
	{ 0x04,	D | R | O, "FORMAT UNIT" },
207
	/* 04   O              FORMAT MEDIUM */
208
	{ 0x04,	T, "FORMAT MEDIUM" },
209
	/* 04    O             FORMAT */
210
	{ 0x04,	L, "FORMAT" },
211
	/* 05  VMVVVV V        READ BLOCK LIMITS */
212
	{ 0x05,	T, "READ BLOCK LIMITS" },
213
	/* 06  VVVVVV V */
214
	/* 07  OVV O OV        REASSIGN BLOCKS */
215
	{ 0x07,	D | W | O, "REASSIGN BLOCKS" },
216
	/* 07         O        INITIALIZE ELEMENT STATUS */
217
	{ 0x07,	M, "INITIALIZE ELEMENT STATUS" },
218
	/* 08  MOV O OV        READ(6) */
219
	{ 0x08,	D | T | W | O, "READ(6)" },
220
	/* 08     O            RECEIVE */
221
	{ 0x08,	P, "RECEIVE" },
222
	/* 08                  GET MESSAGE(6) */
223
	{ 0x08, C, "GET MESSAGE(6)" },
224
	/* 09  VVVVVV V */
225
	/* 0A  OO  O OV        WRITE(6) */
226
	{ 0x0A,	D | T | W | O, "WRITE(6)" },
227
	/* 0A     M            SEND(6) */
228
	{ 0x0A,	P, "SEND(6)" },
229
	/* 0A                  SEND MESSAGE(6) */
230
	{ 0x0A, C, "SEND MESSAGE(6)" },
231
	/* 0A    M             PRINT */
232
	{ 0x0A,	L, "PRINT" },
233
	/* 0B  Z   ZOZV        SEEK(6) */
234
	{ 0x0B,	D | W | R | O, "SEEK(6)" },
235
	/* 0B   O              SET CAPACITY */
236
	{ 0x0B,	T, "SET CAPACITY" },
237
	/* 0B    O             SLEW AND PRINT */
238
	{ 0x0B,	L, "SLEW AND PRINT" },
239
	/* 0C  VVVVVV V */
240
	/* 0D  VVVVVV V */
241
	/* 0E  VVVVVV V */
242
	/* 0F  VOVVVV V        READ REVERSE(6) */
243
	{ 0x0F,	T, "READ REVERSE(6)" },
244
	/* 10  VM VVV          WRITE FILEMARKS(6) */
245
	{ 0x10,	T, "WRITE FILEMARKS(6)" },
246
	/* 10    O             SYNCHRONIZE BUFFER */
247
	{ 0x10,	L, "SYNCHRONIZE BUFFER" },
248
	/* 11  VMVVVV          SPACE(6) */
249
	{ 0x11,	T, "SPACE(6)" },
250
	/* 12  MMMMMMMMMMMMMM  INQUIRY */
251
	{ 0x12,	ALL, "INQUIRY" },
252
	/* 13  V VVVV */
253
	/* 13   O              VERIFY(6) */
254
	{ 0x13,	T, "VERIFY(6)" },
255
	/* 14  VOOVVV          RECOVER BUFFERED DATA */
256
	{ 0x14,	T | L, "RECOVER BUFFERED DATA" },
257
	/* 15  OMO O OOOO OO   MODE SELECT(6) */
258
	{ 0x15,	ALL & ~(P | R | B | F), "MODE SELECT(6)" },
259
	/* 16  ZZMZO OOOZ O    RESERVE(6) */
260
	{ 0x16,	ALL & ~(R | B | V | F | C), "RESERVE(6)" },
261
	/* 16         Z        RESERVE ELEMENT(6) */
262
	{ 0x16,	M, "RESERVE ELEMENT(6)" },
263
	/* 17  ZZMZO OOOZ O    RELEASE(6) */
264
	{ 0x17,	ALL & ~(R | B | V | F | C), "RELEASE(6)" },
265
	/* 17         Z        RELEASE ELEMENT(6) */
266
	{ 0x17,	M, "RELEASE ELEMENT(6)" },
267
	/* 18  ZZZZOZO    Z    COPY */
268
	{ 0x18,	D | T | L | P | W | R | O | K | S, "COPY" },
269
	/* 19  VMVVVV          ERASE(6) */
270
	{ 0x19,	T, "ERASE(6)" },
271
	/* 1A  OMO O OOOO OO   MODE SENSE(6) */
272
	{ 0x1A,	ALL & ~(P | R | B | F), "MODE SENSE(6)" },
273
	/* 1B  O   OOO O MO O  START STOP UNIT */
274
	{ 0x1B,	D | W | R | O | A | B | K | F, "START STOP UNIT" },
275
	/* 1B   O          M   LOAD UNLOAD */
276
	{ 0x1B,	T | V, "LOAD UNLOAD" },
277
	/* 1B                  SCAN */
278
	{ 0x1B, S, "SCAN" },
279
	/* 1B    O             STOP PRINT */
280
	{ 0x1B,	L, "STOP PRINT" },
281
	/* 1B         O        OPEN/CLOSE IMPORT/EXPORT ELEMENT */
282
	{ 0x1B,	M, "OPEN/CLOSE IMPORT/EXPORT ELEMENT" },
283
	/* 1C  OOOOO OOOM OOO  RECEIVE DIAGNOSTIC RESULTS */
284
	{ 0x1C,	ALL & ~(R | B), "RECEIVE DIAGNOSTIC RESULTS" },
285
	/* 1D  MMMMM MMOM MMM  SEND DIAGNOSTIC */
286
	{ 0x1D,	ALL & ~(R | B), "SEND DIAGNOSTIC" },
287
	/* 1E  OO  OOOO   O O  PREVENT ALLOW MEDIUM REMOVAL */
288
	{ 0x1E,	D | T | W | R | O | M | K | F, "PREVENT ALLOW MEDIUM REMOVAL" },
289
	/* 1F */
290
	/* 20  V   VVV    V */
291
	/* 21  V   VVV    V */
292
	/* 22  V   VVV    V */
293
	/* 23  V   V V    V */
294
	/* 23       O          READ FORMAT CAPACITIES */
295
	{ 0x23,	R, "READ FORMAT CAPACITIES" },
296
	/* 24  V   VV          SET WINDOW */
297
	{ 0x24, S, "SET WINDOW" },
298
	/* 25  M   M M   M     READ CAPACITY(10) */
299
	{ 0x25,	D | W | O | B, "READ CAPACITY(10)" },
300
	/* 25       O          READ CAPACITY */
301
	{ 0x25,	R, "READ CAPACITY" },
302
	/* 25             M    READ CARD CAPACITY */
303
	{ 0x25,	K, "READ CARD CAPACITY" },
304
	/* 25                  GET WINDOW */
305
	{ 0x25, S, "GET WINDOW" },
306
	/* 26  V   VV */
307
	/* 27  V   VV */
308
	/* 28  M   MOM   MM    READ(10) */
309
	{ 0x28,	D | W | R | O | B | K | S, "READ(10)" },
310
	/* 28                  GET MESSAGE(10) */
311
	{ 0x28, C, "GET MESSAGE(10)" },
312
	/* 29  V   VVO         READ GENERATION */
313
	{ 0x29,	O, "READ GENERATION" },
314
	/* 2A  O   MOM   MO    WRITE(10) */
315
	{ 0x2A,	D | W | R | O | B | K, "WRITE(10)" },
316
	/* 2A                  SEND(10) */
317
	{ 0x2A, S, "SEND(10)" },
318
	/* 2A                  SEND MESSAGE(10) */
319
	{ 0x2A, C, "SEND MESSAGE(10)" },
320
	/* 2B  Z   OOO    O    SEEK(10) */
321
	{ 0x2B,	D | W | R | O | K, "SEEK(10)" },
322
	/* 2B   O              LOCATE(10) */
323
	{ 0x2B,	T, "LOCATE(10)" },
324
	/* 2B         O        POSITION TO ELEMENT */
325
	{ 0x2B,	M, "POSITION TO ELEMENT" },
326
	/* 2C  V    OO         ERASE(10) */
327
	{ 0x2C,	R | O, "ERASE(10)" },
328
	/* 2D        O         READ UPDATED BLOCK */
329
	{ 0x2D,	O, "READ UPDATED BLOCK" },
330
	/* 2D  V */
331
	/* 2E  O   OOO   MO    WRITE AND VERIFY(10) */
332
	{ 0x2E,	D | W | R | O | B | K, "WRITE AND VERIFY(10)" },
333
	/* 2F  O   OOO         VERIFY(10) */
334
	{ 0x2F,	D | W | R | O, "VERIFY(10)" },
335
	/* 30  Z   ZZZ         SEARCH DATA HIGH(10) */
336
	{ 0x30,	D | W | R | O, "SEARCH DATA HIGH(10)" },
337
	/* 31  Z   ZZZ         SEARCH DATA EQUAL(10) */
338
	{ 0x31,	D | W | R | O, "SEARCH DATA EQUAL(10)" },
339
	/* 31                  OBJECT POSITION */
340
	{ 0x31, S, "OBJECT POSITION" },
341
	/* 32  Z   ZZZ         SEARCH DATA LOW(10) */
342
	{ 0x32,	D | W | R | O, "SEARCH DATA LOW(10)" },
343
	/* 33  Z   OZO         SET LIMITS(10) */
344
	{ 0x33,	D | W | R | O, "SET LIMITS(10)" },
345
	/* 34  O   O O    O    PRE-FETCH(10) */
346
	{ 0x34,	D | W | O | K, "PRE-FETCH(10)" },
347
	/* 34   M              READ POSITION */
348
	{ 0x34,	T, "READ POSITION" },
349
	/* 34                  GET DATA BUFFER STATUS */
350
	{ 0x34, S, "GET DATA BUFFER STATUS" },
351
	/* 35  O   OOO   MO    SYNCHRONIZE CACHE(10) */
352
	{ 0x35,	D | W | R | O | B | K, "SYNCHRONIZE CACHE(10)" },
353
	/* 36  Z   O O    O    LOCK UNLOCK CACHE(10) */
354
	{ 0x36,	D | W | O | K, "LOCK UNLOCK CACHE(10)" },
355
	/* 37  O     O         READ DEFECT DATA(10) */
356
	{ 0x37,	D | O, "READ DEFECT DATA(10)" },
357
	/* 37         O        INITIALIZE ELEMENT STATUS WITH RANGE */
358
	{ 0x37,	M, "INITIALIZE ELEMENT STATUS WITH RANGE" },
359
	/* 38      O O    O    MEDIUM SCAN */
360
	{ 0x38,	W | O | K, "MEDIUM SCAN" },
361
	/* 39  ZZZZOZO    Z    COMPARE */
362
	{ 0x39,	D | T | L | P | W | R | O | K | S, "COMPARE" },
363
	/* 3A  ZZZZOZO    Z    COPY AND VERIFY */
364
	{ 0x3A,	D | T | L | P | W | R | O | K | S, "COPY AND VERIFY" },
365
	/* 3B  OOOOOOOOOOMOOO  WRITE BUFFER */
366
	{ 0x3B,	ALL, "WRITE BUFFER" },
367
	/* 3C  OOOOOOOOOO OOO  READ BUFFER */
368
	{ 0x3C,	ALL & ~(B), "READ BUFFER" },
369
	/* 3D        O         UPDATE BLOCK */
370
	{ 0x3D,	O, "UPDATE BLOCK" },
371
	/* 3E  O   O O         READ LONG(10) */
372
	{ 0x3E,	D | W | O, "READ LONG(10)" },
373
	/* 3F  O   O O         WRITE LONG(10) */
374
	{ 0x3F,	D | W | O, "WRITE LONG(10)" },
375
	/* 40  ZZZZOZOZ        CHANGE DEFINITION */
376
	{ 0x40,	D | T | L | P | W | R | O | M | S | C, "CHANGE DEFINITION" },
377
	/* 41  O               WRITE SAME(10) */
378
	{ 0x41,	D, "WRITE SAME(10)" },
379
	/* 42  O               UNMAP */
380
	{ 0x42,	D, "UNMAP" },
381
	/* 42       O          READ SUB-CHANNEL */
382
	{ 0x42,	R, "READ SUB-CHANNEL" },
383
	/* 43       O          READ TOC/PMA/ATIP */
384
	{ 0x43,	R, "READ TOC/PMA/ATIP" },
385
	/* 44   M          M   REPORT DENSITY SUPPORT */
386
	{ 0x44,	T | V, "REPORT DENSITY SUPPORT" },
387
	/* 44                  READ HEADER */
388
	/* 45       O          PLAY AUDIO(10) */
389
	{ 0x45,	R, "PLAY AUDIO(10)" },
390
	/* 46       M          GET CONFIGURATION */
391
	{ 0x46,	R, "GET CONFIGURATION" },
392
	/* 47       O          PLAY AUDIO MSF */
393
	{ 0x47,	R, "PLAY AUDIO MSF" },
394
	/* 48  O               SANITIZE */
395
	{ 0x48,	D, "SANITIZE" },
396
	/* 49 */
397
	/* 4A       M          GET EVENT STATUS NOTIFICATION */
398
	{ 0x4A,	R, "GET EVENT STATUS NOTIFICATION" },
399
	/* 4B       O          PAUSE/RESUME */
400
	{ 0x4B,	R, "PAUSE/RESUME" },
401
	/* 4C  OOOOO OOOO OOO  LOG SELECT */
402
	{ 0x4C,	ALL & ~(R | B), "LOG SELECT" },
403
	/* 4D  OOOOO OOOO OMO  LOG SENSE */
404
	{ 0x4D,	ALL & ~(R | B), "LOG SENSE" },
405
	/* 4E       O          STOP PLAY/SCAN */
406
	{ 0x4E,	R, "STOP PLAY/SCAN" },
407
	/* 4F */
408
	/* 50  O               XDWRITE(10) */
409
	{ 0x50,	D, "XDWRITE(10)" },
410
	/* 51  O               XPWRITE(10) */
411
	{ 0x51,	D, "XPWRITE(10)" },
412
	/* 51       O          READ DISC INFORMATION */
413
	{ 0x51,	R, "READ DISC INFORMATION" },
414
	/* 52  O               XDREAD(10) */
415
	{ 0x52,	D, "XDREAD(10)" },
416
	/* 52       O          READ TRACK INFORMATION */
417
	{ 0x52,	R, "READ TRACK INFORMATION" },
418
	/* 53  O               XDWRITEREAD(10) */
419
	{ 0x53,	D, "XDWRITEREAD(10)" },
420
	/* 53       O          RESERVE TRACK */
421
	{ 0x53,	R, "RESERVE TRACK" },
422
	/* 54       O          SEND OPC INFORMATION */
423
	{ 0x54,	R, "SEND OPC INFORMATION" },
424
	/* 55  OOO OMOOOOMOMO  MODE SELECT(10) */
425
	{ 0x55,	ALL & ~(P), "MODE SELECT(10)" },
426
	/* 56  ZZMZO OOOZ      RESERVE(10) */
427
	{ 0x56,	ALL & ~(R | B | K | V | F | C), "RESERVE(10)" },
428
	/* 56         Z        RESERVE ELEMENT(10) */
429
	{ 0x56,	M, "RESERVE ELEMENT(10)" },
430
	/* 57  ZZMZO OOOZ      RELEASE(10) */
431
	{ 0x57,	ALL & ~(R | B | K | V | F | C), "RELEASE(10)" },
432
	/* 57         Z        RELEASE ELEMENT(10) */
433
	{ 0x57,	M, "RELEASE ELEMENT(10)" },
434
	/* 58       O          REPAIR TRACK */
435
	{ 0x58,	R, "REPAIR TRACK" },
436
	/* 59 */
437
	/* 5A  OOO OMOOOOMOMO  MODE SENSE(10) */
438
	{ 0x5A,	ALL & ~(P), "MODE SENSE(10)" },
439
	/* 5B       O          CLOSE TRACK/SESSION */
440
	{ 0x5B,	R, "CLOSE TRACK/SESSION" },
441
	/* 5C       O          READ BUFFER CAPACITY */
442
	{ 0x5C,	R, "READ BUFFER CAPACITY" },
443
	/* 5D       O          SEND CUE SHEET */
444
	{ 0x5D,	R, "SEND CUE SHEET" },
445
	/* 5E  OOOOO OOOO   M  PERSISTENT RESERVE IN */
446
	{ 0x5E,	ALL & ~(R | B | K | V | C), "PERSISTENT RESERVE IN" },
447
	/* 5F  OOOOO OOOO   M  PERSISTENT RESERVE OUT */
448
	{ 0x5F,	ALL & ~(R | B | K | V | C), "PERSISTENT RESERVE OUT" },
449
	/* 7E  OO   O OOOO O   extended CDB */
450
	{ 0x7E,	D | T | R | M | A | E | B | V, "extended CDB" },
451
	/* 7F  O            M  variable length CDB (more than 16 bytes) */
452
	{ 0x7F,	D | F, "variable length CDB (more than 16 bytes)" },
453
	/* 80  Z               XDWRITE EXTENDED(16) */
454
	{ 0x80,	D, "XDWRITE EXTENDED(16)" },
455
	/* 80   M              WRITE FILEMARKS(16) */
456
	{ 0x80,	T, "WRITE FILEMARKS(16)" },
457
	/* 81  Z               REBUILD(16) */
458
	{ 0x81,	D, "REBUILD(16)" },
459
	/* 81   O              READ REVERSE(16) */
460
	{ 0x81,	T, "READ REVERSE(16)" },
461
	/* 82  Z               REGENERATE(16) */
462
	{ 0x82,	D, "REGENERATE(16)" },
463
	/* 82   O              ALLOW OVERWRITE */
464
	{ 0x82,	T, "ALLOW OVERWRITE" },
465
	/* 83  OOOOO O    OO   EXTENDED COPY */
466
	{ 0x83,	D | T | L | P | W | O | K | V, "EXTENDED COPY" },
467
	/* 84  OOOOO O    OO   RECEIVE COPY RESULTS */
468
	{ 0x84,	D | T | L | P | W | O | K | V, "RECEIVE COPY RESULTS" },
469
	/* 85  O    O    O     ATA COMMAND PASS THROUGH(16) */
470
	{ 0x85,	D | R | B, "ATA COMMAND PASS THROUGH(16)" },
471
	/* 86  OO OO OOOOOOO   ACCESS CONTROL IN */
472
	{ 0x86,	ALL & ~(L | R | F), "ACCESS CONTROL IN" },
473
	/* 87  OO OO OOOOOOO   ACCESS CONTROL OUT */
474
	{ 0x87,	ALL & ~(L | R | F), "ACCESS CONTROL OUT" },
475
	/* 88  MM  O O   O     READ(16) */
476
	{ 0x88,	D | T | W | O | B, "READ(16)" },
477
	/* 89  O               COMPARE AND WRITE*/
478
	{ 0x89,	D, "COMPARE AND WRITE" },
479
	/* 8A  OM  O O   O     WRITE(16) */
480
	{ 0x8A,	D | T | W | O | B, "WRITE(16)" },
481
	/* 8B  O               ORWRITE */
482
	{ 0x8B,	D, "ORWRITE" },
483
	/* 8C  OO  O OO  O M   READ ATTRIBUTE */
484
	{ 0x8C,	D | T | W | O | M | B | V, "READ ATTRIBUTE" },
485
	/* 8D  OO  O OO  O O   WRITE ATTRIBUTE */
486
	{ 0x8D,	D | T | W | O | M | B | V, "WRITE ATTRIBUTE" },
487
	/* 8E  O   O O   O     WRITE AND VERIFY(16) */
488
	{ 0x8E,	D | W | O | B, "WRITE AND VERIFY(16)" },
489
	/* 8F  OO  O O   O     VERIFY(16) */
490
	{ 0x8F,	D | T | W | O | B, "VERIFY(16)" },
491
	/* 90  O   O O   O     PRE-FETCH(16) */
492
	{ 0x90,	D | W | O | B, "PRE-FETCH(16)" },
493
	/* 91  O   O O   O     SYNCHRONIZE CACHE(16) */
494
	{ 0x91,	D | W | O | B, "SYNCHRONIZE CACHE(16)" },
495
	/* 91   O              SPACE(16) */
496
	{ 0x91,	T, "SPACE(16)" },
497
	/* 92  Z   O O         LOCK UNLOCK CACHE(16) */
498
	{ 0x92,	D | W | O, "LOCK UNLOCK CACHE(16)" },
499
	/* 92   O              LOCATE(16) */
500
	{ 0x92,	T, "LOCATE(16)" },
501
	/* 93  O               WRITE SAME(16) */
502
	{ 0x93,	D, "WRITE SAME(16)" },
503
	/* 93   M              ERASE(16) */
504
	{ 0x93,	T, "ERASE(16)" },
505
	/* 94  O               ZBC OUT */
506
	{ 0x94,	ALL, "ZBC OUT" },
507
	/* 95  O               ZBC IN */
508
	{ 0x95,	ALL, "ZBC IN" },
509
	/* 96 */
510
	/* 97 */
511
	/* 98 */
512
	/* 99 */
513
	/* 9A  O               WRITE STREAM(16) */
514
	{ 0x9A,	D, "WRITE STREAM(16)" },
515
	/* 9B  OOOOOOOOOO OOO  READ BUFFER(16) */
516
	{ 0x9B,	ALL & ~(B) , "READ BUFFER(16)" },
517
	/* 9C  O              WRITE ATOMIC(16) */
518
	{ 0x9C, D, "WRITE ATOMIC(16)" },
519
	/* 9D                  SERVICE ACTION BIDIRECTIONAL */
520
	{ 0x9D, ALL, "SERVICE ACTION BIDIRECTIONAL" },
521
	/* XXX KDM ALL for this?  op-num.txt defines it for none.. */
522
	/* 9E                  SERVICE ACTION IN(16) */
523
	{ 0x9E, ALL, "SERVICE ACTION IN(16)" },
524
	/* 9F              M   SERVICE ACTION OUT(16) */
525
	{ 0x9F,	ALL, "SERVICE ACTION OUT(16)" },
526
	/* A0  MMOOO OMMM OMO  REPORT LUNS */
527
	{ 0xA0,	ALL & ~(R | B), "REPORT LUNS" },
528
	/* A1       O          BLANK */
529
	{ 0xA1,	R, "BLANK" },
530
	/* A1  O         O     ATA COMMAND PASS THROUGH(12) */
531
	{ 0xA1,	D | B, "ATA COMMAND PASS THROUGH(12)" },
532
	/* A2  OO   O      O   SECURITY PROTOCOL IN */
533
	{ 0xA2,	D | T | R | V, "SECURITY PROTOCOL IN" },
534
	/* A3  OOO O OOMOOOM   MAINTENANCE (IN) */
535
	{ 0xA3,	ALL & ~(P | R | F), "MAINTENANCE (IN)" },
536
	/* A3       O          SEND KEY */
537
	{ 0xA3,	R, "SEND KEY" },
538
	/* A4  OOO O OOOOOOO   MAINTENANCE (OUT) */
539
	{ 0xA4,	ALL & ~(P | R | F), "MAINTENANCE (OUT)" },
540
	/* A4       O          REPORT KEY */
541
	{ 0xA4,	R, "REPORT KEY" },
542
	/* A5   O  O OM        MOVE MEDIUM */
543
	{ 0xA5,	T | W | O | M, "MOVE MEDIUM" },
544
	/* A5       O          PLAY AUDIO(12) */
545
	{ 0xA5,	R, "PLAY AUDIO(12)" },
546
	/* A6         O        EXCHANGE MEDIUM */
547
	{ 0xA6,	M, "EXCHANGE MEDIUM" },
548
	/* A6       O          LOAD/UNLOAD C/DVD */
549
	{ 0xA6,	R, "LOAD/UNLOAD C/DVD" },
550
	/* A7  ZZ  O O         MOVE MEDIUM ATTACHED */
551
	{ 0xA7,	D | T | W | O, "MOVE MEDIUM ATTACHED" },
552
	/* A7       O          SET READ AHEAD */
553
	{ 0xA7,	R, "SET READ AHEAD" },
554
	/* A8  O   OOO         READ(12) */
555
	{ 0xA8,	D | W | R | O, "READ(12)" },
556
	/* A8                  GET MESSAGE(12) */
557
	{ 0xA8, C, "GET MESSAGE(12)" },
558
	/* A9              O   SERVICE ACTION OUT(12) */
559
	{ 0xA9,	V, "SERVICE ACTION OUT(12)" },
560
	/* AA  O   OOO         WRITE(12) */
561
	{ 0xAA,	D | W | R | O, "WRITE(12)" },
562
	/* AA                  SEND MESSAGE(12) */
563
	{ 0xAA, C, "SEND MESSAGE(12)" },
564
	/* AB       O      O   SERVICE ACTION IN(12) */
565
	{ 0xAB,	R | V, "SERVICE ACTION IN(12)" },
566
	/* AC        O         ERASE(12) */
567
	{ 0xAC,	O, "ERASE(12)" },
568
	/* AC       O          GET PERFORMANCE */
569
	{ 0xAC,	R, "GET PERFORMANCE" },
570
	/* AD       O          READ DVD STRUCTURE */
571
	{ 0xAD,	R, "READ DVD STRUCTURE" },
572
	/* AE  O   O O         WRITE AND VERIFY(12) */
573
	{ 0xAE,	D | W | O, "WRITE AND VERIFY(12)" },
574
	/* AF  O   OZO         VERIFY(12) */
575
	{ 0xAF,	D | W | R | O, "VERIFY(12)" },
576
	/* B0      ZZZ         SEARCH DATA HIGH(12) */
577
	{ 0xB0,	W | R | O, "SEARCH DATA HIGH(12)" },
578
	/* B1      ZZZ         SEARCH DATA EQUAL(12) */
579
	{ 0xB1,	W | R | O, "SEARCH DATA EQUAL(12)" },
580
	/* B2      ZZZ         SEARCH DATA LOW(12) */
581
	{ 0xB2,	W | R | O, "SEARCH DATA LOW(12)" },
582
	/* B3  Z   OZO         SET LIMITS(12) */
583
	{ 0xB3,	D | W | R | O, "SET LIMITS(12)" },
584
	/* B4  ZZ  OZO         READ ELEMENT STATUS ATTACHED */
585
	{ 0xB4,	D | T | W | R | O, "READ ELEMENT STATUS ATTACHED" },
586
	/* B5  OO   O      O   SECURITY PROTOCOL OUT */
587
	{ 0xB5,	D | T | R | V, "SECURITY PROTOCOL OUT" },
588
	/* B5         O        REQUEST VOLUME ELEMENT ADDRESS */
589
	{ 0xB5,	M, "REQUEST VOLUME ELEMENT ADDRESS" },
590
	/* B6         O        SEND VOLUME TAG */
591
	{ 0xB6,	M, "SEND VOLUME TAG" },
592
	/* B6       O          SET STREAMING */
593
	{ 0xB6,	R, "SET STREAMING" },
594
	/* B7  O     O         READ DEFECT DATA(12) */
595
	{ 0xB7,	D | O, "READ DEFECT DATA(12)" },
596
	/* B8   O  OZOM        READ ELEMENT STATUS */
597
	{ 0xB8,	T | W | R | O | M, "READ ELEMENT STATUS" },
598
	/* B9       O          READ CD MSF */
599
	{ 0xB9,	R, "READ CD MSF" },
600
	/* BA  O   O OOMO      REDUNDANCY GROUP (IN) */
601
	{ 0xBA,	D | W | O | M | A | E, "REDUNDANCY GROUP (IN)" },
602
	/* BA       O          SCAN */
603
	{ 0xBA,	R, "SCAN" },
604
	/* BB  O   O OOOO      REDUNDANCY GROUP (OUT) */
605
	{ 0xBB,	D | W | O | M | A | E, "REDUNDANCY GROUP (OUT)" },
606
	/* BB       O          SET CD SPEED */
607
	{ 0xBB,	R, "SET CD SPEED" },
608
	/* BC  O   O OOMO      SPARE (IN) */
609
	{ 0xBC,	D | W | O | M | A | E, "SPARE (IN)" },
610
	/* BD  O   O OOOO      SPARE (OUT) */
611
	{ 0xBD,	D | W | O | M | A | E, "SPARE (OUT)" },
612
	/* BD       O          MECHANISM STATUS */
613
	{ 0xBD,	R, "MECHANISM STATUS" },
614
	/* BE  O   O OOMO      VOLUME SET (IN) */
615
	{ 0xBE,	D | W | O | M | A | E, "VOLUME SET (IN)" },
616
	/* BE       O          READ CD */
617
	{ 0xBE,	R, "READ CD" },
618
	/* BF  O   O OOOO      VOLUME SET (OUT) */
619
	{ 0xBF,	D | W | O | M | A | E, "VOLUME SET (OUT)" },
620
	/* BF       O          SEND DVD STRUCTURE */
621
	{ 0xBF,	R, "SEND DVD STRUCTURE" }
622
};
623

624
const char *
625
scsi_op_desc(uint16_t opcode, struct scsi_inquiry_data *inq_data)
626
{
627
	caddr_t match;
628
	int i, j;
629
	uint32_t opmask;
630
	uint16_t pd_type;
631
	int       num_ops[2];
632
	struct op_table_entry *table[2];
633
	int num_tables;
634

635
	/*
636
	 * If we've got inquiry data, use it to determine what type of
637
	 * device we're dealing with here.  Otherwise, assume direct
638
	 * access.
639
	 */
640
	if (inq_data == NULL) {
641
		pd_type = T_DIRECT;
642
		match = NULL;
643
	} else {
644
		pd_type = SID_TYPE(inq_data);
645

646
		match = cam_quirkmatch((caddr_t)inq_data,
647
				       (caddr_t)scsi_op_quirk_table,
648
				       nitems(scsi_op_quirk_table),
649
				       sizeof(*scsi_op_quirk_table),
650
				       scsi_inquiry_match);
651
	}
652

653
	if (match != NULL) {
654
		table[0] = ((struct scsi_op_quirk_entry *)match)->op_table;
655
		num_ops[0] = ((struct scsi_op_quirk_entry *)match)->num_ops;
656
		table[1] = scsi_op_codes;
657
		num_ops[1] = nitems(scsi_op_codes);
658
		num_tables = 2;
659
	} else {
660
		/*
661
		 * If this is true, we have a vendor specific opcode that
662
		 * wasn't covered in the quirk table.
663
		 */
664
		if ((opcode > 0xBF) || ((opcode > 0x5F) && (opcode < 0x80)))
665
			return("Vendor Specific Command");
666

667
		table[0] = scsi_op_codes;
668
		num_ops[0] = nitems(scsi_op_codes);
669
		num_tables = 1;
670
	}
671

672
	/* RBC is 'Simplified' Direct Access Device */
673
	if (pd_type == T_RBC)
674
		pd_type = T_DIRECT;
675

676
	/*
677
	 * Host managed drives are direct access for the most part.
678
	 */
679
	if (pd_type == T_ZBC_HM)
680
		pd_type = T_DIRECT;
681

682
	/* Map NODEVICE to Direct Access Device to handle REPORT LUNS, etc. */
683
	if (pd_type == T_NODEVICE)
684
		pd_type = T_DIRECT;
685

686
	opmask = 1 << pd_type;
687

688
	for (j = 0; j < num_tables; j++) {
689
		for (i = 0; i < num_ops[j] && table[j][i].opcode <= opcode; i++) {
690
			if ((table[j][i].opcode == opcode)
691
			 && ((table[j][i].opmask & opmask) != 0))
692
				return(table[j][i].desc);
693
		}
694
	}
695

696
	/*
697
	 * If we can't find a match for the command in the table, we just
698
	 * assume it's a vendor specifc command.
699
	 */
700
	return("Vendor Specific Command");
701

702
}
703

704
#else /* SCSI_NO_OP_STRINGS */
705

706
const char *
707
scsi_op_desc(uint16_t opcode, struct scsi_inquiry_data *inq_data)
708
{
709
	return("");
710
}
711

712
#endif
713

714
#if !defined(SCSI_NO_SENSE_STRINGS)
715
#define SST(asc, ascq, action, desc) \
716
	asc, ascq, action, desc
717
#else
718
const char empty_string[] = "";
719

720
#define SST(asc, ascq, action, desc) \
721
	asc, ascq, action, empty_string
722
#endif
723

724
const struct sense_key_table_entry sense_key_table[] =
725
{
726
	{ SSD_KEY_NO_SENSE, SS_NOP, "NO SENSE" },
727
	{ SSD_KEY_RECOVERED_ERROR, SS_NOP|SSQ_PRINT_SENSE, "RECOVERED ERROR" },
728
	{ SSD_KEY_NOT_READY, SS_RDEF, "NOT READY" },
729
	{ SSD_KEY_MEDIUM_ERROR, SS_RDEF, "MEDIUM ERROR" },
730
	{ SSD_KEY_HARDWARE_ERROR, SS_RDEF, "HARDWARE FAILURE" },
731
	{ SSD_KEY_ILLEGAL_REQUEST, SS_FATAL|EINVAL, "ILLEGAL REQUEST" },
732
	{ SSD_KEY_UNIT_ATTENTION, SS_FATAL|ENXIO, "UNIT ATTENTION" },
733
	{ SSD_KEY_DATA_PROTECT, SS_FATAL|EACCES, "DATA PROTECT" },
734
	{ SSD_KEY_BLANK_CHECK, SS_FATAL|ENOSPC, "BLANK CHECK" },
735
	{ SSD_KEY_Vendor_Specific, SS_FATAL|EIO, "Vendor Specific" },
736
	{ SSD_KEY_COPY_ABORTED, SS_FATAL|EIO, "COPY ABORTED" },
737
	{ SSD_KEY_ABORTED_COMMAND, SS_RDEF, "ABORTED COMMAND" },
738
	{ SSD_KEY_EQUAL, SS_NOP, "EQUAL" },
739
	{ SSD_KEY_VOLUME_OVERFLOW, SS_FATAL|EIO, "VOLUME OVERFLOW" },
740
	{ SSD_KEY_MISCOMPARE, SS_NOP, "MISCOMPARE" },
741
	{ SSD_KEY_COMPLETED, SS_NOP, "COMPLETED" }
742
};
743

744
static struct asc_table_entry quantum_fireball_entries[] = {
745
	{ SST(0x04, 0x0b, SS_START | SSQ_DECREMENT_COUNT | ENXIO,
746
	     "Logical unit not ready, initializing cmd. required") }
747
};
748

749
static struct asc_table_entry sony_mo_entries[] = {
750
	{ SST(0x04, 0x00, SS_START | SSQ_DECREMENT_COUNT | ENXIO,
751
	     "Logical unit not ready, cause not reportable") }
752
};
753

754
static struct asc_table_entry hgst_entries[] = {
755
	{ SST(0x04, 0xF0, SS_RDEF,
756
	    "Vendor Unique - Logical Unit Not Ready") },
757
	{ SST(0x0A, 0x01, SS_RDEF,
758
	    "Unrecovered Super Certification Log Write Error") },
759
	{ SST(0x0A, 0x02, SS_RDEF,
760
	    "Unrecovered Super Certification Log Read Error") },
761
	{ SST(0x15, 0x03, SS_RDEF,
762
	    "Unrecovered Sector Error") },
763
	{ SST(0x3E, 0x04, SS_RDEF,
764
	    "Unrecovered Self-Test Hard-Cache Test Fail") },
765
	{ SST(0x3E, 0x05, SS_RDEF,
766
	    "Unrecovered Self-Test OTF-Cache Fail") },
767
	{ SST(0x40, 0x00, SS_RDEF,
768
	    "Unrecovered SAT No Buffer Overflow Error") },
769
	{ SST(0x40, 0x01, SS_RDEF,
770
	    "Unrecovered SAT Buffer Overflow Error") },
771
	{ SST(0x40, 0x02, SS_RDEF,
772
	    "Unrecovered SAT No Buffer Overflow With ECS Fault") },
773
	{ SST(0x40, 0x03, SS_RDEF,
774
	    "Unrecovered SAT Buffer Overflow With ECS Fault") },
775
	{ SST(0x40, 0x81, SS_RDEF,
776
	    "DRAM Failure") },
777
	{ SST(0x44, 0x0B, SS_RDEF,
778
	    "Vendor Unique - Internal Target Failure") },
779
	{ SST(0x44, 0xF2, SS_RDEF,
780
	    "Vendor Unique - Internal Target Failure") },
781
	{ SST(0x44, 0xF6, SS_RDEF,
782
	    "Vendor Unique - Internal Target Failure") },
783
	{ SST(0x44, 0xF9, SS_RDEF,
784
	    "Vendor Unique - Internal Target Failure") },
785
	{ SST(0x44, 0xFA, SS_RDEF,
786
	    "Vendor Unique - Internal Target Failure") },
787
	{ SST(0x5D, 0x22, SS_RDEF,
788
	    "Extreme Over-Temperature Warning") },
789
	{ SST(0x5D, 0x50, SS_RDEF,
790
	    "Load/Unload cycle Count Warning") },
791
	{ SST(0x81, 0x00, SS_RDEF,
792
	    "Vendor Unique - Internal Logic Error") },
793
	{ SST(0x85, 0x00, SS_RDEF,
794
	    "Vendor Unique - Internal Key Seed Error") },
795
};
796

797
static struct asc_table_entry seagate_entries[] = {
798
	{ SST(0x04, 0xF0, SS_RDEF,
799
	    "Logical Unit Not Ready, super certify in Progress") },
800
	{ SST(0x08, 0x86, SS_RDEF,
801
	    "Write Fault Data Corruption") },
802
	{ SST(0x09, 0x0D, SS_RDEF,
803
	    "Tracking Failure") },
804
	{ SST(0x09, 0x0E, SS_RDEF,
805
	    "ETF Failure") },
806
	{ SST(0x0B, 0x5D, SS_RDEF,
807
	    "Pre-SMART Warning") },
808
	{ SST(0x0B, 0x85, SS_RDEF,
809
	    "5V Voltage Warning") },
810
	{ SST(0x0B, 0x8C, SS_RDEF,
811
	    "12V Voltage Warning") },
812
	{ SST(0x0C, 0xFF, SS_RDEF,
813
	    "Write Error - Too many error recovery revs") },
814
	{ SST(0x11, 0xFF, SS_RDEF,
815
	    "Unrecovered Read Error - Too many error recovery revs") },
816
	{ SST(0x19, 0x0E, SS_RDEF,
817
	    "Fewer than 1/2 defect list copies") },
818
	{ SST(0x20, 0xF3, SS_RDEF,
819
	    "Illegal CDB linked to skip mask cmd") },
820
	{ SST(0x24, 0xF0, SS_RDEF,
821
	    "Illegal byte in CDB, LBA not matching") },
822
	{ SST(0x24, 0xF1, SS_RDEF,
823
	    "Illegal byte in CDB, LEN not matching") },
824
	{ SST(0x24, 0xF2, SS_RDEF,
825
	    "Mask not matching transfer length") },
826
	{ SST(0x24, 0xF3, SS_RDEF,
827
	    "Drive formatted without plist") },
828
	{ SST(0x26, 0x95, SS_RDEF,
829
	    "Invalid Field Parameter - CAP File") },
830
	{ SST(0x26, 0x96, SS_RDEF,
831
	    "Invalid Field Parameter - RAP File") },
832
	{ SST(0x26, 0x97, SS_RDEF,
833
	    "Invalid Field Parameter - TMS Firmware Tag") },
834
	{ SST(0x26, 0x98, SS_RDEF,
835
	    "Invalid Field Parameter - Check Sum") },
836
	{ SST(0x26, 0x99, SS_RDEF,
837
	    "Invalid Field Parameter - Firmware Tag") },
838
	{ SST(0x29, 0x08, SS_RDEF,
839
	    "Write Log Dump data") },
840
	{ SST(0x29, 0x09, SS_RDEF,
841
	    "Write Log Dump data") },
842
	{ SST(0x29, 0x0A, SS_RDEF,
843
	    "Reserved disk space") },
844
	{ SST(0x29, 0x0B, SS_RDEF,
845
	    "SDBP") },
846
	{ SST(0x29, 0x0C, SS_RDEF,
847
	    "SDBP") },
848
	{ SST(0x31, 0x91, SS_RDEF,
849
	    "Format Corrupted World Wide Name (WWN) is Invalid") },
850
	{ SST(0x32, 0x03, SS_RDEF,
851
	    "Defect List - Length exceeds Command Allocated Length") },
852
	{ SST(0x33, 0x00, SS_RDEF,
853
	    "Flash not ready for access") },
854
	{ SST(0x3F, 0x70, SS_RDEF,
855
	    "Invalid RAP block") },
856
	{ SST(0x3F, 0x71, SS_RDEF,
857
	    "RAP/ETF mismatch") },
858
	{ SST(0x3F, 0x90, SS_RDEF,
859
	    "Invalid CAP block") },
860
	{ SST(0x3F, 0x91, SS_RDEF,
861
	    "World Wide Name (WWN) Mismatch") },
862
	{ SST(0x40, 0x01, SS_RDEF,
863
	    "DRAM Parity Error") },
864
	{ SST(0x40, 0x02, SS_RDEF,
865
	    "DRAM Parity Error") },
866
	{ SST(0x42, 0x0A, SS_RDEF,
867
	    "Loopback Test") },
868
	{ SST(0x42, 0x0B, SS_RDEF,
869
	    "Loopback Test") },
870
	{ SST(0x44, 0xF2, SS_RDEF,
871
	    "Compare error during data integrity check") },
872
	{ SST(0x44, 0xF6, SS_RDEF,
873
	    "Unrecoverable error during data integrity check") },
874
	{ SST(0x47, 0x80, SS_RDEF,
875
	    "Fibre Channel Sequence Error") },
876
	{ SST(0x4E, 0x01, SS_RDEF,
877
	    "Information Unit Too Short") },
878
	{ SST(0x80, 0x00, SS_RDEF,
879
	    "General Firmware Error / Command Timeout") },
880
	{ SST(0x80, 0x01, SS_RDEF,
881
	    "Command Timeout") },
882
	{ SST(0x80, 0x02, SS_RDEF,
883
	    "Command Timeout") },
884
	{ SST(0x80, 0x80, SS_RDEF,
885
	    "FC FIFO Error During Read Transfer") },
886
	{ SST(0x80, 0x81, SS_RDEF,
887
	    "FC FIFO Error During Write Transfer") },
888
	{ SST(0x80, 0x82, SS_RDEF,
889
	    "DISC FIFO Error During Read Transfer") },
890
	{ SST(0x80, 0x83, SS_RDEF,
891
	    "DISC FIFO Error During Write Transfer") },
892
	{ SST(0x80, 0x84, SS_RDEF,
893
	    "LBA Seeded LRC Error on Read") },
894
	{ SST(0x80, 0x85, SS_RDEF,
895
	    "LBA Seeded LRC Error on Write") },
896
	{ SST(0x80, 0x86, SS_RDEF,
897
	    "IOEDC Error on Read") },
898
	{ SST(0x80, 0x87, SS_RDEF,
899
	    "IOEDC Error on Write") },
900
	{ SST(0x80, 0x88, SS_RDEF,
901
	    "Host Parity Check Failed") },
902
	{ SST(0x80, 0x89, SS_RDEF,
903
	    "IOEDC error on read detected by formatter") },
904
	{ SST(0x80, 0x8A, SS_RDEF,
905
	    "Host Parity Errors / Host FIFO Initialization Failed") },
906
	{ SST(0x80, 0x8B, SS_RDEF,
907
	    "Host Parity Errors") },
908
	{ SST(0x80, 0x8C, SS_RDEF,
909
	    "Host Parity Errors") },
910
	{ SST(0x80, 0x8D, SS_RDEF,
911
	    "Host Parity Errors") },
912
	{ SST(0x81, 0x00, SS_RDEF,
913
	    "LA Check Failed") },
914
	{ SST(0x82, 0x00, SS_RDEF,
915
	    "Internal client detected insufficient buffer") },
916
	{ SST(0x84, 0x00, SS_RDEF,
917
	    "Scheduled Diagnostic And Repair") },
918
};
919

920
static struct scsi_sense_quirk_entry sense_quirk_table[] = {
921
	{
922
		/*
923
		 * XXX The Quantum Fireball ST and SE like to return 0x04 0x0b
924
		 * when they really should return 0x04 0x02.
925
		 */
926
		{T_DIRECT, SIP_MEDIA_FIXED, "QUANTUM", "FIREBALL S*", "*"},
927
		/*num_sense_keys*/0,
928
		nitems(quantum_fireball_entries),
929
		/*sense key entries*/NULL,
930
		quantum_fireball_entries
931
	},
932
	{
933
		/*
934
		 * This Sony MO drive likes to return 0x04, 0x00 when it
935
		 * isn't spun up.
936
		 */
937
		{T_DIRECT, SIP_MEDIA_REMOVABLE, "SONY", "SMO-*", "*"},
938
		/*num_sense_keys*/0,
939
		nitems(sony_mo_entries),
940
		/*sense key entries*/NULL,
941
		sony_mo_entries
942
	},
943
	{
944
		/*
945
		 * HGST vendor-specific error codes
946
		 */
947
		{T_DIRECT, SIP_MEDIA_FIXED, "HGST", "*", "*"},
948
		/*num_sense_keys*/0,
949
		nitems(hgst_entries),
950
		/*sense key entries*/NULL,
951
		hgst_entries
952
	},
953
	{
954
		/*
955
		 * SEAGATE vendor-specific error codes
956
		 */
957
		{T_DIRECT, SIP_MEDIA_FIXED, "SEAGATE", "*", "*"},
958
		/*num_sense_keys*/0,
959
		nitems(seagate_entries),
960
		/*sense key entries*/NULL,
961
		seagate_entries
962
	}
963
};
964

965
const u_int sense_quirk_table_size = nitems(sense_quirk_table);
966

967
static struct asc_table_entry asc_table[] = {
968
	/*
969
	 * From: http://www.t10.org/lists/asc-num.txt
970
	 * Modifications by Jung-uk Kim ([email protected])
971
	 */
972
	/*
973
	 * File: ASC-NUM.TXT
974
	 *
975
	 * SCSI ASC/ASCQ Assignments
976
	 * Numeric Sorted Listing
977
	 * as of  Sat Mar 25 2023 at 04:30 (using old columns)
978
	 *
979
	 * D - DIRECT ACCESS DEVICE (SBC-2)                   device column key
980
	 * .T - SEQUENTIAL ACCESS DEVICE (SSC)               -------------------
981
	 * . L - PRINTER DEVICE (SSC)                           blank = reserved
982
	 * .  P - PROCESSOR DEVICE (SPC)                     not blank = allowed
983
	 * .  .W - WRITE ONCE READ MULTIPLE DEVICE (SBC-2)
984
	 * .  . R - CD DEVICE (MMC)
985
	 * .  .  O - OPTICAL MEMORY DEVICE (SBC-2)
986
	 * .  .  .M - MEDIA CHANGER DEVICE (SMC)
987
	 * .  .  . A - STORAGE ARRAY DEVICE (SCC)
988
	 * .  .  .  E - ENCLOSURE SERVICES DEVICE (SES)
989
	 * .  .  .  .B - SIMPLIFIED DIRECT-ACCESS DEVICE (RBC)
990
	 * .  .  .  . K - OPTICAL CARD READER/WRITER DEVICE (OCRW)
991
	 * .  .  .  .  V - AUTOMATION/DRIVE INTERFACE (ADC)
992
	 * .  .  .  .  .F - OBJECT-BASED STORAGE (OSD)
993
	 * DTLPWROMAEBKVF
994
	 * ASC      ASCQ  Action
995
	 * Description
996
	 */
997
	/* DTLPWROMAEBKVF */
998
	{ SST(0x00, 0x00, SS_NOP,
999
	    "No additional sense information") },
1000
	/*  T             */
1001
	{ SST(0x00, 0x01, SS_RDEF,
1002
	    "Filemark detected") },
1003
	/*  T             */
1004
	{ SST(0x00, 0x02, SS_RDEF,
1005
	    "End-of-partition/medium detected") },
1006
	/*  T             */
1007
	{ SST(0x00, 0x03, SS_RDEF,
1008
	    "Setmark detected") },
1009
	/*  T             */
1010
	{ SST(0x00, 0x04, SS_RDEF,
1011
	    "Beginning-of-partition/medium detected") },
1012
	/*  TL            */
1013
	{ SST(0x00, 0x05, SS_RDEF,
1014
	    "End-of-data detected") },
1015
	/* DTLPWROMAEBKVF */
1016
	{ SST(0x00, 0x06, SS_RDEF,
1017
	    "I/O process terminated") },
1018
	/*  T             */
1019
	{ SST(0x00, 0x07, SS_RDEF,	/* XXX TBD */
1020
	    "Programmable early warning detected") },
1021
	/*      R         */
1022
	{ SST(0x00, 0x11, SS_FATAL | EBUSY,
1023
	    "Audio play operation in progress") },
1024
	/*      R         */
1025
	{ SST(0x00, 0x12, SS_NOP,
1026
	    "Audio play operation paused") },
1027
	/*      R         */
1028
	{ SST(0x00, 0x13, SS_NOP,
1029
	    "Audio play operation successfully completed") },
1030
	/*      R         */
1031
	{ SST(0x00, 0x14, SS_RDEF,
1032
	    "Audio play operation stopped due to error") },
1033
	/*      R         */
1034
	{ SST(0x00, 0x15, SS_NOP,
1035
	    "No current audio status to return") },
1036
	/* DTLPWROMAEBKVF */
1037
	{ SST(0x00, 0x16, SS_FATAL | EBUSY,
1038
	    "Operation in progress") },
1039
	/* DTL WROMAEBKVF */
1040
	{ SST(0x00, 0x17, SS_RDEF,
1041
	    "Cleaning requested") },
1042
	/*  T             */
1043
	{ SST(0x00, 0x18, SS_RDEF,	/* XXX TBD */
1044
	    "Erase operation in progress") },
1045
	/*  T             */
1046
	{ SST(0x00, 0x19, SS_RDEF,	/* XXX TBD */
1047
	    "Locate operation in progress") },
1048
	/*  T             */
1049
	{ SST(0x00, 0x1A, SS_RDEF,	/* XXX TBD */
1050
	    "Rewind operation in progress") },
1051
	/*  T             */
1052
	{ SST(0x00, 0x1B, SS_RDEF,	/* XXX TBD */
1053
	    "Set capacity operation in progress") },
1054
	/*  T             */
1055
	{ SST(0x00, 0x1C, SS_RDEF,	/* XXX TBD */
1056
	    "Verify operation in progress") },
1057
	/* DT        B    */
1058
	{ SST(0x00, 0x1D, SS_NOP,
1059
	    "ATA pass through information available") },
1060
	/* DT   R MAEBKV  */
1061
	{ SST(0x00, 0x1E, SS_RDEF,	/* XXX TBD */
1062
	    "Conflicting SA creation request") },
1063
	/* DT        B    */
1064
	{ SST(0x00, 0x1F, SS_RDEF,	/* XXX TBD */
1065
	    "Logical unit transitioning to another power condition") },
1066
	/* DT P      B    */
1067
	{ SST(0x00, 0x20, SS_NOP,
1068
	    "Extended copy information available") },
1069
	/* D              */
1070
	{ SST(0x00, 0x21, SS_RDEF,	/* XXX TBD */
1071
	    "Atomic command aborted due to ACA") },
1072
	/* D              */
1073
	{ SST(0x00, 0x22, SS_RDEF,	/* XXX TBD */
1074
	    "Deferred microcode is pending") },
1075
	/* D              */
1076
	{ SST(0x00, 0x23, SS_RDEF,	/* XXX TBD */
1077
	    "Overlapping atomic command in progress") },
1078
	/* D   W O   BK   */
1079
	{ SST(0x01, 0x00, SS_RDEF,
1080
	    "No index/sector signal") },
1081
	/* D   WRO   BK   */
1082
	{ SST(0x02, 0x00, SS_FATAL | EIO,
1083
	    "No seek complete") },
1084
	/* DTL W O   BK   */
1085
	{ SST(0x03, 0x00, SS_RDEF,
1086
	    "Peripheral device write fault") },
1087
	/*  T             */
1088
	{ SST(0x03, 0x01, SS_RDEF,
1089
	    "No write current") },
1090
	/*  T             */
1091
	{ SST(0x03, 0x02, SS_RDEF,
1092
	    "Excessive write errors") },
1093
	/* DTLPWROMAEBKVF */
1094
	{ SST(0x04, 0x00, SS_RDEF,
1095
	    "Logical unit not ready, cause not reportable") },
1096
	/* DTLPWROMAEBKVF */
1097
	{ SST(0x04, 0x01, SS_WAIT | EBUSY,
1098
	    "Logical unit is in process of becoming ready") },
1099
	/* DTLPWROMAEBKVF */
1100
	{ SST(0x04, 0x02, SS_START | SSQ_DECREMENT_COUNT | ENXIO,
1101
	    "Logical unit not ready, initializing command required") },
1102
	/* DTLPWROMAEBKVF */
1103
	{ SST(0x04, 0x03, SS_FATAL | ENXIO,
1104
	    "Logical unit not ready, manual intervention required") },
1105
	/* DTL  RO   B    */
1106
	{ SST(0x04, 0x04, SS_FATAL | EBUSY,
1107
	    "Logical unit not ready, format in progress") },
1108
	/* DT  W O A BK F */
1109
	{ SST(0x04, 0x05, SS_FATAL | EBUSY,
1110
	    "Logical unit not ready, rebuild in progress") },
1111
	/* DT  W O A BK   */
1112
	{ SST(0x04, 0x06, SS_FATAL | EBUSY,
1113
	    "Logical unit not ready, recalculation in progress") },
1114
	/* DTLPWROMAEBKVF */
1115
	{ SST(0x04, 0x07, SS_FATAL | EBUSY,
1116
	    "Logical unit not ready, operation in progress") },
1117
	/*      R         */
1118
	{ SST(0x04, 0x08, SS_FATAL | EBUSY,
1119
	    "Logical unit not ready, long write in progress") },
1120
	/* DTLPWROMAEBKVF */
1121
	{ SST(0x04, 0x09, SS_FATAL | EBUSY,
1122
	    "Logical unit not ready, self-test in progress") },
1123
	/* DTLPWROMAEBKVF */
1124
	{ SST(0x04, 0x0A, SS_WAIT | ENXIO,
1125
	    "Logical unit not accessible, asymmetric access state transition")},
1126
	/* DTLPWROMAEBKVF */
1127
	{ SST(0x04, 0x0B, SS_FATAL | ENXIO,
1128
	    "Logical unit not accessible, target port in standby state") },
1129
	/* DTLPWROMAEBKVF */
1130
	{ SST(0x04, 0x0C, SS_FATAL | ENXIO,
1131
	    "Logical unit not accessible, target port in unavailable state") },
1132
	/*              F */
1133
	{ SST(0x04, 0x0D, SS_RDEF,	/* XXX TBD */
1134
	    "Logical unit not ready, structure check required") },
1135
	/* DTL WR MAEBKVF */
1136
	{ SST(0x04, 0x0E, SS_RDEF,	/* XXX TBD */
1137
	    "Logical unit not ready, security session in progress") },
1138
	/* DT  WROM  B    */
1139
	{ SST(0x04, 0x10, SS_FATAL | ENODEV,
1140
	    "Logical unit not ready, auxiliary memory not accessible") },
1141
	/* DT  WRO AEB VF */
1142
	{ SST(0x04, 0x11, SS_WAIT | ENXIO,
1143
	    "Logical unit not ready, notify (enable spinup) required") },
1144
	/*        M    V  */
1145
	{ SST(0x04, 0x12, SS_FATAL | ENXIO,
1146
	    "Logical unit not ready, offline") },
1147
	/* DT   R MAEBKV  */
1148
	{ SST(0x04, 0x13, SS_WAIT | EBUSY,
1149
	    "Logical unit not ready, SA creation in progress") },
1150
	/* D         B    */
1151
	{ SST(0x04, 0x14, SS_WAIT | ENOSPC,
1152
	    "Logical unit not ready, space allocation in progress") },
1153
	/*        M       */
1154
	{ SST(0x04, 0x15, SS_FATAL | ENXIO,
1155
	    "Logical unit not ready, robotics disabled") },
1156
	/*        M       */
1157
	{ SST(0x04, 0x16, SS_FATAL | ENXIO,
1158
	    "Logical unit not ready, configuration required") },
1159
	/*        M       */
1160
	{ SST(0x04, 0x17, SS_FATAL | ENXIO,
1161
	    "Logical unit not ready, calibration required") },
1162
	/*        M       */
1163
	{ SST(0x04, 0x18, SS_FATAL | ENXIO,
1164
	    "Logical unit not ready, a door is open") },
1165
	/*        M       */
1166
	{ SST(0x04, 0x19, SS_FATAL | ENODEV,
1167
	    "Logical unit not ready, operating in sequential mode") },
1168
	/* DT        B    */
1169
	{ SST(0x04, 0x1A, SS_WAIT | EBUSY,
1170
	    "Logical unit not ready, START/STOP UNIT command in progress") },
1171
	/* D         B    */
1172
	{ SST(0x04, 0x1B, SS_WAIT | EBUSY,
1173
	    "Logical unit not ready, sanitize in progress") },
1174
	/* DT     MAEB    */
1175
	{ SST(0x04, 0x1C, SS_START | SSQ_DECREMENT_COUNT | ENXIO,
1176
	    "Logical unit not ready, additional power use not yet granted") },
1177
	/* D              */
1178
	{ SST(0x04, 0x1D, SS_WAIT | EBUSY,
1179
	    "Logical unit not ready, configuration in progress") },
1180
	/* D              */
1181
	{ SST(0x04, 0x1E, SS_FATAL | ENXIO,
1182
	    "Logical unit not ready, microcode activation required") },
1183
	/* DTLPWROMAEBKVF */
1184
	{ SST(0x04, 0x1F, SS_FATAL | ENXIO,
1185
	    "Logical unit not ready, microcode download required") },
1186
	/* DTLPWROMAEBKVF */
1187
	{ SST(0x04, 0x20, SS_FATAL | ENXIO,
1188
	    "Logical unit not ready, logical unit reset required") },
1189
	/* DTLPWROMAEBKVF */
1190
	{ SST(0x04, 0x21, SS_FATAL | ENXIO,
1191
	    "Logical unit not ready, hard reset required") },
1192
	/* DTLPWROMAEBKVF */
1193
	{ SST(0x04, 0x22, SS_FATAL | ENXIO,
1194
	    "Logical unit not ready, power cycle required") },
1195
	/* D              */
1196
	{ SST(0x04, 0x23, SS_FATAL | ENXIO,
1197
	    "Logical unit not ready, affiliation required") },
1198
	/* D              */
1199
	{ SST(0x04, 0x24, SS_FATAL | EBUSY,
1200
	    "Depopulation in progress") },
1201
	/* D              */
1202
	{ SST(0x04, 0x25, SS_FATAL | EBUSY,
1203
	    "Depopulation restoration in progress") },
1204
	/* DTL WROMAEBKVF */
1205
	{ SST(0x05, 0x00, SS_RDEF,
1206
	    "Logical unit does not respond to selection") },
1207
	/* D   WROM  BK   */
1208
	{ SST(0x06, 0x00, SS_RDEF,
1209
	    "No reference position found") },
1210
	/* DTL WROM  BK   */
1211
	{ SST(0x07, 0x00, SS_RDEF,
1212
	    "Multiple peripheral devices selected") },
1213
	/* DTL WROMAEBKVF */
1214
	{ SST(0x08, 0x00, SS_RDEF,
1215
	    "Logical unit communication failure") },
1216
	/* DTL WROMAEBKVF */
1217
	{ SST(0x08, 0x01, SS_RDEF,
1218
	    "Logical unit communication time-out") },
1219
	/* DTL WROMAEBKVF */
1220
	{ SST(0x08, 0x02, SS_RDEF,
1221
	    "Logical unit communication parity error") },
1222
	/* DT   ROM  BK   */
1223
	{ SST(0x08, 0x03, SS_RDEF,
1224
	    "Logical unit communication CRC error (Ultra-DMA/32)") },
1225
	/* DTLPWRO    K   */
1226
	{ SST(0x08, 0x04, SS_RDEF,	/* XXX TBD */
1227
	    "Unreachable copy target") },
1228
	/* DT  WRO   B    */
1229
	{ SST(0x09, 0x00, SS_RDEF,
1230
	    "Track following error") },
1231
	/*     WRO    K   */
1232
	{ SST(0x09, 0x01, SS_RDEF,
1233
	    "Tracking servo failure") },
1234
	/*     WRO    K   */
1235
	{ SST(0x09, 0x02, SS_RDEF,
1236
	    "Focus servo failure") },
1237
	/*     WRO        */
1238
	{ SST(0x09, 0x03, SS_RDEF,
1239
	    "Spindle servo failure") },
1240
	/* DT  WRO   B    */
1241
	{ SST(0x09, 0x04, SS_RDEF,
1242
	    "Head select fault") },
1243
	/* DT   RO   B    */
1244
	{ SST(0x09, 0x05, SS_RDEF,
1245
	    "Vibration induced tracking error") },
1246
	/* DTLPWROMAEBKVF */
1247
	{ SST(0x0A, 0x00, SS_FATAL | ENOSPC,
1248
	    "Error log overflow") },
1249
	/* DTLPWROMAEBKVF */
1250
	{ SST(0x0B, 0x00, SS_NOP | SSQ_PRINT_SENSE,
1251
	    "Warning") },
1252
	/* DTLPWROMAEBKVF */
1253
	{ SST(0x0B, 0x01, SS_NOP | SSQ_PRINT_SENSE,
1254
	    "Warning - specified temperature exceeded") },
1255
	/* DTLPWROMAEBKVF */
1256
	{ SST(0x0B, 0x02, SS_NOP | SSQ_PRINT_SENSE,
1257
	    "Warning - enclosure degraded") },
1258
	/* DTLPWROMAEBKVF */
1259
	{ SST(0x0B, 0x03, SS_NOP | SSQ_PRINT_SENSE,
1260
	    "Warning - background self-test failed") },
1261
	/* DTLPWRO AEBKVF */
1262
	{ SST(0x0B, 0x04, SS_NOP | SSQ_PRINT_SENSE,
1263
	    "Warning - background pre-scan detected medium error") },
1264
	/* DTLPWRO AEBKVF */
1265
	{ SST(0x0B, 0x05, SS_NOP | SSQ_PRINT_SENSE,
1266
	    "Warning - background medium scan detected medium error") },
1267
	/* DTLPWROMAEBKVF */
1268
	{ SST(0x0B, 0x06, SS_NOP | SSQ_PRINT_SENSE,
1269
	    "Warning - non-volatile cache now volatile") },
1270
	/* DTLPWROMAEBKVF */
1271
	{ SST(0x0B, 0x07, SS_NOP | SSQ_PRINT_SENSE,
1272
	    "Warning - degraded power to non-volatile cache") },
1273
	/* DTLPWROMAEBKVF */
1274
	{ SST(0x0B, 0x08, SS_NOP | SSQ_PRINT_SENSE,
1275
	    "Warning - power loss expected") },
1276
	/* D              */
1277
	{ SST(0x0B, 0x09, SS_NOP | SSQ_PRINT_SENSE,
1278
	    "Warning - device statistics notification available") },
1279
	/* DTLPWROMAEBKV  */
1280
	{ SST(0x0B, 0x0A, SS_NOP | SSQ_PRINT_SENSE,
1281
	    "Warning - High critical temperature limit exceeded") },
1282
	/* DTLPWROMAEBKV  */
1283
	{ SST(0x0B, 0x0B, SS_NOP | SSQ_PRINT_SENSE,
1284
	    "Warning - Low critical temperature limit exceeded") },
1285
	/* DTLPWROMAEBKV  */
1286
	{ SST(0x0B, 0x0C, SS_NOP | SSQ_PRINT_SENSE,
1287
	    "Warning - High operating temperature limit exceeded") },
1288
	/* DTLPWROMAEBKV  */
1289
	{ SST(0x0B, 0x0D, SS_NOP | SSQ_PRINT_SENSE,
1290
	    "Warning - Low operating temperature limit exceeded") },
1291
	/* DTLPWROMAEBKV  */
1292
	{ SST(0x0B, 0x0E, SS_NOP | SSQ_PRINT_SENSE,
1293
	    "Warning - High citical humidity limit exceeded") },
1294
	/* DTLPWROMAEBKV  */
1295
	{ SST(0x0B, 0x0F, SS_NOP | SSQ_PRINT_SENSE,
1296
	    "Warning - Low citical humidity limit exceeded") },
1297
	/* DTLPWROMAEBKV  */
1298
	{ SST(0x0B, 0x10, SS_NOP | SSQ_PRINT_SENSE,
1299
	    "Warning - High operating humidity limit exceeded") },
1300
	/* DTLPWROMAEBKV  */
1301
	{ SST(0x0B, 0x11, SS_NOP | SSQ_PRINT_SENSE,
1302
	    "Warning - Low operating humidity limit exceeded") },
1303
	/* DTLPWROMAEBKVF */
1304
	{ SST(0x0B, 0x12, SS_NOP | SSQ_PRINT_SENSE,
1305
	    "Warning - Microcode security at risk") },
1306
	/* DTLPWROMAEBKVF */
1307
	{ SST(0x0B, 0x13, SS_NOP | SSQ_PRINT_SENSE,
1308
	    "Warning - Microcode digital signature validation failure") },
1309
	/* D              */
1310
	{ SST(0x0B, 0x14, SS_NOP | SSQ_PRINT_SENSE,
1311
	    "Warning - Physical element status change") },
1312
	/*  T   R         */
1313
	{ SST(0x0C, 0x00, SS_RDEF,
1314
	    "Write error") },
1315
	/*            K   */
1316
	{ SST(0x0C, 0x01, SS_NOP | SSQ_PRINT_SENSE,
1317
	    "Write error - recovered with auto reallocation") },
1318
	/* D   W O   BK   */
1319
	{ SST(0x0C, 0x02, SS_RDEF,
1320
	    "Write error - auto reallocation failed") },
1321
	/* D   W O   BK   */
1322
	{ SST(0x0C, 0x03, SS_RDEF,
1323
	    "Write error - recommend reassignment") },
1324
	/* DT  W O   B    */
1325
	{ SST(0x0C, 0x04, SS_RDEF,
1326
	    "Compression check miscompare error") },
1327
	/* DT  W O   B    */
1328
	{ SST(0x0C, 0x05, SS_RDEF,
1329
	    "Data expansion occurred during compression") },
1330
	/* DT  W O   B    */
1331
	{ SST(0x0C, 0x06, SS_RDEF,
1332
	    "Block not compressible") },
1333
	/*      R         */
1334
	{ SST(0x0C, 0x07, SS_RDEF,
1335
	    "Write error - recovery needed") },
1336
	/*      R         */
1337
	{ SST(0x0C, 0x08, SS_RDEF,
1338
	    "Write error - recovery failed") },
1339
	/*      R         */
1340
	{ SST(0x0C, 0x09, SS_RDEF,
1341
	    "Write error - loss of streaming") },
1342
	/*      R         */
1343
	{ SST(0x0C, 0x0A, SS_RDEF,
1344
	    "Write error - padding blocks added") },
1345
	/* DT  WROM  B    */
1346
	{ SST(0x0C, 0x0B, SS_RDEF,	/* XXX TBD */
1347
	    "Auxiliary memory write error") },
1348
	/* DTLPWRO AEBKVF */
1349
	{ SST(0x0C, 0x0C, SS_RDEF,	/* XXX TBD */
1350
	    "Write error - unexpected unsolicited data") },
1351
	/* DTLPWRO AEBKVF */
1352
	{ SST(0x0C, 0x0D, SS_RDEF,	/* XXX TBD */
1353
	    "Write error - not enough unsolicited data") },
1354
	/* DT  W O   BK   */
1355
	{ SST(0x0C, 0x0E, SS_RDEF,	/* XXX TBD */
1356
	    "Multiple write errors") },
1357
	/*      R         */
1358
	{ SST(0x0C, 0x0F, SS_RDEF,	/* XXX TBD */
1359
	    "Defects in error window") },
1360
	/* D              */
1361
	{ SST(0x0C, 0x10, SS_RDEF,	/* XXX TBD */
1362
	    "Incomplete multiple atomic write operations") },
1363
	/* D              */
1364
	{ SST(0x0C, 0x11, SS_RDEF,	/* XXX TBD */
1365
	    "Write error - recovery scan needed") },
1366
	/* D              */
1367
	{ SST(0x0C, 0x12, SS_RDEF,	/* XXX TBD */
1368
	    "Write error - insufficient zone resources") },
1369
	/* DTLPWRO A  K   */
1370
	{ SST(0x0D, 0x00, SS_RDEF,	/* XXX TBD */
1371
	    "Error detected by third party temporary initiator") },
1372
	/* DTLPWRO A  K   */
1373
	{ SST(0x0D, 0x01, SS_RDEF,	/* XXX TBD */
1374
	    "Third party device failure") },
1375
	/* DTLPWRO A  K   */
1376
	{ SST(0x0D, 0x02, SS_RDEF,	/* XXX TBD */
1377
	    "Copy target device not reachable") },
1378
	/* DTLPWRO A  K   */
1379
	{ SST(0x0D, 0x03, SS_RDEF,	/* XXX TBD */
1380
	    "Incorrect copy target device type") },
1381
	/* DTLPWRO A  K   */
1382
	{ SST(0x0D, 0x04, SS_RDEF,	/* XXX TBD */
1383
	    "Copy target device data underrun") },
1384
	/* DTLPWRO A  K   */
1385
	{ SST(0x0D, 0x05, SS_RDEF,	/* XXX TBD */
1386
	    "Copy target device data overrun") },
1387
	/* DT PWROMAEBK F */
1388
	{ SST(0x0E, 0x00, SS_RDEF,	/* XXX TBD */
1389
	    "Invalid information unit") },
1390
	/* DT PWROMAEBK F */
1391
	{ SST(0x0E, 0x01, SS_RDEF,	/* XXX TBD */
1392
	    "Information unit too short") },
1393
	/* DT PWROMAEBK F */
1394
	{ SST(0x0E, 0x02, SS_RDEF,	/* XXX TBD */
1395
	    "Information unit too long") },
1396
	/* DT P R MAEBK F */
1397
	{ SST(0x0E, 0x03, SS_FATAL | EINVAL,
1398
	    "Invalid field in command information unit") },
1399
	/* D   W O   BK   */
1400
	{ SST(0x10, 0x00, SS_RDEF,
1401
	    "ID CRC or ECC error") },
1402
	/* DT  W O        */
1403
	{ SST(0x10, 0x01, SS_RDEF,	/* XXX TBD */
1404
	    "Logical block guard check failed") },
1405
	/* DT  W O        */
1406
	{ SST(0x10, 0x02, SS_RDEF,	/* XXX TBD */
1407
	    "Logical block application tag check failed") },
1408
	/* DT  W O        */
1409
	{ SST(0x10, 0x03, SS_RDEF,	/* XXX TBD */
1410
	    "Logical block reference tag check failed") },
1411
	/*  T             */
1412
	{ SST(0x10, 0x04, SS_RDEF,	/* XXX TBD */
1413
	    "Logical block protection error on recovered buffer data") },
1414
	/*  T             */
1415
	{ SST(0x10, 0x05, SS_RDEF,	/* XXX TBD */
1416
	    "Logical block protection method error") },
1417
	/* DT  WRO   BK   */
1418
	{ SST(0x11, 0x00, SS_FATAL|EIO,
1419
	    "Unrecovered read error") },
1420
	/* DT  WRO   BK   */
1421
	{ SST(0x11, 0x01, SS_FATAL|EIO,
1422
	    "Read retries exhausted") },
1423
	/* DT  WRO   BK   */
1424
	{ SST(0x11, 0x02, SS_FATAL|EIO,
1425
	    "Error too long to correct") },
1426
	/* DT  W O   BK   */
1427
	{ SST(0x11, 0x03, SS_FATAL|EIO,
1428
	    "Multiple read errors") },
1429
	/* D   W O   BK   */
1430
	{ SST(0x11, 0x04, SS_FATAL|EIO,
1431
	    "Unrecovered read error - auto reallocate failed") },
1432
	/*     WRO   B    */
1433
	{ SST(0x11, 0x05, SS_FATAL|EIO,
1434
	    "L-EC uncorrectable error") },
1435
	/*     WRO   B    */
1436
	{ SST(0x11, 0x06, SS_FATAL|EIO,
1437
	    "CIRC unrecovered error") },
1438
	/*     W O   B    */
1439
	{ SST(0x11, 0x07, SS_RDEF,
1440
	    "Data re-synchronization error") },
1441
	/*  T             */
1442
	{ SST(0x11, 0x08, SS_RDEF,
1443
	    "Incomplete block read") },
1444
	/*  T             */
1445
	{ SST(0x11, 0x09, SS_RDEF,
1446
	    "No gap found") },
1447
	/* DT    O   BK   */
1448
	{ SST(0x11, 0x0A, SS_RDEF,
1449
	    "Miscorrected error") },
1450
	/* D   W O   BK   */
1451
	{ SST(0x11, 0x0B, SS_FATAL|EIO,
1452
	    "Unrecovered read error - recommend reassignment") },
1453
	/* D   W O   BK   */
1454
	{ SST(0x11, 0x0C, SS_FATAL|EIO,
1455
	    "Unrecovered read error - recommend rewrite the data") },
1456
	/* DT  WRO   B    */
1457
	{ SST(0x11, 0x0D, SS_RDEF,
1458
	    "De-compression CRC error") },
1459
	/* DT  WRO   B    */
1460
	{ SST(0x11, 0x0E, SS_RDEF,
1461
	    "Cannot decompress using declared algorithm") },
1462
	/*      R         */
1463
	{ SST(0x11, 0x0F, SS_RDEF,
1464
	    "Error reading UPC/EAN number") },
1465
	/*      R         */
1466
	{ SST(0x11, 0x10, SS_RDEF,
1467
	    "Error reading ISRC number") },
1468
	/*      R         */
1469
	{ SST(0x11, 0x11, SS_RDEF,
1470
	    "Read error - loss of streaming") },
1471
	/* DT  WROM  B    */
1472
	{ SST(0x11, 0x12, SS_RDEF,	/* XXX TBD */
1473
	    "Auxiliary memory read error") },
1474
	/* DTLPWRO AEBKVF */
1475
	{ SST(0x11, 0x13, SS_RDEF,	/* XXX TBD */
1476
	    "Read error - failed retransmission request") },
1477
	/* D              */
1478
	{ SST(0x11, 0x14, SS_RDEF,	/* XXX TBD */
1479
	    "Read error - LBA marked bad by application client") },
1480
	/* D              */
1481
	{ SST(0x11, 0x15, SS_FATAL | EIO,
1482
	    "Write after sanitize required") },
1483
	/* D   W O   BK   */
1484
	{ SST(0x12, 0x00, SS_RDEF,
1485
	    "Address mark not found for ID field") },
1486
	/* D   W O   BK   */
1487
	{ SST(0x13, 0x00, SS_RDEF,
1488
	    "Address mark not found for data field") },
1489
	/* DTL WRO   BK   */
1490
	{ SST(0x14, 0x00, SS_RDEF,
1491
	    "Recorded entity not found") },
1492
	/* DT  WRO   BK   */
1493
	{ SST(0x14, 0x01, SS_RDEF,
1494
	    "Record not found") },
1495
	/*  T             */
1496
	{ SST(0x14, 0x02, SS_RDEF,
1497
	    "Filemark or setmark not found") },
1498
	/*  T             */
1499
	{ SST(0x14, 0x03, SS_RDEF,
1500
	    "End-of-data not found") },
1501
	/*  T             */
1502
	{ SST(0x14, 0x04, SS_RDEF,
1503
	    "Block sequence error") },
1504
	/* DT  W O   BK   */
1505
	{ SST(0x14, 0x05, SS_RDEF,
1506
	    "Record not found - recommend reassignment") },
1507
	/* DT  W O   BK   */
1508
	{ SST(0x14, 0x06, SS_RDEF,
1509
	    "Record not found - data auto-reallocated") },
1510
	/*  T             */
1511
	{ SST(0x14, 0x07, SS_RDEF,	/* XXX TBD */
1512
	    "Locate operation failure") },
1513
	/* DTL WROM  BK   */
1514
	{ SST(0x15, 0x00, SS_RDEF,
1515
	    "Random positioning error") },
1516
	/* DTL WROM  BK   */
1517
	{ SST(0x15, 0x01, SS_RDEF,
1518
	    "Mechanical positioning error") },
1519
	/* DT  WRO   BK   */
1520
	{ SST(0x15, 0x02, SS_RDEF,
1521
	    "Positioning error detected by read of medium") },
1522
	/* D   W O   BK   */
1523
	{ SST(0x16, 0x00, SS_RDEF,
1524
	    "Data synchronization mark error") },
1525
	/* D   W O   BK   */
1526
	{ SST(0x16, 0x01, SS_RDEF,
1527
	    "Data sync error - data rewritten") },
1528
	/* D   W O   BK   */
1529
	{ SST(0x16, 0x02, SS_RDEF,
1530
	    "Data sync error - recommend rewrite") },
1531
	/* D   W O   BK   */
1532
	{ SST(0x16, 0x03, SS_NOP | SSQ_PRINT_SENSE,
1533
	    "Data sync error - data auto-reallocated") },
1534
	/* D   W O   BK   */
1535
	{ SST(0x16, 0x04, SS_RDEF,
1536
	    "Data sync error - recommend reassignment") },
1537
	/* DT  WRO   BK   */
1538
	{ SST(0x17, 0x00, SS_NOP | SSQ_PRINT_SENSE,
1539
	    "Recovered data with no error correction applied") },
1540
	/* DT  WRO   BK   */
1541
	{ SST(0x17, 0x01, SS_NOP | SSQ_PRINT_SENSE,
1542
	    "Recovered data with retries") },
1543
	/* DT  WRO   BK   */
1544
	{ SST(0x17, 0x02, SS_NOP | SSQ_PRINT_SENSE,
1545
	    "Recovered data with positive head offset") },
1546
	/* DT  WRO   BK   */
1547
	{ SST(0x17, 0x03, SS_NOP | SSQ_PRINT_SENSE,
1548
	    "Recovered data with negative head offset") },
1549
	/*     WRO   B    */
1550
	{ SST(0x17, 0x04, SS_NOP | SSQ_PRINT_SENSE,
1551
	    "Recovered data with retries and/or CIRC applied") },
1552
	/* D   WRO   BK   */
1553
	{ SST(0x17, 0x05, SS_NOP | SSQ_PRINT_SENSE,
1554
	    "Recovered data using previous sector ID") },
1555
	/* D   W O   BK   */
1556
	{ SST(0x17, 0x06, SS_NOP | SSQ_PRINT_SENSE,
1557
	    "Recovered data without ECC - data auto-reallocated") },
1558
	/* D   WRO   BK   */
1559
	{ SST(0x17, 0x07, SS_NOP | SSQ_PRINT_SENSE,
1560
	    "Recovered data without ECC - recommend reassignment") },
1561
	/* D   WRO   BK   */
1562
	{ SST(0x17, 0x08, SS_NOP | SSQ_PRINT_SENSE,
1563
	    "Recovered data without ECC - recommend rewrite") },
1564
	/* D   WRO   BK   */
1565
	{ SST(0x17, 0x09, SS_NOP | SSQ_PRINT_SENSE,
1566
	    "Recovered data without ECC - data rewritten") },
1567
	/* DT  WRO   BK   */
1568
	{ SST(0x18, 0x00, SS_NOP | SSQ_PRINT_SENSE,
1569
	    "Recovered data with error correction applied") },
1570
	/* D   WRO   BK   */
1571
	{ SST(0x18, 0x01, SS_NOP | SSQ_PRINT_SENSE,
1572
	    "Recovered data with error corr. & retries applied") },
1573
	/* D   WRO   BK   */
1574
	{ SST(0x18, 0x02, SS_NOP | SSQ_PRINT_SENSE,
1575
	    "Recovered data - data auto-reallocated") },
1576
	/*      R         */
1577
	{ SST(0x18, 0x03, SS_NOP | SSQ_PRINT_SENSE,
1578
	    "Recovered data with CIRC") },
1579
	/*      R         */
1580
	{ SST(0x18, 0x04, SS_NOP | SSQ_PRINT_SENSE,
1581
	    "Recovered data with L-EC") },
1582
	/* D   WRO   BK   */
1583
	{ SST(0x18, 0x05, SS_NOP | SSQ_PRINT_SENSE,
1584
	    "Recovered data - recommend reassignment") },
1585
	/* D   WRO   BK   */
1586
	{ SST(0x18, 0x06, SS_NOP | SSQ_PRINT_SENSE,
1587
	    "Recovered data - recommend rewrite") },
1588
	/* D   W O   BK   */
1589
	{ SST(0x18, 0x07, SS_NOP | SSQ_PRINT_SENSE,
1590
	    "Recovered data with ECC - data rewritten") },
1591
	/*      R         */
1592
	{ SST(0x18, 0x08, SS_NOP | SSQ_PRINT_SENSE,
1593
	    "Recovered data with linking") },
1594
	/* D     O    K   */
1595
	{ SST(0x19, 0x00, SS_RDEF,
1596
	    "Defect list error") },
1597
	/* D     O    K   */
1598
	{ SST(0x19, 0x01, SS_RDEF,
1599
	    "Defect list not available") },
1600
	/* D     O    K   */
1601
	{ SST(0x19, 0x02, SS_RDEF,
1602
	    "Defect list error in primary list") },
1603
	/* D     O    K   */
1604
	{ SST(0x19, 0x03, SS_RDEF,
1605
	    "Defect list error in grown list") },
1606
	/* DTLPWROMAEBKVF */
1607
	{ SST(0x1A, 0x00, SS_RDEF,
1608
	    "Parameter list length error") },
1609
	/* DTLPWROMAEBKVF */
1610
	{ SST(0x1B, 0x00, SS_RDEF,
1611
	    "Synchronous data transfer error") },
1612
	/* D     O   BK   */
1613
	{ SST(0x1C, 0x00, SS_RDEF,
1614
	    "Defect list not found") },
1615
	/* D     O   BK   */
1616
	{ SST(0x1C, 0x01, SS_RDEF,
1617
	    "Primary defect list not found") },
1618
	/* D     O   BK   */
1619
	{ SST(0x1C, 0x02, SS_RDEF,
1620
	    "Grown defect list not found") },
1621
	/* DT  WRO   BK   */
1622
	{ SST(0x1D, 0x00, SS_FATAL,
1623
	    "Miscompare during verify operation") },
1624
	/* D         B    */
1625
	{ SST(0x1D, 0x01, SS_RDEF,	/* XXX TBD */
1626
	    "Miscomparable verify of unmapped LBA") },
1627
	/* D   W O   BK   */
1628
	{ SST(0x1E, 0x00, SS_NOP | SSQ_PRINT_SENSE,
1629
	    "Recovered ID with ECC correction") },
1630
	/* D     O    K   */
1631
	{ SST(0x1F, 0x00, SS_RDEF,
1632
	    "Partial defect list transfer") },
1633
	/* DTLPWROMAEBKVF */
1634
	{ SST(0x20, 0x00, SS_FATAL | EINVAL,
1635
	    "Invalid command operation code") },
1636
	/* DT PWROMAEBK   */
1637
	{ SST(0x20, 0x01, SS_RDEF,	/* XXX TBD */
1638
	    "Access denied - initiator pending-enrolled") },
1639
	/* DT PWROMAEBK   */
1640
	{ SST(0x20, 0x02, SS_FATAL | EPERM,
1641
	    "Access denied - no access rights") },
1642
	/* DT PWROMAEBK   */
1643
	{ SST(0x20, 0x03, SS_RDEF,	/* XXX TBD */
1644
	    "Access denied - invalid mgmt ID key") },
1645
	/*  T             */
1646
	{ SST(0x20, 0x04, SS_RDEF,	/* XXX TBD */
1647
	    "Illegal command while in write capable state") },
1648
	/*  T             */
1649
	{ SST(0x20, 0x05, SS_RDEF,	/* XXX TBD */
1650
	    "Obsolete") },
1651
	/*  T             */
1652
	{ SST(0x20, 0x06, SS_RDEF,	/* XXX TBD */
1653
	    "Illegal command while in explicit address mode") },
1654
	/*  T             */
1655
	{ SST(0x20, 0x07, SS_RDEF,	/* XXX TBD */
1656
	    "Illegal command while in implicit address mode") },
1657
	/* DT PWROMAEBK   */
1658
	{ SST(0x20, 0x08, SS_RDEF,	/* XXX TBD */
1659
	    "Access denied - enrollment conflict") },
1660
	/* DT PWROMAEBK   */
1661
	{ SST(0x20, 0x09, SS_RDEF,	/* XXX TBD */
1662
	    "Access denied - invalid LU identifier") },
1663
	/* DT PWROMAEBK   */
1664
	{ SST(0x20, 0x0A, SS_RDEF,	/* XXX TBD */
1665
	    "Access denied - invalid proxy token") },
1666
	/* DT PWROMAEBK   */
1667
	{ SST(0x20, 0x0B, SS_RDEF,	/* XXX TBD */
1668
	    "Access denied - ACL LUN conflict") },
1669
	/*  T             */
1670
	{ SST(0x20, 0x0C, SS_FATAL | EINVAL,
1671
	    "Illegal command when not in append-only mode") },
1672
	/* D              */
1673
	{ SST(0x20, 0x0D, SS_FATAL | EINVAL,
1674
	    "Not an administrative logical unit") },
1675
	/* D              */
1676
	{ SST(0x20, 0x0E, SS_FATAL | EINVAL,
1677
	    "Not a subsidiary logical unit") },
1678
	/* D              */
1679
	{ SST(0x20, 0x0F, SS_FATAL | EINVAL,
1680
	    "Not a conglomerate logical unit") },
1681
	/* DT  WRO   BK   */
1682
	{ SST(0x21, 0x00, SS_FATAL | EINVAL,
1683
	    "Logical block address out of range") },
1684
	/* DT  WROM  BK   */
1685
	{ SST(0x21, 0x01, SS_FATAL | EINVAL,
1686
	    "Invalid element address") },
1687
	/*      R         */
1688
	{ SST(0x21, 0x02, SS_RDEF,	/* XXX TBD */
1689
	    "Invalid address for write") },
1690
	/*      R         */
1691
	{ SST(0x21, 0x03, SS_RDEF,	/* XXX TBD */
1692
	    "Invalid write crossing layer jump") },
1693
	/* D              */
1694
	{ SST(0x21, 0x04, SS_RDEF,	/* XXX TBD */
1695
	    "Unaligned write command") },
1696
	/* D              */
1697
	{ SST(0x21, 0x05, SS_RDEF,	/* XXX TBD */
1698
	    "Write boundary violation") },
1699
	/* D              */
1700
	{ SST(0x21, 0x06, SS_RDEF,	/* XXX TBD */
1701
	    "Attempt to read invalid data") },
1702
	/* D              */
1703
	{ SST(0x21, 0x07, SS_RDEF,	/* XXX TBD */
1704
	    "Read boundary violation") },
1705
	/* D              */
1706
	{ SST(0x21, 0x08, SS_FATAL | EINVAL,
1707
	    "Misaligned write command") },
1708
	/* D              */
1709
	{ SST(0x21, 0x09, SS_FATAL | EINVAL,
1710
	    "Attempt to access gap zone") },
1711
	/* D              */
1712
	{ SST(0x22, 0x00, SS_FATAL | EINVAL,
1713
	    "Illegal function (use 20 00, 24 00, or 26 00)") },
1714
	/* DT P      B    */
1715
	{ SST(0x23, 0x00, SS_FATAL | EINVAL,
1716
	    "Invalid token operation, cause not reportable") },
1717
	/* DT P      B    */
1718
	{ SST(0x23, 0x01, SS_FATAL | EINVAL,
1719
	    "Invalid token operation, unsupported token type") },
1720
	/* DT P      B    */
1721
	{ SST(0x23, 0x02, SS_FATAL | EINVAL,
1722
	    "Invalid token operation, remote token usage not supported") },
1723
	/* DT P      B    */
1724
	{ SST(0x23, 0x03, SS_FATAL | EINVAL,
1725
	    "Invalid token operation, remote ROD token creation not supported") },
1726
	/* DT P      B    */
1727
	{ SST(0x23, 0x04, SS_FATAL | EINVAL,
1728
	    "Invalid token operation, token unknown") },
1729
	/* DT P      B    */
1730
	{ SST(0x23, 0x05, SS_FATAL | EINVAL,
1731
	    "Invalid token operation, token corrupt") },
1732
	/* DT P      B    */
1733
	{ SST(0x23, 0x06, SS_FATAL | EINVAL,
1734
	    "Invalid token operation, token revoked") },
1735
	/* DT P      B    */
1736
	{ SST(0x23, 0x07, SS_FATAL | EINVAL,
1737
	    "Invalid token operation, token expired") },
1738
	/* DT P      B    */
1739
	{ SST(0x23, 0x08, SS_FATAL | EINVAL,
1740
	    "Invalid token operation, token cancelled") },
1741
	/* DT P      B    */
1742
	{ SST(0x23, 0x09, SS_FATAL | EINVAL,
1743
	    "Invalid token operation, token deleted") },
1744
	/* DT P      B    */
1745
	{ SST(0x23, 0x0A, SS_FATAL | EINVAL,
1746
	    "Invalid token operation, invalid token length") },
1747
	/* DTLPWROMAEBKVF */
1748
	{ SST(0x24, 0x00, SS_FATAL | EINVAL,
1749
	    "Invalid field in CDB") },
1750
	/* DTLPWRO AEBKVF */
1751
	{ SST(0x24, 0x01, SS_RDEF,	/* XXX TBD */
1752
	    "CDB decryption error") },
1753
	/*  T             */
1754
	{ SST(0x24, 0x02, SS_RDEF,	/* XXX TBD */
1755
	    "Obsolete") },
1756
	/*  T             */
1757
	{ SST(0x24, 0x03, SS_RDEF,	/* XXX TBD */
1758
	    "Obsolete") },
1759
	/*              F */
1760
	{ SST(0x24, 0x04, SS_RDEF,	/* XXX TBD */
1761
	    "Security audit value frozen") },
1762
	/*              F */
1763
	{ SST(0x24, 0x05, SS_RDEF,	/* XXX TBD */
1764
	    "Security working key frozen") },
1765
	/*              F */
1766
	{ SST(0x24, 0x06, SS_RDEF,	/* XXX TBD */
1767
	    "NONCE not unique") },
1768
	/*              F */
1769
	{ SST(0x24, 0x07, SS_RDEF,	/* XXX TBD */
1770
	    "NONCE timestamp out of range") },
1771
	/* DT   R MAEBKV  */
1772
	{ SST(0x24, 0x08, SS_RDEF,	/* XXX TBD */
1773
	    "Invalid XCDB") },
1774
	/* D              */
1775
	{ SST(0x24, 0x09, SS_FATAL | EINVAL,
1776
	    "Invalid fast format") },
1777
	/* DTLPWROMAEBKVF */
1778
	{ SST(0x25, 0x00, SS_FATAL | ENXIO | SSQ_LOST,
1779
	    "Logical unit not supported") },
1780
	/* DTLPWROMAEBKVF */
1781
	{ SST(0x26, 0x00, SS_FATAL | EINVAL,
1782
	    "Invalid field in parameter list") },
1783
	/* DTLPWROMAEBKVF */
1784
	{ SST(0x26, 0x01, SS_FATAL | EINVAL,
1785
	    "Parameter not supported") },
1786
	/* DTLPWROMAEBKVF */
1787
	{ SST(0x26, 0x02, SS_FATAL | EINVAL,
1788
	    "Parameter value invalid") },
1789
	/* DTLPWROMAE K   */
1790
	{ SST(0x26, 0x03, SS_FATAL | EINVAL,
1791
	    "Threshold parameters not supported") },
1792
	/* DTLPWROMAEBKVF */
1793
	{ SST(0x26, 0x04, SS_FATAL | EINVAL,
1794
	    "Invalid release of persistent reservation") },
1795
	/* DTLPWRO A BK   */
1796
	{ SST(0x26, 0x05, SS_RDEF,	/* XXX TBD */
1797
	    "Data decryption error") },
1798
	/* DTLPWRO    K   */
1799
	{ SST(0x26, 0x06, SS_FATAL | EINVAL,
1800
	    "Too many target descriptors") },
1801
	/* DTLPWRO    K   */
1802
	{ SST(0x26, 0x07, SS_FATAL | EINVAL,
1803
	    "Unsupported target descriptor type code") },
1804
	/* DTLPWRO    K   */
1805
	{ SST(0x26, 0x08, SS_FATAL | EINVAL,
1806
	    "Too many segment descriptors") },
1807
	/* DTLPWRO    K   */
1808
	{ SST(0x26, 0x09, SS_FATAL | EINVAL,
1809
	    "Unsupported segment descriptor type code") },
1810
	/* DTLPWRO    K   */
1811
	{ SST(0x26, 0x0A, SS_FATAL | EINVAL,
1812
	    "Unexpected inexact segment") },
1813
	/* DTLPWRO    K   */
1814
	{ SST(0x26, 0x0B, SS_FATAL | EINVAL,
1815
	    "Inline data length exceeded") },
1816
	/* DTLPWRO    K   */
1817
	{ SST(0x26, 0x0C, SS_FATAL | EINVAL,
1818
	    "Invalid operation for copy source or destination") },
1819
	/* DTLPWRO    K   */
1820
	{ SST(0x26, 0x0D, SS_FATAL | EINVAL,
1821
	    "Copy segment granularity violation") },
1822
	/* DT PWROMAEBK   */
1823
	{ SST(0x26, 0x0E, SS_RDEF,	/* XXX TBD */
1824
	    "Invalid parameter while port is enabled") },
1825
	/*              F */
1826
	{ SST(0x26, 0x0F, SS_RDEF,	/* XXX TBD */
1827
	    "Invalid data-out buffer integrity check value") },
1828
	/*  T             */
1829
	{ SST(0x26, 0x10, SS_RDEF,	/* XXX TBD */
1830
	    "Data decryption key fail limit reached") },
1831
	/*  T             */
1832
	{ SST(0x26, 0x11, SS_RDEF,	/* XXX TBD */
1833
	    "Incomplete key-associated data set") },
1834
	/*  T             */
1835
	{ SST(0x26, 0x12, SS_RDEF,	/* XXX TBD */
1836
	    "Vendor specific key reference not found") },
1837
	/* D              */
1838
	{ SST(0x26, 0x13, SS_RDEF,	/* XXX TBD */
1839
	    "Application tag mode page is invalid") },
1840
	/*  T             */
1841
	{ SST(0x26, 0x14, SS_RDEF,	/* XXX TBD */
1842
	    "Tape stream mirroring prevented") },
1843
	/*  T              */
1844
	{ SST(0x26, 0x15, SS_FATAL | EINVAL,
1845
	    "Copy source or copy destination not authorized") },
1846
	/* D              */
1847
	{ SST(0x26, 0x16, SS_FATAL | EINVAL,
1848
	    "Fast copy not possible") },
1849
	/* DT  WRO   BK   */
1850
	{ SST(0x27, 0x00, SS_FATAL | EACCES,
1851
	    "Write protected") },
1852
	/* DT  WRO   BK   */
1853
	{ SST(0x27, 0x01, SS_FATAL | EACCES,
1854
	    "Hardware write protected") },
1855
	/* DT  WRO   BK   */
1856
	{ SST(0x27, 0x02, SS_FATAL | EACCES,
1857
	    "Logical unit software write protected") },
1858
	/*  T   R         */
1859
	{ SST(0x27, 0x03, SS_FATAL | EACCES,
1860
	    "Associated write protect") },
1861
	/*  T   R         */
1862
	{ SST(0x27, 0x04, SS_FATAL | EACCES,
1863
	    "Persistent write protect") },
1864
	/*  T   R         */
1865
	{ SST(0x27, 0x05, SS_FATAL | EACCES,
1866
	    "Permanent write protect") },
1867
	/*      R       F */
1868
	{ SST(0x27, 0x06, SS_RDEF,	/* XXX TBD */
1869
	    "Conditional write protect") },
1870
	/* D         B    */
1871
	{ SST(0x27, 0x07, SS_FATAL | ENOSPC,
1872
	    "Space allocation failed write protect") },
1873
	/* D              */
1874
	{ SST(0x27, 0x08, SS_FATAL | EACCES,
1875
	    "Zone is read only") },
1876
	/* DTLPWROMAEBKVF */
1877
	{ SST(0x28, 0x00, SS_FATAL | ENXIO,
1878
	    "Not ready to ready change, medium may have changed") },
1879
	/* DT  WROM  B    */
1880
	{ SST(0x28, 0x01, SS_FATAL | ENXIO,
1881
	    "Import or export element accessed") },
1882
	/*      R         */
1883
	{ SST(0x28, 0x02, SS_RDEF,	/* XXX TBD */
1884
	    "Format-layer may have changed") },
1885
	/*        M       */
1886
	{ SST(0x28, 0x03, SS_RDEF,	/* XXX TBD */
1887
	    "Import/export element accessed, medium changed") },
1888
	/*
1889
	 * XXX JGibbs - All of these should use the same errno, but I don't
1890
	 * think ENXIO is the correct choice.  Should we borrow from
1891
	 * the networking errnos?  ECONNRESET anyone?
1892
	 */
1893
	/* DTLPWROMAEBKVF */
1894
	{ SST(0x29, 0x00, SS_FATAL | ENXIO,
1895
	    "Power on, reset, or bus device reset occurred") },
1896
	/* DTLPWROMAEBKVF */
1897
	{ SST(0x29, 0x01, SS_RDEF,
1898
	    "Power on occurred") },
1899
	/* DTLPWROMAEBKVF */
1900
	{ SST(0x29, 0x02, SS_RDEF,
1901
	    "SCSI bus reset occurred") },
1902
	/* DTLPWROMAEBKVF */
1903
	{ SST(0x29, 0x03, SS_RDEF,
1904
	    "Bus device reset function occurred") },
1905
	/* DTLPWROMAEBKVF */
1906
	{ SST(0x29, 0x04, SS_RDEF,
1907
	    "Device internal reset") },
1908
	/* DTLPWROMAEBKVF */
1909
	{ SST(0x29, 0x05, SS_RDEF,
1910
	    "Transceiver mode changed to single-ended") },
1911
	/* DTLPWROMAEBKVF */
1912
	{ SST(0x29, 0x06, SS_RDEF,
1913
	    "Transceiver mode changed to LVD") },
1914
	/* DTLPWROMAEBKVF */
1915
	{ SST(0x29, 0x07, SS_RDEF,	/* XXX TBD */
1916
	    "I_T nexus loss occurred") },
1917
	/* DTL WROMAEBKVF */
1918
	{ SST(0x2A, 0x00, SS_RDEF,
1919
	    "Parameters changed") },
1920
	/* DTL WROMAEBKVF */
1921
	{ SST(0x2A, 0x01, SS_RDEF,
1922
	    "Mode parameters changed") },
1923
	/* DTL WROMAE K   */
1924
	{ SST(0x2A, 0x02, SS_RDEF,
1925
	    "Log parameters changed") },
1926
	/* DTLPWROMAE K   */
1927
	{ SST(0x2A, 0x03, SS_RDEF,
1928
	    "Reservations preempted") },
1929
	/* DTLPWROMAE     */
1930
	{ SST(0x2A, 0x04, SS_RDEF,	/* XXX TBD */
1931
	    "Reservations released") },
1932
	/* DTLPWROMAE     */
1933
	{ SST(0x2A, 0x05, SS_RDEF,	/* XXX TBD */
1934
	    "Registrations preempted") },
1935
	/* DTLPWROMAEBKVF */
1936
	{ SST(0x2A, 0x06, SS_RDEF,	/* XXX TBD */
1937
	    "Asymmetric access state changed") },
1938
	/* DTLPWROMAEBKVF */
1939
	{ SST(0x2A, 0x07, SS_RDEF,	/* XXX TBD */
1940
	    "Implicit asymmetric access state transition failed") },
1941
	/* DT  WROMAEBKVF */
1942
	{ SST(0x2A, 0x08, SS_RDEF,	/* XXX TBD */
1943
	    "Priority changed") },
1944
	/* D              */
1945
	{ SST(0x2A, 0x09, SS_RDEF,	/* XXX TBD */
1946
	    "Capacity data has changed") },
1947
	/* DT             */
1948
	{ SST(0x2A, 0x0A, SS_RDEF,	/* XXX TBD */
1949
	    "Error history I_T nexus cleared") },
1950
	/* DT             */
1951
	{ SST(0x2A, 0x0B, SS_RDEF,	/* XXX TBD */
1952
	    "Error history snapshot released") },
1953
	/*              F */
1954
	{ SST(0x2A, 0x0C, SS_RDEF,	/* XXX TBD */
1955
	    "Error recovery attributes have changed") },
1956
	/*  T             */
1957
	{ SST(0x2A, 0x0D, SS_RDEF,	/* XXX TBD */
1958
	    "Data encryption capabilities changed") },
1959
	/* DT     M E  V  */
1960
	{ SST(0x2A, 0x10, SS_RDEF,	/* XXX TBD */
1961
	    "Timestamp changed") },
1962
	/*  T             */
1963
	{ SST(0x2A, 0x11, SS_RDEF,	/* XXX TBD */
1964
	    "Data encryption parameters changed by another I_T nexus") },
1965
	/*  T             */
1966
	{ SST(0x2A, 0x12, SS_RDEF,	/* XXX TBD */
1967
	    "Data encryption parameters changed by vendor specific event") },
1968
	/*  T             */
1969
	{ SST(0x2A, 0x13, SS_RDEF,	/* XXX TBD */
1970
	    "Data encryption key instance counter has changed") },
1971
	/* DT   R MAEBKV  */
1972
	{ SST(0x2A, 0x14, SS_RDEF,	/* XXX TBD */
1973
	    "SA creation capabilities data has changed") },
1974
	/*  T     M    V  */
1975
	{ SST(0x2A, 0x15, SS_RDEF,	/* XXX TBD */
1976
	    "Medium removal prevention preempted") },
1977
	/* D              */
1978
	{ SST(0x2A, 0x16, SS_RDEF,	/* XXX TBD */
1979
	    "Zone reset write pointer recommended") },
1980
	/* DTLPWRO    K   */
1981
	{ SST(0x2B, 0x00, SS_RDEF,
1982
	    "Copy cannot execute since host cannot disconnect") },
1983
	/* DTLPWROMAEBKVF */
1984
	{ SST(0x2C, 0x00, SS_RDEF,
1985
	    "Command sequence error") },
1986
	/*                */
1987
	{ SST(0x2C, 0x01, SS_RDEF,
1988
	    "Too many windows specified") },
1989
	/*                */
1990
	{ SST(0x2C, 0x02, SS_RDEF,
1991
	    "Invalid combination of windows specified") },
1992
	/*      R         */
1993
	{ SST(0x2C, 0x03, SS_RDEF,
1994
	    "Current program area is not empty") },
1995
	/*      R         */
1996
	{ SST(0x2C, 0x04, SS_RDEF,
1997
	    "Current program area is empty") },
1998
	/*           B    */
1999
	{ SST(0x2C, 0x05, SS_RDEF,	/* XXX TBD */
2000
	    "Illegal power condition request") },
2001
	/*      R         */
2002
	{ SST(0x2C, 0x06, SS_RDEF,	/* XXX TBD */
2003
	    "Persistent prevent conflict") },
2004
	/* DTLPWROMAEBKVF */
2005
	{ SST(0x2C, 0x07, SS_RDEF,	/* XXX TBD */
2006
	    "Previous busy status") },
2007
	/* DTLPWROMAEBKVF */
2008
	{ SST(0x2C, 0x08, SS_RDEF,	/* XXX TBD */
2009
	    "Previous task set full status") },
2010
	/* DTLPWROM EBKVF */
2011
	{ SST(0x2C, 0x09, SS_RDEF,	/* XXX TBD */
2012
	    "Previous reservation conflict status") },
2013
	/*              F */
2014
	{ SST(0x2C, 0x0A, SS_RDEF,	/* XXX TBD */
2015
	    "Partition or collection contains user objects") },
2016
	/*  T             */
2017
	{ SST(0x2C, 0x0B, SS_RDEF,	/* XXX TBD */
2018
	    "Not reserved") },
2019
	/* D              */
2020
	{ SST(0x2C, 0x0C, SS_RDEF,	/* XXX TBD */
2021
	    "ORWRITE generation does not match") },
2022
	/* D              */
2023
	{ SST(0x2C, 0x0D, SS_RDEF,	/* XXX TBD */
2024
	    "Reset write pointer not allowed") },
2025
	/* D              */
2026
	{ SST(0x2C, 0x0E, SS_RDEF,	/* XXX TBD */
2027
	    "Zone is offline") },
2028
	/* D              */
2029
	{ SST(0x2C, 0x0F, SS_RDEF,	/* XXX TBD */
2030
	    "Stream not open") },
2031
	/* D              */
2032
	{ SST(0x2C, 0x10, SS_RDEF,	/* XXX TBD */
2033
	    "Unwritten data in zone") },
2034
	/* D              */
2035
	{ SST(0x2C, 0x11, SS_FATAL | EINVAL,
2036
	    "Descriptor format sense data required") },
2037
	/* D              */
2038
	{ SST(0x2C, 0x12, SS_FATAL | EINVAL,
2039
	    "Zone is inactive") },
2040
	/* DTPEROMAEBKVF  */
2041
	{ SST(0x2C, 0x13, SS_FATAL | EINVAL,
2042
	    "Well known logical unit access required") },
2043
	/*  T             */
2044
	{ SST(0x2D, 0x00, SS_RDEF,
2045
	    "Overwrite error on update in place") },
2046
	/*      R         */
2047
	{ SST(0x2E, 0x00, SS_RDEF,	/* XXX TBD */
2048
	    "Insufficient time for operation") },
2049
	/* D              */
2050
	{ SST(0x2E, 0x01, SS_RDEF,	/* XXX TBD */
2051
	    "Command timeout before processing") },
2052
	/* D              */
2053
	{ SST(0x2E, 0x02, SS_RDEF,	/* XXX TBD */
2054
	    "Command timeout during processing") },
2055
	/* D              */
2056
	{ SST(0x2E, 0x03, SS_RDEF,	/* XXX TBD */
2057
	    "Command timeout during processing due to error recovery") },
2058
	/* DTLPWROMAEBKVF */
2059
	{ SST(0x2F, 0x00, SS_RDEF,
2060
	    "Commands cleared by another initiator") },
2061
	/* D              */
2062
	{ SST(0x2F, 0x01, SS_RDEF,	/* XXX TBD */
2063
	    "Commands cleared by power loss notification") },
2064
	/* DTLPWROMAEBKVF */
2065
	{ SST(0x2F, 0x02, SS_RDEF,	/* XXX TBD */
2066
	    "Commands cleared by device server") },
2067
	/* DTLPWROMAEBKVF */
2068
	{ SST(0x2F, 0x03, SS_RDEF,	/* XXX TBD */
2069
	    "Some commands cleared by queuing layer event") },
2070
	/* DT  WROM  BK   */
2071
	{ SST(0x30, 0x00, SS_RDEF,
2072
	    "Incompatible medium installed") },
2073
	/* DT  WRO   BK   */
2074
	{ SST(0x30, 0x01, SS_RDEF,
2075
	    "Cannot read medium - unknown format") },
2076
	/* DT  WRO   BK   */
2077
	{ SST(0x30, 0x02, SS_RDEF,
2078
	    "Cannot read medium - incompatible format") },
2079
	/* DT   R     K   */
2080
	{ SST(0x30, 0x03, SS_RDEF,
2081
	    "Cleaning cartridge installed") },
2082
	/* DT  WRO   BK   */
2083
	{ SST(0x30, 0x04, SS_RDEF,
2084
	    "Cannot write medium - unknown format") },
2085
	/* DT  WRO   BK   */
2086
	{ SST(0x30, 0x05, SS_RDEF,
2087
	    "Cannot write medium - incompatible format") },
2088
	/* DT  WRO   B    */
2089
	{ SST(0x30, 0x06, SS_RDEF,
2090
	    "Cannot format medium - incompatible medium") },
2091
	/* DTL WROMAEBKVF */
2092
	{ SST(0x30, 0x07, SS_RDEF,
2093
	    "Cleaning failure") },
2094
	/*      R         */
2095
	{ SST(0x30, 0x08, SS_RDEF,
2096
	    "Cannot write - application code mismatch") },
2097
	/*      R         */
2098
	{ SST(0x30, 0x09, SS_RDEF,
2099
	    "Current session not fixated for append") },
2100
	/* DT  WRO AEBK   */
2101
	{ SST(0x30, 0x0A, SS_RDEF,	/* XXX TBD */
2102
	    "Cleaning request rejected") },
2103
	/*  T             */
2104
	{ SST(0x30, 0x0C, SS_RDEF,	/* XXX TBD */
2105
	    "WORM medium - overwrite attempted") },
2106
	/*  T             */
2107
	{ SST(0x30, 0x0D, SS_RDEF,	/* XXX TBD */
2108
	    "WORM medium - integrity check") },
2109
	/*      R         */
2110
	{ SST(0x30, 0x10, SS_RDEF,	/* XXX TBD */
2111
	    "Medium not formatted") },
2112
	/*        M       */
2113
	{ SST(0x30, 0x11, SS_RDEF,	/* XXX TBD */
2114
	    "Incompatible volume type") },
2115
	/*        M       */
2116
	{ SST(0x30, 0x12, SS_RDEF,	/* XXX TBD */
2117
	    "Incompatible volume qualifier") },
2118
	/*        M       */
2119
	{ SST(0x30, 0x13, SS_RDEF,	/* XXX TBD */
2120
	    "Cleaning volume expired") },
2121
	/* DT  WRO   BK   */
2122
	{ SST(0x31, 0x00, SS_FATAL | ENXIO,
2123
	    "Medium format corrupted") },
2124
	/* D L  RO   B    */
2125
	{ SST(0x31, 0x01, SS_RDEF,
2126
	    "Format command failed") },
2127
	/*      R         */
2128
	{ SST(0x31, 0x02, SS_RDEF,	/* XXX TBD */
2129
	    "Zoned formatting failed due to spare linking") },
2130
	/* D         B    */
2131
	{ SST(0x31, 0x03, SS_FATAL | EIO,
2132
	    "SANITIZE command failed") },
2133
	/* D              */
2134
	{ SST(0x31, 0x04, SS_FATAL | EIO,
2135
	    "Depopulation failed") },
2136
	/* D              */
2137
	{ SST(0x31, 0x05, SS_FATAL | EIO,
2138
	    "Depopulation restoration failed") },
2139
	/* D   W O   BK   */
2140
	{ SST(0x32, 0x00, SS_RDEF,
2141
	    "No defect spare location available") },
2142
	/* D   W O   BK   */
2143
	{ SST(0x32, 0x01, SS_RDEF,
2144
	    "Defect list update failure") },
2145
	/*  T             */
2146
	{ SST(0x33, 0x00, SS_RDEF,
2147
	    "Tape length error") },
2148
	/* DTLPWROMAEBKVF */
2149
	{ SST(0x34, 0x00, SS_RDEF,
2150
	    "Enclosure failure") },
2151
	/* DTLPWROMAEBKVF */
2152
	{ SST(0x35, 0x00, SS_RDEF,
2153
	    "Enclosure services failure") },
2154
	/* DTLPWROMAEBKVF */
2155
	{ SST(0x35, 0x01, SS_RDEF,
2156
	    "Unsupported enclosure function") },
2157
	/* DTLPWROMAEBKVF */
2158
	{ SST(0x35, 0x02, SS_RDEF,
2159
	    "Enclosure services unavailable") },
2160
	/* DTLPWROMAEBKVF */
2161
	{ SST(0x35, 0x03, SS_RDEF,
2162
	    "Enclosure services transfer failure") },
2163
	/* DTLPWROMAEBKVF */
2164
	{ SST(0x35, 0x04, SS_RDEF,
2165
	    "Enclosure services transfer refused") },
2166
	/* DTL WROMAEBKVF */
2167
	{ SST(0x35, 0x05, SS_RDEF,	/* XXX TBD */
2168
	    "Enclosure services checksum error") },
2169
	/*   L            */
2170
	{ SST(0x36, 0x00, SS_RDEF,
2171
	    "Ribbon, ink, or toner failure") },
2172
	/* DTL WROMAEBKVF */
2173
	{ SST(0x37, 0x00, SS_RDEF,
2174
	    "Rounded parameter") },
2175
	/*           B    */
2176
	{ SST(0x38, 0x00, SS_RDEF,	/* XXX TBD */
2177
	    "Event status notification") },
2178
	/*           B    */
2179
	{ SST(0x38, 0x02, SS_RDEF,	/* XXX TBD */
2180
	    "ESN - power management class event") },
2181
	/*           B    */
2182
	{ SST(0x38, 0x04, SS_RDEF,	/* XXX TBD */
2183
	    "ESN - media class event") },
2184
	/*           B    */
2185
	{ SST(0x38, 0x06, SS_RDEF,	/* XXX TBD */
2186
	    "ESN - device busy class event") },
2187
	/* D              */
2188
	{ SST(0x38, 0x07, SS_RDEF,	/* XXX TBD */
2189
	    "Thin provisioning soft threshold reached") },
2190
	/* D              */
2191
	{ SST(0x38, 0x08, SS_NOP | SSQ_PRINT_SENSE,
2192
	    "Depopulation interrupted") },
2193
	/* DTL WROMAE K   */
2194
	{ SST(0x39, 0x00, SS_RDEF,
2195
	    "Saving parameters not supported") },
2196
	/* DTL WROM  BK   */
2197
	{ SST(0x3A, 0x00, SS_FATAL | ENXIO,
2198
	    "Medium not present") },
2199
	/* DT  WROM  BK   */
2200
	{ SST(0x3A, 0x01, SS_FATAL | ENXIO,
2201
	    "Medium not present - tray closed") },
2202
	/* DT  WROM  BK   */
2203
	{ SST(0x3A, 0x02, SS_FATAL | ENXIO,
2204
	    "Medium not present - tray open") },
2205
	/* DT  WROM  B    */
2206
	{ SST(0x3A, 0x03, SS_RDEF,	/* XXX TBD */
2207
	    "Medium not present - loadable") },
2208
	/* DT  WRO   B    */
2209
	{ SST(0x3A, 0x04, SS_RDEF,	/* XXX TBD */
2210
	    "Medium not present - medium auxiliary memory accessible") },
2211
	/*  TL            */
2212
	{ SST(0x3B, 0x00, SS_RDEF,
2213
	    "Sequential positioning error") },
2214
	/*  T             */
2215
	{ SST(0x3B, 0x01, SS_RDEF,
2216
	    "Tape position error at beginning-of-medium") },
2217
	/*  T             */
2218
	{ SST(0x3B, 0x02, SS_RDEF,
2219
	    "Tape position error at end-of-medium") },
2220
	/*   L            */
2221
	{ SST(0x3B, 0x03, SS_RDEF,
2222
	    "Tape or electronic vertical forms unit not ready") },
2223
	/*   L            */
2224
	{ SST(0x3B, 0x04, SS_RDEF,
2225
	    "Slew failure") },
2226
	/*   L            */
2227
	{ SST(0x3B, 0x05, SS_RDEF,
2228
	    "Paper jam") },
2229
	/*   L            */
2230
	{ SST(0x3B, 0x06, SS_RDEF,
2231
	    "Failed to sense top-of-form") },
2232
	/*   L            */
2233
	{ SST(0x3B, 0x07, SS_RDEF,
2234
	    "Failed to sense bottom-of-form") },
2235
	/*  T             */
2236
	{ SST(0x3B, 0x08, SS_RDEF,
2237
	    "Reposition error") },
2238
	/*                */
2239
	{ SST(0x3B, 0x09, SS_RDEF,
2240
	    "Read past end of medium") },
2241
	/*                */
2242
	{ SST(0x3B, 0x0A, SS_RDEF,
2243
	    "Read past beginning of medium") },
2244
	/*                */
2245
	{ SST(0x3B, 0x0B, SS_RDEF,
2246
	    "Position past end of medium") },
2247
	/*  T             */
2248
	{ SST(0x3B, 0x0C, SS_RDEF,
2249
	    "Position past beginning of medium") },
2250
	/* DT  WROM  BK   */
2251
	{ SST(0x3B, 0x0D, SS_FATAL | ENOSPC,
2252
	    "Medium destination element full") },
2253
	/* DT  WROM  BK   */
2254
	{ SST(0x3B, 0x0E, SS_RDEF,
2255
	    "Medium source element empty") },
2256
	/*      R         */
2257
	{ SST(0x3B, 0x0F, SS_RDEF,
2258
	    "End of medium reached") },
2259
	/* DT  WROM  BK   */
2260
	{ SST(0x3B, 0x11, SS_RDEF,
2261
	    "Medium magazine not accessible") },
2262
	/* DT  WROM  BK   */
2263
	{ SST(0x3B, 0x12, SS_RDEF,
2264
	    "Medium magazine removed") },
2265
	/* DT  WROM  BK   */
2266
	{ SST(0x3B, 0x13, SS_RDEF,
2267
	    "Medium magazine inserted") },
2268
	/* DT  WROM  BK   */
2269
	{ SST(0x3B, 0x14, SS_RDEF,
2270
	    "Medium magazine locked") },
2271
	/* DT  WROM  BK   */
2272
	{ SST(0x3B, 0x15, SS_RDEF,
2273
	    "Medium magazine unlocked") },
2274
	/*      R         */
2275
	{ SST(0x3B, 0x16, SS_RDEF,	/* XXX TBD */
2276
	    "Mechanical positioning or changer error") },
2277
	/*              F */
2278
	{ SST(0x3B, 0x17, SS_RDEF,	/* XXX TBD */
2279
	    "Read past end of user object") },
2280
	/*        M       */
2281
	{ SST(0x3B, 0x18, SS_RDEF,	/* XXX TBD */
2282
	    "Element disabled") },
2283
	/*        M       */
2284
	{ SST(0x3B, 0x19, SS_RDEF,	/* XXX TBD */
2285
	    "Element enabled") },
2286
	/*        M       */
2287
	{ SST(0x3B, 0x1A, SS_RDEF,	/* XXX TBD */
2288
	    "Data transfer device removed") },
2289
	/*        M       */
2290
	{ SST(0x3B, 0x1B, SS_RDEF,	/* XXX TBD */
2291
	    "Data transfer device inserted") },
2292
	/*  T             */
2293
	{ SST(0x3B, 0x1C, SS_RDEF,	/* XXX TBD */
2294
	    "Too many logical objects on partition to support operation") },
2295
	/*        M       */
2296
	{ SST(0x3B, 0x20, SS_RDEF,	/* XXX TBD */
2297
	    "Element static information changed") },
2298
	/* DTLPWROMAE K   */
2299
	{ SST(0x3D, 0x00, SS_RDEF,
2300
	    "Invalid bits in IDENTIFY message") },
2301
	/* DTLPWROMAEBKVF */
2302
	{ SST(0x3E, 0x00, SS_RDEF,
2303
	    "Logical unit has not self-configured yet") },
2304
	/* DTLPWROMAEBKVF */
2305
	{ SST(0x3E, 0x01, SS_RDEF,
2306
	    "Logical unit failure") },
2307
	/* DTLPWROMAEBKVF */
2308
	{ SST(0x3E, 0x02, SS_RDEF,
2309
	    "Timeout on logical unit") },
2310
	/* DTLPWROMAEBKVF */
2311
	{ SST(0x3E, 0x03, SS_FATAL | ENXIO,
2312
	    "Logical unit failed self-test") },
2313
	/* DTLPWROMAEBKVF */
2314
	{ SST(0x3E, 0x04, SS_RDEF,	/* XXX TBD */
2315
	    "Logical unit unable to update self-test log") },
2316
	/* DTLPWROMAEBKVF */
2317
	{ SST(0x3F, 0x00, SS_RDEF,
2318
	    "Target operating conditions have changed") },
2319
	/* DTLPWROMAEBKVF */
2320
	{ SST(0x3F, 0x01, SS_RDEF,
2321
	    "Microcode has been changed") },
2322
	/* DTLPWROM  BK   */
2323
	{ SST(0x3F, 0x02, SS_RDEF,
2324
	    "Changed operating definition") },
2325
	/* DTLPWROMAEBKVF */
2326
	{ SST(0x3F, 0x03, SS_RDEF,
2327
	    "INQUIRY data has changed") },
2328
	/* DT  WROMAEBK   */
2329
	{ SST(0x3F, 0x04, SS_RDEF,
2330
	    "Component device attached") },
2331
	/* DT  WROMAEBK   */
2332
	{ SST(0x3F, 0x05, SS_RDEF,
2333
	    "Device identifier changed") },
2334
	/* DT  WROMAEB    */
2335
	{ SST(0x3F, 0x06, SS_RDEF,
2336
	    "Redundancy group created or modified") },
2337
	/* DT  WROMAEB    */
2338
	{ SST(0x3F, 0x07, SS_RDEF,
2339
	    "Redundancy group deleted") },
2340
	/* DT  WROMAEB    */
2341
	{ SST(0x3F, 0x08, SS_RDEF,
2342
	    "Spare created or modified") },
2343
	/* DT  WROMAEB    */
2344
	{ SST(0x3F, 0x09, SS_RDEF,
2345
	    "Spare deleted") },
2346
	/* DT  WROMAEBK   */
2347
	{ SST(0x3F, 0x0A, SS_RDEF,
2348
	    "Volume set created or modified") },
2349
	/* DT  WROMAEBK   */
2350
	{ SST(0x3F, 0x0B, SS_RDEF,
2351
	    "Volume set deleted") },
2352
	/* DT  WROMAEBK   */
2353
	{ SST(0x3F, 0x0C, SS_RDEF,
2354
	    "Volume set deassigned") },
2355
	/* DT  WROMAEBK   */
2356
	{ SST(0x3F, 0x0D, SS_RDEF,
2357
	    "Volume set reassigned") },
2358
	/* DTLPWROMAE     */
2359
	{ SST(0x3F, 0x0E, SS_RDEF | SSQ_RESCAN ,
2360
	    "Reported LUNs data has changed") },
2361
	/* DTLPWROMAEBKVF */
2362
	{ SST(0x3F, 0x0F, SS_RDEF,	/* XXX TBD */
2363
	    "Echo buffer overwritten") },
2364
	/* DT  WROM  B    */
2365
	{ SST(0x3F, 0x10, SS_RDEF,	/* XXX TBD */
2366
	    "Medium loadable") },
2367
	/* DT  WROM  B    */
2368
	{ SST(0x3F, 0x11, SS_RDEF,	/* XXX TBD */
2369
	    "Medium auxiliary memory accessible") },
2370
	/* DTLPWR MAEBK F */
2371
	{ SST(0x3F, 0x12, SS_RDEF,	/* XXX TBD */
2372
	    "iSCSI IP address added") },
2373
	/* DTLPWR MAEBK F */
2374
	{ SST(0x3F, 0x13, SS_RDEF,	/* XXX TBD */
2375
	    "iSCSI IP address removed") },
2376
	/* DTLPWR MAEBK F */
2377
	{ SST(0x3F, 0x14, SS_RDEF,	/* XXX TBD */
2378
	    "iSCSI IP address changed") },
2379
	/* DTLPWR MAEBK   */
2380
	{ SST(0x3F, 0x15, SS_RDEF,	/* XXX TBD */
2381
	    "Inspect referrals sense descriptors") },
2382
	/* DTLPWROMAEBKVF */
2383
	{ SST(0x3F, 0x16, SS_RDEF,	/* XXX TBD */
2384
	    "Microcode has been changed without reset") },
2385
	/* D              */
2386
	{ SST(0x3F, 0x17, SS_RDEF,	/* XXX TBD */
2387
	    "Zone transition to full") },
2388
	/* D              */
2389
	{ SST(0x3F, 0x18, SS_RDEF,	/* XXX TBD */
2390
	    "Bind completed") },
2391
	/* D              */
2392
	{ SST(0x3F, 0x19, SS_RDEF,	/* XXX TBD */
2393
	    "Bind redirected") },
2394
	/* D              */
2395
	{ SST(0x3F, 0x1A, SS_RDEF,	/* XXX TBD */
2396
	    "Subsidiary binding changed") },
2397
	{ SST(0x40, 0x00, SS_FATAL | ENXIO,
2398
	    "RAM failure") },		/* deprecated - use 40 NN instead */
2399
	/* DTLPWROMAEBKVF */
2400
	{ SST(0x40, 0x80, SS_FATAL | ENXIO,
2401
	    "Diagnostic failure: ASCQ = Component ID") },
2402
	/* DTLPWROMAEBKVF */
2403
	{ SST(0x40, 0xFF, SS_RDEF | SSQ_RANGE,
2404
	    NULL) },			/* Range 0x80->0xFF */
2405
	/* D              */
2406
	{ SST(0x41, 0x00, SS_RDEF,
2407
	    "Data path failure") },	/* deprecated - use 40 NN instead */
2408
	/* D              */
2409
	{ SST(0x42, 0x00, SS_RDEF,
2410
	    "Power-on or self-test failure") },
2411
					/* deprecated - use 40 NN instead */
2412
	/* DTLPWROMAEBKVF */
2413
	{ SST(0x43, 0x00, SS_RDEF,
2414
	    "Message error") },
2415
	/* DTLPWROMAEBKVF */
2416
	{ SST(0x44, 0x00, SS_FATAL | ENXIO,
2417
	    "Internal target failure") },
2418
	/* DT P   MAEBKVF */
2419
	{ SST(0x44, 0x01, SS_RDEF,	/* XXX TBD */
2420
	    "Persistent reservation information lost") },
2421
	/* DT        B    */
2422
	{ SST(0x44, 0x71, SS_RDEF,	/* XXX TBD */
2423
	    "ATA device failed set features") },
2424
	/* DTLPWROMAEBKVF */
2425
	{ SST(0x45, 0x00, SS_RDEF,
2426
	    "Select or reselect failure") },
2427
	/* DTLPWROM  BK   */
2428
	{ SST(0x46, 0x00, SS_RDEF,
2429
	    "Unsuccessful soft reset") },
2430
	/* DTLPWROMAEBKVF */
2431
	{ SST(0x47, 0x00, SS_RDEF,
2432
	    "SCSI parity error") },
2433
	/* DTLPWROMAEBKVF */
2434
	{ SST(0x47, 0x01, SS_RDEF,	/* XXX TBD */
2435
	    "Data phase CRC error detected") },
2436
	/* DTLPWROMAEBKVF */
2437
	{ SST(0x47, 0x02, SS_RDEF,	/* XXX TBD */
2438
	    "SCSI parity error detected during ST data phase") },
2439
	/* DTLPWROMAEBKVF */
2440
	{ SST(0x47, 0x03, SS_RDEF,	/* XXX TBD */
2441
	    "Information unit iuCRC error detected") },
2442
	/* DTLPWROMAEBKVF */
2443
	{ SST(0x47, 0x04, SS_RDEF,	/* XXX TBD */
2444
	    "Asynchronous information protection error detected") },
2445
	/* DTLPWROMAEBKVF */
2446
	{ SST(0x47, 0x05, SS_RDEF,	/* XXX TBD */
2447
	    "Protocol service CRC error") },
2448
	/* DT     MAEBKVF */
2449
	{ SST(0x47, 0x06, SS_RDEF,	/* XXX TBD */
2450
	    "PHY test function in progress") },
2451
	/* DT PWROMAEBK   */
2452
	{ SST(0x47, 0x7F, SS_RDEF,	/* XXX TBD */
2453
	    "Some commands cleared by iSCSI protocol event") },
2454
	/* DTLPWROMAEBKVF */
2455
	{ SST(0x48, 0x00, SS_RDEF,
2456
	    "Initiator detected error message received") },
2457
	/* DTLPWROMAEBKVF */
2458
	{ SST(0x49, 0x00, SS_RDEF,
2459
	    "Invalid message error") },
2460
	/* DTLPWROMAEBKVF */
2461
	{ SST(0x4A, 0x00, SS_RDEF,
2462
	    "Command phase error") },
2463
	/* DTLPWROMAEBKVF */
2464
	{ SST(0x4B, 0x00, SS_RDEF,
2465
	    "Data phase error") },
2466
	/* DT PWROMAEBK   */
2467
	{ SST(0x4B, 0x01, SS_RDEF,	/* XXX TBD */
2468
	    "Invalid target port transfer tag received") },
2469
	/* DT PWROMAEBK   */
2470
	{ SST(0x4B, 0x02, SS_RDEF,	/* XXX TBD */
2471
	    "Too much write data") },
2472
	/* DT PWROMAEBK   */
2473
	{ SST(0x4B, 0x03, SS_RDEF,	/* XXX TBD */
2474
	    "ACK/NAK timeout") },
2475
	/* DT PWROMAEBK   */
2476
	{ SST(0x4B, 0x04, SS_RDEF,	/* XXX TBD */
2477
	    "NAK received") },
2478
	/* DT PWROMAEBK   */
2479
	{ SST(0x4B, 0x05, SS_RDEF,	/* XXX TBD */
2480
	    "Data offset error") },
2481
	/* DT PWROMAEBK   */
2482
	{ SST(0x4B, 0x06, SS_RDEF,	/* XXX TBD */
2483
	    "Initiator response timeout") },
2484
	/* DT PWROMAEBK F */
2485
	{ SST(0x4B, 0x07, SS_RDEF,	/* XXX TBD */
2486
	    "Connection lost") },
2487
	/* DT PWROMAEBK F */
2488
	{ SST(0x4B, 0x08, SS_RDEF,	/* XXX TBD */
2489
	    "Data-in buffer overflow - data buffer size") },
2490
	/* DT PWROMAEBK F */
2491
	{ SST(0x4B, 0x09, SS_RDEF,	/* XXX TBD */
2492
	    "Data-in buffer overflow - data buffer descriptor area") },
2493
	/* DT PWROMAEBK F */
2494
	{ SST(0x4B, 0x0A, SS_RDEF,	/* XXX TBD */
2495
	    "Data-in buffer error") },
2496
	/* DT PWROMAEBK F */
2497
	{ SST(0x4B, 0x0B, SS_RDEF,	/* XXX TBD */
2498
	    "Data-out buffer overflow - data buffer size") },
2499
	/* DT PWROMAEBK F */
2500
	{ SST(0x4B, 0x0C, SS_RDEF,	/* XXX TBD */
2501
	    "Data-out buffer overflow - data buffer descriptor area") },
2502
	/* DT PWROMAEBK F */
2503
	{ SST(0x4B, 0x0D, SS_RDEF,	/* XXX TBD */
2504
	    "Data-out buffer error") },
2505
	/* DT PWROMAEBK F */
2506
	{ SST(0x4B, 0x0E, SS_RDEF,	/* XXX TBD */
2507
	    "PCIe fabric error") },
2508
	/* DT PWROMAEBK F */
2509
	{ SST(0x4B, 0x0F, SS_RDEF,	/* XXX TBD */
2510
	    "PCIe completion timeout") },
2511
	/* DT PWROMAEBK F */
2512
	{ SST(0x4B, 0x10, SS_RDEF,	/* XXX TBD */
2513
	    "PCIe completer abort") },
2514
	/* DT PWROMAEBK F */
2515
	{ SST(0x4B, 0x11, SS_RDEF,	/* XXX TBD */
2516
	    "PCIe poisoned TLP received") },
2517
	/* DT PWROMAEBK F */
2518
	{ SST(0x4B, 0x12, SS_RDEF,	/* XXX TBD */
2519
	    "PCIe ECRC check failed") },
2520
	/* DT PWROMAEBK F */
2521
	{ SST(0x4B, 0x13, SS_RDEF,	/* XXX TBD */
2522
	    "PCIe unsupported request") },
2523
	/* DT PWROMAEBK F */
2524
	{ SST(0x4B, 0x14, SS_RDEF,	/* XXX TBD */
2525
	    "PCIe ACS violation") },
2526
	/* DT PWROMAEBK F */
2527
	{ SST(0x4B, 0x15, SS_RDEF,	/* XXX TBD */
2528
	    "PCIe TLP prefix blocket") },
2529
	/* DTLPWROMAEBKVF */
2530
	{ SST(0x4C, 0x00, SS_RDEF,
2531
	    "Logical unit failed self-configuration") },
2532
	/* DTLPWROMAEBKVF */
2533
	{ SST(0x4D, 0x00, SS_RDEF,
2534
	    "Tagged overlapped commands: ASCQ = Queue tag ID") },
2535
	/* DTLPWROMAEBKVF */
2536
	{ SST(0x4D, 0xFF, SS_RDEF | SSQ_RANGE,
2537
	    NULL) },			/* Range 0x00->0xFF */
2538
	/* DTLPWROMAEBKVF */
2539
	{ SST(0x4E, 0x00, SS_RDEF,
2540
	    "Overlapped commands attempted") },
2541
	/*  T             */
2542
	{ SST(0x50, 0x00, SS_RDEF,
2543
	    "Write append error") },
2544
	/*  T             */
2545
	{ SST(0x50, 0x01, SS_RDEF,
2546
	    "Write append position error") },
2547
	/*  T             */
2548
	{ SST(0x50, 0x02, SS_RDEF,
2549
	    "Position error related to timing") },
2550
	/*  T   RO        */
2551
	{ SST(0x51, 0x00, SS_RDEF,
2552
	    "Erase failure") },
2553
	/*      R         */
2554
	{ SST(0x51, 0x01, SS_RDEF,	/* XXX TBD */
2555
	    "Erase failure - incomplete erase operation detected") },
2556
	/*  T             */
2557
	{ SST(0x52, 0x00, SS_RDEF,
2558
	    "Cartridge fault") },
2559
	/* DTL WROM  BK   */
2560
	{ SST(0x53, 0x00, SS_RDEF,
2561
	    "Media load or eject failed") },
2562
	/*  T             */
2563
	{ SST(0x53, 0x01, SS_RDEF,
2564
	    "Unload tape failure") },
2565
	/* DT  WROM  BK   */
2566
	{ SST(0x53, 0x02, SS_RDEF,
2567
	    "Medium removal prevented") },
2568
	/*        M       */
2569
	{ SST(0x53, 0x03, SS_RDEF,	/* XXX TBD */
2570
	    "Medium removal prevented by data transfer element") },
2571
	/*  T             */
2572
	{ SST(0x53, 0x04, SS_RDEF,	/* XXX TBD */
2573
	    "Medium thread or unthread failure") },
2574
	/*        M       */
2575
	{ SST(0x53, 0x05, SS_RDEF,	/* XXX TBD */
2576
	    "Volume identifier invalid") },
2577
	/*  T             */
2578
	{ SST(0x53, 0x06, SS_RDEF,	/* XXX TBD */
2579
	    "Volume identifier missing") },
2580
	/*        M       */
2581
	{ SST(0x53, 0x07, SS_RDEF,	/* XXX TBD */
2582
	    "Duplicate volume identifier") },
2583
	/*        M       */
2584
	{ SST(0x53, 0x08, SS_RDEF,	/* XXX TBD */
2585
	    "Element status unknown") },
2586
	/*        M       */
2587
	{ SST(0x53, 0x09, SS_RDEF,	/* XXX TBD */
2588
	    "Data transfer device error - load failed") },
2589
	/*        M       */
2590
	{ SST(0x53, 0x0A, SS_RDEF,	/* XXX TBD */
2591
	    "Data transfer device error - unload failed") },
2592
	/*        M       */
2593
	{ SST(0x53, 0x0B, SS_RDEF,	/* XXX TBD */
2594
	    "Data transfer device error - unload missing") },
2595
	/*        M       */
2596
	{ SST(0x53, 0x0C, SS_RDEF,	/* XXX TBD */
2597
	    "Data transfer device error - eject failed") },
2598
	/*        M       */
2599
	{ SST(0x53, 0x0D, SS_RDEF,	/* XXX TBD */
2600
	    "Data transfer device error - library communication failed") },
2601
	/*    P           */
2602
	{ SST(0x54, 0x00, SS_RDEF,
2603
	    "SCSI to host system interface failure") },
2604
	/*    P           */
2605
	{ SST(0x55, 0x00, SS_RDEF,
2606
	    "System resource failure") },
2607
	/* D     O   BK   */
2608
	{ SST(0x55, 0x01, SS_FATAL | ENOSPC,
2609
	    "System buffer full") },
2610
	/* DTLPWROMAE K   */
2611
	{ SST(0x55, 0x02, SS_RDEF,	/* XXX TBD */
2612
	    "Insufficient reservation resources") },
2613
	/* DTLPWROMAE K   */
2614
	{ SST(0x55, 0x03, SS_RDEF,	/* XXX TBD */
2615
	    "Insufficient resources") },
2616
	/* DTLPWROMAE K   */
2617
	{ SST(0x55, 0x04, SS_RDEF,	/* XXX TBD */
2618
	    "Insufficient registration resources") },
2619
	/* DT PWROMAEBK   */
2620
	{ SST(0x55, 0x05, SS_RDEF,	/* XXX TBD */
2621
	    "Insufficient access control resources") },
2622
	/* DT  WROM  B    */
2623
	{ SST(0x55, 0x06, SS_RDEF,	/* XXX TBD */
2624
	    "Auxiliary memory out of space") },
2625
	/*              F */
2626
	{ SST(0x55, 0x07, SS_RDEF,	/* XXX TBD */
2627
	    "Quota error") },
2628
	/*  T             */
2629
	{ SST(0x55, 0x08, SS_RDEF,	/* XXX TBD */
2630
	    "Maximum number of supplemental decryption keys exceeded") },
2631
	/*        M       */
2632
	{ SST(0x55, 0x09, SS_RDEF,	/* XXX TBD */
2633
	    "Medium auxiliary memory not accessible") },
2634
	/*        M       */
2635
	{ SST(0x55, 0x0A, SS_RDEF,	/* XXX TBD */
2636
	    "Data currently unavailable") },
2637
	/* DTLPWROMAEBKVF */
2638
	{ SST(0x55, 0x0B, SS_RDEF,	/* XXX TBD */
2639
	    "Insufficient power for operation") },
2640
	/* DT P      B    */
2641
	{ SST(0x55, 0x0C, SS_RDEF,	/* XXX TBD */
2642
	    "Insufficient resources to create ROD") },
2643
	/* DT P      B    */
2644
	{ SST(0x55, 0x0D, SS_RDEF,	/* XXX TBD */
2645
	    "Insufficient resources to create ROD token") },
2646
	/* D              */
2647
	{ SST(0x55, 0x0E, SS_RDEF,	/* XXX TBD */
2648
	    "Insufficient zone resources") },
2649
	/* D              */
2650
	{ SST(0x55, 0x0F, SS_RDEF,	/* XXX TBD */
2651
	    "Insufficient zone resources to complete write") },
2652
	/* D              */
2653
	{ SST(0x55, 0x10, SS_RDEF,	/* XXX TBD */
2654
	    "Maximum number of streams open") },
2655
	/* D              */
2656
	{ SST(0x55, 0x11, SS_RDEF,	/* XXX TBD */
2657
	    "Insufficient resources to bind") },
2658
	/*      R         */
2659
	{ SST(0x57, 0x00, SS_RDEF,
2660
	    "Unable to recover table-of-contents") },
2661
	/*       O        */
2662
	{ SST(0x58, 0x00, SS_RDEF,
2663
	    "Generation does not exist") },
2664
	/*       O        */
2665
	{ SST(0x59, 0x00, SS_RDEF,
2666
	    "Updated block read") },
2667
	/* DTLPWRO   BK   */
2668
	{ SST(0x5A, 0x00, SS_RDEF,
2669
	    "Operator request or state change input") },
2670
	/* DT  WROM  BK   */
2671
	{ SST(0x5A, 0x01, SS_RDEF,
2672
	    "Operator medium removal request") },
2673
	/* DT  WRO A BK   */
2674
	{ SST(0x5A, 0x02, SS_RDEF,
2675
	    "Operator selected write protect") },
2676
	/* DT  WRO A BK   */
2677
	{ SST(0x5A, 0x03, SS_RDEF,
2678
	    "Operator selected write permit") },
2679
	/* DTLPWROM   K   */
2680
	{ SST(0x5B, 0x00, SS_RDEF,
2681
	    "Log exception") },
2682
	/* DTLPWROM   K   */
2683
	{ SST(0x5B, 0x01, SS_RDEF,
2684
	    "Threshold condition met") },
2685
	/* DTLPWROM   K   */
2686
	{ SST(0x5B, 0x02, SS_RDEF,
2687
	    "Log counter at maximum") },
2688
	/* DTLPWROM   K   */
2689
	{ SST(0x5B, 0x03, SS_RDEF,
2690
	    "Log list codes exhausted") },
2691
	/* D     O        */
2692
	{ SST(0x5C, 0x00, SS_RDEF,
2693
	    "RPL status change") },
2694
	/* D     O        */
2695
	{ SST(0x5C, 0x01, SS_NOP | SSQ_PRINT_SENSE,
2696
	    "Spindles synchronized") },
2697
	/* D     O        */
2698
	{ SST(0x5C, 0x02, SS_RDEF,
2699
	    "Spindles not synchronized") },
2700
	/* DTLPWROMAEBKVF */
2701
	{ SST(0x5D, 0x00, SS_NOP | SSQ_PRINT_SENSE,
2702
	    "Failure prediction threshold exceeded") },
2703
	/*      R    B    */
2704
	{ SST(0x5D, 0x01, SS_NOP | SSQ_PRINT_SENSE,
2705
	    "Media failure prediction threshold exceeded") },
2706
	/*      R         */
2707
	{ SST(0x5D, 0x02, SS_NOP | SSQ_PRINT_SENSE,
2708
	    "Logical unit failure prediction threshold exceeded") },
2709
	/*      R         */
2710
	{ SST(0x5D, 0x03, SS_NOP | SSQ_PRINT_SENSE,
2711
	    "Spare area exhaustion prediction threshold exceeded") },
2712
	/* D         B    */
2713
	{ SST(0x5D, 0x10, SS_NOP | SSQ_PRINT_SENSE,
2714
	    "Hardware impending failure general hard drive failure") },
2715
	/* D         B    */
2716
	{ SST(0x5D, 0x11, SS_NOP | SSQ_PRINT_SENSE,
2717
	    "Hardware impending failure drive error rate too high") },
2718
	/* D         B    */
2719
	{ SST(0x5D, 0x12, SS_NOP | SSQ_PRINT_SENSE,
2720
	    "Hardware impending failure data error rate too high") },
2721
	/* D         B    */
2722
	{ SST(0x5D, 0x13, SS_NOP | SSQ_PRINT_SENSE,
2723
	    "Hardware impending failure seek error rate too high") },
2724
	/* D         B    */
2725
	{ SST(0x5D, 0x14, SS_NOP | SSQ_PRINT_SENSE,
2726
	    "Hardware impending failure too many block reassigns") },
2727
	/* D         B    */
2728
	{ SST(0x5D, 0x15, SS_NOP | SSQ_PRINT_SENSE,
2729
	    "Hardware impending failure access times too high") },
2730
	/* D         B    */
2731
	{ SST(0x5D, 0x16, SS_NOP | SSQ_PRINT_SENSE,
2732
	    "Hardware impending failure start unit times too high") },
2733
	/* D         B    */
2734
	{ SST(0x5D, 0x17, SS_NOP | SSQ_PRINT_SENSE,
2735
	    "Hardware impending failure channel parametrics") },
2736
	/* D         B    */
2737
	{ SST(0x5D, 0x18, SS_NOP | SSQ_PRINT_SENSE,
2738
	    "Hardware impending failure controller detected") },
2739
	/* D         B    */
2740
	{ SST(0x5D, 0x19, SS_NOP | SSQ_PRINT_SENSE,
2741
	    "Hardware impending failure throughput performance") },
2742
	/* D         B    */
2743
	{ SST(0x5D, 0x1A, SS_NOP | SSQ_PRINT_SENSE,
2744
	    "Hardware impending failure seek time performance") },
2745
	/* D         B    */
2746
	{ SST(0x5D, 0x1B, SS_NOP | SSQ_PRINT_SENSE,
2747
	    "Hardware impending failure spin-up retry count") },
2748
	/* D         B    */
2749
	{ SST(0x5D, 0x1C, SS_NOP | SSQ_PRINT_SENSE,
2750
	    "Hardware impending failure drive calibration retry count") },
2751
	/* D         B    */
2752
	{ SST(0x5D, 0x1D, SS_NOP | SSQ_PRINT_SENSE,
2753
	    "Hardware impending failure power loss protection circuit") },
2754
	/* D         B    */
2755
	{ SST(0x5D, 0x20, SS_NOP | SSQ_PRINT_SENSE,
2756
	    "Controller impending failure general hard drive failure") },
2757
	/* D         B    */
2758
	{ SST(0x5D, 0x21, SS_NOP | SSQ_PRINT_SENSE,
2759
	    "Controller impending failure drive error rate too high") },
2760
	/* D         B    */
2761
	{ SST(0x5D, 0x22, SS_NOP | SSQ_PRINT_SENSE,
2762
	    "Controller impending failure data error rate too high") },
2763
	/* D         B    */
2764
	{ SST(0x5D, 0x23, SS_NOP | SSQ_PRINT_SENSE,
2765
	    "Controller impending failure seek error rate too high") },
2766
	/* D         B    */
2767
	{ SST(0x5D, 0x24, SS_NOP | SSQ_PRINT_SENSE,
2768
	    "Controller impending failure too many block reassigns") },
2769
	/* D         B    */
2770
	{ SST(0x5D, 0x25, SS_NOP | SSQ_PRINT_SENSE,
2771
	    "Controller impending failure access times too high") },
2772
	/* D         B    */
2773
	{ SST(0x5D, 0x26, SS_NOP | SSQ_PRINT_SENSE,
2774
	    "Controller impending failure start unit times too high") },
2775
	/* D         B    */
2776
	{ SST(0x5D, 0x27, SS_NOP | SSQ_PRINT_SENSE,
2777
	    "Controller impending failure channel parametrics") },
2778
	/* D         B    */
2779
	{ SST(0x5D, 0x28, SS_NOP | SSQ_PRINT_SENSE,
2780
	    "Controller impending failure controller detected") },
2781
	/* D         B    */
2782
	{ SST(0x5D, 0x29, SS_NOP | SSQ_PRINT_SENSE,
2783
	    "Controller impending failure throughput performance") },
2784
	/* D         B    */
2785
	{ SST(0x5D, 0x2A, SS_NOP | SSQ_PRINT_SENSE,
2786
	    "Controller impending failure seek time performance") },
2787
	/* D         B    */
2788
	{ SST(0x5D, 0x2B, SS_NOP | SSQ_PRINT_SENSE,
2789
	    "Controller impending failure spin-up retry count") },
2790
	/* D         B    */
2791
	{ SST(0x5D, 0x2C, SS_NOP | SSQ_PRINT_SENSE,
2792
	    "Controller impending failure drive calibration retry count") },
2793
	/* D         B    */
2794
	{ SST(0x5D, 0x30, SS_NOP | SSQ_PRINT_SENSE,
2795
	    "Data channel impending failure general hard drive failure") },
2796
	/* D         B    */
2797
	{ SST(0x5D, 0x31, SS_NOP | SSQ_PRINT_SENSE,
2798
	    "Data channel impending failure drive error rate too high") },
2799
	/* D         B    */
2800
	{ SST(0x5D, 0x32, SS_NOP | SSQ_PRINT_SENSE,
2801
	    "Data channel impending failure data error rate too high") },
2802
	/* D         B    */
2803
	{ SST(0x5D, 0x33, SS_NOP | SSQ_PRINT_SENSE,
2804
	    "Data channel impending failure seek error rate too high") },
2805
	/* D         B    */
2806
	{ SST(0x5D, 0x34, SS_NOP | SSQ_PRINT_SENSE,
2807
	    "Data channel impending failure too many block reassigns") },
2808
	/* D         B    */
2809
	{ SST(0x5D, 0x35, SS_NOP | SSQ_PRINT_SENSE,
2810
	    "Data channel impending failure access times too high") },
2811
	/* D         B    */
2812
	{ SST(0x5D, 0x36, SS_NOP | SSQ_PRINT_SENSE,
2813
	    "Data channel impending failure start unit times too high") },
2814
	/* D         B    */
2815
	{ SST(0x5D, 0x37, SS_NOP | SSQ_PRINT_SENSE,
2816
	    "Data channel impending failure channel parametrics") },
2817
	/* D         B    */
2818
	{ SST(0x5D, 0x38, SS_NOP | SSQ_PRINT_SENSE,
2819
	    "Data channel impending failure controller detected") },
2820
	/* D         B    */
2821
	{ SST(0x5D, 0x39, SS_NOP | SSQ_PRINT_SENSE,
2822
	    "Data channel impending failure throughput performance") },
2823
	/* D         B    */
2824
	{ SST(0x5D, 0x3A, SS_NOP | SSQ_PRINT_SENSE,
2825
	    "Data channel impending failure seek time performance") },
2826
	/* D         B    */
2827
	{ SST(0x5D, 0x3B, SS_NOP | SSQ_PRINT_SENSE,
2828
	    "Data channel impending failure spin-up retry count") },
2829
	/* D         B    */
2830
	{ SST(0x5D, 0x3C, SS_NOP | SSQ_PRINT_SENSE,
2831
	    "Data channel impending failure drive calibration retry count") },
2832
	/* D         B    */
2833
	{ SST(0x5D, 0x40, SS_NOP | SSQ_PRINT_SENSE,
2834
	    "Servo impending failure general hard drive failure") },
2835
	/* D         B    */
2836
	{ SST(0x5D, 0x41, SS_NOP | SSQ_PRINT_SENSE,
2837
	    "Servo impending failure drive error rate too high") },
2838
	/* D         B    */
2839
	{ SST(0x5D, 0x42, SS_NOP | SSQ_PRINT_SENSE,
2840
	    "Servo impending failure data error rate too high") },
2841
	/* D         B    */
2842
	{ SST(0x5D, 0x43, SS_NOP | SSQ_PRINT_SENSE,
2843
	    "Servo impending failure seek error rate too high") },
2844
	/* D         B    */
2845
	{ SST(0x5D, 0x44, SS_NOP | SSQ_PRINT_SENSE,
2846
	    "Servo impending failure too many block reassigns") },
2847
	/* D         B    */
2848
	{ SST(0x5D, 0x45, SS_NOP | SSQ_PRINT_SENSE,
2849
	    "Servo impending failure access times too high") },
2850
	/* D         B    */
2851
	{ SST(0x5D, 0x46, SS_NOP | SSQ_PRINT_SENSE,
2852
	    "Servo impending failure start unit times too high") },
2853
	/* D         B    */
2854
	{ SST(0x5D, 0x47, SS_NOP | SSQ_PRINT_SENSE,
2855
	    "Servo impending failure channel parametrics") },
2856
	/* D         B    */
2857
	{ SST(0x5D, 0x48, SS_NOP | SSQ_PRINT_SENSE,
2858
	    "Servo impending failure controller detected") },
2859
	/* D         B    */
2860
	{ SST(0x5D, 0x49, SS_NOP | SSQ_PRINT_SENSE,
2861
	    "Servo impending failure throughput performance") },
2862
	/* D         B    */
2863
	{ SST(0x5D, 0x4A, SS_NOP | SSQ_PRINT_SENSE,
2864
	    "Servo impending failure seek time performance") },
2865
	/* D         B    */
2866
	{ SST(0x5D, 0x4B, SS_NOP | SSQ_PRINT_SENSE,
2867
	    "Servo impending failure spin-up retry count") },
2868
	/* D         B    */
2869
	{ SST(0x5D, 0x4C, SS_NOP | SSQ_PRINT_SENSE,
2870
	    "Servo impending failure drive calibration retry count") },
2871
	/* D         B    */
2872
	{ SST(0x5D, 0x50, SS_NOP | SSQ_PRINT_SENSE,
2873
	    "Spindle impending failure general hard drive failure") },
2874
	/* D         B    */
2875
	{ SST(0x5D, 0x51, SS_NOP | SSQ_PRINT_SENSE,
2876
	    "Spindle impending failure drive error rate too high") },
2877
	/* D         B    */
2878
	{ SST(0x5D, 0x52, SS_NOP | SSQ_PRINT_SENSE,
2879
	    "Spindle impending failure data error rate too high") },
2880
	/* D         B    */
2881
	{ SST(0x5D, 0x53, SS_NOP | SSQ_PRINT_SENSE,
2882
	    "Spindle impending failure seek error rate too high") },
2883
	/* D         B    */
2884
	{ SST(0x5D, 0x54, SS_NOP | SSQ_PRINT_SENSE,
2885
	    "Spindle impending failure too many block reassigns") },
2886
	/* D         B    */
2887
	{ SST(0x5D, 0x55, SS_NOP | SSQ_PRINT_SENSE,
2888
	    "Spindle impending failure access times too high") },
2889
	/* D         B    */
2890
	{ SST(0x5D, 0x56, SS_NOP | SSQ_PRINT_SENSE,
2891
	    "Spindle impending failure start unit times too high") },
2892
	/* D         B    */
2893
	{ SST(0x5D, 0x57, SS_NOP | SSQ_PRINT_SENSE,
2894
	    "Spindle impending failure channel parametrics") },
2895
	/* D         B    */
2896
	{ SST(0x5D, 0x58, SS_NOP | SSQ_PRINT_SENSE,
2897
	    "Spindle impending failure controller detected") },
2898
	/* D         B    */
2899
	{ SST(0x5D, 0x59, SS_NOP | SSQ_PRINT_SENSE,
2900
	    "Spindle impending failure throughput performance") },
2901
	/* D         B    */
2902
	{ SST(0x5D, 0x5A, SS_NOP | SSQ_PRINT_SENSE,
2903
	    "Spindle impending failure seek time performance") },
2904
	/* D         B    */
2905
	{ SST(0x5D, 0x5B, SS_NOP | SSQ_PRINT_SENSE,
2906
	    "Spindle impending failure spin-up retry count") },
2907
	/* D         B    */
2908
	{ SST(0x5D, 0x5C, SS_NOP | SSQ_PRINT_SENSE,
2909
	    "Spindle impending failure drive calibration retry count") },
2910
	/* D         B    */
2911
	{ SST(0x5D, 0x60, SS_NOP | SSQ_PRINT_SENSE,
2912
	    "Firmware impending failure general hard drive failure") },
2913
	/* D         B    */
2914
	{ SST(0x5D, 0x61, SS_NOP | SSQ_PRINT_SENSE,
2915
	    "Firmware impending failure drive error rate too high") },
2916
	/* D         B    */
2917
	{ SST(0x5D, 0x62, SS_NOP | SSQ_PRINT_SENSE,
2918
	    "Firmware impending failure data error rate too high") },
2919
	/* D         B    */
2920
	{ SST(0x5D, 0x63, SS_NOP | SSQ_PRINT_SENSE,
2921
	    "Firmware impending failure seek error rate too high") },
2922
	/* D         B    */
2923
	{ SST(0x5D, 0x64, SS_NOP | SSQ_PRINT_SENSE,
2924
	    "Firmware impending failure too many block reassigns") },
2925
	/* D         B    */
2926
	{ SST(0x5D, 0x65, SS_NOP | SSQ_PRINT_SENSE,
2927
	    "Firmware impending failure access times too high") },
2928
	/* D         B    */
2929
	{ SST(0x5D, 0x66, SS_NOP | SSQ_PRINT_SENSE,
2930
	    "Firmware impending failure start unit times too high") },
2931
	/* D         B    */
2932
	{ SST(0x5D, 0x67, SS_NOP | SSQ_PRINT_SENSE,
2933
	    "Firmware impending failure channel parametrics") },
2934
	/* D         B    */
2935
	{ SST(0x5D, 0x68, SS_NOP | SSQ_PRINT_SENSE,
2936
	    "Firmware impending failure controller detected") },
2937
	/* D         B    */
2938
	{ SST(0x5D, 0x69, SS_NOP | SSQ_PRINT_SENSE,
2939
	    "Firmware impending failure throughput performance") },
2940
	/* D         B    */
2941
	{ SST(0x5D, 0x6A, SS_NOP | SSQ_PRINT_SENSE,
2942
	    "Firmware impending failure seek time performance") },
2943
	/* D         B    */
2944
	{ SST(0x5D, 0x6B, SS_NOP | SSQ_PRINT_SENSE,
2945
	    "Firmware impending failure spin-up retry count") },
2946
	/* D         B    */
2947
	{ SST(0x5D, 0x6C, SS_NOP | SSQ_PRINT_SENSE,
2948
	    "Firmware impending failure drive calibration retry count") },
2949
	/* D         B    */
2950
	{ SST(0x5D, 0x73, SS_NOP | SSQ_PRINT_SENSE,
2951
	    "Media impending failure endurance limit met") },
2952
	/* DTLPWROMAEBKVF */
2953
	{ SST(0x5D, 0xFF, SS_NOP | SSQ_PRINT_SENSE,
2954
	    "Failure prediction threshold exceeded (false)") },
2955
	/* DTLPWRO A  K   */
2956
	{ SST(0x5E, 0x00, SS_RDEF,
2957
	    "Low power condition on") },
2958
	/* DTLPWRO A  K   */
2959
	{ SST(0x5E, 0x01, SS_RDEF,
2960
	    "Idle condition activated by timer") },
2961
	/* DTLPWRO A  K   */
2962
	{ SST(0x5E, 0x02, SS_RDEF,
2963
	    "Standby condition activated by timer") },
2964
	/* DTLPWRO A  K   */
2965
	{ SST(0x5E, 0x03, SS_RDEF,
2966
	    "Idle condition activated by command") },
2967
	/* DTLPWRO A  K   */
2968
	{ SST(0x5E, 0x04, SS_RDEF,
2969
	    "Standby condition activated by command") },
2970
	/* DTLPWRO A  K   */
2971
	{ SST(0x5E, 0x05, SS_RDEF,
2972
	    "Idle-B condition activated by timer") },
2973
	/* DTLPWRO A  K   */
2974
	{ SST(0x5E, 0x06, SS_RDEF,
2975
	    "Idle-B condition activated by command") },
2976
	/* DTLPWRO A  K   */
2977
	{ SST(0x5E, 0x07, SS_RDEF,
2978
	    "Idle-C condition activated by timer") },
2979
	/* DTLPWRO A  K   */
2980
	{ SST(0x5E, 0x08, SS_RDEF,
2981
	    "Idle-C condition activated by command") },
2982
	/* DTLPWRO A  K   */
2983
	{ SST(0x5E, 0x09, SS_RDEF,
2984
	    "Standby-Y condition activated by timer") },
2985
	/* DTLPWRO A  K   */
2986
	{ SST(0x5E, 0x0A, SS_RDEF,
2987
	    "Standby-Y condition activated by command") },
2988
	/*           B    */
2989
	{ SST(0x5E, 0x41, SS_RDEF,	/* XXX TBD */
2990
	    "Power state change to active") },
2991
	/*           B    */
2992
	{ SST(0x5E, 0x42, SS_RDEF,	/* XXX TBD */
2993
	    "Power state change to idle") },
2994
	/*           B    */
2995
	{ SST(0x5E, 0x43, SS_RDEF,	/* XXX TBD */
2996
	    "Power state change to standby") },
2997
	/*           B    */
2998
	{ SST(0x5E, 0x45, SS_RDEF,	/* XXX TBD */
2999
	    "Power state change to sleep") },
3000
	/*           BK   */
3001
	{ SST(0x5E, 0x47, SS_RDEF,	/* XXX TBD */
3002
	    "Power state change to device control") },
3003
	/*                */
3004
	{ SST(0x60, 0x00, SS_RDEF,
3005
	    "Lamp failure") },
3006
	/*                */
3007
	{ SST(0x61, 0x00, SS_RDEF,
3008
	    "Video acquisition error") },
3009
	/*                */
3010
	{ SST(0x61, 0x01, SS_RDEF,
3011
	    "Unable to acquire video") },
3012
	/*                */
3013
	{ SST(0x61, 0x02, SS_RDEF,
3014
	    "Out of focus") },
3015
	/*                */
3016
	{ SST(0x62, 0x00, SS_RDEF,
3017
	    "Scan head positioning error") },
3018
	/*      R         */
3019
	{ SST(0x63, 0x00, SS_RDEF,
3020
	    "End of user area encountered on this track") },
3021
	/*      R         */
3022
	{ SST(0x63, 0x01, SS_FATAL | ENOSPC,
3023
	    "Packet does not fit in available space") },
3024
	/*      R         */
3025
	{ SST(0x64, 0x00, SS_FATAL | ENXIO,
3026
	    "Illegal mode for this track") },
3027
	/*      R         */
3028
	{ SST(0x64, 0x01, SS_RDEF,
3029
	    "Invalid packet size") },
3030
	/* DTLPWROMAEBKVF */
3031
	{ SST(0x65, 0x00, SS_RDEF,
3032
	    "Voltage fault") },
3033
	/*                */
3034
	{ SST(0x66, 0x00, SS_RDEF,
3035
	    "Automatic document feeder cover up") },
3036
	/*                */
3037
	{ SST(0x66, 0x01, SS_RDEF,
3038
	    "Automatic document feeder lift up") },
3039
	/*                */
3040
	{ SST(0x66, 0x02, SS_RDEF,
3041
	    "Document jam in automatic document feeder") },
3042
	/*                */
3043
	{ SST(0x66, 0x03, SS_RDEF,
3044
	    "Document miss feed automatic in document feeder") },
3045
	/*         A      */
3046
	{ SST(0x67, 0x00, SS_RDEF,
3047
	    "Configuration failure") },
3048
	/*         A      */
3049
	{ SST(0x67, 0x01, SS_RDEF,
3050
	    "Configuration of incapable logical units failed") },
3051
	/*         A      */
3052
	{ SST(0x67, 0x02, SS_RDEF,
3053
	    "Add logical unit failed") },
3054
	/*         A      */
3055
	{ SST(0x67, 0x03, SS_RDEF,
3056
	    "Modification of logical unit failed") },
3057
	/*         A      */
3058
	{ SST(0x67, 0x04, SS_RDEF,
3059
	    "Exchange of logical unit failed") },
3060
	/*         A      */
3061
	{ SST(0x67, 0x05, SS_RDEF,
3062
	    "Remove of logical unit failed") },
3063
	/*         A      */
3064
	{ SST(0x67, 0x06, SS_RDEF,
3065
	    "Attachment of logical unit failed") },
3066
	/*         A      */
3067
	{ SST(0x67, 0x07, SS_RDEF,
3068
	    "Creation of logical unit failed") },
3069
	/*         A      */
3070
	{ SST(0x67, 0x08, SS_RDEF,	/* XXX TBD */
3071
	    "Assign failure occurred") },
3072
	/*         A      */
3073
	{ SST(0x67, 0x09, SS_RDEF,	/* XXX TBD */
3074
	    "Multiply assigned logical unit") },
3075
	/* DTLPWROMAEBKVF */
3076
	{ SST(0x67, 0x0A, SS_RDEF,	/* XXX TBD */
3077
	    "Set target port groups command failed") },
3078
	/* DT        B    */
3079
	{ SST(0x67, 0x0B, SS_RDEF,	/* XXX TBD */
3080
	    "ATA device feature not enabled") },
3081
	/* D              */
3082
	{ SST(0x67, 0x0C, SS_FATAL | EIO,
3083
	    "Command rejected") },
3084
	/* D              */
3085
	{ SST(0x67, 0x0D, SS_FATAL | EINVAL,
3086
	    "Explicit bind not allowed") },
3087
	/*         A      */
3088
	{ SST(0x68, 0x00, SS_RDEF,
3089
	    "Logical unit not configured") },
3090
	/* D              */
3091
	{ SST(0x68, 0x01, SS_RDEF,
3092
	    "Subsidiary logical unit not configured") },
3093
	/*         A      */
3094
	{ SST(0x69, 0x00, SS_RDEF,
3095
	    "Data loss on logical unit") },
3096
	/*         A      */
3097
	{ SST(0x69, 0x01, SS_RDEF,
3098
	    "Multiple logical unit failures") },
3099
	/*         A      */
3100
	{ SST(0x69, 0x02, SS_RDEF,
3101
	    "Parity/data mismatch") },
3102
	/*         A      */
3103
	{ SST(0x6A, 0x00, SS_RDEF,
3104
	    "Informational, refer to log") },
3105
	/*         A      */
3106
	{ SST(0x6B, 0x00, SS_RDEF,
3107
	    "State change has occurred") },
3108
	/*         A      */
3109
	{ SST(0x6B, 0x01, SS_RDEF,
3110
	    "Redundancy level got better") },
3111
	/*         A      */
3112
	{ SST(0x6B, 0x02, SS_RDEF,
3113
	    "Redundancy level got worse") },
3114
	/*         A      */
3115
	{ SST(0x6C, 0x00, SS_RDEF,
3116
	    "Rebuild failure occurred") },
3117
	/*         A      */
3118
	{ SST(0x6D, 0x00, SS_RDEF,
3119
	    "Recalculate failure occurred") },
3120
	/*         A      */
3121
	{ SST(0x6E, 0x00, SS_RDEF,
3122
	    "Command to logical unit failed") },
3123
	/*      R         */
3124
	{ SST(0x6F, 0x00, SS_RDEF,	/* XXX TBD */
3125
	    "Copy protection key exchange failure - authentication failure") },
3126
	/*      R         */
3127
	{ SST(0x6F, 0x01, SS_RDEF,	/* XXX TBD */
3128
	    "Copy protection key exchange failure - key not present") },
3129
	/*      R         */
3130
	{ SST(0x6F, 0x02, SS_RDEF,	/* XXX TBD */
3131
	    "Copy protection key exchange failure - key not established") },
3132
	/*      R         */
3133
	{ SST(0x6F, 0x03, SS_RDEF,	/* XXX TBD */
3134
	    "Read of scrambled sector without authentication") },
3135
	/*      R         */
3136
	{ SST(0x6F, 0x04, SS_RDEF,	/* XXX TBD */
3137
	    "Media region code is mismatched to logical unit region") },
3138
	/*      R         */
3139
	{ SST(0x6F, 0x05, SS_RDEF,	/* XXX TBD */
3140
	    "Drive region must be permanent/region reset count error") },
3141
	/*      R         */
3142
	{ SST(0x6F, 0x06, SS_RDEF,	/* XXX TBD */
3143
	    "Insufficient block count for binding NONCE recording") },
3144
	/*      R         */
3145
	{ SST(0x6F, 0x07, SS_RDEF,	/* XXX TBD */
3146
	    "Conflict in binding NONCE recording") },
3147
	/*      R         */
3148
	{ SST(0x6F, 0x08, SS_FATAL | EPERM,
3149
	    "Insufficient permission") },
3150
	/*      R         */
3151
	{ SST(0x6F, 0x09, SS_FATAL | EINVAL,
3152
	    "Invalid drive-host pairing server") },
3153
	/*      R         */
3154
	{ SST(0x6F, 0x0A, SS_RDEF,	/* XXX TBD */
3155
	    "Drive-host pairing suspended") },
3156
	/*  T             */
3157
	{ SST(0x70, 0x00, SS_RDEF,
3158
	    "Decompression exception short: ASCQ = Algorithm ID") },
3159
	/*  T             */
3160
	{ SST(0x70, 0xFF, SS_RDEF | SSQ_RANGE,
3161
	    NULL) },			/* Range 0x00 -> 0xFF */
3162
	/*  T             */
3163
	{ SST(0x71, 0x00, SS_RDEF,
3164
	    "Decompression exception long: ASCQ = Algorithm ID") },
3165
	/*  T             */
3166
	{ SST(0x71, 0xFF, SS_RDEF | SSQ_RANGE,
3167
	    NULL) },			/* Range 0x00 -> 0xFF */
3168
	/*      R         */
3169
	{ SST(0x72, 0x00, SS_RDEF,
3170
	    "Session fixation error") },
3171
	/*      R         */
3172
	{ SST(0x72, 0x01, SS_RDEF,
3173
	    "Session fixation error writing lead-in") },
3174
	/*      R         */
3175
	{ SST(0x72, 0x02, SS_RDEF,
3176
	    "Session fixation error writing lead-out") },
3177
	/*      R         */
3178
	{ SST(0x72, 0x03, SS_RDEF,
3179
	    "Session fixation error - incomplete track in session") },
3180
	/*      R         */
3181
	{ SST(0x72, 0x04, SS_RDEF,
3182
	    "Empty or partially written reserved track") },
3183
	/*      R         */
3184
	{ SST(0x72, 0x05, SS_RDEF,	/* XXX TBD */
3185
	    "No more track reservations allowed") },
3186
	/*      R         */
3187
	{ SST(0x72, 0x06, SS_RDEF,	/* XXX TBD */
3188
	    "RMZ extension is not allowed") },
3189
	/*      R         */
3190
	{ SST(0x72, 0x07, SS_RDEF,	/* XXX TBD */
3191
	    "No more test zone extensions are allowed") },
3192
	/*      R         */
3193
	{ SST(0x73, 0x00, SS_RDEF,
3194
	    "CD control error") },
3195
	/*      R         */
3196
	{ SST(0x73, 0x01, SS_RDEF,
3197
	    "Power calibration area almost full") },
3198
	/*      R         */
3199
	{ SST(0x73, 0x02, SS_FATAL | ENOSPC,
3200
	    "Power calibration area is full") },
3201
	/*      R         */
3202
	{ SST(0x73, 0x03, SS_RDEF,
3203
	    "Power calibration area error") },
3204
	/*      R         */
3205
	{ SST(0x73, 0x04, SS_RDEF,
3206
	    "Program memory area update failure") },
3207
	/*      R         */
3208
	{ SST(0x73, 0x05, SS_RDEF,
3209
	    "Program memory area is full") },
3210
	/*      R         */
3211
	{ SST(0x73, 0x06, SS_RDEF,	/* XXX TBD */
3212
	    "RMA/PMA is almost full") },
3213
	/*      R         */
3214
	{ SST(0x73, 0x10, SS_RDEF,	/* XXX TBD */
3215
	    "Current power calibration area almost full") },
3216
	/*      R         */
3217
	{ SST(0x73, 0x11, SS_RDEF,	/* XXX TBD */
3218
	    "Current power calibration area is full") },
3219
	/*      R         */
3220
	{ SST(0x73, 0x17, SS_RDEF,	/* XXX TBD */
3221
	    "RDZ is full") },
3222
	/*  T             */
3223
	{ SST(0x74, 0x00, SS_RDEF,	/* XXX TBD */
3224
	    "Security error") },
3225
	/*  T             */
3226
	{ SST(0x74, 0x01, SS_RDEF,	/* XXX TBD */
3227
	    "Unable to decrypt data") },
3228
	/*  T             */
3229
	{ SST(0x74, 0x02, SS_RDEF,	/* XXX TBD */
3230
	    "Unencrypted data encountered while decrypting") },
3231
	/*  T             */
3232
	{ SST(0x74, 0x03, SS_RDEF,	/* XXX TBD */
3233
	    "Incorrect data encryption key") },
3234
	/*  T             */
3235
	{ SST(0x74, 0x04, SS_RDEF,	/* XXX TBD */
3236
	    "Cryptographic integrity validation failed") },
3237
	/*  T             */
3238
	{ SST(0x74, 0x05, SS_RDEF,	/* XXX TBD */
3239
	    "Error decrypting data") },
3240
	/*  T             */
3241
	{ SST(0x74, 0x06, SS_RDEF,	/* XXX TBD */
3242
	    "Unknown signature verification key") },
3243
	/*  T             */
3244
	{ SST(0x74, 0x07, SS_RDEF,	/* XXX TBD */
3245
	    "Encryption parameters not useable") },
3246
	/* DT   R M E  VF */
3247
	{ SST(0x74, 0x08, SS_RDEF,	/* XXX TBD */
3248
	    "Digital signature validation failure") },
3249
	/*  T             */
3250
	{ SST(0x74, 0x09, SS_RDEF,	/* XXX TBD */
3251
	    "Encryption mode mismatch on read") },
3252
	/*  T             */
3253
	{ SST(0x74, 0x0A, SS_RDEF,	/* XXX TBD */
3254
	    "Encrypted block not raw read enabled") },
3255
	/*  T             */
3256
	{ SST(0x74, 0x0B, SS_RDEF,	/* XXX TBD */
3257
	    "Incorrect encryption parameters") },
3258
	/* DT   R MAEBKV  */
3259
	{ SST(0x74, 0x0C, SS_RDEF,	/* XXX TBD */
3260
	    "Unable to decrypt parameter list") },
3261
	/*  T             */
3262
	{ SST(0x74, 0x0D, SS_RDEF,	/* XXX TBD */
3263
	    "Encryption algorithm disabled") },
3264
	/* DT   R MAEBKV  */
3265
	{ SST(0x74, 0x10, SS_RDEF,	/* XXX TBD */
3266
	    "SA creation parameter value invalid") },
3267
	/* DT   R MAEBKV  */
3268
	{ SST(0x74, 0x11, SS_RDEF,	/* XXX TBD */
3269
	    "SA creation parameter value rejected") },
3270
	/* DT   R MAEBKV  */
3271
	{ SST(0x74, 0x12, SS_RDEF,	/* XXX TBD */
3272
	    "Invalid SA usage") },
3273
	/*  T             */
3274
	{ SST(0x74, 0x21, SS_RDEF,	/* XXX TBD */
3275
	    "Data encryption configuration prevented") },
3276
	/* DT   R MAEBKV  */
3277
	{ SST(0x74, 0x30, SS_RDEF,	/* XXX TBD */
3278
	    "SA creation parameter not supported") },
3279
	/* DT   R MAEBKV  */
3280
	{ SST(0x74, 0x40, SS_RDEF,	/* XXX TBD */
3281
	    "Authentication failed") },
3282
	/*             V  */
3283
	{ SST(0x74, 0x61, SS_RDEF,	/* XXX TBD */
3284
	    "External data encryption key manager access error") },
3285
	/*             V  */
3286
	{ SST(0x74, 0x62, SS_RDEF,	/* XXX TBD */
3287
	    "External data encryption key manager error") },
3288
	/*             V  */
3289
	{ SST(0x74, 0x63, SS_RDEF,	/* XXX TBD */
3290
	    "External data encryption key not found") },
3291
	/*             V  */
3292
	{ SST(0x74, 0x64, SS_RDEF,	/* XXX TBD */
3293
	    "External data encryption request not authorized") },
3294
	/*  T             */
3295
	{ SST(0x74, 0x6E, SS_RDEF,	/* XXX TBD */
3296
	    "External data encryption control timeout") },
3297
	/*  T             */
3298
	{ SST(0x74, 0x6F, SS_RDEF,	/* XXX TBD */
3299
	    "External data encryption control error") },
3300
	/* DT   R M E  V  */
3301
	{ SST(0x74, 0x71, SS_FATAL | EACCES,
3302
	    "Logical unit access not authorized") },
3303
	/* D              */
3304
	{ SST(0x74, 0x79, SS_FATAL | EACCES,
3305
	    "Security conflict in translated device") }
3306
};
3307

3308
const u_int asc_table_size = nitems(asc_table);
3309

3310
struct asc_key
3311
{
3312
	int asc;
3313
	int ascq;
3314
};
3315

3316
static int
3317
ascentrycomp(const void *key, const void *member)
3318
{
3319
	int asc;
3320
	int ascq;
3321
	const struct asc_table_entry *table_entry;
3322

3323
	asc = ((const struct asc_key *)key)->asc;
3324
	ascq = ((const struct asc_key *)key)->ascq;
3325
	table_entry = (const struct asc_table_entry *)member;
3326

3327
	if (asc >= table_entry->asc) {
3328
		if (asc > table_entry->asc)
3329
			return (1);
3330

3331
		if (ascq <= table_entry->ascq) {
3332
			/* Check for ranges */
3333
			if (ascq == table_entry->ascq
3334
		 	 || ((table_entry->action & SSQ_RANGE) != 0
3335
		  	   && ascq >= (table_entry - 1)->ascq))
3336
				return (0);
3337
			return (-1);
3338
		}
3339
		return (1);
3340
	}
3341
	return (-1);
3342
}
3343

3344
static int
3345
senseentrycomp(const void *key, const void *member)
3346
{
3347
	int sense_key;
3348
	const struct sense_key_table_entry *table_entry;
3349

3350
	sense_key = *((const int *)key);
3351
	table_entry = (const struct sense_key_table_entry *)member;
3352

3353
	if (sense_key >= table_entry->sense_key) {
3354
		if (sense_key == table_entry->sense_key)
3355
			return (0);
3356
		return (1);
3357
	}
3358
	return (-1);
3359
}
3360

3361
static void
3362
fetchtableentries(int sense_key, int asc, int ascq,
3363
		  struct scsi_inquiry_data *inq_data,
3364
		  const struct sense_key_table_entry **sense_entry,
3365
		  const struct asc_table_entry **asc_entry)
3366
{
3367
	caddr_t match;
3368
	const struct asc_table_entry *asc_tables[2];
3369
	const struct sense_key_table_entry *sense_tables[2];
3370
	struct asc_key asc_ascq;
3371
	size_t asc_tables_size[2];
3372
	size_t sense_tables_size[2];
3373
	int num_asc_tables;
3374
	int num_sense_tables;
3375
	int i;
3376

3377
	/* Default to failure */
3378
	*sense_entry = NULL;
3379
	*asc_entry = NULL;
3380
	match = NULL;
3381
	if (inq_data != NULL)
3382
		match = cam_quirkmatch((caddr_t)inq_data,
3383
				       (caddr_t)sense_quirk_table,
3384
				       sense_quirk_table_size,
3385
				       sizeof(*sense_quirk_table),
3386
				       scsi_inquiry_match);
3387

3388
	if (match != NULL) {
3389
		struct scsi_sense_quirk_entry *quirk;
3390

3391
		quirk = (struct scsi_sense_quirk_entry *)match;
3392
		asc_tables[0] = quirk->asc_info;
3393
		asc_tables_size[0] = quirk->num_ascs;
3394
		asc_tables[1] = asc_table;
3395
		asc_tables_size[1] = asc_table_size;
3396
		num_asc_tables = 2;
3397
		sense_tables[0] = quirk->sense_key_info;
3398
		sense_tables_size[0] = quirk->num_sense_keys;
3399
		sense_tables[1] = sense_key_table;
3400
		sense_tables_size[1] = nitems(sense_key_table);
3401
		num_sense_tables = 2;
3402
	} else {
3403
		asc_tables[0] = asc_table;
3404
		asc_tables_size[0] = asc_table_size;
3405
		num_asc_tables = 1;
3406
		sense_tables[0] = sense_key_table;
3407
		sense_tables_size[0] = nitems(sense_key_table);
3408
		num_sense_tables = 1;
3409
	}
3410

3411
	asc_ascq.asc = asc;
3412
	asc_ascq.ascq = ascq;
3413
	for (i = 0; i < num_asc_tables; i++) {
3414
		void *found_entry;
3415

3416
		found_entry = bsearch(&asc_ascq, asc_tables[i],
3417
				      asc_tables_size[i],
3418
				      sizeof(**asc_tables),
3419
				      ascentrycomp);
3420

3421
		if (found_entry) {
3422
			/*
3423
			 * If we get to the SSQ_RANGE entry, we're one too
3424
			 * far. The prior entry is the interesting one, since it
3425
			 * contains the string to print, etc. Only the top end
3426
			 * range is interesting in this entry.
3427
			 */
3428
			*asc_entry = (struct asc_table_entry *)found_entry;
3429
			if (((*asc_entry)->action & SSQ_RANGE) != 0)
3430
				(*asc_entry)--;
3431
			break;
3432
		}
3433
	}
3434

3435
	for (i = 0; i < num_sense_tables; i++) {
3436
		void *found_entry;
3437

3438
		found_entry = bsearch(&sense_key, sense_tables[i],
3439
				      sense_tables_size[i],
3440
				      sizeof(**sense_tables),
3441
				      senseentrycomp);
3442

3443
		if (found_entry) {
3444
			*sense_entry =
3445
			    (struct sense_key_table_entry *)found_entry;
3446
			break;
3447
		}
3448
	}
3449
}
3450

3451
void
3452
scsi_sense_desc(int sense_key, int asc, int ascq,
3453
		struct scsi_inquiry_data *inq_data,
3454
		const char **sense_key_desc, const char **asc_desc)
3455
{
3456
	const struct asc_table_entry *asc_entry;
3457
	const struct sense_key_table_entry *sense_entry;
3458

3459
	fetchtableentries(sense_key, asc, ascq,
3460
			  inq_data,
3461
			  &sense_entry,
3462
			  &asc_entry);
3463

3464
	if (sense_entry != NULL)
3465
		*sense_key_desc = sense_entry->desc;
3466
	else
3467
		*sense_key_desc = "Invalid Sense Key";
3468

3469
	if (asc_entry != NULL)
3470
		*asc_desc = asc_entry->desc;
3471
	else if (asc >= 0x80 && asc <= 0xff)
3472
		*asc_desc = "Vendor Specific ASC";
3473
	else if (ascq >= 0x80 && ascq <= 0xff)
3474
		*asc_desc = "Vendor Specific ASCQ";
3475
	else
3476
		*asc_desc = "Reserved ASC/ASCQ pair";
3477
}
3478

3479
/*
3480
 * Given sense and device type information, return the appropriate action.
3481
 * If we do not understand the specific error as identified by the ASC/ASCQ
3482
 * pair, fall back on the more generic actions derived from the sense key.
3483
 */
3484
scsi_sense_action
3485
scsi_error_action(struct ccb_scsiio *csio, struct scsi_inquiry_data *inq_data,
3486
		  uint32_t sense_flags)
3487
{
3488
	const struct asc_table_entry *asc_entry;
3489
	const struct sense_key_table_entry *sense_entry;
3490
	int error_code, sense_key, asc, ascq;
3491
	scsi_sense_action action;
3492

3493
	if (!scsi_extract_sense_ccb((union ccb *)csio,
3494
	    &error_code, &sense_key, &asc, &ascq)) {
3495
		action = SS_RDEF;
3496
	} else if ((error_code == SSD_DEFERRED_ERROR)
3497
	 || (error_code == SSD_DESC_DEFERRED_ERROR)) {
3498
		/*
3499
		 * XXX [email protected]
3500
		 * This error doesn't relate to the command associated
3501
		 * with this request sense.  A deferred error is an error
3502
		 * for a command that has already returned GOOD status
3503
		 * (see SCSI2 8.2.14.2).
3504
		 *
3505
		 * By my reading of that section, it looks like the current
3506
		 * command has been cancelled, we should now clean things up
3507
		 * (hopefully recovering any lost data) and then retry the
3508
		 * current command.  There are two easy choices, both wrong:
3509
		 *
3510
		 * 1. Drop through (like we had been doing), thus treating
3511
		 *    this as if the error were for the current command and
3512
		 *    return and stop the current command.
3513
		 *
3514
		 * 2. Issue a retry (like I made it do) thus hopefully
3515
		 *    recovering the current transfer, and ignoring the
3516
		 *    fact that we've dropped a command.
3517
		 *
3518
		 * These should probably be handled in a device specific
3519
		 * sense handler or punted back up to a user mode daemon
3520
		 */
3521
		action = SS_RETRY|SSQ_DECREMENT_COUNT|SSQ_PRINT_SENSE;
3522
	} else {
3523
		fetchtableentries(sense_key, asc, ascq,
3524
				  inq_data,
3525
				  &sense_entry,
3526
				  &asc_entry);
3527

3528
		/*
3529
		 * Override the 'No additional Sense' entry (0,0)
3530
		 * with the error action of the sense key.
3531
		 */
3532
		if (asc_entry != NULL
3533
		 && (asc != 0 || ascq != 0))
3534
			action = asc_entry->action;
3535
		else if (sense_entry != NULL)
3536
			action = sense_entry->action;
3537
		else
3538
			action = SS_RETRY|SSQ_DECREMENT_COUNT|SSQ_PRINT_SENSE;
3539

3540
		if (sense_key == SSD_KEY_RECOVERED_ERROR) {
3541
			/*
3542
			 * The action succeeded but the device wants
3543
			 * the user to know that some recovery action
3544
			 * was required.
3545
			 */
3546
			action &= ~(SS_MASK|SSQ_MASK|SS_ERRMASK);
3547
			action |= SS_NOP|SSQ_PRINT_SENSE;
3548
		} else if (sense_key == SSD_KEY_ILLEGAL_REQUEST) {
3549
			if ((sense_flags & SF_QUIET_IR) != 0)
3550
				action &= ~SSQ_PRINT_SENSE;
3551
		} else if (sense_key == SSD_KEY_UNIT_ATTENTION) {
3552
			if ((sense_flags & SF_RETRY_UA) != 0
3553
			 && (action & SS_MASK) == SS_FAIL) {
3554
				action &= ~(SS_MASK|SSQ_MASK);
3555
				action |= SS_RETRY|SSQ_DECREMENT_COUNT|
3556
					  SSQ_PRINT_SENSE;
3557
			}
3558
			action |= SSQ_UA;
3559
		}
3560
	}
3561
	if ((action & SS_MASK) >= SS_START &&
3562
	    (sense_flags & SF_NO_RECOVERY)) {
3563
		action &= ~SS_MASK;
3564
		action |= SS_FAIL;
3565
	} else if ((action & SS_MASK) == SS_RETRY &&
3566
	    (sense_flags & SF_NO_RETRY)) {
3567
		action &= ~SS_MASK;
3568
		action |= SS_FAIL;
3569
	}
3570
	if ((sense_flags & SF_PRINT_ALWAYS) != 0)
3571
		action |= SSQ_PRINT_SENSE;
3572
	else if ((sense_flags & SF_NO_PRINT) != 0)
3573
		action &= ~SSQ_PRINT_SENSE;
3574

3575
	return (action);
3576
}
3577

3578
char *
3579
scsi_cdb_string(uint8_t *cdb_ptr, char *cdb_string, size_t len)
3580
{
3581
	struct sbuf sb;
3582
	int error;
3583

3584
	if (len == 0)
3585
		return ("");
3586

3587
	sbuf_new(&sb, cdb_string, len, SBUF_FIXEDLEN);
3588

3589
	scsi_cdb_sbuf(cdb_ptr, &sb);
3590

3591
	/* ENOMEM just means that the fixed buffer is full, OK to ignore */
3592
	error = sbuf_finish(&sb);
3593
	if (error != 0 &&
3594
#ifdef _KERNEL
3595
	    error != ENOMEM)
3596
#else
3597
	    errno != ENOMEM)
3598
#endif
3599
		return ("");
3600

3601
	return(sbuf_data(&sb));
3602
}
3603

3604
void
3605
scsi_cdb_sbuf(uint8_t *cdb_ptr, struct sbuf *sb)
3606
{
3607
	uint8_t cdb_len;
3608
	int i;
3609

3610
	if (cdb_ptr == NULL)
3611
		return;
3612

3613
	/*
3614
	 * This is taken from the SCSI-3 draft spec.
3615
	 * (T10/1157D revision 0.3)
3616
	 * The top 3 bits of an opcode are the group code.  The next 5 bits
3617
	 * are the command code.
3618
	 * Group 0:  six byte commands
3619
	 * Group 1:  ten byte commands
3620
	 * Group 2:  ten byte commands
3621
	 * Group 3:  reserved
3622
	 * Group 4:  sixteen byte commands
3623
	 * Group 5:  twelve byte commands
3624
	 * Group 6:  vendor specific
3625
	 * Group 7:  vendor specific
3626
	 */
3627
	switch((*cdb_ptr >> 5) & 0x7) {
3628
		case 0:
3629
			cdb_len = 6;
3630
			break;
3631
		case 1:
3632
		case 2:
3633
			cdb_len = 10;
3634
			break;
3635
		case 3:
3636
		case 6:
3637
		case 7:
3638
			/* in this case, just print out the opcode */
3639
			cdb_len = 1;
3640
			break;
3641
		case 4:
3642
			cdb_len = 16;
3643
			break;
3644
		case 5:
3645
			cdb_len = 12;
3646
			break;
3647
	}
3648

3649
	for (i = 0; i < cdb_len; i++)
3650
		sbuf_printf(sb, "%02hhx ", cdb_ptr[i]);
3651

3652
	return;
3653
}
3654

3655
const char *
3656
scsi_status_string(struct ccb_scsiio *csio)
3657
{
3658
	switch(csio->scsi_status) {
3659
	case SCSI_STATUS_OK:
3660
		return("OK");
3661
	case SCSI_STATUS_CHECK_COND:
3662
		return("Check Condition");
3663
	case SCSI_STATUS_BUSY:
3664
		return("Busy");
3665
	case SCSI_STATUS_INTERMED:
3666
		return("Intermediate");
3667
	case SCSI_STATUS_INTERMED_COND_MET:
3668
		return("Intermediate-Condition Met");
3669
	case SCSI_STATUS_RESERV_CONFLICT:
3670
		return("Reservation Conflict");
3671
	case SCSI_STATUS_CMD_TERMINATED:
3672
		return("Command Terminated");
3673
	case SCSI_STATUS_QUEUE_FULL:
3674
		return("Queue Full");
3675
	case SCSI_STATUS_ACA_ACTIVE:
3676
		return("ACA Active");
3677
	case SCSI_STATUS_TASK_ABORTED:
3678
		return("Task Aborted");
3679
	default: {
3680
		static char unkstr[64];
3681
		snprintf(unkstr, sizeof(unkstr), "Unknown %#x",
3682
			 csio->scsi_status);
3683
		return(unkstr);
3684
	}
3685
	}
3686
}
3687

3688
/*
3689
 * scsi_command_string() returns 0 for success and -1 for failure.
3690
 */
3691
#ifdef _KERNEL
3692
int
3693
scsi_command_string(struct ccb_scsiio *csio, struct sbuf *sb)
3694
#else /* !_KERNEL */
3695
int
3696
scsi_command_string(struct cam_device *device, struct ccb_scsiio *csio,
3697
		    struct sbuf *sb)
3698
#endif /* _KERNEL/!_KERNEL */
3699
{
3700
	struct scsi_inquiry_data *inq_data;
3701
#ifdef _KERNEL
3702
	struct	  ccb_getdev *cgd;
3703
#endif /* _KERNEL */
3704

3705
#ifdef _KERNEL
3706
	if ((cgd = (struct ccb_getdev*)xpt_alloc_ccb_nowait()) == NULL)
3707
		return(-1);
3708
	/*
3709
	 * Get the device information.
3710
	 */
3711
	xpt_gdev_type(cgd, csio->ccb_h.path);
3712

3713
	/*
3714
	 * If the device is unconfigured, the inq data is invalid.
3715
	 */
3716
	if (cgd->ccb_h.status == CAM_DEV_NOT_THERE)
3717
		inq_data = NULL;
3718
	else
3719
		inq_data = &cgd->inq_data;
3720

3721
#else /* !_KERNEL */
3722

3723
	inq_data = &device->inq_data;
3724

3725
#endif /* _KERNEL/!_KERNEL */
3726

3727
	sbuf_printf(sb, "%s. CDB: ",
3728
		    scsi_op_desc(scsiio_cdb_ptr(csio)[0], inq_data));
3729
	scsi_cdb_sbuf(scsiio_cdb_ptr(csio), sb);
3730

3731
#ifdef _KERNEL
3732
	xpt_free_ccb((union ccb *)cgd);
3733
#endif
3734

3735
	return(0);
3736
}
3737

3738
/*
3739
 * Iterate over sense descriptors.  Each descriptor is passed into iter_func().
3740
 * If iter_func() returns 0, list traversal continues.  If iter_func()
3741
 * returns non-zero, list traversal is stopped.
3742
 */
3743
void
3744
scsi_desc_iterate(struct scsi_sense_data_desc *sense, u_int sense_len,
3745
		  int (*iter_func)(struct scsi_sense_data_desc *sense,
3746
				   u_int, struct scsi_sense_desc_header *,
3747
				   void *), void *arg)
3748
{
3749
	int cur_pos;
3750
	int desc_len;
3751

3752
	/*
3753
	 * First make sure the extra length field is present.
3754
	 */
3755
	if (SSD_DESC_IS_PRESENT(sense, sense_len, extra_len) == 0)
3756
		return;
3757

3758
	/*
3759
	 * The length of data actually returned may be different than the
3760
	 * extra_len recorded in the structure.
3761
	 */
3762
	desc_len = sense_len -offsetof(struct scsi_sense_data_desc, sense_desc);
3763

3764
	/*
3765
	 * Limit this further by the extra length reported, and the maximum
3766
	 * allowed extra length.
3767
	 */
3768
	desc_len = MIN(desc_len, MIN(sense->extra_len, SSD_EXTRA_MAX));
3769

3770
	/*
3771
	 * Subtract the size of the header from the descriptor length.
3772
	 * This is to ensure that we have at least the header left, so we
3773
	 * don't have to check that inside the loop.  This can wind up
3774
	 * being a negative value.
3775
	 */
3776
	desc_len -= sizeof(struct scsi_sense_desc_header);
3777

3778
	for (cur_pos = 0; cur_pos < desc_len;) {
3779
		struct scsi_sense_desc_header *header;
3780

3781
		header = (struct scsi_sense_desc_header *)
3782
			&sense->sense_desc[cur_pos];
3783

3784
		/*
3785
		 * Check to make sure we have the entire descriptor.  We
3786
		 * don't call iter_func() unless we do.
3787
		 *
3788
		 * Note that although cur_pos is at the beginning of the
3789
		 * descriptor, desc_len already has the header length
3790
		 * subtracted.  So the comparison of the length in the
3791
		 * header (which does not include the header itself) to
3792
		 * desc_len - cur_pos is correct.
3793
		 */
3794
		if (header->length > (desc_len - cur_pos))
3795
			break;
3796

3797
		if (iter_func(sense, sense_len, header, arg) != 0)
3798
			break;
3799

3800
		cur_pos += sizeof(*header) + header->length;
3801
	}
3802
}
3803

3804
struct scsi_find_desc_info {
3805
	uint8_t desc_type;
3806
	struct scsi_sense_desc_header *header;
3807
};
3808

3809
static int
3810
scsi_find_desc_func(struct scsi_sense_data_desc *sense, u_int sense_len,
3811
		    struct scsi_sense_desc_header *header, void *arg)
3812
{
3813
	struct scsi_find_desc_info *desc_info;
3814

3815
	desc_info = (struct scsi_find_desc_info *)arg;
3816

3817
	if (header->desc_type == desc_info->desc_type) {
3818
		desc_info->header = header;
3819

3820
		/* We found the descriptor, tell the iterator to stop. */
3821
		return (1);
3822
	} else
3823
		return (0);
3824
}
3825

3826
/*
3827
 * Given a descriptor type, return a pointer to it if it is in the sense
3828
 * data and not truncated.  Avoiding truncating sense data will simplify
3829
 * things significantly for the caller.
3830
 */
3831
uint8_t *
3832
scsi_find_desc(struct scsi_sense_data_desc *sense, u_int sense_len,
3833
	       uint8_t desc_type)
3834
{
3835
	struct scsi_find_desc_info desc_info;
3836

3837
	desc_info.desc_type = desc_type;
3838
	desc_info.header = NULL;
3839

3840
	scsi_desc_iterate(sense, sense_len, scsi_find_desc_func, &desc_info);
3841

3842
	return ((uint8_t *)desc_info.header);
3843
}
3844

3845
/*
3846
 * Fill in SCSI descriptor sense data with the specified parameters.
3847
 */
3848
static void
3849
scsi_set_sense_data_desc_va(struct scsi_sense_data *sense_data,
3850
    u_int *sense_len, scsi_sense_data_type sense_format, int current_error,
3851
    int sense_key, int asc, int ascq, va_list ap)
3852
{
3853
	struct scsi_sense_data_desc *sense;
3854
	scsi_sense_elem_type elem_type;
3855
	int space, len;
3856
	uint8_t *desc, *data;
3857

3858
	memset(sense_data, 0, sizeof(*sense_data));
3859
	sense = (struct scsi_sense_data_desc *)sense_data;
3860
	if (current_error != 0)
3861
		sense->error_code = SSD_DESC_CURRENT_ERROR;
3862
	else
3863
		sense->error_code = SSD_DESC_DEFERRED_ERROR;
3864
	sense->sense_key = sense_key;
3865
	sense->add_sense_code = asc;
3866
	sense->add_sense_code_qual = ascq;
3867
	sense->flags = 0;
3868

3869
	desc = &sense->sense_desc[0];
3870
	space = *sense_len - offsetof(struct scsi_sense_data_desc, sense_desc);
3871
	while ((elem_type = va_arg(ap, scsi_sense_elem_type)) !=
3872
	    SSD_ELEM_NONE) {
3873
		if (elem_type >= SSD_ELEM_MAX) {
3874
			printf("%s: invalid sense type %d\n", __func__,
3875
			       elem_type);
3876
			break;
3877
		}
3878
		len = va_arg(ap, int);
3879
		data = va_arg(ap, uint8_t *);
3880

3881
		switch (elem_type) {
3882
		case SSD_ELEM_SKIP:
3883
			break;
3884
		case SSD_ELEM_DESC:
3885
			if (space < len) {
3886
				sense->flags |= SSDD_SDAT_OVFL;
3887
				break;
3888
			}
3889
			bcopy(data, desc, len);
3890
			desc += len;
3891
			space -= len;
3892
			break;
3893
		case SSD_ELEM_SKS: {
3894
			struct scsi_sense_sks *sks = (void *)desc;
3895

3896
			if (len > sizeof(sks->sense_key_spec))
3897
				break;
3898
			if (space < sizeof(*sks)) {
3899
				sense->flags |= SSDD_SDAT_OVFL;
3900
				break;
3901
			}
3902
			sks->desc_type = SSD_DESC_SKS;
3903
			sks->length = sizeof(*sks) -
3904
			    (offsetof(struct scsi_sense_sks, length) + 1);
3905
			bcopy(data, &sks->sense_key_spec, len);
3906
			desc += sizeof(*sks);
3907
			space -= sizeof(*sks);
3908
			break;
3909
		}
3910
		case SSD_ELEM_COMMAND: {
3911
			struct scsi_sense_command *cmd = (void *)desc;
3912

3913
			if (len > sizeof(cmd->command_info))
3914
				break;
3915
			if (space < sizeof(*cmd)) {
3916
				sense->flags |= SSDD_SDAT_OVFL;
3917
				break;
3918
			}
3919
			cmd->desc_type = SSD_DESC_COMMAND;
3920
			cmd->length = sizeof(*cmd) -
3921
			    (offsetof(struct scsi_sense_command, length) + 1);
3922
			bcopy(data, &cmd->command_info[
3923
			    sizeof(cmd->command_info) - len], len);
3924
			desc += sizeof(*cmd);
3925
			space -= sizeof(*cmd);
3926
			break;
3927
		}
3928
		case SSD_ELEM_INFO: {
3929
			struct scsi_sense_info *info = (void *)desc;
3930

3931
			if (len > sizeof(info->info))
3932
				break;
3933
			if (space < sizeof(*info)) {
3934
				sense->flags |= SSDD_SDAT_OVFL;
3935
				break;
3936
			}
3937
			info->desc_type = SSD_DESC_INFO;
3938
			info->length = sizeof(*info) -
3939
			    (offsetof(struct scsi_sense_info, length) + 1);
3940
			info->byte2 = SSD_INFO_VALID;
3941
			bcopy(data, &info->info[sizeof(info->info) - len], len);
3942
			desc += sizeof(*info);
3943
			space -= sizeof(*info);
3944
			break;
3945
		}
3946
		case SSD_ELEM_FRU: {
3947
			struct scsi_sense_fru *fru = (void *)desc;
3948

3949
			if (len > sizeof(fru->fru))
3950
				break;
3951
			if (space < sizeof(*fru)) {
3952
				sense->flags |= SSDD_SDAT_OVFL;
3953
				break;
3954
			}
3955
			fru->desc_type = SSD_DESC_FRU;
3956
			fru->length = sizeof(*fru) -
3957
			    (offsetof(struct scsi_sense_fru, length) + 1);
3958
			fru->fru = *data;
3959
			desc += sizeof(*fru);
3960
			space -= sizeof(*fru);
3961
			break;
3962
		}
3963
		case SSD_ELEM_STREAM: {
3964
			struct scsi_sense_stream *stream = (void *)desc;
3965

3966
			if (len > sizeof(stream->byte3))
3967
				break;
3968
			if (space < sizeof(*stream)) {
3969
				sense->flags |= SSDD_SDAT_OVFL;
3970
				break;
3971
			}
3972
			stream->desc_type = SSD_DESC_STREAM;
3973
			stream->length = sizeof(*stream) -
3974
			    (offsetof(struct scsi_sense_stream, length) + 1);
3975
			stream->byte3 = *data;
3976
			desc += sizeof(*stream);
3977
			space -= sizeof(*stream);
3978
			break;
3979
		}
3980
		default:
3981
			/*
3982
			 * We shouldn't get here, but if we do, do nothing.
3983
			 * We've already consumed the arguments above.
3984
			 */
3985
			break;
3986
		}
3987
	}
3988
	sense->extra_len = desc - &sense->sense_desc[0];
3989
	*sense_len = offsetof(struct scsi_sense_data_desc, extra_len) + 1 +
3990
	    sense->extra_len;
3991
}
3992

3993
/*
3994
 * Fill in SCSI fixed sense data with the specified parameters.
3995
 */
3996
static void
3997
scsi_set_sense_data_fixed_va(struct scsi_sense_data *sense_data,
3998
    u_int *sense_len, scsi_sense_data_type sense_format, int current_error,
3999
    int sense_key, int asc, int ascq, va_list ap)
4000
{
4001
	struct scsi_sense_data_fixed *sense;
4002
	scsi_sense_elem_type elem_type;
4003
	uint8_t *data;
4004
	int len;
4005

4006
	memset(sense_data, 0, sizeof(*sense_data));
4007
	sense = (struct scsi_sense_data_fixed *)sense_data;
4008
	if (current_error != 0)
4009
		sense->error_code = SSD_CURRENT_ERROR;
4010
	else
4011
		sense->error_code = SSD_DEFERRED_ERROR;
4012
	sense->flags = sense_key & SSD_KEY;
4013
	sense->extra_len = 0;
4014
	if (*sense_len >= 13) {
4015
		sense->add_sense_code = asc;
4016
		sense->extra_len = MAX(sense->extra_len, 5);
4017
	} else
4018
		sense->flags |= SSD_SDAT_OVFL;
4019
	if (*sense_len >= 14) {
4020
		sense->add_sense_code_qual = ascq;
4021
		sense->extra_len = MAX(sense->extra_len, 6);
4022
	} else
4023
		sense->flags |= SSD_SDAT_OVFL;
4024

4025
	while ((elem_type = va_arg(ap, scsi_sense_elem_type)) !=
4026
	    SSD_ELEM_NONE) {
4027
		if (elem_type >= SSD_ELEM_MAX) {
4028
			printf("%s: invalid sense type %d\n", __func__,
4029
			       elem_type);
4030
			break;
4031
		}
4032
		len = va_arg(ap, int);
4033
		data = va_arg(ap, uint8_t *);
4034

4035
		switch (elem_type) {
4036
		case SSD_ELEM_SKIP:
4037
			break;
4038
		case SSD_ELEM_SKS:
4039
			if (len > sizeof(sense->sense_key_spec))
4040
				break;
4041
			if (*sense_len < 18) {
4042
				sense->flags |= SSD_SDAT_OVFL;
4043
				break;
4044
			}
4045
			bcopy(data, &sense->sense_key_spec[0], len);
4046
			sense->extra_len = MAX(sense->extra_len, 10);
4047
			break;
4048
		case SSD_ELEM_COMMAND:
4049
			if (*sense_len < 12) {
4050
				sense->flags |= SSD_SDAT_OVFL;
4051
				break;
4052
			}
4053
			if (len > sizeof(sense->cmd_spec_info)) {
4054
				data += len - sizeof(sense->cmd_spec_info);
4055
				len = sizeof(sense->cmd_spec_info);
4056
			}
4057
			bcopy(data, &sense->cmd_spec_info[
4058
			    sizeof(sense->cmd_spec_info) - len], len);
4059
			sense->extra_len = MAX(sense->extra_len, 4);
4060
			break;
4061
		case SSD_ELEM_INFO:
4062
			/* Set VALID bit only if no overflow. */
4063
			sense->error_code |= SSD_ERRCODE_VALID;
4064
			while (len > sizeof(sense->info)) {
4065
				if (data[0] != 0)
4066
					sense->error_code &= ~SSD_ERRCODE_VALID;
4067
				data ++;
4068
				len --;
4069
			}
4070
			bcopy(data, &sense->info[sizeof(sense->info) - len], len);
4071
			break;
4072
		case SSD_ELEM_FRU:
4073
			if (*sense_len < 15) {
4074
				sense->flags |= SSD_SDAT_OVFL;
4075
				break;
4076
			}
4077
			sense->fru = *data;
4078
			sense->extra_len = MAX(sense->extra_len, 7);
4079
			break;
4080
		case SSD_ELEM_STREAM:
4081
			sense->flags |= *data &
4082
			    (SSD_ILI | SSD_EOM | SSD_FILEMARK);
4083
			break;
4084
		default:
4085

4086
			/*
4087
			 * We can't handle that in fixed format.  Skip it.
4088
			 */
4089
			break;
4090
		}
4091
	}
4092
	*sense_len = offsetof(struct scsi_sense_data_fixed, extra_len) + 1 +
4093
	    sense->extra_len;
4094
}
4095

4096
/*
4097
 * Fill in SCSI sense data with the specified parameters.  This routine can
4098
 * fill in either fixed or descriptor type sense data.
4099
 */
4100
void
4101
scsi_set_sense_data_va(struct scsi_sense_data *sense_data, u_int *sense_len,
4102
		      scsi_sense_data_type sense_format, int current_error,
4103
		      int sense_key, int asc, int ascq, va_list ap)
4104
{
4105

4106
	if (*sense_len > SSD_FULL_SIZE)
4107
		*sense_len = SSD_FULL_SIZE;
4108
	if (sense_format == SSD_TYPE_DESC)
4109
		scsi_set_sense_data_desc_va(sense_data, sense_len,
4110
		    sense_format, current_error, sense_key, asc, ascq, ap);
4111
	else
4112
		scsi_set_sense_data_fixed_va(sense_data, sense_len,
4113
		    sense_format, current_error, sense_key, asc, ascq, ap);
4114
}
4115

4116
void
4117
scsi_set_sense_data(struct scsi_sense_data *sense_data,
4118
		    scsi_sense_data_type sense_format, int current_error,
4119
		    int sense_key, int asc, int ascq, ...)
4120
{
4121
	va_list ap;
4122
	u_int	sense_len = SSD_FULL_SIZE;
4123

4124
	va_start(ap, ascq);
4125
	scsi_set_sense_data_va(sense_data, &sense_len, sense_format,
4126
	    current_error, sense_key, asc, ascq, ap);
4127
	va_end(ap);
4128
}
4129

4130
void
4131
scsi_set_sense_data_len(struct scsi_sense_data *sense_data, u_int *sense_len,
4132
		    scsi_sense_data_type sense_format, int current_error,
4133
		    int sense_key, int asc, int ascq, ...)
4134
{
4135
	va_list ap;
4136

4137
	va_start(ap, ascq);
4138
	scsi_set_sense_data_va(sense_data, sense_len, sense_format,
4139
	    current_error, sense_key, asc, ascq, ap);
4140
	va_end(ap);
4141
}
4142

4143
/*
4144
 * Get sense information for three similar sense data types.
4145
 */
4146
int
4147
scsi_get_sense_info(struct scsi_sense_data *sense_data, u_int sense_len,
4148
		    uint8_t info_type, uint64_t *info, int64_t *signed_info)
4149
{
4150
	scsi_sense_data_type sense_type;
4151

4152
	if (sense_len == 0)
4153
		goto bailout;
4154

4155
	sense_type = scsi_sense_type(sense_data);
4156

4157
	switch (sense_type) {
4158
	case SSD_TYPE_DESC: {
4159
		struct scsi_sense_data_desc *sense;
4160
		uint8_t *desc;
4161

4162
		sense = (struct scsi_sense_data_desc *)sense_data;
4163

4164
		desc = scsi_find_desc(sense, sense_len, info_type);
4165
		if (desc == NULL)
4166
			goto bailout;
4167

4168
		switch (info_type) {
4169
		case SSD_DESC_INFO: {
4170
			struct scsi_sense_info *info_desc;
4171

4172
			info_desc = (struct scsi_sense_info *)desc;
4173

4174
			if ((info_desc->byte2 & SSD_INFO_VALID) == 0)
4175
				goto bailout;
4176

4177
			*info = scsi_8btou64(info_desc->info);
4178
			if (signed_info != NULL)
4179
				*signed_info = *info;
4180
			break;
4181
		}
4182
		case SSD_DESC_COMMAND: {
4183
			struct scsi_sense_command *cmd_desc;
4184

4185
			cmd_desc = (struct scsi_sense_command *)desc;
4186

4187
			*info = scsi_8btou64(cmd_desc->command_info);
4188
			if (signed_info != NULL)
4189
				*signed_info = *info;
4190
			break;
4191
		}
4192
		case SSD_DESC_FRU: {
4193
			struct scsi_sense_fru *fru_desc;
4194

4195
			fru_desc = (struct scsi_sense_fru *)desc;
4196

4197
			if (fru_desc->fru == 0)
4198
				goto bailout;
4199

4200
			*info = fru_desc->fru;
4201
			if (signed_info != NULL)
4202
				*signed_info = (int8_t)fru_desc->fru;
4203
			break;
4204
		}
4205
		default:
4206
			goto bailout;
4207
			break;
4208
		}
4209
		break;
4210
	}
4211
	case SSD_TYPE_FIXED: {
4212
		struct scsi_sense_data_fixed *sense;
4213

4214
		sense = (struct scsi_sense_data_fixed *)sense_data;
4215

4216
		switch (info_type) {
4217
		case SSD_DESC_INFO: {
4218
			uint32_t info_val;
4219

4220
			if ((sense->error_code & SSD_ERRCODE_VALID) == 0)
4221
				goto bailout;
4222

4223
			if (SSD_FIXED_IS_PRESENT(sense, sense_len, info) == 0)
4224
				goto bailout;
4225

4226
			info_val = scsi_4btoul(sense->info);
4227

4228
			*info = info_val;
4229
			if (signed_info != NULL)
4230
				*signed_info = (int32_t)info_val;
4231
			break;
4232
		}
4233
		case SSD_DESC_COMMAND: {
4234
			uint32_t cmd_val;
4235

4236
			if ((SSD_FIXED_IS_PRESENT(sense, sense_len,
4237
			     cmd_spec_info) == 0)
4238
			 || (SSD_FIXED_IS_FILLED(sense, cmd_spec_info) == 0))
4239
				goto bailout;
4240

4241
			cmd_val = scsi_4btoul(sense->cmd_spec_info);
4242
			if (cmd_val == 0)
4243
				goto bailout;
4244

4245
			*info = cmd_val;
4246
			if (signed_info != NULL)
4247
				*signed_info = (int32_t)cmd_val;
4248
			break;
4249
		}
4250
		case SSD_DESC_FRU:
4251
			if ((SSD_FIXED_IS_PRESENT(sense, sense_len, fru) == 0)
4252
			 || (SSD_FIXED_IS_FILLED(sense, fru) == 0))
4253
				goto bailout;
4254

4255
			if (sense->fru == 0)
4256
				goto bailout;
4257

4258
			*info = sense->fru;
4259
			if (signed_info != NULL)
4260
				*signed_info = (int8_t)sense->fru;
4261
			break;
4262
		default:
4263
			goto bailout;
4264
			break;
4265
		}
4266
		break;
4267
	}
4268
	default:
4269
		goto bailout;
4270
		break;
4271
	}
4272

4273
	return (0);
4274
bailout:
4275
	return (1);
4276
}
4277

4278
int
4279
scsi_get_sks(struct scsi_sense_data *sense_data, u_int sense_len, uint8_t *sks)
4280
{
4281
	scsi_sense_data_type sense_type;
4282

4283
	if (sense_len == 0)
4284
		goto bailout;
4285

4286
	sense_type = scsi_sense_type(sense_data);
4287

4288
	switch (sense_type) {
4289
	case SSD_TYPE_DESC: {
4290
		struct scsi_sense_data_desc *sense;
4291
		struct scsi_sense_sks *desc;
4292

4293
		sense = (struct scsi_sense_data_desc *)sense_data;
4294

4295
		desc = (struct scsi_sense_sks *)scsi_find_desc(sense, sense_len,
4296
							       SSD_DESC_SKS);
4297
		if (desc == NULL)
4298
			goto bailout;
4299

4300
		if ((desc->sense_key_spec[0] & SSD_SKS_VALID) == 0)
4301
			goto bailout;
4302

4303
		bcopy(desc->sense_key_spec, sks, sizeof(desc->sense_key_spec));
4304
		break;
4305
	}
4306
	case SSD_TYPE_FIXED: {
4307
		struct scsi_sense_data_fixed *sense;
4308

4309
		sense = (struct scsi_sense_data_fixed *)sense_data;
4310

4311
		if ((SSD_FIXED_IS_PRESENT(sense, sense_len, sense_key_spec)== 0)
4312
		 || (SSD_FIXED_IS_FILLED(sense, sense_key_spec) == 0))
4313
			goto bailout;
4314

4315
		if ((sense->sense_key_spec[0] & SSD_SCS_VALID) == 0)
4316
			goto bailout;
4317

4318
		bcopy(sense->sense_key_spec, sks,sizeof(sense->sense_key_spec));
4319
		break;
4320
	}
4321
	default:
4322
		goto bailout;
4323
		break;
4324
	}
4325
	return (0);
4326
bailout:
4327
	return (1);
4328
}
4329

4330
/*
4331
 * Provide a common interface for fixed and descriptor sense to detect
4332
 * whether we have block-specific sense information.  It is clear by the
4333
 * presence of the block descriptor in descriptor mode, but we have to
4334
 * infer from the inquiry data and ILI bit in fixed mode.
4335
 */
4336
int
4337
scsi_get_block_info(struct scsi_sense_data *sense_data, u_int sense_len,
4338
		    struct scsi_inquiry_data *inq_data, uint8_t *block_bits)
4339
{
4340
	scsi_sense_data_type sense_type;
4341

4342
	if (inq_data != NULL) {
4343
		switch (SID_TYPE(inq_data)) {
4344
		case T_DIRECT:
4345
		case T_RBC:
4346
		case T_ZBC_HM:
4347
			break;
4348
		default:
4349
			goto bailout;
4350
			break;
4351
		}
4352
	}
4353

4354
	sense_type = scsi_sense_type(sense_data);
4355

4356
	switch (sense_type) {
4357
	case SSD_TYPE_DESC: {
4358
		struct scsi_sense_data_desc *sense;
4359
		struct scsi_sense_block *block;
4360

4361
		sense = (struct scsi_sense_data_desc *)sense_data;
4362

4363
		block = (struct scsi_sense_block *)scsi_find_desc(sense,
4364
		    sense_len, SSD_DESC_BLOCK);
4365
		if (block == NULL)
4366
			goto bailout;
4367

4368
		*block_bits = block->byte3;
4369
		break;
4370
	}
4371
	case SSD_TYPE_FIXED: {
4372
		struct scsi_sense_data_fixed *sense;
4373

4374
		sense = (struct scsi_sense_data_fixed *)sense_data;
4375

4376
		if (SSD_FIXED_IS_PRESENT(sense, sense_len, flags) == 0)
4377
			goto bailout;
4378

4379
		*block_bits = sense->flags & SSD_ILI;
4380
		break;
4381
	}
4382
	default:
4383
		goto bailout;
4384
		break;
4385
	}
4386
	return (0);
4387
bailout:
4388
	return (1);
4389
}
4390

4391
int
4392
scsi_get_stream_info(struct scsi_sense_data *sense_data, u_int sense_len,
4393
		     struct scsi_inquiry_data *inq_data, uint8_t *stream_bits)
4394
{
4395
	scsi_sense_data_type sense_type;
4396

4397
	if (inq_data != NULL) {
4398
		switch (SID_TYPE(inq_data)) {
4399
		case T_SEQUENTIAL:
4400
			break;
4401
		default:
4402
			goto bailout;
4403
			break;
4404
		}
4405
	}
4406

4407
	sense_type = scsi_sense_type(sense_data);
4408

4409
	switch (sense_type) {
4410
	case SSD_TYPE_DESC: {
4411
		struct scsi_sense_data_desc *sense;
4412
		struct scsi_sense_stream *stream;
4413

4414
		sense = (struct scsi_sense_data_desc *)sense_data;
4415

4416
		stream = (struct scsi_sense_stream *)scsi_find_desc(sense,
4417
		    sense_len, SSD_DESC_STREAM);
4418
		if (stream == NULL)
4419
			goto bailout;
4420

4421
		*stream_bits = stream->byte3;
4422
		break;
4423
	}
4424
	case SSD_TYPE_FIXED: {
4425
		struct scsi_sense_data_fixed *sense;
4426

4427
		sense = (struct scsi_sense_data_fixed *)sense_data;
4428

4429
		if (SSD_FIXED_IS_PRESENT(sense, sense_len, flags) == 0)
4430
			goto bailout;
4431

4432
		*stream_bits = sense->flags & (SSD_ILI|SSD_EOM|SSD_FILEMARK);
4433
		break;
4434
	}
4435
	default:
4436
		goto bailout;
4437
		break;
4438
	}
4439
	return (0);
4440
bailout:
4441
	return (1);
4442
}
4443

4444
void
4445
scsi_info_sbuf(struct sbuf *sb, uint8_t *cdb, int cdb_len,
4446
	       struct scsi_inquiry_data *inq_data, uint64_t info)
4447
{
4448
	sbuf_printf(sb, "Info: %#jx", info);
4449
}
4450

4451
void
4452
scsi_command_sbuf(struct sbuf *sb, uint8_t *cdb, int cdb_len,
4453
		  struct scsi_inquiry_data *inq_data, uint64_t csi)
4454
{
4455
	sbuf_printf(sb, "Command Specific Info: %#jx", csi);
4456
}
4457

4458
void
4459
scsi_progress_sbuf(struct sbuf *sb, uint16_t progress)
4460
{
4461
	sbuf_printf(sb, "Progress: %d%% (%d/%d) complete",
4462
		    (progress * 100) / SSD_SKS_PROGRESS_DENOM,
4463
		    progress, SSD_SKS_PROGRESS_DENOM);
4464
}
4465

4466
/*
4467
 * Returns 1 for failure (i.e. SKS isn't valid) and 0 for success.
4468
 */
4469
int
4470
scsi_sks_sbuf(struct sbuf *sb, int sense_key, uint8_t *sks)
4471
{
4472

4473
	switch (sense_key) {
4474
	case SSD_KEY_ILLEGAL_REQUEST: {
4475
		struct scsi_sense_sks_field *field;
4476
		int bad_command;
4477
		char tmpstr[40];
4478

4479
		/*Field Pointer*/
4480
		field = (struct scsi_sense_sks_field *)sks;
4481

4482
		if (field->byte0 & SSD_SKS_FIELD_CMD)
4483
			bad_command = 1;
4484
		else
4485
			bad_command = 0;
4486

4487
		tmpstr[0] = '\0';
4488

4489
		/* Bit pointer is valid */
4490
		if (field->byte0 & SSD_SKS_BPV)
4491
			snprintf(tmpstr, sizeof(tmpstr), "bit %d ",
4492
				 field->byte0 & SSD_SKS_BIT_VALUE);
4493

4494
		sbuf_printf(sb, "%s byte %d %sis invalid",
4495
			    bad_command ? "Command" : "Data",
4496
			    scsi_2btoul(field->field), tmpstr);
4497
		break;
4498
	}
4499
	case SSD_KEY_UNIT_ATTENTION: {
4500
		struct scsi_sense_sks_overflow *overflow;
4501

4502
		overflow = (struct scsi_sense_sks_overflow *)sks;
4503

4504
		/*UA Condition Queue Overflow*/
4505
		sbuf_printf(sb, "Unit Attention Condition Queue %s",
4506
			    (overflow->byte0 & SSD_SKS_OVERFLOW_SET) ?
4507
			    "Overflowed" : "Did Not Overflow??");
4508
		break;
4509
	}
4510
	case SSD_KEY_RECOVERED_ERROR:
4511
	case SSD_KEY_HARDWARE_ERROR:
4512
	case SSD_KEY_MEDIUM_ERROR: {
4513
		struct scsi_sense_sks_retry *retry;
4514

4515
		/*Actual Retry Count*/
4516
		retry = (struct scsi_sense_sks_retry *)sks;
4517

4518
		sbuf_printf(sb, "Actual Retry Count: %d",
4519
			    scsi_2btoul(retry->actual_retry_count));
4520
		break;
4521
	}
4522
	case SSD_KEY_NO_SENSE:
4523
	case SSD_KEY_NOT_READY: {
4524
		struct scsi_sense_sks_progress *progress;
4525
		int progress_val;
4526

4527
		/*Progress Indication*/
4528
		progress = (struct scsi_sense_sks_progress *)sks;
4529
		progress_val = scsi_2btoul(progress->progress);
4530

4531
		scsi_progress_sbuf(sb, progress_val);
4532
		break;
4533
	}
4534
	case SSD_KEY_COPY_ABORTED: {
4535
		struct scsi_sense_sks_segment *segment;
4536
		char tmpstr[40];
4537

4538
		/*Segment Pointer*/
4539
		segment = (struct scsi_sense_sks_segment *)sks;
4540

4541
		tmpstr[0] = '\0';
4542

4543
		if (segment->byte0 & SSD_SKS_SEGMENT_BPV)
4544
			snprintf(tmpstr, sizeof(tmpstr), "bit %d ",
4545
				 segment->byte0 & SSD_SKS_SEGMENT_BITPTR);
4546

4547
		sbuf_printf(sb, "%s byte %d %sis invalid", (segment->byte0 &
4548
			    SSD_SKS_SEGMENT_SD) ? "Segment" : "Data",
4549
			    scsi_2btoul(segment->field), tmpstr);
4550
		break;
4551
	}
4552
	default:
4553
		sbuf_printf(sb, "Sense Key Specific: %#x,%#x", sks[0],
4554
			    scsi_2btoul(&sks[1]));
4555
		break;
4556
	}
4557

4558
	return (0);
4559
}
4560

4561
void
4562
scsi_fru_sbuf(struct sbuf *sb, uint64_t fru)
4563
{
4564
	sbuf_printf(sb, "Field Replaceable Unit: %d", (int)fru);
4565
}
4566

4567
void
4568
scsi_stream_sbuf(struct sbuf *sb, uint8_t stream_bits)
4569
{
4570
	int need_comma;
4571

4572
	need_comma = 0;
4573
	/*
4574
	 * XXX KDM this needs more descriptive decoding.
4575
	 */
4576
	sbuf_cat(sb, "Stream Command Sense Data: ");
4577
	if (stream_bits & SSD_DESC_STREAM_FM) {
4578
		sbuf_cat(sb, "Filemark");
4579
		need_comma = 1;
4580
	}
4581

4582
	if (stream_bits & SSD_DESC_STREAM_EOM) {
4583
		sbuf_printf(sb, "%sEOM", (need_comma) ? "," : "");
4584
		need_comma = 1;
4585
	}
4586

4587
	if (stream_bits & SSD_DESC_STREAM_ILI)
4588
		sbuf_printf(sb, "%sILI", (need_comma) ? "," : "");
4589
}
4590

4591
void
4592
scsi_block_sbuf(struct sbuf *sb, uint8_t block_bits)
4593
{
4594

4595
	sbuf_cat(sb, "Block Command Sense Data: ");
4596
	if (block_bits & SSD_DESC_BLOCK_ILI)
4597
		sbuf_cat(sb, "ILI");
4598
}
4599

4600
void
4601
scsi_sense_info_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4602
		     u_int sense_len, uint8_t *cdb, int cdb_len,
4603
		     struct scsi_inquiry_data *inq_data,
4604
		     struct scsi_sense_desc_header *header)
4605
{
4606
	struct scsi_sense_info *info;
4607

4608
	info = (struct scsi_sense_info *)header;
4609

4610
	if ((info->byte2 & SSD_INFO_VALID) == 0)
4611
		return;
4612

4613
	scsi_info_sbuf(sb, cdb, cdb_len, inq_data, scsi_8btou64(info->info));
4614
}
4615

4616
void
4617
scsi_sense_command_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4618
			u_int sense_len, uint8_t *cdb, int cdb_len,
4619
			struct scsi_inquiry_data *inq_data,
4620
			struct scsi_sense_desc_header *header)
4621
{
4622
	struct scsi_sense_command *command;
4623

4624
	command = (struct scsi_sense_command *)header;
4625

4626
	scsi_command_sbuf(sb, cdb, cdb_len, inq_data,
4627
			  scsi_8btou64(command->command_info));
4628
}
4629

4630
void
4631
scsi_sense_sks_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4632
		    u_int sense_len, uint8_t *cdb, int cdb_len,
4633
		    struct scsi_inquiry_data *inq_data,
4634
		    struct scsi_sense_desc_header *header)
4635
{
4636
	struct scsi_sense_sks *sks;
4637
	int error_code, sense_key, asc, ascq;
4638

4639
	sks = (struct scsi_sense_sks *)header;
4640

4641
	if ((sks->sense_key_spec[0] & SSD_SKS_VALID) == 0)
4642
		return;
4643

4644
	scsi_extract_sense_len(sense, sense_len, &error_code, &sense_key,
4645
			       &asc, &ascq, /*show_errors*/ 1);
4646

4647
	scsi_sks_sbuf(sb, sense_key, sks->sense_key_spec);
4648
}
4649

4650
void
4651
scsi_sense_fru_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4652
		    u_int sense_len, uint8_t *cdb, int cdb_len,
4653
		    struct scsi_inquiry_data *inq_data,
4654
		    struct scsi_sense_desc_header *header)
4655
{
4656
	struct scsi_sense_fru *fru;
4657

4658
	fru = (struct scsi_sense_fru *)header;
4659

4660
	if (fru->fru == 0)
4661
		return;
4662

4663
	scsi_fru_sbuf(sb, (uint64_t)fru->fru);
4664
}
4665

4666
void
4667
scsi_sense_stream_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4668
		       u_int sense_len, uint8_t *cdb, int cdb_len,
4669
		       struct scsi_inquiry_data *inq_data,
4670
		       struct scsi_sense_desc_header *header)
4671
{
4672
	struct scsi_sense_stream *stream;
4673

4674
	stream = (struct scsi_sense_stream *)header;
4675
	scsi_stream_sbuf(sb, stream->byte3);
4676
}
4677

4678
void
4679
scsi_sense_block_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4680
		      u_int sense_len, uint8_t *cdb, int cdb_len,
4681
		      struct scsi_inquiry_data *inq_data,
4682
		      struct scsi_sense_desc_header *header)
4683
{
4684
	struct scsi_sense_block *block;
4685

4686
	block = (struct scsi_sense_block *)header;
4687
	scsi_block_sbuf(sb, block->byte3);
4688
}
4689

4690
void
4691
scsi_sense_progress_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4692
			 u_int sense_len, uint8_t *cdb, int cdb_len,
4693
			 struct scsi_inquiry_data *inq_data,
4694
			 struct scsi_sense_desc_header *header)
4695
{
4696
	struct scsi_sense_progress *progress;
4697
	const char *sense_key_desc;
4698
	const char *asc_desc;
4699
	int progress_val;
4700

4701
	progress = (struct scsi_sense_progress *)header;
4702

4703
	/*
4704
	 * Get descriptions for the sense key, ASC, and ASCQ in the
4705
	 * progress descriptor.  These could be different than the values
4706
	 * in the overall sense data.
4707
	 */
4708
	scsi_sense_desc(progress->sense_key, progress->add_sense_code,
4709
			progress->add_sense_code_qual, inq_data,
4710
			&sense_key_desc, &asc_desc);
4711

4712
	progress_val = scsi_2btoul(progress->progress);
4713

4714
	/*
4715
	 * The progress indicator is for the operation described by the
4716
	 * sense key, ASC, and ASCQ in the descriptor.
4717
	 */
4718
	sbuf_cat(sb, sense_key_desc);
4719
	sbuf_printf(sb, " asc:%x,%x (%s): ", progress->add_sense_code,
4720
		    progress->add_sense_code_qual, asc_desc);
4721
	scsi_progress_sbuf(sb, progress_val);
4722
}
4723

4724
void
4725
scsi_sense_ata_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4726
			 u_int sense_len, uint8_t *cdb, int cdb_len,
4727
			 struct scsi_inquiry_data *inq_data,
4728
			 struct scsi_sense_desc_header *header)
4729
{
4730
	struct scsi_sense_ata_ret_desc *res;
4731

4732
	res = (struct scsi_sense_ata_ret_desc *)header;
4733

4734
	sbuf_printf(sb, "ATA status: %02x (%s%s%s%s%s%s%s%s), ",
4735
	    res->status,
4736
	    (res->status & 0x80) ? "BSY " : "",
4737
	    (res->status & 0x40) ? "DRDY " : "",
4738
	    (res->status & 0x20) ? "DF " : "",
4739
	    (res->status & 0x10) ? "SERV " : "",
4740
	    (res->status & 0x08) ? "DRQ " : "",
4741
	    (res->status & 0x04) ? "CORR " : "",
4742
	    (res->status & 0x02) ? "IDX " : "",
4743
	    (res->status & 0x01) ? "ERR" : "");
4744
	if (res->status & 1) {
4745
	    sbuf_printf(sb, "error: %02x (%s%s%s%s%s%s%s%s), ",
4746
		res->error,
4747
		(res->error & 0x80) ? "ICRC " : "",
4748
		(res->error & 0x40) ? "UNC " : "",
4749
		(res->error & 0x20) ? "MC " : "",
4750
		(res->error & 0x10) ? "IDNF " : "",
4751
		(res->error & 0x08) ? "MCR " : "",
4752
		(res->error & 0x04) ? "ABRT " : "",
4753
		(res->error & 0x02) ? "NM " : "",
4754
		(res->error & 0x01) ? "ILI" : "");
4755
	}
4756

4757
	if (res->flags & SSD_DESC_ATA_FLAG_EXTEND) {
4758
		sbuf_printf(sb, "count: %02x%02x, ",
4759
		    res->count_15_8, res->count_7_0);
4760
		sbuf_printf(sb, "LBA: %02x%02x%02x%02x%02x%02x, ",
4761
		    res->lba_47_40, res->lba_39_32, res->lba_31_24,
4762
		    res->lba_23_16, res->lba_15_8, res->lba_7_0);
4763
	} else {
4764
		sbuf_printf(sb, "count: %02x, ", res->count_7_0);
4765
		sbuf_printf(sb, "LBA: %02x%02x%02x, ",
4766
		    res->lba_23_16, res->lba_15_8, res->lba_7_0);
4767
	}
4768
	sbuf_printf(sb, "device: %02x, ", res->device);
4769
}
4770

4771
void
4772
scsi_sense_forwarded_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4773
			 u_int sense_len, uint8_t *cdb, int cdb_len,
4774
			 struct scsi_inquiry_data *inq_data,
4775
			 struct scsi_sense_desc_header *header)
4776
{
4777
	struct scsi_sense_forwarded *forwarded;
4778
	const char *sense_key_desc;
4779
	const char *asc_desc;
4780
	int error_code, sense_key, asc, ascq;
4781

4782
	forwarded = (struct scsi_sense_forwarded *)header;
4783
	scsi_extract_sense_len((struct scsi_sense_data *)forwarded->sense_data,
4784
	    forwarded->length - 2, &error_code, &sense_key, &asc, &ascq, 1);
4785
	scsi_sense_desc(sense_key, asc, ascq, NULL, &sense_key_desc, &asc_desc);
4786

4787
	sbuf_printf(sb, "Forwarded sense: %s asc:%x,%x (%s): ",
4788
	    sense_key_desc, asc, ascq, asc_desc);
4789
}
4790

4791
void
4792
scsi_sense_dabd_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4793
		     u_int sense_len, uint8_t *cdb, int cdb_len,
4794
		     struct scsi_inquiry_data *inq_data,
4795
		     struct scsi_sense_desc_header *header)
4796
{
4797
	struct scsi_sense_direct_access_block_device *dabd;
4798
	int error_code, sense_key, asc, ascq;
4799

4800
	dabd = (struct scsi_sense_direct_access_block_device *)header;
4801

4802
	sbuf_printf(sb, "Direct Access Block Device: fru: %d ",
4803
	    dabd->fru);
4804
	if (dabd->sks_byte & SSD_DESC_DABD_SKS_VALID) {
4805
		scsi_extract_sense_len(sense, sense_len, &error_code, &sense_key,
4806
		    &asc, &ascq, /*show_errors*/ 1);
4807
		scsi_sks_sbuf(sb, sense_key, dabd->data);
4808
	}
4809
	if (dabd->byte2 & SSD_DESC_DABD_VALID) {
4810
		scsi_info_sbuf(sb, cdb, cdb_len, inq_data,
4811
		    scsi_8btou64(dabd->info));
4812
		scsi_command_sbuf(sb, cdb, cdb_len, inq_data,
4813
		    scsi_8btou64(dabd->command_info));
4814
	}
4815
}
4816

4817
/*
4818
 * Generic sense descriptor printing routine.  This is used when we have
4819
 * not yet implemented a specific printing routine for this descriptor.
4820
 */
4821
void
4822
scsi_sense_generic_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4823
			u_int sense_len, uint8_t *cdb, int cdb_len,
4824
			struct scsi_inquiry_data *inq_data,
4825
			struct scsi_sense_desc_header *header)
4826
{
4827
	int i;
4828
	uint8_t *buf_ptr;
4829

4830
	sbuf_printf(sb, "Descriptor %#x:", header->desc_type);
4831

4832
	buf_ptr = (uint8_t *)&header[1];
4833

4834
	for (i = 0; i < header->length; i++, buf_ptr++)
4835
		sbuf_printf(sb, " %02x", *buf_ptr);
4836
}
4837

4838
/*
4839
 * Keep this list in numeric order.  This speeds the array traversal.
4840
 */
4841
struct scsi_sense_desc_printer {
4842
	uint8_t desc_type;
4843
	/*
4844
	 * The function arguments here are the superset of what is needed
4845
	 * to print out various different descriptors.  Command and
4846
	 * information descriptors need inquiry data and command type.
4847
	 * Sense key specific descriptors need the sense key.
4848
	 *
4849
	 * The sense, cdb, and inquiry data arguments may be NULL, but the
4850
	 * information printed may not be fully decoded as a result.
4851
	 */
4852
	void (*print_func)(struct sbuf *sb, struct scsi_sense_data *sense,
4853
			   u_int sense_len, uint8_t *cdb, int cdb_len,
4854
			   struct scsi_inquiry_data *inq_data,
4855
			   struct scsi_sense_desc_header *header);
4856
} scsi_sense_printers[] = {
4857
	{SSD_DESC_INFO, scsi_sense_info_sbuf},
4858
	{SSD_DESC_COMMAND, scsi_sense_command_sbuf},
4859
	{SSD_DESC_SKS, scsi_sense_sks_sbuf},
4860
	{SSD_DESC_FRU, scsi_sense_fru_sbuf},
4861
	{SSD_DESC_STREAM, scsi_sense_stream_sbuf},
4862
	{SSD_DESC_BLOCK, scsi_sense_block_sbuf},
4863
	{SSD_DESC_ATA, scsi_sense_ata_sbuf},
4864
	{SSD_DESC_PROGRESS, scsi_sense_progress_sbuf},
4865
	{SSD_DESC_DABD, scsi_sense_dabd_sbuf},
4866
	{SSD_DESC_FORWARDED, scsi_sense_forwarded_sbuf},
4867
};
4868

4869
void
4870
scsi_sense_desc_sbuf(struct sbuf *sb, struct scsi_sense_data *sense,
4871
		     u_int sense_len, uint8_t *cdb, int cdb_len,
4872
		     struct scsi_inquiry_data *inq_data,
4873
		     struct scsi_sense_desc_header *header)
4874
{
4875
	u_int i;
4876

4877
	for (i = 0; i < nitems(scsi_sense_printers); i++) {
4878
		struct scsi_sense_desc_printer *printer;
4879

4880
		printer = &scsi_sense_printers[i];
4881

4882
		/*
4883
		 * The list is sorted, so quit if we've passed our
4884
		 * descriptor number.
4885
		 */
4886
		if (printer->desc_type > header->desc_type)
4887
			break;
4888

4889
		if (printer->desc_type != header->desc_type)
4890
			continue;
4891

4892
		printer->print_func(sb, sense, sense_len, cdb, cdb_len,
4893
				    inq_data, header);
4894

4895
		return;
4896
	}
4897

4898
	/*
4899
	 * No specific printing routine, so use the generic routine.
4900
	 */
4901
	scsi_sense_generic_sbuf(sb, sense, sense_len, cdb, cdb_len,
4902
				inq_data, header);
4903
}
4904

4905
scsi_sense_data_type
4906
scsi_sense_type(struct scsi_sense_data *sense_data)
4907
{
4908
	switch (sense_data->error_code & SSD_ERRCODE) {
4909
	case SSD_DESC_CURRENT_ERROR:
4910
	case SSD_DESC_DEFERRED_ERROR:
4911
		return (SSD_TYPE_DESC);
4912
		break;
4913
	case SSD_CURRENT_ERROR:
4914
	case SSD_DEFERRED_ERROR:
4915
		return (SSD_TYPE_FIXED);
4916
		break;
4917
	default:
4918
		break;
4919
	}
4920

4921
	return (SSD_TYPE_NONE);
4922
}
4923

4924
struct scsi_print_sense_info {
4925
	struct sbuf *sb;
4926
	char *path_str;
4927
	uint8_t *cdb;
4928
	int cdb_len;
4929
	struct scsi_inquiry_data *inq_data;
4930
};
4931

4932
static int
4933
scsi_print_desc_func(struct scsi_sense_data_desc *sense, u_int sense_len,
4934
		     struct scsi_sense_desc_header *header, void *arg)
4935
{
4936
	struct scsi_print_sense_info *print_info;
4937

4938
	print_info = (struct scsi_print_sense_info *)arg;
4939

4940
	switch (header->desc_type) {
4941
	case SSD_DESC_INFO:
4942
	case SSD_DESC_FRU:
4943
	case SSD_DESC_COMMAND:
4944
	case SSD_DESC_SKS:
4945
	case SSD_DESC_BLOCK:
4946
	case SSD_DESC_STREAM:
4947
		/*
4948
		 * We have already printed these descriptors, if they are
4949
		 * present.
4950
		 */
4951
		break;
4952
	default: {
4953
		sbuf_printf(print_info->sb, "%s", print_info->path_str);
4954
		scsi_sense_desc_sbuf(print_info->sb,
4955
				     (struct scsi_sense_data *)sense, sense_len,
4956
				     print_info->cdb, print_info->cdb_len,
4957
				     print_info->inq_data, header);
4958
		sbuf_putc(print_info->sb, '\n');
4959
		break;
4960
	}
4961
	}
4962

4963
	/*
4964
	 * Tell the iterator that we want to see more descriptors if they
4965
	 * are present.
4966
	 */
4967
	return (0);
4968
}
4969

4970
void
4971
scsi_sense_only_sbuf(struct scsi_sense_data *sense, u_int sense_len,
4972
		     struct sbuf *sb, char *path_str,
4973
		     struct scsi_inquiry_data *inq_data, uint8_t *cdb,
4974
		     int cdb_len)
4975
{
4976
	int error_code, sense_key, asc, ascq;
4977

4978
	sbuf_cat(sb, path_str);
4979

4980
	scsi_extract_sense_len(sense, sense_len, &error_code, &sense_key,
4981
			       &asc, &ascq, /*show_errors*/ 1);
4982

4983
	sbuf_cat(sb, "SCSI sense: ");
4984
	switch (error_code) {
4985
	case SSD_DEFERRED_ERROR:
4986
	case SSD_DESC_DEFERRED_ERROR:
4987
		sbuf_cat(sb, "Deferred error: ");
4988

4989
		/* FALLTHROUGH */
4990
	case SSD_CURRENT_ERROR:
4991
	case SSD_DESC_CURRENT_ERROR:
4992
	{
4993
		struct scsi_sense_data_desc *desc_sense;
4994
		struct scsi_print_sense_info print_info;
4995
		const char *sense_key_desc;
4996
		const char *asc_desc;
4997
		uint8_t sks[3];
4998
		uint64_t val;
4999
		uint8_t bits;
5000

5001
		/*
5002
		 * Get descriptions for the sense key, ASC, and ASCQ.  If
5003
		 * these aren't present in the sense data (i.e. the sense
5004
		 * data isn't long enough), the -1 values that
5005
		 * scsi_extract_sense_len() returns will yield default
5006
		 * or error descriptions.
5007
		 */
5008
		scsi_sense_desc(sense_key, asc, ascq, inq_data,
5009
				&sense_key_desc, &asc_desc);
5010

5011
		/*
5012
		 * We first print the sense key and ASC/ASCQ.
5013
		 */
5014
		sbuf_cat(sb, sense_key_desc);
5015
		sbuf_printf(sb, " asc:%x,%x (%s)\n", asc, ascq, asc_desc);
5016

5017
		/*
5018
		 * Print any block or stream device-specific information.
5019
		 */
5020
		if (scsi_get_block_info(sense, sense_len, inq_data,
5021
		    &bits) == 0 && bits != 0) {
5022
			sbuf_cat(sb, path_str);
5023
			scsi_block_sbuf(sb, bits);
5024
			sbuf_putc(sb, '\n');
5025
		} else if (scsi_get_stream_info(sense, sense_len, inq_data,
5026
		    &bits) == 0 && bits != 0) {
5027
			sbuf_cat(sb, path_str);
5028
			scsi_stream_sbuf(sb, bits);
5029
			sbuf_putc(sb, '\n');
5030
		}
5031

5032
		/*
5033
		 * Print the info field.
5034
		 */
5035
		if (scsi_get_sense_info(sense, sense_len, SSD_DESC_INFO,
5036
					&val, NULL) == 0) {
5037
			sbuf_cat(sb, path_str);
5038
			scsi_info_sbuf(sb, cdb, cdb_len, inq_data, val);
5039
			sbuf_putc(sb, '\n');
5040
		}
5041

5042
		/*
5043
		 * Print the FRU.
5044
		 */
5045
		if (scsi_get_sense_info(sense, sense_len, SSD_DESC_FRU,
5046
					&val, NULL) == 0) {
5047
			sbuf_cat(sb, path_str);
5048
			scsi_fru_sbuf(sb, val);
5049
			sbuf_putc(sb, '\n');
5050
		}
5051

5052
		/*
5053
		 * Print any command-specific information.
5054
		 */
5055
		if (scsi_get_sense_info(sense, sense_len, SSD_DESC_COMMAND,
5056
					&val, NULL) == 0) {
5057
			sbuf_cat(sb, path_str);
5058
			scsi_command_sbuf(sb, cdb, cdb_len, inq_data, val);
5059
			sbuf_putc(sb, '\n');
5060
		}
5061

5062
		/*
5063
		 * Print out any sense-key-specific information.
5064
		 */
5065
		if (scsi_get_sks(sense, sense_len, sks) == 0) {
5066
			sbuf_cat(sb, path_str);
5067
			scsi_sks_sbuf(sb, sense_key, sks);
5068
			sbuf_putc(sb, '\n');
5069
		}
5070

5071
		/*
5072
		 * If this is fixed sense, we're done.  If we have
5073
		 * descriptor sense, we might have more information
5074
		 * available.
5075
		 */
5076
		if (scsi_sense_type(sense) != SSD_TYPE_DESC)
5077
			break;
5078

5079
		desc_sense = (struct scsi_sense_data_desc *)sense;
5080

5081
		print_info.sb = sb;
5082
		print_info.path_str = path_str;
5083
		print_info.cdb = cdb;
5084
		print_info.cdb_len = cdb_len;
5085
		print_info.inq_data = inq_data;
5086

5087
		/*
5088
		 * Print any sense descriptors that we have not already printed.
5089
		 */
5090
		scsi_desc_iterate(desc_sense, sense_len, scsi_print_desc_func,
5091
				  &print_info);
5092
		break;
5093
	}
5094
	case -1:
5095
		/*
5096
		 * scsi_extract_sense_len() sets values to -1 if the
5097
		 * show_errors flag is set and they aren't present in the
5098
		 * sense data.  This means that sense_len is 0.
5099
		 */
5100
		sbuf_cat(sb, "No sense data present\n");
5101
		break;
5102
	default: {
5103
		sbuf_printf(sb, "Error code 0x%x", error_code);
5104
		if (sense->error_code & SSD_ERRCODE_VALID) {
5105
			struct scsi_sense_data_fixed *fixed_sense;
5106

5107
			fixed_sense = (struct scsi_sense_data_fixed *)sense;
5108

5109
			if (SSD_FIXED_IS_PRESENT(fixed_sense, sense_len, info)){
5110
				uint32_t info;
5111

5112
				info = scsi_4btoul(fixed_sense->info);
5113

5114
				sbuf_printf(sb, " at block no. %d (decimal)",
5115
					    info);
5116
			}
5117
		}
5118
		sbuf_putc(sb, '\n');
5119
		break;
5120
	}
5121
	}
5122
}
5123

5124
/*
5125
 * scsi_sense_sbuf() returns 0 for success and -1 for failure.
5126
 */
5127
#ifdef _KERNEL
5128
int
5129
scsi_sense_sbuf(struct ccb_scsiio *csio, struct sbuf *sb,
5130
		scsi_sense_string_flags flags)
5131
#else /* !_KERNEL */
5132
int
5133
scsi_sense_sbuf(struct cam_device *device, struct ccb_scsiio *csio,
5134
		struct sbuf *sb, scsi_sense_string_flags flags)
5135
#endif /* _KERNEL/!_KERNEL */
5136
{
5137
	struct	  scsi_sense_data *sense;
5138
	struct	  scsi_inquiry_data *inq_data;
5139
#ifdef _KERNEL
5140
	struct	  ccb_getdev *cgd;
5141
#endif /* _KERNEL */
5142
	char	  path_str[64];
5143

5144
#ifndef _KERNEL
5145
	if (device == NULL)
5146
		return(-1);
5147
#endif /* !_KERNEL */
5148
	if ((csio == NULL) || (sb == NULL))
5149
		return(-1);
5150

5151
	/*
5152
	 * If the CDB is a physical address, we can't deal with it..
5153
	 */
5154
	if ((csio->ccb_h.flags & CAM_CDB_PHYS) != 0)
5155
		flags &= ~SSS_FLAG_PRINT_COMMAND;
5156

5157
#ifdef _KERNEL
5158
	xpt_path_string(csio->ccb_h.path, path_str, sizeof(path_str));
5159
#else /* !_KERNEL */
5160
	cam_path_string(device, path_str, sizeof(path_str));
5161
#endif /* _KERNEL/!_KERNEL */
5162

5163
#ifdef _KERNEL
5164
	if ((cgd = (struct ccb_getdev*)xpt_alloc_ccb_nowait()) == NULL)
5165
		return(-1);
5166
	/*
5167
	 * Get the device information.
5168
	 */
5169
	xpt_gdev_type(cgd, csio->ccb_h.path);
5170

5171
	/*
5172
	 * If the device is unconfigured, the inq data is invalid.
5173
	 */
5174
	if (cgd->ccb_h.status == CAM_DEV_NOT_THERE)
5175
		inq_data = NULL;
5176
	else
5177
		inq_data = &cgd->inq_data;
5178

5179
#else /* !_KERNEL */
5180

5181
	inq_data = &device->inq_data;
5182

5183
#endif /* _KERNEL/!_KERNEL */
5184

5185
	sense = NULL;
5186

5187
	if (flags & SSS_FLAG_PRINT_COMMAND) {
5188
		sbuf_cat(sb, path_str);
5189

5190
#ifdef _KERNEL
5191
		scsi_command_string(csio, sb);
5192
#else /* !_KERNEL */
5193
		scsi_command_string(device, csio, sb);
5194
#endif /* _KERNEL/!_KERNEL */
5195
		sbuf_putc(sb, '\n');
5196
	}
5197

5198
	/*
5199
	 * If the sense data is a physical pointer, forget it.
5200
	 */
5201
	if (csio->ccb_h.flags & CAM_SENSE_PTR) {
5202
		if (csio->ccb_h.flags & CAM_SENSE_PHYS) {
5203
#ifdef _KERNEL
5204
			xpt_free_ccb((union ccb*)cgd);
5205
#endif /* _KERNEL/!_KERNEL */
5206
			return(-1);
5207
		} else {
5208
			/*
5209
			 * bcopy the pointer to avoid unaligned access
5210
			 * errors on finicky architectures.  We don't
5211
			 * ensure that the sense data is pointer aligned.
5212
			 */
5213
			bcopy((struct scsi_sense_data **)&csio->sense_data,
5214
			    &sense, sizeof(struct scsi_sense_data *));
5215
		}
5216
	} else {
5217
		/*
5218
		 * If the physical sense flag is set, but the sense pointer
5219
		 * is not also set, we assume that the user is an idiot and
5220
		 * return.  (Well, okay, it could be that somehow, the
5221
		 * entire csio is physical, but we would have probably core
5222
		 * dumped on one of the bogus pointer deferences above
5223
		 * already.)
5224
		 */
5225
		if (csio->ccb_h.flags & CAM_SENSE_PHYS) {
5226
#ifdef _KERNEL
5227
			xpt_free_ccb((union ccb*)cgd);
5228
#endif /* _KERNEL/!_KERNEL */
5229
			return(-1);
5230
		} else
5231
			sense = &csio->sense_data;
5232
	}
5233

5234
	scsi_sense_only_sbuf(sense, csio->sense_len - csio->sense_resid, sb,
5235
	    path_str, inq_data, scsiio_cdb_ptr(csio), csio->cdb_len);
5236

5237
#ifdef _KERNEL
5238
	xpt_free_ccb((union ccb*)cgd);
5239
#endif /* _KERNEL/!_KERNEL */
5240
	return(0);
5241
}
5242

5243
#ifdef _KERNEL
5244
char *
5245
scsi_sense_string(struct ccb_scsiio *csio, char *str, int str_len)
5246
#else /* !_KERNEL */
5247
char *
5248
scsi_sense_string(struct cam_device *device, struct ccb_scsiio *csio,
5249
		  char *str, int str_len)
5250
#endif /* _KERNEL/!_KERNEL */
5251
{
5252
	struct sbuf sb;
5253

5254
	sbuf_new(&sb, str, str_len, 0);
5255

5256
#ifdef _KERNEL
5257
	scsi_sense_sbuf(csio, &sb, SSS_FLAG_PRINT_COMMAND);
5258
#else /* !_KERNEL */
5259
	scsi_sense_sbuf(device, csio, &sb, SSS_FLAG_PRINT_COMMAND);
5260
#endif /* _KERNEL/!_KERNEL */
5261

5262
	sbuf_finish(&sb);
5263

5264
	return(sbuf_data(&sb));
5265
}
5266

5267
#ifdef _KERNEL
5268
void
5269
scsi_sense_print(struct ccb_scsiio *csio)
5270
{
5271
	struct sbuf sb;
5272
	char str[512];
5273

5274
	sbuf_new(&sb, str, sizeof(str), 0);
5275

5276
	scsi_sense_sbuf(csio, &sb, SSS_FLAG_PRINT_COMMAND);
5277

5278
	sbuf_finish(&sb);
5279

5280
	sbuf_putbuf(&sb);
5281
}
5282

5283
#else /* !_KERNEL */
5284
void
5285
scsi_sense_print(struct cam_device *device, struct ccb_scsiio *csio,
5286
		 FILE *ofile)
5287
{
5288
	struct sbuf sb;
5289
	char str[512];
5290

5291
	if ((device == NULL) || (csio == NULL) || (ofile == NULL))
5292
		return;
5293

5294
	sbuf_new(&sb, str, sizeof(str), 0);
5295

5296
	scsi_sense_sbuf(device, csio, &sb, SSS_FLAG_PRINT_COMMAND);
5297

5298
	sbuf_finish(&sb);
5299

5300
	fprintf(ofile, "%s", sbuf_data(&sb));
5301
}
5302

5303
#endif /* _KERNEL/!_KERNEL */
5304

5305
/*
5306
 * Extract basic sense information.  This is backward-compatible with the
5307
 * previous implementation.  For new implementations,
5308
 * scsi_extract_sense_len() is recommended.
5309
 */
5310
void
5311
scsi_extract_sense(struct scsi_sense_data *sense_data, int *error_code,
5312
		   int *sense_key, int *asc, int *ascq)
5313
{
5314
	scsi_extract_sense_len(sense_data, sizeof(*sense_data), error_code,
5315
			       sense_key, asc, ascq, /*show_errors*/ 0);
5316
}
5317

5318
/*
5319
 * Extract basic sense information from SCSI I/O CCB structure.
5320
 */
5321
int
5322
scsi_extract_sense_ccb(union ccb *ccb,
5323
    int *error_code, int *sense_key, int *asc, int *ascq)
5324
{
5325
	struct scsi_sense_data *sense_data;
5326

5327
	/* Make sure there are some sense data we can access. */
5328
	if (ccb->ccb_h.func_code != XPT_SCSI_IO ||
5329
	    (ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_SCSI_STATUS_ERROR ||
5330
	    (ccb->csio.scsi_status != SCSI_STATUS_CHECK_COND) ||
5331
	    (ccb->ccb_h.status & CAM_AUTOSNS_VALID) == 0 ||
5332
	    (ccb->ccb_h.flags & CAM_SENSE_PHYS))
5333
		return (0);
5334

5335
	if (ccb->ccb_h.flags & CAM_SENSE_PTR)
5336
		bcopy((struct scsi_sense_data **)&ccb->csio.sense_data,
5337
		    &sense_data, sizeof(struct scsi_sense_data *));
5338
	else
5339
		sense_data = &ccb->csio.sense_data;
5340
	scsi_extract_sense_len(sense_data,
5341
	    ccb->csio.sense_len - ccb->csio.sense_resid,
5342
	    error_code, sense_key, asc, ascq, 1);
5343
	if (*error_code == -1)
5344
		return (0);
5345
	return (1);
5346
}
5347

5348
/*
5349
 * Extract basic sense information.  If show_errors is set, sense values
5350
 * will be set to -1 if they are not present.
5351
 */
5352
void
5353
scsi_extract_sense_len(struct scsi_sense_data *sense_data, u_int sense_len,
5354
		       int *error_code, int *sense_key, int *asc, int *ascq,
5355
		       int show_errors)
5356
{
5357
	/*
5358
	 * If we have no length, we have no sense.
5359
	 */
5360
	if (sense_len == 0) {
5361
		if (show_errors == 0) {
5362
			*error_code = 0;
5363
			*sense_key = 0;
5364
			*asc = 0;
5365
			*ascq = 0;
5366
		} else {
5367
			*error_code = -1;
5368
			*sense_key = -1;
5369
			*asc = -1;
5370
			*ascq = -1;
5371
		}
5372
		return;
5373
	}
5374

5375
	*error_code = sense_data->error_code & SSD_ERRCODE;
5376

5377
	switch (*error_code) {
5378
	case SSD_DESC_CURRENT_ERROR:
5379
	case SSD_DESC_DEFERRED_ERROR: {
5380
		struct scsi_sense_data_desc *sense;
5381

5382
		sense = (struct scsi_sense_data_desc *)sense_data;
5383

5384
		if (SSD_DESC_IS_PRESENT(sense, sense_len, sense_key))
5385
			*sense_key = sense->sense_key & SSD_KEY;
5386
		else
5387
			*sense_key = (show_errors) ? -1 : 0;
5388

5389
		if (SSD_DESC_IS_PRESENT(sense, sense_len, add_sense_code))
5390
			*asc = sense->add_sense_code;
5391
		else
5392
			*asc = (show_errors) ? -1 : 0;
5393

5394
		if (SSD_DESC_IS_PRESENT(sense, sense_len, add_sense_code_qual))
5395
			*ascq = sense->add_sense_code_qual;
5396
		else
5397
			*ascq = (show_errors) ? -1 : 0;
5398
		break;
5399
	}
5400
	case SSD_CURRENT_ERROR:
5401
	case SSD_DEFERRED_ERROR:
5402
	default: {
5403
		struct scsi_sense_data_fixed *sense;
5404

5405
		sense = (struct scsi_sense_data_fixed *)sense_data;
5406

5407
		if (SSD_FIXED_IS_PRESENT(sense, sense_len, flags))
5408
			*sense_key = sense->flags & SSD_KEY;
5409
		else
5410
			*sense_key = (show_errors) ? -1 : 0;
5411

5412
		if ((SSD_FIXED_IS_PRESENT(sense, sense_len, add_sense_code))
5413
		 && (SSD_FIXED_IS_FILLED(sense, add_sense_code)))
5414
			*asc = sense->add_sense_code;
5415
		else
5416
			*asc = (show_errors) ? -1 : 0;
5417

5418
		if ((SSD_FIXED_IS_PRESENT(sense, sense_len,add_sense_code_qual))
5419
		 && (SSD_FIXED_IS_FILLED(sense, add_sense_code_qual)))
5420
			*ascq = sense->add_sense_code_qual;
5421
		else
5422
			*ascq = (show_errors) ? -1 : 0;
5423
		break;
5424
	}
5425
	}
5426
}
5427

5428
int
5429
scsi_get_sense_key(struct scsi_sense_data *sense_data, u_int sense_len,
5430
		   int show_errors)
5431
{
5432
	int error_code, sense_key, asc, ascq;
5433

5434
	scsi_extract_sense_len(sense_data, sense_len, &error_code,
5435
			       &sense_key, &asc, &ascq, show_errors);
5436

5437
	return (sense_key);
5438
}
5439

5440
int
5441
scsi_get_asc(struct scsi_sense_data *sense_data, u_int sense_len,
5442
	     int show_errors)
5443
{
5444
	int error_code, sense_key, asc, ascq;
5445

5446
	scsi_extract_sense_len(sense_data, sense_len, &error_code,
5447
			       &sense_key, &asc, &ascq, show_errors);
5448

5449
	return (asc);
5450
}
5451

5452
int
5453
scsi_get_ascq(struct scsi_sense_data *sense_data, u_int sense_len,
5454
	      int show_errors)
5455
{
5456
	int error_code, sense_key, asc, ascq;
5457

5458
	scsi_extract_sense_len(sense_data, sense_len, &error_code,
5459
			       &sense_key, &asc, &ascq, show_errors);
5460

5461
	return (ascq);
5462
}
5463

5464
/*
5465
 * This function currently requires at least 36 bytes, or
5466
 * SHORT_INQUIRY_LENGTH, worth of data to function properly.  If this
5467
 * function needs more or less data in the future, another length should be
5468
 * defined in scsi_all.h to indicate the minimum amount of data necessary
5469
 * for this routine to function properly.
5470
 */
5471
void
5472
scsi_print_inquiry_sbuf(struct sbuf *sb, struct scsi_inquiry_data *inq_data)
5473
{
5474
	uint8_t type;
5475
	char *dtype, *qtype;
5476

5477
	type = SID_TYPE(inq_data);
5478

5479
	/*
5480
	 * Figure out basic device type and qualifier.
5481
	 */
5482
	if (SID_QUAL_IS_VENDOR_UNIQUE(inq_data)) {
5483
		qtype = " (vendor-unique qualifier)";
5484
	} else {
5485
		switch (SID_QUAL(inq_data)) {
5486
		case SID_QUAL_LU_CONNECTED:
5487
			qtype = "";
5488
			break;
5489

5490
		case SID_QUAL_LU_OFFLINE:
5491
			qtype = " (offline)";
5492
			break;
5493

5494
		case SID_QUAL_RSVD:
5495
			qtype = " (reserved qualifier)";
5496
			break;
5497
		default:
5498
		case SID_QUAL_BAD_LU:
5499
			qtype = " (LUN not supported)";
5500
			break;
5501
		}
5502
	}
5503

5504
	switch (type) {
5505
	case T_DIRECT:
5506
		dtype = "Direct Access";
5507
		break;
5508
	case T_SEQUENTIAL:
5509
		dtype = "Sequential Access";
5510
		break;
5511
	case T_PRINTER:
5512
		dtype = "Printer";
5513
		break;
5514
	case T_PROCESSOR:
5515
		dtype = "Processor";
5516
		break;
5517
	case T_WORM:
5518
		dtype = "WORM";
5519
		break;
5520
	case T_CDROM:
5521
		dtype = "CD-ROM";
5522
		break;
5523
	case T_SCANNER:
5524
		dtype = "Scanner";
5525
		break;
5526
	case T_OPTICAL:
5527
		dtype = "Optical";
5528
		break;
5529
	case T_CHANGER:
5530
		dtype = "Changer";
5531
		break;
5532
	case T_COMM:
5533
		dtype = "Communication";
5534
		break;
5535
	case T_STORARRAY:
5536
		dtype = "Storage Array";
5537
		break;
5538
	case T_ENCLOSURE:
5539
		dtype = "Enclosure Services";
5540
		break;
5541
	case T_RBC:
5542
		dtype = "Simplified Direct Access";
5543
		break;
5544
	case T_OCRW:
5545
		dtype = "Optical Card Read/Write";
5546
		break;
5547
	case T_OSD:
5548
		dtype = "Object-Based Storage";
5549
		break;
5550
	case T_ADC:
5551
		dtype = "Automation/Drive Interface";
5552
		break;
5553
	case T_ZBC_HM:
5554
		dtype = "Host Managed Zoned Block";
5555
		break;
5556
	case T_NODEVICE:
5557
		dtype = "Uninstalled";
5558
		break;
5559
	default:
5560
		dtype = "unknown";
5561
		break;
5562
	}
5563

5564
	scsi_print_inquiry_short_sbuf(sb, inq_data);
5565

5566
	sbuf_printf(sb, "%s %s ", SID_IS_REMOVABLE(inq_data) ? "Removable" : "Fixed", dtype);
5567

5568
	if (SID_ANSI_REV(inq_data) == SCSI_REV_0)
5569
		sbuf_cat(sb, "SCSI ");
5570
	else if (SID_ANSI_REV(inq_data) <= SCSI_REV_SPC) {
5571
		sbuf_printf(sb, "SCSI-%d ", SID_ANSI_REV(inq_data));
5572
	} else {
5573
		sbuf_printf(sb, "SPC-%d SCSI ", SID_ANSI_REV(inq_data) - 2);
5574
	}
5575
	sbuf_printf(sb, "device%s\n", qtype);
5576
}
5577

5578
void
5579
scsi_print_inquiry(struct scsi_inquiry_data *inq_data)
5580
{
5581
	struct sbuf	sb;
5582
	char		buffer[120];
5583

5584
	sbuf_new(&sb, buffer, 120, SBUF_FIXEDLEN);
5585
	scsi_print_inquiry_sbuf(&sb, inq_data);
5586
	sbuf_finish(&sb);
5587
	sbuf_putbuf(&sb);
5588
}
5589

5590
void
5591
scsi_print_inquiry_short_sbuf(struct sbuf *sb, struct scsi_inquiry_data *inq_data)
5592
{
5593

5594
	sbuf_putc(sb, '<');
5595
	cam_strvis_sbuf(sb, inq_data->vendor, sizeof(inq_data->vendor), 0);
5596
	sbuf_putc(sb, ' ');
5597
	cam_strvis_sbuf(sb, inq_data->product, sizeof(inq_data->product), 0);
5598
	sbuf_putc(sb, ' ');
5599
	cam_strvis_sbuf(sb, inq_data->revision, sizeof(inq_data->revision), 0);
5600
	sbuf_cat(sb, "> ");
5601
}
5602

5603
void
5604
scsi_print_inquiry_short(struct scsi_inquiry_data *inq_data)
5605
{
5606
	struct sbuf	sb;
5607
	char		buffer[84];
5608

5609
	sbuf_new(&sb, buffer, 84, SBUF_FIXEDLEN);
5610
	scsi_print_inquiry_short_sbuf(&sb, inq_data);
5611
	sbuf_finish(&sb);
5612
	sbuf_putbuf(&sb);
5613
}
5614

5615
/*
5616
 * Table of syncrates that don't follow the "divisible by 4"
5617
 * rule. This table will be expanded in future SCSI specs.
5618
 */
5619
static struct {
5620
	u_int period_factor;
5621
	u_int period;	/* in 100ths of ns */
5622
} scsi_syncrates[] = {
5623
	{ 0x08, 625 },	/* FAST-160 */
5624
	{ 0x09, 1250 },	/* FAST-80 */
5625
	{ 0x0a, 2500 },	/* FAST-40 40MHz */
5626
	{ 0x0b, 3030 },	/* FAST-40 33MHz */
5627
	{ 0x0c, 5000 }	/* FAST-20 */
5628
};
5629

5630
/*
5631
 * Return the frequency in kHz corresponding to the given
5632
 * sync period factor.
5633
 */
5634
u_int
5635
scsi_calc_syncsrate(u_int period_factor)
5636
{
5637
	u_int i;
5638
	u_int num_syncrates;
5639

5640
	/*
5641
	 * It's a bug if period is zero, but if it is anyway, don't
5642
	 * die with a divide fault- instead return something which
5643
	 * 'approximates' async
5644
	 */
5645
	if (period_factor == 0) {
5646
		return (3300);
5647
	}
5648

5649
	num_syncrates = nitems(scsi_syncrates);
5650
	/* See if the period is in the "exception" table */
5651
	for (i = 0; i < num_syncrates; i++) {
5652
		if (period_factor == scsi_syncrates[i].period_factor) {
5653
			/* Period in kHz */
5654
			return (100000000 / scsi_syncrates[i].period);
5655
		}
5656
	}
5657

5658
	/*
5659
	 * Wasn't in the table, so use the standard
5660
	 * 4 times conversion.
5661
	 */
5662
	return (10000000 / (period_factor * 4 * 10));
5663
}
5664

5665
/*
5666
 * Return the SCSI sync parameter that corresponds to
5667
 * the passed in period in 10ths of ns.
5668
 */
5669
u_int
5670
scsi_calc_syncparam(u_int period)
5671
{
5672
	u_int i;
5673
	u_int num_syncrates;
5674

5675
	if (period == 0)
5676
		return (~0);	/* Async */
5677

5678
	/* Adjust for exception table being in 100ths. */
5679
	period *= 10;
5680
	num_syncrates = nitems(scsi_syncrates);
5681
	/* See if the period is in the "exception" table */
5682
	for (i = 0; i < num_syncrates; i++) {
5683
		if (period <= scsi_syncrates[i].period) {
5684
			/* Period in 100ths of ns */
5685
			return (scsi_syncrates[i].period_factor);
5686
		}
5687
	}
5688

5689
	/*
5690
	 * Wasn't in the table, so use the standard
5691
	 * 1/4 period in ns conversion.
5692
	 */
5693
	return (period/400);
5694
}
5695

5696
int
5697
scsi_devid_is_naa_ieee_reg(uint8_t *bufp)
5698
{
5699
	struct scsi_vpd_id_descriptor *descr;
5700
	struct scsi_vpd_id_naa_basic *naa;
5701
	int n;
5702

5703
	descr = (struct scsi_vpd_id_descriptor *)bufp;
5704
	naa = (struct scsi_vpd_id_naa_basic *)descr->identifier;
5705
	if ((descr->id_type & SVPD_ID_TYPE_MASK) != SVPD_ID_TYPE_NAA)
5706
		return 0;
5707
	if (descr->length < sizeof(struct scsi_vpd_id_naa_ieee_reg))
5708
		return 0;
5709
	n = naa->naa >> SVPD_ID_NAA_NAA_SHIFT;
5710
	if (n != SVPD_ID_NAA_LOCAL_REG && n != SVPD_ID_NAA_IEEE_REG)
5711
		return 0;
5712
	return 1;
5713
}
5714

5715
int
5716
scsi_devid_is_sas_target(uint8_t *bufp)
5717
{
5718
	struct scsi_vpd_id_descriptor *descr;
5719

5720
	descr = (struct scsi_vpd_id_descriptor *)bufp;
5721
	if (!scsi_devid_is_naa_ieee_reg(bufp))
5722
		return 0;
5723
	if ((descr->id_type & SVPD_ID_PIV) == 0) /* proto field reserved */
5724
		return 0;
5725
	if ((descr->proto_codeset >> SVPD_ID_PROTO_SHIFT) != SCSI_PROTO_SAS)
5726
		return 0;
5727
	return 1;
5728
}
5729

5730
int
5731
scsi_devid_is_lun_eui64(uint8_t *bufp)
5732
{
5733
	struct scsi_vpd_id_descriptor *descr;
5734

5735
	descr = (struct scsi_vpd_id_descriptor *)bufp;
5736
	if ((descr->id_type & SVPD_ID_ASSOC_MASK) != SVPD_ID_ASSOC_LUN)
5737
		return 0;
5738
	if ((descr->id_type & SVPD_ID_TYPE_MASK) != SVPD_ID_TYPE_EUI64)
5739
		return 0;
5740
	return 1;
5741
}
5742

5743
int
5744
scsi_devid_is_lun_naa(uint8_t *bufp)
5745
{
5746
	struct scsi_vpd_id_descriptor *descr;
5747

5748
	descr = (struct scsi_vpd_id_descriptor *)bufp;
5749
	if ((descr->id_type & SVPD_ID_ASSOC_MASK) != SVPD_ID_ASSOC_LUN)
5750
		return 0;
5751
	if ((descr->id_type & SVPD_ID_TYPE_MASK) != SVPD_ID_TYPE_NAA)
5752
		return 0;
5753
	return 1;
5754
}
5755

5756
int
5757
scsi_devid_is_lun_t10(uint8_t *bufp)
5758
{
5759
	struct scsi_vpd_id_descriptor *descr;
5760

5761
	descr = (struct scsi_vpd_id_descriptor *)bufp;
5762
	if ((descr->id_type & SVPD_ID_ASSOC_MASK) != SVPD_ID_ASSOC_LUN)
5763
		return 0;
5764
	if ((descr->id_type & SVPD_ID_TYPE_MASK) != SVPD_ID_TYPE_T10)
5765
		return 0;
5766
	return 1;
5767
}
5768

5769
int
5770
scsi_devid_is_lun_name(uint8_t *bufp)
5771
{
5772
	struct scsi_vpd_id_descriptor *descr;
5773

5774
	descr = (struct scsi_vpd_id_descriptor *)bufp;
5775
	if ((descr->id_type & SVPD_ID_ASSOC_MASK) != SVPD_ID_ASSOC_LUN)
5776
		return 0;
5777
	if ((descr->id_type & SVPD_ID_TYPE_MASK) != SVPD_ID_TYPE_SCSI_NAME)
5778
		return 0;
5779
	return 1;
5780
}
5781

5782
int
5783
scsi_devid_is_lun_md5(uint8_t *bufp)
5784
{
5785
	struct scsi_vpd_id_descriptor *descr;
5786

5787
	descr = (struct scsi_vpd_id_descriptor *)bufp;
5788
	if ((descr->id_type & SVPD_ID_ASSOC_MASK) != SVPD_ID_ASSOC_LUN)
5789
		return 0;
5790
	if ((descr->id_type & SVPD_ID_TYPE_MASK) != SVPD_ID_TYPE_MD5_LUN_ID)
5791
		return 0;
5792
	return 1;
5793
}
5794

5795
int
5796
scsi_devid_is_lun_uuid(uint8_t *bufp)
5797
{
5798
	struct scsi_vpd_id_descriptor *descr;
5799

5800
	descr = (struct scsi_vpd_id_descriptor *)bufp;
5801
	if ((descr->id_type & SVPD_ID_ASSOC_MASK) != SVPD_ID_ASSOC_LUN)
5802
		return 0;
5803
	if ((descr->id_type & SVPD_ID_TYPE_MASK) != SVPD_ID_TYPE_UUID)
5804
		return 0;
5805
	return 1;
5806
}
5807

5808
int
5809
scsi_devid_is_port_naa(uint8_t *bufp)
5810
{
5811
	struct scsi_vpd_id_descriptor *descr;
5812

5813
	descr = (struct scsi_vpd_id_descriptor *)bufp;
5814
	if ((descr->id_type & SVPD_ID_ASSOC_MASK) != SVPD_ID_ASSOC_PORT)
5815
		return 0;
5816
	if ((descr->id_type & SVPD_ID_TYPE_MASK) != SVPD_ID_TYPE_NAA)
5817
		return 0;
5818
	return 1;
5819
}
5820

5821
struct scsi_vpd_id_descriptor *
5822
scsi_get_devid_desc(struct scsi_vpd_id_descriptor *desc, uint32_t len,
5823
    scsi_devid_checkfn_t ck_fn)
5824
{
5825
	uint8_t *desc_buf_end;
5826

5827
	desc_buf_end = (uint8_t *)desc + len;
5828

5829
	for (; desc->identifier <= desc_buf_end &&
5830
	    desc->identifier + desc->length <= desc_buf_end;
5831
	    desc = (struct scsi_vpd_id_descriptor *)(desc->identifier
5832
						    + desc->length)) {
5833
		if (ck_fn == NULL || ck_fn((uint8_t *)desc) != 0)
5834
			return (desc);
5835
	}
5836
	return (NULL);
5837
}
5838

5839
struct scsi_vpd_id_descriptor *
5840
scsi_get_devid(struct scsi_vpd_device_id *id, uint32_t page_len,
5841
    scsi_devid_checkfn_t ck_fn)
5842
{
5843
	uint32_t len;
5844

5845
	if (page_len < sizeof(*id))
5846
		return (NULL);
5847
	len = MIN(scsi_2btoul(id->length), page_len - sizeof(*id));
5848
	return (scsi_get_devid_desc((struct scsi_vpd_id_descriptor *)
5849
	    id->desc_list, len, ck_fn));
5850
}
5851

5852
int
5853
scsi_transportid_sbuf(struct sbuf *sb, struct scsi_transportid_header *hdr,
5854
		      uint32_t valid_len)
5855
{
5856
	switch (hdr->format_protocol & SCSI_TRN_PROTO_MASK) {
5857
	case SCSI_PROTO_FC: {
5858
		struct scsi_transportid_fcp *fcp;
5859
		uint64_t n_port_name;
5860

5861
		fcp = (struct scsi_transportid_fcp *)hdr;
5862

5863
		n_port_name = scsi_8btou64(fcp->n_port_name);
5864

5865
		sbuf_printf(sb, "FCP address: 0x%.16jx",(uintmax_t)n_port_name);
5866
		break;
5867
	}
5868
	case SCSI_PROTO_SPI: {
5869
		struct scsi_transportid_spi *spi;
5870

5871
		spi = (struct scsi_transportid_spi *)hdr;
5872

5873
		sbuf_printf(sb, "SPI address: %u,%u",
5874
			    scsi_2btoul(spi->scsi_addr),
5875
			    scsi_2btoul(spi->rel_trgt_port_id));
5876
		break;
5877
	}
5878
	case SCSI_PROTO_SSA:
5879
		/*
5880
		 * XXX KDM there is no transport ID defined in SPC-4 for
5881
		 * SSA.
5882
		 */
5883
		break;
5884
	case SCSI_PROTO_1394: {
5885
		struct scsi_transportid_1394 *sbp;
5886
		uint64_t eui64;
5887

5888
		sbp = (struct scsi_transportid_1394 *)hdr;
5889

5890
		eui64 = scsi_8btou64(sbp->eui64);
5891
		sbuf_printf(sb, "SBP address: 0x%.16jx", (uintmax_t)eui64);
5892
		break;
5893
	}
5894
	case SCSI_PROTO_RDMA: {
5895
		struct scsi_transportid_rdma *rdma;
5896
		unsigned int i;
5897

5898
		rdma = (struct scsi_transportid_rdma *)hdr;
5899

5900
		sbuf_cat(sb, "RDMA address: 0x");
5901
		for (i = 0; i < sizeof(rdma->initiator_port_id); i++)
5902
			sbuf_printf(sb, "%02x", rdma->initiator_port_id[i]);
5903
		break;
5904
	}
5905
	case SCSI_PROTO_ISCSI: {
5906
		uint32_t add_len, i;
5907
		uint8_t *iscsi_name = NULL;
5908
		int nul_found = 0;
5909

5910
		sbuf_cat(sb, "iSCSI address: ");
5911
		if ((hdr->format_protocol & SCSI_TRN_FORMAT_MASK) ==
5912
		    SCSI_TRN_ISCSI_FORMAT_DEVICE) {
5913
			struct scsi_transportid_iscsi_device *dev;
5914

5915
			dev = (struct scsi_transportid_iscsi_device *)hdr;
5916

5917
			/*
5918
			 * Verify how much additional data we really have.
5919
			 */
5920
			add_len = scsi_2btoul(dev->additional_length);
5921
			add_len = MIN(add_len, valid_len -
5922
				__offsetof(struct scsi_transportid_iscsi_device,
5923
					   iscsi_name));
5924
			iscsi_name = &dev->iscsi_name[0];
5925

5926
		} else if ((hdr->format_protocol & SCSI_TRN_FORMAT_MASK) ==
5927
			    SCSI_TRN_ISCSI_FORMAT_PORT) {
5928
			struct scsi_transportid_iscsi_port *port;
5929

5930
			port = (struct scsi_transportid_iscsi_port *)hdr;
5931

5932
			add_len = scsi_2btoul(port->additional_length);
5933
			add_len = MIN(add_len, valid_len -
5934
				__offsetof(struct scsi_transportid_iscsi_port,
5935
					   iscsi_name));
5936
			iscsi_name = &port->iscsi_name[0];
5937
		} else {
5938
			sbuf_printf(sb, "unknown format %x",
5939
				    (hdr->format_protocol &
5940
				     SCSI_TRN_FORMAT_MASK) >>
5941
				     SCSI_TRN_FORMAT_SHIFT);
5942
			break;
5943
		}
5944
		if (add_len == 0) {
5945
			sbuf_cat(sb, "not enough data");
5946
			break;
5947
		}
5948
		/*
5949
		 * This is supposed to be a NUL-terminated ASCII
5950
		 * string, but you never know.  So we're going to
5951
		 * check.  We need to do this because there is no
5952
		 * sbuf equivalent of strncat().
5953
		 */
5954
		for (i = 0; i < add_len; i++) {
5955
			if (iscsi_name[i] == '\0') {
5956
				nul_found = 1;
5957
				break;
5958
			}
5959
		}
5960
		/*
5961
		 * If there is a NUL in the name, we can just use
5962
		 * sbuf_cat().  Otherwise we need to use sbuf_bcat().
5963
		 */
5964
		if (nul_found != 0)
5965
			sbuf_cat(sb, iscsi_name);
5966
		else
5967
			sbuf_bcat(sb, iscsi_name, add_len);
5968
		break;
5969
	}
5970
	case SCSI_PROTO_SAS: {
5971
		struct scsi_transportid_sas *sas;
5972
		uint64_t sas_addr;
5973

5974
		sas = (struct scsi_transportid_sas *)hdr;
5975

5976
		sas_addr = scsi_8btou64(sas->sas_address);
5977
		sbuf_printf(sb, "SAS address: 0x%.16jx", (uintmax_t)sas_addr);
5978
		break;
5979
	}
5980
	case SCSI_PROTO_ADITP:
5981
	case SCSI_PROTO_ATA:
5982
	case SCSI_PROTO_UAS:
5983
		/*
5984
		 * No Transport ID format for ADI, ATA or USB is defined in
5985
		 * SPC-4.
5986
		 */
5987
		sbuf_printf(sb, "No known Transport ID format for protocol "
5988
			    "%#x", hdr->format_protocol & SCSI_TRN_PROTO_MASK);
5989
		break;
5990
	case SCSI_PROTO_SOP: {
5991
		struct scsi_transportid_sop *sop;
5992
		struct scsi_sop_routing_id_norm *rid;
5993

5994
		sop = (struct scsi_transportid_sop *)hdr;
5995
		rid = (struct scsi_sop_routing_id_norm *)sop->routing_id;
5996

5997
		/*
5998
		 * Note that there is no alternate format specified in SPC-4
5999
		 * for the PCIe routing ID, so we don't really have a way
6000
		 * to know whether the second byte of the routing ID is
6001
		 * a device and function or just a function.  So we just
6002
		 * assume bus,device,function.
6003
		 */
6004
		sbuf_printf(sb, "SOP Routing ID: %u,%u,%u",
6005
			    rid->bus, rid->devfunc >> SCSI_TRN_SOP_DEV_SHIFT,
6006
			    rid->devfunc & SCSI_TRN_SOP_FUNC_NORM_MAX);
6007
		break;
6008
	}
6009
	case SCSI_PROTO_NONE:
6010
	default:
6011
		sbuf_printf(sb, "Unknown protocol %#x",
6012
			    hdr->format_protocol & SCSI_TRN_PROTO_MASK);
6013
		break;
6014
	}
6015

6016
	return (0);
6017
}
6018

6019
struct scsi_nv scsi_proto_map[] = {
6020
	{ "fcp", SCSI_PROTO_FC },
6021
	{ "spi", SCSI_PROTO_SPI },
6022
	{ "ssa", SCSI_PROTO_SSA },
6023
	{ "sbp", SCSI_PROTO_1394 },
6024
	{ "1394", SCSI_PROTO_1394 },
6025
	{ "srp", SCSI_PROTO_RDMA },
6026
	{ "rdma", SCSI_PROTO_RDMA },
6027
	{ "iscsi", SCSI_PROTO_ISCSI },
6028
	{ "iqn", SCSI_PROTO_ISCSI },
6029
	{ "sas", SCSI_PROTO_SAS },
6030
	{ "aditp", SCSI_PROTO_ADITP },
6031
	{ "ata", SCSI_PROTO_ATA },
6032
	{ "uas", SCSI_PROTO_UAS },
6033
	{ "usb", SCSI_PROTO_UAS },
6034
	{ "sop", SCSI_PROTO_SOP }
6035
};
6036

6037
const char *
6038
scsi_nv_to_str(struct scsi_nv *table, int num_table_entries, uint64_t value)
6039
{
6040
	int i;
6041

6042
	for (i = 0; i < num_table_entries; i++) {
6043
		if (table[i].value == value)
6044
			return (table[i].name);
6045
	}
6046

6047
	return (NULL);
6048
}
6049

6050
/*
6051
 * Given a name/value table, find a value matching the given name.
6052
 * Return values:
6053
 *	SCSI_NV_FOUND - match found
6054
 *	SCSI_NV_AMBIGUOUS - more than one match, none of them exact
6055
 *	SCSI_NV_NOT_FOUND - no match found
6056
 */
6057
scsi_nv_status
6058
scsi_get_nv(struct scsi_nv *table, int num_table_entries,
6059
	    char *name, int *table_entry, scsi_nv_flags flags)
6060
{
6061
	int i, num_matches = 0;
6062

6063
	for (i = 0; i < num_table_entries; i++) {
6064
		size_t table_len, name_len;
6065

6066
		table_len = strlen(table[i].name);
6067
		name_len = strlen(name);
6068

6069
		if ((((flags & SCSI_NV_FLAG_IG_CASE) != 0)
6070
		  && (strncasecmp(table[i].name, name, name_len) == 0))
6071
		|| (((flags & SCSI_NV_FLAG_IG_CASE) == 0)
6072
		 && (strncmp(table[i].name, name, name_len) == 0))) {
6073
			*table_entry = i;
6074

6075
			/*
6076
			 * Check for an exact match.  If we have the same
6077
			 * number of characters in the table as the argument,
6078
			 * and we already know they're the same, we have
6079
			 * an exact match.
6080
		 	 */
6081
			if (table_len == name_len)
6082
				return (SCSI_NV_FOUND);
6083

6084
			/*
6085
			 * Otherwise, bump up the number of matches.  We'll
6086
			 * see later how many we have.
6087
			 */
6088
			num_matches++;
6089
		}
6090
	}
6091

6092
	if (num_matches > 1)
6093
		return (SCSI_NV_AMBIGUOUS);
6094
	else if (num_matches == 1)
6095
		return (SCSI_NV_FOUND);
6096
	else
6097
		return (SCSI_NV_NOT_FOUND);
6098
}
6099

6100
/*
6101
 * Parse transport IDs for Fibre Channel, 1394 and SAS.  Since these are
6102
 * all 64-bit numbers, the code is similar.
6103
 */
6104
int
6105
scsi_parse_transportid_64bit(int proto_id, char *id_str,
6106
			     struct scsi_transportid_header **hdr,
6107
			     unsigned int *alloc_len,
6108
#ifdef _KERNEL
6109
			     struct malloc_type *type, int flags,
6110
#endif
6111
			     char *error_str, int error_str_len)
6112
{
6113
	uint64_t value;
6114
	char *endptr;
6115
	int retval;
6116
	size_t alloc_size;
6117

6118
	retval = 0;
6119

6120
	value = strtouq(id_str, &endptr, 0);
6121
	if (*endptr != '\0') {
6122
		if (error_str != NULL) {
6123
			snprintf(error_str, error_str_len, "%s: error "
6124
				 "parsing ID %s, 64-bit number required",
6125
				 __func__, id_str);
6126
		}
6127
		retval = 1;
6128
		goto bailout;
6129
	}
6130

6131
	switch (proto_id) {
6132
	case SCSI_PROTO_FC:
6133
		alloc_size = sizeof(struct scsi_transportid_fcp);
6134
		break;
6135
	case SCSI_PROTO_1394:
6136
		alloc_size = sizeof(struct scsi_transportid_1394);
6137
		break;
6138
	case SCSI_PROTO_SAS:
6139
		alloc_size = sizeof(struct scsi_transportid_sas);
6140
		break;
6141
	default:
6142
		if (error_str != NULL) {
6143
			snprintf(error_str, error_str_len, "%s: unsupported "
6144
				 "protocol %d", __func__, proto_id);
6145
		}
6146
		retval = 1;
6147
		goto bailout;
6148
		break; /* NOTREACHED */
6149
	}
6150
#ifdef _KERNEL
6151
	*hdr = malloc(alloc_size, type, flags);
6152
#else /* _KERNEL */
6153
	*hdr = malloc(alloc_size);
6154
#endif /*_KERNEL */
6155
	if (*hdr == NULL) {
6156
		if (error_str != NULL) {
6157
			snprintf(error_str, error_str_len, "%s: unable to "
6158
				 "allocate %zu bytes", __func__, alloc_size);
6159
		}
6160
		retval = 1;
6161
		goto bailout;
6162
	}
6163

6164
	*alloc_len = alloc_size;
6165

6166
	bzero(*hdr, alloc_size);
6167

6168
	switch (proto_id) {
6169
	case SCSI_PROTO_FC: {
6170
		struct scsi_transportid_fcp *fcp;
6171

6172
		fcp = (struct scsi_transportid_fcp *)(*hdr);
6173
		fcp->format_protocol = SCSI_PROTO_FC |
6174
				       SCSI_TRN_FCP_FORMAT_DEFAULT;
6175
		scsi_u64to8b(value, fcp->n_port_name);
6176
		break;
6177
	}
6178
	case SCSI_PROTO_1394: {
6179
		struct scsi_transportid_1394 *sbp;
6180

6181
		sbp = (struct scsi_transportid_1394 *)(*hdr);
6182
		sbp->format_protocol = SCSI_PROTO_1394 |
6183
				       SCSI_TRN_1394_FORMAT_DEFAULT;
6184
		scsi_u64to8b(value, sbp->eui64);
6185
		break;
6186
	}
6187
	case SCSI_PROTO_SAS: {
6188
		struct scsi_transportid_sas *sas;
6189

6190
		sas = (struct scsi_transportid_sas *)(*hdr);
6191
		sas->format_protocol = SCSI_PROTO_SAS |
6192
				       SCSI_TRN_SAS_FORMAT_DEFAULT;
6193
		scsi_u64to8b(value, sas->sas_address);
6194
		break;
6195
	}
6196
	default:
6197
		break;
6198
	}
6199
bailout:
6200
	return (retval);
6201
}
6202

6203
/*
6204
 * Parse a SPI (Parallel SCSI) address of the form: id,rel_tgt_port
6205
 */
6206
int
6207
scsi_parse_transportid_spi(char *id_str, struct scsi_transportid_header **hdr,
6208
			   unsigned int *alloc_len,
6209
#ifdef _KERNEL
6210
			   struct malloc_type *type, int flags,
6211
#endif
6212
			   char *error_str, int error_str_len)
6213
{
6214
	unsigned long scsi_addr, target_port;
6215
	struct scsi_transportid_spi *spi;
6216
	char *tmpstr, *endptr;
6217
	int retval;
6218

6219
	retval = 0;
6220

6221
	tmpstr = strsep(&id_str, ",");
6222
	if (tmpstr == NULL) {
6223
		if (error_str != NULL) {
6224
			snprintf(error_str, error_str_len,
6225
				 "%s: no ID found", __func__);
6226
		}
6227
		retval = 1;
6228
		goto bailout;
6229
	}
6230
	scsi_addr = strtoul(tmpstr, &endptr, 0);
6231
	if (*endptr != '\0') {
6232
		if (error_str != NULL) {
6233
			snprintf(error_str, error_str_len, "%s: error "
6234
				 "parsing SCSI ID %s, number required",
6235
				 __func__, tmpstr);
6236
		}
6237
		retval = 1;
6238
		goto bailout;
6239
	}
6240

6241
	if (id_str == NULL) {
6242
		if (error_str != NULL) {
6243
			snprintf(error_str, error_str_len, "%s: no relative "
6244
				 "target port found", __func__);
6245
		}
6246
		retval = 1;
6247
		goto bailout;
6248
	}
6249

6250
	target_port = strtoul(id_str, &endptr, 0);
6251
	if (*endptr != '\0') {
6252
		if (error_str != NULL) {
6253
			snprintf(error_str, error_str_len, "%s: error "
6254
				 "parsing relative target port %s, number "
6255
				 "required", __func__, id_str);
6256
		}
6257
		retval = 1;
6258
		goto bailout;
6259
	}
6260
#ifdef _KERNEL
6261
	spi = malloc(sizeof(*spi), type, flags);
6262
#else
6263
	spi = malloc(sizeof(*spi));
6264
#endif
6265
	if (spi == NULL) {
6266
		if (error_str != NULL) {
6267
			snprintf(error_str, error_str_len, "%s: unable to "
6268
				 "allocate %zu bytes", __func__,
6269
				 sizeof(*spi));
6270
		}
6271
		retval = 1;
6272
		goto bailout;
6273
	}
6274
	*alloc_len = sizeof(*spi);
6275
	bzero(spi, sizeof(*spi));
6276

6277
	spi->format_protocol = SCSI_PROTO_SPI | SCSI_TRN_SPI_FORMAT_DEFAULT;
6278
	scsi_ulto2b(scsi_addr, spi->scsi_addr);
6279
	scsi_ulto2b(target_port, spi->rel_trgt_port_id);
6280

6281
	*hdr = (struct scsi_transportid_header *)spi;
6282
bailout:
6283
	return (retval);
6284
}
6285

6286
/*
6287
 * Parse an RDMA/SRP Initiator Port ID string.  This is 32 hexadecimal digits,
6288
 * optionally prefixed by "0x" or "0X".
6289
 */
6290
int
6291
scsi_parse_transportid_rdma(char *id_str, struct scsi_transportid_header **hdr,
6292
			    unsigned int *alloc_len,
6293
#ifdef _KERNEL
6294
			    struct malloc_type *type, int flags,
6295
#endif
6296
			    char *error_str, int error_str_len)
6297
{
6298
	struct scsi_transportid_rdma *rdma;
6299
	int retval;
6300
	size_t id_len, rdma_id_size;
6301
	uint8_t rdma_id[SCSI_TRN_RDMA_PORT_LEN];
6302
	char *tmpstr;
6303
	unsigned int i, j;
6304

6305
	retval = 0;
6306
	id_len = strlen(id_str);
6307
	rdma_id_size = SCSI_TRN_RDMA_PORT_LEN;
6308

6309
	/*
6310
	 * Check the size.  It needs to be either 32 or 34 characters long.
6311
	 */
6312
	if ((id_len != (rdma_id_size * 2))
6313
	 && (id_len != ((rdma_id_size * 2) + 2))) {
6314
		if (error_str != NULL) {
6315
			snprintf(error_str, error_str_len, "%s: RDMA ID "
6316
				 "must be 32 hex digits (0x prefix "
6317
				 "optional), only %zu seen", __func__, id_len);
6318
		}
6319
		retval = 1;
6320
		goto bailout;
6321
	}
6322

6323
	tmpstr = id_str;
6324
	/*
6325
	 * If the user gave us 34 characters, the string needs to start
6326
	 * with '0x'.
6327
	 */
6328
	if (id_len == ((rdma_id_size * 2) + 2)) {
6329
	 	if ((tmpstr[0] == '0')
6330
		 && ((tmpstr[1] == 'x') || (tmpstr[1] == 'X'))) {
6331
			tmpstr += 2;
6332
		} else {
6333
			if (error_str != NULL) {
6334
				snprintf(error_str, error_str_len, "%s: RDMA "
6335
					 "ID prefix, if used, must be \"0x\", "
6336
					 "got %s", __func__, tmpstr);
6337
			}
6338
			retval = 1;
6339
			goto bailout;
6340
		}
6341
	}
6342
	bzero(rdma_id, sizeof(rdma_id));
6343

6344
	/*
6345
	 * Convert ASCII hex into binary bytes.  There is no standard
6346
	 * 128-bit integer type, and so no strtou128t() routine to convert
6347
	 * from hex into a large integer.  In the end, we're not going to
6348
	 * an integer, but rather to a byte array, so that and the fact
6349
	 * that we require the user to give us 32 hex digits simplifies the
6350
	 * logic.
6351
	 */
6352
	for (i = 0; i < (rdma_id_size * 2); i++) {
6353
		int cur_shift;
6354
		unsigned char c;
6355

6356
		/* Increment the byte array one for every 2 hex digits */
6357
		j = i >> 1;
6358

6359
		/*
6360
		 * The first digit in every pair is the most significant
6361
		 * 4 bits.  The second is the least significant 4 bits.
6362
		 */
6363
		if ((i % 2) == 0)
6364
			cur_shift = 4;
6365
		else
6366
			cur_shift = 0;
6367

6368
		c = tmpstr[i];
6369
		/* Convert the ASCII hex character into a number */
6370
		if (isdigit(c))
6371
			c -= '0';
6372
		else if (isalpha(c))
6373
			c -= isupper(c) ? 'A' - 10 : 'a' - 10;
6374
		else {
6375
			if (error_str != NULL) {
6376
				snprintf(error_str, error_str_len, "%s: "
6377
					 "RDMA ID must be hex digits, got "
6378
					 "invalid character %c", __func__,
6379
					 tmpstr[i]);
6380
			}
6381
			retval = 1;
6382
			goto bailout;
6383
		}
6384
		/*
6385
		 * The converted number can't be less than 0; the type is
6386
		 * unsigned, and the subtraction logic will not give us
6387
		 * a negative number.  So we only need to make sure that
6388
		 * the value is not greater than 0xf.  (i.e. make sure the
6389
		 * user didn't give us a value like "0x12jklmno").
6390
		 */
6391
		if (c > 0xf) {
6392
			if (error_str != NULL) {
6393
				snprintf(error_str, error_str_len, "%s: "
6394
					 "RDMA ID must be hex digits, got "
6395
					 "invalid character %c", __func__,
6396
					 tmpstr[i]);
6397
			}
6398
			retval = 1;
6399
			goto bailout;
6400
		}
6401

6402
		rdma_id[j] |= c << cur_shift;
6403
	}
6404

6405
#ifdef _KERNEL
6406
	rdma = malloc(sizeof(*rdma), type, flags);
6407
#else
6408
	rdma = malloc(sizeof(*rdma));
6409
#endif
6410
	if (rdma == NULL) {
6411
		if (error_str != NULL) {
6412
			snprintf(error_str, error_str_len, "%s: unable to "
6413
				 "allocate %zu bytes", __func__,
6414
				 sizeof(*rdma));
6415
		}
6416
		retval = 1;
6417
		goto bailout;
6418
	}
6419
	*alloc_len = sizeof(*rdma);
6420
	bzero(rdma, *alloc_len);
6421

6422
	rdma->format_protocol = SCSI_PROTO_RDMA | SCSI_TRN_RDMA_FORMAT_DEFAULT;
6423
	bcopy(rdma_id, rdma->initiator_port_id, SCSI_TRN_RDMA_PORT_LEN);
6424

6425
	*hdr = (struct scsi_transportid_header *)rdma;
6426

6427
bailout:
6428
	return (retval);
6429
}
6430

6431
/*
6432
 * Parse an iSCSI name.  The format is either just the name:
6433
 *
6434
 *	iqn.2012-06.com.example:target0
6435
 * or the name, separator and initiator session ID:
6436
 *
6437
 *	iqn.2012-06.com.example:target0,i,0x123
6438
 *
6439
 * The separator format is exact.
6440
 */
6441
int
6442
scsi_parse_transportid_iscsi(char *id_str, struct scsi_transportid_header **hdr,
6443
			     unsigned int *alloc_len,
6444
#ifdef _KERNEL
6445
			     struct malloc_type *type, int flags,
6446
#endif
6447
			     char *error_str, int error_str_len)
6448
{
6449
	size_t id_len, sep_len, id_size, name_len;
6450
	int retval;
6451
	unsigned int i, sep_pos, sep_found;
6452
	const char *sep_template = ",i,0x";
6453
	const char *iqn_prefix = "iqn.";
6454
	struct scsi_transportid_iscsi_device *iscsi;
6455

6456
	retval = 0;
6457
	sep_found = 0;
6458

6459
	id_len = strlen(id_str);
6460
	sep_len = strlen(sep_template);
6461

6462
	/*
6463
	 * The separator is defined as exactly ',i,0x'.  Any other commas,
6464
	 * or any other form, is an error.  So look for a comma, and once
6465
	 * we find that, the next few characters must match the separator
6466
	 * exactly.  Once we get through the separator, there should be at
6467
	 * least one character.
6468
	 */
6469
	for (i = 0, sep_pos = 0; i < id_len; i++) {
6470
		if (sep_pos == 0) {
6471
		 	if (id_str[i] == sep_template[sep_pos])
6472
				sep_pos++;
6473

6474
			continue;
6475
		}
6476
		if (sep_pos < sep_len) {
6477
			if (id_str[i] == sep_template[sep_pos]) {
6478
				sep_pos++;
6479
				continue;
6480
			}
6481
			if (error_str != NULL) {
6482
				snprintf(error_str, error_str_len, "%s: "
6483
					 "invalid separator in iSCSI name "
6484
					 "\"%s\"",
6485
					 __func__, id_str);
6486
			}
6487
			retval = 1;
6488
			goto bailout;
6489
		} else {
6490
			sep_found = 1;
6491
			break;
6492
		}
6493
	}
6494

6495
	/*
6496
	 * Check to see whether we have a separator but no digits after it.
6497
	 */
6498
	if ((sep_pos != 0)
6499
	 && (sep_found == 0)) {
6500
		if (error_str != NULL) {
6501
			snprintf(error_str, error_str_len, "%s: no digits "
6502
				 "found after separator in iSCSI name \"%s\"",
6503
				 __func__, id_str);
6504
		}
6505
		retval = 1;
6506
		goto bailout;
6507
	}
6508

6509
	/*
6510
	 * The incoming ID string has the "iqn." prefix stripped off.  We
6511
	 * need enough space for the base structure (the structures are the
6512
	 * same for the two iSCSI forms), the prefix, the ID string and a
6513
	 * terminating NUL.
6514
	 */
6515
	id_size = sizeof(*iscsi) + strlen(iqn_prefix) + id_len + 1;
6516

6517
#ifdef _KERNEL
6518
	iscsi = malloc(id_size, type, flags);
6519
#else
6520
	iscsi = malloc(id_size);
6521
#endif
6522
	if (iscsi == NULL) {
6523
		if (error_str != NULL) {
6524
			snprintf(error_str, error_str_len, "%s: unable to "
6525
				 "allocate %zu bytes", __func__, id_size);
6526
		}
6527
		retval = 1;
6528
		goto bailout;
6529
	}
6530
	*alloc_len = id_size;
6531
	bzero(iscsi, id_size);
6532

6533
	iscsi->format_protocol = SCSI_PROTO_ISCSI;
6534
	if (sep_found == 0)
6535
		iscsi->format_protocol |= SCSI_TRN_ISCSI_FORMAT_DEVICE;
6536
	else
6537
		iscsi->format_protocol |= SCSI_TRN_ISCSI_FORMAT_PORT;
6538
	name_len = id_size - sizeof(*iscsi);
6539
	scsi_ulto2b(name_len, iscsi->additional_length);
6540
	snprintf(iscsi->iscsi_name, name_len, "%s%s", iqn_prefix, id_str);
6541

6542
	*hdr = (struct scsi_transportid_header *)iscsi;
6543

6544
bailout:
6545
	return (retval);
6546
}
6547

6548
/*
6549
 * Parse a SCSI over PCIe (SOP) identifier.  The Routing ID can either be
6550
 * of the form 'bus,device,function' or 'bus,function'.
6551
 */
6552
int
6553
scsi_parse_transportid_sop(char *id_str, struct scsi_transportid_header **hdr,
6554
			   unsigned int *alloc_len,
6555
#ifdef _KERNEL
6556
			   struct malloc_type *type, int flags,
6557
#endif
6558
			   char *error_str, int error_str_len)
6559
{
6560
	struct scsi_transportid_sop *sop;
6561
	unsigned long bus, device, function;
6562
	char *tmpstr, *endptr;
6563
	int retval, device_spec;
6564

6565
	retval = 0;
6566
	device_spec = 0;
6567
	device = 0;
6568

6569
	tmpstr = strsep(&id_str, ",");
6570
	if ((tmpstr == NULL)
6571
	 || (*tmpstr == '\0')) {
6572
		if (error_str != NULL) {
6573
			snprintf(error_str, error_str_len, "%s: no ID found",
6574
				 __func__);
6575
		}
6576
		retval = 1;
6577
		goto bailout;
6578
	}
6579
	bus = strtoul(tmpstr, &endptr, 0);
6580
	if (*endptr != '\0') {
6581
		if (error_str != NULL) {
6582
			snprintf(error_str, error_str_len, "%s: error "
6583
				 "parsing PCIe bus %s, number required",
6584
				 __func__, tmpstr);
6585
		}
6586
		retval = 1;
6587
		goto bailout;
6588
	}
6589
	if ((id_str == NULL)
6590
	 || (*id_str == '\0')) {
6591
		if (error_str != NULL) {
6592
			snprintf(error_str, error_str_len, "%s: no PCIe "
6593
				 "device or function found", __func__);
6594
		}
6595
		retval = 1;
6596
		goto bailout;
6597
	}
6598
	tmpstr = strsep(&id_str, ",");
6599
	function = strtoul(tmpstr, &endptr, 0);
6600
	if (*endptr != '\0') {
6601
		if (error_str != NULL) {
6602
			snprintf(error_str, error_str_len, "%s: error "
6603
				 "parsing PCIe device/function %s, number "
6604
				 "required", __func__, tmpstr);
6605
		}
6606
		retval = 1;
6607
		goto bailout;
6608
	}
6609
	/*
6610
	 * Check to see whether the user specified a third value.  If so,
6611
	 * the second is the device.
6612
	 */
6613
	if (id_str != NULL) {
6614
		if (*id_str == '\0') {
6615
			if (error_str != NULL) {
6616
				snprintf(error_str, error_str_len, "%s: "
6617
					 "no PCIe function found", __func__);
6618
			}
6619
			retval = 1;
6620
			goto bailout;
6621
		}
6622
		device = function;
6623
		device_spec = 1;
6624
		function = strtoul(id_str, &endptr, 0);
6625
		if (*endptr != '\0') {
6626
			if (error_str != NULL) {
6627
				snprintf(error_str, error_str_len, "%s: "
6628
					 "error parsing PCIe function %s, "
6629
					 "number required", __func__, id_str);
6630
			}
6631
			retval = 1;
6632
			goto bailout;
6633
		}
6634
	}
6635
	if (bus > SCSI_TRN_SOP_BUS_MAX) {
6636
		if (error_str != NULL) {
6637
			snprintf(error_str, error_str_len, "%s: bus value "
6638
				 "%lu greater than maximum %u", __func__,
6639
				 bus, SCSI_TRN_SOP_BUS_MAX);
6640
		}
6641
		retval = 1;
6642
		goto bailout;
6643
	}
6644

6645
	if ((device_spec != 0)
6646
	 && (device > SCSI_TRN_SOP_DEV_MASK)) {
6647
		if (error_str != NULL) {
6648
			snprintf(error_str, error_str_len, "%s: device value "
6649
				 "%lu greater than maximum %u", __func__,
6650
				 device, SCSI_TRN_SOP_DEV_MAX);
6651
		}
6652
		retval = 1;
6653
		goto bailout;
6654
	}
6655

6656
	if (((device_spec != 0)
6657
	  && (function > SCSI_TRN_SOP_FUNC_NORM_MAX))
6658
	 || ((device_spec == 0)
6659
	  && (function > SCSI_TRN_SOP_FUNC_ALT_MAX))) {
6660
		if (error_str != NULL) {
6661
			snprintf(error_str, error_str_len, "%s: function value "
6662
				 "%lu greater than maximum %u", __func__,
6663
				 function, (device_spec == 0) ?
6664
				 SCSI_TRN_SOP_FUNC_ALT_MAX :
6665
				 SCSI_TRN_SOP_FUNC_NORM_MAX);
6666
		}
6667
		retval = 1;
6668
		goto bailout;
6669
	}
6670

6671
#ifdef _KERNEL
6672
	sop = malloc(sizeof(*sop), type, flags);
6673
#else
6674
	sop = malloc(sizeof(*sop));
6675
#endif
6676
	if (sop == NULL) {
6677
		if (error_str != NULL) {
6678
			snprintf(error_str, error_str_len, "%s: unable to "
6679
				 "allocate %zu bytes", __func__, sizeof(*sop));
6680
		}
6681
		retval = 1;
6682
		goto bailout;
6683
	}
6684
	*alloc_len = sizeof(*sop);
6685
	bzero(sop, sizeof(*sop));
6686
	sop->format_protocol = SCSI_PROTO_SOP | SCSI_TRN_SOP_FORMAT_DEFAULT;
6687
	if (device_spec != 0) {
6688
		struct scsi_sop_routing_id_norm rid;
6689

6690
		rid.bus = bus;
6691
		rid.devfunc = (device << SCSI_TRN_SOP_DEV_SHIFT) | function;
6692
		bcopy(&rid, sop->routing_id, MIN(sizeof(rid),
6693
		      sizeof(sop->routing_id)));
6694
	} else {
6695
		struct scsi_sop_routing_id_alt rid;
6696

6697
		rid.bus = bus;
6698
		rid.function = function;
6699
		bcopy(&rid, sop->routing_id, MIN(sizeof(rid),
6700
		      sizeof(sop->routing_id)));
6701
	}
6702

6703
	*hdr = (struct scsi_transportid_header *)sop;
6704
bailout:
6705
	return (retval);
6706
}
6707

6708
/*
6709
 * transportid_str: NUL-terminated string with format: protcol,id
6710
 *		    The ID is protocol specific.
6711
 * hdr:		    Storage will be allocated for the transport ID.
6712
 * alloc_len:	    The amount of memory allocated is returned here.
6713
 * type:	    Malloc bucket (kernel only).
6714
 * flags:	    Malloc flags (kernel only).
6715
 * error_str:	    If non-NULL, it will contain error information (without
6716
 * 		    a terminating newline) if an error is returned.
6717
 * error_str_len:   Allocated length of the error string.
6718
 *
6719
 * Returns 0 for success, non-zero for failure.
6720
 */
6721
int
6722
scsi_parse_transportid(char *transportid_str,
6723
		       struct scsi_transportid_header **hdr,
6724
		       unsigned int *alloc_len,
6725
#ifdef _KERNEL
6726
		       struct malloc_type *type, int flags,
6727
#endif
6728
		       char *error_str, int error_str_len)
6729
{
6730
	char *tmpstr;
6731
	scsi_nv_status status;
6732
	u_int num_proto_entries;
6733
	int retval, table_entry;
6734

6735
	retval = 0;
6736
	table_entry = 0;
6737

6738
	/*
6739
	 * We do allow a period as well as a comma to separate the protocol
6740
	 * from the ID string.  This is to accommodate iSCSI names, which
6741
	 * start with "iqn.".
6742
	 */
6743
	tmpstr = strsep(&transportid_str, ",.");
6744
	if (tmpstr == NULL) {
6745
		if (error_str != NULL) {
6746
			snprintf(error_str, error_str_len,
6747
				 "%s: transportid_str is NULL", __func__);
6748
		}
6749
		retval = 1;
6750
		goto bailout;
6751
	}
6752

6753
	num_proto_entries = nitems(scsi_proto_map);
6754
	status = scsi_get_nv(scsi_proto_map, num_proto_entries, tmpstr,
6755
			     &table_entry, SCSI_NV_FLAG_IG_CASE);
6756
	if (status != SCSI_NV_FOUND) {
6757
		if (error_str != NULL) {
6758
			snprintf(error_str, error_str_len, "%s: %s protocol "
6759
				 "name %s", __func__,
6760
				 (status == SCSI_NV_AMBIGUOUS) ? "ambiguous" :
6761
				 "invalid", tmpstr);
6762
		}
6763
		retval = 1;
6764
		goto bailout;
6765
	}
6766
	switch (scsi_proto_map[table_entry].value) {
6767
	case SCSI_PROTO_FC:
6768
	case SCSI_PROTO_1394:
6769
	case SCSI_PROTO_SAS:
6770
		retval = scsi_parse_transportid_64bit(
6771
		    scsi_proto_map[table_entry].value, transportid_str, hdr,
6772
		    alloc_len,
6773
#ifdef _KERNEL
6774
		    type, flags,
6775
#endif
6776
		    error_str, error_str_len);
6777
		break;
6778
	case SCSI_PROTO_SPI:
6779
		retval = scsi_parse_transportid_spi(transportid_str, hdr,
6780
		    alloc_len,
6781
#ifdef _KERNEL
6782
		    type, flags,
6783
#endif
6784
		    error_str, error_str_len);
6785
		break;
6786
	case SCSI_PROTO_RDMA:
6787
		retval = scsi_parse_transportid_rdma(transportid_str, hdr,
6788
		    alloc_len,
6789
#ifdef _KERNEL
6790
		    type, flags,
6791
#endif
6792
		    error_str, error_str_len);
6793
		break;
6794
	case SCSI_PROTO_ISCSI:
6795
		retval = scsi_parse_transportid_iscsi(transportid_str, hdr,
6796
		    alloc_len,
6797
#ifdef _KERNEL
6798
		    type, flags,
6799
#endif
6800
		    error_str, error_str_len);
6801
		break;
6802
	case SCSI_PROTO_SOP:
6803
		retval = scsi_parse_transportid_sop(transportid_str, hdr,
6804
		    alloc_len,
6805
#ifdef _KERNEL
6806
		    type, flags,
6807
#endif
6808
		    error_str, error_str_len);
6809
		break;
6810
	case SCSI_PROTO_SSA:
6811
	case SCSI_PROTO_ADITP:
6812
	case SCSI_PROTO_ATA:
6813
	case SCSI_PROTO_UAS:
6814
	case SCSI_PROTO_NONE:
6815
	default:
6816
		/*
6817
		 * There is no format defined for a Transport ID for these
6818
		 * protocols.  So even if the user gives us something, we
6819
		 * have no way to turn it into a standard SCSI Transport ID.
6820
		 */
6821
		retval = 1;
6822
		if (error_str != NULL) {
6823
			snprintf(error_str, error_str_len, "%s: no Transport "
6824
				 "ID format exists for protocol %s",
6825
				 __func__, tmpstr);
6826
		}
6827
		goto bailout;
6828
		break;	/* NOTREACHED */
6829
	}
6830
bailout:
6831
	return (retval);
6832
}
6833

6834
struct scsi_attrib_table_entry scsi_mam_attr_table[] = {
6835
	{ SMA_ATTR_REM_CAP_PARTITION, SCSI_ATTR_FLAG_NONE,
6836
	  "Remaining Capacity in Partition",
6837
	  /*suffix*/ "MB", /*to_str*/ scsi_attrib_int_sbuf,/*parse_str*/ NULL },
6838
	{ SMA_ATTR_MAX_CAP_PARTITION, SCSI_ATTR_FLAG_NONE,
6839
	  "Maximum Capacity in Partition",
6840
	  /*suffix*/"MB", /*to_str*/ scsi_attrib_int_sbuf, /*parse_str*/ NULL },
6841
	{ SMA_ATTR_TAPEALERT_FLAGS, SCSI_ATTR_FLAG_HEX,
6842
	  "TapeAlert Flags",
6843
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf, /*parse_str*/ NULL },
6844
	{ SMA_ATTR_LOAD_COUNT, SCSI_ATTR_FLAG_NONE,
6845
	  "Load Count",
6846
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf, /*parse_str*/ NULL },
6847
	{ SMA_ATTR_MAM_SPACE_REMAINING, SCSI_ATTR_FLAG_NONE,
6848
	  "MAM Space Remaining",
6849
	  /*suffix*/"bytes", /*to_str*/ scsi_attrib_int_sbuf,
6850
	  /*parse_str*/ NULL },
6851
	{ SMA_ATTR_DEV_ASSIGNING_ORG, SCSI_ATTR_FLAG_NONE,
6852
	  "Assigning Organization",
6853
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf,
6854
	  /*parse_str*/ NULL },
6855
	{ SMA_ATTR_FORMAT_DENSITY_CODE, SCSI_ATTR_FLAG_HEX,
6856
	  "Format Density Code",
6857
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf, /*parse_str*/ NULL },
6858
	{ SMA_ATTR_INITIALIZATION_COUNT, SCSI_ATTR_FLAG_NONE,
6859
	  "Initialization Count",
6860
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf, /*parse_str*/ NULL },
6861
	{ SMA_ATTR_VOLUME_ID, SCSI_ATTR_FLAG_NONE,
6862
	  "Volume Identifier",
6863
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf,
6864
	  /*parse_str*/ NULL },
6865
	{ SMA_ATTR_VOLUME_CHANGE_REF, SCSI_ATTR_FLAG_HEX,
6866
	  "Volume Change Reference",
6867
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf,
6868
	  /*parse_str*/ NULL },
6869
	{ SMA_ATTR_DEV_SERIAL_LAST_LOAD, SCSI_ATTR_FLAG_NONE,
6870
	  "Device Vendor/Serial at Last Load",
6871
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_vendser_sbuf,
6872
	  /*parse_str*/ NULL },
6873
	{ SMA_ATTR_DEV_SERIAL_LAST_LOAD_1, SCSI_ATTR_FLAG_NONE,
6874
	  "Device Vendor/Serial at Last Load - 1",
6875
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_vendser_sbuf,
6876
	  /*parse_str*/ NULL },
6877
	{ SMA_ATTR_DEV_SERIAL_LAST_LOAD_2, SCSI_ATTR_FLAG_NONE,
6878
	  "Device Vendor/Serial at Last Load - 2",
6879
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_vendser_sbuf,
6880
	  /*parse_str*/ NULL },
6881
	{ SMA_ATTR_DEV_SERIAL_LAST_LOAD_3, SCSI_ATTR_FLAG_NONE,
6882
	  "Device Vendor/Serial at Last Load - 3",
6883
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_vendser_sbuf,
6884
	  /*parse_str*/ NULL },
6885
	{ SMA_ATTR_TOTAL_MB_WRITTEN_LT, SCSI_ATTR_FLAG_NONE,
6886
	  "Total MB Written in Medium Life",
6887
	  /*suffix*/ "MB", /*to_str*/ scsi_attrib_int_sbuf,
6888
	  /*parse_str*/ NULL },
6889
	{ SMA_ATTR_TOTAL_MB_READ_LT, SCSI_ATTR_FLAG_NONE,
6890
	  "Total MB Read in Medium Life",
6891
	  /*suffix*/ "MB", /*to_str*/ scsi_attrib_int_sbuf,
6892
	  /*parse_str*/ NULL },
6893
	{ SMA_ATTR_TOTAL_MB_WRITTEN_CUR, SCSI_ATTR_FLAG_NONE,
6894
	  "Total MB Written in Current/Last Load",
6895
	  /*suffix*/ "MB", /*to_str*/ scsi_attrib_int_sbuf,
6896
	  /*parse_str*/ NULL },
6897
	{ SMA_ATTR_TOTAL_MB_READ_CUR, SCSI_ATTR_FLAG_NONE,
6898
	  "Total MB Read in Current/Last Load",
6899
	  /*suffix*/ "MB", /*to_str*/ scsi_attrib_int_sbuf,
6900
	  /*parse_str*/ NULL },
6901
	{ SMA_ATTR_FIRST_ENC_BLOCK, SCSI_ATTR_FLAG_NONE,
6902
	  "Logical Position of First Encrypted Block",
6903
	  /*suffix*/ NULL, /*to_str*/ scsi_attrib_int_sbuf,
6904
	  /*parse_str*/ NULL },
6905
	{ SMA_ATTR_NEXT_UNENC_BLOCK, SCSI_ATTR_FLAG_NONE,
6906
	  "Logical Position of First Unencrypted Block after First "
6907
	  "Encrypted Block",
6908
	  /*suffix*/ NULL, /*to_str*/ scsi_attrib_int_sbuf,
6909
	  /*parse_str*/ NULL },
6910
	{ SMA_ATTR_MEDIUM_USAGE_HIST, SCSI_ATTR_FLAG_NONE,
6911
	  "Medium Usage History",
6912
	  /*suffix*/ NULL, /*to_str*/ NULL,
6913
	  /*parse_str*/ NULL },
6914
	{ SMA_ATTR_PART_USAGE_HIST, SCSI_ATTR_FLAG_NONE,
6915
	  "Partition Usage History",
6916
	  /*suffix*/ NULL, /*to_str*/ NULL,
6917
	  /*parse_str*/ NULL },
6918
	{ SMA_ATTR_MED_MANUF, SCSI_ATTR_FLAG_NONE,
6919
	  "Medium Manufacturer",
6920
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf,
6921
	  /*parse_str*/ NULL },
6922
	{ SMA_ATTR_MED_SERIAL, SCSI_ATTR_FLAG_NONE,
6923
	  "Medium Serial Number",
6924
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf,
6925
	  /*parse_str*/ NULL },
6926
	{ SMA_ATTR_MED_LENGTH, SCSI_ATTR_FLAG_NONE,
6927
	  "Medium Length",
6928
	  /*suffix*/"m", /*to_str*/ scsi_attrib_int_sbuf,
6929
	  /*parse_str*/ NULL },
6930
	{ SMA_ATTR_MED_WIDTH, SCSI_ATTR_FLAG_FP | SCSI_ATTR_FLAG_DIV_10 |
6931
	  SCSI_ATTR_FLAG_FP_1DIGIT,
6932
	  "Medium Width",
6933
	  /*suffix*/"mm", /*to_str*/ scsi_attrib_int_sbuf,
6934
	  /*parse_str*/ NULL },
6935
	{ SMA_ATTR_MED_ASSIGNING_ORG, SCSI_ATTR_FLAG_NONE,
6936
	  "Assigning Organization",
6937
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf,
6938
	  /*parse_str*/ NULL },
6939
	{ SMA_ATTR_MED_DENSITY_CODE, SCSI_ATTR_FLAG_HEX,
6940
	  "Medium Density Code",
6941
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf,
6942
	  /*parse_str*/ NULL },
6943
	{ SMA_ATTR_MED_MANUF_DATE, SCSI_ATTR_FLAG_NONE,
6944
	  "Medium Manufacture Date",
6945
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf,
6946
	  /*parse_str*/ NULL },
6947
	{ SMA_ATTR_MAM_CAPACITY, SCSI_ATTR_FLAG_NONE,
6948
	  "MAM Capacity",
6949
	  /*suffix*/"bytes", /*to_str*/ scsi_attrib_int_sbuf,
6950
	  /*parse_str*/ NULL },
6951
	{ SMA_ATTR_MED_TYPE, SCSI_ATTR_FLAG_HEX,
6952
	  "Medium Type",
6953
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf,
6954
	  /*parse_str*/ NULL },
6955
	{ SMA_ATTR_MED_TYPE_INFO, SCSI_ATTR_FLAG_HEX,
6956
	  "Medium Type Information",
6957
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf,
6958
	  /*parse_str*/ NULL },
6959
	{ SMA_ATTR_MED_SERIAL_NUM, SCSI_ATTR_FLAG_NONE,
6960
	  "Medium Serial Number",
6961
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf,
6962
	  /*parse_str*/ NULL },
6963
	{ SMA_ATTR_APP_VENDOR, SCSI_ATTR_FLAG_NONE,
6964
	  "Application Vendor",
6965
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf,
6966
	  /*parse_str*/ NULL },
6967
	{ SMA_ATTR_APP_NAME, SCSI_ATTR_FLAG_NONE,
6968
	  "Application Name",
6969
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf,
6970
	  /*parse_str*/ NULL },
6971
	{ SMA_ATTR_APP_VERSION, SCSI_ATTR_FLAG_NONE,
6972
	  "Application Version",
6973
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf,
6974
	  /*parse_str*/ NULL },
6975
	{ SMA_ATTR_USER_MED_TEXT_LABEL, SCSI_ATTR_FLAG_NONE,
6976
	  "User Medium Text Label",
6977
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_text_sbuf,
6978
	  /*parse_str*/ NULL },
6979
	{ SMA_ATTR_LAST_WRITTEN_TIME, SCSI_ATTR_FLAG_NONE,
6980
	  "Date and Time Last Written",
6981
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf,
6982
	  /*parse_str*/ NULL },
6983
	{ SMA_ATTR_TEXT_LOCAL_ID, SCSI_ATTR_FLAG_HEX,
6984
	  "Text Localization Identifier",
6985
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf,
6986
	  /*parse_str*/ NULL },
6987
	{ SMA_ATTR_BARCODE, SCSI_ATTR_FLAG_NONE,
6988
	  "Barcode",
6989
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf,
6990
	  /*parse_str*/ NULL },
6991
	{ SMA_ATTR_HOST_OWNER_NAME, SCSI_ATTR_FLAG_NONE,
6992
	  "Owning Host Textual Name",
6993
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_text_sbuf,
6994
	  /*parse_str*/ NULL },
6995
	{ SMA_ATTR_MEDIA_POOL, SCSI_ATTR_FLAG_NONE,
6996
	  "Media Pool",
6997
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_text_sbuf,
6998
	  /*parse_str*/ NULL },
6999
	{ SMA_ATTR_PART_USER_LABEL, SCSI_ATTR_FLAG_NONE,
7000
	  "Partition User Text Label",
7001
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf,
7002
	  /*parse_str*/ NULL },
7003
	{ SMA_ATTR_LOAD_UNLOAD_AT_PART, SCSI_ATTR_FLAG_NONE,
7004
	  "Load/Unload at Partition",
7005
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_int_sbuf,
7006
	  /*parse_str*/ NULL },
7007
	{ SMA_ATTR_APP_FORMAT_VERSION, SCSI_ATTR_FLAG_NONE,
7008
	  "Application Format Version",
7009
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_ascii_sbuf,
7010
	  /*parse_str*/ NULL },
7011
	{ SMA_ATTR_VOL_COHERENCY_INFO, SCSI_ATTR_FLAG_NONE,
7012
	  "Volume Coherency Information",
7013
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_volcoh_sbuf,
7014
	  /*parse_str*/ NULL },
7015
	{ 0x0ff1, SCSI_ATTR_FLAG_NONE,
7016
	  "Spectra MLM Creation",
7017
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf,
7018
	  /*parse_str*/ NULL },
7019
	{ 0x0ff2, SCSI_ATTR_FLAG_NONE,
7020
	  "Spectra MLM C3",
7021
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf,
7022
	  /*parse_str*/ NULL },
7023
	{ 0x0ff3, SCSI_ATTR_FLAG_NONE,
7024
	  "Spectra MLM RW",
7025
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf,
7026
	  /*parse_str*/ NULL },
7027
	{ 0x0ff4, SCSI_ATTR_FLAG_NONE,
7028
	  "Spectra MLM SDC List",
7029
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf,
7030
	  /*parse_str*/ NULL },
7031
	{ 0x0ff7, SCSI_ATTR_FLAG_NONE,
7032
	  "Spectra MLM Post Scan",
7033
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf,
7034
	  /*parse_str*/ NULL },
7035
	{ 0x0ffe, SCSI_ATTR_FLAG_NONE,
7036
	  "Spectra MLM Checksum",
7037
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf,
7038
	  /*parse_str*/ NULL },
7039
	{ 0x17f1, SCSI_ATTR_FLAG_NONE,
7040
	  "Spectra MLM Creation",
7041
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf,
7042
	  /*parse_str*/ NULL },
7043
	{ 0x17f2, SCSI_ATTR_FLAG_NONE,
7044
	  "Spectra MLM C3",
7045
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf,
7046
	  /*parse_str*/ NULL },
7047
	{ 0x17f3, SCSI_ATTR_FLAG_NONE,
7048
	  "Spectra MLM RW",
7049
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf,
7050
	  /*parse_str*/ NULL },
7051
	{ 0x17f4, SCSI_ATTR_FLAG_NONE,
7052
	  "Spectra MLM SDC List",
7053
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf,
7054
	  /*parse_str*/ NULL },
7055
	{ 0x17f7, SCSI_ATTR_FLAG_NONE,
7056
	  "Spectra MLM Post Scan",
7057
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf,
7058
	  /*parse_str*/ NULL },
7059
	{ 0x17ff, SCSI_ATTR_FLAG_NONE,
7060
	  "Spectra MLM Checksum",
7061
	  /*suffix*/NULL, /*to_str*/ scsi_attrib_hexdump_sbuf,
7062
	  /*parse_str*/ NULL },
7063
};
7064

7065
/*
7066
 * Print out Volume Coherency Information (Attribute 0x080c).
7067
 * This field has two variable length members, including one at the
7068
 * beginning, so it isn't practical to have a fixed structure definition.
7069
 * This is current as of SSC4r03 (see section 4.2.21.3), dated March 25,
7070
 * 2013.
7071
 */
7072
int
7073
scsi_attrib_volcoh_sbuf(struct sbuf *sb, struct scsi_mam_attribute_header *hdr,
7074
			 uint32_t valid_len, uint32_t flags,
7075
			 uint32_t output_flags, char *error_str,
7076
			 int error_str_len)
7077
{
7078
	size_t avail_len;
7079
	uint32_t field_size;
7080
	uint64_t tmp_val;
7081
	uint8_t *cur_ptr;
7082
	int retval;
7083
	int vcr_len, as_len;
7084

7085
	retval = 0;
7086
	tmp_val = 0;
7087

7088
	field_size = scsi_2btoul(hdr->length);
7089
	avail_len = valid_len - sizeof(*hdr);
7090
	if (field_size > avail_len) {
7091
		if (error_str != NULL) {
7092
			snprintf(error_str, error_str_len, "Available "
7093
				 "length of attribute ID 0x%.4x %zu < field "
7094
				 "length %u", scsi_2btoul(hdr->id), avail_len,
7095
				 field_size);
7096
		}
7097
		retval = 1;
7098
		goto bailout;
7099
	} else if (field_size == 0) {
7100
		/*
7101
		 * It isn't clear from the spec whether a field length of
7102
		 * 0 is invalid here.  It probably is, but be lenient here
7103
		 * to avoid inconveniencing the user.
7104
		 */
7105
		goto bailout;
7106
	}
7107
	cur_ptr = hdr->attribute;
7108
	vcr_len = *cur_ptr;
7109
	cur_ptr++;
7110

7111
	sbuf_cat(sb, "\n\tVolume Change Reference Value:");
7112

7113
	switch (vcr_len) {
7114
	case 0:
7115
		if (error_str != NULL) {
7116
			snprintf(error_str, error_str_len, "Volume Change "
7117
				 "Reference value has length of 0");
7118
		}
7119
		retval = 1;
7120
		goto bailout;
7121
		break; /*NOTREACHED*/
7122
	case 1:
7123
		tmp_val = *cur_ptr;
7124
		break;
7125
	case 2:
7126
		tmp_val = scsi_2btoul(cur_ptr);
7127
		break;
7128
	case 3:
7129
		tmp_val = scsi_3btoul(cur_ptr);
7130
		break;
7131
	case 4:
7132
		tmp_val = scsi_4btoul(cur_ptr);
7133
		break;
7134
	case 8:
7135
		tmp_val = scsi_8btou64(cur_ptr);
7136
		break;
7137
	default:
7138
		sbuf_putc(sb, '\n');
7139
		sbuf_hexdump(sb, cur_ptr, vcr_len, NULL, 0);
7140
		break;
7141
	}
7142
	if (vcr_len <= 8)
7143
		sbuf_printf(sb, " 0x%jx\n", (uintmax_t)tmp_val);
7144

7145
	cur_ptr += vcr_len;
7146
	tmp_val = scsi_8btou64(cur_ptr);
7147
	sbuf_printf(sb, "\tVolume Coherency Count: %ju\n", (uintmax_t)tmp_val);
7148

7149
	cur_ptr += sizeof(tmp_val);
7150
	tmp_val = scsi_8btou64(cur_ptr);
7151
	sbuf_printf(sb, "\tVolume Coherency Set Identifier: 0x%jx\n",
7152
		    (uintmax_t)tmp_val);
7153

7154
	/*
7155
	 * Figure out how long the Application Client Specific Information
7156
	 * is and produce a hexdump.
7157
	 */
7158
	cur_ptr += sizeof(tmp_val);
7159
	as_len = scsi_2btoul(cur_ptr);
7160
	cur_ptr += sizeof(uint16_t);
7161
	sbuf_cat(sb, "\tApplication Client Specific Information: ");
7162
	if (((as_len == SCSI_LTFS_VER0_LEN)
7163
	  || (as_len == SCSI_LTFS_VER1_LEN))
7164
	 && (strncmp(cur_ptr, SCSI_LTFS_STR_NAME, SCSI_LTFS_STR_LEN) == 0)) {
7165
		sbuf_cat(sb, "LTFS\n");
7166
		cur_ptr += SCSI_LTFS_STR_LEN + 1;
7167
		if (cur_ptr[SCSI_LTFS_UUID_LEN] != '\0')
7168
			cur_ptr[SCSI_LTFS_UUID_LEN] = '\0';
7169
		sbuf_printf(sb, "\tLTFS UUID: %s\n", cur_ptr);
7170
		cur_ptr += SCSI_LTFS_UUID_LEN + 1;
7171
		/* XXX KDM check the length */
7172
		sbuf_printf(sb, "\tLTFS Version: %d\n", *cur_ptr);
7173
	} else {
7174
		sbuf_cat(sb, "Unknown\n");
7175
		sbuf_hexdump(sb, cur_ptr, as_len, NULL, 0);
7176
	}
7177

7178
bailout:
7179
	return (retval);
7180
}
7181

7182
int
7183
scsi_attrib_vendser_sbuf(struct sbuf *sb, struct scsi_mam_attribute_header *hdr,
7184
			 uint32_t valid_len, uint32_t flags,
7185
			 uint32_t output_flags, char *error_str,
7186
			 int error_str_len)
7187
{
7188
	size_t avail_len;
7189
	uint32_t field_size;
7190
	struct scsi_attrib_vendser *vendser;
7191
	cam_strvis_flags strvis_flags;
7192
	int retval = 0;
7193

7194
	field_size = scsi_2btoul(hdr->length);
7195
	avail_len = valid_len - sizeof(*hdr);
7196
	if (field_size > avail_len) {
7197
		if (error_str != NULL) {
7198
			snprintf(error_str, error_str_len, "Available "
7199
				 "length of attribute ID 0x%.4x %zu < field "
7200
				 "length %u", scsi_2btoul(hdr->id), avail_len,
7201
				 field_size);
7202
		}
7203
		retval = 1;
7204
		goto bailout;
7205
	} else if (field_size == 0) {
7206
		/*
7207
		 * A field size of 0 doesn't make sense here.  The device
7208
		 * can at least give you the vendor ID, even if it can't
7209
		 * give you the serial number.
7210
		 */
7211
		if (error_str != NULL) {
7212
			snprintf(error_str, error_str_len, "The length of "
7213
				 "attribute ID 0x%.4x is 0",
7214
				 scsi_2btoul(hdr->id));
7215
		}
7216
		retval = 1;
7217
		goto bailout;
7218
	}
7219
	vendser = (struct scsi_attrib_vendser *)hdr->attribute;
7220

7221
	switch (output_flags & SCSI_ATTR_OUTPUT_NONASCII_MASK) {
7222
	case SCSI_ATTR_OUTPUT_NONASCII_TRIM:
7223
		strvis_flags = CAM_STRVIS_FLAG_NONASCII_TRIM;
7224
		break;
7225
	case SCSI_ATTR_OUTPUT_NONASCII_RAW:
7226
		strvis_flags = CAM_STRVIS_FLAG_NONASCII_RAW;
7227
		break;
7228
	case SCSI_ATTR_OUTPUT_NONASCII_ESC:
7229
	default:
7230
		strvis_flags = CAM_STRVIS_FLAG_NONASCII_ESC;
7231
		break;
7232
	}
7233
	cam_strvis_sbuf(sb, vendser->vendor, sizeof(vendser->vendor),
7234
	    strvis_flags);
7235
	sbuf_putc(sb, ' ');
7236
	cam_strvis_sbuf(sb, vendser->serial_num, sizeof(vendser->serial_num),
7237
	    strvis_flags);
7238
bailout:
7239
	return (retval);
7240
}
7241

7242
int
7243
scsi_attrib_hexdump_sbuf(struct sbuf *sb, struct scsi_mam_attribute_header *hdr,
7244
			 uint32_t valid_len, uint32_t flags,
7245
			 uint32_t output_flags, char *error_str,
7246
			 int error_str_len)
7247
{
7248
	uint32_t field_size;
7249
	ssize_t avail_len;
7250
	uint32_t print_len;
7251
	uint8_t *num_ptr;
7252
	int retval = 0;
7253

7254
	field_size = scsi_2btoul(hdr->length);
7255
	avail_len = valid_len - sizeof(*hdr);
7256
	print_len = MIN(avail_len, field_size);
7257
	num_ptr = hdr->attribute;
7258

7259
	if (print_len > 0) {
7260
		sbuf_putc(sb, '\n');
7261
		sbuf_hexdump(sb, num_ptr, print_len, NULL, 0);
7262
	}
7263

7264
	return (retval);
7265
}
7266

7267
int
7268
scsi_attrib_int_sbuf(struct sbuf *sb, struct scsi_mam_attribute_header *hdr,
7269
		     uint32_t valid_len, uint32_t flags,
7270
		     uint32_t output_flags, char *error_str,
7271
		     int error_str_len)
7272
{
7273
	uint64_t print_number;
7274
	size_t avail_len;
7275
	uint32_t number_size;
7276
	int retval = 0;
7277

7278
	number_size = scsi_2btoul(hdr->length);
7279

7280
	avail_len = valid_len - sizeof(*hdr);
7281
	if (avail_len < number_size) {
7282
		if (error_str != NULL) {
7283
			snprintf(error_str, error_str_len, "Available "
7284
				 "length of attribute ID 0x%.4x %zu < field "
7285
				 "length %u", scsi_2btoul(hdr->id), avail_len,
7286
				 number_size);
7287
		}
7288
		retval = 1;
7289
		goto bailout;
7290
	}
7291

7292
	switch (number_size) {
7293
	case 0:
7294
		/*
7295
		 * We don't treat this as an error, since there may be
7296
		 * scenarios where a device reports a field but then gives
7297
		 * a length of 0.  See the note in scsi_attrib_ascii_sbuf().
7298
		 */
7299
		goto bailout;
7300
		break; /*NOTREACHED*/
7301
	case 1:
7302
		print_number = hdr->attribute[0];
7303
		break;
7304
	case 2:
7305
		print_number = scsi_2btoul(hdr->attribute);
7306
		break;
7307
	case 3:
7308
		print_number = scsi_3btoul(hdr->attribute);
7309
		break;
7310
	case 4:
7311
		print_number = scsi_4btoul(hdr->attribute);
7312
		break;
7313
	case 8:
7314
		print_number = scsi_8btou64(hdr->attribute);
7315
		break;
7316
	default:
7317
		/*
7318
		 * If we wind up here, the number is too big to print
7319
		 * normally, so just do a hexdump.
7320
		 */
7321
		retval = scsi_attrib_hexdump_sbuf(sb, hdr, valid_len,
7322
						  flags, output_flags,
7323
						  error_str, error_str_len);
7324
		goto bailout;
7325
		break;
7326
	}
7327

7328
	if (flags & SCSI_ATTR_FLAG_FP) {
7329
#ifndef _KERNEL
7330
		long double num_float;
7331

7332
		num_float = (long double)print_number;
7333

7334
		if (flags & SCSI_ATTR_FLAG_DIV_10)
7335
			num_float /= 10;
7336

7337
		sbuf_printf(sb, "%.*Lf", (flags & SCSI_ATTR_FLAG_FP_1DIGIT) ?
7338
			    1 : 0, num_float);
7339
#else /* _KERNEL */
7340
		sbuf_printf(sb, "%ju", (flags & SCSI_ATTR_FLAG_DIV_10) ?
7341
			    (print_number / 10) : print_number);
7342
#endif /* _KERNEL */
7343
	} else if (flags & SCSI_ATTR_FLAG_HEX) {
7344
		sbuf_printf(sb, "0x%jx", (uintmax_t)print_number);
7345
	} else
7346
		sbuf_printf(sb, "%ju", (uintmax_t)print_number);
7347

7348
bailout:
7349
	return (retval);
7350
}
7351

7352
int
7353
scsi_attrib_ascii_sbuf(struct sbuf *sb, struct scsi_mam_attribute_header *hdr,
7354
		       uint32_t valid_len, uint32_t flags,
7355
		       uint32_t output_flags, char *error_str,
7356
		       int error_str_len)
7357
{
7358
	size_t avail_len;
7359
	uint32_t field_size, print_size;
7360
	int retval = 0;
7361

7362
	avail_len = valid_len - sizeof(*hdr);
7363
	field_size = scsi_2btoul(hdr->length);
7364
	print_size = MIN(avail_len, field_size);
7365

7366
	if (print_size > 0) {
7367
		cam_strvis_flags strvis_flags;
7368

7369
		switch (output_flags & SCSI_ATTR_OUTPUT_NONASCII_MASK) {
7370
		case SCSI_ATTR_OUTPUT_NONASCII_TRIM:
7371
			strvis_flags = CAM_STRVIS_FLAG_NONASCII_TRIM;
7372
			break;
7373
		case SCSI_ATTR_OUTPUT_NONASCII_RAW:
7374
			strvis_flags = CAM_STRVIS_FLAG_NONASCII_RAW;
7375
			break;
7376
		case SCSI_ATTR_OUTPUT_NONASCII_ESC:
7377
		default:
7378
			strvis_flags = CAM_STRVIS_FLAG_NONASCII_ESC;
7379
			break;
7380
		}
7381
		cam_strvis_sbuf(sb, hdr->attribute, print_size, strvis_flags);
7382
	} else if (avail_len < field_size) {
7383
		/*
7384
		 * We only report an error if the user didn't allocate
7385
		 * enough space to hold the full value of this field.  If
7386
		 * the field length is 0, that is allowed by the spec.
7387
		 * e.g. in SPC-4r37, section 7.4.2.2.5, VOLUME IDENTIFIER
7388
		 * "This attribute indicates the current volume identifier
7389
		 * (see SMC-3) of the medium. If the device server supports
7390
		 * this attribute but does not have access to the volume
7391
		 * identifier, the device server shall report this attribute
7392
		 * with an attribute length value of zero."
7393
		 */
7394
		if (error_str != NULL) {
7395
			snprintf(error_str, error_str_len, "Available "
7396
				 "length of attribute ID 0x%.4x %zu < field "
7397
				 "length %u", scsi_2btoul(hdr->id), avail_len,
7398
				 field_size);
7399
		}
7400
		retval = 1;
7401
	}
7402

7403
	return (retval);
7404
}
7405

7406
int
7407
scsi_attrib_text_sbuf(struct sbuf *sb, struct scsi_mam_attribute_header *hdr,
7408
		      uint32_t valid_len, uint32_t flags,
7409
		      uint32_t output_flags, char *error_str,
7410
		      int error_str_len)
7411
{
7412
	size_t avail_len;
7413
	uint32_t field_size, print_size;
7414
	int retval = 0;
7415
	int esc_text = 1;
7416

7417
	avail_len = valid_len - sizeof(*hdr);
7418
	field_size = scsi_2btoul(hdr->length);
7419
	print_size = MIN(avail_len, field_size);
7420

7421
	if ((output_flags & SCSI_ATTR_OUTPUT_TEXT_MASK) ==
7422
	     SCSI_ATTR_OUTPUT_TEXT_RAW)
7423
		esc_text = 0;
7424

7425
	if (print_size > 0) {
7426
		uint32_t i;
7427

7428
		for (i = 0; i < print_size; i++) {
7429
			if (hdr->attribute[i] == '\0')
7430
				continue;
7431
			else if (((unsigned char)hdr->attribute[i] < 0x80)
7432
			      || (esc_text == 0))
7433
				sbuf_putc(sb, hdr->attribute[i]);
7434
			else
7435
				sbuf_printf(sb, "%%%02x",
7436
				    (unsigned char)hdr->attribute[i]);
7437
		}
7438
	} else if (avail_len < field_size) {
7439
		/*
7440
		 * We only report an error if the user didn't allocate
7441
		 * enough space to hold the full value of this field.
7442
		 */
7443
		if (error_str != NULL) {
7444
			snprintf(error_str, error_str_len, "Available "
7445
				 "length of attribute ID 0x%.4x %zu < field "
7446
				 "length %u", scsi_2btoul(hdr->id), avail_len,
7447
				 field_size);
7448
		}
7449
		retval = 1;
7450
	}
7451

7452
	return (retval);
7453
}
7454

7455
struct scsi_attrib_table_entry *
7456
scsi_find_attrib_entry(struct scsi_attrib_table_entry *table,
7457
		       size_t num_table_entries, uint32_t id)
7458
{
7459
	uint32_t i;
7460

7461
	for (i = 0; i < num_table_entries; i++) {
7462
		if (table[i].id == id)
7463
			return (&table[i]);
7464
	}
7465

7466
	return (NULL);
7467
}
7468

7469
struct scsi_attrib_table_entry *
7470
scsi_get_attrib_entry(uint32_t id)
7471
{
7472
	return (scsi_find_attrib_entry(scsi_mam_attr_table,
7473
	    nitems(scsi_mam_attr_table), id));
7474
}
7475

7476
int
7477
scsi_attrib_value_sbuf(struct sbuf *sb, uint32_t valid_len,
7478
   struct scsi_mam_attribute_header *hdr, uint32_t output_flags,
7479
   char *error_str, size_t error_str_len)
7480
{
7481
	int retval;
7482

7483
	switch (hdr->byte2 & SMA_FORMAT_MASK) {
7484
	case SMA_FORMAT_ASCII:
7485
		retval = scsi_attrib_ascii_sbuf(sb, hdr, valid_len,
7486
		    SCSI_ATTR_FLAG_NONE, output_flags, error_str,error_str_len);
7487
		break;
7488
	case SMA_FORMAT_BINARY:
7489
		if (scsi_2btoul(hdr->length) <= 8)
7490
			retval = scsi_attrib_int_sbuf(sb, hdr, valid_len,
7491
			    SCSI_ATTR_FLAG_NONE, output_flags, error_str,
7492
			    error_str_len);
7493
		else
7494
			retval = scsi_attrib_hexdump_sbuf(sb, hdr, valid_len,
7495
			    SCSI_ATTR_FLAG_NONE, output_flags, error_str,
7496
			    error_str_len);
7497
		break;
7498
	case SMA_FORMAT_TEXT:
7499
		retval = scsi_attrib_text_sbuf(sb, hdr, valid_len,
7500
		    SCSI_ATTR_FLAG_NONE, output_flags, error_str,
7501
		    error_str_len);
7502
		break;
7503
	default:
7504
		if (error_str != NULL) {
7505
			snprintf(error_str, error_str_len, "Unknown attribute "
7506
			    "format 0x%x", hdr->byte2 & SMA_FORMAT_MASK);
7507
		}
7508
		retval = 1;
7509
		goto bailout;
7510
		break; /*NOTREACHED*/
7511
	}
7512

7513
	sbuf_trim(sb);
7514

7515
bailout:
7516

7517
	return (retval);
7518
}
7519

7520
void
7521
scsi_attrib_prefix_sbuf(struct sbuf *sb, uint32_t output_flags,
7522
			struct scsi_mam_attribute_header *hdr,
7523
			uint32_t valid_len, const char *desc)
7524
{
7525
	int need_space = 0;
7526
	uint32_t len;
7527
	uint32_t id;
7528

7529
	/*
7530
	 * We can't do anything if we don't have enough valid data for the
7531
	 * header.
7532
	 */
7533
	if (valid_len < sizeof(*hdr))
7534
		return;
7535

7536
	id = scsi_2btoul(hdr->id);
7537
	/*
7538
	 * Note that we print out the value of the attribute listed in the
7539
	 * header, regardless of whether we actually got that many bytes
7540
	 * back from the device through the controller.  A truncated result
7541
	 * could be the result of a failure to ask for enough data; the
7542
	 * header indicates how many bytes are allocated for this attribute
7543
	 * in the MAM.
7544
	 */
7545
	len = scsi_2btoul(hdr->length);
7546

7547
	if ((output_flags & SCSI_ATTR_OUTPUT_FIELD_MASK) ==
7548
	    SCSI_ATTR_OUTPUT_FIELD_NONE)
7549
		return;
7550

7551
	if ((output_flags & SCSI_ATTR_OUTPUT_FIELD_DESC)
7552
	 && (desc != NULL)) {
7553
		sbuf_cat(sb, desc);
7554
		need_space = 1;
7555
	}
7556

7557
	if (output_flags & SCSI_ATTR_OUTPUT_FIELD_NUM) {
7558
		sbuf_printf(sb, "%s(0x%.4x)", (need_space) ? " " : "", id);
7559
		need_space = 0;
7560
	}
7561

7562
	if (output_flags & SCSI_ATTR_OUTPUT_FIELD_SIZE) {
7563
		sbuf_printf(sb, "%s[%d]", (need_space) ? " " : "", len);
7564
		need_space = 0;
7565
	}
7566
	if (output_flags & SCSI_ATTR_OUTPUT_FIELD_RW) {
7567
		sbuf_printf(sb, "%s(%s)", (need_space) ? " " : "",
7568
			    (hdr->byte2 & SMA_READ_ONLY) ? "RO" : "RW");
7569
	}
7570
	sbuf_cat(sb, ": ");
7571
}
7572

7573
int
7574
scsi_attrib_sbuf(struct sbuf *sb, struct scsi_mam_attribute_header *hdr,
7575
		 uint32_t valid_len, struct scsi_attrib_table_entry *user_table,
7576
		 size_t num_user_entries, int prefer_user_table,
7577
		 uint32_t output_flags, char *error_str, int error_str_len)
7578
{
7579
	int retval;
7580
	struct scsi_attrib_table_entry *table1 = NULL, *table2 = NULL;
7581
	struct scsi_attrib_table_entry *entry = NULL;
7582
	size_t table1_size = 0, table2_size = 0;
7583
	uint32_t id;
7584

7585
	retval = 0;
7586

7587
	if (valid_len < sizeof(*hdr)) {
7588
		retval = 1;
7589
		goto bailout;
7590
	}
7591

7592
	id = scsi_2btoul(hdr->id);
7593

7594
	if (user_table != NULL) {
7595
		if (prefer_user_table != 0) {
7596
			table1 = user_table;
7597
			table1_size = num_user_entries;
7598
			table2 = scsi_mam_attr_table;
7599
			table2_size = nitems(scsi_mam_attr_table);
7600
		} else {
7601
			table1 = scsi_mam_attr_table;
7602
			table1_size = nitems(scsi_mam_attr_table);
7603
			table2 = user_table;
7604
			table2_size = num_user_entries;
7605
		}
7606
	} else {
7607
		table1 = scsi_mam_attr_table;
7608
		table1_size = nitems(scsi_mam_attr_table);
7609
	}
7610

7611
	entry = scsi_find_attrib_entry(table1, table1_size, id);
7612
	if (entry != NULL) {
7613
		scsi_attrib_prefix_sbuf(sb, output_flags, hdr, valid_len,
7614
					entry->desc);
7615
		if (entry->to_str == NULL)
7616
			goto print_default;
7617
		retval = entry->to_str(sb, hdr, valid_len, entry->flags,
7618
				       output_flags, error_str, error_str_len);
7619
		goto bailout;
7620
	}
7621
	if (table2 != NULL) {
7622
		entry = scsi_find_attrib_entry(table2, table2_size, id);
7623
		if (entry != NULL) {
7624
			if (entry->to_str == NULL)
7625
				goto print_default;
7626

7627
			scsi_attrib_prefix_sbuf(sb, output_flags, hdr,
7628
						valid_len, entry->desc);
7629
			retval = entry->to_str(sb, hdr, valid_len, entry->flags,
7630
					       output_flags, error_str,
7631
					       error_str_len);
7632
			goto bailout;
7633
		}
7634
	}
7635

7636
	scsi_attrib_prefix_sbuf(sb, output_flags, hdr, valid_len, NULL);
7637

7638
print_default:
7639
	retval = scsi_attrib_value_sbuf(sb, valid_len, hdr, output_flags,
7640
	    error_str, error_str_len);
7641
bailout:
7642
	if (retval == 0) {
7643
	 	if ((entry != NULL)
7644
		 && (entry->suffix != NULL))
7645
			sbuf_printf(sb, " %s", entry->suffix);
7646

7647
		sbuf_trim(sb);
7648
		sbuf_putc(sb, '\n');
7649
	}
7650

7651
	return (retval);
7652
}
7653

7654
void
7655
scsi_test_unit_ready(struct ccb_scsiio *csio, uint32_t retries,
7656
		     void (*cbfcnp)(struct cam_periph *, union ccb *),
7657
		     uint8_t tag_action, uint8_t sense_len, uint32_t timeout)
7658
{
7659
	struct scsi_test_unit_ready *scsi_cmd;
7660

7661
	cam_fill_csio(csio,
7662
		      retries,
7663
		      cbfcnp,
7664
		      CAM_DIR_NONE,
7665
		      tag_action,
7666
		      /*data_ptr*/NULL,
7667
		      /*dxfer_len*/0,
7668
		      sense_len,
7669
		      sizeof(*scsi_cmd),
7670
		      timeout);
7671

7672
	scsi_cmd = (struct scsi_test_unit_ready *)&csio->cdb_io.cdb_bytes;
7673
	bzero(scsi_cmd, sizeof(*scsi_cmd));
7674
	scsi_cmd->opcode = TEST_UNIT_READY;
7675
}
7676

7677
void
7678
scsi_request_sense(struct ccb_scsiio *csio, uint32_t retries,
7679
		   void (*cbfcnp)(struct cam_periph *, union ccb *),
7680
		   void *data_ptr, uint8_t dxfer_len, uint8_t tag_action,
7681
		   uint8_t sense_len, uint32_t timeout)
7682
{
7683
	struct scsi_request_sense *scsi_cmd;
7684

7685
	cam_fill_csio(csio,
7686
		      retries,
7687
		      cbfcnp,
7688
		      CAM_DIR_IN,
7689
		      tag_action,
7690
		      data_ptr,
7691
		      dxfer_len,
7692
		      sense_len,
7693
		      sizeof(*scsi_cmd),
7694
		      timeout);
7695

7696
	scsi_cmd = (struct scsi_request_sense *)&csio->cdb_io.cdb_bytes;
7697
	bzero(scsi_cmd, sizeof(*scsi_cmd));
7698
	scsi_cmd->opcode = REQUEST_SENSE;
7699
	scsi_cmd->length = dxfer_len;
7700
}
7701

7702
void
7703
scsi_inquiry(struct ccb_scsiio *csio, uint32_t retries,
7704
	     void (*cbfcnp)(struct cam_periph *, union ccb *),
7705
	     uint8_t tag_action, uint8_t *inq_buf, uint32_t inq_len,
7706
	     int evpd, uint8_t page_code, uint8_t sense_len,
7707
	     uint32_t timeout)
7708
{
7709
	struct scsi_inquiry *scsi_cmd;
7710

7711
	cam_fill_csio(csio,
7712
		      retries,
7713
		      cbfcnp,
7714
		      /*flags*/CAM_DIR_IN,
7715
		      tag_action,
7716
		      /*data_ptr*/inq_buf,
7717
		      /*dxfer_len*/inq_len,
7718
		      sense_len,
7719
		      sizeof(*scsi_cmd),
7720
		      timeout);
7721

7722
	scsi_cmd = (struct scsi_inquiry *)&csio->cdb_io.cdb_bytes;
7723
	bzero(scsi_cmd, sizeof(*scsi_cmd));
7724
	scsi_cmd->opcode = INQUIRY;
7725
	if (evpd) {
7726
		scsi_cmd->byte2 |= SI_EVPD;
7727
		scsi_cmd->page_code = page_code;
7728
	}
7729
	scsi_ulto2b(inq_len, scsi_cmd->length);
7730
}
7731

7732
void
7733
scsi_mode_sense(struct ccb_scsiio *csio, uint32_t retries,
7734
    void (*cbfcnp)(struct cam_periph *, union ccb *), uint8_t tag_action,
7735
    int dbd, uint8_t pc, uint8_t page, uint8_t *param_buf, uint32_t param_len,
7736
    uint8_t sense_len, uint32_t timeout)
7737
{
7738

7739
	scsi_mode_sense_subpage(csio, retries, cbfcnp, tag_action, dbd,
7740
	    pc, page, 0, param_buf, param_len, 0, sense_len, timeout);
7741
}
7742

7743
void
7744
scsi_mode_sense_len(struct ccb_scsiio *csio, uint32_t retries,
7745
    void (*cbfcnp)(struct cam_periph *, union ccb *), uint8_t tag_action,
7746
    int dbd, uint8_t pc, uint8_t page, uint8_t *param_buf, uint32_t param_len,
7747
    int minimum_cmd_size, uint8_t sense_len, uint32_t timeout)
7748
{
7749

7750
	scsi_mode_sense_subpage(csio, retries, cbfcnp, tag_action, dbd,
7751
	    pc, page, 0, param_buf, param_len, minimum_cmd_size,
7752
	    sense_len, timeout);
7753
}
7754

7755
void
7756
scsi_mode_sense_subpage(struct ccb_scsiio *csio, uint32_t retries,
7757
    void (*cbfcnp)(struct cam_periph *, union ccb *), uint8_t tag_action,
7758
    int dbd, uint8_t pc, uint8_t page, uint8_t subpage, uint8_t *param_buf,
7759
    uint32_t param_len, int minimum_cmd_size, uint8_t sense_len,
7760
    uint32_t timeout)
7761
{
7762
	uint8_t cdb_len;
7763

7764
	/*
7765
	 * Use the smallest possible command to perform the operation.
7766
	 */
7767
	if ((param_len < 256)
7768
	 && (minimum_cmd_size < 10)) {
7769
		/*
7770
		 * We can fit in a 6 byte cdb.
7771
		 */
7772
		struct scsi_mode_sense_6 *scsi_cmd;
7773

7774
		scsi_cmd = (struct scsi_mode_sense_6 *)&csio->cdb_io.cdb_bytes;
7775
		bzero(scsi_cmd, sizeof(*scsi_cmd));
7776
		scsi_cmd->opcode = MODE_SENSE_6;
7777
		if (dbd != 0)
7778
			scsi_cmd->byte2 |= SMS_DBD;
7779
		scsi_cmd->page = pc | page;
7780
		scsi_cmd->subpage = subpage;
7781
		scsi_cmd->length = param_len;
7782
		cdb_len = sizeof(*scsi_cmd);
7783
	} else {
7784
		/*
7785
		 * Need a 10 byte cdb.
7786
		 */
7787
		struct scsi_mode_sense_10 *scsi_cmd;
7788

7789
		scsi_cmd = (struct scsi_mode_sense_10 *)&csio->cdb_io.cdb_bytes;
7790
		bzero(scsi_cmd, sizeof(*scsi_cmd));
7791
		scsi_cmd->opcode = MODE_SENSE_10;
7792
		if (dbd != 0)
7793
			scsi_cmd->byte2 |= SMS_DBD;
7794
		scsi_cmd->page = pc | page;
7795
		scsi_cmd->subpage = subpage;
7796
		scsi_ulto2b(param_len, scsi_cmd->length);
7797
		cdb_len = sizeof(*scsi_cmd);
7798
	}
7799
	cam_fill_csio(csio,
7800
		      retries,
7801
		      cbfcnp,
7802
		      CAM_DIR_IN,
7803
		      tag_action,
7804
		      param_buf,
7805
		      param_len,
7806
		      sense_len,
7807
		      cdb_len,
7808
		      timeout);
7809
}
7810

7811
void
7812
scsi_mode_select(struct ccb_scsiio *csio, uint32_t retries,
7813
		 void (*cbfcnp)(struct cam_periph *, union ccb *),
7814
		 uint8_t tag_action, int scsi_page_fmt, int save_pages,
7815
		 uint8_t *param_buf, uint32_t param_len, uint8_t sense_len,
7816
		 uint32_t timeout)
7817
{
7818
	scsi_mode_select_len(csio, retries, cbfcnp, tag_action,
7819
			     scsi_page_fmt, save_pages, param_buf,
7820
			     param_len, 0, sense_len, timeout);
7821
}
7822

7823
void
7824
scsi_mode_select_len(struct ccb_scsiio *csio, uint32_t retries,
7825
		     void (*cbfcnp)(struct cam_periph *, union ccb *),
7826
		     uint8_t tag_action, int scsi_page_fmt, int save_pages,
7827
		     uint8_t *param_buf, uint32_t param_len,
7828
		     int minimum_cmd_size, uint8_t sense_len,
7829
		     uint32_t timeout)
7830
{
7831
	uint8_t cdb_len;
7832

7833
	/*
7834
	 * Use the smallest possible command to perform the operation.
7835
	 */
7836
	if ((param_len < 256)
7837
	 && (minimum_cmd_size < 10)) {
7838
		/*
7839
		 * We can fit in a 6 byte cdb.
7840
		 */
7841
		struct scsi_mode_select_6 *scsi_cmd;
7842

7843
		scsi_cmd = (struct scsi_mode_select_6 *)&csio->cdb_io.cdb_bytes;
7844
		bzero(scsi_cmd, sizeof(*scsi_cmd));
7845
		scsi_cmd->opcode = MODE_SELECT_6;
7846
		if (scsi_page_fmt != 0)
7847
			scsi_cmd->byte2 |= SMS_PF;
7848
		if (save_pages != 0)
7849
			scsi_cmd->byte2 |= SMS_SP;
7850
		scsi_cmd->length = param_len;
7851
		cdb_len = sizeof(*scsi_cmd);
7852
	} else {
7853
		/*
7854
		 * Need a 10 byte cdb.
7855
		 */
7856
		struct scsi_mode_select_10 *scsi_cmd;
7857

7858
		scsi_cmd =
7859
		    (struct scsi_mode_select_10 *)&csio->cdb_io.cdb_bytes;
7860
		bzero(scsi_cmd, sizeof(*scsi_cmd));
7861
		scsi_cmd->opcode = MODE_SELECT_10;
7862
		if (scsi_page_fmt != 0)
7863
			scsi_cmd->byte2 |= SMS_PF;
7864
		if (save_pages != 0)
7865
			scsi_cmd->byte2 |= SMS_SP;
7866
		scsi_ulto2b(param_len, scsi_cmd->length);
7867
		cdb_len = sizeof(*scsi_cmd);
7868
	}
7869
	cam_fill_csio(csio,
7870
		      retries,
7871
		      cbfcnp,
7872
		      CAM_DIR_OUT,
7873
		      tag_action,
7874
		      param_buf,
7875
		      param_len,
7876
		      sense_len,
7877
		      cdb_len,
7878
		      timeout);
7879
}
7880

7881
void
7882
scsi_log_sense(struct ccb_scsiio *csio, uint32_t retries,
7883
	       void (*cbfcnp)(struct cam_periph *, union ccb *),
7884
	       uint8_t tag_action, uint8_t page_code, uint8_t page,
7885
	       int save_pages, int ppc, uint32_t paramptr,
7886
	       uint8_t *param_buf, uint32_t param_len, uint8_t sense_len,
7887
	       uint32_t timeout)
7888
{
7889
	struct scsi_log_sense *scsi_cmd;
7890
	uint8_t cdb_len;
7891

7892
	scsi_cmd = (struct scsi_log_sense *)&csio->cdb_io.cdb_bytes;
7893
	bzero(scsi_cmd, sizeof(*scsi_cmd));
7894
	scsi_cmd->opcode = LOG_SENSE;
7895
	scsi_cmd->page = page_code | page;
7896
	if (save_pages != 0)
7897
		scsi_cmd->byte2 |= SLS_SP;
7898
	if (ppc != 0)
7899
		scsi_cmd->byte2 |= SLS_PPC;
7900
	scsi_ulto2b(paramptr, scsi_cmd->paramptr);
7901
	scsi_ulto2b(param_len, scsi_cmd->length);
7902
	cdb_len = sizeof(*scsi_cmd);
7903

7904
	cam_fill_csio(csio,
7905
		      retries,
7906
		      cbfcnp,
7907
		      /*flags*/CAM_DIR_IN,
7908
		      tag_action,
7909
		      /*data_ptr*/param_buf,
7910
		      /*dxfer_len*/param_len,
7911
		      sense_len,
7912
		      cdb_len,
7913
		      timeout);
7914
}
7915

7916
void
7917
scsi_log_select(struct ccb_scsiio *csio, uint32_t retries,
7918
		void (*cbfcnp)(struct cam_periph *, union ccb *),
7919
		uint8_t tag_action, uint8_t page_code, int save_pages,
7920
		int pc_reset, uint8_t *param_buf, uint32_t param_len,
7921
		uint8_t sense_len, uint32_t timeout)
7922
{
7923
	struct scsi_log_select *scsi_cmd;
7924
	uint8_t cdb_len;
7925

7926
	scsi_cmd = (struct scsi_log_select *)&csio->cdb_io.cdb_bytes;
7927
	bzero(scsi_cmd, sizeof(*scsi_cmd));
7928
	scsi_cmd->opcode = LOG_SELECT;
7929
	scsi_cmd->page = page_code & SLS_PAGE_CODE;
7930
	if (save_pages != 0)
7931
		scsi_cmd->byte2 |= SLS_SP;
7932
	if (pc_reset != 0)
7933
		scsi_cmd->byte2 |= SLS_PCR;
7934
	scsi_ulto2b(param_len, scsi_cmd->length);
7935
	cdb_len = sizeof(*scsi_cmd);
7936

7937
	cam_fill_csio(csio,
7938
		      retries,
7939
		      cbfcnp,
7940
		      /*flags*/CAM_DIR_OUT,
7941
		      tag_action,
7942
		      /*data_ptr*/param_buf,
7943
		      /*dxfer_len*/param_len,
7944
		      sense_len,
7945
		      cdb_len,
7946
		      timeout);
7947
}
7948

7949
/*
7950
 * Prevent or allow the user to remove the media
7951
 */
7952
void
7953
scsi_prevent(struct ccb_scsiio *csio, uint32_t retries,
7954
	     void (*cbfcnp)(struct cam_periph *, union ccb *),
7955
	     uint8_t tag_action, uint8_t action,
7956
	     uint8_t sense_len, uint32_t timeout)
7957
{
7958
	struct scsi_prevent *scsi_cmd;
7959

7960
	cam_fill_csio(csio,
7961
		      retries,
7962
		      cbfcnp,
7963
		      /*flags*/CAM_DIR_NONE,
7964
		      tag_action,
7965
		      /*data_ptr*/NULL,
7966
		      /*dxfer_len*/0,
7967
		      sense_len,
7968
		      sizeof(*scsi_cmd),
7969
		      timeout);
7970

7971
	scsi_cmd = (struct scsi_prevent *)&csio->cdb_io.cdb_bytes;
7972
	bzero(scsi_cmd, sizeof(*scsi_cmd));
7973
	scsi_cmd->opcode = PREVENT_ALLOW;
7974
	scsi_cmd->how = action;
7975
}
7976

7977
/* XXX allow specification of address and PMI bit and LBA */
7978
void
7979
scsi_read_capacity(struct ccb_scsiio *csio, uint32_t retries,
7980
		   void (*cbfcnp)(struct cam_periph *, union ccb *),
7981
		   uint8_t tag_action,
7982
		   struct scsi_read_capacity_data *rcap_buf,
7983
		   uint8_t sense_len, uint32_t timeout)
7984
{
7985
	struct scsi_read_capacity *scsi_cmd;
7986

7987
	cam_fill_csio(csio,
7988
		      retries,
7989
		      cbfcnp,
7990
		      /*flags*/CAM_DIR_IN,
7991
		      tag_action,
7992
		      /*data_ptr*/(uint8_t *)rcap_buf,
7993
		      /*dxfer_len*/sizeof(*rcap_buf),
7994
		      sense_len,
7995
		      sizeof(*scsi_cmd),
7996
		      timeout);
7997

7998
	scsi_cmd = (struct scsi_read_capacity *)&csio->cdb_io.cdb_bytes;
7999
	bzero(scsi_cmd, sizeof(*scsi_cmd));
8000
	scsi_cmd->opcode = READ_CAPACITY;
8001
}
8002

8003
void
8004
scsi_read_capacity_16(struct ccb_scsiio *csio, uint32_t retries,
8005
		      void (*cbfcnp)(struct cam_periph *, union ccb *),
8006
		      uint8_t tag_action, uint64_t lba, int reladr, int pmi,
8007
		      uint8_t *rcap_buf, int rcap_buf_len, uint8_t sense_len,
8008
		      uint32_t timeout)
8009
{
8010
	struct scsi_read_capacity_16 *scsi_cmd;
8011

8012
	cam_fill_csio(csio,
8013
		      retries,
8014
		      cbfcnp,
8015
		      /*flags*/CAM_DIR_IN,
8016
		      tag_action,
8017
		      /*data_ptr*/(uint8_t *)rcap_buf,
8018
		      /*dxfer_len*/rcap_buf_len,
8019
		      sense_len,
8020
		      sizeof(*scsi_cmd),
8021
		      timeout);
8022
	scsi_cmd = (struct scsi_read_capacity_16 *)&csio->cdb_io.cdb_bytes;
8023
	bzero(scsi_cmd, sizeof(*scsi_cmd));
8024
	scsi_cmd->opcode = SERVICE_ACTION_IN;
8025
	scsi_cmd->service_action = SRC16_SERVICE_ACTION;
8026
	scsi_u64to8b(lba, scsi_cmd->addr);
8027
	scsi_ulto4b(rcap_buf_len, scsi_cmd->alloc_len);
8028
	if (pmi)
8029
		scsi_cmd->reladr |= SRC16_PMI;
8030
	if (reladr)
8031
		scsi_cmd->reladr |= SRC16_RELADR;
8032
}
8033

8034
void
8035
scsi_report_luns(struct ccb_scsiio *csio, uint32_t retries,
8036
		 void (*cbfcnp)(struct cam_periph *, union ccb *),
8037
		 uint8_t tag_action, uint8_t select_report,
8038
		 struct scsi_report_luns_data *rpl_buf, uint32_t alloc_len,
8039
		 uint8_t sense_len, uint32_t timeout)
8040
{
8041
	struct scsi_report_luns *scsi_cmd;
8042

8043
	cam_fill_csio(csio,
8044
		      retries,
8045
		      cbfcnp,
8046
		      /*flags*/CAM_DIR_IN,
8047
		      tag_action,
8048
		      /*data_ptr*/(uint8_t *)rpl_buf,
8049
		      /*dxfer_len*/alloc_len,
8050
		      sense_len,
8051
		      sizeof(*scsi_cmd),
8052
		      timeout);
8053
	scsi_cmd = (struct scsi_report_luns *)&csio->cdb_io.cdb_bytes;
8054
	bzero(scsi_cmd, sizeof(*scsi_cmd));
8055
	scsi_cmd->opcode = REPORT_LUNS;
8056
	scsi_cmd->select_report = select_report;
8057
	scsi_ulto4b(alloc_len, scsi_cmd->length);
8058
}
8059

8060
void
8061
scsi_report_target_group(struct ccb_scsiio *csio, uint32_t retries,
8062
		 void (*cbfcnp)(struct cam_periph *, union ccb *),
8063
		 uint8_t tag_action, uint8_t pdf,
8064
		 void *buf, uint32_t alloc_len,
8065
		 uint8_t sense_len, uint32_t timeout)
8066
{
8067
	struct scsi_target_group *scsi_cmd;
8068

8069
	cam_fill_csio(csio,
8070
		      retries,
8071
		      cbfcnp,
8072
		      /*flags*/CAM_DIR_IN,
8073
		      tag_action,
8074
		      /*data_ptr*/(uint8_t *)buf,
8075
		      /*dxfer_len*/alloc_len,
8076
		      sense_len,
8077
		      sizeof(*scsi_cmd),
8078
		      timeout);
8079
	scsi_cmd = (struct scsi_target_group *)&csio->cdb_io.cdb_bytes;
8080
	bzero(scsi_cmd, sizeof(*scsi_cmd));
8081
	scsi_cmd->opcode = MAINTENANCE_IN;
8082
	scsi_cmd->service_action = REPORT_TARGET_PORT_GROUPS | pdf;
8083
	scsi_ulto4b(alloc_len, scsi_cmd->length);
8084
}
8085

8086
void
8087
scsi_report_timestamp(struct ccb_scsiio *csio, uint32_t retries,
8088
		 void (*cbfcnp)(struct cam_periph *, union ccb *),
8089
		 uint8_t tag_action, uint8_t pdf,
8090
		 void *buf, uint32_t alloc_len,
8091
		 uint8_t sense_len, uint32_t timeout)
8092
{
8093
	struct scsi_timestamp *scsi_cmd;
8094

8095
	cam_fill_csio(csio,
8096
		      retries,
8097
		      cbfcnp,
8098
		      /*flags*/CAM_DIR_IN,
8099
		      tag_action,
8100
		      /*data_ptr*/(uint8_t *)buf,
8101
		      /*dxfer_len*/alloc_len,
8102
		      sense_len,
8103
		      sizeof(*scsi_cmd),
8104
		      timeout);
8105
	scsi_cmd = (struct scsi_timestamp *)&csio->cdb_io.cdb_bytes;
8106
	bzero(scsi_cmd, sizeof(*scsi_cmd));
8107
	scsi_cmd->opcode = MAINTENANCE_IN;
8108
	scsi_cmd->service_action = REPORT_TIMESTAMP | pdf;
8109
	scsi_ulto4b(alloc_len, scsi_cmd->length);
8110
}
8111

8112
void
8113
scsi_set_target_group(struct ccb_scsiio *csio, uint32_t retries,
8114
		 void (*cbfcnp)(struct cam_periph *, union ccb *),
8115
		 uint8_t tag_action, void *buf, uint32_t alloc_len,
8116
		 uint8_t sense_len, uint32_t timeout)
8117
{
8118
	struct scsi_target_group *scsi_cmd;
8119

8120
	cam_fill_csio(csio,
8121
		      retries,
8122
		      cbfcnp,
8123
		      /*flags*/CAM_DIR_OUT,
8124
		      tag_action,
8125
		      /*data_ptr*/(uint8_t *)buf,
8126
		      /*dxfer_len*/alloc_len,
8127
		      sense_len,
8128
		      sizeof(*scsi_cmd),
8129
		      timeout);
8130
	scsi_cmd = (struct scsi_target_group *)&csio->cdb_io.cdb_bytes;
8131
	bzero(scsi_cmd, sizeof(*scsi_cmd));
8132
	scsi_cmd->opcode = MAINTENANCE_OUT;
8133
	scsi_cmd->service_action = SET_TARGET_PORT_GROUPS;
8134
	scsi_ulto4b(alloc_len, scsi_cmd->length);
8135
}
8136

8137
void
8138
scsi_create_timestamp(uint8_t *timestamp_6b_buf,
8139
		      uint64_t timestamp)
8140
{
8141
	uint8_t buf[8];
8142
	scsi_u64to8b(timestamp, buf);
8143
	/*
8144
	 * Using memcopy starting at buf[2] because the set timestamp parameters
8145
	 * only has six bytes for the timestamp to fit into, and we don't have a
8146
	 * scsi_u64to6b function.
8147
	 */
8148
	memcpy(timestamp_6b_buf, &buf[2], 6);
8149
}
8150

8151
void
8152
scsi_set_timestamp(struct ccb_scsiio *csio, uint32_t retries,
8153
		   void (*cbfcnp)(struct cam_periph *, union ccb *),
8154
		   uint8_t tag_action, void *buf, uint32_t alloc_len,
8155
		   uint8_t sense_len, uint32_t timeout)
8156
{
8157
	struct scsi_timestamp *scsi_cmd;
8158

8159
	cam_fill_csio(csio,
8160
		      retries,
8161
		      cbfcnp,
8162
		      /*flags*/CAM_DIR_OUT,
8163
		      tag_action,
8164
		      /*data_ptr*/(uint8_t *) buf,
8165
		      /*dxfer_len*/alloc_len,
8166
		      sense_len,
8167
		      sizeof(*scsi_cmd),
8168
		      timeout);
8169
	scsi_cmd = (struct scsi_timestamp *)&csio->cdb_io.cdb_bytes;
8170
	bzero(scsi_cmd, sizeof(*scsi_cmd));
8171
	scsi_cmd->opcode = MAINTENANCE_OUT;
8172
	scsi_cmd->service_action = SET_TIMESTAMP;
8173
	scsi_ulto4b(alloc_len, scsi_cmd->length);
8174
}
8175

8176
/*
8177
 * Syncronize the media to the contents of the cache for
8178
 * the given lba/count pair.  Specifying 0/0 means sync
8179
 * the whole cache.
8180
 */
8181
void
8182
scsi_synchronize_cache(struct ccb_scsiio *csio, uint32_t retries,
8183
		       void (*cbfcnp)(struct cam_periph *, union ccb *),
8184
		       uint8_t tag_action, uint32_t begin_lba,
8185
		       uint16_t lb_count, uint8_t sense_len,
8186
		       uint32_t timeout)
8187
{
8188
	struct scsi_sync_cache *scsi_cmd;
8189

8190
	cam_fill_csio(csio,
8191
		      retries,
8192
		      cbfcnp,
8193
		      /*flags*/CAM_DIR_NONE,
8194
		      tag_action,
8195
		      /*data_ptr*/NULL,
8196
		      /*dxfer_len*/0,
8197
		      sense_len,
8198
		      sizeof(*scsi_cmd),
8199
		      timeout);
8200

8201
	scsi_cmd = (struct scsi_sync_cache *)&csio->cdb_io.cdb_bytes;
8202
	bzero(scsi_cmd, sizeof(*scsi_cmd));
8203
	scsi_cmd->opcode = SYNCHRONIZE_CACHE;
8204
	scsi_ulto4b(begin_lba, scsi_cmd->begin_lba);
8205
	scsi_ulto2b(lb_count, scsi_cmd->lb_count);
8206
}
8207

8208
void
8209
scsi_read_write(struct ccb_scsiio *csio, uint32_t retries,
8210
		void (*cbfcnp)(struct cam_periph *, union ccb *),
8211
		uint8_t tag_action, int readop, uint8_t byte2,
8212
		int minimum_cmd_size, uint64_t lba, uint32_t block_count,
8213
		uint8_t *data_ptr, uint32_t dxfer_len, uint8_t sense_len,
8214
		uint32_t timeout)
8215
{
8216
	int read;
8217
	uint8_t cdb_len;
8218

8219
	read = (readop & SCSI_RW_DIRMASK) == SCSI_RW_READ;
8220

8221
	/*
8222
	 * Use the smallest possible command to perform the operation
8223
	 * as some legacy hardware does not support the 10 byte commands.
8224
	 * If any of the bits in byte2 is set, we have to go with a larger
8225
	 * command.
8226
	 */
8227
	if ((minimum_cmd_size < 10)
8228
	 && ((lba & 0x1fffff) == lba)
8229
	 && ((block_count & 0xff) == block_count)
8230
	 && (byte2 == 0)) {
8231
		/*
8232
		 * We can fit in a 6 byte cdb.
8233
		 */
8234
		struct scsi_rw_6 *scsi_cmd;
8235

8236
		scsi_cmd = (struct scsi_rw_6 *)&csio->cdb_io.cdb_bytes;
8237
		scsi_cmd->opcode = read ? READ_6 : WRITE_6;
8238
		scsi_ulto3b(lba, scsi_cmd->addr);
8239
		scsi_cmd->length = block_count & 0xff;
8240
		scsi_cmd->control = 0;
8241
		cdb_len = sizeof(*scsi_cmd);
8242

8243
		CAM_DEBUG(csio->ccb_h.path, CAM_DEBUG_SUBTRACE,
8244
			  ("6byte: %x%x%x:%d:%d\n", scsi_cmd->addr[0],
8245
			   scsi_cmd->addr[1], scsi_cmd->addr[2],
8246
			   scsi_cmd->length, dxfer_len));
8247
	} else if ((minimum_cmd_size < 12)
8248
		&& ((block_count & 0xffff) == block_count)
8249
		&& ((lba & 0xffffffff) == lba)) {
8250
		/*
8251
		 * Need a 10 byte cdb.
8252
		 */
8253
		struct scsi_rw_10 *scsi_cmd;
8254

8255
		scsi_cmd = (struct scsi_rw_10 *)&csio->cdb_io.cdb_bytes;
8256
		scsi_cmd->opcode = read ? READ_10 : WRITE_10;
8257
		scsi_cmd->byte2 = byte2;
8258
		scsi_ulto4b(lba, scsi_cmd->addr);
8259
		scsi_cmd->reserved = 0;
8260
		scsi_ulto2b(block_count, scsi_cmd->length);
8261
		scsi_cmd->control = 0;
8262
		cdb_len = sizeof(*scsi_cmd);
8263

8264
		CAM_DEBUG(csio->ccb_h.path, CAM_DEBUG_SUBTRACE,
8265
			  ("10byte: %x%x%x%x:%x%x: %d\n", scsi_cmd->addr[0],
8266
			   scsi_cmd->addr[1], scsi_cmd->addr[2],
8267
			   scsi_cmd->addr[3], scsi_cmd->length[0],
8268
			   scsi_cmd->length[1], dxfer_len));
8269
	} else if ((minimum_cmd_size < 16)
8270
		&& ((block_count & 0xffffffff) == block_count)
8271
		&& ((lba & 0xffffffff) == lba)) {
8272
		/*
8273
		 * The block count is too big for a 10 byte CDB, use a 12
8274
		 * byte CDB.
8275
		 */
8276
		struct scsi_rw_12 *scsi_cmd;
8277

8278
		scsi_cmd = (struct scsi_rw_12 *)&csio->cdb_io.cdb_bytes;
8279
		scsi_cmd->opcode = read ? READ_12 : WRITE_12;
8280
		scsi_cmd->byte2 = byte2;
8281
		scsi_ulto4b(lba, scsi_cmd->addr);
8282
		scsi_cmd->reserved = 0;
8283
		scsi_ulto4b(block_count, scsi_cmd->length);
8284
		scsi_cmd->control = 0;
8285
		cdb_len = sizeof(*scsi_cmd);
8286

8287
		CAM_DEBUG(csio->ccb_h.path, CAM_DEBUG_SUBTRACE,
8288
			  ("12byte: %x%x%x%x:%x%x%x%x: %d\n", scsi_cmd->addr[0],
8289
			   scsi_cmd->addr[1], scsi_cmd->addr[2],
8290
			   scsi_cmd->addr[3], scsi_cmd->length[0],
8291
			   scsi_cmd->length[1], scsi_cmd->length[2],
8292
			   scsi_cmd->length[3], dxfer_len));
8293
	} else {
8294
		/*
8295
		 * 16 byte CDB.  We'll only get here if the LBA is larger
8296
		 * than 2^32, or if the user asks for a 16 byte command.
8297
		 */
8298
		struct scsi_rw_16 *scsi_cmd;
8299

8300
		scsi_cmd = (struct scsi_rw_16 *)&csio->cdb_io.cdb_bytes;
8301
		scsi_cmd->opcode = read ? READ_16 : WRITE_16;
8302
		scsi_cmd->byte2 = byte2;
8303
		scsi_u64to8b(lba, scsi_cmd->addr);
8304
		scsi_cmd->reserved = 0;
8305
		scsi_ulto4b(block_count, scsi_cmd->length);
8306
		scsi_cmd->control = 0;
8307
		cdb_len = sizeof(*scsi_cmd);
8308
	}
8309
	cam_fill_csio(csio,
8310
		      retries,
8311
		      cbfcnp,
8312
		      (read ? CAM_DIR_IN : CAM_DIR_OUT) |
8313
		      ((readop & SCSI_RW_BIO) != 0 ? CAM_DATA_BIO : 0),
8314
		      tag_action,
8315
		      data_ptr,
8316
		      dxfer_len,
8317
		      sense_len,
8318
		      cdb_len,
8319
		      timeout);
8320
}
8321

8322
void
8323
scsi_write_same(struct ccb_scsiio *csio, uint32_t retries,
8324
		void (*cbfcnp)(struct cam_periph *, union ccb *),
8325
		uint8_t tag_action, uint8_t byte2,
8326
		int minimum_cmd_size, uint64_t lba, uint32_t block_count,
8327
		uint8_t *data_ptr, uint32_t dxfer_len, uint8_t sense_len,
8328
		uint32_t timeout)
8329
{
8330
	uint8_t cdb_len;
8331
	if ((minimum_cmd_size < 16) &&
8332
	    ((block_count & 0xffff) == block_count) &&
8333
	    ((lba & 0xffffffff) == lba)) {
8334
		/*
8335
		 * Need a 10 byte cdb.
8336
		 */
8337
		struct scsi_write_same_10 *scsi_cmd;
8338

8339
		scsi_cmd = (struct scsi_write_same_10 *)&csio->cdb_io.cdb_bytes;
8340
		scsi_cmd->opcode = WRITE_SAME_10;
8341
		scsi_cmd->byte2 = byte2;
8342
		scsi_ulto4b(lba, scsi_cmd->addr);
8343
		scsi_cmd->group = 0;
8344
		scsi_ulto2b(block_count, scsi_cmd->length);
8345
		scsi_cmd->control = 0;
8346
		cdb_len = sizeof(*scsi_cmd);
8347

8348
		CAM_DEBUG(csio->ccb_h.path, CAM_DEBUG_SUBTRACE,
8349
			  ("10byte: %x%x%x%x:%x%x: %d\n", scsi_cmd->addr[0],
8350
			   scsi_cmd->addr[1], scsi_cmd->addr[2],
8351
			   scsi_cmd->addr[3], scsi_cmd->length[0],
8352
			   scsi_cmd->length[1], dxfer_len));
8353
	} else {
8354
		/*
8355
		 * 16 byte CDB.  We'll only get here if the LBA is larger
8356
		 * than 2^32, or if the user asks for a 16 byte command.
8357
		 */
8358
		struct scsi_write_same_16 *scsi_cmd;
8359

8360
		scsi_cmd = (struct scsi_write_same_16 *)&csio->cdb_io.cdb_bytes;
8361
		scsi_cmd->opcode = WRITE_SAME_16;
8362
		scsi_cmd->byte2 = byte2;
8363
		scsi_u64to8b(lba, scsi_cmd->addr);
8364
		scsi_ulto4b(block_count, scsi_cmd->length);
8365
		scsi_cmd->group = 0;
8366
		scsi_cmd->control = 0;
8367
		cdb_len = sizeof(*scsi_cmd);
8368

8369
		CAM_DEBUG(csio->ccb_h.path, CAM_DEBUG_SUBTRACE,
8370
			  ("16byte: %x%x%x%x%x%x%x%x:%x%x%x%x: %d\n",
8371
			   scsi_cmd->addr[0], scsi_cmd->addr[1],
8372
			   scsi_cmd->addr[2], scsi_cmd->addr[3],
8373
			   scsi_cmd->addr[4], scsi_cmd->addr[5],
8374
			   scsi_cmd->addr[6], scsi_cmd->addr[7],
8375
			   scsi_cmd->length[0], scsi_cmd->length[1],
8376
			   scsi_cmd->length[2], scsi_cmd->length[3],
8377
			   dxfer_len));
8378
	}
8379
	cam_fill_csio(csio,
8380
		      retries,
8381
		      cbfcnp,
8382
		      /*flags*/CAM_DIR_OUT,
8383
		      tag_action,
8384
		      data_ptr,
8385
		      dxfer_len,
8386
		      sense_len,
8387
		      cdb_len,
8388
		      timeout);
8389
}
8390

8391
void
8392
scsi_ata_identify(struct ccb_scsiio *csio, uint32_t retries,
8393
		  void (*cbfcnp)(struct cam_periph *, union ccb *),
8394
		  uint8_t tag_action, uint8_t *data_ptr,
8395
		  uint16_t dxfer_len, uint8_t sense_len,
8396
		  uint32_t timeout)
8397
{
8398
	scsi_ata_pass(csio,
8399
		      retries,
8400
		      cbfcnp,
8401
		      /*flags*/CAM_DIR_IN,
8402
		      tag_action,
8403
		      /*protocol*/AP_PROTO_PIO_IN,
8404
		      /*ata_flags*/AP_FLAG_TDIR_FROM_DEV |
8405
				   AP_FLAG_BYT_BLOK_BLOCKS |
8406
				   AP_FLAG_TLEN_SECT_CNT,
8407
		      /*features*/0,
8408
		      /*sector_count*/dxfer_len / 512,
8409
		      /*lba*/0,
8410
		      /*command*/ATA_ATA_IDENTIFY,
8411
		      /*device*/ 0,
8412
		      /*icc*/ 0,
8413
		      /*auxiliary*/ 0,
8414
		      /*control*/0,
8415
		      data_ptr,
8416
		      dxfer_len,
8417
		      /*cdb_storage*/ NULL,
8418
		      /*cdb_storage_len*/ 0,
8419
		      /*minimum_cmd_size*/ 0,
8420
		      sense_len,
8421
		      timeout);
8422
}
8423

8424
void
8425
scsi_ata_trim(struct ccb_scsiio *csio, uint32_t retries,
8426
	      void (*cbfcnp)(struct cam_periph *, union ccb *),
8427
	      uint8_t tag_action, uint16_t block_count,
8428
	      uint8_t *data_ptr, uint16_t dxfer_len, uint8_t sense_len,
8429
	      uint32_t timeout)
8430
{
8431
	scsi_ata_pass_16(csio,
8432
			 retries,
8433
			 cbfcnp,
8434
			 /*flags*/CAM_DIR_OUT,
8435
			 tag_action,
8436
			 /*protocol*/AP_EXTEND|AP_PROTO_DMA,
8437
			 /*ata_flags*/AP_FLAG_TLEN_SECT_CNT|AP_FLAG_BYT_BLOK_BLOCKS,
8438
			 /*features*/ATA_DSM_TRIM,
8439
			 /*sector_count*/block_count,
8440
			 /*lba*/0,
8441
			 /*command*/ATA_DATA_SET_MANAGEMENT,
8442
			 /*control*/0,
8443
			 data_ptr,
8444
			 dxfer_len,
8445
			 sense_len,
8446
			 timeout);
8447
}
8448

8449
int
8450
scsi_ata_read_log(struct ccb_scsiio *csio, uint32_t retries,
8451
		  void (*cbfcnp)(struct cam_periph *, union ccb *),
8452
		  uint8_t tag_action, uint32_t log_address,
8453
		  uint32_t page_number, uint16_t block_count,
8454
		  uint8_t protocol, uint8_t *data_ptr, uint32_t dxfer_len,
8455
		  uint8_t sense_len, uint32_t timeout)
8456
{
8457
	uint8_t command, protocol_out;
8458
	uint16_t count_out;
8459
	uint64_t lba;
8460
	int retval;
8461

8462
	retval = 0;
8463

8464
	switch (protocol) {
8465
	case AP_PROTO_DMA:
8466
		count_out = block_count;
8467
		command = ATA_READ_LOG_DMA_EXT;
8468
		protocol_out = AP_PROTO_DMA;
8469
		break;
8470
	case AP_PROTO_PIO_IN:
8471
	default:
8472
		count_out = block_count;
8473
		command = ATA_READ_LOG_EXT;
8474
		protocol_out = AP_PROTO_PIO_IN;
8475
		break;
8476
	}
8477

8478
	lba = (((uint64_t)page_number & 0xff00) << 32) |
8479
	      ((page_number & 0x00ff) << 8) |
8480
	      (log_address & 0xff);
8481

8482
	protocol_out |= AP_EXTEND;
8483

8484
	retval = scsi_ata_pass(csio,
8485
			       retries,
8486
			       cbfcnp,
8487
			       /*flags*/CAM_DIR_IN,
8488
			       tag_action,
8489
			       /*protocol*/ protocol_out,
8490
			       /*ata_flags*/AP_FLAG_TLEN_SECT_CNT |
8491
					    AP_FLAG_BYT_BLOK_BLOCKS |
8492
					    AP_FLAG_TDIR_FROM_DEV,
8493
			       /*feature*/ 0,
8494
			       /*sector_count*/ count_out,
8495
			       /*lba*/ lba,
8496
			       /*command*/ command,
8497
			       /*device*/ 0,
8498
			       /*icc*/ 0,
8499
			       /*auxiliary*/ 0,
8500
			       /*control*/0,
8501
			       data_ptr,
8502
			       dxfer_len,
8503
			       /*cdb_storage*/ NULL,
8504
			       /*cdb_storage_len*/ 0,
8505
			       /*minimum_cmd_size*/ 0,
8506
			       sense_len,
8507
			       timeout);
8508

8509
	return (retval);
8510
}
8511

8512
int scsi_ata_setfeatures(struct ccb_scsiio *csio, uint32_t retries,
8513
			 void (*cbfcnp)(struct cam_periph *, union ccb *),
8514
			 uint8_t tag_action, uint8_t feature,
8515
			 uint64_t lba, uint32_t count,
8516
			 uint8_t sense_len, uint32_t timeout)
8517
{
8518
	return (scsi_ata_pass(csio,
8519
		retries,
8520
		cbfcnp,
8521
		/*flags*/CAM_DIR_NONE,
8522
		tag_action,
8523
		/*protocol*/AP_PROTO_PIO_IN,
8524
		/*ata_flags*/AP_FLAG_TDIR_FROM_DEV |
8525
			     AP_FLAG_BYT_BLOK_BYTES |
8526
			     AP_FLAG_TLEN_SECT_CNT,
8527
		/*features*/feature,
8528
		/*sector_count*/count,
8529
		/*lba*/lba,
8530
		/*command*/ATA_SETFEATURES,
8531
		/*device*/ 0,
8532
		/*icc*/ 0,
8533
		/*auxiliary*/0,
8534
		/*control*/0,
8535
		/*data_ptr*/NULL,
8536
		/*dxfer_len*/0,
8537
		/*cdb_storage*/NULL,
8538
		/*cdb_storage_len*/0,
8539
		/*minimum_cmd_size*/0,
8540
		sense_len,
8541
		timeout));
8542
}
8543

8544
/*
8545
 * Note! This is an unusual CDB building function because it can return
8546
 * an error in the event that the command in question requires a variable
8547
 * length CDB, but the caller has not given storage space for one or has not
8548
 * given enough storage space.  If there is enough space available in the
8549
 * standard SCSI CCB CDB bytes, we'll prefer that over passed in storage.
8550
 */
8551
int
8552
scsi_ata_pass(struct ccb_scsiio *csio, uint32_t retries,
8553
	      void (*cbfcnp)(struct cam_periph *, union ccb *),
8554
	      uint32_t flags, uint8_t tag_action,
8555
	      uint8_t protocol, uint8_t ata_flags, uint16_t features,
8556
	      uint16_t sector_count, uint64_t lba, uint8_t command,
8557
	      uint8_t device, uint8_t icc, uint32_t auxiliary,
8558
	      uint8_t control, uint8_t *data_ptr, uint32_t dxfer_len,
8559
	      uint8_t *cdb_storage, size_t cdb_storage_len,
8560
	      int minimum_cmd_size, uint8_t sense_len, uint32_t timeout)
8561
{
8562
	uint32_t cam_flags;
8563
	uint8_t *cdb_ptr;
8564
	int cmd_size;
8565
	int retval;
8566
	uint8_t cdb_len;
8567

8568
	retval = 0;
8569
	cam_flags = flags;
8570

8571
	/*
8572
	 * Round the user's request to the nearest command size that is at
8573
	 * least as big as what he requested.
8574
	 */
8575
	if (minimum_cmd_size <= 12)
8576
		cmd_size = 12;
8577
	else if (minimum_cmd_size > 16)
8578
		cmd_size = 32;
8579
	else
8580
		cmd_size = 16;
8581

8582
	/*
8583
	 * If we have parameters that require a 48-bit ATA command, we have to
8584
	 * use the 16 byte ATA PASS-THROUGH command at least.
8585
	 */
8586
	if (((lba > ATA_MAX_28BIT_LBA)
8587
	  || (sector_count > 255)
8588
	  || (features > 255)
8589
	  || (protocol & AP_EXTEND))
8590
	 && ((cmd_size < 16)
8591
	  || ((protocol & AP_EXTEND) == 0))) {
8592
		if (cmd_size < 16)
8593
			cmd_size = 16;
8594
		protocol |= AP_EXTEND;
8595
	}
8596

8597
	/*
8598
	 * The icc and auxiliary ATA registers are only supported in the
8599
	 * 32-byte version of the ATA PASS-THROUGH command.
8600
	 */
8601
	if ((icc != 0)
8602
	 || (auxiliary != 0)) {
8603
		cmd_size = 32;
8604
		protocol |= AP_EXTEND;
8605
	}
8606

8607
	if ((cmd_size > sizeof(csio->cdb_io.cdb_bytes))
8608
	 && ((cdb_storage == NULL)
8609
	  || (cdb_storage_len < cmd_size))) {
8610
		retval = 1;
8611
		goto bailout;
8612
	}
8613

8614
	/*
8615
	 * At this point we know we have enough space to store the command
8616
	 * in one place or another.  We prefer the built-in array, but used
8617
	 * the passed in storage if necessary.
8618
	 */
8619
	if (cmd_size <= sizeof(csio->cdb_io.cdb_bytes))
8620
		cdb_ptr = csio->cdb_io.cdb_bytes;
8621
	else {
8622
		cdb_ptr = cdb_storage;
8623
		cam_flags |= CAM_CDB_POINTER;
8624
	}
8625

8626
	if (cmd_size <= 12) {
8627
		struct ata_pass_12 *cdb;
8628

8629
		cdb = (struct ata_pass_12 *)cdb_ptr;
8630
		cdb_len = sizeof(*cdb);
8631
		bzero(cdb, cdb_len);
8632

8633
		cdb->opcode = ATA_PASS_12;
8634
		cdb->protocol = protocol;
8635
		cdb->flags = ata_flags;
8636
		cdb->features = features;
8637
		cdb->sector_count = sector_count;
8638
		cdb->lba_low = lba & 0xff;
8639
		cdb->lba_mid = (lba >> 8) & 0xff;
8640
		cdb->lba_high = (lba >> 16) & 0xff;
8641
		cdb->device = ((lba >> 24) & 0xf) | ATA_DEV_LBA;
8642
		cdb->command = command;
8643
		cdb->control = control;
8644
	} else if (cmd_size <= 16) {
8645
		struct ata_pass_16 *cdb;
8646

8647
		cdb = (struct ata_pass_16 *)cdb_ptr;
8648
		cdb_len = sizeof(*cdb);
8649
		bzero(cdb, cdb_len);
8650

8651
		cdb->opcode = ATA_PASS_16;
8652
		cdb->protocol = protocol;
8653
		cdb->flags = ata_flags;
8654
		cdb->features = features & 0xff;
8655
		cdb->sector_count = sector_count & 0xff;
8656
		cdb->lba_low = lba & 0xff;
8657
		cdb->lba_mid = (lba >> 8) & 0xff;
8658
		cdb->lba_high = (lba >> 16) & 0xff;
8659
		/*
8660
		 * If AP_EXTEND is set, we're sending a 48-bit command.
8661
		 * Otherwise it's a 28-bit command.
8662
		 */
8663
		if (protocol & AP_EXTEND) {
8664
			cdb->lba_low_ext = (lba >> 24) & 0xff;
8665
			cdb->lba_mid_ext = (lba >> 32) & 0xff;
8666
			cdb->lba_high_ext = (lba >> 40) & 0xff;
8667
			cdb->features_ext = (features >> 8) & 0xff;
8668
			cdb->sector_count_ext = (sector_count >> 8) & 0xff;
8669
			cdb->device = device | ATA_DEV_LBA;
8670
		} else {
8671
			cdb->lba_low_ext = (lba >> 24) & 0xf;
8672
			cdb->device = ((lba >> 24) & 0xf) | ATA_DEV_LBA;
8673
		}
8674
		cdb->command = command;
8675
		cdb->control = control;
8676
	} else {
8677
		struct ata_pass_32 *cdb;
8678
		uint8_t tmp_lba[8];
8679

8680
		cdb = (struct ata_pass_32 *)cdb_ptr;
8681
		cdb_len = sizeof(*cdb);
8682
		bzero(cdb, cdb_len);
8683
		cdb->opcode = VARIABLE_LEN_CDB;
8684
		cdb->control = control;
8685
		cdb->length = sizeof(*cdb) - __offsetof(struct ata_pass_32,
8686
							service_action);
8687
		scsi_ulto2b(ATA_PASS_32_SA, cdb->service_action);
8688
		cdb->protocol = protocol;
8689
		cdb->flags = ata_flags;
8690

8691
		if ((protocol & AP_EXTEND) == 0) {
8692
			lba &= 0x0fffffff;
8693
			cdb->device = ((lba >> 24) & 0xf) | ATA_DEV_LBA;
8694
			features &= 0xff;
8695
			sector_count &= 0xff;
8696
		} else {
8697
			cdb->device = device | ATA_DEV_LBA;
8698
		}
8699
		scsi_u64to8b(lba, tmp_lba);
8700
		bcopy(&tmp_lba[2], cdb->lba, sizeof(cdb->lba));
8701
		scsi_ulto2b(features, cdb->features);
8702
		scsi_ulto2b(sector_count, cdb->count);
8703
		cdb->command = command;
8704
		cdb->icc = icc;
8705
		scsi_ulto4b(auxiliary, cdb->auxiliary);
8706
	}
8707

8708
	cam_fill_csio(csio,
8709
		      retries,
8710
		      cbfcnp,
8711
		      cam_flags,
8712
		      tag_action,
8713
		      data_ptr,
8714
		      dxfer_len,
8715
		      sense_len,
8716
		      cmd_size,
8717
		      timeout);
8718
bailout:
8719
	return (retval);
8720
}
8721

8722
void
8723
scsi_ata_pass_16(struct ccb_scsiio *csio, uint32_t retries,
8724
		 void (*cbfcnp)(struct cam_periph *, union ccb *),
8725
		 uint32_t flags, uint8_t tag_action,
8726
		 uint8_t protocol, uint8_t ata_flags, uint16_t features,
8727
		 uint16_t sector_count, uint64_t lba, uint8_t command,
8728
		 uint8_t control, uint8_t *data_ptr, uint16_t dxfer_len,
8729
		 uint8_t sense_len, uint32_t timeout)
8730
{
8731
	struct ata_pass_16 *ata_cmd;
8732

8733
	ata_cmd = (struct ata_pass_16 *)&csio->cdb_io.cdb_bytes;
8734
	ata_cmd->opcode = ATA_PASS_16;
8735
	ata_cmd->protocol = protocol;
8736
	ata_cmd->flags = ata_flags;
8737
	ata_cmd->features_ext = features >> 8;
8738
	ata_cmd->features = features;
8739
	ata_cmd->sector_count_ext = sector_count >> 8;
8740
	ata_cmd->sector_count = sector_count;
8741
	ata_cmd->lba_low = lba;
8742
	ata_cmd->lba_mid = lba >> 8;
8743
	ata_cmd->lba_high = lba >> 16;
8744
	ata_cmd->device = ATA_DEV_LBA;
8745
	if (protocol & AP_EXTEND) {
8746
		ata_cmd->lba_low_ext = lba >> 24;
8747
		ata_cmd->lba_mid_ext = lba >> 32;
8748
		ata_cmd->lba_high_ext = lba >> 40;
8749
	} else
8750
		ata_cmd->device |= (lba >> 24) & 0x0f;
8751
	ata_cmd->command = command;
8752
	ata_cmd->control = control;
8753

8754
	cam_fill_csio(csio,
8755
		      retries,
8756
		      cbfcnp,
8757
		      flags,
8758
		      tag_action,
8759
		      data_ptr,
8760
		      dxfer_len,
8761
		      sense_len,
8762
		      sizeof(*ata_cmd),
8763
		      timeout);
8764
}
8765

8766
void
8767
scsi_unmap(struct ccb_scsiio *csio, uint32_t retries,
8768
	   void (*cbfcnp)(struct cam_periph *, union ccb *),
8769
	   uint8_t tag_action, uint8_t byte2,
8770
	   uint8_t *data_ptr, uint16_t dxfer_len, uint8_t sense_len,
8771
	   uint32_t timeout)
8772
{
8773
	struct scsi_unmap *scsi_cmd;
8774

8775
	scsi_cmd = (struct scsi_unmap *)&csio->cdb_io.cdb_bytes;
8776
	scsi_cmd->opcode = UNMAP;
8777
	scsi_cmd->byte2 = byte2;
8778
	scsi_ulto4b(0, scsi_cmd->reserved);
8779
	scsi_cmd->group = 0;
8780
	scsi_ulto2b(dxfer_len, scsi_cmd->length);
8781
	scsi_cmd->control = 0;
8782

8783
	cam_fill_csio(csio,
8784
		      retries,
8785
		      cbfcnp,
8786
		      /*flags*/CAM_DIR_OUT,
8787
		      tag_action,
8788
		      data_ptr,
8789
		      dxfer_len,
8790
		      sense_len,
8791
		      sizeof(*scsi_cmd),
8792
		      timeout);
8793
}
8794

8795
void
8796
scsi_receive_diagnostic_results(struct ccb_scsiio *csio, uint32_t retries,
8797
				void (*cbfcnp)(struct cam_periph *, union ccb*),
8798
				uint8_t tag_action, int pcv, uint8_t page_code,
8799
				uint8_t *data_ptr, uint16_t allocation_length,
8800
				uint8_t sense_len, uint32_t timeout)
8801
{
8802
	struct scsi_receive_diag *scsi_cmd;
8803

8804
	scsi_cmd = (struct scsi_receive_diag *)&csio->cdb_io.cdb_bytes;
8805
	memset(scsi_cmd, 0, sizeof(*scsi_cmd));
8806
	scsi_cmd->opcode = RECEIVE_DIAGNOSTIC;
8807
	if (pcv) {
8808
		scsi_cmd->byte2 |= SRD_PCV;
8809
		scsi_cmd->page_code = page_code;
8810
	}
8811
	scsi_ulto2b(allocation_length, scsi_cmd->length);
8812

8813
	cam_fill_csio(csio,
8814
		      retries,
8815
		      cbfcnp,
8816
		      /*flags*/CAM_DIR_IN,
8817
		      tag_action,
8818
		      data_ptr,
8819
		      allocation_length,
8820
		      sense_len,
8821
		      sizeof(*scsi_cmd),
8822
		      timeout);
8823
}
8824

8825
void
8826
scsi_send_diagnostic(struct ccb_scsiio *csio, uint32_t retries,
8827
		     void (*cbfcnp)(struct cam_periph *, union ccb *),
8828
		     uint8_t tag_action, int unit_offline, int device_offline,
8829
		     int self_test, int page_format, int self_test_code,
8830
		     uint8_t *data_ptr, uint16_t param_list_length,
8831
		     uint8_t sense_len, uint32_t timeout)
8832
{
8833
	struct scsi_send_diag *scsi_cmd;
8834

8835
	scsi_cmd = (struct scsi_send_diag *)&csio->cdb_io.cdb_bytes;
8836
	memset(scsi_cmd, 0, sizeof(*scsi_cmd));
8837
	scsi_cmd->opcode = SEND_DIAGNOSTIC;
8838

8839
	/*
8840
	 * The default self-test mode control and specific test
8841
	 * control are mutually exclusive.
8842
	 */
8843
	if (self_test)
8844
		self_test_code = SSD_SELF_TEST_CODE_NONE;
8845

8846
	scsi_cmd->byte2 = ((self_test_code << SSD_SELF_TEST_CODE_SHIFT)
8847
			 & SSD_SELF_TEST_CODE_MASK)
8848
			| (unit_offline   ? SSD_UNITOFFL : 0)
8849
			| (device_offline ? SSD_DEVOFFL  : 0)
8850
			| (self_test      ? SSD_SELFTEST : 0)
8851
			| (page_format    ? SSD_PF       : 0);
8852
	scsi_ulto2b(param_list_length, scsi_cmd->length);
8853

8854
	cam_fill_csio(csio,
8855
		      retries,
8856
		      cbfcnp,
8857
		      /*flags*/param_list_length ? CAM_DIR_OUT : CAM_DIR_NONE,
8858
		      tag_action,
8859
		      data_ptr,
8860
		      param_list_length,
8861
		      sense_len,
8862
		      sizeof(*scsi_cmd),
8863
		      timeout);
8864
}
8865

8866
void
8867
scsi_get_physical_element_status(struct ccb_scsiio *csio, uint32_t retries,
8868
				 void (*cbfcnp)(struct cam_periph *, union ccb *),
8869
				 uint8_t tag_action, uint8_t *data_ptr,
8870
				 uint16_t allocation_length, uint8_t report_type,
8871
				 uint32_t starting_element,
8872
				 uint8_t sense_len, uint32_t timeout)
8873
{
8874
	struct scsi_get_physical_element_status *scsi_cmd;
8875

8876
	scsi_cmd = (struct scsi_get_physical_element_status *)&csio->cdb_io.cdb_bytes;
8877
	memset(scsi_cmd, 0, sizeof(*scsi_cmd));
8878
	scsi_cmd->opcode = SERVICE_ACTION_IN;
8879
	scsi_cmd->service_action = GET_PHYSICAL_ELEMENT_STATUS;
8880
	scsi_ulto4b(starting_element, scsi_cmd->starting_element);
8881
	scsi_ulto4b(allocation_length, scsi_cmd->allocation_length);
8882

8883
	cam_fill_csio(csio,
8884
		      retries,
8885
		      cbfcnp,
8886
		      /*flags*/ CAM_DIR_IN,
8887
		      tag_action,
8888
		      data_ptr,
8889
		      allocation_length,
8890
		      sense_len,
8891
		      sizeof(*scsi_cmd),
8892
		      timeout);
8893
}
8894

8895
void
8896
scsi_remove_element_and_truncate(struct ccb_scsiio *csio, uint32_t retries,
8897
				 void (*cbfcnp)(struct cam_periph *, union ccb *),
8898
				 uint8_t tag_action,
8899
				 uint64_t requested_capacity, uint32_t element_id,
8900
				 uint8_t sense_len, uint32_t timeout)
8901
{
8902
	struct scsi_remove_element_and_truncate *scsi_cmd;
8903

8904
	scsi_cmd = (struct scsi_remove_element_and_truncate *)&csio->cdb_io.cdb_bytes;
8905
	memset(scsi_cmd, 0, sizeof(*scsi_cmd));
8906
	scsi_cmd->opcode = SERVICE_ACTION_IN;
8907
	scsi_cmd->service_action = REMOVE_ELEMENT_AND_TRUNCATE;
8908
	scsi_u64to8b(requested_capacity, scsi_cmd->requested_capacity);
8909
	scsi_ulto4b(element_id, scsi_cmd->element_identifier);
8910

8911
	cam_fill_csio(csio,
8912
		      retries,
8913
		      cbfcnp,
8914
		      /*flags*/ CAM_DIR_OUT,
8915
		      tag_action,
8916
		      NULL,
8917
		      0,
8918
		      sense_len,
8919
		      sizeof(*scsi_cmd),
8920
		      timeout);
8921
}
8922

8923
void
8924
scsi_restore_elements_and_rebuild(struct ccb_scsiio *csio, uint32_t retries,
8925
				  void (*cbfcnp)(struct cam_periph *, union ccb *),
8926
				  uint8_t tag_action,
8927
				  uint8_t sense_len, uint32_t timeout)
8928
{
8929
	struct scsi_service_action_in *scsi_cmd;
8930

8931
	scsi_cmd = (struct scsi_service_action_in *)&csio->cdb_io.cdb_bytes;
8932
	memset(scsi_cmd, 0, sizeof(*scsi_cmd));
8933
	scsi_cmd->opcode = SERVICE_ACTION_IN;
8934
	scsi_cmd->service_action = RESTORE_ELEMENTS_AND_REBUILD;
8935

8936
	cam_fill_csio(csio,
8937
		      retries,
8938
		      cbfcnp,
8939
		      /*flags*/ CAM_DIR_OUT,
8940
		      tag_action,
8941
		      NULL,
8942
		      0,
8943
		      sense_len,
8944
		      sizeof(*scsi_cmd),
8945
		      timeout);
8946
}
8947

8948
void
8949
scsi_read_buffer(struct ccb_scsiio *csio, uint32_t retries,
8950
			void (*cbfcnp)(struct cam_periph *, union ccb*),
8951
			uint8_t tag_action, int mode,
8952
			uint8_t buffer_id, uint32_t offset,
8953
			uint8_t *data_ptr, uint32_t allocation_length,
8954
			uint8_t sense_len, uint32_t timeout)
8955
{
8956
	struct scsi_read_buffer *scsi_cmd;
8957

8958
	scsi_cmd = (struct scsi_read_buffer *)&csio->cdb_io.cdb_bytes;
8959
	memset(scsi_cmd, 0, sizeof(*scsi_cmd));
8960
	scsi_cmd->opcode = READ_BUFFER;
8961
	scsi_cmd->byte2 = mode;
8962
	scsi_cmd->buffer_id = buffer_id;
8963
	scsi_ulto3b(offset, scsi_cmd->offset);
8964
	scsi_ulto3b(allocation_length, scsi_cmd->length);
8965

8966
	cam_fill_csio(csio,
8967
		      retries,
8968
		      cbfcnp,
8969
		      /*flags*/CAM_DIR_IN,
8970
		      tag_action,
8971
		      data_ptr,
8972
		      allocation_length,
8973
		      sense_len,
8974
		      sizeof(*scsi_cmd),
8975
		      timeout);
8976
}
8977

8978
void
8979
scsi_write_buffer(struct ccb_scsiio *csio, uint32_t retries,
8980
			void (*cbfcnp)(struct cam_periph *, union ccb *),
8981
			uint8_t tag_action, int mode,
8982
			uint8_t buffer_id, uint32_t offset,
8983
			uint8_t *data_ptr, uint32_t param_list_length,
8984
			uint8_t sense_len, uint32_t timeout)
8985
{
8986
	struct scsi_write_buffer *scsi_cmd;
8987

8988
	scsi_cmd = (struct scsi_write_buffer *)&csio->cdb_io.cdb_bytes;
8989
	memset(scsi_cmd, 0, sizeof(*scsi_cmd));
8990
	scsi_cmd->opcode = WRITE_BUFFER;
8991
	scsi_cmd->byte2 = mode;
8992
	scsi_cmd->buffer_id = buffer_id;
8993
	scsi_ulto3b(offset, scsi_cmd->offset);
8994
	scsi_ulto3b(param_list_length, scsi_cmd->length);
8995

8996
	cam_fill_csio(csio,
8997
		      retries,
8998
		      cbfcnp,
8999
		      /*flags*/param_list_length ? CAM_DIR_OUT : CAM_DIR_NONE,
9000
		      tag_action,
9001
		      data_ptr,
9002
		      param_list_length,
9003
		      sense_len,
9004
		      sizeof(*scsi_cmd),
9005
		      timeout);
9006
}
9007

9008
void
9009
scsi_start_stop(struct ccb_scsiio *csio, uint32_t retries,
9010
		void (*cbfcnp)(struct cam_periph *, union ccb *),
9011
		uint8_t tag_action, int start, int load_eject,
9012
		int immediate, uint8_t sense_len, uint32_t timeout)
9013
{
9014
	struct scsi_start_stop_unit *scsi_cmd;
9015
	int extra_flags = 0;
9016

9017
	scsi_cmd = (struct scsi_start_stop_unit *)&csio->cdb_io.cdb_bytes;
9018
	bzero(scsi_cmd, sizeof(*scsi_cmd));
9019
	scsi_cmd->opcode = START_STOP_UNIT;
9020
	if (start != 0) {
9021
		scsi_cmd->how |= SSS_START;
9022
		/* it takes a lot of power to start a drive */
9023
		extra_flags |= CAM_HIGH_POWER;
9024
	}
9025
	if (load_eject != 0)
9026
		scsi_cmd->how |= SSS_LOEJ;
9027
	if (immediate != 0)
9028
		scsi_cmd->byte2 |= SSS_IMMED;
9029

9030
	cam_fill_csio(csio,
9031
		      retries,
9032
		      cbfcnp,
9033
		      /*flags*/CAM_DIR_NONE | extra_flags,
9034
		      tag_action,
9035
		      /*data_ptr*/NULL,
9036
		      /*dxfer_len*/0,
9037
		      sense_len,
9038
		      sizeof(*scsi_cmd),
9039
		      timeout);
9040
}
9041

9042
void
9043
scsi_start_stop_pc(struct ccb_scsiio *csio, uint32_t retries,
9044
		void (*cbfcnp)(struct cam_periph *, union ccb *),
9045
		uint8_t tag_action, int start, int load_eject,
9046
		int immediate, uint8_t power_condition, uint8_t sense_len,
9047
		uint32_t timeout)
9048
{
9049
	struct scsi_start_stop_unit *scsi_cmd;
9050
	int extra_flags = 0;
9051

9052
	scsi_cmd = (struct scsi_start_stop_unit *)&csio->cdb_io.cdb_bytes;
9053
	bzero(scsi_cmd, sizeof(*scsi_cmd));
9054
	scsi_cmd->opcode = START_STOP_UNIT;
9055
	if (start != 0) {
9056
		scsi_cmd->how |= SSS_START;
9057
		/* it takes a lot of power to start a drive */
9058
		extra_flags |= CAM_HIGH_POWER;
9059
	}
9060
	if (load_eject != 0)
9061
		scsi_cmd->how |= SSS_LOEJ;
9062
	scsi_cmd->how |= power_condition;
9063
	if (immediate != 0)
9064
		scsi_cmd->byte2 |= SSS_IMMED;
9065

9066
	cam_fill_csio(csio,
9067
		      retries,
9068
		      cbfcnp,
9069
		      /*flags*/CAM_DIR_NONE | extra_flags,
9070
		      tag_action,
9071
		      /*data_ptr*/NULL,
9072
		      /*dxfer_len*/0,
9073
		      sense_len,
9074
		      sizeof(*scsi_cmd),
9075
		      timeout);
9076
}
9077

9078
void
9079
scsi_read_attribute(struct ccb_scsiio *csio, uint32_t retries,
9080
		    void (*cbfcnp)(struct cam_periph *, union ccb *),
9081
		    uint8_t tag_action, uint8_t service_action,
9082
		    uint32_t element, uint8_t elem_type, int logical_volume,
9083
		    int partition, uint32_t first_attribute, int cache,
9084
		    uint8_t *data_ptr, uint32_t length, int sense_len,
9085
		    uint32_t timeout)
9086
{
9087
	struct scsi_read_attribute *scsi_cmd;
9088

9089
	scsi_cmd = (struct scsi_read_attribute *)&csio->cdb_io.cdb_bytes;
9090
	bzero(scsi_cmd, sizeof(*scsi_cmd));
9091

9092
	scsi_cmd->opcode = READ_ATTRIBUTE;
9093
	scsi_cmd->service_action = service_action;
9094
	scsi_ulto2b(element, scsi_cmd->element);
9095
	scsi_cmd->elem_type = elem_type;
9096
	scsi_cmd->logical_volume = logical_volume;
9097
	scsi_cmd->partition = partition;
9098
	scsi_ulto2b(first_attribute, scsi_cmd->first_attribute);
9099
	scsi_ulto4b(length, scsi_cmd->length);
9100
	if (cache != 0)
9101
		scsi_cmd->cache |= SRA_CACHE;
9102

9103
	cam_fill_csio(csio,
9104
		      retries,
9105
		      cbfcnp,
9106
		      /*flags*/CAM_DIR_IN,
9107
		      tag_action,
9108
		      /*data_ptr*/data_ptr,
9109
		      /*dxfer_len*/length,
9110
		      sense_len,
9111
		      sizeof(*scsi_cmd),
9112
		      timeout);
9113
}
9114

9115
void
9116
scsi_write_attribute(struct ccb_scsiio *csio, uint32_t retries,
9117
		    void (*cbfcnp)(struct cam_periph *, union ccb *),
9118
		    uint8_t tag_action, uint32_t element, int logical_volume,
9119
		    int partition, int wtc, uint8_t *data_ptr,
9120
		    uint32_t length, int sense_len, uint32_t timeout)
9121
{
9122
	struct scsi_write_attribute *scsi_cmd;
9123

9124
	scsi_cmd = (struct scsi_write_attribute *)&csio->cdb_io.cdb_bytes;
9125
	bzero(scsi_cmd, sizeof(*scsi_cmd));
9126

9127
	scsi_cmd->opcode = WRITE_ATTRIBUTE;
9128
	if (wtc != 0)
9129
		scsi_cmd->byte2 = SWA_WTC;
9130
	scsi_ulto3b(element, scsi_cmd->element);
9131
	scsi_cmd->logical_volume = logical_volume;
9132
	scsi_cmd->partition = partition;
9133
	scsi_ulto4b(length, scsi_cmd->length);
9134

9135
	cam_fill_csio(csio,
9136
		      retries,
9137
		      cbfcnp,
9138
		      /*flags*/CAM_DIR_OUT,
9139
		      tag_action,
9140
		      /*data_ptr*/data_ptr,
9141
		      /*dxfer_len*/length,
9142
		      sense_len,
9143
		      sizeof(*scsi_cmd),
9144
		      timeout);
9145
}
9146

9147
void
9148
scsi_persistent_reserve_in(struct ccb_scsiio *csio, uint32_t retries,
9149
			   void (*cbfcnp)(struct cam_periph *, union ccb *),
9150
			   uint8_t tag_action, int service_action,
9151
			   uint8_t *data_ptr, uint32_t dxfer_len, int sense_len,
9152
			   int timeout)
9153
{
9154
	struct scsi_per_res_in *scsi_cmd;
9155

9156
	scsi_cmd = (struct scsi_per_res_in *)&csio->cdb_io.cdb_bytes;
9157
	bzero(scsi_cmd, sizeof(*scsi_cmd));
9158

9159
	scsi_cmd->opcode = PERSISTENT_RES_IN;
9160
	scsi_cmd->action = service_action;
9161
	scsi_ulto2b(dxfer_len, scsi_cmd->length);
9162

9163
	cam_fill_csio(csio,
9164
		      retries,
9165
		      cbfcnp,
9166
		      /*flags*/CAM_DIR_IN,
9167
		      tag_action,
9168
		      data_ptr,
9169
		      dxfer_len,
9170
		      sense_len,
9171
		      sizeof(*scsi_cmd),
9172
		      timeout);
9173
}
9174

9175
void
9176
scsi_persistent_reserve_out(struct ccb_scsiio *csio, uint32_t retries,
9177
			    void (*cbfcnp)(struct cam_periph *, union ccb *),
9178
			    uint8_t tag_action, int service_action,
9179
			    int scope, int res_type, uint8_t *data_ptr,
9180
			    uint32_t dxfer_len, int sense_len, int timeout)
9181
{
9182
	struct scsi_per_res_out *scsi_cmd;
9183

9184
	scsi_cmd = (struct scsi_per_res_out *)&csio->cdb_io.cdb_bytes;
9185
	bzero(scsi_cmd, sizeof(*scsi_cmd));
9186

9187
	scsi_cmd->opcode = PERSISTENT_RES_OUT;
9188
	scsi_cmd->action = service_action;
9189
	scsi_cmd->scope_type = scope | res_type;
9190
	scsi_ulto4b(dxfer_len, scsi_cmd->length);
9191

9192
	cam_fill_csio(csio,
9193
		      retries,
9194
		      cbfcnp,
9195
		      /*flags*/CAM_DIR_OUT,
9196
		      tag_action,
9197
		      /*data_ptr*/data_ptr,
9198
		      /*dxfer_len*/dxfer_len,
9199
		      sense_len,
9200
		      sizeof(*scsi_cmd),
9201
		      timeout);
9202
}
9203

9204
void
9205
scsi_security_protocol_in(struct ccb_scsiio *csio, uint32_t retries,
9206
			  void (*cbfcnp)(struct cam_periph *, union ccb *),
9207
			  uint8_t tag_action, uint32_t security_protocol,
9208
			  uint32_t security_protocol_specific, int byte4,
9209
			  uint8_t *data_ptr, uint32_t dxfer_len, int sense_len,
9210
			  int timeout)
9211
{
9212
	struct scsi_security_protocol_in *scsi_cmd;
9213

9214
	scsi_cmd = (struct scsi_security_protocol_in *)&csio->cdb_io.cdb_bytes;
9215
	bzero(scsi_cmd, sizeof(*scsi_cmd));
9216

9217
	scsi_cmd->opcode = SECURITY_PROTOCOL_IN;
9218

9219
	scsi_cmd->security_protocol = security_protocol;
9220
	scsi_ulto2b(security_protocol_specific,
9221
		    scsi_cmd->security_protocol_specific);
9222
	scsi_cmd->byte4 = byte4;
9223
	scsi_ulto4b(dxfer_len, scsi_cmd->length);
9224

9225
	cam_fill_csio(csio,
9226
		      retries,
9227
		      cbfcnp,
9228
		      /*flags*/CAM_DIR_IN,
9229
		      tag_action,
9230
		      data_ptr,
9231
		      dxfer_len,
9232
		      sense_len,
9233
		      sizeof(*scsi_cmd),
9234
		      timeout);
9235
}
9236

9237
void
9238
scsi_security_protocol_out(struct ccb_scsiio *csio, uint32_t retries,
9239
			   void (*cbfcnp)(struct cam_periph *, union ccb *),
9240
			   uint8_t tag_action, uint32_t security_protocol,
9241
			   uint32_t security_protocol_specific, int byte4,
9242
			   uint8_t *data_ptr, uint32_t dxfer_len, int sense_len,
9243
			   int timeout)
9244
{
9245
	struct scsi_security_protocol_out *scsi_cmd;
9246

9247
	scsi_cmd = (struct scsi_security_protocol_out *)&csio->cdb_io.cdb_bytes;
9248
	bzero(scsi_cmd, sizeof(*scsi_cmd));
9249

9250
	scsi_cmd->opcode = SECURITY_PROTOCOL_OUT;
9251

9252
	scsi_cmd->security_protocol = security_protocol;
9253
	scsi_ulto2b(security_protocol_specific,
9254
		    scsi_cmd->security_protocol_specific);
9255
	scsi_cmd->byte4 = byte4;
9256
	scsi_ulto4b(dxfer_len, scsi_cmd->length);
9257

9258
	cam_fill_csio(csio,
9259
		      retries,
9260
		      cbfcnp,
9261
		      /*flags*/CAM_DIR_OUT,
9262
		      tag_action,
9263
		      data_ptr,
9264
		      dxfer_len,
9265
		      sense_len,
9266
		      sizeof(*scsi_cmd),
9267
		      timeout);
9268
}
9269

9270
void
9271
scsi_report_supported_opcodes(struct ccb_scsiio *csio, uint32_t retries,
9272
			      void (*cbfcnp)(struct cam_periph *, union ccb *),
9273
			      uint8_t tag_action, int options, int req_opcode,
9274
			      int req_service_action, uint8_t *data_ptr,
9275
			      uint32_t dxfer_len, int sense_len, int timeout)
9276
{
9277
	struct scsi_report_supported_opcodes *scsi_cmd;
9278

9279
	scsi_cmd = (struct scsi_report_supported_opcodes *)
9280
	    &csio->cdb_io.cdb_bytes;
9281
	bzero(scsi_cmd, sizeof(*scsi_cmd));
9282

9283
	scsi_cmd->opcode = MAINTENANCE_IN;
9284
	scsi_cmd->service_action = REPORT_SUPPORTED_OPERATION_CODES;
9285
	scsi_cmd->options = options;
9286
	scsi_cmd->requested_opcode = req_opcode;
9287
	scsi_ulto2b(req_service_action, scsi_cmd->requested_service_action);
9288
	scsi_ulto4b(dxfer_len, scsi_cmd->length);
9289

9290
	cam_fill_csio(csio,
9291
		      retries,
9292
		      cbfcnp,
9293
		      /*flags*/CAM_DIR_IN,
9294
		      tag_action,
9295
		      data_ptr,
9296
		      dxfer_len,
9297
		      sense_len,
9298
		      sizeof(*scsi_cmd),
9299
		      timeout);
9300
}
9301

9302
/*
9303
 * Try make as good a match as possible with
9304
 * available sub drivers
9305
 */
9306
int
9307
scsi_inquiry_match(caddr_t inqbuffer, caddr_t table_entry)
9308
{
9309
	struct scsi_inquiry_pattern *entry;
9310
	struct scsi_inquiry_data *inq;
9311

9312
	entry = (struct scsi_inquiry_pattern *)table_entry;
9313
	inq = (struct scsi_inquiry_data *)inqbuffer;
9314

9315
	if (((SID_TYPE(inq) == entry->type)
9316
	  || (entry->type == T_ANY))
9317
	 && (SID_IS_REMOVABLE(inq) ? entry->media_type & SIP_MEDIA_REMOVABLE
9318
				   : entry->media_type & SIP_MEDIA_FIXED)
9319
	 && (cam_strmatch(inq->vendor, entry->vendor, sizeof(inq->vendor)) == 0)
9320
	 && (cam_strmatch(inq->product, entry->product,
9321
			  sizeof(inq->product)) == 0)
9322
	 && (cam_strmatch(inq->revision, entry->revision,
9323
			  sizeof(inq->revision)) == 0)) {
9324
		return (0);
9325
	}
9326
        return (-1);
9327
}
9328

9329
/*
9330
 * Try make as good a match as possible with
9331
 * available sub drivers
9332
 */
9333
int
9334
scsi_static_inquiry_match(caddr_t inqbuffer, caddr_t table_entry)
9335
{
9336
	struct scsi_static_inquiry_pattern *entry;
9337
	struct scsi_inquiry_data *inq;
9338

9339
	entry = (struct scsi_static_inquiry_pattern *)table_entry;
9340
	inq = (struct scsi_inquiry_data *)inqbuffer;
9341

9342
	if (((SID_TYPE(inq) == entry->type)
9343
	  || (entry->type == T_ANY))
9344
	 && (SID_IS_REMOVABLE(inq) ? entry->media_type & SIP_MEDIA_REMOVABLE
9345
				   : entry->media_type & SIP_MEDIA_FIXED)
9346
	 && (cam_strmatch(inq->vendor, entry->vendor, sizeof(inq->vendor)) == 0)
9347
	 && (cam_strmatch(inq->product, entry->product,
9348
			  sizeof(inq->product)) == 0)
9349
	 && (cam_strmatch(inq->revision, entry->revision,
9350
			  sizeof(inq->revision)) == 0)) {
9351
		return (0);
9352
	}
9353
        return (-1);
9354
}
9355

9356
/**
9357
 * Compare two buffers of vpd device descriptors for a match.
9358
 *
9359
 * \param lhs      Pointer to first buffer of descriptors to compare.
9360
 * \param lhs_len  The length of the first buffer.
9361
 * \param rhs	   Pointer to second buffer of descriptors to compare.
9362
 * \param rhs_len  The length of the second buffer.
9363
 *
9364
 * \return  0 on a match, -1 otherwise.
9365
 *
9366
 * Treat rhs and lhs as arrays of vpd device id descriptors.  Walk lhs matching
9367
 * against each element in rhs until all data are exhausted or we have found
9368
 * a match.
9369
 */
9370
int
9371
scsi_devid_match(uint8_t *lhs, size_t lhs_len, uint8_t *rhs, size_t rhs_len)
9372
{
9373
	struct scsi_vpd_id_descriptor *lhs_id;
9374
	struct scsi_vpd_id_descriptor *lhs_last;
9375
	struct scsi_vpd_id_descriptor *rhs_last;
9376
	uint8_t *lhs_end;
9377
	uint8_t *rhs_end;
9378

9379
	lhs_end = lhs + lhs_len;
9380
	rhs_end = rhs + rhs_len;
9381

9382
	/*
9383
	 * rhs_last and lhs_last are the last possible position of a valid
9384
	 * descriptor assuming it had a zero length identifier.  We use
9385
	 * these variables to insure we can safely dereference the length
9386
	 * field in our loop termination tests.
9387
	 */
9388
	lhs_last = (struct scsi_vpd_id_descriptor *)
9389
	    (lhs_end - __offsetof(struct scsi_vpd_id_descriptor, identifier));
9390
	rhs_last = (struct scsi_vpd_id_descriptor *)
9391
	    (rhs_end - __offsetof(struct scsi_vpd_id_descriptor, identifier));
9392

9393
	lhs_id = (struct scsi_vpd_id_descriptor *)lhs;
9394
	while (lhs_id <= lhs_last
9395
	    && (lhs_id->identifier + lhs_id->length) <= lhs_end) {
9396
		struct scsi_vpd_id_descriptor *rhs_id;
9397

9398
		rhs_id = (struct scsi_vpd_id_descriptor *)rhs;
9399
		while (rhs_id <= rhs_last
9400
		    && (rhs_id->identifier + rhs_id->length) <= rhs_end) {
9401
			if ((rhs_id->id_type &
9402
			     (SVPD_ID_ASSOC_MASK | SVPD_ID_TYPE_MASK)) ==
9403
			    (lhs_id->id_type &
9404
			     (SVPD_ID_ASSOC_MASK | SVPD_ID_TYPE_MASK))
9405
			 && rhs_id->length == lhs_id->length
9406
			 && memcmp(rhs_id->identifier, lhs_id->identifier,
9407
				   rhs_id->length) == 0)
9408
				return (0);
9409

9410
			rhs_id = (struct scsi_vpd_id_descriptor *)
9411
			   (rhs_id->identifier + rhs_id->length);
9412
		}
9413
		lhs_id = (struct scsi_vpd_id_descriptor *)
9414
		   (lhs_id->identifier + lhs_id->length);
9415
	}
9416
	return (-1);
9417
}
9418

9419
#ifdef _KERNEL
9420
int
9421
scsi_vpd_supported_page(struct cam_periph *periph, uint8_t page_id)
9422
{
9423
	struct cam_ed *device;
9424
	struct scsi_vpd_supported_pages *vpds;
9425
	int i, num_pages;
9426

9427
	device = periph->path->device;
9428
	vpds = (struct scsi_vpd_supported_pages *)device->supported_vpds;
9429

9430
	if (vpds != NULL) {
9431
		num_pages = device->supported_vpds_len -
9432
		    SVPD_SUPPORTED_PAGES_HDR_LEN;
9433
		for (i = 0; i < num_pages; i++) {
9434
			if (vpds->page_list[i] == page_id)
9435
				return (1);
9436
		}
9437
	}
9438

9439
	return (0);
9440
}
9441

9442
static void
9443
decode_sks(struct sbuf *sb, int sk, uint8_t *sks)
9444
{
9445
	/*
9446
	 * The format of the sense key specific info varies based on key types.
9447
	 * The valid bit should be checked by the caller for fixed formats and
9448
	 * is always one for variable formats since it's mere presence signals
9449
	 * validity. SPC7 4.4.2.4.1 and 4.4.3.
9450
	 */
9451
	switch (sk) {
9452
	case SSD_KEY_ILLEGAL_REQUEST:
9453
	{
9454
		const char *type;
9455

9456
		type = sks[0] & SSD_FIELDPTR_CMD ? "CDB" : "buffer";
9457
		sbuf_printf(sb, "error_in=\"%s\" ", type);
9458
		if (sks[0] & SSD_BITPTR_VALID) {
9459
			sbuf_printf(sb, "bit_ptr=%d ", sks[0] & SSD_BITPTR_VALUE);
9460
		}
9461
		sbuf_printf(sb, "byte=%d ", scsi_2btoul(sks + 1));
9462
		break;
9463
	}
9464
	case SSD_KEY_HARDWARE_ERROR:
9465
	case SSD_KEY_MEDIUM_ERROR:
9466
	case SSD_KEY_RECOVERED_ERROR:
9467
		sbuf_printf(sb, "retry_count=%d ", scsi_2btoul(sks + 1));
9468
		break;
9469
	case SSD_KEY_NO_SENSE:
9470
	case SSD_KEY_NOT_READY:
9471
		sbuf_printf(sb, "progress=%d ", scsi_2btoul(sks + 1));
9472
		break;
9473
	case SSD_KEY_COPY_ABORTED:
9474
	{
9475
		const char *type;
9476

9477
		/* Note: segment number in cmd_info if SD=1 */
9478
		type = sks[0] & SSD_SD_VALID ? "rel" : "abs";
9479
		    sbuf_printf(sb, "segment=\"%s\" ", type);
9480
		if (sks[0] & SSD_BITPTR_VALID) {
9481
			sbuf_printf(sb, "bit_ptr=%d ", sks[0] & SSD_BITPTR_VALUE);
9482
		}
9483
		sbuf_printf(sb, "byte=%d ", scsi_2btoul(sks + 1));
9484
		break;
9485
	}
9486
	case SSD_KEY_UNIT_ATTENTION:
9487
		sbuf_printf(sb, "overflow=%d ", sks[0] & 0x1);
9488
		break;
9489
	default:
9490
		/*
9491
		 * NO DATA - SKSV should be zero, but no
9492
		 * reported data on 1 either.
9493
		 */
9494
		break;
9495
	}
9496
}
9497

9498
/*
9499
 * Decode the sense buffer we get back from the drive. See SPC7 4.4
9500
 * for details.
9501
 */
9502
void
9503
scsi_format_sense_devd(struct ccb_scsiio *csio, struct sbuf *sb)
9504
{
9505
	int serr, sk, asc, ascq, slen;
9506
	struct scsi_sense_data *sense_data;
9507
	uint8_t *walker, *ep;
9508
	union ccb *ccb = (union ccb *)csio;
9509

9510
	sbuf_printf(sb, "scsi_status=%d ", csio->scsi_status);
9511
	if (scsi_extract_sense_ccb(ccb, &serr, &sk, &asc, &ascq))
9512
		sbuf_printf(sb, "scsi_sense=\"%02x %02x %02x %02x\" ",
9513
		    serr, sk, asc, ascq);
9514
	if (csio->ccb_h.flags & CAM_SENSE_PTR)
9515
		bcopy((struct scsi_sense_data **)&csio->sense_data,
9516
		    &sense_data, sizeof(struct scsi_sense_data *));
9517
	else
9518
		sense_data = &csio->sense_data;
9519
	/*
9520
	 * Decode the rest of the sense buffer
9521
	 */
9522
	slen = csio->sense_len - csio->sense_resid;
9523
	walker = (uint8_t *)sense_data;
9524
	ep = walker + slen;
9525
	switch (*walker) {
9526
	case SSD_DESC_CURRENT_ERROR:
9527
	case SSD_DESC_DEFERRED_ERROR:
9528
	{
9529
		struct scsi_sense_data_desc *sdesc = (struct scsi_sense_data_desc *)walker;
9530

9531
		walker = sdesc->sense_desc;
9532
		if (walker + sdesc->extra_len > ep)
9533
			return;	/* more data than buffer, just punt */
9534
		ep = walker + sdesc->extra_len;
9535
		while (walker < ep) {
9536
			struct scsi_sense_desc_header *hdr =
9537
			    (struct scsi_sense_desc_header *)walker;
9538

9539
			switch (hdr->desc_type) {
9540
			case SSD_DESC_INFO:
9541
			{
9542
				struct scsi_sense_info *info;
9543

9544
				info = (struct scsi_sense_info *)hdr;
9545
				if ((info->byte2 & SSD_INFO_VALID) == 0)
9546
					break;
9547
				sbuf_printf(sb, "info=0x%jx ",
9548
				    scsi_8btou64(info->info));
9549
				break;
9550
			}
9551
			case SSD_DESC_COMMAND:
9552
			{
9553
				struct scsi_sense_command *command;
9554

9555
				command = (struct scsi_sense_command *)hdr;
9556
				sbuf_printf(sb, "cmd_info=0x%jx ",
9557
				    scsi_8btou64(command->command_info));
9558
				break;
9559
			}
9560
			case SSD_DESC_SKS:
9561
				/* len sanity */
9562
				decode_sks(sb, sk, walker + 2);
9563
				break;
9564
			case SSD_DESC_FRU:
9565
			{
9566
				struct scsi_sense_fru *fru;
9567

9568
				fru = (struct scsi_sense_fru *)hdr;
9569
				sbuf_printf(sb, "fru=%u ", fru->fru);
9570
				break;
9571
			}
9572
			case SSD_DESC_ATA:
9573
			{
9574
				struct scsi_sense_ata_ret_desc *res;
9575
				uint16_t count;
9576
				uint64_t lba;
9577

9578
				res = (struct scsi_sense_ata_ret_desc *)hdr;
9579
				sbuf_printf(sb, "ata_status=0x%02x ata_error=0x%02x ",
9580
				    res->status, res->error);
9581
				if (res->flags & SSD_DESC_ATA_FLAG_EXTEND) {
9582
					count = ((uint16_t)res->count_15_8 << 8) | res->count_7_0;
9583
					lba = ((uint64_t)res->lba_47_40 << 40) |
9584
					    ((uint64_t)res->lba_39_32 << 32) |
9585
					    ((uint64_t)res->lba_31_24 << 24) |
9586
					    ((uint64_t)res->lba_23_16 << 16) |
9587
					    ((uint64_t)res->lba_15_8 << 8) |
9588
					    res->lba_7_0;
9589
				} else {
9590
					count = res->count_7_0;
9591
					lba = ((uint64_t)res->lba_23_16 << 16) |
9592
					    ((uint64_t)res->lba_15_8 << 8) |
9593
					    res->lba_7_0;
9594
				}
9595
				sbuf_printf(sb, "count=%d lba=0x%jx ", count, (uintmax_t)lba);
9596
				break;
9597
			}
9598
			case SSD_DESC_DABD:
9599
			{
9600
				struct scsi_sense_direct_access_block_device *dabd;
9601

9602
				dabd = (struct scsi_sense_direct_access_block_device *)hdr;
9603

9604
				if (dabd->sks_byte & SSD_DESC_DABD_SKS_VALID)
9605
					decode_sks(sb, sk, dabd->data);
9606
				sbuf_printf(sb, "fru=%u ", dabd->fru);
9607
				if (dabd->byte2 & SSD_DESC_DABD_VALID) {
9608
					sbuf_printf(sb, "info=0x%jx ",
9609
					    scsi_8btou64(dabd->info));
9610
					sbuf_printf(sb, "cmd_info=0x%jx ",
9611
					    scsi_8btou64(dabd->command_info));
9612
				}
9613
			}
9614
			default:
9615
			{
9616
				uint8_t *cp;
9617

9618
				if (hdr->desc_type >= SSD_DESC_VENDOR_MIN && hdr->desc_type <= SSD_DESC_VENDOR_MAX)
9619
					sbuf_printf(sb, "ven%02x=\"", hdr->desc_type);
9620
				else
9621
					sbuf_printf(sb, "desc%02x=\"", hdr->desc_type);
9622
				cp = (uint8_t *)&hdr[1];
9623
				for (int i = 0; i < hdr->length; i++, cp++)
9624
					sbuf_printf(sb, "%02x ", *cp);
9625
				sbuf_printf(sb, "\" ");
9626
				break;
9627
			}
9628
			} /* switch */
9629

9630
			walker += sizeof(*hdr) + hdr->length;
9631
		}
9632
	}
9633
	case SSD_CURRENT_ERROR:
9634
	case SSD_DEFERRED_ERROR:
9635
	{
9636
		struct scsi_sense_data_fixed *sfixed = (struct scsi_sense_data_fixed *)walker;
9637

9638
		if (sfixed->error_code & SSD_ERRCODE_VALID) {
9639
			uint32_t val = scsi_4btoul(sfixed->info);
9640

9641
			sbuf_printf(sb, "info=0x%x ", val);
9642
		}
9643
		if (SSD_FIXED_IS_PRESENT(sfixed, slen, cmd_spec_info) &&
9644
		    SSD_FIXED_IS_FILLED(sfixed, cmd_spec_info)) {
9645
			uint32_t val = scsi_4btoul(sfixed->cmd_spec_info);
9646

9647
			sbuf_printf(sb, "cmd_info=0x%x ", val);
9648
		}
9649
		if (SSD_FIXED_IS_PRESENT(sfixed, slen, fru) &&
9650
		    SSD_FIXED_IS_FILLED(sfixed, fru)) {
9651

9652
			sbuf_printf(sb, "fru=0x%x ", sfixed->fru);
9653
		}
9654
		if (SSD_FIXED_IS_PRESENT(sfixed, slen, sense_key_spec) &&
9655
		    SSD_FIXED_IS_FILLED(sfixed, sense_key_spec) &&
9656
		    (sfixed->sense_key_spec[0] & SSD_SCS_VALID) != 0) {
9657
			decode_sks(sb, sk, sfixed->sense_key_spec);
9658
		}
9659
		/* Additional bytes not reported -- vendor specific */
9660
		/* Report the bytes present ? but can't use macros since it's at most 14 bytes */
9661
	}
9662
	} /* switch */
9663
}
9664

9665
static void
9666
init_scsi_delay(void *dummy __unused)
9667
{
9668
	int delay;
9669

9670
	delay = SCSI_DELAY;
9671
	TUNABLE_INT_FETCH("kern.cam.scsi_delay", &delay);
9672

9673
	if (set_scsi_delay(delay) != 0) {
9674
		printf("cam: invalid value for tunable kern.cam.scsi_delay\n");
9675
		set_scsi_delay(SCSI_DELAY);
9676
	}
9677
}
9678
SYSINIT(scsi_delay, SI_SUB_TUNABLES, SI_ORDER_ANY, init_scsi_delay, NULL);
9679

9680
static int
9681
sysctl_scsi_delay(SYSCTL_HANDLER_ARGS)
9682
{
9683
	int error, delay;
9684

9685
	delay = scsi_delay;
9686
	error = sysctl_handle_int(oidp, &delay, 0, req);
9687
	if (error != 0 || req->newptr == NULL)
9688
		return (error);
9689
	return (set_scsi_delay(delay));
9690
}
9691
SYSCTL_PROC(_kern_cam, OID_AUTO, scsi_delay,
9692
    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_NOFETCH | CTLFLAG_MPSAFE,
9693
    0, 0, sysctl_scsi_delay, "I",
9694
    "Delay to allow devices to settle after a SCSI bus reset (ms)");
9695

9696
static int
9697
set_scsi_delay(int delay)
9698
{
9699
	/*
9700
         * If someone sets this to 0, we assume that they want the
9701
         * minimum allowable bus settle delay.
9702
	 */
9703
	if (delay == 0) {
9704
		printf("cam: using minimum scsi_delay (%dms)\n",
9705
		    SCSI_MIN_DELAY);
9706
		delay = SCSI_MIN_DELAY;
9707
	}
9708
	if (delay < SCSI_MIN_DELAY)
9709
		return (EINVAL);
9710
	scsi_delay = delay;
9711
	return (0);
9712
}
9713
#endif /* _KERNEL */
9714

9715
Product

Resources

Company
