xref: /illumos-gate/usr/src/uts/common/io/scsi/targets/st.c (revision e213afc33a406f0a4fc6c832d489a0e6f529ca63)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 /*
30  * SCSI	 SCSA-compliant and not-so-DDI-compliant Tape Driver
31  */
32 
33 #if defined(lint) && !defined(DEBUG)
34 #define	DEBUG	1
35 #endif
36 
37 #include <sys/modctl.h>
38 #include <sys/scsi/scsi.h>
39 #include <sys/mtio.h>
40 #include <sys/scsi/targets/stdef.h>
41 #include <sys/file.h>
42 #include <sys/stat.h>
43 #include <sys/kstat.h>
44 #include <sys/ddidmareq.h>
45 #include <sys/ddi.h>
46 #include <sys/sunddi.h>
47 
48 #define	IOSP	KSTAT_IO_PTR(un->un_stats)
49 /*
50  * stats maintained only for reads/writes as commands
51  * like rewind etc skew the wait/busy times
52  */
53 #define	IS_RW(bp) 	((bp)->b_bcount > 0)
54 #define	ST_DO_KSTATS(bp, kstat_function) \
55 	if ((bp != un->un_sbufp) && un->un_stats && IS_RW(bp)) { \
56 		kstat_function(IOSP); \
57 	}
58 
59 #define	ST_DO_ERRSTATS(un, x)  \
60 	if (un->un_errstats) { \
61 		struct st_errstats *stp; \
62 		stp = (struct st_errstats *)un->un_errstats->ks_data; \
63 		stp->x.value.ul++; \
64 	}
65 
66 #define	FILL_SCSI1_LUN(devp, pkt) 					\
67 	if ((devp)->sd_inq->inq_ansi == 0x1) {				\
68 		int _lun;						\
69 		_lun = ddi_prop_get_int(DDI_DEV_T_ANY, (devp)->sd_dev,	\
70 		    DDI_PROP_DONTPASS, SCSI_ADDR_PROP_LUN, 0);		\
71 		if (_lun > 0) {						\
72 			((union scsi_cdb *)(pkt)->pkt_cdbp)->scc_lun =	\
73 			    _lun;					\
74 		}							\
75 	}
76 
77 /*
78  * get an available contig mem header, cp.
79  * when big_enough is true, we will return NULL, if no big enough
80  * contig mem is found.
81  * when big_enough is false, we will try to find cp containing big
82  * enough contig mem. if not found, we will ruturn the last cp available.
83  *
84  * used by st_get_contig_mem()
85  */
86 #define	ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough) {		\
87 	struct contig_mem *tmp_cp = NULL;				\
88 	for ((cp) = (un)->un_contig_mem;				\
89 	    (cp) != NULL;						\
90 	    tmp_cp = (cp), (cp) = (cp)->cm_next) { 			\
91 		if (((cp)->cm_len >= (len)) || 				\
92 		    (!(big_enough) && ((cp)->cm_next == NULL))) { 	\
93 			if (tmp_cp == NULL) { 				\
94 				(un)->un_contig_mem = (cp)->cm_next; 	\
95 			} else { 					\
96 				tmp_cp->cm_next = (cp)->cm_next; 	\
97 			} 						\
98 			(cp)->cm_next = NULL; 				\
99 			(un)->un_contig_mem_available_num--; 		\
100 			break; 						\
101 		} 							\
102 	} 								\
103 }
104 
105 #define	ST_NUM_MEMBERS(array)	(sizeof (array) / sizeof (array[0]))
106 
107 /*
108  * Global External Data Definitions
109  */
110 extern struct scsi_key_strings scsi_cmds[];
111 
112 /*
113  * Local Static Data
114  */
115 static void *st_state;
116 static char *st_label = "st";
117 
118 #if defined(__i386) || defined(__amd64)
119 /*
120  * We need to use below DMA attr to alloc physically contiguous
121  * memory to do I/O in big block size
122  */
123 static ddi_dma_attr_t st_contig_mem_dma_attr = {
124 	DMA_ATTR_V0,    /* version number */
125 	0x0,		/* lowest usable address */
126 	0xFFFFFFFFull,  /* high DMA address range */
127 	0xFFFFFFFFull,  /* DMA counter register */
128 	1,		/* DMA address alignment */
129 	1,		/* DMA burstsizes */
130 	1,		/* min effective DMA size */
131 	0xFFFFFFFFull,  /* max DMA xfer size */
132 	0xFFFFFFFFull,  /* segment boundary */
133 	1,		/* s/g list length */
134 	1,		/* granularity of device */
135 	0		/* DMA transfer flags */
136 };
137 
138 static ddi_device_acc_attr_t st_acc_attr = {
139 	DDI_DEVICE_ATTR_V0,
140 	DDI_NEVERSWAP_ACC,
141 	DDI_STRICTORDER_ACC
142 };
143 
144 /* set limitation for the number of contig_mem */
145 static int st_max_contig_mem_num = ST_MAX_CONTIG_MEM_NUM;
146 #endif
147 
148 /*
149  * Tunable parameters
150  *
151  * DISCLAIMER
152  * ----------
153  * These parameters are intended for use only in system testing; if you use
154  * them in production systems, you do so at your own risk. Altering any
155  * variable not listed below may cause unpredictable system behavior.
156  *
157  * st_check_media_time
158  *
159  *   Three second state check
160  *
161  * st_allow_large_xfer
162  *
163  *   Gated with ST_NO_RECSIZE_LIMIT
164  *
165  *   0 - Transfers larger than 64KB will not be allowed
166  *       regardless of the setting of ST_NO_RECSIZE_LIMIT
167  *   1 - Transfers larger than 64KB will be allowed
168  *       if ST_NO_RECSIZE_LIMIT is TRUE for the drive
169  *
170  * st_report_soft_errors_on_close
171  *
172  *  Gated with ST_SOFT_ERROR_REPORTING
173  *
174  *  0 - Errors will not be reported on close regardless
175  *      of the setting of ST_SOFT_ERROR_REPORTING
176  *
177  *  1 - Errors will be reported on close if
178  *      ST_SOFT_ERROR_REPORTING is TRUE for the drive
179  */
180 static int st_selection_retry_count = ST_SEL_RETRY_COUNT;
181 static int st_retry_count	= ST_RETRY_COUNT;
182 
183 static int st_io_time		= ST_IO_TIME;
184 static int st_long_timeout_x	= ST_LONG_TIMEOUT_X;
185 
186 static int st_space_time	= ST_SPACE_TIME;
187 static int st_long_space_time_x	= ST_LONG_SPACE_TIME_X;
188 
189 static int st_error_level	= SCSI_ERR_RETRYABLE;
190 static int st_check_media_time	= 3000000;	/* 3 Second State Check */
191 
192 static int st_max_throttle	= ST_MAX_THROTTLE;
193 
194 static clock_t st_wait_cmds_complete = ST_WAIT_CMDS_COMPLETE;
195 
196 static int st_allow_large_xfer = 1;
197 static int st_report_soft_errors_on_close = 1;
198 
199 /*
200  * End of tunable parameters list
201  */
202 
203 
204 
205 /*
206  * Asynchronous I/O and persistent errors, refer to PSARC/1995/228
207  *
208  * Asynchronous I/O's main offering is that it is a non-blocking way to do
209  * reads and writes.  The driver will queue up all the requests it gets and
210  * have them ready to transport to the HBA.  Unfortunately, we cannot always
211  * just ship the I/O requests to the HBA, as there errors and exceptions
212  * that may happen when we don't want the HBA to continue.  Therein comes
213  * the flush-on-errors capability.  If the HBA supports it, then st will
214  * send in st_max_throttle I/O requests at the same time.
215  *
216  * Persistent errors : This was also reasonably simple.  In the interrupt
217  * routines, if there was an error or exception (FM, LEOT, media error,
218  * transport error), the persistent error bits are set and shuts everything
219  * down, but setting the throttle to zero.  If we hit and exception in the
220  * HBA, and flush-on-errors were set, we wait for all outstanding I/O's to
221  * come back (with CMD_ABORTED), then flush all bp's in the wait queue with
222  * the appropriate error, and this will preserve order. Of course, depending
223  * on the exception we have to show a zero read or write before we show
224  * errors back to the application.
225  */
226 
227 extern const int st_ndrivetypes;	/* defined in st_conf.c */
228 extern const struct st_drivetype st_drivetypes[];
229 
230 #ifdef STDEBUG
231 static int st_soft_error_report_debug = 0;
232 static int st_debug = 0;
233 #endif
234 
235 #define	ST_MT02_NAME	"Emulex  MT02 QIC-11/24  "
236 
237 static const struct driver_minor_data {
238 	char	*name;
239 	int	minor;
240 } st_minor_data[] = {
241 	/*
242 	 * The top 4 entries are for the default densities,
243 	 * don't alter their position.
244 	 */
245 	{"",	0},
246 	{"n",	MT_NOREWIND},
247 	{"b",	MT_BSD},
248 	{"bn",	MT_NOREWIND | MT_BSD},
249 	{"l",	MT_DENSITY1},
250 	{"m",	MT_DENSITY2},
251 	{"h",	MT_DENSITY3},
252 	{"c",	MT_DENSITY4},
253 	{"u",	MT_DENSITY4},
254 	{"ln",	MT_DENSITY1 | MT_NOREWIND},
255 	{"mn",	MT_DENSITY2 | MT_NOREWIND},
256 	{"hn",	MT_DENSITY3 | MT_NOREWIND},
257 	{"cn",	MT_DENSITY4 | MT_NOREWIND},
258 	{"un",	MT_DENSITY4 | MT_NOREWIND},
259 	{"lb",	MT_DENSITY1 | MT_BSD},
260 	{"mb",	MT_DENSITY2 | MT_BSD},
261 	{"hb",	MT_DENSITY3 | MT_BSD},
262 	{"cb",	MT_DENSITY4 | MT_BSD},
263 	{"ub",	MT_DENSITY4 | MT_BSD},
264 	{"lbn",	MT_DENSITY1 | MT_NOREWIND | MT_BSD},
265 	{"mbn",	MT_DENSITY2 | MT_NOREWIND | MT_BSD},
266 	{"hbn",	MT_DENSITY3 | MT_NOREWIND | MT_BSD},
267 	{"cbn",	MT_DENSITY4 | MT_NOREWIND | MT_BSD},
268 	{"ubn",	MT_DENSITY4 | MT_NOREWIND | MT_BSD}
269 };
270 
271 /* strings used in many debug and warning messages */
272 static const char wr_str[]  = "write";
273 static const char rd_str[]  = "read";
274 static const char wrg_str[] = "writing";
275 static const char rdg_str[] = "reading";
276 
277 /* default density offsets in the table above */
278 #define	DEF_BLANK	0
279 #define	DEF_NOREWIND	1
280 #define	DEF_BSD		2
281 #define	DEF_BSD_NR	3
282 
283 /* Sense Key, ASC/ASCQ for which tape ejection is needed */
284 
285 static struct tape_failure_code {
286 	uchar_t key;
287 	uchar_t add_code;
288 	uchar_t qual_code;
289 } st_tape_failure_code[] = {
290 	{ KEY_HARDWARE_ERROR, 0x15, 0x01},
291 	{ KEY_HARDWARE_ERROR, 0x44, 0x00},
292 	{ KEY_HARDWARE_ERROR, 0x53, 0x00},
293 	{ KEY_HARDWARE_ERROR, 0x53, 0x01},
294 	{ KEY_NOT_READY, 0x53, 0x00},
295 	{ 0xff}
296 };
297 
298 /*  clean bit position and mask */
299 
300 static struct cln_bit_position {
301 	ushort_t cln_bit_byte;
302 	uchar_t cln_bit_mask;
303 } st_cln_bit_position[] = {
304 	{ 21, 0x08},
305 	{ 70, 0xc0},
306 	{ 18, 0x81}  /* 80 bit indicates in bit mode, 1 bit clean light is on */
307 };
308 
309 /*
310  * architecture dependent allocation restrictions. For x86, we'll set
311  * dma_attr_addr_hi to st_max_phys_addr and dma_attr_sgllen to
312  * st_sgl_size during _init().
313  */
314 #if defined(__sparc)
315 static ddi_dma_attr_t st_alloc_attr = {
316 	DMA_ATTR_V0,	/* version number */
317 	0x0,		/* lowest usable address */
318 	0xFFFFFFFFull,	/* high DMA address range */
319 	0xFFFFFFFFull,	/* DMA counter register */
320 	1,		/* DMA address alignment */
321 	1,		/* DMA burstsizes */
322 	1,		/* min effective DMA size */
323 	0xFFFFFFFFull,	/* max DMA xfer size */
324 	0xFFFFFFFFull,	/* segment boundary */
325 	1,		/* s/g list length */
326 	512,		/* granularity of device */
327 	0		/* DMA transfer flags */
328 };
329 #elif defined(__x86)
330 static ddi_dma_attr_t st_alloc_attr = {
331 	DMA_ATTR_V0,	/* version number */
332 	0x0,		/* lowest usable address */
333 	0x0,		/* high DMA address range [set in _init()] */
334 	0xFFFFull,	/* DMA counter register */
335 	512,		/* DMA address alignment */
336 	1,		/* DMA burstsizes */
337 	1,		/* min effective DMA size */
338 	0xFFFFFFFFull,	/* max DMA xfer size */
339 	0xFFFFFFFFull,  /* segment boundary */
340 	0,		/* s/g list length */
341 	512,		/* granularity of device [set in _init()] */
342 	0		/* DMA transfer flags */
343 };
344 uint64_t st_max_phys_addr = 0xFFFFFFFFull;
345 int st_sgl_size = 0xF;
346 
347 #endif
348 
349 /*
350  * Configuration Data:
351  *
352  * Device driver ops vector
353  */
354 static int st_aread(dev_t dev, struct aio_req *aio, cred_t *cred_p);
355 static int st_awrite(dev_t dev, struct aio_req *aio, cred_t *cred_p);
356 static int st_read(dev_t  dev,  struct   uio   *uio_p,   cred_t *cred_p);
357 static int st_write(dev_t  dev,  struct  uio   *uio_p,   cred_t *cred_p);
358 static int st_open(dev_t  *devp,  int  flag,  int  otyp,  cred_t *cred_p);
359 static int st_close(dev_t  dev,  int  flag,  int  otyp,  cred_t *cred_p);
360 static int st_strategy(struct buf *bp);
361 static int st_ioctl(dev_t dev, int cmd, intptr_t arg, int  flag,
362 	cred_t *cred_p, int *rval_p);
363 extern int nulldev(), nodev();
364 
365 static struct cb_ops st_cb_ops = {
366 	st_open,			/* open */
367 	st_close,		/* close */
368 	st_strategy,		/* strategy */
369 	nodev,			/* print */
370 	nodev,			/* dump */
371 	st_read,		/* read */
372 	st_write,		/* write */
373 	st_ioctl,		/* ioctl */
374 	nodev,			/* devmap */
375 	nodev,			/* mmap */
376 	nodev,			/* segmap */
377 	nochpoll,		/* poll */
378 	ddi_prop_op,		/* cb_prop_op */
379 	0,			/* streamtab  */
380 	D_64BIT | D_MP | D_NEW | D_HOTPLUG,	/* Driver compatibility flag */
381 	CB_REV,			/* cb_rev */
382 	st_aread, 		/* async I/O read entry point */
383 	st_awrite		/* async I/O write entry point */
384 
385 };
386 
387 static int stinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
388 		void **result);
389 static int st_probe(dev_info_t *dev);
390 static int st_attach(dev_info_t *dev, ddi_attach_cmd_t cmd);
391 static int st_detach(dev_info_t *dev, ddi_detach_cmd_t cmd);
392 
393 static struct dev_ops st_ops = {
394 	DEVO_REV,		/* devo_rev, */
395 	0,			/* refcnt  */
396 	stinfo,			/* info */
397 	nulldev,		/* identify */
398 	st_probe,		/* probe */
399 	st_attach,		/* attach */
400 	st_detach,		/* detach */
401 	nodev,			/* reset */
402 	&st_cb_ops,		/* driver operations */
403 	(struct bus_ops *)0,	/* bus operations */
404 	nulldev			/* power */
405 };
406 
407 /*
408  * Local Function Declarations
409  */
410 static void st_clean_print(dev_info_t *dev, char *label, uint_t level,
411 	char *title, char *data, int len);
412 static int st_doattach(struct scsi_device *devp, int (*canwait)());
413 static void st_known_tape_type(struct scsi_tape *un);
414 static int st_get_conf_from_st_dot_conf(struct scsi_tape *, char *,
415     struct st_drivetype *);
416 static int st_get_conf_from_st_conf_dot_c(struct scsi_tape *, char *,
417     struct st_drivetype *);
418 static int st_get_default_conf(struct scsi_tape *, char *,
419     struct st_drivetype *);
420 static int st_rw(dev_t dev, struct uio *uio, int flag);
421 static int st_arw(dev_t dev, struct aio_req *aio, int flag);
422 static int st_find_eom(dev_t dev);
423 static int st_check_density_or_wfm(dev_t dev, int wfm, int mode, int stepflag);
424 static int st_ioctl_cmd(dev_t dev, struct uscsi_cmd *,
425 	enum uio_seg, enum uio_seg, enum uio_seg);
426 static int st_mtioctop(struct scsi_tape *un, intptr_t arg, int flag);
427 static void st_start(struct scsi_tape *un);
428 static int st_handle_start_busy(struct scsi_tape *un, struct buf *bp,
429     clock_t timeout_interval);
430 static int st_handle_intr_busy(struct scsi_tape *un, struct buf *bp,
431     clock_t timeout_interval);
432 static int st_handle_intr_retry_lcmd(struct scsi_tape *un, struct buf *bp);
433 static void st_done_and_mutex_exit(struct scsi_tape *un, struct buf *bp);
434 static void st_init(struct scsi_tape *un);
435 static void st_make_cmd(struct scsi_tape *un, struct buf *bp,
436     int (*func)(caddr_t));
437 static void st_make_uscsi_cmd(struct scsi_tape *, struct uscsi_cmd *,
438     struct buf *bp, int (*func)(caddr_t));
439 static void st_intr(struct scsi_pkt *pkt);
440 static void st_set_state(struct scsi_tape *un);
441 static void st_test_append(struct buf *bp);
442 static int st_runout(caddr_t);
443 static int st_cmd(dev_t dev, int com, int count, int wait);
444 static int st_set_compression(struct scsi_tape *un);
445 static int st_write_fm(dev_t dev, int wfm);
446 static int st_determine_generic(dev_t dev);
447 static int st_determine_density(dev_t dev, int rw);
448 static int st_get_density(dev_t dev);
449 static int st_set_density(dev_t dev);
450 static int st_loadtape(dev_t dev);
451 static int st_modesense(struct scsi_tape *un);
452 static int st_modeselect(struct scsi_tape *un);
453 static int st_handle_incomplete(struct scsi_tape *un, struct buf *bp);
454 static int st_wrongtapetype(struct scsi_tape *un);
455 static int st_check_error(struct scsi_tape *un, struct scsi_pkt *pkt);
456 static int st_handle_sense(struct scsi_tape *un, struct buf *bp);
457 static int st_handle_autosense(struct scsi_tape *un, struct buf *bp);
458 static int st_decode_sense(struct scsi_tape *un, struct buf *bp, int amt,
459 	struct scsi_status *);
460 static int st_report_soft_errors(dev_t dev, int flag);
461 static void st_delayed_cv_broadcast(void *arg);
462 static int st_check_media(dev_t dev, enum mtio_state state);
463 static int st_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp);
464 static void st_intr_restart(void *arg);
465 static void st_start_restart(void *arg);
466 static int st_gen_mode_sense(struct scsi_tape *un, int page,
467     struct seq_mode *page_data, int page_size);
468 static int st_change_block_size(dev_t dev, uint32_t nblksz);
469 static int st_gen_mode_select(struct scsi_tape *un, struct seq_mode *page_data,
470     int page_size);
471 static int st_tape_init(dev_t dev);
472 static void st_flush(struct scsi_tape *un);
473 static void st_set_pe_errno(struct scsi_tape *un);
474 static void st_hba_unflush(struct scsi_tape *un);
475 static void st_turn_pe_on(struct scsi_tape *un);
476 static void st_turn_pe_off(struct scsi_tape *un);
477 static void st_set_pe_flag(struct scsi_tape *un);
478 static void st_clear_pe(struct scsi_tape *un);
479 static void st_wait_for_io(struct scsi_tape *un);
480 static int st_set_devconfig_page(struct scsi_tape *un, int compression_on);
481 static int st_set_datacomp_page(struct scsi_tape *un, int compression_on);
482 static int st_reserve_release(struct scsi_tape *un, int command);
483 static int st_check_cdb_for_need_to_reserve(struct scsi_tape *un, caddr_t cdb);
484 static int st_check_cmd_for_need_to_reserve(struct scsi_tape *un, uchar_t cmd,
485     int count);
486 static int st_take_ownership(dev_t dev);
487 static int st_check_asc_ascq(struct scsi_tape *un);
488 static int st_check_clean_bit(dev_t dev);
489 static int st_check_alert_clean_bit(dev_t dev);
490 static int st_check_sequential_clean_bit(dev_t dev);
491 static int st_check_sense_clean_bit(dev_t dev);
492 static int st_clear_unit_attentions(dev_t dev_instance, int max_trys);
493 static void st_calculate_timeouts(struct scsi_tape *un);
494 
495 #if defined(__i386) || defined(__amd64)
496 /*
497  * routines for I/O in big block size
498  */
499 static void st_release_contig_mem(struct scsi_tape *un, struct contig_mem *cp);
500 static struct contig_mem *st_get_contig_mem(struct scsi_tape *un, size_t len,
501     int alloc_flags);
502 static int st_bigblk_xfer_done(struct buf *bp);
503 static struct buf *st_get_bigblk_bp(struct buf *bp);
504 #endif
505 
506 /*
507  * error statistics create/update functions
508  */
509 static int st_create_errstats(struct scsi_tape *, int);
510 static void st_uscsi_minphys(struct buf *bp);
511 static int st_validate_tapemarks(struct scsi_tape *un, int fileno, daddr_t bn);
512 
513 #ifdef STDEBUG
514 static void st_debug_cmds(struct scsi_tape *un, int com, int count, int wait);
515 static char *st_dev_name(dev_t dev);
516 #endif /* STDEBUG */
517 
518 #if !defined(lint)
519 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", scsi_pkt buf uio scsi_cdb))
520 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", scsi_extended_sense scsi_status))
521 _NOTE(SCHEME_PROTECTS_DATA("stable data", scsi_device))
522 _NOTE(DATA_READABLE_WITHOUT_LOCK(st_drivetype scsi_address))
523 #endif
524 
525 /*
526  * autoconfiguration routines.
527  */
528 char _depends_on[] = "misc/scsi";
529 
530 static struct modldrv modldrv = {
531 	&mod_driverops,		/* Type of module. This one is a driver */
532 	"SCSI tape Driver %I%", /* Name of the module. */
533 	&st_ops			/* driver ops */
534 };
535 
536 static struct modlinkage modlinkage = {
537 	MODREV_1, &modldrv, NULL
538 };
539 
540 /*
541  * Notes on Post Reset Behavior in the tape driver:
542  *
543  * When the tape drive is opened, the driver  attempts  to make sure that
544  * the tape head is positioned exactly where it was left when it was last
545  * closed  provided  the  medium  is not  changed.  If the tape  drive is
546  * opened in O_NDELAY mode, the repositioning  (if necessary for any loss
547  * of position due to reset) will happen when the first tape operation or
548  * I/O occurs.  The repositioning (if required) may not be possible under
549  * certain situations such as when the device firmware not able to report
550  * the medium  change in the REQUEST  SENSE data  because of a reset or a
551  * misbehaving  bus  not  allowing  the  reposition  to  happen.  In such
552  * extraordinary  situations, where the driver fails to position the head
553  * at its  original  position,  it will fail the open the first  time, to
554  * save the applications from overwriting the data.  All further attempts
555  * to open the tape device will result in the driver  attempting  to load
556  * the  tape at BOT  (beginning  of  tape).  Also a  warning  message  to
557  * indicate  that further  attempts to open the tape device may result in
558  * the tape being  loaded at BOT will be printed on the  console.  If the
559  * tape  device is opened  in  O_NDELAY  mode,  failure  to  restore  the
560  * original tape head  position,  will result in the failure of the first
561  * tape  operation  or I/O,  Further,  the  driver  will  invalidate  its
562  * internal tape position  which will  necessitate  the  applications  to
563  * validate the position by using either a tape  positioning  ioctl (such
564  * as MTREW) or closing and reopening the tape device.
565  *
566  */
567 
568 int
569 _init(void)
570 {
571 	int e;
572 
573 	if (((e = ddi_soft_state_init(&st_state,
574 	    sizeof (struct scsi_tape), ST_MAXUNIT)) != 0)) {
575 		return (e);
576 	}
577 
578 	if ((e = mod_install(&modlinkage)) != 0) {
579 		ddi_soft_state_fini(&st_state);
580 	}
581 
582 #if defined(__x86)
583 	/* set the max physical address for iob allocs on x86 */
584 	st_alloc_attr.dma_attr_addr_hi = st_max_phys_addr;
585 
586 	/*
587 	 * set the sgllen for iob allocs on x86. If this is set less than
588 	 * the number of pages the buffer will take (taking into account
589 	 * alignment), it would force the allocator to try and allocate
590 	 * contiguous pages.
591 	 */
592 	st_alloc_attr.dma_attr_sgllen = st_sgl_size;
593 #endif
594 
595 	return (e);
596 }
597 
598 int
599 _fini(void)
600 {
601 	int e;
602 
603 	if ((e = mod_remove(&modlinkage)) != 0) {
604 		return (e);
605 	}
606 
607 	ddi_soft_state_fini(&st_state);
608 
609 	return (e);
610 }
611 
612 int
613 _info(struct modinfo *modinfop)
614 {
615 	return (mod_info(&modlinkage, modinfop));
616 }
617 
618 
619 static int
620 st_probe(dev_info_t *devi)
621 {
622 	int instance;
623 	struct scsi_device *devp;
624 	int rval;
625 
626 #if !defined(__sparc)
627 	char    *tape_prop;
628 	int	tape_prop_len;
629 #endif
630 
631 	/* If self identifying device */
632 	if (ddi_dev_is_sid(devi) == DDI_SUCCESS) {
633 		return (DDI_PROBE_DONTCARE);
634 	}
635 
636 #if !defined(__sparc)
637 	/*
638 	 * Since some x86 HBAs have devnodes that look like SCSI as
639 	 * far as we can tell but aren't really SCSI (DADK, like mlx)
640 	 * we check for the presence of the "tape" property.
641 	 */
642 	if (ddi_prop_op(DDI_DEV_T_NONE, devi, PROP_LEN_AND_VAL_ALLOC,
643 	    DDI_PROP_CANSLEEP, "tape",
644 	    (caddr_t)&tape_prop, &tape_prop_len) != DDI_PROP_SUCCESS) {
645 		return (DDI_PROBE_FAILURE);
646 	}
647 	if (strncmp(tape_prop, "sctp", tape_prop_len) != 0) {
648 		kmem_free(tape_prop, tape_prop_len);
649 		return (DDI_PROBE_FAILURE);
650 	}
651 	kmem_free(tape_prop, tape_prop_len);
652 #endif
653 
654 	devp = ddi_get_driver_private(devi);
655 	instance = ddi_get_instance(devi);
656 
657 	if (ddi_get_soft_state(st_state, instance) != NULL) {
658 		return (DDI_PROBE_PARTIAL);
659 	}
660 
661 
662 	/*
663 	 * Turn around and call probe routine to see whether
664 	 * we actually have a tape at this SCSI nexus.
665 	 */
666 	if (scsi_probe(devp, NULL_FUNC) == SCSIPROBE_EXISTS) {
667 
668 		/*
669 		 * In checking the whole inq_dtype byte we are looking at both
670 		 * the Peripheral Qualifier and the Peripheral Device Type.
671 		 * For this driver we are only interested in sequential devices
672 		 * that are connected or capable if connecting to this logical
673 		 * unit.
674 		 */
675 		if (devp->sd_inq->inq_dtype ==
676 		    (DTYPE_SEQUENTIAL | DPQ_POSSIBLE)) {
677 			ST_DEBUG6(devi, st_label, SCSI_DEBUG,
678 			    "probe exists\n");
679 			rval = DDI_PROBE_SUCCESS;
680 		} else {
681 			rval = DDI_PROBE_FAILURE;
682 		}
683 	} else {
684 		ST_DEBUG6(devi, st_label, SCSI_DEBUG,
685 		    "probe failure: nothing there\n");
686 		rval = DDI_PROBE_FAILURE;
687 	}
688 	scsi_unprobe(devp);
689 	return (rval);
690 }
691 
692 static int
693 st_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
694 {
695 	int 	instance;
696 	int	wide;
697 	int 	dev_instance;
698 	int	ret_status;
699 	struct	scsi_device *devp;
700 	int	node_ix;
701 	struct	scsi_tape *un;
702 
703 	devp = ddi_get_driver_private(devi);
704 	instance = ddi_get_instance(devi);
705 
706 	switch (cmd) {
707 		case DDI_ATTACH:
708 			if (st_doattach(devp, SLEEP_FUNC) == DDI_FAILURE) {
709 				return (DDI_FAILURE);
710 			}
711 			break;
712 		case DDI_RESUME:
713 			/*
714 			 * Suspend/Resume
715 			 *
716 			 * When the driver suspended, there might be
717 			 * outstanding cmds and therefore we need to
718 			 * reset the suspended flag and resume the scsi
719 			 * watch thread and restart commands and timeouts
720 			 */
721 
722 			if (!(un = ddi_get_soft_state(st_state, instance))) {
723 				return (DDI_FAILURE);
724 			}
725 			dev_instance = ((un->un_dev == 0) ? MTMINOR(instance) :
726 			    un->un_dev);
727 
728 			mutex_enter(ST_MUTEX);
729 
730 			un->un_throttle = un->un_max_throttle;
731 			un->un_tids_at_suspend = 0;
732 			un->un_pwr_mgmt = ST_PWR_NORMAL;
733 
734 			if (un->un_swr_token) {
735 				scsi_watch_resume(un->un_swr_token);
736 			}
737 
738 			/*
739 			 * Restart timeouts
740 			 */
741 			if ((un->un_tids_at_suspend & ST_DELAY_TID) != 0) {
742 				mutex_exit(ST_MUTEX);
743 				un->un_delay_tid =
744 				    timeout(st_delayed_cv_broadcast, un,
745 					drv_usectohz((clock_t)
746 					MEDIA_ACCESS_DELAY));
747 				mutex_enter(ST_MUTEX);
748 			}
749 
750 			if (un->un_tids_at_suspend & ST_HIB_TID) {
751 				mutex_exit(ST_MUTEX);
752 				un->un_hib_tid = timeout(st_intr_restart, un,
753 				    ST_STATUS_BUSY_TIMEOUT);
754 				mutex_enter(ST_MUTEX);
755 			}
756 
757 			ret_status = st_clear_unit_attentions(dev_instance, 5);
758 
759 			/*
760 			 * now check if we need to restore the tape position
761 			 */
762 			if ((un->un_suspend_fileno > 0) ||
763 			    (un->un_suspend_blkno > 0)) {
764 				if (ret_status != 0) {
765 					/*
766 					 * tape didn't get good TUR
767 					 * just print out error messages
768 					 */
769 					scsi_log(ST_DEVINFO, st_label, CE_WARN,
770 					    "st_attach-RESUME: tape failure "
771 					    " tape position will be lost");
772 				} else {
773 					/* this prints errors */
774 					(void) st_validate_tapemarks(un,
775 					    un->un_suspend_fileno,
776 					    un->un_suspend_blkno);
777 				}
778 				/*
779 				 * there are no retries, if there is an error
780 				 * we don't know if the tape has changed
781 				 */
782 				un->un_suspend_fileno = 0;
783 				un->un_suspend_blkno = 0;
784 			}
785 
786 			/* now we are ready to start up any queued I/Os */
787 			if (un->un_ncmds || un->un_quef) {
788 				st_start(un);
789 			}
790 
791 			cv_broadcast(&un->un_suspend_cv);
792 			mutex_exit(ST_MUTEX);
793 			return (DDI_SUCCESS);
794 
795 		default:
796 			return (DDI_FAILURE);
797 	}
798 
799 	un = ddi_get_soft_state(st_state, instance);
800 
801 	ST_DEBUG(devi, st_label, SCSI_DEBUG,
802 	    "st_attach: instance=%x\n", instance);
803 
804 	/*
805 	 * find the drive type for this target
806 	 */
807 	st_known_tape_type(un);
808 
809 	for (node_ix = 0; node_ix < ST_NUM_MEMBERS(st_minor_data); node_ix++) {
810 		int minor;
811 		char *name;
812 
813 		name  = st_minor_data[node_ix].name;
814 		minor = st_minor_data[node_ix].minor;
815 
816 		/*
817 		 * For default devices set the density to the
818 		 * preferred default density for this device.
819 		 */
820 		if (node_ix <= DEF_BSD_NR) {
821 			minor |= un->un_dp->default_density;
822 		}
823 		minor |= MTMINOR(instance);
824 
825 		if (ddi_create_minor_node(devi, name, S_IFCHR, minor,
826 		    DDI_NT_TAPE, NULL) == DDI_SUCCESS) {
827 			continue;
828 		}
829 
830 		ddi_remove_minor_node(devi, NULL);
831 		if (un) {
832 			cv_destroy(&un->un_clscv);
833 			cv_destroy(&un->un_sbuf_cv);
834 			cv_destroy(&un->un_queue_cv);
835 			cv_destroy(&un->un_state_cv);
836 			cv_destroy(&un->un_suspend_cv);
837 			cv_destroy(&un->un_tape_busy_cv);
838 
839 			if (un->un_sbufp) {
840 				freerbuf(un->un_sbufp);
841 			}
842 			if (un->un_uscsi_rqs_buf) {
843 				kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH);
844 			}
845 			if (un->un_mspl) {
846 				i_ddi_mem_free((caddr_t)un->un_mspl, 0);
847 			}
848 			scsi_destroy_pkt(un->un_rqs);
849 			scsi_free_consistent_buf(un->un_rqs_bp);
850 			ddi_soft_state_free(st_state, instance);
851 			devp->sd_private = NULL;
852 			devp->sd_sense = NULL;
853 
854 		}
855 		ddi_prop_remove_all(devi);
856 		return (DDI_FAILURE);
857 	}
858 
859 	/*
860 	 * Add a zero-length attribute to tell the world we support
861 	 * kernel ioctls (for layered drivers)
862 	 */
863 	(void) ddi_prop_create(DDI_DEV_T_NONE, devi, DDI_PROP_CANSLEEP,
864 	    DDI_KERNEL_IOCTL, NULL, 0);
865 
866 	ddi_report_dev((dev_info_t *)devi);
867 
868 	/*
869 	 * If it's a SCSI-2 tape drive which supports wide,
870 	 * tell the host adapter to use wide.
871 	 */
872 	wide = ((devp->sd_inq->inq_rdf == RDF_SCSI2) &&
873 	    (devp->sd_inq->inq_wbus16 || devp->sd_inq->inq_wbus32)) ?
874 		1 : 0;
875 
876 	if (scsi_ifsetcap(ROUTE, "wide-xfer", wide, 1) == 1) {
877 		ST_DEBUG(devi, st_label, SCSI_DEBUG,
878 		    "Wide Transfer %s\n", wide ? "enabled" : "disabled");
879 	}
880 
881 	/*
882 	 * enable autorequest sense; keep the rq packet around in case
883 	 * the autorequest sense fails because of a busy condition
884 	 * do a getcap first in case the capability is not variable
885 	 */
886 	if (scsi_ifgetcap(ROUTE, "auto-rqsense", 1) == 1) {
887 		un->un_arq_enabled = 1;
888 	} else {
889 		un->un_arq_enabled =
890 		    ((scsi_ifsetcap(ROUTE, "auto-rqsense", 1, 1) == 1) ? 1 : 0);
891 	}
892 
893 
894 	ST_DEBUG(devi, st_label, SCSI_DEBUG, "auto request sense %s\n",
895 		(un->un_arq_enabled ? "enabled" : "disabled"));
896 
897 	un->un_untagged_qing =
898 	    (scsi_ifgetcap(ROUTE, "untagged-qing", 0) == 1);
899 
900 	/*
901 	 * XXX - This is just for 2.6.  to tell users that write buffering
902 	 *	has gone away.
903 	 */
904 	if (un->un_arq_enabled && un->un_untagged_qing) {
905 		if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
906 		    "tape-driver-buffering", 0) != 0) {
907 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
908 			    "Write Data Buffering has been depricated. Your "
909 			    "applications should continue to work normally.\n"
910 			    " But, they should  ported to use Asynchronous "
911 			    " I/O\n"
912 			    " For more information, read about "
913 			    " tape-driver-buffering "
914 			    "property in the st(7d) man page\n");
915 		}
916 	}
917 
918 	un->un_max_throttle = un->un_throttle = un->un_last_throttle = 1;
919 	un->un_flush_on_errors = 0;
920 	un->un_mkr_pkt = (struct scsi_pkt *)NULL;
921 
922 	ST_DEBUG(devi, st_label, SCSI_DEBUG,
923 	    "throttle=%x, max_throttle = %x\n",
924 	    un->un_throttle, un->un_max_throttle);
925 
926 	/* initialize persistent errors to nil */
927 	un->un_persistence = 0;
928 	un->un_persist_errors = 0;
929 
930 	/*
931 	 * Get dma-max from HBA driver. If it is not defined, use 64k
932 	 */
933 	un->un_maxdma	= scsi_ifgetcap(&devp->sd_address, "dma-max", 1);
934 	if (un->un_maxdma == -1) {
935 		un->un_maxdma = (64 * 1024);
936 	}
937 
938 	un->un_maxbsize = MAXBSIZE_UNKNOWN;
939 
940 	un->un_mediastate = MTIO_NONE;
941 	un->un_HeadClean  = TAPE_ALERT_SUPPORT_UNKNOWN;
942 
943 	/*
944 	 * initialize kstats
945 	 */
946 	un->un_stats = kstat_create("st", instance, NULL, "tape",
947 			KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT);
948 	if (un->un_stats) {
949 		un->un_stats->ks_lock = ST_MUTEX;
950 		kstat_install(un->un_stats);
951 	}
952 	(void) st_create_errstats(un, instance);
953 
954 	return (DDI_SUCCESS);
955 }
956 
957 /*
958  * st_detach:
959  *
960  * we allow a detach if and only if:
961  *	- no tape is currently inserted
962  *	- tape position is at BOT or unknown
963  *		(if it is not at BOT then a no rewind
964  *		device was opened and we have to preserve state)
965  *	- it must be in a closed state : no timeouts or scsi_watch requests
966  *		will exist if it is closed, so we don't need to check for
967  *		them here.
968  */
969 /*ARGSUSED*/
970 static int
971 st_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
972 {
973 	int 	instance;
974 	int 	dev_instance;
975 	struct scsi_device *devp;
976 	struct scsi_tape *un;
977 	clock_t wait_cmds_complete;
978 
979 	instance = ddi_get_instance(devi);
980 
981 	if (!(un = ddi_get_soft_state(st_state, instance))) {
982 		return (DDI_FAILURE);
983 	}
984 
985 	switch (cmd) {
986 
987 	case DDI_DETACH:
988 		/*
989 		 * Undo what we did in st_attach & st_doattach,
990 		 * freeing resources and removing things we installed.
991 		 * The system framework guarantees we are not active
992 		 * with this devinfo node in any other entry points at
993 		 * this time.
994 		 */
995 
996 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
997 		    "st_detach: instance=%x, un=%p\n", instance,
998 		    (void *)un);
999 
1000 		if (((un->un_dp->options & ST_UNLOADABLE) == 0) ||
1001 		    (un->un_ncmds != 0) || (un->un_quef != NULL) ||
1002 		    (un->un_state != ST_STATE_CLOSED)) {
1003 			/*
1004 			 * we cannot unload some targets because the
1005 			 * inquiry returns junk unless immediately
1006 			 * after a reset
1007 			 */
1008 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
1009 			    "cannot unload instance %x\n", instance);
1010 			return (DDI_FAILURE);
1011 		}
1012 
1013 		/*
1014 		 * if the tape has been removed then we may unload;
1015 		 * do a test unit ready and if it returns NOT READY
1016 		 * then we assume that it is safe to unload.
1017 		 * as a side effect, fileno may be set to -1 if the
1018 		 * the test unit ready fails;
1019 		 * also un_state may be set to non-closed, so reset it
1020 		 */
1021 		if ((un->un_dev) &&		/* Been opened since attach */
1022 		    ((un->un_fileno > 0) ||	/* Known position not rewound */
1023 		    (un->un_blkno != 0))) {	/* Or within first file */
1024 			mutex_enter(ST_MUTEX);
1025 			/*
1026 			 * Send Test Unit Ready in the hopes that if
1027 			 * the drive is not in the state we think it is.
1028 			 * And the state will be changed so it can be detached.
1029 			 * If the command fails to reach the device and
1030 			 * the drive was not rewound or unloaded we want
1031 			 * to fail the detach till a user command fails
1032 			 * where after the detach will succead.
1033 			 */
1034 			(void) st_cmd(un->un_dev, SCMD_TEST_UNIT_READY,
1035 			    0, SYNC_CMD);
1036 			/*
1037 			 * After TUR un_state may be set to non-closed,
1038 			 * so reset it back.
1039 			 */
1040 			un->un_state = ST_STATE_CLOSED;
1041 			mutex_exit(ST_MUTEX);
1042 		}
1043 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
1044 		    "un_status=%x, fileno=%x, blkno=%lx\n",
1045 		    un->un_status, un->un_fileno, un->un_blkno);
1046 
1047 		/*
1048 		 * check again:
1049 		 * if we are not at BOT then it is not safe to unload
1050 		 */
1051 		if ((un->un_dev) &&		/* Been opened since attach */
1052 		    ((un->un_fileno > 0) ||	/* Known position not rewound */
1053 		    (un->un_blkno != 0))) {	/* Or within first file */
1054 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
1055 			    "cannot detach: fileno=%x, blkno=%lx\n",
1056 			    un->un_fileno, un->un_blkno);
1057 			return (DDI_FAILURE);
1058 		}
1059 
1060 		/*
1061 		 * Just To make sure that we have released the
1062 		 * tape unit .
1063 		 */
1064 		if (un->un_dev && (un->un_rsvd_status & ST_RESERVE) &&
1065 		    !DEVI_IS_DEVICE_REMOVED(devi)) {
1066 			mutex_enter(ST_MUTEX);
1067 			(void) st_reserve_release(un, ST_RELEASE);
1068 			mutex_exit(ST_MUTEX);
1069 		}
1070 
1071 		/*
1072 		 * now remove other data structures allocated in st_doattach()
1073 		 */
1074 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
1075 		    "destroying/freeing\n");
1076 		cv_destroy(&un->un_clscv);
1077 		cv_destroy(&un->un_sbuf_cv);
1078 		cv_destroy(&un->un_queue_cv);
1079 		cv_destroy(&un->un_suspend_cv);
1080 		cv_destroy(&un->un_tape_busy_cv);
1081 
1082 		if (un->un_hib_tid) {
1083 			(void) untimeout(un->un_hib_tid);
1084 			un->un_hib_tid = 0;
1085 		}
1086 
1087 		if (un->un_delay_tid) {
1088 			(void) untimeout(un->un_delay_tid);
1089 			un->un_delay_tid = 0;
1090 		}
1091 		cv_destroy(&un->un_state_cv);
1092 
1093 #if defined(__i386) || defined(__amd64)
1094 		if (un->un_contig_mem_hdl != NULL) {
1095 			ddi_dma_free_handle(&un->un_contig_mem_hdl);
1096 		}
1097 #endif
1098 		if (un->un_sbufp) {
1099 			freerbuf(un->un_sbufp);
1100 		}
1101 		if (un->un_uscsi_rqs_buf) {
1102 			kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH);
1103 		}
1104 		if (un->un_mspl) {
1105 			i_ddi_mem_free((caddr_t)un->un_mspl, 0);
1106 		}
1107 		if (un->un_rqs) {
1108 			scsi_destroy_pkt(un->un_rqs);
1109 			scsi_free_consistent_buf(un->un_rqs_bp);
1110 		}
1111 		if (un->un_mkr_pkt) {
1112 			scsi_destroy_pkt(un->un_mkr_pkt);
1113 		}
1114 		if (un->un_arq_enabled) {
1115 			(void) scsi_ifsetcap(ROUTE, "auto-rqsense", 0, 1);
1116 		}
1117 		if (un->un_dp_size) {
1118 			kmem_free(un->un_dp, un->un_dp_size);
1119 		}
1120 		if (un->un_stats) {
1121 			kstat_delete(un->un_stats);
1122 			un->un_stats = (kstat_t *)0;
1123 		}
1124 		if (un->un_errstats) {
1125 			kstat_delete(un->un_errstats);
1126 			un->un_errstats = (kstat_t *)0;
1127 		}
1128 		devp = ST_SCSI_DEVP;
1129 		ddi_soft_state_free(st_state, instance);
1130 		devp->sd_private = NULL;
1131 		devp->sd_sense = NULL;
1132 		scsi_unprobe(devp);
1133 		ddi_prop_remove_all(devi);
1134 		ddi_remove_minor_node(devi, NULL);
1135 		ST_DEBUG(0, st_label, SCSI_DEBUG, "st_detach done\n");
1136 		return (DDI_SUCCESS);
1137 
1138 	case DDI_SUSPEND:
1139 
1140 		/*
1141 		 * Suspend/Resume
1142 		 *
1143 		 * To process DDI_SUSPEND, we must do the following:
1144 		 *
1145 		 *  - check ddi_removing_power to see if power will be turned
1146 		 *    off. if so, return DDI_FAILURE
1147 		 *  - check if we are already suspended,
1148 		 *    if so, return DDI_FAILURE
1149 		 *  - check if device state is CLOSED,
1150 		 *    if not, return DDI_FAILURE.
1151 		 *  - wait until outstanding operations complete
1152 		 *  - save tape state
1153 		 *  - block new operations
1154 		 *  - cancel pending timeouts
1155 		 *
1156 		 */
1157 
1158 		if (ddi_removing_power(devi))
1159 			return (DDI_FAILURE);
1160 
1161 		mutex_enter(ST_MUTEX);
1162 
1163 		/*
1164 		 * Shouldn't already be suspended, if so return failure
1165 		 */
1166 		if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
1167 			mutex_exit(ST_MUTEX);
1168 			return (DDI_FAILURE);
1169 		}
1170 		if (un->un_state != ST_STATE_CLOSED) {
1171 			mutex_exit(ST_MUTEX);
1172 			return (DDI_FAILURE);
1173 		}
1174 
1175 		/*
1176 		 * Wait for all outstanding I/O's to complete
1177 		 *
1178 		 * we wait on both ncmds and the wait queue for times
1179 		 * when we are flushing after persistent errors are
1180 		 * flagged, which is when ncmds can be 0, and the
1181 		 * queue can still have I/O's.  This way we preserve
1182 		 * order of biodone's.
1183 		 */
1184 		wait_cmds_complete = ddi_get_lbolt();
1185 		wait_cmds_complete +=
1186 		    st_wait_cmds_complete * drv_usectohz(1000000);
1187 		while (un->un_ncmds || un->un_quef ||
1188 		    (un->un_state == ST_STATE_RESOURCE_WAIT)) {
1189 
1190 			if (cv_timedwait(&un->un_tape_busy_cv, ST_MUTEX,
1191 			    wait_cmds_complete) == -1) {
1192 				/*
1193 				 * Time expired then cancel the command
1194 				 */
1195 				mutex_exit(ST_MUTEX);
1196 				if (scsi_reset(ROUTE, RESET_TARGET) == 0) {
1197 					mutex_enter(ST_MUTEX);
1198 					if (un->un_last_throttle) {
1199 						un->un_throttle =
1200 						    un->un_last_throttle;
1201 					}
1202 					mutex_exit(ST_MUTEX);
1203 					return (DDI_FAILURE);
1204 				} else {
1205 					mutex_enter(ST_MUTEX);
1206 					break;
1207 				}
1208 			}
1209 		}
1210 
1211 		/*
1212 		 * DDI_SUSPEND says that the system "may" power down, we
1213 		 * remember the file and block number before rewinding.
1214 		 * we also need to save state before issuing
1215 		 * any WRITE_FILE_MARK command.
1216 		 */
1217 		if (un->un_fileno < 0) {
1218 			un->un_suspend_fileno = 0;
1219 			un->un_suspend_blkno  = 0;
1220 		} else {
1221 			un->un_suspend_fileno = un->un_fileno;
1222 			un->un_suspend_blkno = un->un_blkno;
1223 		}
1224 		dev_instance = ((un->un_dev == 0) ? MTMINOR(instance) :
1225 		    un->un_dev);
1226 
1227 		/*
1228 		 * Issue a zero write file fmk command to tell the drive to
1229 		 * flush any buffered tape marks
1230 		 */
1231 		(void) st_cmd(dev_instance, SCMD_WRITE_FILE_MARK, 0, SYNC_CMD);
1232 
1233 		/*
1234 		 * Because not all tape drives correctly implement buffer
1235 		 * flushing with the zero write file fmk command, issue a
1236 		 * synchronous rewind command to force data flushing.
1237 		 * st_validate_tapemarks() will do a rewind during DDI_RESUME
1238 		 * anyway.
1239 		 */
1240 		(void) st_cmd(dev_instance, SCMD_REWIND, 0, SYNC_CMD);
1241 
1242 		/* stop any new operations */
1243 		un->un_pwr_mgmt = ST_PWR_SUSPENDED;
1244 		un->un_throttle = 0;
1245 
1246 		/*
1247 		 * cancel any outstanding timeouts
1248 		 */
1249 		if (un->un_delay_tid) {
1250 			timeout_id_t temp_id = un->un_delay_tid;
1251 			un->un_delay_tid = 0;
1252 			un->un_tids_at_suspend |= ST_DELAY_TID;
1253 			mutex_exit(ST_MUTEX);
1254 			(void) untimeout(temp_id);
1255 			mutex_enter(ST_MUTEX);
1256 		}
1257 
1258 		if (un->un_hib_tid) {
1259 			timeout_id_t temp_id = un->un_hib_tid;
1260 			un->un_hib_tid = 0;
1261 			un->un_tids_at_suspend |= ST_HIB_TID;
1262 			mutex_exit(ST_MUTEX);
1263 			(void) untimeout(temp_id);
1264 			mutex_enter(ST_MUTEX);
1265 		}
1266 
1267 		/*
1268 		 * Suspend the scsi_watch_thread
1269 		 */
1270 		if (un->un_swr_token) {
1271 			opaque_t temp_token = un->un_swr_token;
1272 			mutex_exit(ST_MUTEX);
1273 			scsi_watch_suspend(temp_token);
1274 		} else {
1275 			mutex_exit(ST_MUTEX);
1276 		}
1277 
1278 		return (DDI_SUCCESS);
1279 
1280 	default:
1281 		ST_DEBUG(0, st_label, SCSI_DEBUG, "st_detach failed\n");
1282 		return (DDI_FAILURE);
1283 	}
1284 }
1285 
1286 
1287 /* ARGSUSED */
1288 static int
1289 stinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
1290 {
1291 	dev_t dev;
1292 	struct scsi_tape *un;
1293 	int instance, error;
1294 	switch (infocmd) {
1295 	case DDI_INFO_DEVT2DEVINFO:
1296 		dev = (dev_t)arg;
1297 		instance = MTUNIT(dev);
1298 		if ((un = ddi_get_soft_state(st_state, instance)) == NULL)
1299 			return (DDI_FAILURE);
1300 		*result = (void *) ST_DEVINFO;
1301 		error = DDI_SUCCESS;
1302 		break;
1303 	case DDI_INFO_DEVT2INSTANCE:
1304 		dev = (dev_t)arg;
1305 		instance = MTUNIT(dev);
1306 		*result = (void *)(uintptr_t)instance;
1307 		error = DDI_SUCCESS;
1308 		break;
1309 	default:
1310 		error = DDI_FAILURE;
1311 	}
1312 	return (error);
1313 }
1314 
1315 static int
1316 st_doattach(struct scsi_device *devp, int (*canwait)())
1317 {
1318 	struct scsi_pkt *rqpkt = NULL;
1319 	struct scsi_tape *un = NULL;
1320 	int km_flags = (canwait != NULL_FUNC) ? KM_SLEEP : KM_NOSLEEP;
1321 	int instance;
1322 	struct buf *bp;
1323 	size_t rlen;
1324 
1325 	/*
1326 	 * Call the routine scsi_probe to do some of the dirty work.
1327 	 * If the INQUIRY command succeeds, the field sd_inq in the
1328 	 * device structure will be filled in.
1329 	 */
1330 	ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG,
1331 		"st_doattach(): probing\n");
1332 
1333 	if (scsi_probe(devp, canwait) == SCSIPROBE_EXISTS) {
1334 
1335 		/*
1336 		 * In checking the whole inq_dtype byte we are looking at both
1337 		 * the Peripheral Qualifier and the Peripheral Device Type.
1338 		 * For this driver we are only interested in sequential devices
1339 		 * that are connected or capable if connecting to this logical
1340 		 * unit.
1341 		 */
1342 		if (devp->sd_inq->inq_dtype ==
1343 		    (DTYPE_SEQUENTIAL | DPQ_POSSIBLE)) {
1344 			ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG,
1345 			    "probe exists\n");
1346 		} else {
1347 			/* Something there but not a tape device */
1348 			scsi_unprobe(devp);
1349 			return (DDI_FAILURE);
1350 		}
1351 	} else {
1352 		/* Nothing there */
1353 		ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG,
1354 		    "probe failure: nothing there\n");
1355 		scsi_unprobe(devp);
1356 		return (DDI_FAILURE);
1357 	}
1358 
1359 	bp = scsi_alloc_consistent_buf(&devp->sd_address, (struct buf *)NULL,
1360 	    SENSE_LENGTH, B_READ, canwait, NULL);
1361 	if (!bp) {
1362 		goto error;
1363 	}
1364 	rqpkt = scsi_init_pkt(&devp->sd_address,
1365 	    (struct scsi_pkt *)NULL, bp, CDB_GROUP0, 1, 0,
1366 	    PKT_CONSISTENT, canwait, NULL);
1367 	if (!rqpkt) {
1368 		goto error;
1369 	}
1370 	devp->sd_sense = (struct scsi_extended_sense *)bp->b_un.b_addr;
1371 	ASSERT(geterror(bp) == NULL);
1372 
1373 	(void) scsi_setup_cdb((union scsi_cdb *)rqpkt->pkt_cdbp,
1374 	    SCMD_REQUEST_SENSE, 0, SENSE_LENGTH, 0);
1375 	FILL_SCSI1_LUN(devp, rqpkt);
1376 
1377 	/*
1378 	 * The actual unit is present.
1379 	 * Now is the time to fill in the rest of our info..
1380 	 */
1381 	instance = ddi_get_instance(devp->sd_dev);
1382 
1383 	if (ddi_soft_state_zalloc(st_state, instance) != DDI_SUCCESS) {
1384 		goto error;
1385 	}
1386 	un = ddi_get_soft_state(st_state, instance);
1387 
1388 	un->un_sbufp = getrbuf(km_flags);
1389 
1390 	un->un_uscsi_rqs_buf = kmem_alloc(SENSE_LENGTH, KM_SLEEP);
1391 
1392 	/*
1393 	 * use i_ddi_mem_alloc() for now until we have an interface to allocate
1394 	 * memory for DMA which doesn't require a DMA handle. ddi_iopb_alloc()
1395 	 * is obsolete and we want more flexibility in controlling the DMA
1396 	 * address constraints.
1397 	 */
1398 	(void) i_ddi_mem_alloc(devp->sd_dev, &st_alloc_attr,
1399 	    sizeof (struct seq_mode), ((km_flags == KM_SLEEP) ? 1 : 0), 0,
1400 	    NULL, (caddr_t *)&un->un_mspl, &rlen, NULL);
1401 
1402 	if (!un->un_sbufp || !un->un_mspl) {
1403 		if (un->un_mspl) {
1404 			i_ddi_mem_free((caddr_t)un->un_mspl, 0);
1405 		}
1406 		ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG,
1407 		    "probe partial failure: no space\n");
1408 		goto error;
1409 	}
1410 
1411 	bzero(un->un_mspl, sizeof (struct seq_mode));
1412 
1413 	cv_init(&un->un_sbuf_cv, NULL, CV_DRIVER, NULL);
1414 	cv_init(&un->un_queue_cv, NULL, CV_DRIVER, NULL);
1415 	cv_init(&un->un_clscv, NULL, CV_DRIVER, NULL);
1416 	cv_init(&un->un_state_cv, NULL, CV_DRIVER, NULL);
1417 #if defined(__i386) || defined(__amd64)
1418 	cv_init(&un->un_contig_mem_cv, NULL, CV_DRIVER, NULL);
1419 #endif
1420 
1421 	/* Initialize power managemnet condition variable */
1422 	cv_init(&un->un_suspend_cv, NULL, CV_DRIVER, NULL);
1423 	cv_init(&un->un_tape_busy_cv, NULL, CV_DRIVER, NULL);
1424 
1425 	rqpkt->pkt_flags |= (FLAG_SENSING | FLAG_HEAD | FLAG_NODISCON);
1426 
1427 	un->un_fileno	= -1;
1428 	rqpkt->pkt_time = st_io_time;
1429 	rqpkt->pkt_comp = st_intr;
1430 	un->un_rqs	= rqpkt;
1431 	un->un_sd	= devp;
1432 	un->un_rqs_bp	= bp;
1433 	un->un_swr_token = (opaque_t)NULL;
1434 	un->un_comp_page = ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE;
1435 
1436 	un->un_suspend_fileno 	= 0;
1437 	un->un_suspend_blkno 	= 0;
1438 
1439 #if defined(__i386) || defined(__amd64)
1440 	if (ddi_dma_alloc_handle(ST_DEVINFO, &st_contig_mem_dma_attr,
1441 		DDI_DMA_SLEEP, NULL, &un->un_contig_mem_hdl) != DDI_SUCCESS) {
1442 		ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG,
1443 		    "allocation of contiguous memory dma handle failed!");
1444 		un->un_contig_mem_hdl = NULL;
1445 		goto error;
1446 	}
1447 #endif
1448 
1449 	/*
1450 	 * Since this driver manages devices with "remote" hardware,
1451 	 * i.e. the devices themselves have no "reg" properties,
1452 	 * the SUSPEND/RESUME commands in detach/attach will not be
1453 	 * called by the power management framework unless we request
1454 	 * it by creating a "pm-hardware-state" property and setting it
1455 	 * to value "needs-suspend-resume".
1456 	 */
1457 	if (ddi_prop_update_string(DDI_DEV_T_NONE, devp->sd_dev,
1458 	    "pm-hardware-state", "needs-suspend-resume") !=
1459 	    DDI_PROP_SUCCESS) {
1460 
1461 		ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG,
1462 		    "ddi_prop_update(\"pm-hardware-state\") failed\n");
1463 		goto error;
1464 	}
1465 
1466 	if (ddi_prop_create(DDI_DEV_T_NONE, devp->sd_dev, DDI_PROP_CANSLEEP,
1467 	    "no-involuntary-power-cycles", NULL, 0) != DDI_PROP_SUCCESS) {
1468 
1469 		ST_DEBUG(devp->sd_dev, st_label, SCSI_DEBUG,
1470 		    "ddi_prop_create(\"no-involuntary-power-cycles\") "
1471 		    "failed\n");
1472 		goto error;
1473 	}
1474 
1475 	ST_DEBUG6(devp->sd_dev, st_label, SCSI_DEBUG, "probe success\n");
1476 	return (DDI_SUCCESS);
1477 
1478 error:
1479 	devp->sd_sense = NULL;
1480 
1481 	ddi_remove_minor_node(devp->sd_dev, NULL);
1482 	if (un) {
1483 		if (un->un_mspl) {
1484 			i_ddi_mem_free((caddr_t)un->un_mspl, 0);
1485 		}
1486 		if (un->un_sbufp) {
1487 			freerbuf(un->un_sbufp);
1488 		}
1489 		if (un->un_uscsi_rqs_buf) {
1490 			kmem_free(un->un_uscsi_rqs_buf, SENSE_LENGTH);
1491 		}
1492 #if defined(__i386) || defined(__amd64)
1493 		if (un->un_contig_mem_hdl != NULL) {
1494 			ddi_dma_free_handle(&un->un_contig_mem_hdl);
1495 		}
1496 #endif
1497 		ddi_soft_state_free(st_state, instance);
1498 		devp->sd_private = NULL;
1499 	}
1500 
1501 	if (rqpkt) {
1502 		scsi_destroy_pkt(rqpkt);
1503 	}
1504 
1505 	if (bp) {
1506 		scsi_free_consistent_buf(bp);
1507 	}
1508 
1509 	if (devp->sd_inq) {
1510 		scsi_unprobe(devp);
1511 	}
1512 	return (DDI_FAILURE);
1513 }
1514 
1515 typedef int
1516 (*cfg_functp)(struct scsi_tape *, char *vidpid, struct st_drivetype *);
1517 
1518 static cfg_functp config_functs[] = {
1519 	st_get_conf_from_st_dot_conf,
1520 	st_get_conf_from_st_conf_dot_c,
1521 	st_get_default_conf
1522 };
1523 
1524 
1525 /*
1526  * determine tape type, using tape-config-list or built-in table or
1527  * use a generic tape config entry
1528  */
1529 static void
1530 st_known_tape_type(struct scsi_tape *un)
1531 {
1532 	struct st_drivetype *dp;
1533 	cfg_functp *config_funct;
1534 
1535 	/*
1536 	 * XXX:  Emulex MT-02 (and emulators) predates SCSI-1 and has
1537 	 *	 no vid & pid inquiry data.  So, we provide one.
1538 	 */
1539 	if (ST_INQUIRY->inq_len == 0 ||
1540 		(bcmp("\0\0\0\0\0\0\0\0", ST_INQUIRY->inq_vid, 8) == 0)) {
1541 		(void) strcpy((char *)ST_INQUIRY->inq_vid, ST_MT02_NAME);
1542 	}
1543 
1544 	un->un_dp_size = sizeof (struct st_drivetype);
1545 	dp = kmem_zalloc((size_t)un->un_dp_size, KM_SLEEP);
1546 	un->un_dp = dp;
1547 
1548 	/*
1549 	 * Loop through the configuration methods till one works.
1550 	 */
1551 	for (config_funct = &config_functs[0]; ; config_funct++) {
1552 		if ((*config_funct)(un, ST_INQUIRY->inq_vid, dp)) {
1553 			break;
1554 		}
1555 	}
1556 
1557 	/*
1558 	 * If we didn't just make up this configuration and
1559 	 * all the density codes are the same..
1560 	 * Set Auto Density over ride.
1561 	 */
1562 	if (*config_funct != st_get_default_conf) {
1563 		/*
1564 		 * If this device is one that is configured and all
1565 		 * densities are the same, This saves doing gets and set
1566 		 * that yield nothing.
1567 		 */
1568 		if ((dp->densities[0]) == (dp->densities[1]) &&
1569 		    (dp->densities[0]) == (dp->densities[2]) &&
1570 		    (dp->densities[0]) == (dp->densities[3])) {
1571 
1572 			dp->options |= ST_AUTODEN_OVERRIDE;
1573 		}
1574 	}
1575 
1576 
1577 	/*
1578 	 * Store tape drive characteristics.
1579 	 */
1580 	un->un_status = 0;
1581 	un->un_attached = 1;
1582 	un->un_init_options = dp->options;
1583 
1584 	/* setup operation time-outs based on options */
1585 	st_calculate_timeouts(un);
1586 
1587 	/* make sure if we are supposed to be variable, make it variable */
1588 	if (dp->options & ST_VARIABLE) {
1589 		dp->bsize = 0;
1590 	}
1591 
1592 	scsi_log(ST_DEVINFO, st_label, CE_NOTE, "?<%s>\n", dp->name);
1593 }
1594 
1595 
1596 typedef struct {
1597 	int mask;
1598 	int bottom;
1599 	int top;
1600 	char *name;
1601 } conf_limit;
1602 
1603 static const conf_limit conf_limits[] = {
1604 
1605 	-1,		1,		2,		"conf version",
1606 	-1,		MT_ISTS,	ST_LAST_TYPE,	"drive type",
1607 	-1,		0,		0xffffff,	"block size",
1608 	ST_VALID_OPTS,	0,		ST_VALID_OPTS,	"options",
1609 	-1,		0,		4,		"number of densities",
1610 	-1,		0,		UINT8_MAX,	"density code",
1611 	-1,		0,		3,		"default density",
1612 	-1,		0,		UINT16_MAX,	"non motion timeout",
1613 	-1,		0,		UINT16_MAX,	"I/O timeout",
1614 	-1,		0,		UINT16_MAX,	"space timeout",
1615 	-1,		0,		UINT16_MAX,	"load timeout",
1616 	-1,		0,		UINT16_MAX,	"unload timeout",
1617 	-1,		0,		UINT16_MAX,	"erase timeout",
1618 	0,		0,		0,		NULL
1619 };
1620 
1621 static int
1622 st_validate_conf_data(struct scsi_tape *un, int *list, int list_len,
1623     const char *conf_name)
1624 {
1625 	int dens;
1626 	int ndens;
1627 	int value;
1628 	int type;
1629 	int count;
1630 	const conf_limit *limit = &conf_limits[0];
1631 
1632 	ST_DEBUG3(ST_DEVINFO, st_label, CE_NOTE,
1633 	    "Checking %d entrys total with %d densities\n", list_len, list[4]);
1634 
1635 	count = list_len;
1636 	type = *list;
1637 	for (;  count && limit->name; count--, list++, limit++) {
1638 
1639 		value = *list;
1640 		if (value & ~limit->mask) {
1641 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
1642 			    "%s %s value invalid bits set: 0x%X\n",
1643 			    conf_name, limit->name, value & ~limit->mask);
1644 			*list &= limit->mask;
1645 		} else if (value < limit->bottom) {
1646 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
1647 			    "%s %s value too low: value = %d limit %d\n",
1648 			    conf_name, limit->name, value, limit->bottom);
1649 		} else if (value > limit->top) {
1650 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
1651 			    "%s %s value too high: value = %d limit %d\n",
1652 			    conf_name, limit->name, value, limit->top);
1653 		} else {
1654 			ST_DEBUG3(ST_DEVINFO, st_label, CE_CONT,
1655 			    "%s %s value = 0x%X\n",
1656 			    conf_name, limit->name, value);
1657 		}
1658 
1659 		/* If not the number of densities continue */
1660 		if (limit != &conf_limits[4]) {
1661 			continue;
1662 		}
1663 
1664 		/* If number of densities is not in range can't use config */
1665 		if (value < limit->bottom || value > limit->top) {
1666 			return (-1);
1667 		}
1668 
1669 		ndens = min(value, NDENSITIES);
1670 		if ((type == 1) && (list_len - ndens) != 6) {
1671 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
1672 			    "%s conf version 1 with %d densities has %d items"
1673 			    " should have %d",
1674 			    conf_name, ndens, list_len, 6 + ndens);
1675 		} else if ((type == 2) && (list_len - ndens) != 13) {
1676 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
1677 			    "%s conf version 2 with %d densities has %d items"
1678 			    " should have %d",
1679 			    conf_name, ndens, list_len, 13 + ndens);
1680 		}
1681 
1682 		limit++;
1683 		for (dens = 0; dens < ndens && count; dens++) {
1684 			count--;
1685 			list++;
1686 			value = *list;
1687 			if (value < limit->bottom) {
1688 				scsi_log(ST_DEVINFO, st_label, CE_NOTE,
1689 				    "%s density[%d] value too low: value ="
1690 				    " 0x%X limit 0x%X\n",
1691 				    conf_name, dens, value, limit->bottom);
1692 			} else if (value > limit->top) {
1693 				scsi_log(ST_DEVINFO, st_label, CE_NOTE,
1694 				    "%s density[%d] value too high: value ="
1695 				    " 0x%X limit 0x%X\n",
1696 				    conf_name, dens, value, limit->top);
1697 			} else {
1698 				ST_DEBUG3(ST_DEVINFO, st_label, CE_CONT,
1699 				    "%s density[%d] value = 0x%X\n",
1700 				    conf_name, dens, value);
1701 			}
1702 		}
1703 	}
1704 
1705 	return (0);
1706 }
1707 
1708 static int
1709 st_get_conf_from_st_dot_conf(struct scsi_tape *un, char *vidpid,
1710     struct st_drivetype *dp)
1711 {
1712 	caddr_t config_list = NULL;
1713 	caddr_t data_list = NULL;
1714 	int	*data_ptr;
1715 	caddr_t vidptr, prettyptr, datanameptr;
1716 	size_t	vidlen, prettylen, datanamelen, tripletlen = 0;
1717 	int config_list_len, data_list_len, len, i;
1718 	int version;
1719 	int found = 0;
1720 
1721 
1722 	/*
1723 	 * Determine type of tape controller. Type is determined by
1724 	 * checking the vendor ids of the earlier inquiry command and
1725 	 * comparing those with vids in tape-config-list defined in st.conf
1726 	 */
1727 	if (ddi_getlongprop(DDI_DEV_T_ANY, ST_DEVINFO, DDI_PROP_DONTPASS,
1728 	    "tape-config-list", (caddr_t)&config_list, &config_list_len)
1729 	    != DDI_PROP_SUCCESS) {
1730 		return (found);
1731 	}
1732 
1733 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
1734 	    "st_get_conf_from_st_dot_conf(): st.conf has tape-config-list\n");
1735 
1736 	/*
1737 	 * Compare vids in each triplet - if it matches, get value for
1738 	 * data_name and contruct a st_drivetype struct
1739 	 * tripletlen is not set yet!
1740 	 */
1741 	for (len = config_list_len, vidptr = config_list;
1742 	    len > 0;
1743 	    vidptr += tripletlen, len -= tripletlen) {
1744 
1745 		vidlen = strlen(vidptr);
1746 		prettyptr = vidptr + vidlen + 1;
1747 		prettylen = strlen(prettyptr);
1748 		datanameptr = prettyptr + prettylen + 1;
1749 		datanamelen = strlen(datanameptr);
1750 		tripletlen = vidlen + prettylen + datanamelen + 3;
1751 
1752 		if (vidlen == 0) {
1753 			continue;
1754 		}
1755 
1756 		/*
1757 		 * If inquiry vid dosen't match this triplets vid,
1758 		 * try the next.
1759 		 */
1760 		if (strncasecmp(vidpid, vidptr, vidlen)) {
1761 			continue;
1762 		}
1763 
1764 		/*
1765 		 * if prettylen is zero then use the vid string
1766 		 */
1767 		if (prettylen == 0) {
1768 			prettyptr = vidptr;
1769 			prettylen = vidlen;
1770 		}
1771 
1772 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
1773 		    "vid = %s, pretty=%s, dataname = %s\n",
1774 		    vidptr, prettyptr, datanameptr);
1775 
1776 		/*
1777 		 * get the data list
1778 		 */
1779 		if (ddi_getlongprop(DDI_DEV_T_ANY, ST_DEVINFO, 0,
1780 		    datanameptr, (caddr_t)&data_list,
1781 		    &data_list_len) != DDI_PROP_SUCCESS) {
1782 			/*
1783 			 * Error in getting property value
1784 			 * print warning!
1785 			 */
1786 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
1787 			    "data property (%s) has no value\n",
1788 			    datanameptr);
1789 			continue;
1790 		}
1791 
1792 		/*
1793 		 * now initialize the st_drivetype struct
1794 		 */
1795 		(void) strncpy(dp->name, prettyptr, ST_NAMESIZE - 1);
1796 		dp->length = (int)min(vidlen, (VIDPIDLEN - 1));
1797 		(void) strncpy(dp->vid, vidptr, dp->length);
1798 		data_ptr = (int *)data_list;
1799 		/*
1800 		 * check if data is enough for version, type,
1801 		 * bsize, options, # of densities, density1,
1802 		 * density2, ..., default_density
1803 		 */
1804 		if ((data_list_len < 5 * sizeof (int)) ||
1805 		    (data_list_len < 6 * sizeof (int) +
1806 		    *(data_ptr + 4) * sizeof (int))) {
1807 			/*
1808 			 * print warning and skip to next triplet.
1809 			 */
1810 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
1811 			    "data property (%s) incomplete\n",
1812 			    datanameptr);
1813 			kmem_free(data_list, data_list_len);
1814 			continue;
1815 		}
1816 
1817 		if (st_validate_conf_data(un, data_ptr,
1818 		    data_list_len / sizeof (int), datanameptr)) {
1819 			kmem_free(data_list, data_list_len);
1820 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
1821 			    "data property (%s) rejected\n",
1822 			    datanameptr);
1823 			continue;
1824 		}
1825 
1826 		/*
1827 		 * check version
1828 		 */
1829 		version = *data_ptr++;
1830 		if (version != 1 && version != 2) {
1831 			/* print warning but accept it */
1832 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
1833 			    "Version # for data property (%s) "
1834 			    "not set to 1 or 2\n", datanameptr);
1835 		}
1836 
1837 		dp->type    = *data_ptr++;
1838 		dp->bsize   = *data_ptr++;
1839 		dp->options = *data_ptr++;
1840 		dp->options |= ST_DYNAMIC;
1841 		len = *data_ptr++;
1842 		for (i = 0; i < NDENSITIES; i++) {
1843 			if (i < len) {
1844 				dp->densities[i] = *data_ptr++;
1845 			}
1846 		}
1847 		dp->default_density = *data_ptr << 3;
1848 		if (version == 2 &&
1849 		    data_list_len >= (13 + len) * sizeof (int)) {
1850 			data_ptr++;
1851 			dp->non_motion_timeout	= *data_ptr++;
1852 			dp->io_timeout		= *data_ptr++;
1853 			dp->rewind_timeout	= *data_ptr++;
1854 			dp->space_timeout	= *data_ptr++;
1855 			dp->load_timeout	= *data_ptr++;
1856 			dp->unload_timeout	= *data_ptr++;
1857 			dp->erase_timeout	= *data_ptr++;
1858 		}
1859 		kmem_free(data_list, data_list_len);
1860 		found = 1;
1861 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
1862 		    "found in st.conf: vid = %s, pretty=%s\n",
1863 		    dp->vid, dp->name);
1864 		break;
1865 	}
1866 
1867 	/*
1868 	 * free up the memory allocated by ddi_getlongprop
1869 	 */
1870 	if (config_list) {
1871 		kmem_free(config_list, config_list_len);
1872 	}
1873 	return (found);
1874 }
1875 
1876 static int
1877 st_get_conf_from_st_conf_dot_c(struct scsi_tape *un, char *vidpid,
1878     struct st_drivetype *dp)
1879 {
1880 	int i;
1881 
1882 	/*
1883 	 * Determine type of tape controller.  Type is determined by
1884 	 * checking the result of the earlier inquiry command and
1885 	 * comparing vendor ids with strings in a table declared in st_conf.c.
1886 	 */
1887 	ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
1888 	    "st_get_conf_from_st_conf_dot_c(): looking at st_drivetypes\n");
1889 
1890 	for (i = 0; i < st_ndrivetypes; i++) {
1891 		if (st_drivetypes[i].length == 0) {
1892 			continue;
1893 		}
1894 		if (strncasecmp(vidpid, st_drivetypes[i].vid,
1895 		    st_drivetypes[i].length)) {
1896 			continue;
1897 		}
1898 		bcopy(&st_drivetypes[i], dp, sizeof (st_drivetypes[i]));
1899 		return (1);
1900 	}
1901 	return (0);
1902 }
1903 
1904 static int
1905 st_get_default_conf(struct scsi_tape *un, char *vidpid, struct st_drivetype *dp)
1906 {
1907 	int i;
1908 
1909 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
1910 	    "st_get_default_conf(): making drivetype from INQ cmd\n");
1911 
1912 
1913 	/*
1914 	 * Make up a name
1915 	 */
1916 	bcopy("Vendor '", dp->name, 8);
1917 	bcopy(vidpid, &dp->name[8], VIDLEN);
1918 	bcopy("' Product '", &dp->name[16], 11);
1919 	bcopy(&vidpid[8], &dp->name[27], PIDLEN);
1920 	dp->name[ST_NAMESIZE - 2] = '\'';
1921 	dp->name[ST_NAMESIZE - 1] = '\0';
1922 	dp->length = min(strlen(ST_INQUIRY->inq_vid), (VIDPIDLEN - 1));
1923 	(void) strncpy(dp->vid, ST_INQUIRY->inq_vid, dp->length);
1924 	/*
1925 	 * 'clean' vendor and product strings of non-printing chars
1926 	 */
1927 	for (i = 0; i < ST_NAMESIZE - 2; i++) {
1928 		if (dp->name[i] < ' ' || dp->name[i] > '~') {
1929 			dp->name[i] = '.';
1930 		}
1931 	}
1932 	dp->type = ST_TYPE_INVALID;
1933 	dp->options |= (ST_DYNAMIC | ST_UNLOADABLE | ST_MODE_SEL_COMP);
1934 
1935 	return (1); /* Can Not Fail */
1936 }
1937 
1938 /*
1939  * Regular Unix Entry points
1940  */
1941 
1942 
1943 
1944 /* ARGSUSED */
1945 static int
1946 st_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p)
1947 {
1948 	dev_t dev = *dev_p;
1949 	int rval = 0;
1950 
1951 	GET_SOFT_STATE(dev);
1952 
1953 	/*
1954 	 * validate that we are addressing a sensible unit
1955 	 */
1956 	mutex_enter(ST_MUTEX);
1957 
1958 #ifdef	STDEBUG
1959 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
1960 	    "st_open(node = %s dev = 0x%lx, flag = %d, otyp = %d)\n",
1961 	    st_dev_name(dev), *dev_p, flag, otyp);
1962 #endif
1963 
1964 	/*
1965 	 * All device accesss go thru st_strategy() where we check
1966 	 * suspend status
1967 	 */
1968 
1969 	if (!un->un_attached) {
1970 		st_known_tape_type(un);
1971 		if (!un->un_attached) {
1972 			rval = ENXIO;
1973 			goto exit;
1974 		}
1975 
1976 	}
1977 
1978 	/*
1979 	 * Check for the case of the tape in the middle of closing.
1980 	 * This isn't simply a check of the current state, because
1981 	 * we could be in state of sensing with the previous state
1982 	 * that of closing.
1983 	 *
1984 	 * And don't allow multiple opens.
1985 	 */
1986 	if (!(flag & (FNDELAY | FNONBLOCK)) && IS_CLOSING(un)) {
1987 		un->un_laststate = un->un_state;
1988 		un->un_state = ST_STATE_CLOSE_PENDING_OPEN;
1989 		while (IS_CLOSING(un) ||
1990 		    un->un_state == ST_STATE_CLOSE_PENDING_OPEN) {
1991 			if (cv_wait_sig(&un->un_clscv, ST_MUTEX) == 0) {
1992 				rval = EINTR;
1993 				un->un_state = un->un_laststate;
1994 				goto exit;
1995 			}
1996 		}
1997 	} else if (un->un_state != ST_STATE_CLOSED) {
1998 		rval = EBUSY;
1999 		goto busy;
2000 	}
2001 
2002 	/*
2003 	 * record current dev
2004 	 */
2005 	un->un_dev = dev;
2006 	un->un_oflags = flag;	/* save for use in st_tape_init() */
2007 	un->un_errno = 0;	/* no errors yet */
2008 	un->un_restore_pos = 0;
2009 	un->un_rqs_state = 0;
2010 
2011 	/*
2012 	 * If we are opening O_NDELAY, or O_NONBLOCK, we don't check for
2013 	 * anything, leave internal states alone, if fileno >= 0
2014 	 */
2015 	if (flag & (FNDELAY | FNONBLOCK)) {
2016 		if (un->un_fileno < 0 || (un->un_fileno == 0 &&
2017 		    un->un_blkno == 0)) {
2018 			un->un_state = ST_STATE_OFFLINE;
2019 		} else {
2020 			/*
2021 			 * set un_read_only/write-protect status.
2022 			 *
2023 			 * If the tape is not bot we can assume
2024 			 * that mspl->wp_status is set properly.
2025 			 * else
2026 			 * we need to do a mode sense/Tur once
2027 			 * again to get the actual tape status.(since
2028 			 * user might have replaced the tape)
2029 			 * Hence make the st state OFFLINE so that
2030 			 * we re-intialize the tape once again.
2031 			 */
2032 			if (un->un_fileno > 0 ||
2033 			    (un->un_fileno == 0 && un->un_blkno != 0)) {
2034 				un->un_read_only =
2035 				    (un->un_oflags & FWRITE) ? 0 : 1;
2036 				un->un_state = ST_STATE_OPEN_PENDING_IO;
2037 			} else {
2038 				un->un_state = ST_STATE_OFFLINE;
2039 			}
2040 		}
2041 		rval = 0;
2042 	} else {
2043 		/*
2044 		 * Not opening O_NDELAY.
2045 		 */
2046 		un->un_state = ST_STATE_OPENING;
2047 
2048 		rval = st_tape_init(dev);
2049 		if (rval) {
2050 			/*
2051 			 * Release the tape unit, if reserved and not
2052 			 * preserve reserve.
2053 			 */
2054 			if ((un->un_rsvd_status &
2055 			    (ST_RESERVE | ST_PRESERVE_RESERVE)) == ST_RESERVE) {
2056 				(void) st_reserve_release(un, ST_RELEASE);
2057 			}
2058 		} else {
2059 			un->un_state = ST_STATE_OPEN_PENDING_IO;
2060 		}
2061 	}
2062 
2063 exit:
2064 	/*
2065 	 * we don't want any uninvited guests scrogging our data when we're
2066 	 * busy with something, so for successful opens or failed opens
2067 	 * (except for EBUSY), reset these counters and state appropriately.
2068 	 */
2069 	if (rval != EBUSY) {
2070 		if (rval) {
2071 			un->un_state = ST_STATE_CLOSED;
2072 		}
2073 		un->un_err_resid = 0;
2074 		un->un_retry_ct = 0;
2075 		un->un_tran_retry_ct = 0;
2076 	}
2077 busy:
2078 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
2079 	    "st_open: return val = %x, state = %d\n", rval, un->un_state);
2080 	mutex_exit(ST_MUTEX);
2081 	return (rval);
2082 
2083 }
2084 
2085 static int
2086 st_tape_init(dev_t dev)
2087 {
2088 	int err;
2089 	int rval = 0;
2090 
2091 	GET_SOFT_STATE(dev);
2092 
2093 	ASSERT(mutex_owned(ST_MUTEX));
2094 
2095 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
2096 	    "st_tape_init(dev = 0x%lx, oflags = %d)\n", dev, un->un_oflags);
2097 
2098 	/*
2099 	 * Clean up after any errors left by 'last' close.
2100 	 * This also handles the case of the initial open.
2101 	 */
2102 	if (un->un_state != ST_STATE_INITIALIZING) {
2103 		un->un_laststate = un->un_state;
2104 		un->un_state = ST_STATE_OPENING;
2105 	}
2106 
2107 	un->un_kbytes_xferred = 0;
2108 
2109 	/*
2110 	 * do a throw away TUR to clear check condition
2111 	 */
2112 	err = st_cmd(dev, SCMD_TEST_UNIT_READY, 0, SYNC_CMD);
2113 
2114 	/*
2115 	 * If test unit ready fails because the drive is reserved
2116 	 * by another host fail the open for no access.
2117 	 */
2118 	if (err) {
2119 		if (un->un_rsvd_status & ST_RESERVATION_CONFLICT) {
2120 			un->un_state = ST_STATE_CLOSED;
2121 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
2122 			    "st_tape_init: RESERVATION CONFLICT\n");
2123 			rval = EACCES;
2124 			goto exit;
2125 		}
2126 	}
2127 
2128 	/*
2129 	 * See whether this is a generic device that we haven't figured
2130 	 * anything out about yet.
2131 	 */
2132 	if (un->un_dp->type == ST_TYPE_INVALID) {
2133 		rval = st_determine_generic(dev);
2134 		if (rval) {
2135 			if (rval != EACCES) {
2136 				rval = EIO;
2137 			}
2138 			un->un_state = ST_STATE_CLOSED;
2139 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2140 			    "st_tape_init: %s invalid type\n",
2141 			    rval == EACCES ? "EACCES" : "EIO");
2142 			goto exit;
2143 		}
2144 		/*
2145 		 * If this is a Unknown Type drive,
2146 		 * Use the READ BLOCK LIMITS to determine if
2147 		 * allow large xfer is approprate if not globally
2148 		 * disabled with st_allow_large_xfer.
2149 		 */
2150 		un->un_allow_large_xfer = (uchar_t)st_allow_large_xfer;
2151 	} else {
2152 
2153 		/*
2154 		 * If we allow_large_xfer (ie >64k) and have not yet found out
2155 		 * the max block size supported by the drive,
2156 		 * find it by issueing a READ_BLKLIM command.
2157 		 * if READ_BLKLIM cmd fails, assume drive doesn't
2158 		 * allow_large_xfer and min/max block sizes as 1 byte and 63k.
2159 		 */
2160 		un->un_allow_large_xfer = st_allow_large_xfer &&
2161 		    (un->un_dp->options & ST_NO_RECSIZE_LIMIT);
2162 	}
2163 	/*
2164 	 * if maxbsize is unknown, set the maximum block size.
2165 	 */
2166 	if (un->un_maxbsize == MAXBSIZE_UNKNOWN) {
2167 
2168 		/*
2169 		 * Get the Block limits of the tape drive.
2170 		 * if un->un_allow_large_xfer = 0 , then make sure
2171 		 * that maxbsize is <= ST_MAXRECSIZE_FIXED.
2172 		 */
2173 		un->un_rbl = kmem_zalloc(RBLSIZE, KM_SLEEP);
2174 
2175 		err = st_cmd(dev, SCMD_READ_BLKLIM, RBLSIZE, SYNC_CMD);
2176 		if (err) {
2177 			/* Retry */
2178 			err = st_cmd(dev, SCMD_READ_BLKLIM, RBLSIZE, SYNC_CMD);
2179 		}
2180 		if (!err) {
2181 
2182 			/*
2183 			 * if cmd successful, use limit returned
2184 			 */
2185 			un->un_maxbsize = (un->un_rbl->max_hi << 16) +
2186 					(un->un_rbl->max_mid << 8) +
2187 					un->un_rbl->max_lo;
2188 			un->un_minbsize = (un->un_rbl->min_hi << 8) +
2189 					un->un_rbl->min_lo;
2190 			un->un_data_mod = 1 << un->un_rbl->granularity;
2191 			if ((un->un_maxbsize == 0) ||
2192 			    (un->un_allow_large_xfer == 0 &&
2193 			    un->un_maxbsize > ST_MAXRECSIZE_FIXED)) {
2194 				un->un_maxbsize = ST_MAXRECSIZE_FIXED;
2195 
2196 			} else if (un->un_dp->type == ST_TYPE_DEFAULT) {
2197 				/*
2198 				 * Drive is not one that is configured, But the
2199 				 * READ BLOCK LIMITS tells us it can do large
2200 				 * xfers.
2201 				 */
2202 				if (un->un_maxbsize > ST_MAXRECSIZE_FIXED) {
2203 					un->un_dp->options |=
2204 					    ST_NO_RECSIZE_LIMIT;
2205 				}
2206 				/*
2207 				 * If max and mimimum block limits are the
2208 				 * same this is a fixed block size device.
2209 				 */
2210 				if (un->un_maxbsize == un->un_minbsize) {
2211 					un->un_dp->options &= ~ST_VARIABLE;
2212 				}
2213 			}
2214 
2215 			if (un->un_minbsize == 0) {
2216 				un->un_minbsize = 1;
2217 			}
2218 
2219 		} else { /* error on read block limits */
2220 
2221 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
2222 				"!st_tape_init: Error on READ BLOCK LIMITS,"
2223 				" errno = %d un_rsvd_status = 0x%X\n",
2224 				err, un->un_rsvd_status);
2225 
2226 			/*
2227 			 * since read block limits cmd failed,
2228 			 * do not allow large xfers.
2229 			 * use old values in st_minphys
2230 			 */
2231 			if (un->un_rsvd_status & ST_RESERVATION_CONFLICT) {
2232 				rval = EACCES;
2233 			} else {
2234 				un->un_allow_large_xfer = 0;
2235 				scsi_log(ST_DEVINFO, st_label, CE_NOTE,
2236 					"!Disabling large transfers\n");
2237 
2238 				/*
2239 				 * we guess maxbsize and minbsize
2240 				 */
2241 				if (un->un_bsize) {
2242 					un->un_maxbsize = un->un_minbsize =
2243 						un->un_bsize;
2244 				} else {
2245 					un->un_maxbsize = ST_MAXRECSIZE_FIXED;
2246 					un->un_minbsize = 1;
2247 				}
2248 				/*
2249 				 * Data Mod must be set,
2250 				 * Even if read block limits fails.
2251 				 * Prevents Divide By Zero in st_rw().
2252 				 */
2253 				un->un_data_mod = 1;
2254 			}
2255 		}
2256 		if (un->un_rbl) {
2257 			kmem_free(un->un_rbl, RBLSIZE);
2258 			un->un_rbl = NULL;
2259 		}
2260 
2261 		if (rval) {
2262 			goto exit;
2263 		}
2264 	}
2265 
2266 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
2267 	    "maxdma = %d, maxbsize = %d, minbsize = %d, %s large xfer\n",
2268 	    un->un_maxdma, un->un_maxbsize, un->un_minbsize,
2269 	    (un->un_allow_large_xfer ? "ALLOW": "DON'T ALLOW"));
2270 
2271 	err = st_cmd(dev, SCMD_TEST_UNIT_READY, 0, SYNC_CMD);
2272 
2273 	if (err != 0) {
2274 		if (err == EINTR) {
2275 			un->un_laststate = un->un_state;
2276 			un->un_state = ST_STATE_CLOSED;
2277 			rval = EINTR;
2278 			goto exit;
2279 		}
2280 		/*
2281 		 * Make sure the tape is ready
2282 		 */
2283 		un->un_fileno = -1;
2284 		if (un->un_status != KEY_UNIT_ATTENTION) {
2285 			/*
2286 			 * allow open no media.  Subsequent MTIOCSTATE
2287 			 * with media present will complete the open
2288 			 * logic.
2289 			 */
2290 			un->un_laststate = un->un_state;
2291 			if (un->un_oflags & (FNONBLOCK|FNDELAY)) {
2292 				un->un_mediastate = MTIO_EJECTED;
2293 				un->un_state = ST_STATE_OFFLINE;
2294 				rval = 0;
2295 				goto exit;
2296 			} else {
2297 				un->un_state = ST_STATE_CLOSED;
2298 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2299 				    "st_tape_init EIO no media, not opened "
2300 				    "O_NONBLOCK|O_EXCL\n");
2301 				rval = EIO;
2302 				goto exit;
2303 			}
2304 		}
2305 	}
2306 
2307 	/*
2308 	 * On each open, initialize block size from drivetype struct,
2309 	 * as it could have been changed by MTSRSZ ioctl.
2310 	 * Now, ST_VARIABLE simply means drive is capable of variable
2311 	 * mode. All drives are assumed to support fixed records.
2312 	 * Hence, un_bsize tells what mode the drive is in.
2313 	 *	un_bsize	= 0	- variable record length
2314 	 *			= x	- fixed record length is x
2315 	 */
2316 	un->un_bsize = un->un_dp->bsize;
2317 
2318 	if (un->un_restore_pos) {
2319 		rval = st_validate_tapemarks(un, un->un_save_fileno,
2320 		    un->un_save_blkno);
2321 		if (rval != 0) {
2322 			if (rval != EACCES) {
2323 				rval = EIO;
2324 			}
2325 			un->un_restore_pos = 0;
2326 			un->un_laststate = un->un_state;
2327 			un->un_state = ST_STATE_CLOSED;
2328 			goto exit;
2329 		}
2330 		un->un_restore_pos = 0;
2331 	}
2332 
2333 	if (un->un_fileno < 0) {
2334 		rval = st_loadtape(dev);
2335 		if (rval) {
2336 			if (rval != EACCES) {
2337 				rval = EIO;
2338 			}
2339 			un->un_laststate = un->un_state;
2340 			un->un_state = ST_STATE_CLOSED;
2341 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2342 			    "st_tape_init: %s can't open tape\n",
2343 			    rval == EACCES ? "EACCES" : "EIO");
2344 			goto exit;
2345 		}
2346 	}
2347 
2348 	/*
2349 	 * do a mode sense to pick up state of current write-protect,
2350 	 * Could cause reserve and fail due to conflict.
2351 	 */
2352 	rval = st_modesense(un);
2353 	if (rval == EACCES) {
2354 		goto exit;
2355 	}
2356 
2357 	/*
2358 	 * If we are opening the tape for writing, check
2359 	 * to make sure that the tape can be written.
2360 	 */
2361 	if (un->un_oflags & FWRITE) {
2362 		err = 0;
2363 		if (un->un_mspl->wp)  {
2364 			un->un_status = KEY_WRITE_PROTECT;
2365 			un->un_laststate = un->un_state;
2366 			un->un_state = ST_STATE_CLOSED;
2367 			rval = EACCES;
2368 			goto exit;
2369 		} else {
2370 			un->un_read_only = 0;
2371 		}
2372 	} else {
2373 		un->un_read_only = 1;
2374 	}
2375 
2376 	/*
2377 	 * If we're opening the tape write-only, we need to
2378 	 * write 2 filemarks on the HP 1/2 inch drive, to
2379 	 * create a null file.
2380 	 */
2381 	if ((un->un_oflags == FWRITE) && (un->un_dp->options & ST_REEL)) {
2382 		un->un_fmneeded = 2;
2383 	} else if (un->un_oflags == FWRITE) {
2384 		un->un_fmneeded = 1;
2385 	} else {
2386 		un->un_fmneeded = 0;
2387 	}
2388 
2389 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
2390 	    "fmneeded = %x\n", un->un_fmneeded);
2391 
2392 	/*
2393 	 * Make sure the density can be selected correctly.
2394 	 */
2395 	if (st_determine_density(dev, B_WRITE)) {
2396 		un->un_status = KEY_ILLEGAL_REQUEST;
2397 		un->un_laststate = un->un_state;
2398 		un->un_state = ST_STATE_CLOSED;
2399 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
2400 		    "st_tape_init: EIO can't determine density\n");
2401 		rval = EIO;
2402 		goto exit;
2403 	}
2404 
2405 	/*
2406 	 * Destroy the knowledge that we have 'determined'
2407 	 * density so that a later read at BOT comes along
2408 	 * does the right density determination.
2409 	 */
2410 
2411 	un->un_density_known = 0;
2412 
2413 
2414 	/*
2415 	 * Okay, the tape is loaded and either at BOT or somewhere past.
2416 	 * Mark the state such that any I/O or tape space operations
2417 	 * will get/set the right density, etc..
2418 	 */
2419 	un->un_laststate = un->un_state;
2420 	un->un_lastop = ST_OP_NIL;
2421 	un->un_mediastate = MTIO_INSERTED;
2422 	cv_broadcast(&un->un_state_cv);
2423 
2424 	/*
2425 	 *  Set test append flag if writing.
2426 	 *  First write must check that tape is positioned correctly.
2427 	 */
2428 	un->un_test_append = (un->un_oflags & FWRITE);
2429 
2430 exit:
2431 	un->un_err_resid = 0;
2432 	un->un_last_resid = 0;
2433 	un->un_last_count = 0;
2434 
2435 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
2436 	    "st_tape_init: return val = %x\n", rval);
2437 	return (rval);
2438 
2439 }
2440 
2441 
2442 
2443 /* ARGSUSED */
2444 static int
2445 st_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
2446 {
2447 	int err = 0;
2448 	int norew, count, last_state;
2449 #if defined(__i386) || defined(__amd64)
2450 	struct contig_mem *cp, *cp_temp;
2451 #endif
2452 
2453 	GET_SOFT_STATE(dev);
2454 
2455 	/*
2456 	 * wait till all cmds in the pipeline have been completed
2457 	 */
2458 	mutex_enter(ST_MUTEX);
2459 
2460 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
2461 	    "st_close(dev = 0x%lx, flag = %d, otyp = %d)\n", dev, flag, otyp);
2462 
2463 	st_wait_for_io(un);
2464 
2465 	/* turn off persistent errors on close, as we want close to succeed */
2466 	TURN_PE_OFF(un);
2467 
2468 	/*
2469 	 * set state to indicate that we are in process of closing
2470 	 */
2471 	last_state = un->un_laststate = un->un_state;
2472 	un->un_state = ST_STATE_CLOSING;
2473 
2474 	/*
2475 	 * BSD behavior:
2476 	 * a close always causes a silent span to the next file if we've hit
2477 	 * an EOF (but not yet read across it).
2478 	 */
2479 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
2480 	    "st_close1: fileno=%x, blkno=%lx, un_eof=%x\n", un->un_fileno,
2481 	    un->un_blkno, un->un_eof);
2482 
2483 
2484 	if (BSD_BEHAVIOR && (un->un_eof == ST_EOF)) {
2485 		if (un->un_fileno >= 0) {
2486 			un->un_fileno++;
2487 			un->un_blkno = 0;
2488 		}
2489 		un->un_eof = ST_NO_EOF;
2490 	}
2491 
2492 	/*
2493 	 * rewinding?
2494 	 */
2495 	norew = (getminor(dev) & MT_NOREWIND);
2496 
2497 	/*
2498 	 * SVR4 behavior for skipping to next file:
2499 	 *
2500 	 * If we have not seen a filemark, space to the next file
2501 	 *
2502 	 * If we have already seen the filemark we are physically in the next
2503 	 * file and we only increment the filenumber
2504 	 */
2505 
2506 	if (norew && SVR4_BEHAVIOR && (flag & FREAD) && (un->un_blkno != 0) &&
2507 	    (un->un_lastop != ST_OP_WRITE)) {
2508 		switch (un->un_eof) {
2509 		case ST_NO_EOF:
2510 			/*
2511 			 * if we were reading and did not read the complete file
2512 			 * skip to the next file, leaving the tape correctly
2513 			 * positioned to read the first record of the next file
2514 			 * Check first for REEL if we are at EOT by trying to
2515 			 * read a block
2516 			 */
2517 			if ((un->un_dp->options & ST_REEL) &&
2518 				(!(un->un_dp->options & ST_READ_IGNORE_EOFS)) &&
2519 			    (un->un_blkno == 0)) {
2520 				if (st_cmd(dev, SCMD_SPACE, Blk(1), SYNC_CMD)) {
2521 					ST_DEBUG2(ST_DEVINFO, st_label,
2522 					    SCSI_DEBUG,
2523 					    "st_close : EIO can't space\n");
2524 					err = EIO;
2525 					break;
2526 				}
2527 				if (un->un_eof >= ST_EOF_PENDING) {
2528 					un->un_eof = ST_EOT_PENDING;
2529 					un->un_fileno += 1;
2530 					un->un_blkno   = 0;
2531 					break;
2532 				}
2533 			}
2534 			if (st_cmd(dev, SCMD_SPACE, Fmk(1), SYNC_CMD)) {
2535 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2536 				    "st_close: EIO can't space #2\n");
2537 				err = EIO;
2538 			} else {
2539 				ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
2540 				    "st_close2: fileno=%x,blkno=%lx,"
2541 				    "un_eof=%x\n",
2542 				    un->un_fileno, un->un_blkno, un->un_eof);
2543 				un->un_eof = ST_NO_EOF;
2544 			}
2545 			break;
2546 
2547 		case ST_EOF_PENDING:
2548 		case ST_EOF:
2549 			un->un_fileno += 1;
2550 			un->un_blkno   = 0;
2551 			un->un_eof = ST_NO_EOF;
2552 			break;
2553 
2554 		case ST_EOT:
2555 		case ST_EOT_PENDING:
2556 			/* nothing to do */
2557 			break;
2558 		}
2559 	}
2560 
2561 
2562 	/*
2563 	 * For performance reasons (HP 88780), the driver should
2564 	 * postpone writing the second tape mark until just before a file
2565 	 * positioning ioctl is issued (e.g., rewind).	This means that
2566 	 * the user must not manually rewind the tape because the tape will
2567 	 * be missing the second tape mark which marks EOM.
2568 	 * However, this small performance improvement is not worth the risk.
2569 	 */
2570 
2571 	/*
2572 	 * We need to back up over the filemark we inadvertently popped
2573 	 * over doing a read in between the two filemarks that constitute
2574 	 * logical eot for 1/2" tapes. Note that ST_EOT_PENDING is only
2575 	 * set while reading.
2576 	 *
2577 	 * If we happen to be at physical eot (ST_EOM) (writing case),
2578 	 * the writing of filemark(s) will clear the ST_EOM state, which
2579 	 * we don't want, so we save this state and restore it later.
2580 	 */
2581 
2582 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
2583 	    "flag=%x, fmneeded=%x, lastop=%x, eof=%x\n",
2584 		flag, un->un_fmneeded, un->un_lastop, un->un_eof);
2585 
2586 	if (un->un_eof == ST_EOT_PENDING) {
2587 		if (norew) {
2588 			if (st_cmd(dev, SCMD_SPACE, Fmk((-1)), SYNC_CMD)) {
2589 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2590 				    "st_close: EIO can't space #3\n");
2591 				err = EIO;
2592 			} else {
2593 				un->un_blkno = 0;
2594 				un->un_eof = ST_EOT;
2595 			}
2596 		} else {
2597 			un->un_eof = ST_NO_EOF;
2598 		}
2599 
2600 	/*
2601 	 * Do we need to write a file mark?
2602 	 *
2603 	 * only write filemarks if there are fmks to be written and
2604 	 *   - open for write (possibly read/write)
2605 	 *   - the last operation was a write
2606 	 * or:
2607 	 *   -	opened for wronly
2608 	 *   -	no data was written
2609 	 */
2610 	} else if ((un->un_fileno >= 0) && (un->un_fmneeded > 0) &&
2611 	    (((flag & FWRITE) && (un->un_lastop == ST_OP_WRITE)) ||
2612 	    ((flag & FWRITE) && (un->un_lastop == ST_OP_WEOF)) ||
2613 	    ((flag == FWRITE) && (un->un_lastop == ST_OP_NIL)))) {
2614 
2615 		/* save ST_EOM state */
2616 		int was_at_eom = (un->un_eof == ST_EOM) ? 1 : 0;
2617 
2618 		/*
2619 		 * Note that we will write a filemark if we had opened
2620 		 * the tape write only and no data was written, thus
2621 		 * creating a null file.
2622 		 *
2623 		 * If the user already wrote one, we only have to write 1 more.
2624 		 * If they wrote two, we don't have to write any.
2625 		 */
2626 
2627 		count = un->un_fmneeded;
2628 		if (count > 0) {
2629 			if (st_cmd(dev, SCMD_WRITE_FILE_MARK,
2630 			    count, SYNC_CMD)) {
2631 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2632 				    "st_close : EIO can't wfm\n");
2633 				err = EIO;
2634 			}
2635 			if ((un->un_dp->options & ST_REEL) && norew) {
2636 				if (st_cmd(dev, SCMD_SPACE, Fmk((-1)),
2637 				    SYNC_CMD)) {
2638 					ST_DEBUG2(ST_DEVINFO, st_label,
2639 					    SCSI_DEBUG,
2640 					    "st_close : EIO space fmk(-1)\n");
2641 					err = EIO;
2642 				}
2643 				un->un_eof = ST_NO_EOF;
2644 				/* fix up block number */
2645 				un->un_blkno = 0;
2646 			}
2647 		}
2648 
2649 		/*
2650 		 * If we aren't going to be rewinding, and we were at
2651 		 * physical eot, restore the state that indicates we
2652 		 * are at physical eot. Once you have reached physical
2653 		 * eot, and you close the tape, the only thing you can
2654 		 * do on the next open is to rewind. Access to trailer
2655 		 * records is only allowed without closing the device.
2656 		 */
2657 		if (norew == 0 && was_at_eom)
2658 			un->un_eof = ST_EOM;
2659 	}
2660 
2661 	/*
2662 	 * report soft errors if enabled and available, if we never accessed
2663 	 * the drive, don't get errors. This will prevent some DAT error
2664 	 * messages upon LOG SENSE.
2665 	 */
2666 	if (st_report_soft_errors_on_close &&
2667 	    (un->un_dp->options & ST_SOFT_ERROR_REPORTING) &&
2668 	    (last_state != ST_STATE_OFFLINE)) {
2669 		(void) st_report_soft_errors(dev, flag);
2670 	}
2671 
2672 
2673 	/*
2674 	 * Do we need to rewind? Can we rewind?
2675 	 */
2676 	if (norew == 0 && un->un_fileno >= 0 && err == 0) {
2677 		/*
2678 		 * We'd like to rewind with the
2679 		 * 'immediate' bit set, but this
2680 		 * causes problems on some drives
2681 		 * where subsequent opens get a
2682 		 * 'NOT READY' error condition
2683 		 * back while the tape is rewinding,
2684 		 * which is impossible to distinguish
2685 		 * from the condition of 'no tape loaded'.
2686 		 *
2687 		 * Also, for some targets, if you disconnect
2688 		 * with the 'immediate' bit set, you don't
2689 		 * actually return right away, i.e., the
2690 		 * target ignores your request for immediate
2691 		 * return.
2692 		 *
2693 		 * Instead, we'll fire off an async rewind
2694 		 * command. We'll mark the device as closed,
2695 		 * and any subsequent open will stall on
2696 		 * the first TEST_UNIT_READY until the rewind
2697 		 * completes.
2698 		 */
2699 
2700 		/*
2701 		 * Used to be if reserve was not supported we'd send an
2702 		 * asynchronious rewind. Comments above may be slightly invalid
2703 		 * as the immediate bit was never set. Doing an immedate rewind
2704 		 * makes sense, I think fixes to not ready status might handle
2705 		 * the problems described above.
2706 		 */
2707 		if (un->un_sd->sd_inq->inq_ansi < 2) {
2708 			(void) st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD);
2709 		} else {
2710 			(void) st_cmd(dev, SCMD_REWIND, 0, ASYNC_CMD);
2711 		}
2712 	}
2713 
2714 	/*
2715 	 * eject tape if necessary
2716 	 */
2717 	if (un->un_eject_tape_on_failure) {
2718 		un->un_eject_tape_on_failure = 0;
2719 		if (st_cmd(dev, SCMD_LOAD, 0, SYNC_CMD)) {
2720 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2721 			    "st_close : can't unload tape\n");
2722 		} else {
2723 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
2724 			    "st_close : tape unloaded \n");
2725 			un->un_eof = ST_NO_EOF;
2726 			un->un_mediastate = MTIO_EJECTED;
2727 		}
2728 	}
2729 	/*
2730 	 * Release the tape unit, if default reserve/release
2731 	 * behaviour.
2732 	 */
2733 	if ((un->un_rsvd_status &
2734 	    (ST_RESERVE | ST_PRESERVE_RESERVE)) == ST_RESERVE) {
2735 		(void) st_reserve_release(un, ST_RELEASE);
2736 	}
2737 
2738 	/*
2739 	 * clear up state
2740 	 */
2741 	un->un_laststate = un->un_state;
2742 	un->un_state = ST_STATE_CLOSED;
2743 	un->un_lastop = ST_OP_NIL;
2744 	un->un_throttle = 1;	/* assume one request at time, for now */
2745 	un->un_retry_ct = 0;
2746 	un->un_tran_retry_ct = 0;
2747 	un->un_errno = 0;
2748 	un->un_swr_token = (opaque_t)NULL;
2749 	un->un_rsvd_status &= ~(ST_INIT_RESERVE);
2750 
2751 	/* Restore the options to the init time settings */
2752 	if (un->un_init_options & ST_READ_IGNORE_ILI) {
2753 		un->un_dp->options |= ST_READ_IGNORE_ILI;
2754 	} else {
2755 		un->un_dp->options &= ~ST_READ_IGNORE_ILI;
2756 	}
2757 
2758 	if (un->un_init_options & ST_READ_IGNORE_EOFS) {
2759 		un->un_dp->options |= ST_READ_IGNORE_EOFS;
2760 	} else {
2761 		un->un_dp->options &= ~ST_READ_IGNORE_EOFS;
2762 	}
2763 
2764 	if (un->un_init_options & ST_SHORT_FILEMARKS) {
2765 		un->un_dp->options |= ST_SHORT_FILEMARKS;
2766 	} else {
2767 		un->un_dp->options &= ~ST_SHORT_FILEMARKS;
2768 	}
2769 
2770 	ASSERT(mutex_owned(ST_MUTEX));
2771 
2772 	/*
2773 	 * Signal anyone awaiting a close operation to complete.
2774 	 */
2775 	cv_signal(&un->un_clscv);
2776 
2777 	/*
2778 	 * any kind of error on closing causes all state to be tossed
2779 	 */
2780 	if (err && un->un_status != KEY_ILLEGAL_REQUEST) {
2781 		un->un_density_known = 0;
2782 		/*
2783 		 * note that st_intr has already set un_fileno to -1
2784 		 */
2785 	}
2786 
2787 #if defined(__i386) || defined(__amd64)
2788 	/*
2789 	 * free any contiguous mem alloc'ed for big block I/O
2790 	 */
2791 	cp = un->un_contig_mem;
2792 	while (cp) {
2793 		if (cp->cm_addr) {
2794 			ddi_dma_mem_free(&cp->cm_acc_hdl);
2795 		}
2796 		cp_temp = cp;
2797 		cp = cp->cm_next;
2798 		kmem_free(cp_temp,
2799 		    sizeof (struct contig_mem) + biosize());
2800 	}
2801 	un->un_contig_mem_total_num = 0;
2802 	un->un_contig_mem_available_num = 0;
2803 	un->un_contig_mem = NULL;
2804 	un->un_max_contig_mem_len = 0;
2805 #endif
2806 
2807 	ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
2808 	    "st_close3: return val = %x, fileno=%x, blkno=%lx, un_eof=%x\n",
2809 			    err, un->un_fileno, un->un_blkno, un->un_eof);
2810 
2811 	mutex_exit(ST_MUTEX);
2812 	return (err);
2813 }
2814 
2815 /*
2816  * These routines perform raw i/o operations.
2817  */
2818 
2819 /* ARGSUSED2 */
2820 static int
2821 st_aread(dev_t dev, struct aio_req *aio, cred_t *cred_p)
2822 {
2823 	return (st_arw(dev, aio, B_READ));
2824 }
2825 
2826 
2827 /* ARGSUSED2 */
2828 static int
2829 st_awrite(dev_t dev, struct aio_req *aio, cred_t *cred_p)
2830 {
2831 	return (st_arw(dev, aio, B_WRITE));
2832 }
2833 
2834 
2835 
2836 /* ARGSUSED */
2837 static int
2838 st_read(dev_t dev, struct uio *uiop, cred_t *cred_p)
2839 {
2840 	return (st_rw(dev, uiop, B_READ));
2841 }
2842 
2843 /* ARGSUSED */
2844 static int
2845 st_write(dev_t dev, struct uio *uiop, cred_t *cred_p)
2846 {
2847 	return (st_rw(dev, uiop, B_WRITE));
2848 }
2849 
2850 /*
2851  * Due to historical reasons, old limits are: For variable-length devices:
2852  * if greater than 64KB - 1 (ST_MAXRECSIZE_VARIABLE), block into 64 KB - 2
2853  * ST_MAXRECSIZE_VARIABLE_LIMIT) requests; otherwise,
2854  * (let it through unmodified. For fixed-length record devices:
2855  * 63K (ST_MAXRECSIZE_FIXED) is max (default minphys).
2856  *
2857  * The new limits used are un_maxdma (retrieved using scsi_ifgetcap()
2858  * from the HBA) and un_maxbsize (retrieved by sending SCMD_READ_BLKLIM
2859  * command to the drive).
2860  *
2861  */
2862 static void
2863 st_minphys(struct buf *bp)
2864 {
2865 	struct scsi_tape *un;
2866 
2867 #if !defined(lint)
2868 	_NOTE(SCHEME_PROTECTS_DATA("stable data", scsi_tape::un_sd));
2869 #endif
2870 
2871 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
2872 
2873 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
2874 	    "st_minphys(bp = 0x%p): b_bcount = 0x%lx\n", (void *)bp,
2875 	    bp->b_bcount);
2876 
2877 	if (un->un_allow_large_xfer) {
2878 
2879 		/*
2880 		 * check un_maxbsize for variable length devices only
2881 		 */
2882 		if (un->un_bsize == 0 && bp->b_bcount > un->un_maxbsize) {
2883 			bp->b_bcount = un->un_maxbsize;
2884 		}
2885 		/*
2886 		 * can't go more that HBA maxdma limit in either fixed-length
2887 		 * or variable-length tape drives.
2888 		 */
2889 		if (bp->b_bcount > un->un_maxdma) {
2890 			bp->b_bcount = un->un_maxdma;
2891 		}
2892 	} else {
2893 
2894 		/*
2895 		 *  use old fixed limits
2896 		 */
2897 		if (un->un_bsize == 0) {
2898 			if (bp->b_bcount > ST_MAXRECSIZE_VARIABLE) {
2899 				bp->b_bcount = ST_MAXRECSIZE_VARIABLE_LIMIT;
2900 			}
2901 		} else {
2902 			if (bp->b_bcount > ST_MAXRECSIZE_FIXED) {
2903 				bp->b_bcount = ST_MAXRECSIZE_FIXED;
2904 			}
2905 		}
2906 	}
2907 
2908 #if !defined(lint)
2909 _NOTE(DATA_READABLE_WITHOUT_LOCK(scsi_tape::un_sbufp));
2910 #endif /* lint */
2911 	/*
2912 	 * For regular raw I/O and Fixed Block length devices, make sure
2913 	 * the adjusted block count is a whole multiple of the device
2914 	 * block size.
2915 	 */
2916 	if (bp != un->un_sbufp && un->un_bsize) {
2917 		bp->b_bcount -= (bp->b_bcount % un->un_bsize);
2918 	}
2919 }
2920 
2921 /*ARGSUSED*/
2922 static void
2923 st_uscsi_minphys(struct buf *bp)
2924 {
2925 	/*
2926 	 * do not break up because the CDB count would then be
2927 	 * incorrect and create spurious data underrun errors.
2928 	 */
2929 }
2930 
2931 static int
2932 st_rw(dev_t dev, struct uio *uio, int flag)
2933 {
2934 	int rval = 0;
2935 	long len;
2936 
2937 	GET_SOFT_STATE(dev);
2938 
2939 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
2940 	    "st_rw(dev = 0x%lx, flag = %s)\n", dev,
2941 	    (flag == B_READ ? rd_str: wr_str));
2942 
2943 	/* get local copy of transfer length */
2944 	len = uio->uio_iov->iov_len;
2945 
2946 	mutex_enter(ST_MUTEX);
2947 
2948 	/*
2949 	 * If in fixed block size mode and requested read or write
2950 	 * is not an even multiple of that block size.
2951 	 */
2952 	if ((un->un_bsize != 0) && (len % un->un_bsize != 0)) {
2953 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
2954 		    "%s: not modulo %d block size\n",
2955 		    (flag == B_WRITE) ? wr_str : rd_str, un->un_bsize);
2956 		rval = EINVAL;
2957 	}
2958 
2959 	/* If device has set granularity in the READ_BLKLIM we honor it. */
2960 	if ((un->un_data_mod != 0) && (len % un->un_data_mod != 0)) {
2961 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
2962 		    "%s: not modulo %d device granularity\n",
2963 		    (flag == B_WRITE) ? wr_str : rd_str, un->un_data_mod);
2964 		rval = EINVAL;
2965 	}
2966 
2967 	if (rval != 0) {
2968 		un->un_errno = rval;
2969 		mutex_exit(ST_MUTEX);
2970 		return (rval);
2971 	}
2972 
2973 	un->un_silent_skip = 0;
2974 	mutex_exit(ST_MUTEX);
2975 
2976 	len = uio->uio_resid;
2977 
2978 	rval = physio(st_strategy, (struct buf *)NULL,
2979 		dev, flag, st_minphys, uio);
2980 	/*
2981 	 * if we have hit logical EOT during this xfer and there is not a
2982 	 * full residue, then set un_eof back  to ST_EOM to make sure that
2983 	 * the user will see at least one zero write
2984 	 * after this short write
2985 	 */
2986 	mutex_enter(ST_MUTEX);
2987 	if (un->un_eof > ST_NO_EOF) {
2988 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
2989 		"un_eof=%d resid=%lx\n", un->un_eof, uio->uio_resid);
2990 	}
2991 	if (un->un_eof >= ST_EOM && (flag == B_WRITE)) {
2992 		if ((uio->uio_resid != len) && (uio->uio_resid != 0)) {
2993 			un->un_eof = ST_EOM;
2994 		} else if (uio->uio_resid == len) {
2995 			un->un_eof = ST_NO_EOF;
2996 		}
2997 	}
2998 
2999 	if (un->un_silent_skip && uio->uio_resid != len) {
3000 		un->un_eof = ST_EOF;
3001 		un->un_blkno = un->un_save_blkno;
3002 		un->un_fileno--;
3003 	}
3004 
3005 	un->un_errno = rval;
3006 
3007 	mutex_exit(ST_MUTEX);
3008 
3009 	return (rval);
3010 }
3011 
3012 static int
3013 st_arw(dev_t dev, struct aio_req *aio, int flag)
3014 {
3015 	struct uio *uio = aio->aio_uio;
3016 	int rval = 0;
3017 	long len;
3018 
3019 	GET_SOFT_STATE(dev);
3020 
3021 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
3022 	    "st_rw(dev = 0x%lx, flag = %s)\n", dev,
3023 	    (flag == B_READ ? rd_str: wr_str));
3024 
3025 	/* get local copy of transfer length */
3026 	len = uio->uio_iov->iov_len;
3027 
3028 	mutex_enter(ST_MUTEX);
3029 
3030 	/*
3031 	 * If in fixed block size mode and requested read or write
3032 	 * is not an even multiple of that block size.
3033 	 */
3034 	if ((un->un_bsize != 0) && (len % un->un_bsize != 0)) {
3035 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
3036 		    "%s: not modulo %d block size\n",
3037 		    (flag == B_WRITE) ? wr_str : rd_str, un->un_bsize);
3038 		rval = EINVAL;
3039 	}
3040 
3041 	/* If device has set granularity in the READ_BLKLIM we honor it. */
3042 	if ((un->un_data_mod != 0) && (len % un->un_data_mod != 0)) {
3043 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
3044 		    "%s: not modulo %d device granularity\n",
3045 		    (flag == B_WRITE) ? wr_str : rd_str, un->un_data_mod);
3046 		rval = EINVAL;
3047 	}
3048 
3049 	if (rval != 0) {
3050 		un->un_errno = rval;
3051 		mutex_exit(ST_MUTEX);
3052 		return (rval);
3053 	}
3054 
3055 	mutex_exit(ST_MUTEX);
3056 
3057 	len = uio->uio_resid;
3058 
3059 	rval = aphysio(st_strategy, anocancel, dev, flag, st_minphys, aio);
3060 
3061 	/*
3062 	 * if we have hit logical EOT during this xfer and there is not a
3063 	 * full residue, then set un_eof back  to ST_EOM to make sure that
3064 	 * the user will see at least one zero write
3065 	 * after this short write
3066 	 *
3067 	 * we keep this here just in case the application is not using
3068 	 * persistent errors
3069 	 */
3070 	mutex_enter(ST_MUTEX);
3071 	if (un->un_eof > ST_NO_EOF) {
3072 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3073 		    "un_eof=%d resid=%lx\n", un->un_eof, uio->uio_resid);
3074 	}
3075 	if (un->un_eof >= ST_EOM && (flag == B_WRITE)) {
3076 		if ((uio->uio_resid != len) && (uio->uio_resid != 0)) {
3077 			un->un_eof = ST_EOM;
3078 		} else if (uio->uio_resid == len && !IS_PE_FLAG_SET(un)) {
3079 			un->un_eof = ST_NO_EOF;
3080 		}
3081 	}
3082 	un->un_errno = rval;
3083 	mutex_exit(ST_MUTEX);
3084 
3085 	return (rval);
3086 }
3087 
3088 
3089 
3090 static int
3091 st_strategy(struct buf *bp)
3092 {
3093 	struct scsi_tape *un;
3094 	dev_t dev = bp->b_edev;
3095 
3096 	/*
3097 	 * validate arguments
3098 	 */
3099 	if ((un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev))) == NULL) {
3100 		bp->b_resid = bp->b_bcount;
3101 		mutex_enter(ST_MUTEX);
3102 		st_bioerror(bp, ENXIO);
3103 		mutex_exit(ST_MUTEX);
3104 		goto error;
3105 	}
3106 
3107 	mutex_enter(ST_MUTEX);
3108 
3109 	while (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
3110 		cv_wait(&un->un_suspend_cv, ST_MUTEX);
3111 	}
3112 
3113 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
3114 	    "st_strategy(): bcount=0x%lx, fileno=%d, blkno=%lx, eof=%d\n",
3115 	    bp->b_bcount, un->un_fileno, un->un_blkno, un->un_eof);
3116 
3117 	/*
3118 	 * If persistent errors have been flagged, just nix this one. We wait
3119 	 * for any outstanding I/O's below, so we will be in order.
3120 	 */
3121 	if (IS_PE_FLAG_SET(un))
3122 		goto exit;
3123 
3124 	if (bp != un->un_sbufp) {
3125 		char reading = bp->b_flags & B_READ;
3126 		int wasopening = 0;
3127 
3128 		/*
3129 		 * If we haven't done/checked reservation on the tape unit
3130 		 * do it now.
3131 		 */
3132 		if ((un->un_rsvd_status &
3133 		    (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) {
3134 			if ((un->un_dp->options & ST_NO_RESERVE_RELEASE) == 0) {
3135 				if (st_reserve_release(un, ST_RESERVE)) {
3136 					st_bioerror(bp, un->un_errno);
3137 					goto exit;
3138 				}
3139 			} else if (un->un_state == ST_STATE_OPEN_PENDING_IO) {
3140 				/*
3141 				 * Enter here to restore position for possible
3142 				 * resets when the device was closed and opened
3143 				 * in O_NDELAY mode subsequently
3144 				 */
3145 				un->un_state = ST_STATE_INITIALIZING;
3146 				(void) st_cmd(dev, SCMD_TEST_UNIT_READY,
3147 				    0, SYNC_CMD);
3148 				un->un_state = ST_STATE_OPEN_PENDING_IO;
3149 			}
3150 			un->un_rsvd_status |= ST_INIT_RESERVE;
3151 		}
3152 
3153 		/*
3154 		 * If we are offline, we have to initialize everything first.
3155 		 * This is to handle either when opened with O_NDELAY, or
3156 		 * we just got a new tape in the drive, after an offline.
3157 		 * We don't observe O_NDELAY past the open,
3158 		 * as it will not make sense for tapes.
3159 		 */
3160 		if (un->un_state == ST_STATE_OFFLINE || un->un_restore_pos) {
3161 			/* reset state to avoid recursion */
3162 			un->un_state = ST_STATE_INITIALIZING;
3163 			if (st_tape_init(dev)) {
3164 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3165 				    "stioctl : OFFLINE init failure ");
3166 				un->un_state = ST_STATE_OFFLINE;
3167 				un->un_fileno = -1;
3168 				goto b_done_err;
3169 			}
3170 			un->un_state = ST_STATE_OPEN_PENDING_IO;
3171 		}
3172 		/*
3173 		 * Check for legal operations
3174 		 */
3175 		if (un->un_fileno < 0) {
3176 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3177 			    "strategy with un->un_fileno < 0\n");
3178 			goto b_done_err;
3179 		}
3180 
3181 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3182 		    "st_strategy(): regular io\n");
3183 
3184 		/*
3185 		 * Process this first. If we were reading, and we're pending
3186 		 * logical eot, that means we've bumped one file mark too far.
3187 		 */
3188 
3189 		/*
3190 		 * Recursion warning: st_cmd will route back through here.
3191 		 */
3192 		if (un->un_eof == ST_EOT_PENDING) {
3193 			if (st_cmd(dev, SCMD_SPACE, Fmk((-1)), SYNC_CMD)) {
3194 				un->un_fileno = -1;
3195 				un->un_density_known = 0;
3196 				goto b_done_err;
3197 			}
3198 			un->un_blkno = 0; /* fix up block number.. */
3199 			un->un_eof = ST_EOT;
3200 		}
3201 
3202 		/*
3203 		 * If we are in the process of opening, we may have to
3204 		 * determine/set the correct density. We also may have
3205 		 * to do a test_append (if QIC) to see whether we are
3206 		 * in a position to append to the end of the tape.
3207 		 *
3208 		 * If we're already at logical eot, we transition
3209 		 * to ST_NO_EOF. If we're at physical eot, we punt
3210 		 * to the switch statement below to handle.
3211 		 */
3212 		if ((un->un_state == ST_STATE_OPEN_PENDING_IO) ||
3213 		    (un->un_test_append && (un->un_dp->options & ST_QIC))) {
3214 
3215 			if (un->un_state == ST_STATE_OPEN_PENDING_IO) {
3216 				if (st_determine_density(dev, (int)reading)) {
3217 					goto b_done_err;
3218 				}
3219 			}
3220 
3221 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3222 			    "pending_io@fileno %d rw %d qic %d eof %d\n",
3223 			    un->un_fileno, (int)reading,
3224 			    (un->un_dp->options & ST_QIC) ? 1 : 0,
3225 			    un->un_eof);
3226 
3227 			if (!reading && un->un_eof != ST_EOM) {
3228 				if (un->un_eof == ST_EOT) {
3229 					un->un_eof = ST_NO_EOF;
3230 				} else if (un->un_fileno > 0 &&
3231 				    (un->un_dp->options & ST_QIC)) {
3232 					/*
3233 					 * st_test_append() will do it all
3234 					 */
3235 					st_test_append(bp);
3236 					goto done;
3237 				}
3238 			}
3239 			if (un->un_state == ST_STATE_OPEN_PENDING_IO) {
3240 				wasopening = 1;
3241 			}
3242 			un->un_laststate = un->un_state;
3243 			un->un_state = ST_STATE_OPEN;
3244 		}
3245 
3246 
3247 		/*
3248 		 * Process rest of END OF FILE and END OF TAPE conditions
3249 		 */
3250 
3251 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3252 		    "un_eof=%x, wasopening=%x\n",
3253 		    un->un_eof, wasopening);
3254 
3255 		switch (un->un_eof) {
3256 		case ST_EOM:
3257 			/*
3258 			 * This allows writes to proceed past physical
3259 			 * eot. We'll *really* be in trouble if the
3260 			 * user continues blindly writing data too
3261 			 * much past this point (unwind the tape).
3262 			 * Physical eot really means 'early warning
3263 			 * eot' in this context.
3264 			 *
3265 			 * Every other write from now on will succeed
3266 			 * (if sufficient  tape left).
3267 			 * This write will return with resid == count
3268 			 * but the next one should be successful
3269 			 *
3270 			 * Note that we only transition to logical EOT
3271 			 * if the last state wasn't the OPENING state.
3272 			 * We explicitly prohibit running up to physical
3273 			 * eot, closing the device, and then re-opening
3274 			 * to proceed. Trailer records may only be gotten
3275 			 * at by keeping the tape open after hitting eot.
3276 			 *
3277 			 * Also note that ST_EOM cannot be set by reading-
3278 			 * this can only be set during writing. Reading
3279 			 * up to the end of the tape gets a blank check
3280 			 * or a double-filemark indication (ST_EOT_PENDING),
3281 			 * and we prohibit reading after that point.
3282 			 *
3283 			 */
3284 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOM\n");
3285 			if (wasopening == 0) {
3286 				/*
3287 				 * this allows st_rw() to reset it back to
3288 				 * ST_EOM to make sure that the application
3289 				 * will see a zero write
3290 				 */
3291 				un->un_eof = ST_WRITE_AFTER_EOM;
3292 			}
3293 			un->un_status = SUN_KEY_EOT;
3294 			goto b_done;
3295 
3296 		case ST_WRITE_AFTER_EOM:
3297 		case ST_EOT:
3298 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOT\n");
3299 			un->un_status = SUN_KEY_EOT;
3300 			if (SVR4_BEHAVIOR && reading) {
3301 				goto b_done_err;
3302 			}
3303 
3304 			if (reading) {
3305 				goto b_done;
3306 			}
3307 			un->un_eof = ST_NO_EOF;
3308 			break;
3309 
3310 		case ST_EOF_PENDING:
3311 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3312 			    "EOF PENDING\n");
3313 			un->un_status = SUN_KEY_EOF;
3314 			if (SVR4_BEHAVIOR) {
3315 				un->un_eof = ST_EOF;
3316 				goto b_done;
3317 			}
3318 			/* FALLTHROUGH */
3319 		case ST_EOF:
3320 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "EOF\n");
3321 			un->un_status = SUN_KEY_EOF;
3322 			if (SVR4_BEHAVIOR) {
3323 				goto b_done_err;
3324 			}
3325 
3326 			if (BSD_BEHAVIOR) {
3327 				un->un_eof = ST_NO_EOF;
3328 				un->un_fileno += 1;
3329 				un->un_blkno   = 0;
3330 			}
3331 
3332 			if (reading) {
3333 				ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3334 				    "now file %d (read)\n",
3335 				    un->un_fileno);
3336 				goto b_done;
3337 			}
3338 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3339 			    "now file %d (write)\n", un->un_fileno);
3340 			break;
3341 		default:
3342 			un->un_status = 0;
3343 			break;
3344 		}
3345 	}
3346 
3347 	bp->b_flags &= ~(B_DONE);
3348 	st_bioerror(bp, 0);
3349 	bp->av_forw = NULL;
3350 	bp->b_resid = 0;
3351 	SET_BP_PKT(bp, 0);
3352 
3353 
3354 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3355 	    "st_strategy: cmd=0x%p  count=%ld  resid=%ld flags=0x%x"
3356 	    " pkt=0x%p\n",
3357 	    (void *)bp->b_forw, bp->b_bcount,
3358 	    bp->b_resid, bp->b_flags, (void *)BP_PKT(bp));
3359 
3360 #if defined(__i386) || defined(__amd64)
3361 	/*
3362 	 * We will replace bp with a new bp that can do big blk xfer
3363 	 * if the requested xfer size is bigger than ST_BIGBLK_XFER
3364 	 *
3365 	 * Also, we need to make sure that we're handling real I/O
3366 	 * by checking group 0/1 SCSI I/O commands, if needed
3367 	 */
3368 	if (bp->b_bcount > ST_BIGBLK_XFER &&
3369 	    (bp != un->un_sbufp					||
3370 	    (uchar_t)(uintptr_t)bp->b_forw == SCMD_READ		||
3371 	    (uchar_t)(uintptr_t)bp->b_forw == SCMD_READ_G1	||
3372 	    (uchar_t)(uintptr_t)bp->b_forw == SCMD_WRITE	||
3373 	    (uchar_t)(uintptr_t)bp->b_forw == SCMD_WRITE_G1)) {
3374 		mutex_exit(ST_MUTEX);
3375 		bp = st_get_bigblk_bp(bp);
3376 		mutex_enter(ST_MUTEX);
3377 	}
3378 #endif
3379 
3380 	/* put on wait queue */
3381 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3382 	    "st_strategy: un->un_quef = 0x%p, bp = 0x%p\n",
3383 	    (void *)un->un_quef, (void *)bp);
3384 
3385 	if (un->un_quef) {
3386 		un->un_quel->b_actf = bp;
3387 	} else {
3388 		un->un_quef = bp;
3389 	}
3390 	un->un_quel = bp;
3391 
3392 	ST_DO_KSTATS(bp, kstat_waitq_enter);
3393 
3394 	st_start(un);
3395 
3396 done:
3397 	mutex_exit(ST_MUTEX);
3398 	return (0);
3399 
3400 
3401 error:
3402 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3403 	    "st_strategy: error exit\n");
3404 
3405 	biodone(bp);
3406 	return (0);
3407 
3408 b_done_err:
3409 	st_bioerror(bp, EIO);
3410 	ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3411 	    "st_strategy : EIO b_done_err\n");
3412 
3413 b_done:
3414 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3415 	    "st_strategy: b_done\n");
3416 
3417 exit:
3418 	/*
3419 	 * make sure no commands are outstanding or waiting before closing,
3420 	 * so we can guarantee order
3421 	 */
3422 	st_wait_for_io(un);
3423 	un->un_err_resid = bp->b_resid = bp->b_bcount;
3424 
3425 	/* override errno here, if persistent errors were flagged */
3426 	if (IS_PE_FLAG_SET(un))
3427 		bioerror(bp, un->un_errno);
3428 
3429 	mutex_exit(ST_MUTEX);
3430 
3431 	biodone(bp);
3432 	ASSERT(mutex_owned(ST_MUTEX) == 0);
3433 	return (0);
3434 }
3435 
3436 
3437 
3438 /*
3439  * this routine spaces forward over filemarks
3440  */
3441 static int
3442 st_space_fmks(dev_t dev, int count)
3443 {
3444 	int rval = 0;
3445 
3446 	GET_SOFT_STATE(dev);
3447 
3448 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
3449 	    "st_space_fmks(dev = 0x%lx, count = %d)\n", dev, count);
3450 
3451 	ASSERT(mutex_owned(ST_MUTEX));
3452 
3453 	/*
3454 	 * the risk with doing only one space operation is that we
3455 	 * may accidentily jump in old data
3456 	 * the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD
3457 	 * because the 8200 does not append a marker; in order not to
3458 	 * sacrifice the fast file skip, we do a slow skip if the low
3459 	 * density device has been opened
3460 	 */
3461 
3462 	if ((un->un_dp->options & ST_KNOWS_EOD) &&
3463 	    !((un->un_dp->type == ST_TYPE_EXB8500 && MT_DENSITY(dev) == 0))) {
3464 		if (st_cmd(dev, SCMD_SPACE, Fmk(count), SYNC_CMD)) {
3465 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3466 			    "space_fmks : EIO can't do space cmd #1\n");
3467 			rval = EIO;
3468 		}
3469 	} else {
3470 		while (count > 0) {
3471 			if (st_cmd(dev, SCMD_SPACE, Fmk(1), SYNC_CMD)) {
3472 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3473 				    "space_fmks : EIO can't do space cmd #2\n");
3474 				rval = EIO;
3475 				break;
3476 			}
3477 			count -= 1;
3478 			/*
3479 			 * read a block to see if we have reached
3480 			 * end of medium (double filemark for reel or
3481 			 * medium error for others)
3482 			 */
3483 			if (count > 0) {
3484 				if (st_cmd(dev, SCMD_SPACE, Blk(1),
3485 				    SYNC_CMD)) {
3486 					ST_DEBUG2(ST_DEVINFO, st_label,
3487 					    SCSI_DEBUG,
3488 					    "space_fmks : EIO can't do "
3489 					    "space cmd #3\n");
3490 					rval = EIO;
3491 					break;
3492 				}
3493 				if ((un->un_eof >= ST_EOF_PENDING) &&
3494 				    (un->un_dp->options & ST_REEL)) {
3495 					un->un_status = SUN_KEY_EOT;
3496 					ST_DEBUG2(ST_DEVINFO, st_label,
3497 					    SCSI_DEBUG,
3498 					    "space_fmks : EIO ST_REEL\n");
3499 					rval = EIO;
3500 					break;
3501 				} else if (IN_EOF(un)) {
3502 					un->un_eof = ST_NO_EOF;
3503 					un->un_fileno++;
3504 					un->un_blkno = 0;
3505 					count--;
3506 				} else if (un->un_eof > ST_EOF) {
3507 					ST_DEBUG2(ST_DEVINFO, st_label,
3508 					    SCSI_DEBUG,
3509 					    "space_fmks, EIO > ST_EOF\n");
3510 					rval = EIO;
3511 					break;
3512 				}
3513 
3514 			}
3515 		}
3516 		un->un_err_resid = count;
3517 		un->un_err_fileno = un->un_fileno;
3518 		un->un_err_blkno = un->un_blkno;
3519 	}
3520 	ASSERT(mutex_owned(ST_MUTEX));
3521 	return (rval);
3522 }
3523 
3524 /*
3525  * this routine spaces to EOM
3526  *
3527  * it keeps track of the current filenumber and returns the filenumber after
3528  * the last successful space operation, we keep the number high because as
3529  * tapes are getting larger, the possibility of more and more files exist,
3530  * 0x100000 (1 Meg of files) probably will never have to be changed any time
3531  * soon
3532  */
3533 #define	MAX_SKIP	0x100000 /* somewhat arbitrary */
3534 
3535 static int
3536 st_find_eom(dev_t dev)
3537 {
3538 	int count, savefile;
3539 	struct scsi_tape *un;
3540 	int instance;
3541 
3542 	instance = MTUNIT(dev);
3543 	if ((un = ddi_get_soft_state(st_state, instance)) == NULL)
3544 		return (-1);
3545 
3546 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
3547 	    "st_find_eom(dev = 0x%lx): fileno = %d\n", dev, un->un_fileno);
3548 
3549 	ASSERT(mutex_owned(ST_MUTEX));
3550 
3551 	savefile = un->un_fileno;
3552 
3553 	/*
3554 	 * see if the drive is smart enough to do the skips in
3555 	 * one operation; 1/2" use two filemarks
3556 	 * the exabyte 8500 reading 8200 tapes cannot use KNOWS_EOD
3557 	 * because the 8200 does not append a marker; in order not to
3558 	 * sacrifice the fast file skip, we do a slow skip if the low
3559 	 * density device has been opened
3560 	 */
3561 	if ((un->un_dp->options & ST_KNOWS_EOD) &&
3562 	    !((un->un_dp->type == ST_TYPE_EXB8500 && MT_DENSITY(dev) == 0))) {
3563 		count = MAX_SKIP;
3564 	} else {
3565 		count = 1;
3566 	}
3567 
3568 	while (st_cmd(dev, SCMD_SPACE, Fmk(count), SYNC_CMD) == 0) {
3569 
3570 		savefile = un->un_fileno;
3571 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3572 			"count=%x, eof=%x, status=%x\n", count,  un->un_eof,
3573 			un->un_status);
3574 
3575 		/*
3576 		 * If we're not EOM smart,  space a record
3577 		 * to see whether we're now in the slot between
3578 		 * the two sequential filemarks that logical
3579 		 * EOM consists of (REEL) or hit nowhere land
3580 		 * (8mm).
3581 		 */
3582 		if (count == 1) {
3583 			/*
3584 			 * no fast skipping, check a record
3585 			 */
3586 			if (st_cmd(dev, SCMD_SPACE, Blk((1)), SYNC_CMD))
3587 				break;
3588 			else if ((un->un_eof >= ST_EOF_PENDING) &&
3589 			    (un->un_dp->options & ST_REEL)) {
3590 				un->un_status = KEY_BLANK_CHECK;
3591 				un->un_fileno++;
3592 				un->un_blkno = 0;
3593 				break;
3594 			} else if (IN_EOF(un)) {
3595 				un->un_eof = ST_NO_EOF;
3596 				un->un_fileno++;
3597 				un->un_blkno = 0;
3598 			} else if (un->un_eof > ST_EOF) {
3599 				break;
3600 			}
3601 		} else {
3602 			if (un->un_eof >  ST_EOF) {
3603 				break;
3604 			}
3605 		}
3606 	}
3607 
3608 	if (un->un_dp->options & ST_KNOWS_EOD) {
3609 		savefile = un->un_fileno;
3610 	}
3611 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
3612 	    "st_find_eom: %x\n", savefile);
3613 	ASSERT(mutex_owned(ST_MUTEX));
3614 	return (savefile);
3615 }
3616 
3617 
3618 /*
3619  * this routine is frequently used in ioctls below;
3620  * it determines whether we know the density and if not will
3621  * determine it
3622  * if we have written the tape before, one or more filemarks are written
3623  *
3624  * depending on the stepflag, the head is repositioned to where it was before
3625  * the filemarks were written in order not to confuse step counts
3626  */
3627 #define	STEPBACK    0
3628 #define	NO_STEPBACK 1
3629 
3630 static int
3631 st_check_density_or_wfm(dev_t dev, int wfm, int mode, int stepflag)
3632 {
3633 
3634 	GET_SOFT_STATE(dev);
3635 
3636 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
3637 	"st_check_density_or_wfm(dev= 0x%lx, wfm= %d, mode= %d, stpflg= %d)\n",
3638 	dev, wfm, mode, stepflag);
3639 
3640 	ASSERT(mutex_owned(ST_MUTEX));
3641 
3642 	/*
3643 	 * If we don't yet know the density of the tape we have inserted,
3644 	 * we have to either unconditionally set it (if we're 'writing'),
3645 	 * or we have to determine it. As side effects, check for any
3646 	 * write-protect errors, and for the need to put out any file-marks
3647 	 * before positioning a tape.
3648 	 *
3649 	 * If we are going to be spacing forward, and we haven't determined
3650 	 * the tape density yet, we have to do so now...
3651 	 */
3652 	if (un->un_state == ST_STATE_OPEN_PENDING_IO) {
3653 		if (st_determine_density(dev, mode)) {
3654 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3655 			    "check_density_or_wfm : EIO can't determine "
3656 			    "density\n");
3657 			un->un_errno = EIO;
3658 			return (EIO);
3659 		}
3660 		/*
3661 		 * Presumably we are at BOT. If we attempt to write, it will
3662 		 * either work okay, or bomb. We don't do a st_test_append
3663 		 * unless we're past BOT.
3664 		 */
3665 		un->un_laststate = un->un_state;
3666 		un->un_state = ST_STATE_OPEN;
3667 
3668 	} else if (un->un_fileno >= 0 && un->un_fmneeded > 0 &&
3669 	    ((un->un_lastop == ST_OP_WEOF && wfm) ||
3670 	    (un->un_lastop == ST_OP_WRITE && wfm))) {
3671 
3672 		daddr_t blkno = un->un_blkno;
3673 		int fileno = un->un_fileno;
3674 
3675 		/*
3676 		 * We need to write one or two filemarks.
3677 		 * In the case of the HP, we need to
3678 		 * position the head between the two
3679 		 * marks.
3680 		 */
3681 		if ((un->un_fmneeded > 0) || (un->un_lastop == ST_OP_WEOF)) {
3682 			wfm = un->un_fmneeded;
3683 			un->un_fmneeded = 0;
3684 		}
3685 
3686 		if (st_write_fm(dev, wfm)) {
3687 			un->un_fileno = -1;
3688 			un->un_density_known = 0;
3689 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3690 			    "check_density_or_wfm : EIO can't write fm\n");
3691 			un->un_errno = EIO;
3692 			return (EIO);
3693 		}
3694 
3695 		if (stepflag == STEPBACK) {
3696 			if (st_cmd(dev, SCMD_SPACE, Fmk((-wfm)), SYNC_CMD)) {
3697 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3698 				    "check_density_or_wfm : EIO can't space "
3699 				    "(-wfm)\n");
3700 				un->un_errno = EIO;
3701 				return (EIO);
3702 			}
3703 			un->un_blkno = blkno;
3704 			un->un_fileno = fileno;
3705 		}
3706 	}
3707 
3708 	/*
3709 	 * Whatever we do at this point clears the state of the eof flag.
3710 	 */
3711 
3712 	un->un_eof = ST_NO_EOF;
3713 
3714 	/*
3715 	 * If writing, let's check that we're positioned correctly
3716 	 * at the end of tape before issuing the next write.
3717 	 */
3718 	if (!un->un_read_only) {
3719 		un->un_test_append = 1;
3720 	}
3721 
3722 	ASSERT(mutex_owned(ST_MUTEX));
3723 	return (0);
3724 }
3725 
3726 
3727 /*
3728  * Wait for all outstaning I/O's to complete
3729  *
3730  * we wait on both ncmds and the wait queue for times when we are flushing
3731  * after persistent errors are flagged, which is when ncmds can be 0, and the
3732  * queue can still have I/O's.  This way we preserve order of biodone's.
3733  */
3734 static void
3735 st_wait_for_io(struct scsi_tape *un)
3736 {
3737 	ASSERT(mutex_owned(ST_MUTEX));
3738 	while (un->un_ncmds || un->un_quef) {
3739 		cv_wait(&un->un_queue_cv, ST_MUTEX);
3740 	}
3741 }
3742 
3743 /*
3744  * This routine implements the ioctl calls.  It is called
3745  * from the device switch at normal priority.
3746  */
3747 /*ARGSUSED*/
3748 static int
3749 st_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cred_p,
3750     int *rval_p)
3751 {
3752 	int tmp, rval = 0;
3753 
3754 	GET_SOFT_STATE(dev);
3755 
3756 	mutex_enter(ST_MUTEX);
3757 
3758 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
3759 	    "st_ioctl(): fileno=%x, blkno=%lx, un_eof=%x, state = %d, "
3760 	    "pe_flag = %d\n",
3761 	    un->un_fileno, un->un_blkno, un->un_eof, un->un_state,
3762 	    IS_PE_FLAG_SET(un));
3763 
3764 	/*
3765 	 * We don't want to block on these, so let them through
3766 	 * and we don't care about setting driver states here.
3767 	 */
3768 	if ((cmd == MTIOCGETDRIVETYPE) ||
3769 	    (cmd == MTIOCGUARANTEEDORDER) ||
3770 	    (cmd == MTIOCPERSISTENTSTATUS)) {
3771 		goto check_commands;
3772 	}
3773 
3774 	/*
3775 	 * wait for all outstanding commands to complete, or be dequeued.
3776 	 * And because ioctl's are synchronous commands, any return value
3777 	 * after this,  will be in order
3778 	 */
3779 	st_wait_for_io(un);
3780 
3781 	/*
3782 	 * allow only a through clear errors and persistent status, and
3783 	 * status
3784 	 */
3785 	if (IS_PE_FLAG_SET(un)) {
3786 		if ((cmd == MTIOCLRERR) ||
3787 		    (cmd == MTIOCPERSISTENT) ||
3788 		    (cmd == MTIOCGET) ||
3789 		    (cmd == USCSIGETRQS)) {
3790 			goto check_commands;
3791 		} else {
3792 			rval = un->un_errno;
3793 			goto exit;
3794 		}
3795 	}
3796 
3797 	un->un_throttle = 1;	/* > 1 will never happen here */
3798 	un->un_errno = 0;	/* start clean from here */
3799 
3800 	/*
3801 	 * first and foremost, handle any ST_EOT_PENDING cases.
3802 	 * That is, if a logical eot is pending notice, notice it.
3803 	 */
3804 	if (un->un_eof == ST_EOT_PENDING) {
3805 		int resid = un->un_err_resid;
3806 		uchar_t status = un->un_status;
3807 		uchar_t lastop = un->un_lastop;
3808 
3809 		if (st_cmd(dev, SCMD_SPACE, Fmk((-1)), SYNC_CMD)) {
3810 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
3811 			    "stioctl : EIO can't space fmk(-1)\n");
3812 			rval = EIO;
3813 			goto exit;
3814 		}
3815 		un->un_lastop = lastop; /* restore last operation */
3816 		if (status == SUN_KEY_EOF) {
3817 			un->un_status = SUN_KEY_EOT;
3818 		} else {
3819 			un->un_status = status;
3820 		}
3821 		un->un_err_resid  = resid;
3822 		un->un_err_blkno = un->un_blkno = 0; /* fix up block number */
3823 		un->un_eof = ST_EOT;	/* now we're at logical eot */
3824 	}
3825 
3826 	/*
3827 	 * now, handle the rest of the situations
3828 	 */
3829 check_commands:
3830 	switch (cmd) {
3831 	case MTIOCGET:
3832 		{
3833 #ifdef _MULTI_DATAMODEL
3834 			/*
3835 			 * For use when a 32 bit app makes a call into a
3836 			 * 64 bit ioctl
3837 			 */
3838 			struct mtget32		mtg_local32;
3839 			struct mtget32 		*mtget_32 = &mtg_local32;
3840 #endif /* _MULTI_DATAMODEL */
3841 
3842 			/* Get tape status */
3843 			struct mtget mtg_local;
3844 			struct mtget *mtget = &mtg_local;
3845 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
3846 				"st_ioctl: MTIOCGET\n");
3847 
3848 			bzero(mtget, sizeof (struct mtget));
3849 			mtget->mt_erreg = un->un_status;
3850 			mtget->mt_resid = un->un_err_resid;
3851 			mtget->mt_dsreg = un->un_retry_ct;
3852 			mtget->mt_fileno = un->un_err_fileno;
3853 			mtget->mt_blkno = un->un_err_blkno;
3854 			mtget->mt_type = un->un_dp->type;
3855 			mtget->mt_flags = MTF_SCSI | MTF_ASF;
3856 			if (un->un_dp->options & ST_REEL) {
3857 				mtget->mt_flags |= MTF_REEL;
3858 				mtget->mt_bf = 20;
3859 			} else {		/* 1/4" cartridges */
3860 				switch (mtget->mt_type) {
3861 				/* Emulex cartridge tape */
3862 				case MT_ISMT02:
3863 					mtget->mt_bf = 40;
3864 					break;
3865 				default:
3866 					mtget->mt_bf = 126;
3867 					break;
3868 				}
3869 			}
3870 
3871 			/*
3872 			 * If large transfers are allowed and drive options
3873 			 * has no record size limit set. Calculate blocking
3874 			 * factor from the lesser of maxbsize and maxdma.
3875 			 */
3876 			if ((un->un_allow_large_xfer) &&
3877 			    (un->un_dp->options & ST_NO_RECSIZE_LIMIT)) {
3878 				mtget->mt_bf = min(un->un_maxbsize,
3879 				    un->un_maxdma) / SECSIZE;
3880 			}
3881 
3882 			rval = st_check_clean_bit(dev);
3883 			if (rval == -1) {
3884 				rval = EIO;
3885 				goto exit;
3886 			} else {
3887 				mtget->mt_flags |= (ushort_t)rval;
3888 				rval = 0;
3889 			}
3890 
3891 			un->un_status = 0;		/* Reset status */
3892 			un->un_err_resid = 0;
3893 			tmp = sizeof (struct mtget);
3894 
3895 #ifdef _MULTI_DATAMODEL
3896 
3897 		switch (ddi_model_convert_from(flag & FMODELS)) {
3898 		case DDI_MODEL_ILP32:
3899 			/*
3900 			 * Convert 64 bit back to 32 bit before doing
3901 			 * copyout. This is what the ILP32 app expects.
3902 			 */
3903 			mtget_32->mt_erreg = 	mtget->mt_erreg;
3904 			mtget_32->mt_resid = 	mtget->mt_resid;
3905 			mtget_32->mt_dsreg = 	mtget->mt_dsreg;
3906 			mtget_32->mt_fileno = 	(daddr32_t)mtget->mt_fileno;
3907 			mtget_32->mt_blkno = 	(daddr32_t)mtget->mt_blkno;
3908 			mtget_32->mt_type =  	mtget->mt_type;
3909 			mtget_32->mt_flags = 	mtget->mt_flags;
3910 			mtget_32->mt_bf = 	mtget->mt_bf;
3911 
3912 			if (ddi_copyout(mtget_32, (void *)arg,
3913 			    sizeof (struct mtget32), flag)) {
3914 				rval = EFAULT;
3915 			}
3916 			break;
3917 
3918 		case DDI_MODEL_NONE:
3919 			if (ddi_copyout(mtget, (void *)arg, tmp, flag)) {
3920 				rval = EFAULT;
3921 			}
3922 			break;
3923 		}
3924 #else /* ! _MULTI_DATAMODE */
3925 		if (ddi_copyout(mtget, (void *)arg, tmp, flag)) {
3926 			rval = EFAULT;
3927 		}
3928 #endif /* _MULTI_DATAMODE */
3929 
3930 			break;
3931 		}
3932 	case MTIOCSTATE:
3933 		{
3934 			/*
3935 			 * return when media presence matches state
3936 			 */
3937 			enum mtio_state state;
3938 
3939 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
3940 				"st_ioctl: MTIOCSTATE\n");
3941 
3942 			if (ddi_copyin((void *)arg, &state, sizeof (int), flag))
3943 				rval = EFAULT;
3944 
3945 			mutex_exit(ST_MUTEX);
3946 
3947 			rval = st_check_media(dev, state);
3948 
3949 			mutex_enter(ST_MUTEX);
3950 
3951 			if (rval != 0) {
3952 				break;
3953 			}
3954 
3955 			if (ddi_copyout(&un->un_mediastate, (void *)arg,
3956 			    sizeof (int), flag))
3957 				rval = EFAULT;
3958 			break;
3959 
3960 		}
3961 
3962 	case MTIOCGETDRIVETYPE:
3963 		{
3964 #ifdef _MULTI_DATAMODEL
3965 		/*
3966 		 * For use when a 32 bit app makes a call into a
3967 		 * 64 bit ioctl
3968 		 */
3969 		struct mtdrivetype_request32	mtdtrq32;
3970 #endif /* _MULTI_DATAMODEL */
3971 
3972 			/*
3973 			 * return mtdrivetype
3974 			 */
3975 			struct mtdrivetype_request mtdtrq;
3976 			struct mtdrivetype mtdrtyp;
3977 			struct mtdrivetype *mtdt = &mtdrtyp;
3978 			struct st_drivetype *stdt = un->un_dp;
3979 
3980 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
3981 				"st_ioctl: MTIOCGETDRIVETYPE\n");
3982 
3983 #ifdef _MULTI_DATAMODEL
3984 		switch (ddi_model_convert_from(flag & FMODELS)) {
3985 		case DDI_MODEL_ILP32:
3986 		{
3987 			if (ddi_copyin((void *)arg, &mtdtrq32,
3988 			    sizeof (struct mtdrivetype_request32), flag)) {
3989 				rval = EFAULT;
3990 				break;
3991 			}
3992 			mtdtrq.size = mtdtrq32.size;
3993 			mtdtrq.mtdtp =
3994 			    (struct  mtdrivetype *)(uintptr_t)mtdtrq32.mtdtp;
3995 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
3996 				"st_ioctl: size 0x%x\n", mtdtrq.size);
3997 			break;
3998 		}
3999 		case DDI_MODEL_NONE:
4000 			if (ddi_copyin((void *)arg, &mtdtrq,
4001 			    sizeof (struct mtdrivetype_request), flag)) {
4002 				rval = EFAULT;
4003 				break;
4004 			}
4005 			break;
4006 		}
4007 
4008 #else /* ! _MULTI_DATAMODEL */
4009 		if (ddi_copyin((void *)arg, &mtdtrq,
4010 		    sizeof (struct mtdrivetype_request), flag)) {
4011 			rval = EFAULT;
4012 			break;
4013 		}
4014 #endif /* _MULTI_DATAMODEL */
4015 
4016 			/*
4017 			 * if requested size is < 0 then return
4018 			 * error.
4019 			 */
4020 			if (mtdtrq.size < 0) {
4021 				rval = EINVAL;
4022 				break;
4023 			}
4024 			bzero(mtdt, sizeof (struct mtdrivetype));
4025 			(void) strncpy(mtdt->name, stdt->name, ST_NAMESIZE);
4026 			(void) strncpy(mtdt->vid, stdt->vid, VIDPIDLEN - 1);
4027 			mtdt->type = stdt->type;
4028 			mtdt->bsize = stdt->bsize;
4029 			mtdt->options = stdt->options;
4030 			mtdt->max_rretries = stdt->max_rretries;
4031 			mtdt->max_wretries = stdt->max_wretries;
4032 			for (tmp = 0; tmp < NDENSITIES; tmp++)
4033 				mtdt->densities[tmp] = stdt->densities[tmp];
4034 			mtdt->default_density = stdt->default_density;
4035 			/*
4036 			 * Speed hasn't been used since the hayday of reel tape.
4037 			 * For all drives not setting the option ST_KNOWS_MEDIA
4038 			 * the speed member renamed to mediatype are zeros.
4039 			 * Those drives that have ST_KNOWS_MEDIA set use the
4040 			 * new mediatype member which is used to figure the
4041 			 * type of media loaded.
4042 			 *
4043 			 * So as to not break applications speed in the
4044 			 * mtdrivetype structure is not renamed.
4045 			 */
4046 			for (tmp = 0; tmp < NDENSITIES; tmp++) {
4047 				mtdt->speeds[tmp] = stdt->mediatype[tmp];
4048 			}
4049 			mtdt->non_motion_timeout = stdt->non_motion_timeout;
4050 			mtdt->io_timeout = stdt->io_timeout;
4051 			mtdt->rewind_timeout = stdt->rewind_timeout;
4052 			mtdt->space_timeout = stdt->space_timeout;
4053 			mtdt->load_timeout = stdt->load_timeout;
4054 			mtdt->unload_timeout = stdt->unload_timeout;
4055 			mtdt->erase_timeout = stdt->erase_timeout;
4056 
4057 			/*
4058 			 * Limit the maximum length of the result to
4059 			 * sizeof (struct mtdrivetype).
4060 			 */
4061 			tmp = sizeof (struct mtdrivetype);
4062 			if (mtdtrq.size < tmp)
4063 				tmp = mtdtrq.size;
4064 			if (ddi_copyout(mtdt, mtdtrq.mtdtp, tmp, flag)) {
4065 				rval = EFAULT;
4066 			}
4067 			break;
4068 		}
4069 	case MTIOCPERSISTENT:
4070 		{
4071 			int persistence = 0;
4072 
4073 			if (ddi_copyin((void *)arg, &persistence,
4074 			    sizeof (int), flag)) {
4075 				rval = EFAULT;
4076 				break;
4077 			}
4078 
4079 			/* non zero sets it, only 0 turns it off */
4080 			un->un_persistence = (uchar_t)persistence ? 1 : 0;
4081 
4082 			if (un->un_persistence)
4083 				TURN_PE_ON(un);
4084 			else
4085 				TURN_PE_OFF(un);
4086 
4087 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4088 			    "st_ioctl: MTIOCPERSISTENT : persistence = %d\n",
4089 			    un->un_persistence);
4090 
4091 			break;
4092 		}
4093 	case MTIOCPERSISTENTSTATUS:
4094 		{
4095 			int persistence = (int)un->un_persistence;
4096 
4097 			if (ddi_copyout(&persistence, (void *)arg,
4098 			    sizeof (int), flag)) {
4099 				rval = EFAULT;
4100 			}
4101 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4102 			    "st_ioctl: MTIOCPERSISTENTSTATUS:persistece = %d\n",
4103 			    un->un_persistence);
4104 
4105 			break;
4106 		}
4107 
4108 
4109 	case MTIOCLRERR:
4110 		{
4111 			/* clear persistent errors */
4112 
4113 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4114 			    "st_ioctl: MTIOCLRERR\n");
4115 
4116 			CLEAR_PE(un);
4117 
4118 			break;
4119 		}
4120 
4121 	case MTIOCGUARANTEEDORDER:
4122 		{
4123 			/*
4124 			 * this is just a holder to make a valid ioctl and
4125 			 * it won't be in any earlier release
4126 			 */
4127 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4128 			    "st_ioctl: MTIOCGUARANTEEDORDER\n");
4129 
4130 			break;
4131 		}
4132 
4133 	case MTIOCRESERVE:
4134 		{
4135 			ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4136 			    "st_ioctl: MTIOCRESERVE\n");
4137 
4138 			/*
4139 			 * Check if Reserve/Release is supported.
4140 			 */
4141 			if (un->un_dp->options & ST_NO_RESERVE_RELEASE) {
4142 				rval = ENOTTY;
4143 				break;
4144 			}
4145 
4146 			rval = st_reserve_release(un, ST_RESERVE);
4147 
4148 			if (rval == 0) {
4149 				un->un_rsvd_status |= ST_PRESERVE_RESERVE;
4150 			}
4151 			break;
4152 		}
4153 
4154 	case MTIOCRELEASE:
4155 		{
4156 			ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4157 			    "st_ioctl: MTIOCRELEASE\n");
4158 
4159 			/*
4160 			 * Check if Reserve/Release is supported.
4161 			 */
4162 			if (un->un_dp->options & ST_NO_RESERVE_RELEASE) {
4163 				rval = ENOTTY;
4164 				break;
4165 			}
4166 
4167 			/*
4168 			 * Used to just clear ST_PRESERVE_RESERVE which
4169 			 * made the reservation release at next close.
4170 			 * As the user may have opened and then done a
4171 			 * persistant reservation we now need to drop
4172 			 * the reservation without closing if the user
4173 			 * attempts to do this.
4174 			 */
4175 			rval = st_reserve_release(un, ST_RELEASE);
4176 
4177 			un->un_rsvd_status &= ~ST_PRESERVE_RESERVE;
4178 
4179 			break;
4180 		}
4181 
4182 	case MTIOCFORCERESERVE:
4183 		{
4184 			ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4185 			    "st_ioctl: MTIOCFORCERESERVE\n");
4186 
4187 			/*
4188 			 * Check if Reserve/Release is supported.
4189 			 */
4190 			if (un->un_dp->options & ST_NO_RESERVE_RELEASE) {
4191 				rval = ENOTTY;
4192 				break;
4193 			}
4194 			/*
4195 			 * allow only super user to run this.
4196 			 */
4197 			if (drv_priv(cred_p) != 0) {
4198 				rval = EPERM;
4199 				break;
4200 			}
4201 			/*
4202 			 * Throw away reserve,
4203 			 * not using test-unit-ready
4204 			 * since reserve can succeed without tape being
4205 			 * present in the drive.
4206 			 */
4207 			(void) st_reserve_release(un, ST_RESERVE);
4208 
4209 			rval = st_take_ownership(dev);
4210 
4211 			break;
4212 		}
4213 	case USCSIGETRQS:
4214 		{
4215 #ifdef _MULTI_DATAMODEL
4216 		/*
4217 		 * For use when a 32 bit app makes a call into a
4218 		 * 64 bit ioctl
4219 		 */
4220 		struct uscsi_rqs32	urqs_32;
4221 		struct uscsi_rqs32	*urqs_32_ptr = &urqs_32;
4222 #endif /* _MULTI_DATAMODEL */
4223 			struct uscsi_rqs	urqs;
4224 			struct uscsi_rqs	*urqs_ptr = &urqs;
4225 			ushort_t		len;
4226 #ifdef _MULTI_DATAMODEL
4227 		switch (ddi_model_convert_from(flag & FMODELS)) {
4228 		case DDI_MODEL_ILP32:
4229 		{
4230 			if (ddi_copyin((void *)arg, urqs_32_ptr,
4231 			    sizeof (struct uscsi_rqs32), flag)) {
4232 				rval = EFAULT;
4233 				break;
4234 			}
4235 			urqs_ptr->rqs_buflen = urqs_32_ptr->rqs_buflen;
4236 			urqs_ptr->rqs_bufaddr =
4237 			    (caddr_t)(uintptr_t)urqs_32_ptr->rqs_bufaddr;
4238 			break;
4239 		}
4240 		case DDI_MODEL_NONE:
4241 			if (ddi_copyin((void *)arg, urqs_ptr,
4242 			    sizeof (struct uscsi_rqs), flag)) {
4243 				rval = EFAULT;
4244 				break;
4245 			}
4246 		}
4247 #else /* ! _MULTI_DATAMODEL */
4248 		if (ddi_copyin((void *)arg, urqs_ptr, sizeof (urqs), flag)) {
4249 			rval = EFAULT;
4250 			break;
4251 		}
4252 #endif /* _MULTI_DATAMODEL */
4253 
4254 			urqs_ptr->rqs_flags = (int)un->un_rqs_state &
4255 			    (ST_RQS_OVR | ST_RQS_VALID);
4256 			if (urqs_ptr->rqs_buflen <= SENSE_LENGTH) {
4257 			    len = urqs_ptr->rqs_buflen;
4258 			    urqs_ptr->rqs_resid = 0;
4259 			} else {
4260 			    len = SENSE_LENGTH;
4261 			    urqs_ptr->rqs_resid = urqs_ptr->rqs_buflen
4262 				    - SENSE_LENGTH;
4263 			}
4264 			if (!(un->un_rqs_state & ST_RQS_VALID)) {
4265 			    urqs_ptr->rqs_resid = urqs_ptr->rqs_buflen;
4266 			}
4267 			un->un_rqs_state |= ST_RQS_READ;
4268 			un->un_rqs_state &= ~(ST_RQS_OVR);
4269 
4270 #ifdef _MULTI_DATAMODEL
4271 		switch (ddi_model_convert_from(flag & FMODELS)) {
4272 		case DDI_MODEL_ILP32:
4273 			urqs_32_ptr->rqs_flags = urqs_ptr->rqs_flags;
4274 			urqs_32_ptr->rqs_resid = urqs_ptr->rqs_resid;
4275 			if (ddi_copyout(&urqs_32, (void *)arg,
4276 			    sizeof (urqs_32), flag)) {
4277 				rval = EFAULT;
4278 			}
4279 			break;
4280 		case DDI_MODEL_NONE:
4281 			if (ddi_copyout(&urqs, (void *)arg, sizeof (urqs),
4282 			    flag)) {
4283 				rval = EFAULT;
4284 			}
4285 			break;
4286 		}
4287 
4288 		if (un->un_rqs_state & ST_RQS_VALID) {
4289 			if (ddi_copyout(un->un_uscsi_rqs_buf,
4290 			    urqs_ptr->rqs_bufaddr, len, flag)) {
4291 				rval = EFAULT;
4292 		    }
4293 		}
4294 #else /* ! _MULTI_DATAMODEL */
4295 		if (ddi_copyout(&urqs, (void *)arg, sizeof (urqs), flag)) {
4296 			rval = EFAULT;
4297 		}
4298 		if (un->un_rqs_state & ST_RQS_VALID) {
4299 			if (ddi_copyout(un->un_uscsi_rqs_buf,
4300 			    urqs_ptr->rqs_bufaddr, len, flag)) {
4301 				rval = EFAULT;
4302 		    }
4303 		}
4304 #endif /* _MULTI_DATAMODEL */
4305 			break;
4306 		}
4307 
4308 	case USCSICMD:
4309 	{
4310 		cred_t	*cr;
4311 #ifdef _MULTI_DATAMODEL
4312 		/*
4313 		 * For use when a 32 bit app makes a call into a
4314 		 * 64 bit ioctl
4315 		 */
4316 		struct uscsi_cmd32	ucmd_32;
4317 		struct uscsi_cmd32	*ucmd_32_ptr = &ucmd_32;
4318 #endif /* _MULTI_DATAMODEL */
4319 
4320 		/*
4321 		 * Run a generic USCSI command
4322 		 */
4323 		struct uscsi_cmd ucmd;
4324 		struct uscsi_cmd *ucmd_ptr = &ucmd;
4325 		enum uio_seg uioseg;
4326 
4327 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4328 			"st_ioctl: USCSICMD\n");
4329 
4330 		cr = ddi_get_cred();
4331 		if ((drv_priv(cred_p) != 0) && (drv_priv(cr) != 0)) {
4332 			rval = EPERM;
4333 			break;
4334 		}
4335 
4336 #ifdef _MULTI_DATAMODEL
4337 		switch (ddi_model_convert_from(flag & FMODELS)) {
4338 		case DDI_MODEL_ILP32:
4339 		{
4340 			if (ddi_copyin((void *)arg, ucmd_32_ptr,
4341 			    sizeof (struct uscsi_cmd32), flag)) {
4342 				rval = EFAULT;
4343 				break;
4344 			}
4345 			uscsi_cmd32touscsi_cmd(ucmd_32_ptr, ucmd_ptr);
4346 			break;
4347 		}
4348 		case DDI_MODEL_NONE:
4349 			if (ddi_copyin((void *)arg, ucmd_ptr, sizeof (ucmd),
4350 			    flag)) {
4351 				rval = EFAULT;
4352 				break;
4353 			}
4354 		}
4355 
4356 #else /* ! _MULTI_DATAMODEL */
4357 		if (ddi_copyin((void *)arg, ucmd_ptr, sizeof (ucmd), flag)) {
4358 			rval = EFAULT;
4359 			break;
4360 		}
4361 #endif /* _MULTI_DATAMODEL */
4362 
4363 
4364 		/*
4365 		 * although st_ioctl_cmd() never makes use of these
4366 		 * now, we are just being safe and consistent
4367 		 */
4368 		ucmd.uscsi_flags &= ~(USCSI_NOINTR | USCSI_NOPARITY |
4369 		    USCSI_OTAG | USCSI_HTAG | USCSI_HEAD);
4370 
4371 
4372 		uioseg = (flag & FKIOCTL) ?  UIO_SYSSPACE : UIO_USERSPACE;
4373 
4374 		rval = st_ioctl_cmd(dev, &ucmd, uioseg, uioseg, uioseg);
4375 
4376 
4377 #ifdef _MULTI_DATAMODEL
4378 		switch (ddi_model_convert_from(flag & FMODELS)) {
4379 		case DDI_MODEL_ILP32:
4380 			/*
4381 			 * Convert 64 bit back to 32 bit before doing
4382 			 * copyout. This is what the ILP32 app expects.
4383 			 */
4384 			uscsi_cmdtouscsi_cmd32(ucmd_ptr, ucmd_32_ptr);
4385 
4386 			if (ddi_copyout(&ucmd_32, (void *)arg,
4387 			    sizeof (ucmd_32), flag)) {
4388 				if (rval != 0)
4389 					rval = EFAULT;
4390 				}
4391 			break;
4392 
4393 		case DDI_MODEL_NONE:
4394 			if (ddi_copyout(&ucmd, (void *)arg,
4395 			    sizeof (ucmd), flag)) {
4396 				if (rval != 0)
4397 					rval = EFAULT;
4398 				}
4399 			break;
4400 		}
4401 #else /* ! _MULTI_DATAMODEL */
4402 		if (ddi_copyout(&ucmd, (void *)arg, sizeof (ucmd), flag)) {
4403 			if (rval != 0)
4404 				rval = EFAULT;
4405 		}
4406 #endif /* _MULTI_DATAMODEL */
4407 
4408 		break;
4409 	}
4410 
4411 	case MTIOCTOP:
4412 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4413 			"st_ioctl: MTIOCTOP\n");
4414 		rval = st_mtioctop(un, arg, flag);
4415 		break;
4416 
4417 	case MTIOCREADIGNOREILI:
4418 		{
4419 			int set_ili;
4420 
4421 			if (ddi_copyin((void *)arg, &set_ili,
4422 			    sizeof (set_ili), flag)) {
4423 				rval = EFAULT;
4424 				break;
4425 			}
4426 
4427 			if (un->un_bsize) {
4428 				rval = ENOTTY;
4429 				break;
4430 			}
4431 
4432 			switch (set_ili) {
4433 			case 0:
4434 				un->un_dp->options &= ~ST_READ_IGNORE_ILI;
4435 				break;
4436 
4437 			case 1:
4438 				un->un_dp->options |= ST_READ_IGNORE_ILI;
4439 				break;
4440 
4441 			default:
4442 				rval = EINVAL;
4443 				break;
4444 			}
4445 			break;
4446 		}
4447 
4448 	case MTIOCREADIGNOREEOFS:
4449 		{
4450 			int ignore_eof;
4451 
4452 			if (ddi_copyin((void *)arg, &ignore_eof,
4453 			    sizeof (ignore_eof), flag)) {
4454 				rval = EFAULT;
4455 				break;
4456 			}
4457 
4458 			if (!(un->un_dp->options & ST_REEL)) {
4459 				rval = ENOTTY;
4460 				break;
4461 			}
4462 
4463 			switch (ignore_eof) {
4464 			case 0:
4465 				un->un_dp->options &= ~ST_READ_IGNORE_EOFS;
4466 				break;
4467 
4468 			case 1:
4469 				un->un_dp->options |= ST_READ_IGNORE_EOFS;
4470 				break;
4471 
4472 			default:
4473 				rval = EINVAL;
4474 				break;
4475 			}
4476 			break;
4477 		}
4478 
4479 	case MTIOCSHORTFMK:
4480 		{
4481 			int short_fmk;
4482 
4483 			if (ddi_copyin((void *)arg, &short_fmk,
4484 			    sizeof (short_fmk), flag)) {
4485 				rval = EFAULT;
4486 				break;
4487 			}
4488 
4489 			switch (un->un_dp->type) {
4490 			case ST_TYPE_EXB8500:
4491 			case ST_TYPE_EXABYTE:
4492 				if (!short_fmk) {
4493 					un->un_dp->options &=
4494 						~ST_SHORT_FILEMARKS;
4495 				} else if (short_fmk == 1) {
4496 					un->un_dp->options |=
4497 						ST_SHORT_FILEMARKS;
4498 				} else {
4499 					rval = EINVAL;
4500 				}
4501 				break;
4502 
4503 			default:
4504 				rval = ENOTTY;
4505 				break;
4506 			}
4507 			break;
4508 		}
4509 
4510 	default:
4511 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4512 			"st_ioctl: unknown ioctl\n");
4513 		rval = ENOTTY;
4514 	}
4515 
4516 exit:
4517 	if (!IS_PE_FLAG_SET(un))
4518 		un->un_errno = rval;
4519 
4520 	mutex_exit(ST_MUTEX);
4521 
4522 	return (rval);
4523 }
4524 
4525 
4526 /*
4527  * do some MTIOCTOP tape operations
4528  */
4529 static int
4530 st_mtioctop(struct scsi_tape *un, intptr_t arg, int flag)
4531 {
4532 	struct mtop *mtop, local;
4533 	int savefile, tmp, rval = 0;
4534 	dev_t dev = un->un_dev;
4535 #ifdef _MULTI_DATAMODEL
4536 	/*
4537 	 * For use when a 32 bit app makes a call into a
4538 	 * 64 bit ioctl
4539 	 */
4540 	struct mtop32	mtop_32_for_64;
4541 #endif /* _MULTI_DATAMODEL */
4542 
4543 
4544 	ASSERT(mutex_owned(ST_MUTEX));
4545 
4546 	mtop = &local;
4547 #ifdef _MULTI_DATAMODEL
4548 		switch (ddi_model_convert_from(flag & FMODELS)) {
4549 		case DDI_MODEL_ILP32:
4550 		{
4551 			if (ddi_copyin((void *)arg, &mtop_32_for_64,
4552 			    sizeof (struct mtop32), flag)) {
4553 				return (EFAULT);
4554 			}
4555 			mtop->mt_op = mtop_32_for_64.mt_op;
4556 			mtop->mt_count =  (daddr_t)mtop_32_for_64.mt_count;
4557 			break;
4558 		}
4559 		case DDI_MODEL_NONE:
4560 			if (ddi_copyin((void *)arg, mtop,
4561 			    sizeof (struct mtop), flag)) {
4562 				return (EFAULT);
4563 			}
4564 			break;
4565 		}
4566 
4567 #else /* ! _MULTI_DATAMODEL */
4568 		if (ddi_copyin((void *)arg, mtop, sizeof (struct mtop), flag)) {
4569 			return (EFAULT);
4570 		}
4571 #endif /* _MULTI_DATAMODEL */
4572 
4573 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4574 	    "st_mtioctop(): mt_op=%x\n", mtop->mt_op);
4575 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
4576 	    "fileno=%x, blkno=%lx, un_eof=%x\n", un->un_fileno, un->un_blkno,
4577 	    un->un_eof);
4578 
4579 	rval = 0;
4580 	un->un_status = 0;
4581 
4582 	/*
4583 	 * if we are going to mess with a tape, we have to make sure we have
4584 	 * one and are not offline (i.e. no tape is initialized).  We let
4585 	 * commands pass here that don't actually touch the tape, except for
4586 	 * loading and initialization (rewinding).
4587 	 */
4588 	if (un->un_state == ST_STATE_OFFLINE) {
4589 		switch (mtop->mt_op) {
4590 		case MTLOAD:
4591 		case MTNOP:
4592 			/*
4593 			 * We don't want strategy calling st_tape_init here,
4594 			 * so, change state
4595 			 */
4596 			un->un_state = ST_STATE_INITIALIZING;
4597 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4598 			    "st_mtioctop : OFFLINE state = %d\n",
4599 			    un->un_state);
4600 			break;
4601 		default:
4602 			/*
4603 			 * reinitialize by normal means
4604 			 */
4605 			rval = st_tape_init(dev);
4606 			if (rval) {
4607 				un->un_state = ST_STATE_INITIALIZING;
4608 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4609 				    "st_mtioctop : OFFLINE init failure ");
4610 				un->un_state = ST_STATE_OFFLINE;
4611 				un->un_fileno = -1;
4612 				if (rval != EACCES) {
4613 					rval = EIO;
4614 				}
4615 				return (rval);
4616 			}
4617 			un->un_state = ST_STATE_OPEN_PENDING_IO;
4618 			break;
4619 		}
4620 	}
4621 
4622 	/*
4623 	 * If the file position is invalid, allow only those
4624 	 * commands that properly position the tape and fail
4625 	 * the rest with EIO
4626 	 */
4627 	if (un->un_fileno < 0) {
4628 		switch (mtop->mt_op) {
4629 		case MTWEOF:
4630 		case MTRETEN:
4631 		case MTERASE:
4632 		case MTEOM:
4633 		case MTFSF:
4634 		case MTFSR:
4635 		case MTBSF:
4636 		case MTNBSF:
4637 		case MTBSR:
4638 		case MTSRSZ:
4639 		case MTGRSZ:
4640 			return (EIO);
4641 			/* NOTREACHED */
4642 		case MTREW:
4643 		case MTLOAD:
4644 		case MTOFFL:
4645 		case MTNOP:
4646 			break;
4647 
4648 		default:
4649 			return (ENOTTY);
4650 			/* NOTREACHED */
4651 		}
4652 	}
4653 
4654 	switch (mtop->mt_op) {
4655 	case MTERASE:
4656 		/*
4657 		 * MTERASE rewinds the tape, erase it completely, and returns
4658 		 * to the beginning of the tape
4659 		 */
4660 		if (un->un_dp->options & ST_REEL)
4661 			un->un_fmneeded = 2;
4662 
4663 		if (un->un_mspl->wp || un->un_read_only) {
4664 			un->un_status = KEY_WRITE_PROTECT;
4665 			un->un_err_resid = mtop->mt_count;
4666 			un->un_err_fileno = un->un_fileno;
4667 			un->un_err_blkno = un->un_blkno;
4668 			return (EACCES);
4669 		}
4670 		if (st_check_density_or_wfm(dev, 1, B_WRITE, NO_STEPBACK) ||
4671 		    st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD) ||
4672 		    st_cmd(dev, SCMD_ERASE, 0, SYNC_CMD)) {
4673 			un->un_fileno = -1;
4674 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4675 			    "st_mtioctop : EIO space or erase or check den)\n");
4676 			rval = EIO;
4677 		} else {
4678 			/* QIC and helical scan rewind after erase */
4679 			if (un->un_dp->options & ST_REEL) {
4680 				(void) st_cmd(dev, SCMD_REWIND, 0, ASYNC_CMD);
4681 			}
4682 		}
4683 		break;
4684 
4685 	case MTWEOF:
4686 		/*
4687 		 * write an end-of-file record
4688 		 */
4689 		if (un->un_mspl->wp || un->un_read_only) {
4690 			un->un_status = KEY_WRITE_PROTECT;
4691 			un->un_err_resid = mtop->mt_count;
4692 			un->un_err_fileno = un->un_fileno;
4693 			un->un_err_blkno = un->un_blkno;
4694 			return (EACCES);
4695 		}
4696 
4697 		/*
4698 		 * zero count means just flush buffers
4699 		 * negative count is not permitted
4700 		 */
4701 		if (mtop->mt_count < 0)
4702 			return (EINVAL);
4703 
4704 		if (!un->un_read_only) {
4705 			un->un_test_append = 1;
4706 		}
4707 
4708 		if (un->un_state == ST_STATE_OPEN_PENDING_IO) {
4709 			if (st_determine_density(dev, B_WRITE)) {
4710 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4711 				    "st_mtioctop : EIO : MTWEOF can't determine"
4712 				    "density");
4713 				return (EIO);
4714 			}
4715 		}
4716 
4717 		if (st_write_fm(dev, (int)mtop->mt_count)) {
4718 			/*
4719 			 * Failure due to something other than illegal
4720 			 * request results in loss of state (st_intr).
4721 			 */
4722 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4723 			    "st_mtioctop : EIO : MTWEOF can't write file mark");
4724 			rval = EIO;
4725 		}
4726 		break;
4727 
4728 	case MTRETEN:
4729 		/*
4730 		 * retension the tape
4731 		 */
4732 		if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK) ||
4733 		    st_cmd(dev, SCMD_LOAD, 3, SYNC_CMD)) {
4734 			un->un_fileno = -1;
4735 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4736 			    "st_mtioctop : EIO : MTRETEN ");
4737 			rval = EIO;
4738 		}
4739 		break;
4740 
4741 	case MTREW:
4742 		/*
4743 		 * rewind  the tape
4744 		 */
4745 		if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK)) {
4746 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4747 			    "st_mtioctop : EIO:MTREW check density/wfm failed");
4748 			return (EIO);
4749 		}
4750 		if (st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD)) {
4751 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4752 			    "st_mtioctop : EIO : MTREW ");
4753 			rval = EIO;
4754 		}
4755 		break;
4756 
4757 	case MTOFFL:
4758 		/*
4759 		 * rewinds, and, if appropriate, takes the device offline by
4760 		 * unloading the tape
4761 		 */
4762 		if (st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK)) {
4763 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4764 			    "st_mtioctop :EIO:MTOFFL check density/wfm failed");
4765 			return (EIO);
4766 		}
4767 		(void) st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD);
4768 		if (st_cmd(dev, SCMD_LOAD, 0, SYNC_CMD)) {
4769 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4770 			    "st_mtioctop : EIO : MTOFFL");
4771 			return (EIO);
4772 		}
4773 		un->un_eof = ST_NO_EOF;
4774 		un->un_laststate = un->un_state;
4775 		un->un_state = ST_STATE_OFFLINE;
4776 		un->un_mediastate = MTIO_EJECTED;
4777 		break;
4778 
4779 	case MTLOAD:
4780 		/*
4781 		 * This is to load a tape into the drive
4782 		 * Note that if the tape is not loaded, the device will have
4783 		 * to be opened via O_NDELAY or O_NONBLOCK.
4784 		 */
4785 		/*
4786 		 * Let's try and clean things up, if we are not
4787 		 * initializing, and then send in the load command, no
4788 		 * matter what.
4789 		 *
4790 		 * load after a media change by the user.
4791 		 */
4792 
4793 		if (un->un_state > ST_STATE_INITIALIZING)
4794 			(void) st_check_density_or_wfm(dev, 1, 0, NO_STEPBACK);
4795 		rval = st_cmd(dev, SCMD_LOAD, 1, SYNC_CMD);
4796 		if (rval) {
4797 			if (rval != EACCES) {
4798 				rval = EIO;
4799 			}
4800 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4801 			    "st_mtioctop : %s : MTLOAD\n",
4802 			    rval == EACCES ? "EACCES" : "EIO");
4803 			/*
4804 			 * If load tape fails, who knows what happened...
4805 			 */
4806 			un->un_fileno = -1;
4807 			break;
4808 		}
4809 
4810 		/*
4811 		 * reset all counters appropriately using rewind, as if LOAD
4812 		 * succeeds, we are at BOT
4813 		 */
4814 		un->un_state = ST_STATE_INITIALIZING;
4815 
4816 		if (st_tape_init(dev)) {
4817 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4818 			    "st_mtioctop : EIO : MTLOAD calls st_tape_init\n");
4819 			rval = EIO;
4820 			un->un_state = ST_STATE_OFFLINE;
4821 		}
4822 
4823 		break;
4824 
4825 	case MTNOP:
4826 		un->un_status = 0;		/* Reset status */
4827 		un->un_err_resid = 0;
4828 		break;
4829 
4830 	case MTEOM:
4831 		/*
4832 		 * positions the tape at a location just after the last file
4833 		 * written on the tape. For cartridge and 8 mm, this after
4834 		 * the last file mark; for reel, this is inbetween the two
4835 		 * last 2 file marks
4836 		 */
4837 		if ((un->un_eof >= ST_EOT) ||
4838 		    (un->un_lastop == ST_OP_WRITE) ||
4839 		    (un->un_lastop == ST_OP_WEOF)) {
4840 			/*
4841 			 * If the command wants to move to logical end
4842 			 * of media, and we're already there, we're done.
4843 			 * If we were at logical eot, we reset the state
4844 			 * to be *not* at logical eot.
4845 			 *
4846 			 * If we're at physical or logical eot, we prohibit
4847 			 * forward space operations (unconditionally).
4848 			 *
4849 			 * Also if the last operation was a write of any
4850 			 * kind the tape is at EOD.
4851 			 */
4852 			return (0);
4853 		}
4854 		/*
4855 		 * physical tape position may not be what we've been
4856 		 * telling the user; adjust the request accordingly
4857 		 */
4858 		if (IN_EOF(un)) {
4859 			un->un_fileno++;
4860 			un->un_blkno = 0;
4861 		}
4862 
4863 		if (st_check_density_or_wfm(dev, 1, B_READ, NO_STEPBACK)) {
4864 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4865 			    "st_mtioctop : EIO:MTEOM check density/wfm failed");
4866 			return (EIO);
4867 		}
4868 
4869 		/*
4870 		 * st_find_eom() returns the last fileno we knew about;
4871 		 */
4872 		savefile = st_find_eom(dev);
4873 
4874 		if ((un->un_status != KEY_BLANK_CHECK) &&
4875 		    (un->un_status != SUN_KEY_EOT)) {
4876 			un->un_fileno = -1;
4877 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4878 			    "st_mtioctop : EIO : MTEOM status check failed");
4879 			rval = EIO;
4880 		} else {
4881 			/*
4882 			 * For 1/2" reel tapes assume logical EOT marked
4883 			 * by two file marks or we don't care that we may
4884 			 * be extending the last file on the tape.
4885 			 */
4886 			if (un->un_dp->options & ST_REEL) {
4887 				if (st_cmd(dev, SCMD_SPACE, Fmk((-1)),
4888 				    SYNC_CMD)) {
4889 					un->un_fileno = -1;
4890 					ST_DEBUG2(ST_DEVINFO, st_label,
4891 					    SCSI_DEBUG,
4892 					    "st_mtioctop : EIO : MTEOM space "
4893 					    "cmd failed");
4894 					rval = EIO;
4895 					break;
4896 				}
4897 				/*
4898 				 * Fix up the block number.
4899 				 */
4900 				un->un_blkno = 0;
4901 				un->un_err_blkno = 0;
4902 			}
4903 			un->un_err_resid = 0;
4904 			un->un_fileno = savefile;
4905 			un->un_eof = ST_EOT;
4906 		}
4907 		un->un_status = 0;
4908 		break;
4909 
4910 	case MTFSF:
4911 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4912 		    "fsf: count=%lx, eof=%x\n", mtop->mt_count,
4913 			un->un_eof);
4914 		/*
4915 		 * forward space over filemark
4916 		 *
4917 		 * For ASF we allow a count of 0 on fsf which means
4918 		 * we just want to go to beginning of current file.
4919 		 * Equivalent to "nbsf(0)" or "bsf(1) + fsf".
4920 		 * Allow stepping over double fmk with reel
4921 		 */
4922 		if ((un->un_eof >= ST_EOT) && (mtop->mt_count > 0) &&
4923 		    ((un->un_dp->options & ST_REEL) == 0)) {
4924 			/* we're at EOM */
4925 			un->un_err_resid = mtop->mt_count;
4926 			un->un_status = KEY_BLANK_CHECK;
4927 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4928 			    "st_mtioctop : EIO : MTFSF at EOM");
4929 			return (EIO);
4930 		}
4931 
4932 		/*
4933 		 * physical tape position may not be what we've been
4934 		 * telling the user; adjust the request accordingly
4935 		 */
4936 		if (IN_EOF(un)) {
4937 			un->un_fileno++;
4938 			un->un_blkno = 0;
4939 			/*
4940 			 * For positive direction case, we're now covered.
4941 			 * For zero or negative direction, we're covered
4942 			 * (almost)
4943 			 */
4944 			mtop->mt_count--;
4945 		}
4946 
4947 		if (st_check_density_or_wfm(dev, 1, B_READ, STEPBACK)) {
4948 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4949 			    "st_mtioctop : EIO : MTFSF density/wfm failed");
4950 			return (EIO);
4951 		}
4952 
4953 
4954 		/*
4955 		 * Forward space file marks.
4956 		 * We leave ourselves at block zero
4957 		 * of the target file number.
4958 		 */
4959 		if (mtop->mt_count < 0) {
4960 			mtop->mt_count = -mtop->mt_count;
4961 			mtop->mt_op = MTNBSF;
4962 			goto bspace;
4963 		}
4964 fspace:
4965 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
4966 		    "fspace: count=%lx, eof=%x\n", mtop->mt_count,
4967 			un->un_eof);
4968 		if ((tmp = mtop->mt_count) == 0) {
4969 			if (un->un_blkno == 0) {
4970 				un->un_err_resid = 0;
4971 				un->un_err_fileno = un->un_fileno;
4972 				un->un_err_blkno = un->un_blkno;
4973 				break;
4974 			} else if (un->un_fileno == 0) {
4975 				rval = st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD);
4976 			} else if (un->un_dp->options & ST_BSF) {
4977 				rval = (st_cmd(dev, SCMD_SPACE, Fmk((-1)),
4978 				    SYNC_CMD) ||
4979 				    st_cmd(dev, SCMD_SPACE, Fmk(1), SYNC_CMD));
4980 			} else {
4981 				tmp = un->un_fileno;
4982 				rval = (st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD) ||
4983 				    st_cmd(dev, SCMD_SPACE, (int)Fmk(tmp),
4984 				    SYNC_CMD));
4985 			}
4986 			if (rval != 0) {
4987 				un->un_fileno = -1;
4988 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
4989 				    "st_mtioctop : EIO : fspace fileno = -1");
4990 
4991 				rval = EIO;
4992 			}
4993 		} else {
4994 			rval = st_space_fmks(dev, tmp);
4995 		}
4996 
4997 		if (mtop->mt_op == MTBSF && rval != EIO) {
4998 			/*
4999 			 * we came here with a count < 0; we now need
5000 			 * to skip back to end up before the filemark
5001 			 */
5002 			mtop->mt_count = 1;
5003 			goto bspace;
5004 		}
5005 		break;
5006 
5007 
5008 	case MTFSR:
5009 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5010 		    "fsr: count=%lx, eof=%x\n", mtop->mt_count,
5011 			un->un_eof);
5012 		/*
5013 		 * forward space to inter-record gap
5014 		 *
5015 		 */
5016 		if ((un->un_eof >= ST_EOT) && (mtop->mt_count > 0)) {
5017 			/* we're at EOM */
5018 			un->un_err_resid = mtop->mt_count;
5019 			un->un_status = KEY_BLANK_CHECK;
5020 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5021 			    "st_mtioctop : EIO : MTFSR un_eof > ST_EOT");
5022 			return (EIO);
5023 		}
5024 
5025 		if (mtop->mt_count == 0) {
5026 			un->un_err_fileno = un->un_fileno;
5027 			un->un_err_blkno = un->un_blkno;
5028 			un->un_err_resid = 0;
5029 			if (IN_EOF(un) && SVR4_BEHAVIOR) {
5030 				un->un_status = SUN_KEY_EOF;
5031 			}
5032 			return (0);
5033 		}
5034 
5035 		/*
5036 		 * physical tape position may not be what we've been
5037 		 * telling the user; adjust the position accordingly
5038 		 */
5039 		if (IN_EOF(un)) {
5040 			daddr_t blkno = un->un_blkno;
5041 			int fileno = un->un_fileno;
5042 			uchar_t lastop = un->un_lastop;
5043 			if (st_cmd(dev, SCMD_SPACE, Fmk((-1)), SYNC_CMD)
5044 			    == -1) {
5045 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5046 				    "st_mtioctop : EIO :MTFSR count && IN_EOF");
5047 				return (EIO);
5048 			}
5049 
5050 			un->un_blkno = blkno;
5051 			un->un_fileno = fileno;
5052 			un->un_lastop = lastop;
5053 		}
5054 
5055 		if (st_check_density_or_wfm(dev, 1, B_READ, STEPBACK)) {
5056 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5057 			    "st_mtioctop : EIO : MTFSR st_check_den");
5058 			return (EIO);
5059 		}
5060 
5061 space_records:
5062 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5063 		    "space_records: count=%lx, eof=%x\n", mtop->mt_count,
5064 			un->un_eof);
5065 		tmp = un->un_blkno + mtop->mt_count;
5066 		if (tmp == un->un_blkno) {
5067 			un->un_err_resid = 0;
5068 			un->un_err_fileno = un->un_fileno;
5069 			un->un_err_blkno = un->un_blkno;
5070 			break;
5071 		} else if (un->un_blkno < tmp ||
5072 		    (un->un_dp->options & ST_BSR)) {
5073 			/*
5074 			 * If we're spacing forward, or the device can
5075 			 * backspace records, we can just use the SPACE
5076 			 * command.
5077 			 */
5078 			tmp = tmp - un->un_blkno;
5079 			if (st_cmd(dev, SCMD_SPACE, Blk(tmp), SYNC_CMD)) {
5080 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5081 				    "st_mtioctop :EIO:space_records can't spc");
5082 				rval = EIO;
5083 			} else if (un->un_eof >= ST_EOF_PENDING) {
5084 				/*
5085 				 * check if we hit BOT/EOT
5086 				 */
5087 				if (tmp < 0 && un->un_eof == ST_EOM) {
5088 					un->un_status = SUN_KEY_BOT;
5089 					un->un_eof = ST_NO_EOF;
5090 				} else if (tmp < 0 && un->un_eof ==
5091 				    ST_EOF_PENDING) {
5092 					int residue = un->un_err_resid;
5093 					/*
5094 					 * we skipped over a filemark
5095 					 * and need to go forward again
5096 					 */
5097 					if (st_cmd(dev, SCMD_SPACE, Fmk(1),
5098 					    SYNC_CMD)) {
5099 						ST_DEBUG2(ST_DEVINFO,
5100 						    st_label, SCSI_DEBUG,
5101 						    "st_mtioctop : EIO : "
5102 						    "space_records can't "
5103 						    "space #2");
5104 						rval = EIO;
5105 					}
5106 					un->un_err_resid = residue;
5107 				}
5108 				if (rval == 0) {
5109 					ST_DEBUG2(ST_DEVINFO, st_label,
5110 					    SCSI_DEBUG,
5111 					    "st_mtioctop : EIO : space_rec rval"
5112 					    " == 0");
5113 					rval = EIO;
5114 				}
5115 			}
5116 		} else {
5117 			/*
5118 			 * else we rewind, space forward across filemarks to
5119 			 * the desired file, and then space records to the
5120 			 * desired block.
5121 			 */
5122 
5123 			int t = un->un_fileno;	/* save current file */
5124 
5125 			if (tmp < 0) {
5126 				/*
5127 				 * Wups - we're backing up over a filemark
5128 				 */
5129 				if (un->un_blkno != 0 &&
5130 				    (st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD) ||
5131 				    st_cmd(dev, SCMD_SPACE, Fmk(t), SYNC_CMD)))
5132 					un->un_fileno = -1;
5133 				un->un_err_resid = -tmp;
5134 				if (un->un_fileno == 0 && un->un_blkno == 0) {
5135 					un->un_status = SUN_KEY_BOT;
5136 					un->un_eof = ST_NO_EOF;
5137 				} else if (un->un_fileno > 0) {
5138 					un->un_status = SUN_KEY_EOF;
5139 					un->un_eof = ST_NO_EOF;
5140 				}
5141 				un->un_err_fileno = un->un_fileno;
5142 				un->un_err_blkno = un->un_blkno;
5143 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5144 				    "st_mtioctop :EIO:space_records : tmp < 0");
5145 				rval = EIO;
5146 			} else if (st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD) ||
5147 				    st_cmd(dev, SCMD_SPACE, Fmk(t), SYNC_CMD) ||
5148 				    st_cmd(dev, SCMD_SPACE, Blk(tmp),
5149 					SYNC_CMD)) {
5150 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5151 				    "st_mtioctop : EIO :space_records : rewind "
5152 				    "and space failed");
5153 				un->un_fileno = -1;
5154 				rval = EIO;
5155 			}
5156 		}
5157 		break;
5158 
5159 
5160 	case MTBSF:
5161 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5162 		    "bsf: count=%lx, eof=%x\n", mtop->mt_count,
5163 			un->un_eof);
5164 		/*
5165 		 * backward space of file filemark (1/2" and 8mm)
5166 		 * tape position will end on the beginning of tape side
5167 		 * of the desired file mark
5168 		 */
5169 		if ((un->un_dp->options & ST_BSF) == 0) {
5170 			return (ENOTTY);
5171 		}
5172 
5173 		/*
5174 		 * If a negative count (which implies a forward space op)
5175 		 * is specified, and we're at logical or physical eot,
5176 		 * bounce the request.
5177 		 */
5178 
5179 		if (un->un_eof >= ST_EOT && mtop->mt_count < 0) {
5180 			un->un_err_resid = mtop->mt_count;
5181 			un->un_status = SUN_KEY_EOT;
5182 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5183 			    "st_ioctl : EIO : MTBSF : un_eof > ST_EOF");
5184 			return (EIO);
5185 		}
5186 		/*
5187 		 * physical tape position may not be what we've been
5188 		 * telling the user; adjust the request accordingly
5189 		 */
5190 		if (IN_EOF(un)) {
5191 			un->un_fileno++;
5192 			un->un_blkno = 0;
5193 			mtop->mt_count++;
5194 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5195 			"bsf in eof: count=%ld, op=%x\n",
5196 			mtop->mt_count, mtop->mt_op);
5197 
5198 		}
5199 
5200 		if (st_check_density_or_wfm(dev, 1, 0, STEPBACK)) {
5201 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5202 			    "st_ioctl : EIO : MTBSF : check den wfm");
5203 			return (EIO);
5204 		}
5205 
5206 		if (mtop->mt_count <= 0) {
5207 			/*
5208 			 * for a negative count, we need to step forward
5209 			 * first and then step back again
5210 			 */
5211 			mtop->mt_count = -mtop->mt_count+1;
5212 			goto fspace;
5213 		}
5214 
5215 bspace:
5216 	{
5217 		int skip_cnt, end_at_eof;
5218 
5219 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5220 		    "bspace: count=%lx, eof=%x\n", mtop->mt_count,
5221 			un->un_eof);
5222 		/*
5223 		 * Backspace files (MTNBSF):
5224 		 *
5225 		 *	For tapes that can backspace, backspace
5226 		 *	count+1 filemarks and then run forward over
5227 		 *	a filemark
5228 		 *
5229 		 *	For tapes that can't backspace,
5230 		 *		calculate desired filenumber
5231 		 *		(un->un_fileno - count), rewind,
5232 		 *		and then space forward this amount
5233 		 *
5234 		 * Backspace filemarks (MTBSF)
5235 		 *
5236 		 *	For tapes that can backspace, backspace count
5237 		 *	filemarks
5238 		 *
5239 		 *	For tapes that can't backspace, calculate
5240 		 *	desired filenumber (un->un_fileno - count),
5241 		 *	add 1, rewind, space forward this amount,
5242 		 *	and mark state as ST_EOF_PENDING appropriately.
5243 		 */
5244 
5245 		if (mtop->mt_op == MTBSF) {
5246 			end_at_eof = 1;
5247 		} else {
5248 			end_at_eof = 0;
5249 		}
5250 
5251 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5252 		    "bspace: mt_op=%x, count=%lx, fileno=%x, blkno=%lx\n",
5253 		    mtop->mt_op, mtop->mt_count, un->un_fileno, un->un_blkno);
5254 
5255 		/*
5256 		 * Handle the simple case of BOT
5257 		 * playing a role in these cmds.
5258 		 * We do this by calculating the
5259 		 * ending file number. If the ending
5260 		 * file is < BOT, rewind and set an
5261 		 * error and mark resid appropriately.
5262 		 * If we're backspacing a file (not a
5263 		 * filemark) and the target file is
5264 		 * the first file on the tape, just
5265 		 * rewind.
5266 		 */
5267 
5268 		tmp = un->un_fileno - mtop->mt_count;
5269 		if ((end_at_eof && tmp < 0) || (end_at_eof == 0 && tmp <= 0)) {
5270 			if (st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD)) {
5271 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5272 				    "st_ioctl : EIO : bspace : end_at_eof && "
5273 				    "tmp < 0");
5274 				rval = EIO;
5275 			}
5276 			if (tmp < 0) {
5277 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5278 				    "st_ioctl : EIO : bspace : tmp < 0");
5279 				rval = EIO;
5280 				un->un_err_resid = -tmp;
5281 				un->un_status = SUN_KEY_BOT;
5282 			}
5283 			break;
5284 		}
5285 
5286 		if (un->un_dp->options & ST_BSF) {
5287 			skip_cnt = 1 - end_at_eof;
5288 			/*
5289 			 * If we are going to end up at the beginning
5290 			 * of the file, we have to space one extra file
5291 			 * first, and then space forward later.
5292 			 */
5293 			tmp = -(mtop->mt_count + skip_cnt);
5294 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5295 			    "skip_cnt=%x, tmp=%x\n", skip_cnt, tmp);
5296 			if (st_cmd(dev, SCMD_SPACE, Fmk(tmp), SYNC_CMD)) {
5297 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5298 				    "st_ioctl : EIO : bspace : can't space "
5299 				    "tmp");
5300 				rval = EIO;
5301 			}
5302 		} else {
5303 			if (st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD)) {
5304 				rval = EIO;
5305 			} else {
5306 				skip_cnt = tmp + end_at_eof;
5307 			}
5308 		}
5309 
5310 		/*
5311 		 * If we have to space forward, do so...
5312 		 */
5313 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5314 		    "space forward skip_cnt=%x, rval=%x\n", skip_cnt, rval);
5315 		if (rval == 0 && skip_cnt) {
5316 			if (st_cmd(dev, SCMD_SPACE, Fmk(skip_cnt), SYNC_CMD)) {
5317 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5318 				    "st_ioctl : EIO : bspace : can't space "
5319 				    "skip_cnt");
5320 				rval = EIO;
5321 			} else if (end_at_eof) {
5322 				/*
5323 				 * If we had to space forward, and we're
5324 				 * not a tape that can backspace, mark state
5325 				 * as if we'd just seen a filemark during a
5326 				 * a read.
5327 				 */
5328 				if ((un->un_dp->options & ST_BSF) == 0) {
5329 					un->un_eof = ST_EOF_PENDING;
5330 					un->un_fileno -= 1;
5331 					un->un_blkno = INF;
5332 				}
5333 			}
5334 		}
5335 
5336 		if (rval != 0) {
5337 			un->un_fileno = -1;
5338 		}
5339 		break;
5340 	}
5341 
5342 	case MTNBSF:
5343 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5344 		    "nbsf: count=%lx, eof=%x\n", mtop->mt_count,
5345 			un->un_eof);
5346 		/*
5347 		 * backward space file to beginning of file
5348 		 *
5349 		 * If a negative count (which implies a forward space op)
5350 		 * is specified, and we're at logical or physical eot,
5351 		 * bounce the request.
5352 		 */
5353 
5354 		if (un->un_eof >= ST_EOT && mtop->mt_count < 0) {
5355 			un->un_err_resid = mtop->mt_count;
5356 			un->un_status = SUN_KEY_EOT;
5357 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5358 			    "st_ioctl : EIO : > EOT and count < 0");
5359 			return (EIO);
5360 		}
5361 		/*
5362 		 * physical tape position may not be what we've been
5363 		 * telling the user; adjust the request accordingly
5364 		 */
5365 		if (IN_EOF(un)) {
5366 			un->un_fileno++;
5367 			un->un_blkno = 0;
5368 			mtop->mt_count++;
5369 		}
5370 
5371 		if (st_check_density_or_wfm(dev, 1, 0, STEPBACK)) {
5372 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5373 			    "st_ioctl : EIO : MTNBSF check den and wfm");
5374 			return (EIO);
5375 		}
5376 
5377 mtnbsf:
5378 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5379 		    "mtnbsf: count=%lx, eof=%x\n", mtop->mt_count,
5380 			un->un_eof);
5381 		if (mtop->mt_count <= 0) {
5382 			mtop->mt_op = MTFSF;
5383 			mtop->mt_count = -mtop->mt_count;
5384 			goto fspace;
5385 		}
5386 		goto bspace;
5387 
5388 	case MTBSR:
5389 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5390 		    "bsr: count=%lx, eof=%x\n", mtop->mt_count,
5391 			un->un_eof);
5392 		/*
5393 		 * backward space into inter-record gap
5394 		 *
5395 		 * If a negative count (which implies a forward space op)
5396 		 * is specified, and we're at logical or physical eot,
5397 		 * bounce the request.
5398 		 */
5399 		if (un->un_eof >= ST_EOT && mtop->mt_count < 0) {
5400 			un->un_err_resid = mtop->mt_count;
5401 			un->un_status = SUN_KEY_EOT;
5402 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5403 			    "st_ioctl : EIO : MTBSR > EOT");
5404 			return (EIO);
5405 		}
5406 
5407 		if (mtop->mt_count == 0) {
5408 			un->un_err_fileno = un->un_fileno;
5409 			un->un_err_blkno = un->un_blkno;
5410 			un->un_err_resid = 0;
5411 			if (IN_EOF(un) && SVR4_BEHAVIOR) {
5412 				un->un_status = SUN_KEY_EOF;
5413 			}
5414 			return (0);
5415 		}
5416 
5417 		/*
5418 		 * physical tape position may not be what we've been
5419 		 * telling the user; adjust the position accordingly.
5420 		 * bsr can not skip filemarks and continue to skip records
5421 		 * therefore if we are logically before the filemark but
5422 		 * physically at the EOT side of the filemark, we need to step
5423 		 * back; this allows fsr N where N > number of blocks in file
5424 		 * followed by bsr 1 to position at the beginning of last block
5425 		 */
5426 		if (IN_EOF(un)) {
5427 			int blkno = un->un_blkno;
5428 			int fileno = un->un_fileno;
5429 			uchar_t lastop = un->un_lastop;
5430 			if (st_cmd(dev, SCMD_SPACE, Fmk((-1)), SYNC_CMD)
5431 			    == -1) {
5432 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5433 				    "st_write_fm : EIO : MTBSR can't space");
5434 				return (EIO);
5435 			}
5436 
5437 			un->un_blkno = blkno;
5438 			un->un_fileno = fileno;
5439 			un->un_lastop = lastop;
5440 		}
5441 
5442 		un->un_eof = ST_NO_EOF;
5443 
5444 		if (st_check_density_or_wfm(dev, 1, 0, STEPBACK)) {
5445 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5446 			    "st_ioctl : EIO : MTBSR : can't set density or "
5447 			    "wfm");
5448 			return (EIO);
5449 		}
5450 
5451 		mtop->mt_count = -mtop->mt_count;
5452 		goto space_records;
5453 
5454 	case MTSRSZ:
5455 
5456 		/*
5457 		 * Set record-size to that sent by user
5458 		 * Check to see if there is reason that the requested
5459 		 * block size should not be set.
5460 		 */
5461 
5462 		/* If requesting variable block size is it ok? */
5463 		if ((mtop->mt_count == 0) &&
5464 		    ((un->un_dp->options & ST_VARIABLE) == 0)) {
5465 			return (ENOTTY);
5466 		}
5467 
5468 		/*
5469 		 * If requested block size is not variable "0",
5470 		 * is it less then minimum.
5471 		 */
5472 		if ((mtop->mt_count != 0) &&
5473 		    (mtop->mt_count < un->un_minbsize)) {
5474 			return (EINVAL);
5475 		}
5476 
5477 		/* Is the requested block size more then maximum */
5478 		if ((mtop->mt_count > min(un->un_maxbsize, un->un_maxdma)) &&
5479 		    (un->un_maxbsize != 0)) {
5480 			return (EINVAL);
5481 		}
5482 
5483 		/* Is requested block size a modulus the device likes */
5484 		if ((mtop->mt_count % un->un_data_mod) != 0) {
5485 			return (EINVAL);
5486 		}
5487 
5488 		if (st_change_block_size(dev, (uint32_t)mtop->mt_count) != 0) {
5489 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5490 			    "st_ioctl : MTSRSZ : EIO : cant set block size");
5491 			return (EIO);
5492 		}
5493 
5494 		return (0);
5495 
5496 	case MTGRSZ:
5497 	{
5498 #ifdef _MULTI_DATAMODEL
5499 	/*
5500 	 * For use when a 32 bit app makes a call into a
5501 	 * 64 bit ioctl
5502 	 */
5503 	struct mtop32	mtop_32_for_64;
5504 #endif /* _MULTI_DATAMODEL */
5505 
5506 
5507 		/*
5508 		 * Get record-size to the user
5509 		 */
5510 		mtop->mt_count = un->un_bsize;
5511 
5512 #ifdef _MULTI_DATAMODEL
5513 		switch (ddi_model_convert_from(flag & FMODELS)) {
5514 		case DDI_MODEL_ILP32:
5515 			/*
5516 			 * Convert 64 bit back to 32 bit before doing
5517 			 * copyout. This is what the ILP32 app expects.
5518 			 */
5519 			mtop_32_for_64.mt_op = mtop->mt_op;
5520 			mtop_32_for_64.mt_count = mtop->mt_count;
5521 
5522 			if (ddi_copyout(&mtop_32_for_64, (void *)arg,
5523 			    sizeof (struct mtop32), flag)) {
5524 				return (EFAULT);
5525 			}
5526 			break;
5527 
5528 		case DDI_MODEL_NONE:
5529 			if (ddi_copyout(mtop, (void *)arg,
5530 			    sizeof (struct mtop), flag)) {
5531 				return (EFAULT);
5532 			}
5533 			break;
5534 		}
5535 #else /* ! _MULTI_DATAMODE */
5536 		if (ddi_copyout(mtop, (void *)arg, sizeof (struct mtop), flag))
5537 			return (EFAULT);
5538 
5539 #endif /* _MULTI_DATAMODE */
5540 
5541 		return (0);
5542 	}
5543 	default:
5544 		rval = ENOTTY;
5545 	}
5546 
5547 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5548 	    "st_ioctl: fileno=%x, blkno=%lx, un_eof=%x\n", un->un_fileno,
5549 	    un->un_blkno, un->un_eof);
5550 
5551 	if (un->un_fileno < 0) {
5552 		un->un_density_known = 0;
5553 	}
5554 
5555 	ASSERT(mutex_owned(ST_MUTEX));
5556 	return (rval);
5557 }
5558 
5559 
5560 /*
5561  * Run a command for uscsi ioctl.
5562  * cdbspace is address space of cdb.
5563  * dataspace is address space of the uscsi data buffer.
5564  */
5565 static int
5566 st_ioctl_cmd(dev_t dev, struct uscsi_cmd *ucmd,
5567 	enum uio_seg cdbspace, enum uio_seg dataspace,
5568 	enum uio_seg rqbufspace)
5569 {
5570 	struct buf *bp;
5571 	struct uscsi_cmd *kcmd;
5572 	caddr_t kcdb;
5573 	int flag;
5574 	int err;
5575 	int rqlen;
5576 	int offline_state = 0;
5577 	char *krqbuf = NULL;
5578 
5579 	GET_SOFT_STATE(dev);
5580 
5581 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
5582 	    "st_ioctl_cmd(dev = 0x%lx)\n", dev);
5583 
5584 	ASSERT(mutex_owned(ST_MUTEX));
5585 
5586 	/*
5587 	 * We really don't know what commands are coming in here and
5588 	 * we don't want to limit the commands coming in.
5589 	 *
5590 	 * If st_tape_init() gets called from st_strategy(), then we
5591 	 * will hang the process waiting for un->un_sbuf_busy to be cleared,
5592 	 * which it never will, as we set it below.  To prevent
5593 	 * st_tape_init() from getting called, we have to set state to other
5594 	 * than ST_STATE_OFFLINE, so we choose ST_STATE_INITIALIZING, which
5595 	 * achieves this purpose already
5596 	 *
5597 	 * We use offline_state to preserve the OFFLINE state, if it exists,
5598 	 * so other entry points to the driver might have the chance to call
5599 	 * st_tape_init().
5600 	 */
5601 	if (un->un_state == ST_STATE_OFFLINE) {
5602 		un->un_laststate = ST_STATE_OFFLINE;
5603 		un->un_state = ST_STATE_INITIALIZING;
5604 		offline_state = 1;
5605 	}
5606 	/*
5607 	 * Is this a request to reset the bus?
5608 	 * If so, we need go no further.
5609 	 */
5610 	if (ucmd->uscsi_flags & (USCSI_RESET|USCSI_RESET_ALL)) {
5611 		flag = ((ucmd->uscsi_flags & USCSI_RESET_ALL)) ?
5612 			RESET_ALL : RESET_TARGET;
5613 
5614 		mutex_exit(ST_MUTEX);
5615 		err = (scsi_reset(ROUTE, flag)) ? 0 : EIO;
5616 		mutex_enter(ST_MUTEX);
5617 
5618 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
5619 			"reset %s %s\n",
5620 			(flag == RESET_ALL) ? "all" : "target",
5621 			(err == 0) ? "ok" : "failed");
5622 		/*
5623 		 * If scsi reset successful, don't write any filemarks.
5624 		 */
5625 		if (err == 0) {
5626 			un->un_fmneeded = 0;
5627 		} else {
5628 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5629 			    "st_ioctl_cmd : EIO : scsi_reset failed");
5630 		}
5631 		goto exit;
5632 	}
5633 
5634 	/*
5635 	 * First do some sanity checks for USCSI commands.
5636 	 */
5637 	if (ucmd->uscsi_cdblen <= 0) {
5638 		return (EINVAL);
5639 	}
5640 
5641 	/*
5642 	 * In order to not worry about where the uscsi structure
5643 	 * or cdb it points to came from, we kmem_alloc copies
5644 	 * of them here.  This will allow reference to the data
5645 	 * they contain long after this process has gone to
5646 	 * sleep and its kernel stack has been unmapped, etc.
5647 	 */
5648 
5649 	kcdb = kmem_alloc((size_t)ucmd->uscsi_cdblen, KM_SLEEP);
5650 	if (cdbspace == UIO_SYSSPACE) {
5651 		bcopy(ucmd->uscsi_cdb, kcdb, ucmd->uscsi_cdblen);
5652 	} else {
5653 		if (ddi_copyin(ucmd->uscsi_cdb, kcdb,
5654 		    (size_t)ucmd->uscsi_cdblen, 0)) {
5655 			kmem_free(kcdb, (size_t)ucmd->uscsi_cdblen);
5656 			err = EFAULT;
5657 			goto exit;
5658 		}
5659 	}
5660 
5661 	kcmd = kmem_alloc(sizeof (struct uscsi_cmd), KM_SLEEP);
5662 	bcopy(ucmd, kcmd, sizeof (struct uscsi_cmd));
5663 	kcmd->uscsi_cdb = kcdb;
5664 
5665 	flag = (kcmd->uscsi_flags & USCSI_READ) ? B_READ : B_WRITE;
5666 
5667 	/* check to see if this command requires the drive to be reserved */
5668 	err = st_check_cdb_for_need_to_reserve(un, &kcdb[0]);
5669 
5670 	if (err) {
5671 		goto exit_free;
5672 	}
5673 
5674 	/*
5675 	 * Get buffer resources...
5676 	 */
5677 	while (un->un_sbuf_busy)
5678 		cv_wait(&un->un_sbuf_cv, ST_MUTEX);
5679 	un->un_sbuf_busy = 1;
5680 
5681 #ifdef STDEBUG
5682 	if (st_debug > 6) {
5683 		st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG,
5684 		    "uscsi cdb", kcdb, kcmd->uscsi_cdblen);
5685 		if (kcmd->uscsi_buflen) {
5686 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5687 			"uscsi %s of %ld bytes %s %s space\n",
5688 			(flag == B_READ) ? rd_str : wr_str,
5689 			kcmd->uscsi_buflen,
5690 			(flag == B_READ) ? "to" : "from",
5691 			(dataspace == UIO_SYSSPACE) ? "system" : "user");
5692 		}
5693 	}
5694 #endif /* ST_DEBUG */
5695 
5696 	/*
5697 	 * Initialize Request Sense buffering, if requested.
5698 	 * For user processes, allocate a kernel copy of the sense buffer
5699 	 */
5700 	if ((kcmd->uscsi_flags & USCSI_RQENABLE) &&
5701 			kcmd->uscsi_rqlen && kcmd->uscsi_rqbuf) {
5702 		if (rqbufspace == UIO_USERSPACE) {
5703 			krqbuf = kmem_alloc(SENSE_LENGTH, KM_SLEEP);
5704 		}
5705 		kcmd->uscsi_rqlen = SENSE_LENGTH;
5706 		kcmd->uscsi_rqresid = SENSE_LENGTH;
5707 	} else {
5708 		kcmd->uscsi_rqlen = 0;
5709 		kcmd->uscsi_rqresid = 0;
5710 	}
5711 
5712 	un->un_srqbufp = krqbuf;
5713 	bp = un->un_sbufp;
5714 	bzero(bp, sizeof (buf_t));
5715 
5716 	/*
5717 	 * Force asynchronous mode, if necessary.
5718 	 */
5719 	if (ucmd->uscsi_flags & USCSI_ASYNC) {
5720 		mutex_exit(ST_MUTEX);
5721 		if (scsi_ifgetcap(ROUTE, "synchronous", 1) == 1) {
5722 			if (scsi_ifsetcap(ROUTE, "synchronous", 0, 1) == 1) {
5723 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
5724 				    "forced async ok\n");
5725 			} else {
5726 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
5727 				    "forced async failed\n");
5728 				err = EINVAL;
5729 				mutex_enter(ST_MUTEX);
5730 				goto done;
5731 			}
5732 		}
5733 		mutex_enter(ST_MUTEX);
5734 	}
5735 
5736 	/*
5737 	 * Re-enable synchronous mode, if requested
5738 	 */
5739 	if (ucmd->uscsi_flags & USCSI_SYNC) {
5740 		mutex_exit(ST_MUTEX);
5741 		if (scsi_ifgetcap(ROUTE, "synchronous", 1) == 0) {
5742 			int i = scsi_ifsetcap(ROUTE, "synchronous", 1, 1);
5743 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
5744 				"re-enabled sync %s\n",
5745 				(i == 1) ? "ok" : "failed");
5746 		}
5747 		mutex_enter(ST_MUTEX);
5748 	}
5749 
5750 	if (kcmd->uscsi_buflen) {
5751 		/*
5752 		 * We're going to do actual I/O.
5753 		 * Set things up for physio.
5754 		 */
5755 		struct iovec aiov;
5756 		struct uio auio;
5757 		struct uio *uio = &auio;
5758 
5759 		bzero(&auio, sizeof (struct uio));
5760 		bzero(&aiov, sizeof (struct iovec));
5761 		aiov.iov_base = kcmd->uscsi_bufaddr;
5762 		aiov.iov_len = kcmd->uscsi_buflen;
5763 
5764 		uio->uio_iov = &aiov;
5765 		uio->uio_iovcnt = 1;
5766 		uio->uio_resid = aiov.iov_len;
5767 		uio->uio_segflg = dataspace;
5768 
5769 		/*
5770 		 * Let physio do the rest...
5771 		 */
5772 		bp->b_forw = (struct buf *)(uintptr_t)kcdb[0];
5773 		bp->b_back = (struct buf *)kcmd;
5774 
5775 		mutex_exit(ST_MUTEX);
5776 		err = physio(st_strategy, bp, dev, flag, st_uscsi_minphys, uio);
5777 		mutex_enter(ST_MUTEX);
5778 	} else {
5779 		/*
5780 		 * Mimic physio
5781 		 */
5782 		bp->b_forw = (struct buf *)(uintptr_t)kcdb[0];
5783 		bp->b_back = (struct buf *)kcmd;
5784 		bp->b_flags = B_BUSY | flag;
5785 		bp->b_edev = dev;
5786 		bp->b_dev = cmpdev(dev);
5787 		bp->b_bcount = 0;
5788 		bp->b_blkno = 0;
5789 		bp->b_resid = 0;
5790 		mutex_exit(ST_MUTEX);
5791 		(void) st_strategy(bp);
5792 
5793 		/*
5794 		 * BugTraq #4260046
5795 		 * ----------------
5796 		 * See comments in st_cmd.
5797 		 */
5798 
5799 		err = biowait(bp);
5800 		mutex_enter(ST_MUTEX);
5801 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5802 		    "st_ioctl_cmd: biowait returns %d\n", err);
5803 	}
5804 
5805 	/*
5806 	 * Copy status from kernel copy of uscsi_cmd to user copy
5807 	 * of uscsi_cmd - this was saved in st_done_and_mutex_exit()
5808 	 */
5809 	ucmd->uscsi_status = kcmd->uscsi_status;
5810 
5811 done:
5812 	ucmd->uscsi_resid = bp->b_resid;
5813 
5814 	/*
5815 	 * Update the Request Sense status and resid
5816 	 */
5817 	rqlen = kcmd->uscsi_rqlen - kcmd->uscsi_rqresid;
5818 	rqlen = min(((int)ucmd->uscsi_rqlen), rqlen);
5819 	ucmd->uscsi_rqresid = ucmd->uscsi_rqlen - rqlen;
5820 	ucmd->uscsi_rqstatus = kcmd->uscsi_rqstatus;
5821 	/*
5822 	 * Copy out the sense data for user processes
5823 	 */
5824 	if (ucmd->uscsi_rqbuf && rqlen && rqbufspace == UIO_USERSPACE) {
5825 		if (copyout(krqbuf, ucmd->uscsi_rqbuf, rqlen)) {
5826 			err = EFAULT;
5827 		}
5828 	}
5829 
5830 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5831 	    "st_ioctl_cmd status is 0x%x, resid is 0x%lx\n",
5832 	    ucmd->uscsi_status, ucmd->uscsi_resid);
5833 	if (DEBUGGING && (rqlen != 0)) {
5834 		int i, n, len;
5835 		char *data = krqbuf;
5836 		scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
5837 			"rqstatus=0x%x	rqlen=0x%x  rqresid=0x%x\n",
5838 			ucmd->uscsi_rqstatus, ucmd->uscsi_rqlen,
5839 			ucmd->uscsi_rqresid);
5840 		len = (int)ucmd->uscsi_rqlen - ucmd->uscsi_rqresid;
5841 		for (i = 0; i < len; i += 16) {
5842 			n = min(16, len-1);
5843 			st_clean_print(ST_DEVINFO, st_label, CE_NOTE,
5844 				"  ", &data[i], n);
5845 		}
5846 	}
5847 
5848 exit_free:
5849 	/*
5850 	 * Free resources
5851 	 */
5852 	un->un_sbuf_busy = 0;
5853 	un->un_srqbufp = NULL;
5854 	cv_signal(&un->un_sbuf_cv);
5855 
5856 	if (krqbuf) {
5857 		kmem_free(krqbuf, SENSE_LENGTH);
5858 	}
5859 	kmem_free(kcdb, kcmd->uscsi_cdblen);
5860 	kmem_free(kcmd, sizeof (struct uscsi_cmd));
5861 
5862 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5863 	    "st_ioctl_cmd returns 0x%x\n", err);
5864 
5865 
5866 exit:
5867 	/* don't lose offline state */
5868 	if (offline_state)
5869 		un->un_state = ST_STATE_OFFLINE;
5870 
5871 	ASSERT(mutex_owned(ST_MUTEX));
5872 	return (err);
5873 }
5874 
5875 static int
5876 st_write_fm(dev_t dev, int wfm)
5877 {
5878 	int i;
5879 
5880 	GET_SOFT_STATE(dev);
5881 
5882 	ASSERT(mutex_owned(ST_MUTEX));
5883 
5884 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
5885 	    "st_write_fm(dev = 0x%lx, wfm = %d)\n", dev, wfm);
5886 
5887 	/*
5888 	 * write one filemark at the time after EOT
5889 	 */
5890 	if (un->un_eof >= ST_EOT) {
5891 		for (i = 0; i < wfm; i++) {
5892 			if (st_cmd(dev, SCMD_WRITE_FILE_MARK, 1, SYNC_CMD)) {
5893 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5894 				    "st_write_fm : EIO : write EOT file mark");
5895 				return (EIO);
5896 			}
5897 		}
5898 	} else if (st_cmd(dev, SCMD_WRITE_FILE_MARK, wfm, SYNC_CMD)) {
5899 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
5900 		    "st_write_fm : EIO : write file mark");
5901 		return (EIO);
5902 	}
5903 
5904 	ASSERT(mutex_owned(ST_MUTEX));
5905 	return (0);
5906 }
5907 
5908 #ifdef STDEBUG
5909 static void
5910 start_dump(struct scsi_tape *un, struct buf *bp)
5911 {
5912 	struct scsi_pkt *pkt = BP_PKT(bp);
5913 	uchar_t *cdbp = (uchar_t *)pkt->pkt_cdbp;
5914 
5915 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5916 	    "st_start: cmd=0x%p count=%ld resid=%ld flags=0x%x pkt=0x%p\n",
5917 	    (void *)bp->b_forw, bp->b_bcount,
5918 	    bp->b_resid, bp->b_flags, (void *)BP_PKT(bp));
5919 
5920 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
5921 	    "st_start: cdb %x %x %x %x %x %x, fileno=%d, blk=%ld\n",
5922 	    cdbp[0], cdbp[1], cdbp[2],
5923 	    cdbp[3], cdbp[4], cdbp[5], un->un_fileno,
5924 	    un->un_blkno);
5925 }
5926 #endif
5927 
5928 
5929 /*
5930  * Command start && done functions
5931  */
5932 
5933 /*
5934  * st_start()
5935  *
5936  * Called from:
5937  *  st_strategy() to start a command.
5938  *  st_runout() to retry when scsi_pkt allocation fails on previous attempt(s).
5939  *  st_attach() when resuming from power down state.
5940  *  st_start_restart() to retry transport when device was previously busy.
5941  *  st_done_and_mutex_exit() to start the next command when previous is done.
5942  *
5943  * On entry:
5944  *  scsi_pkt may or may not be allocated.
5945  *
5946  */
5947 static void
5948 st_start(struct scsi_tape *un)
5949 {
5950 	struct buf *bp;
5951 	int status;
5952 
5953 	ASSERT(mutex_owned(ST_MUTEX));
5954 
5955 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
5956 	    "st_start(): dev = 0x%lx\n", un->un_dev);
5957 
5958 	if ((bp = un->un_quef) == NULL) {
5959 		return;
5960 	}
5961 
5962 	ASSERT((bp->b_flags & B_DONE) == 0);
5963 
5964 	/*
5965 	 * Don't send more than un_throttle commands to the HBA
5966 	 */
5967 	if ((un->un_throttle <= 0) || (un->un_ncmds >= un->un_throttle)) {
5968 		return;
5969 	}
5970 
5971 	/*
5972 	 * If the buf has no scsi_pkt call st_make_cmd() to get one and
5973 	 * build the command.
5974 	 */
5975 	if (BP_PKT(bp) == NULL) {
5976 		ASSERT((bp->b_flags & B_DONE) == 0);
5977 		st_make_cmd(un, bp, st_runout);
5978 		ASSERT((bp->b_flags & B_DONE) == 0);
5979 		status = geterror(bp);
5980 
5981 		/*
5982 		 * Some HBA's don't call bioerror() to set an error.
5983 		 * And geterror() returns zero if B_ERROR is not set.
5984 		 * So if we get zero we must check b_error.
5985 		 */
5986 		if (status == 0 && bp->b_error != 0) {
5987 			status = bp->b_error;
5988 			bioerror(bp, status);
5989 		}
5990 
5991 		/*
5992 		 * Some HBA's convert DDI_DMA_NORESOURCES into ENOMEM.
5993 		 * In tape ENOMEM has special meaning so we'll change it.
5994 		 */
5995 		if (status == ENOMEM) {
5996 			status = 0;
5997 			bioerror(bp, status);
5998 		}
5999 
6000 		/*
6001 		 * Did it fail and is it retryable?
6002 		 * If so return and wait for the callback through st_runout.
6003 		 * Also looks like scsi_init_pkt() will setup a callback even
6004 		 * if it isn't retryable.
6005 		 */
6006 		if (BP_PKT(bp) == NULL) {
6007 			if (status == 0) {
6008 				/*
6009 				 * If first attempt save state.
6010 				 */
6011 				if (un->un_state != ST_STATE_RESOURCE_WAIT) {
6012 					un->un_laststate = un->un_state;
6013 					un->un_state = ST_STATE_RESOURCE_WAIT;
6014 				}
6015 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
6016 				    "temp no resources for pkt\n");
6017 			} else {
6018 				/*
6019 				 * Unlikely that it would be retryable then not.
6020 				 */
6021 				if (un->un_state == ST_STATE_RESOURCE_WAIT) {
6022 					un->un_state = un->un_laststate;
6023 				}
6024 				scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
6025 				    "perm no resources for pkt errno = 0x%x\n",
6026 				    status);
6027 			}
6028 			return;
6029 		}
6030 		/*
6031 		 * Worked this time set the state back.
6032 		 */
6033 		if (un->un_state == ST_STATE_RESOURCE_WAIT) {
6034 			un->un_state = un->un_laststate;
6035 		}
6036 	}
6037 
6038 	/*
6039 	 * move from waitq to runq
6040 	 */
6041 	un->un_quef = bp->b_actf;
6042 	if (un->un_quel == bp) {
6043 		/*
6044 		 *  For the case of queue having one
6045 		 *  element, set the tail pointer to
6046 		 *  point to the element.
6047 		 */
6048 		un->un_quel = bp->b_actf;
6049 	}
6050 
6051 	bp->b_actf = NULL;
6052 
6053 	if (un->un_runqf) {
6054 		un->un_runql->b_actf = bp;
6055 	} else {
6056 		un->un_runqf = bp;
6057 	}
6058 	un->un_runql = bp;
6059 
6060 
6061 #ifdef STDEBUG
6062 	start_dump(un, bp);
6063 #endif
6064 
6065 	/* could not get here if throttle was zero */
6066 	un->un_last_throttle = un->un_throttle;
6067 	un->un_throttle = 0;	/* so nothing else will come in here */
6068 	un->un_ncmds++;
6069 
6070 	ST_DO_KSTATS(bp, kstat_waitq_to_runq);
6071 
6072 	mutex_exit(ST_MUTEX);
6073 
6074 	status = scsi_transport(BP_PKT(bp));
6075 
6076 	mutex_enter(ST_MUTEX);
6077 
6078 	if (un->un_last_throttle) {
6079 		un->un_throttle = un->un_last_throttle;
6080 	}
6081 
6082 	if (status != TRAN_ACCEPT) {
6083 		ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
6084 		mutex_exit(ST_MUTEX);
6085 
6086 		if (status == TRAN_BUSY) {
6087 			/* if too many retries, fail the transport */
6088 			if (st_handle_start_busy(un, bp,
6089 			    ST_TRAN_BUSY_TIMEOUT) == 0)
6090 				goto done;
6091 		}
6092 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
6093 		    "transport rejected\n");
6094 		bp->b_resid = bp->b_bcount;
6095 
6096 
6097 #ifndef __lock_lint
6098 		/*
6099 		 * warlock doesn't understand this potential
6100 		 * recursion?
6101 		 */
6102 		mutex_enter(ST_MUTEX);
6103 		ST_DO_KSTATS(bp, kstat_waitq_exit);
6104 		ST_DO_ERRSTATS(un, st_transerrs);
6105 		st_bioerror(bp, EIO);
6106 		SET_PE_FLAG(un);
6107 		st_done_and_mutex_exit(un, bp);
6108 #endif
6109 	} else {
6110 		un->un_tran_retry_ct = 0;
6111 		mutex_exit(ST_MUTEX);
6112 	}
6113 
6114 done:
6115 
6116 	mutex_enter(ST_MUTEX);
6117 }
6118 
6119 /*
6120  * if the transport is busy, then put this bp back on the waitq
6121  */
6122 static int
6123 st_handle_start_busy(struct scsi_tape *un, struct buf *bp,
6124     clock_t timeout_interval)
6125 {
6126 	struct buf *last_quef, *runq_bp;
6127 	int rval = 0;
6128 
6129 	mutex_enter(ST_MUTEX);
6130 
6131 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6132 	    "st_handle_start_busy()\n");
6133 
6134 	/*
6135 	 * Check to see if we hit the retry timeout and one last check for
6136 	 * making sure this is the last on the runq, if it is not, we have
6137 	 * to fail
6138 	 */
6139 	if (((int)un->un_tran_retry_ct++ > st_retry_count) ||
6140 	    (un->un_runql != bp)) {
6141 		rval = -1;
6142 		goto exit;
6143 	}
6144 
6145 	/* put the bp back on the waitq */
6146 	if (un->un_quef) {
6147 		last_quef = un->un_quef;
6148 		un->un_quef = bp;
6149 		bp->b_actf = last_quef;
6150 	} else  {
6151 		bp->b_actf = NULL;
6152 		un->un_quef = bp;
6153 		un->un_quel = bp;
6154 	}
6155 
6156 	/*
6157 	 * Decrement un_ncmds so that this
6158 	 * gets thru' st_start() again.
6159 	 */
6160 	un->un_ncmds--;
6161 
6162 	/*
6163 	 * since this is an error case, we won't have to do
6164 	 * this list walking much.  We've already made sure this bp was the
6165 	 * last on the runq
6166 	 */
6167 	runq_bp = un->un_runqf;
6168 
6169 	if (un->un_runqf == bp) {
6170 		un->un_runqf = NULL;
6171 		un->un_runql = NULL;
6172 	} else {
6173 		while (runq_bp) {
6174 			if (runq_bp->b_actf == bp) {
6175 				runq_bp->b_actf = NULL;
6176 				un->un_runql = runq_bp;
6177 				break;
6178 			}
6179 			runq_bp = runq_bp->b_actf;
6180 		}
6181 	}
6182 
6183 
6184 	/*
6185 	 * send a marker pkt, if appropriate
6186 	 */
6187 	st_hba_unflush(un);
6188 
6189 	/*
6190 	 * all queues are aligned, we are just waiting to
6191 	 * transport, don't alloc any more buf p's, when
6192 	 * st_start is reentered.
6193 	 */
6194 	(void) timeout(st_start_restart, un, timeout_interval);
6195 
6196 exit:
6197 	mutex_exit(ST_MUTEX);
6198 	return (rval);
6199 }
6200 
6201 
6202 
6203 /*
6204  * st_runout a callback that is called what a resource allocatation failed
6205  */
6206 static int
6207 st_runout(caddr_t arg)
6208 {
6209 	struct scsi_tape *un = (struct scsi_tape *)arg;
6210 	struct buf *bp;
6211 
6212 	ASSERT(un != NULL);
6213 
6214 	mutex_enter(ST_MUTEX);
6215 
6216 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_runout()\n");
6217 
6218 	bp = un->un_quef;
6219 
6220 	/*
6221 	 * failed scsi_init_pkt(). If errno is zero its retryable.
6222 	 */
6223 	if ((bp != NULL) && (geterror(bp) != 0)) {
6224 
6225 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
6226 		    "errors after pkt alloc (b_flags=0x%x, b_error=0x%x)\n",
6227 		    bp->b_flags, geterror(bp));
6228 		ASSERT((bp->b_flags & B_DONE) == 0);
6229 
6230 		un->un_quef = bp->b_actf;
6231 		if (un->un_quel == bp) {
6232 			/*
6233 			 *  For the case of queue having one
6234 			 *  element, set the tail pointer to
6235 			 *  point to the element.
6236 			 */
6237 			un->un_quel = bp->b_actf;
6238 		}
6239 		mutex_exit(ST_MUTEX);
6240 		bp->b_actf = NULL;
6241 
6242 		ASSERT((bp->b_flags & B_DONE) == 0);
6243 
6244 		/*
6245 		 * Set resid, Error already set, then unblock calling thread.
6246 		 */
6247 		bp->b_resid = bp->b_bcount;
6248 		biodone(bp);
6249 	} else {
6250 		/*
6251 		 * Try Again
6252 		 */
6253 		st_start(un);
6254 		mutex_exit(ST_MUTEX);
6255 	}
6256 
6257 	/*
6258 	 * Comments courtesy of sd.c
6259 	 * The scsi_init_pkt routine allows for the callback function to
6260 	 * return a 0 indicating the callback should be rescheduled or a 1
6261 	 * indicating not to reschedule. This routine always returns 1
6262 	 * because the driver always provides a callback function to
6263 	 * scsi_init_pkt. This results in a callback always being scheduled
6264 	 * (via the scsi_init_pkt callback implementation) if a resource
6265 	 * failure occurs.
6266 	 */
6267 
6268 	return (1);
6269 }
6270 
6271 /*
6272  * st_done_and_mutex_exit()
6273  *	- remove bp from runq
6274  *	- start up the next request
6275  *	- if this was an asynch bp, clean up
6276  *	- exit with released mutex
6277  */
6278 static void
6279 st_done_and_mutex_exit(struct scsi_tape *un, struct buf *bp)
6280 {
6281 	struct buf *runqbp, *prevbp;
6282 	int	pe_flagged = 0;
6283 
6284 	ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex));
6285 #if !defined(lint)
6286 	_NOTE(LOCK_RELEASED_AS_SIDE_EFFECT(&un->un_sd->sd_mutex))
6287 #endif
6288 	ASSERT(mutex_owned(ST_MUTEX));
6289 
6290 	/*
6291 	 * if bp is still on the runq (anywhere), then remove it
6292 	 */
6293 	prevbp = NULL;
6294 	for (runqbp = un->un_runqf; runqbp != 0; runqbp = runqbp->b_actf) {
6295 		if (runqbp == bp) {
6296 			if (runqbp == un->un_runqf) {
6297 				un->un_runqf = bp->b_actf;
6298 			} else {
6299 				prevbp->b_actf = bp->b_actf;
6300 			}
6301 			if (un->un_runql == bp) {
6302 				un->un_runql = prevbp;
6303 			}
6304 			break;
6305 		}
6306 		prevbp = runqbp;
6307 	}
6308 	bp->b_actf = NULL;
6309 
6310 	un->un_ncmds--;
6311 	cv_signal(&un->un_queue_cv);
6312 
6313 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6314 	"st_done_and_mutex_exit(): cmd=0x%x count=%ld resid=%ld  flags=0x%x\n",
6315 		(int)*((caddr_t)(BP_PKT(bp))->pkt_cdbp),
6316 		bp->b_bcount, bp->b_resid, bp->b_flags);
6317 
6318 
6319 	/*
6320 	 * update kstats with transfer count info
6321 	 */
6322 	if (un->un_stats && (bp != un->un_sbufp) && IS_RW(bp)) {
6323 		uint32_t n_done =  bp->b_bcount - bp->b_resid;
6324 		if (bp->b_flags & B_READ) {
6325 			IOSP->reads++;
6326 			IOSP->nread += n_done;
6327 		} else {
6328 			IOSP->writes++;
6329 			IOSP->nwritten += n_done;
6330 		}
6331 	}
6332 
6333 	/*
6334 	 * Start the next one before releasing resources on this one, if
6335 	 * there is something on the queue and persistent errors has not been
6336 	 * flagged
6337 	 */
6338 
6339 	if ((pe_flagged = IS_PE_FLAG_SET(un)) != 0) {
6340 		un->un_last_resid = bp->b_resid;
6341 		un->un_last_count = bp->b_bcount;
6342 	}
6343 
6344 	if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
6345 		cv_broadcast(&un->un_tape_busy_cv);
6346 	} else if (un->un_quef && un->un_throttle && !pe_flagged) {
6347 		st_start(un);
6348 	}
6349 
6350 	if (bp == un->un_sbufp && (bp->b_flags & B_ASYNC)) {
6351 		/*
6352 		 * Since we marked this ourselves as ASYNC,
6353 		 * there isn't anybody around waiting for
6354 		 * completion any more.
6355 		 */
6356 		uchar_t com = (uchar_t)(uintptr_t)bp->b_forw;
6357 		if (com == SCMD_READ || com == SCMD_WRITE) {
6358 			bp->b_un.b_addr = (caddr_t)0;
6359 		}
6360 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
6361 		    "st_done_and_mutex_exit(async): freeing pkt\n");
6362 		scsi_destroy_pkt(BP_PKT(bp));
6363 		un->un_sbuf_busy = 0;
6364 		cv_signal(&un->un_sbuf_cv);
6365 		mutex_exit(ST_MUTEX);
6366 		return;
6367 	}
6368 
6369 	if (bp == un->un_sbufp && BP_UCMD(bp)) {
6370 		/*
6371 		 * Copy status from scsi_pkt to uscsi_cmd
6372 		 * since st_ioctl_cmd needs it
6373 		 */
6374 		BP_UCMD(bp)->uscsi_status = SCBP_C(BP_PKT(bp));
6375 	}
6376 
6377 
6378 #ifdef STDEBUG
6379 	if ((st_debug >= 4) &&
6380 	    (((un->un_blkno % 100) == 0) || IS_PE_FLAG_SET(un))) {
6381 
6382 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
6383 		    "st_d_a_m_exit(): ncmds = %d, thr = %d, "
6384 		    "un_errno = %d, un_pe = %d\n",
6385 		    un->un_ncmds, un->un_throttle, un->un_errno,
6386 		    un->un_persist_errors);
6387 	}
6388 
6389 #endif
6390 
6391 	mutex_exit(ST_MUTEX);
6392 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
6393 	    "st_done_and_mutex_exit: freeing pkt\n");
6394 
6395 	scsi_destroy_pkt(BP_PKT(bp));
6396 
6397 	biodone(bp);
6398 
6399 	/*
6400 	 * now that we biodoned that command, if persistent errors have been
6401 	 * flagged, flush the waitq
6402 	 */
6403 	if (pe_flagged)
6404 		st_flush(un);
6405 }
6406 
6407 
6408 /*
6409  * Tape error, flush tape driver queue.
6410  */
6411 static void
6412 st_flush(struct scsi_tape *un)
6413 {
6414 	struct buf *bp;
6415 
6416 	mutex_enter(ST_MUTEX);
6417 
6418 	ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
6419 	    "st_flush(), ncmds = %d, quef = 0x%p\n",
6420 	    un->un_ncmds, (void *)un->un_quef);
6421 
6422 	/*
6423 	 * if we still have commands outstanding, wait for them to come in
6424 	 * before flushing the queue, and make sure there is a queue
6425 	 */
6426 	if (un->un_ncmds || !un->un_quef)
6427 		goto exit;
6428 
6429 	/*
6430 	 * we have no more commands outstanding, so let's deal with special
6431 	 * cases in the queue for EOM and FM. If we are here, and un_errno
6432 	 * is 0, then we know there was no error and we return a 0 read or
6433 	 * write before showing errors
6434 	 */
6435 
6436 	/* Flush the wait queue. */
6437 	while ((bp = un->un_quef) != NULL) {
6438 		un->un_quef = bp->b_actf;
6439 
6440 		bp->b_resid = bp->b_bcount;
6441 
6442 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
6443 		    "st_flush() : blkno=%ld, err=%d, b_bcount=%ld\n",
6444 		    un->un_blkno, un->un_errno, bp->b_bcount);
6445 
6446 		st_set_pe_errno(un);
6447 
6448 		bioerror(bp, un->un_errno);
6449 
6450 		mutex_exit(ST_MUTEX);
6451 		/* it should have one, but check anyway */
6452 		if (BP_PKT(bp)) {
6453 			scsi_destroy_pkt(BP_PKT(bp));
6454 		}
6455 		biodone(bp);
6456 		mutex_enter(ST_MUTEX);
6457 	}
6458 
6459 	/*
6460 	 * It's not a bad practice to reset the
6461 	 * waitq tail pointer to NULL.
6462 	 */
6463 	un->un_quel = NULL;
6464 
6465 exit:
6466 	/* we mucked with the queue, so let others know about it */
6467 	cv_signal(&un->un_queue_cv);
6468 	mutex_exit(ST_MUTEX);
6469 }
6470 
6471 
6472 /*
6473  * Utility functions
6474  */
6475 static int
6476 st_determine_generic(dev_t dev)
6477 {
6478 	int bsize;
6479 	static char *cart = "0.25 inch cartridge";
6480 	char *sizestr;
6481 
6482 	GET_SOFT_STATE(dev);
6483 
6484 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6485 	    "st_determine_generic(dev = 0x%lx)\n", dev);
6486 
6487 	ASSERT(mutex_owned(ST_MUTEX));
6488 
6489 	if (st_modesense(un)) {
6490 		return (-1);
6491 	}
6492 
6493 	bsize = (un->un_mspl->high_bl << 16)	|
6494 		(un->un_mspl->mid_bl << 8)	|
6495 		(un->un_mspl->low_bl);
6496 
6497 	if (bsize == 0) {
6498 		un->un_dp->options |= ST_VARIABLE;
6499 		un->un_dp->bsize = 0;
6500 		un->un_bsize = 0;
6501 	} else if (bsize > ST_MAXRECSIZE_FIXED) {
6502 		/*
6503 		 * record size of this device too big.
6504 		 * try and convert it to variable record length.
6505 		 *
6506 		 */
6507 		un->un_dp->options |= ST_VARIABLE;
6508 		if (st_change_block_size(dev, 0) != 0) {
6509 			ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
6510 			    "Fixed Record Size %d is too large\n", bsize);
6511 			ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
6512 			    "Cannot switch to variable record size\n");
6513 			un->un_dp->options &= ~ST_VARIABLE;
6514 			return (-1);
6515 		}
6516 	} else if (st_change_block_size(dev, 0) == 0) {
6517 		/*
6518 		 * If the drive was set to a non zero block size,
6519 		 * See if it can be set to a zero block size.
6520 		 * If it works, ST_VARIABLE so user can set it as they want.
6521 		 */
6522 		un->un_dp->options |= ST_VARIABLE;
6523 		un->un_dp->bsize = 0;
6524 		un->un_bsize = 0;
6525 	} else {
6526 		un->un_dp->bsize = bsize;
6527 		un->un_bsize = bsize;
6528 	}
6529 
6530 
6531 	switch (un->un_mspl->density) {
6532 	default:
6533 	case 0x0:
6534 		/*
6535 		 * default density, cannot determine any other
6536 		 * information.
6537 		 */
6538 		sizestr = "Unknown type- assuming 0.25 inch cartridge";
6539 		un->un_dp->type = ST_TYPE_DEFAULT;
6540 		un->un_dp->options |= (ST_AUTODEN_OVERRIDE|ST_QIC);
6541 		break;
6542 	case 0x1:
6543 	case 0x2:
6544 	case 0x3:
6545 	case 0x6:
6546 		/*
6547 		 * 1/2" reel
6548 		 */
6549 		sizestr = "0.50 inch reel";
6550 		un->un_dp->type = ST_TYPE_REEL;
6551 		un->un_dp->options |= ST_REEL;
6552 		un->un_dp->densities[0] = 0x1;
6553 		un->un_dp->densities[1] = 0x2;
6554 		un->un_dp->densities[2] = 0x6;
6555 		un->un_dp->densities[3] = 0x3;
6556 		break;
6557 	case 0x4:
6558 	case 0x5:
6559 	case 0x7:
6560 	case 0x0b:
6561 
6562 		/*
6563 		 * Quarter inch.
6564 		 */
6565 		sizestr = cart;
6566 		un->un_dp->type = ST_TYPE_DEFAULT;
6567 		un->un_dp->options |= ST_QIC;
6568 
6569 		un->un_dp->densities[1] = 0x4;
6570 		un->un_dp->densities[2] = 0x5;
6571 		un->un_dp->densities[3] = 0x7;
6572 		un->un_dp->densities[0] = 0x0b;
6573 		break;
6574 
6575 	case 0x0f:
6576 	case 0x10:
6577 	case 0x11:
6578 	case 0x12:
6579 		/*
6580 		 * QIC-120, QIC-150, QIC-320, QIC-600
6581 		 */
6582 		sizestr = cart;
6583 		un->un_dp->type = ST_TYPE_DEFAULT;
6584 		un->un_dp->options |= ST_QIC;
6585 		un->un_dp->densities[0] = 0x0f;
6586 		un->un_dp->densities[1] = 0x10;
6587 		un->un_dp->densities[2] = 0x11;
6588 		un->un_dp->densities[3] = 0x12;
6589 		break;
6590 
6591 	case 0x09:
6592 	case 0x0a:
6593 	case 0x0c:
6594 	case 0x0d:
6595 		/*
6596 		 * 1/2" cartridge tapes. Include HI-TC.
6597 		 */
6598 		sizestr = cart;
6599 		sizestr[2] = '5';
6600 		sizestr[3] = '0';
6601 		un->un_dp->type = ST_TYPE_HIC;
6602 		un->un_dp->densities[0] = 0x09;
6603 		un->un_dp->densities[1] = 0x0a;
6604 		un->un_dp->densities[2] = 0x0c;
6605 		un->un_dp->densities[3] = 0x0d;
6606 		break;
6607 
6608 	case 0x13:
6609 			/* DDS-2/DDS-3 scsi spec densities */
6610 	case 0x24:
6611 	case 0x25:
6612 	case 0x26:
6613 		sizestr = "DAT Data Storage (DDS)";
6614 		un->un_dp->type = ST_TYPE_DAT;
6615 		un->un_dp->options |= ST_AUTODEN_OVERRIDE;
6616 		break;
6617 
6618 	case 0x14:
6619 		/*
6620 		 * Helical Scan (Exabyte) devices
6621 		 */
6622 		sizestr = "8mm helical scan cartridge";
6623 		un->un_dp->type = ST_TYPE_EXABYTE;
6624 		un->un_dp->options |= ST_AUTODEN_OVERRIDE;
6625 		break;
6626 	}
6627 
6628 	/*
6629 	 * Assume LONG ERASE, BSF and BSR
6630 	 */
6631 
6632 	un->un_dp->options |= (ST_LONG_ERASE|ST_UNLOADABLE|ST_BSF|
6633 				ST_BSR|ST_KNOWS_EOD);
6634 
6635 	/*
6636 	 * Only if mode sense data says no buffered write, set NOBUF
6637 	 */
6638 	if (un->un_mspl->bufm == 0)
6639 		un->un_dp->options |= ST_NOBUF;
6640 
6641 	/*
6642 	 * set up large read and write retry counts
6643 	 */
6644 
6645 	un->un_dp->max_rretries = un->un_dp->max_wretries = 1000;
6646 
6647 	/*
6648 	 * If this is a 0.50 inch reel tape, and
6649 	 * it is *not* variable mode, try and
6650 	 * set it to variable record length
6651 	 * mode.
6652 	 */
6653 	if ((un->un_dp->options & ST_REEL) && un->un_bsize != 0 &&
6654 	    (un->un_dp->options & ST_VARIABLE)) {
6655 		if (st_change_block_size(dev, 0) == 0) {
6656 			un->un_dp->bsize = 0;
6657 			un->un_mspl->high_bl = un->un_mspl->mid_bl =
6658 			    un->un_mspl->low_bl = 0;
6659 		}
6660 	}
6661 
6662 	/*
6663 	 * Write to console about type of device found
6664 	 */
6665 	ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE,
6666 	    "Generic Drive, Vendor=%s\n\t%s", un->un_dp->name,
6667 	    sizestr);
6668 	if (un->un_dp->options & ST_VARIABLE) {
6669 		scsi_log(ST_DEVINFO, st_label, CE_NOTE,
6670 		    "!Variable record length I/O\n");
6671 	} else {
6672 		scsi_log(ST_DEVINFO, st_label, CE_NOTE,
6673 		    "!Fixed record length (%d byte blocks) I/O\n",
6674 		    un->un_dp->bsize);
6675 	}
6676 	ASSERT(mutex_owned(ST_MUTEX));
6677 	return (0);
6678 }
6679 
6680 static int
6681 st_determine_density(dev_t dev, int rw)
6682 {
6683 	int rval = 0;
6684 
6685 	GET_SOFT_STATE(dev);
6686 
6687 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6688 	    "st_determine_density(dev = 0x%lx, rw = %s)\n",
6689 	    dev, (rw == B_WRITE ? wr_str: rd_str));
6690 
6691 	ASSERT(mutex_owned(ST_MUTEX));
6692 
6693 	/*
6694 	 * If we're past BOT, density is determined already.
6695 	 */
6696 	if (un->un_fileno > 0 || (un->un_fileno == 0 && un->un_blkno != 0)) {
6697 		/*
6698 		 * XXX: put in a bitch message about attempting to
6699 		 * XXX: change density past BOT.
6700 		 */
6701 		goto exit;
6702 	}
6703 
6704 	/*
6705 	 * If we're going to be writing, we set the density
6706 	 */
6707 	if (rw == 0 || rw == B_WRITE) {
6708 		/* un_curdens is used as an index into densities table */
6709 		un->un_curdens = MT_DENSITY(un->un_dev);
6710 		if (st_set_density(dev)) {
6711 			rval = -1;
6712 		}
6713 		goto exit;
6714 	}
6715 
6716 	/*
6717 	 * If density is known already,
6718 	 * we don't have to get it again.(?)
6719 	 */
6720 	if (!un->un_density_known) {
6721 		if (st_get_density(dev)) {
6722 			rval = -1;
6723 		}
6724 	}
6725 
6726 exit:
6727 	ASSERT(mutex_owned(ST_MUTEX));
6728 	return (rval);
6729 }
6730 
6731 
6732 /*
6733  * Try to determine density. We do this by attempting to read the
6734  * first record off the tape, cycling through the available density
6735  * codes as we go.
6736  */
6737 
6738 static int
6739 st_get_density(dev_t dev)
6740 {
6741 	int succes = 0, rval = -1, i;
6742 	uint_t size;
6743 	uchar_t dens, olddens;
6744 
6745 	GET_SOFT_STATE(dev);
6746 
6747 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6748 	    "st_get_density(dev = 0x%lx)\n", dev);
6749 
6750 	ASSERT(mutex_owned(ST_MUTEX));
6751 
6752 	/*
6753 	 * If Auto Density override is enabled The drive has
6754 	 * only one density and there is no point in attempting
6755 	 * find the correct one.
6756 	 *
6757 	 * Since most modern drives auto detect the density
6758 	 * and format of the recorded media before they come
6759 	 * ready. What this function does is a legacy behavior
6760 	 * and modern drives not only don't need it, The backup
6761 	 * utilities that do positioning via uscsi find the un-
6762 	 * expected rewinds problematic.
6763 	 *
6764 	 * The drives that need this are old reel to reel devices.
6765 	 * I took a swag and said they must be scsi-1 or older.
6766 	 * I don't beleave there will any of the newer devices
6767 	 * that need this. There will be some scsi-1 devices that
6768 	 * don't need this but I don't think they will be using the
6769 	 * BIG aftermarket backup and restore utilitys.
6770 	 */
6771 	if ((un->un_dp->options & ST_AUTODEN_OVERRIDE) ||
6772 	    (un->un_sd->sd_inq->inq_ansi > 1)) {
6773 		un->un_density_known = 1;
6774 		rval = 0;
6775 		goto exit;
6776 	}
6777 
6778 	/*
6779 	 * This will only work on variable record length tapes
6780 	 * if and only if all variable record length tapes autodensity
6781 	 * select.
6782 	 */
6783 	size = (unsigned)(un->un_dp->bsize ? un->un_dp->bsize : SECSIZE);
6784 	un->un_tmpbuf = kmem_alloc(size, KM_SLEEP);
6785 
6786 	/*
6787 	 * Start at the specified density
6788 	 */
6789 
6790 	dens = olddens = un->un_curdens = MT_DENSITY(un->un_dev);
6791 
6792 	for (i = 0; i < NDENSITIES; i++, ((un->un_curdens == NDENSITIES - 1) ?
6793 					(un->un_curdens = 0) :
6794 					(un->un_curdens += 1))) {
6795 		/*
6796 		 * If we've done this density before,
6797 		 * don't bother to do it again.
6798 		 */
6799 		dens = un->un_dp->densities[un->un_curdens];
6800 		if (i > 0 && dens == olddens)
6801 			continue;
6802 		olddens = dens;
6803 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
6804 		    "trying density 0x%x\n", dens);
6805 		if (st_set_density(dev)) {
6806 			continue;
6807 		}
6808 
6809 		/*
6810 		 * XXX - the creates lots of headaches and slowdowns - must
6811 		 * fix.
6812 		 */
6813 		succes = (st_cmd(dev, SCMD_READ, (int)size, SYNC_CMD) == 0);
6814 		if (st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD)) {
6815 			break;
6816 		}
6817 		if (succes) {
6818 			st_init(un);
6819 			rval = 0;
6820 			un->un_density_known = 1;
6821 			break;
6822 		}
6823 	}
6824 	kmem_free(un->un_tmpbuf, size);
6825 	un->un_tmpbuf = 0;
6826 
6827 exit:
6828 	ASSERT(mutex_owned(ST_MUTEX));
6829 	return (rval);
6830 }
6831 
6832 static int
6833 st_set_density(dev_t dev)
6834 {
6835 	int rval = 0;
6836 
6837 	GET_SOFT_STATE(dev);
6838 
6839 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6840 	    "st_set_density(dev = 0x%lx): density = 0x%x\n", dev,
6841 	    un->un_dp->densities[un->un_curdens]);
6842 
6843 	ASSERT(mutex_owned(ST_MUTEX));
6844 
6845 	un->un_mspl->density = un->un_dp->densities[un->un_curdens];
6846 
6847 	if ((un->un_dp->options & ST_AUTODEN_OVERRIDE) == 0) {
6848 		/*
6849 		 * If auto density override is not set, Use mode select
6850 		 * to set density and compression.
6851 		 */
6852 		if (st_modeselect(un)) {
6853 			rval = -1;
6854 		}
6855 	} else if ((un->un_dp->options & ST_MODE_SEL_COMP) != 0) {
6856 		/*
6857 		 * If auto density and mode select compression are set,
6858 		 * This is a drive with one density code but compression
6859 		 * can be enabled or disabled.
6860 		 * Set compression but no need to set density.
6861 		 */
6862 		rval = st_set_compression(un);
6863 		if ((rval != 0) && (rval != EALREADY)) {
6864 			rval = -1;
6865 		} else {
6866 			rval = 0;
6867 		}
6868 	}
6869 
6870 	/* If sucessful set density and/or compression, mark density known */
6871 	if (rval == 0) {
6872 		un->un_density_known = 1;
6873 	}
6874 
6875 	ASSERT(mutex_owned(ST_MUTEX));
6876 	return (rval);
6877 }
6878 
6879 static int
6880 st_loadtape(dev_t dev)
6881 {
6882 	int rval;
6883 
6884 	GET_SOFT_STATE(dev);
6885 
6886 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6887 	    "st_loadtape(dev = 0x%lx)\n", dev);
6888 
6889 	ASSERT(mutex_owned(ST_MUTEX));
6890 
6891 	/*
6892 	 * 'LOAD' the tape to BOT by rewinding
6893 	 */
6894 	rval = st_cmd(dev, SCMD_REWIND, 1, SYNC_CMD);
6895 	if (rval == 0) {
6896 		st_init(un);
6897 		un->un_density_known = 0;
6898 	}
6899 
6900 	ASSERT(mutex_owned(ST_MUTEX));
6901 	return (rval);
6902 }
6903 
6904 
6905 /*
6906  * Note: QIC devices aren't so smart.  If you try to append
6907  * after EOM, the write can fail because the device doesn't know
6908  * it's at EOM.	 In that case, issue a read.  The read should fail
6909  * because there's no data, but the device knows it's at EOM,
6910  * so a subsequent write should succeed.  To further confuse matters,
6911  * the target returns the same error if the tape is positioned
6912  * such that a write would overwrite existing data.  That's why
6913  * we have to do the append test.  A read in the middle of
6914  * recorded data would succeed, thus indicating we're attempting
6915  * something illegal.
6916  */
6917 
6918 void bp_mapin(struct buf *bp);
6919 
6920 static void
6921 st_test_append(struct buf *bp)
6922 {
6923 	dev_t dev = bp->b_edev;
6924 	struct scsi_tape *un;
6925 	uchar_t status;
6926 	unsigned bcount;
6927 
6928 	un = ddi_get_soft_state(st_state, MTUNIT(dev));
6929 
6930 	ASSERT(mutex_owned(ST_MUTEX));
6931 
6932 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
6933 	    "st_test_append(): fileno %d\n", un->un_fileno);
6934 
6935 	un->un_laststate = un->un_state;
6936 	un->un_state = ST_STATE_APPEND_TESTING;
6937 	un->un_test_append = 0;
6938 
6939 	/*
6940 	 * first, map in the buffer, because we're doing a double write --
6941 	 * first into the kernel, then onto the tape.
6942 	 */
6943 	bp_mapin(bp);
6944 
6945 	/*
6946 	 * get a copy of the data....
6947 	 */
6948 	un->un_tmpbuf = kmem_alloc((unsigned)bp->b_bcount, KM_SLEEP);
6949 	bcopy(bp->b_un.b_addr, un->un_tmpbuf, (uint_t)bp->b_bcount);
6950 
6951 	/*
6952 	 * attempt the write..
6953 	 */
6954 
6955 	if (st_cmd(dev, (int)SCMD_WRITE, (int)bp->b_bcount, SYNC_CMD) == 0) {
6956 success:
6957 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
6958 		    "append write succeeded\n");
6959 		bp->b_resid = un->un_sbufp->b_resid;
6960 		mutex_exit(ST_MUTEX);
6961 		bcount = (unsigned)bp->b_bcount;
6962 		biodone(bp);
6963 		mutex_enter(ST_MUTEX);
6964 		un->un_laststate = un->un_state;
6965 		un->un_state = ST_STATE_OPEN;
6966 		kmem_free(un->un_tmpbuf, bcount);
6967 		un->un_tmpbuf = NULL;
6968 		return;
6969 	}
6970 
6971 	/*
6972 	 * The append failed. Do a short read. If that fails,  we are at EOM
6973 	 * so we can retry the write command. If that succeeds, than we're
6974 	 * all screwed up (the controller reported a real error).
6975 	 *
6976 	 * XXX: should the dummy read be > SECSIZE? should it be the device's
6977 	 * XXX: block size?
6978 	 *
6979 	 */
6980 	status = un->un_status;
6981 	un->un_status = 0;
6982 	(void) st_cmd(dev, SCMD_READ, SECSIZE, SYNC_CMD);
6983 	if (un->un_status == KEY_BLANK_CHECK) {
6984 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
6985 		    "append at EOM\n");
6986 		/*
6987 		 * Okay- the read failed. We should actually have confused
6988 		 * the controller enough to allow writing. In any case, the
6989 		 * i/o is on its own from here on out.
6990 		 */
6991 		un->un_laststate = un->un_state;
6992 		un->un_state = ST_STATE_OPEN;
6993 		bcopy(bp->b_un.b_addr, un->un_tmpbuf, (uint_t)bp->b_bcount);
6994 		if (st_cmd(dev, (int)SCMD_WRITE, (int)bp->b_bcount,
6995 		    SYNC_CMD) == 0) {
6996 			goto success;
6997 		}
6998 	}
6999 
7000 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7001 	    "append write failed- not at EOM\n");
7002 	bp->b_resid = bp->b_bcount;
7003 	st_bioerror(bp, EIO);
7004 
7005 	ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
7006 	    "st_test_append : EIO : append write failed - not at EOM");
7007 
7008 	/*
7009 	 * backspace one record to get back to where we were
7010 	 */
7011 	if (st_cmd(dev, SCMD_SPACE, Blk(-1), SYNC_CMD)) {
7012 		un->un_fileno = -1;
7013 	}
7014 
7015 	un->un_err_resid = bp->b_resid;
7016 	un->un_status = status;
7017 
7018 	/*
7019 	 * Note: biodone will do a bp_mapout()
7020 	 */
7021 	mutex_exit(ST_MUTEX);
7022 	bcount = (unsigned)bp->b_bcount;
7023 	biodone(bp);
7024 	mutex_enter(ST_MUTEX);
7025 	un->un_laststate = un->un_state;
7026 	un->un_state = ST_STATE_OPEN_PENDING_IO;
7027 	kmem_free(un->un_tmpbuf, bcount);
7028 	un->un_tmpbuf = NULL;
7029 }
7030 
7031 /*
7032  * Special command handler
7033  */
7034 
7035 /*
7036  * common st_cmd code. The fourth parameter states
7037  * whether the caller wishes to await the results
7038  * Note the release of the mutex during most of the function
7039  */
7040 static int
7041 st_cmd(dev_t dev, int com, int count, int wait)
7042 {
7043 	struct buf *bp;
7044 	int err;
7045 
7046 	GET_SOFT_STATE(dev);
7047 
7048 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
7049 	    "st_cmd(dev = 0x%lx, com = 0x%x, count = %x, wait = %d)\n",
7050 	    dev, com, count, wait);
7051 
7052 	ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex));
7053 	ASSERT(mutex_owned(ST_MUTEX));
7054 
7055 #ifdef STDEBUG
7056 	if (st_debug)
7057 		st_debug_cmds(un, com, count, wait);
7058 #endif
7059 
7060 	/* check to see if this command requires the drive to be reserved */
7061 	err = st_check_cmd_for_need_to_reserve(un, com, count);
7062 
7063 	if (err) {
7064 		return (err);
7065 	}
7066 
7067 	while (un->un_sbuf_busy)
7068 		cv_wait(&un->un_sbuf_cv, ST_MUTEX);
7069 	un->un_sbuf_busy = 1;
7070 
7071 	bp = un->un_sbufp;
7072 	bzero(bp, sizeof (buf_t));
7073 
7074 	bp->b_flags = (wait) ? B_BUSY : B_BUSY|B_ASYNC;
7075 
7076 	/*
7077 	 * Set count to the actual size of the data tranfer.
7078 	 * For commands with no data transfer, set bp->b_bcount
7079 	 * to the value to be used when constructing the
7080 	 * cdb in st_make_cmd().
7081 	 */
7082 	switch (com) {
7083 	case SCMD_READ:
7084 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7085 		    "special read %d\n", count);
7086 		bp->b_flags |= B_READ;
7087 		bp->b_un.b_addr = un->un_tmpbuf;
7088 		break;
7089 
7090 	case SCMD_WRITE:
7091 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7092 		    "special write %d\n", count);
7093 		bp->b_un.b_addr = un->un_tmpbuf;
7094 		break;
7095 
7096 	case SCMD_WRITE_FILE_MARK:
7097 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7098 		    "write %d file marks\n", count);
7099 		bp->b_bcount = count;
7100 		count = 0;
7101 		break;
7102 
7103 	case SCMD_REWIND:
7104 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "rewind\n");
7105 		bp->b_bcount = 0;
7106 		count = 0;
7107 		break;
7108 
7109 	case SCMD_SPACE:
7110 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "space\n");
7111 		bp->b_bcount = count;
7112 		count = 0;
7113 		break;
7114 
7115 	case SCMD_RESERVE:
7116 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "reserve");
7117 		bp->b_bcount = 0;
7118 		count = 0;
7119 		break;
7120 
7121 	case SCMD_RELEASE:
7122 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "release");
7123 		bp->b_bcount = 0;
7124 		count = 0;
7125 		break;
7126 
7127 	case SCMD_LOAD:
7128 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7129 		    "%s tape\n", (count) ? "load" : "unload");
7130 		bp->b_bcount = count;
7131 		count = 0;
7132 		break;
7133 
7134 	case SCMD_ERASE:
7135 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7136 		    "erase tape\n");
7137 		bp->b_bcount = 0;
7138 		count = 0;
7139 		break;
7140 
7141 	case SCMD_MODE_SENSE:
7142 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7143 		    "mode sense\n");
7144 		bp->b_flags |= B_READ;
7145 		bp->b_un.b_addr = (caddr_t)(un->un_mspl);
7146 		break;
7147 
7148 	case SCMD_MODE_SELECT:
7149 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7150 		    "mode select\n");
7151 		bp->b_un.b_addr = (caddr_t)(un->un_mspl);
7152 		break;
7153 
7154 	case SCMD_READ_BLKLIM:
7155 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7156 		    "read block limits\n");
7157 		bp->b_flags |= B_READ;
7158 		bp->b_un.b_addr = (caddr_t)(un->un_rbl);
7159 		break;
7160 
7161 	case SCMD_TEST_UNIT_READY:
7162 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7163 		    "test unit ready\n");
7164 		bp->b_bcount = 0;
7165 		count = 0;
7166 		break;
7167 	default:
7168 		ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
7169 		    "Unhandled scsi command 0x%x in st_cmd()\n", com);
7170 	}
7171 
7172 	mutex_exit(ST_MUTEX);
7173 
7174 	if (count > 0) {
7175 		/*
7176 		 * We're going to do actual I/O.
7177 		 * Set things up for physio.
7178 		 */
7179 		struct iovec aiov;
7180 		struct uio auio;
7181 		struct uio *uio = &auio;
7182 
7183 		bzero(&auio, sizeof (struct uio));
7184 		bzero(&aiov, sizeof (struct iovec));
7185 		aiov.iov_base = bp->b_un.b_addr;
7186 		aiov.iov_len = count;
7187 
7188 		uio->uio_iov = &aiov;
7189 		uio->uio_iovcnt = 1;
7190 		uio->uio_resid = aiov.iov_len;
7191 		uio->uio_segflg = UIO_SYSSPACE;
7192 
7193 		/*
7194 		 * Let physio do the rest...
7195 		 */
7196 		bp->b_forw = (struct buf *)(uintptr_t)com;
7197 		bp->b_back = NULL;
7198 		err = physio(st_strategy, bp, dev,
7199 			(bp->b_flags & B_READ) ? B_READ : B_WRITE,
7200 			st_minphys, uio);
7201 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7202 		    "st_cmd: physio returns %d\n", err);
7203 	} else {
7204 		/*
7205 		 * Mimic physio
7206 		 */
7207 		bp->b_forw = (struct buf *)(uintptr_t)com;
7208 		bp->b_back = NULL;
7209 		bp->b_edev = dev;
7210 		bp->b_dev = cmpdev(dev);
7211 		bp->b_blkno = 0;
7212 		bp->b_resid = 0;
7213 		(void) st_strategy(bp);
7214 		if (!wait) {
7215 			/*
7216 			 * This is an async command- the caller won't wait
7217 			 * and doesn't care about errors.
7218 			 */
7219 			mutex_enter(ST_MUTEX);
7220 			return (0);
7221 		}
7222 
7223 		/*
7224 		 * BugTraq #4260046
7225 		 * ----------------
7226 		 * Restore Solaris 2.5.1 behavior, namely call biowait
7227 		 * unconditionally. The old comment said...
7228 		 *
7229 		 * "if strategy was flagged with  persistent errors, we would
7230 		 *  have an error here, and the bp would never be sent, so we
7231 		 *  don't want to wait on a bp that was never sent...or hang"
7232 		 *
7233 		 * The new rationale, courtesy of Chitrank...
7234 		 *
7235 		 * "we should unconditionally biowait() here because
7236 		 *  st_strategy() will do a biodone() in the persistent error
7237 		 *  case and the following biowait() will return immediately.
7238 		 *  If not, in the case of "errors after pkt alloc" in
7239 		 *  st_start(), we will not biowait here which will cause the
7240 		 *  next biowait() to return immediately which will cause
7241 		 *  us to send out the next command. In the case where both of
7242 		 *  these use the sbuf, when the first command completes we'll
7243 		 *  free the packet attached to sbuf and the same pkt will
7244 		 *  get freed again when we complete the second command.
7245 		 *  see esc 518987.  BTW, it is necessary to do biodone() in
7246 		 *  st_start() for the pkt alloc failure case because physio()
7247 		 *  does biowait() and will hang if we don't do biodone()"
7248 		 */
7249 
7250 		err = biowait(bp);
7251 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7252 		    "st_cmd: biowait returns %d\n", err);
7253 	}
7254 	mutex_enter(ST_MUTEX);
7255 
7256 	un->un_sbuf_busy = 0;
7257 	cv_signal(&un->un_sbuf_cv);
7258 	return (err);
7259 }
7260 
7261 static int
7262 st_set_compression(struct scsi_tape *un)
7263 {
7264 	int rval;
7265 	int turn_compression_on;
7266 	minor_t minor;
7267 
7268 	/*
7269 	 * Drive either dosn't have compression or it is controlled with
7270 	 * special density codes. Return ENOTTY so caller
7271 	 * knows nothing was done.
7272 	 */
7273 	if ((un->un_dp->options & ST_MODE_SEL_COMP) == 0) {
7274 		un->un_comp_page = 0;
7275 		return (ENOTTY);
7276 	}
7277 
7278 	/* set compression based on minor node opened */
7279 	minor = MT_DENSITY(un->un_dev);
7280 
7281 	/*
7282 	 * If this the compression density or
7283 	 * the drive has two densities and uses mode select for
7284 	 * control of compression turn on compression for MT_DENSITY2
7285 	 * as well.
7286 	 */
7287 	if ((minor == ST_COMPRESSION_DENSITY) ||
7288 	    (minor == MT_DENSITY(MT_DENSITY2)) &&
7289 	    (un->un_dp->densities[0] == un->un_dp->densities[1]) &&
7290 	    (un->un_dp->densities[2] == un->un_dp->densities[3]) &&
7291 	    (un->un_dp->densities[0] != un->un_dp->densities[2])) {
7292 
7293 		turn_compression_on = 1;
7294 	} else {
7295 		turn_compression_on = 0;
7296 	}
7297 
7298 	un->un_mspl->high_bl = (uchar_t)(un->un_bsize >> 16);
7299 	un->un_mspl->mid_bl  = (uchar_t)(un->un_bsize >> 8);
7300 	un->un_mspl->low_bl  = (uchar_t)(un->un_bsize);
7301 
7302 	/*
7303 	 * Need to determine which page does the device use for compression.
7304 	 * First try the data compression page. If this fails try the device
7305 	 * configuration page
7306 	 */
7307 
7308 	if ((un->un_comp_page & ST_DEV_DATACOMP_PAGE) == ST_DEV_DATACOMP_PAGE) {
7309 		rval = st_set_datacomp_page(un, turn_compression_on);
7310 		if (rval == EALREADY) {
7311 			return (rval);
7312 		}
7313 		if (rval != 0) {
7314 			if (un->un_status == KEY_ILLEGAL_REQUEST) {
7315 				/*
7316 				 * This device does not support data
7317 				 * compression page
7318 				 */
7319 				un->un_comp_page = ST_DEV_CONFIG_PAGE;
7320 			} else if (un->un_state >= ST_STATE_OPEN) {
7321 				un->un_fileno = -1;
7322 				rval = EIO;
7323 			} else {
7324 				rval = -1;
7325 			}
7326 		} else {
7327 			un->un_comp_page = ST_DEV_DATACOMP_PAGE;
7328 		}
7329 	}
7330 
7331 	if ((un->un_comp_page & ST_DEV_CONFIG_PAGE) == ST_DEV_CONFIG_PAGE) {
7332 		rval = st_set_devconfig_page(un, turn_compression_on);
7333 		if (rval == EALREADY) {
7334 			return (rval);
7335 		}
7336 		if (rval != 0) {
7337 			if (un->un_status == KEY_ILLEGAL_REQUEST) {
7338 				/*
7339 				 * This device does not support
7340 				 * compression at all advice the
7341 				 * user and unset ST_MODE_SEL_COMP
7342 				 */
7343 				un->un_dp->options &= ~ST_MODE_SEL_COMP;
7344 				un->un_comp_page = 0;
7345 				scsi_log(ST_DEVINFO, st_label, CE_NOTE,
7346 				    "Device Does Not Support Compression\n");
7347 			} else if (un->un_state >= ST_STATE_OPEN) {
7348 				un->un_fileno = -1;
7349 				rval = EIO;
7350 			} else {
7351 				rval = -1;
7352 			}
7353 		}
7354 	}
7355 
7356 	return (rval);
7357 }
7358 
7359 /*
7360  * set or unset compression thru device configuration page.
7361  */
7362 static int
7363 st_set_devconfig_page(struct scsi_tape *un, int compression_on)
7364 {
7365 	unsigned char cflag;
7366 	int rval = 0;
7367 
7368 	ASSERT(mutex_owned(ST_MUTEX));
7369 
7370 	/*
7371 	 * Figure what to set compression flag to.
7372 	 */
7373 	if (compression_on) {
7374 		/* They have selected a compression node */
7375 		if (un->un_dp->type == ST_TYPE_FUJI) {
7376 			cflag = 0x84;   /* use EDRC */
7377 		} else {
7378 			cflag = ST_DEV_CONFIG_DEF_COMP;
7379 		}
7380 	} else {
7381 		cflag = ST_DEV_CONFIG_NO_COMP;
7382 	}
7383 
7384 	/*
7385 	 * If compression is already set the way it was requested.
7386 	 * And if this not the first time we has tried.
7387 	 */
7388 	if ((cflag == un->un_mspl->page.dev.comp_alg) &&
7389 	    (un->un_comp_page == ST_DEV_DATACOMP_PAGE)) {
7390 		return (EALREADY);
7391 	}
7392 
7393 	un->un_mspl->page.dev.comp_alg = cflag;
7394 	/*
7395 	 * need to send mode select even if correct compression is
7396 	 * already set since need to set density code
7397 	 */
7398 
7399 #ifdef STDEBUG
7400 	if (st_debug >= 6) {
7401 		st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG,
7402 		    "st_set_devconfig_page: sense data for mode select",
7403 		    (char *)un->un_mspl, sizeof (struct seq_mode));
7404 	}
7405 #endif
7406 	rval = st_gen_mode_select(un, un->un_mspl, sizeof (struct seq_mode));
7407 
7408 	return (rval);
7409 }
7410 
7411 /*
7412  * set/reset compression bit thru data compression page
7413  */
7414 static int
7415 st_set_datacomp_page(struct scsi_tape *un, int compression_on)
7416 {
7417 	int compression_on_already;
7418 	int rval = 0;
7419 
7420 	ASSERT(mutex_owned(ST_MUTEX));
7421 
7422 	/*
7423 	 * If drive is not capable of compression (at this time)
7424 	 * return EALREADY so caller doesn't think that this page
7425 	 * is not supported. This check is for drives that can
7426 	 * disable compression from the front panel or configuration.
7427 	 * I doubt that a drive that supports this page is not really
7428 	 * capable of compression.
7429 	 */
7430 	if (un->un_mspl->page.comp.dcc == 0) {
7431 		return (EALREADY);
7432 	}
7433 
7434 	/* See if compression currently turned on */
7435 	if (un->un_mspl->page.comp.dce) {
7436 		compression_on_already = 1;
7437 	} else {
7438 		compression_on_already = 0;
7439 	}
7440 
7441 	/*
7442 	 * If compression is already set the way it was requested.
7443 	 * And if this not the first time we has tried.
7444 	 */
7445 	if ((compression_on == compression_on_already) &&
7446 	    (un->un_comp_page == ST_DEV_DATACOMP_PAGE)) {
7447 		return (EALREADY);
7448 	}
7449 
7450 	/*
7451 	 * if we are already set to the appropriate compression
7452 	 * mode, don't set it again
7453 	 */
7454 	if (compression_on) {
7455 		/* compression selected */
7456 		un->un_mspl->page.comp.dce = 1;
7457 	} else {
7458 		un->un_mspl->page.comp.dce = 0;
7459 	}
7460 
7461 
7462 #ifdef STDEBUG
7463 	if (st_debug >= 6) {
7464 		st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG,
7465 		    "st_set_datacomp_page: sense data for mode select",
7466 		    (char *)un->un_mspl, sizeof (struct seq_mode));
7467 	}
7468 #endif
7469 	rval = st_gen_mode_select(un, un->un_mspl, sizeof (struct seq_mode));
7470 
7471 	return (rval);
7472 }
7473 
7474 static int
7475 st_modesense(struct scsi_tape *un)
7476 {
7477 	int rval;
7478 	uchar_t page;
7479 
7480 	page = un->un_comp_page;
7481 
7482 	switch (page) {
7483 	case ST_DEV_DATACOMP_PAGE:
7484 	case ST_DEV_CONFIG_PAGE: /* fall through */
7485 		rval = st_gen_mode_sense(un, page, un->un_mspl,
7486 		    sizeof (struct seq_mode));
7487 		break;
7488 
7489 	case ST_DEV_DATACOMP_PAGE | ST_DEV_CONFIG_PAGE:
7490 		if (un->un_dp->options & ST_MODE_SEL_COMP) {
7491 			page = ST_DEV_DATACOMP_PAGE;
7492 			rval = st_gen_mode_sense(un, page, un->un_mspl,
7493 			    sizeof (struct seq_mode));
7494 			if (rval == 0 && un->un_mspl->page_code == page) {
7495 				un->un_comp_page = page;
7496 				break;
7497 			}
7498 			page = ST_DEV_CONFIG_PAGE;
7499 			rval = st_gen_mode_sense(un, page, un->un_mspl,
7500 			    sizeof (struct seq_mode));
7501 			if (rval == 0 && un->un_mspl->page_code == page) {
7502 				un->un_comp_page = page;
7503 				break;
7504 			}
7505 			un->un_dp->options &= ~ST_MODE_SEL_COMP;
7506 			un->un_comp_page = 0;
7507 		} else {
7508 			un->un_comp_page = 0;
7509 		}
7510 
7511 	default:	/* fall through */
7512 		rval = st_cmd(un->un_dev, SCMD_MODE_SENSE, MSIZE, SYNC_CMD);
7513 	}
7514 	return (rval);
7515 }
7516 
7517 static int
7518 st_modeselect(struct scsi_tape *un)
7519 {
7520 	int rval = 0;
7521 	int ix;
7522 
7523 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
7524 	    "st_modeselect(dev = 0x%lx): density = 0x%x\n",
7525 	    un->un_dev, un->un_mspl->density);
7526 
7527 	ASSERT(mutex_owned(ST_MUTEX));
7528 
7529 	/*
7530 	 * The parameter list should be the same for all of the
7531 	 * cases that follow so set them here
7532 	 *
7533 	 * Try mode select first if if fails set fields manually
7534 	 */
7535 	rval = st_modesense(un);
7536 	if (rval != 0) {
7537 		ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN,
7538 		    "st_modeselect: First mode sense failed\n");
7539 		un->un_mspl->bd_len  = 8;
7540 		un->un_mspl->high_nb = 0;
7541 		un->un_mspl->mid_nb  = 0;
7542 		un->un_mspl->low_nb  = 0;
7543 	}
7544 	un->un_mspl->high_bl = (uchar_t)(un->un_bsize >> 16);
7545 	un->un_mspl->mid_bl  = (uchar_t)(un->un_bsize >> 8);
7546 	un->un_mspl->low_bl  = (uchar_t)(un->un_bsize);
7547 
7548 
7549 	/*
7550 	 * If configured to use a specific density code for a media type.
7551 	 * curdens is previously set by the minor node opened.
7552 	 * If the media type doesn't match the minor node we change it so it
7553 	 * looks like the correct one was opened.
7554 	 */
7555 	if (un->un_dp->options & ST_KNOWS_MEDIA) {
7556 		uchar_t best;
7557 
7558 		for (best = 0xff, ix = 0; ix < NDENSITIES; ix++) {
7559 			if (un->un_mspl->media_type ==
7560 			    un->un_dp->mediatype[ix]) {
7561 				best = ix;
7562 				/*
7563 				 * It matches but it might not be the only one.
7564 				 * Use the highest matching media type but not
7565 				 * to exceed the density selected by the open.
7566 				 */
7567 				if (ix < un->un_curdens) {
7568 					continue;
7569 				}
7570 				un->un_curdens = ix;
7571 				break;
7572 			}
7573 		}
7574 		/* If a match was found best will not be 0xff any more */
7575 		if (best < NDENSITIES) {
7576 			ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN,
7577 			    "found media 0x%X using density 0x%X\n",
7578 			    un->un_mspl->media_type,
7579 			    un->un_dp->densities[best]);
7580 		}
7581 
7582 		un->un_mspl->density = un->un_dp->densities[best];
7583 
7584 	} else {
7585 		/* Otherwise set density based on minor node opened */
7586 		un->un_mspl->density = un->un_dp->densities[un->un_curdens];
7587 	}
7588 
7589 	if (un->un_dp->options & ST_NOBUF) {
7590 		un->un_mspl->bufm = 0;
7591 	} else {
7592 		un->un_mspl->bufm = 1;
7593 	}
7594 
7595 	rval = st_set_compression(un);
7596 
7597 	/*
7598 	 * If st_set_compression returned invalid or already it
7599 	 * found no need to do the mode select.
7600 	 * So do it here.
7601 	 */
7602 	if ((rval == ENOTTY) || (rval == EALREADY)) {
7603 
7604 		/* Zero non-writeable fields */
7605 		un->un_mspl->data_len = 0;
7606 		un->un_mspl->media_type = 0;
7607 		un->un_mspl->wp = 0;
7608 
7609 		/* need to set the density code */
7610 		rval = st_cmd(un->un_dev, SCMD_MODE_SELECT, MSIZE, SYNC_CMD);
7611 		if (rval != 0) {
7612 			if (un->un_state >= ST_STATE_OPEN) {
7613 				ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
7614 				    "unable to set tape mode\n");
7615 				un->un_fileno = -1;
7616 				rval = EIO;
7617 			} else {
7618 				rval = -1;
7619 			}
7620 		}
7621 	}
7622 
7623 	/*
7624 	 * The spec recommends to send a mode sense after a mode select
7625 	 */
7626 	(void) st_modesense(un);
7627 
7628 	ASSERT(mutex_owned(ST_MUTEX));
7629 
7630 	return (rval);
7631 }
7632 
7633 /*
7634  * st_gen_mode_sense
7635  *
7636  * generic mode sense.. it allows for any page
7637  */
7638 static int
7639 st_gen_mode_sense(struct scsi_tape *un, int page, struct seq_mode *page_data,
7640     int page_size)
7641 {
7642 
7643 	int r;
7644 	char	cdb[CDB_GROUP0];
7645 	struct uscsi_cmd *com;
7646 
7647 	com = kmem_zalloc(sizeof (*com), KM_SLEEP);
7648 
7649 	bzero(cdb, CDB_GROUP0);
7650 	cdb[0] = SCMD_MODE_SENSE;
7651 	cdb[2] = (char)page;
7652 	cdb[4] = (char)page_size;
7653 
7654 	com->uscsi_cdb = cdb;
7655 	com->uscsi_cdblen = CDB_GROUP0;
7656 	com->uscsi_bufaddr = (caddr_t)page_data;
7657 	com->uscsi_buflen = page_size;
7658 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
7659 	com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT |
7660 			    USCSI_READ | USCSI_RQENABLE;
7661 
7662 	r = st_ioctl_cmd(un->un_dev, com, UIO_SYSSPACE, UIO_SYSSPACE,
7663 		UIO_SYSSPACE);
7664 	kmem_free(com, sizeof (*com));
7665 	return (r);
7666 }
7667 
7668 /*
7669  * st_gen_mode_select
7670  *
7671  * generic mode select.. it allows for any page
7672  */
7673 static int
7674 st_gen_mode_select(struct scsi_tape *un, struct seq_mode *page_data,
7675     int page_size)
7676 {
7677 
7678 	int r;
7679 	char cdb[CDB_GROUP0];
7680 	struct uscsi_cmd *com;
7681 
7682 	/* Zero non-writeable fields */
7683 	page_data->data_len = 0;
7684 	page_data->media_type = 0;
7685 	page_data->wp = 0;
7686 
7687 	/*
7688 	 * If mode select has any page data, zero the ps (Page Savable) bit.
7689 	 */
7690 	if (page_size > MSIZE) {
7691 		page_data->ps = 0;
7692 	}
7693 
7694 
7695 	com = kmem_zalloc(sizeof (*com), KM_SLEEP);
7696 
7697 	/*
7698 	 * then, do a mode select to set what ever info
7699 	 */
7700 	bzero(cdb, CDB_GROUP0);
7701 	cdb[0] = SCMD_MODE_SELECT;
7702 	cdb[1] = 0x10;		/* set PF bit for many third party drives */
7703 	cdb[4] = (char)page_size;
7704 
7705 	com->uscsi_cdb = cdb;
7706 	com->uscsi_cdblen = CDB_GROUP0;
7707 	com->uscsi_bufaddr = (caddr_t)page_data;
7708 	com->uscsi_buflen = page_size;
7709 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
7710 	com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT
7711 		| USCSI_WRITE | USCSI_RQENABLE;
7712 
7713 	r = st_ioctl_cmd(un->un_dev, com, UIO_SYSSPACE, UIO_SYSSPACE,
7714 		UIO_SYSSPACE);
7715 
7716 	kmem_free(com, sizeof (*com));
7717 	return (r);
7718 }
7719 
7720 /*
7721  * Changes devices blocksize and bsize to requested blocksize nblksz.
7722  * Returns returned value from first failed call or zero on success.
7723  */
7724 static int
7725 st_change_block_size(dev_t dev, uint32_t nblksz)
7726 {
7727 	struct seq_mode *current;
7728 	int rval;
7729 	uint32_t oldblksz;
7730 
7731 	GET_SOFT_STATE(dev);
7732 
7733 	current = kmem_zalloc(MSIZE, KM_SLEEP);
7734 
7735 	/* Read current settings */
7736 	rval = st_gen_mode_sense(un, 0, current, MSIZE);
7737 	if (rval != 0) {
7738 		scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
7739 		    "mode sense for change block size failed: rval = %d", rval);
7740 		goto finish;
7741 	}
7742 
7743 	/* Figure the current block size */
7744 	oldblksz =
7745 	    (current->high_bl << 16) |
7746 	    (current->mid_bl << 8) |
7747 	    (current->low_bl);
7748 
7749 	/* If current block size is the same as requested were done */
7750 	if (oldblksz == nblksz) {
7751 		un->un_bsize = nblksz;
7752 		rval = 0;
7753 		goto finish;
7754 	}
7755 
7756 	/* Change to requested block size */
7757 	current->high_bl = (uchar_t)(nblksz >> 16);
7758 	current->mid_bl  = (uchar_t)(nblksz >> 8);
7759 	current->low_bl  = (uchar_t)(nblksz);
7760 
7761 	/* Attempt to change block size */
7762 	rval = st_gen_mode_select(un, current, MSIZE);
7763 	if (rval != 0) {
7764 		scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
7765 		    "Set new block size failed: rval = %d", rval);
7766 		goto finish;
7767 	}
7768 
7769 	/* Read back and verify setting */
7770 	rval = st_modesense(un);
7771 	if (rval == 0) {
7772 		un->un_bsize =
7773 		    (un->un_mspl->high_bl << 16) |
7774 		    (un->un_mspl->mid_bl << 8) |
7775 		    (un->un_mspl->low_bl);
7776 
7777 		if (un->un_bsize != nblksz) {
7778 			scsi_log(ST_DEVINFO, st_label, SCSI_DEBUG,
7779 			    "Blocksize set does not equal requested blocksize"
7780 			    "(read: %u requested: %u)\n", nblksz, un->un_bsize);
7781 			rval = EIO;
7782 		}
7783 	}
7784 finish:
7785 	kmem_free(current, MSIZE);
7786 	return (rval);
7787 }
7788 
7789 
7790 static void
7791 st_init(struct scsi_tape *un)
7792 {
7793 	ASSERT(mutex_owned(ST_MUTEX));
7794 
7795 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
7796 	"st_init(): dev = 0x%lx, will reset fileno, blkno, eof\n", un->un_dev);
7797 
7798 	un->un_blkno = 0;
7799 	un->un_fileno = 0;
7800 	un->un_lastop = ST_OP_NIL;
7801 	un->un_eof = ST_NO_EOF;
7802 	un->un_pwr_mgmt = ST_PWR_NORMAL;
7803 	if (st_error_level != SCSI_ERR_ALL) {
7804 		if (DEBUGGING) {
7805 			st_error_level = SCSI_ERR_ALL;
7806 		} else {
7807 			st_error_level = SCSI_ERR_RETRYABLE;
7808 		}
7809 	}
7810 }
7811 
7812 
7813 static void
7814 st_make_cmd(struct scsi_tape *un, struct buf *bp, int (*func)(caddr_t))
7815 {
7816 	struct scsi_pkt *pkt;
7817 	struct uscsi_cmd *ucmd;
7818 	int count, tval = 0;
7819 	int flags = 0;
7820 	uchar_t com;
7821 	char fixbit;
7822 
7823 	ASSERT(mutex_owned(ST_MUTEX));
7824 
7825 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
7826 	    "st_make_cmd(): dev = 0x%lx\n", un->un_dev);
7827 
7828 
7829 	/*
7830 	 * fixbit is for setting the Fixed Mode and Suppress Incorrect
7831 	 * Length Indicator bits on read/write commands, for setting
7832 	 * the Long bit on erase commands, and for setting the Code
7833 	 * Field bits on space commands.
7834 	 * XXX why do we set lastop here?
7835 	 */
7836 
7837 	if (bp != un->un_sbufp) {		/* regular raw I/O */
7838 		int stat_size = (un->un_arq_enabled ?
7839 			sizeof (struct scsi_arq_status) : 1);
7840 		pkt = scsi_init_pkt(ROUTE, NULL, bp,
7841 		    CDB_GROUP0, stat_size, 0, 0, func, (caddr_t)un);
7842 		if (pkt == NULL) {
7843 			goto exit;
7844 		}
7845 		SET_BP_PKT(bp, pkt);
7846 		if (un->un_bsize == 0) {
7847 			count = bp->b_bcount;
7848 			fixbit = 0;
7849 		} else {
7850 			count = bp->b_bcount / un->un_bsize;
7851 			fixbit = 1;
7852 		}
7853 		if (bp->b_flags & B_READ) {
7854 			com = SCMD_READ;
7855 			un->un_lastop = ST_OP_READ;
7856 			if ((un->un_bsize == 0) && /* Not Fixed Block */
7857 			    (un->un_dp->options & ST_READ_IGNORE_ILI)) {
7858 				fixbit = 2;
7859 			}
7860 		} else {
7861 			com = SCMD_WRITE;
7862 			un->un_lastop = ST_OP_WRITE;
7863 		}
7864 
7865 		tval = un->un_dp->io_timeout;
7866 
7867 		/*
7868 		 * For really large xfers, increase timeout
7869 		 */
7870 		if (bp->b_bcount > (10 * ONE_MEG))
7871 			tval *= bp->b_bcount/(10 * ONE_MEG);
7872 
7873 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7874 		    "%s %ld amt 0x%lx\n", (com == SCMD_WRITE) ?
7875 		    wr_str: rd_str, un->un_blkno, bp->b_bcount);
7876 
7877 	} else if ((ucmd = BP_UCMD(bp)) != NULL) {
7878 		/*
7879 		 * uscsi - build command, allocate scsi resources
7880 		 */
7881 		st_make_uscsi_cmd(un, ucmd, bp, func);
7882 		goto exit;
7883 
7884 	} else {				/* special I/O */
7885 		struct buf *allocbp = NULL;
7886 		int stat_size = (un->un_arq_enabled ?
7887 			sizeof (struct scsi_arq_status) : 1);
7888 
7889 
7890 		com = (uchar_t)(uintptr_t)bp->b_forw;
7891 		count = bp->b_bcount;
7892 
7893 		switch (com) {
7894 		case SCMD_READ:
7895 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7896 			    "special read %d\n", count);
7897 			if (un->un_bsize == 0) {
7898 				fixbit = 2;	/* suppress SILI */
7899 			} else {
7900 				fixbit = 1;	/* Fixed Block Mode */
7901 				count /= un->un_bsize;
7902 			}
7903 			allocbp = bp;
7904 			un->un_lastop = ST_OP_READ;
7905 			tval = un->un_dp->io_timeout;
7906 			break;
7907 
7908 		case SCMD_WRITE:
7909 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7910 			    "special write %d\n", count);
7911 			if (un->un_bsize != 0) {
7912 				fixbit = 1;	/* Fixed Block Mode */
7913 				count /= un->un_bsize;
7914 			} else {
7915 				fixbit = 0;
7916 			}
7917 			allocbp = bp;
7918 			un->un_lastop = ST_OP_WRITE;
7919 			tval = un->un_dp->io_timeout;
7920 			break;
7921 
7922 		case SCMD_WRITE_FILE_MARK:
7923 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7924 			    "write %d file marks\n", count);
7925 			un->un_lastop = ST_OP_WEOF;
7926 			fixbit = 0;
7927 			tval = un->un_dp->io_timeout;
7928 			break;
7929 
7930 		case SCMD_REWIND:
7931 			if (bp->b_flags & B_ASYNC) {
7932 				fixbit = 1;
7933 			} else {
7934 				fixbit = 0;
7935 			}
7936 			count = 0;
7937 			un->un_lastop = ST_OP_CTL;
7938 			tval = un->un_dp->rewind_timeout;
7939 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7940 			    "rewind\n");
7941 			break;
7942 
7943 		case SCMD_SPACE:
7944 			fixbit = Isfmk(count);
7945 			count = (int)space_cnt(count);
7946 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7947 			    "space %d %s from file %d blk %ld\n",
7948 			    count, (fixbit) ? "filemarks" : "records",
7949 			    un->un_fileno, un->un_blkno);
7950 			un->un_lastop = ST_OP_CTL;
7951 			tval = un->un_dp->space_timeout;
7952 			break;
7953 
7954 		case SCMD_LOAD:
7955 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7956 			    "%s tape\n", (count & 1) ? "load" : "unload");
7957 			fixbit = 0;
7958 
7959 			/* Loading or Unloading */
7960 			if (count & 1) {
7961 				tval = un->un_dp->load_timeout;
7962 			} else {
7963 				tval = un->un_dp->unload_timeout;
7964 			}
7965 			/* Is Retension requested */
7966 			if (count & 2) {
7967 				tval += un->un_dp->rewind_timeout;
7968 			}
7969 			un->un_lastop = ST_OP_CTL;
7970 			break;
7971 
7972 		case SCMD_ERASE:
7973 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7974 			    "erase tape\n");
7975 			count = 0;
7976 			/*
7977 			 * We support long erase only
7978 			 */
7979 			fixbit = 1;
7980 			tval = un->un_dp->erase_timeout;
7981 			un->un_lastop = ST_OP_CTL;
7982 			break;
7983 
7984 		case SCMD_MODE_SENSE:
7985 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7986 			    "mode sense\n");
7987 			allocbp = bp;
7988 			fixbit = 0;
7989 			tval = un->un_dp->non_motion_timeout;
7990 			break;
7991 
7992 		case SCMD_MODE_SELECT:
7993 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
7994 			    "mode select\n");
7995 			allocbp = bp;
7996 			fixbit = 0;
7997 			tval = un->un_dp->non_motion_timeout;
7998 			break;
7999 
8000 		case SCMD_RESERVE:
8001 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8002 			    "reserve\n");
8003 			fixbit = 0;
8004 			tval = un->un_dp->non_motion_timeout;
8005 			break;
8006 
8007 		case SCMD_RELEASE:
8008 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8009 			    "release\n");
8010 			fixbit = 0;
8011 			tval = un->un_dp->non_motion_timeout;
8012 			break;
8013 
8014 		case SCMD_READ_BLKLIM:
8015 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8016 			    "read block limits\n");
8017 			allocbp = bp;
8018 			fixbit = count = 0;
8019 			tval = un->un_dp->non_motion_timeout;
8020 			break;
8021 
8022 		case SCMD_TEST_UNIT_READY:
8023 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8024 			    "test unit ready\n");
8025 			fixbit = 0;
8026 			tval = un->un_dp->non_motion_timeout;
8027 			break;
8028 		default:
8029 			ST_DEBUG(ST_DEVINFO, st_label, CE_PANIC,
8030 			    "Unhandled scsi command 0x%x in st_make_cmd()\n",
8031 			    com);
8032 		}
8033 		pkt = scsi_init_pkt(ROUTE, NULL, allocbp,
8034 			CDB_GROUP0, stat_size, 0, 0, func, (caddr_t)un);
8035 		if (pkt == NULL) {
8036 			goto exit;
8037 		}
8038 		if (allocbp)
8039 			ASSERT(geterror(allocbp) == 0);
8040 
8041 	}
8042 
8043 	(void) scsi_setup_cdb((union scsi_cdb *)pkt->pkt_cdbp,
8044 	    com, 0, (uint_t)count, 0);
8045 	FILL_SCSI1_LUN(un->un_sd, pkt);
8046 	/*
8047 	 * Initialize the SILI/Fixed bits of the byte 1 of cdb.
8048 	 */
8049 	((union scsi_cdb *)(pkt->pkt_cdbp))->t_code = fixbit;
8050 	pkt->pkt_flags = flags;
8051 
8052 	/*
8053 	 * If ST_SHORT_FILEMARKS bit is ON for EXABYTE
8054 	 * device, set the Vendor Unique bit to
8055 	 * write Short File Mark.
8056 	 */
8057 	if (com == SCMD_WRITE_FILE_MARK &&
8058 		un->un_dp->options & ST_SHORT_FILEMARKS) {
8059 		switch (un->un_dp->type) {
8060 		case ST_TYPE_EXB8500:
8061 		case ST_TYPE_EXABYTE:
8062 			/*
8063 			 * Now the Vendor Unique bit 7 in Byte 5 of CDB
8064 			 * is set to to write Short File Mark
8065 			 */
8066 			((union scsi_cdb *)pkt->pkt_cdbp)->g0_vu_1 = 1;
8067 			break;
8068 
8069 		default:
8070 			/*
8071 			 * Well, if ST_SHORT_FILEMARKS is set for other
8072 			 * tape drives, it is just ignored
8073 			 */
8074 			break;
8075 		}
8076 	}
8077 	ASSERT(tval);
8078 	pkt->pkt_time = tval;
8079 	pkt->pkt_comp = st_intr;
8080 	pkt->pkt_private = (opaque_t)bp;
8081 	SET_BP_PKT(bp, pkt);
8082 
8083 exit:
8084 	ASSERT(mutex_owned(ST_MUTEX));
8085 }
8086 
8087 
8088 /*
8089  * Build a command based on a uscsi command;
8090  */
8091 static void
8092 st_make_uscsi_cmd(struct scsi_tape *un, struct uscsi_cmd *ucmd,
8093     struct buf *bp, int (*func)(caddr_t))
8094 {
8095 	struct scsi_pkt *pkt;
8096 	caddr_t cdb;
8097 	int	cdblen;
8098 	int stat_size;
8099 
8100 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8101 	    "st_make_uscsi_cmd(): dev = 0x%lx\n", un->un_dev);
8102 
8103 	if (ucmd->uscsi_flags & USCSI_RQENABLE) {
8104 		stat_size = (un->un_arq_enabled ?
8105 		    sizeof (struct scsi_arq_status) : 1);
8106 	} else {
8107 		stat_size = 1;
8108 	}
8109 
8110 	ASSERT(mutex_owned(ST_MUTEX));
8111 
8112 	un->un_lastop = ST_OP_CTL;	/* usual */
8113 
8114 	cdb = ucmd->uscsi_cdb;
8115 	cdblen = ucmd->uscsi_cdblen;
8116 
8117 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8118 	    "st_make_uscsi_cmd: buflen=%ld bcount=%ld\n",
8119 		ucmd->uscsi_buflen, bp->b_bcount);
8120 	pkt = scsi_init_pkt(ROUTE, NULL,
8121 		(bp->b_bcount > 0) ? bp : NULL,
8122 		cdblen, stat_size, 0, 0, func, (caddr_t)un);
8123 	if (pkt == NULL) {
8124 		goto exit;
8125 	}
8126 
8127 	bcopy(cdb, pkt->pkt_cdbp, (uint_t)cdblen);
8128 
8129 #ifdef STDEBUG
8130 	if (st_debug >= 6) {
8131 		st_clean_print(ST_DEVINFO, st_label, SCSI_DEBUG,
8132 		    "pkt_cdbp", (char *)cdb, cdblen);
8133 	}
8134 #endif
8135 
8136 	if (ucmd->uscsi_flags & USCSI_SILENT) {
8137 		pkt->pkt_flags |= FLAG_SILENT;
8138 	}
8139 
8140 	pkt->pkt_time = ucmd->uscsi_timeout;
8141 	pkt->pkt_comp = st_intr;
8142 	pkt->pkt_private = (opaque_t)bp;
8143 	SET_BP_PKT(bp, pkt);
8144 exit:
8145 	ASSERT(mutex_owned(ST_MUTEX));
8146 }
8147 
8148 
8149 /*
8150  * restart cmd currently at the head of the runq
8151  *
8152  * If scsi_transport() succeeds or the retries
8153  * count exhausted, restore the throttle that was
8154  * zeroed out in st_handle_intr_busy().
8155  *
8156  */
8157 static void
8158 st_intr_restart(void *arg)
8159 {
8160 	struct scsi_tape *un = arg;
8161 	struct buf *bp;
8162 	int status = TRAN_ACCEPT;
8163 
8164 	mutex_enter(ST_MUTEX);
8165 
8166 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8167 		"st_intr_restart(), un = 0x%p\n", (void *)un);
8168 
8169 	un->un_hib_tid = 0;
8170 
8171 	/*
8172 	 * move from waitq to runq, if there is anything on the waitq
8173 	 */
8174 	if ((bp = un->un_quef) == NULL) {
8175 		mutex_exit(ST_MUTEX);
8176 		return;
8177 	}
8178 
8179 	/*
8180 	 * Here we know :
8181 	 *	throttle = 0, via st_handle_intr_busy
8182 	 */
8183 
8184 	if (un->un_quel == bp) {
8185 		un->un_quel = NULL;
8186 		un->un_quef = NULL;	/* we know it's the first one */
8187 	} else {
8188 		un->un_quef = bp->b_actf;
8189 	}
8190 	bp->b_actf = NULL;
8191 
8192 	if (un->un_runqf) {
8193 		/*
8194 		 * not good, we don't want to requeue something after
8195 		 * another.
8196 		 */
8197 		mutex_exit(ST_MUTEX);
8198 		goto done_error;
8199 	} else {
8200 		un->un_runqf = bp;
8201 		un->un_runql = bp;
8202 	}
8203 
8204 	ST_DO_KSTATS(bp, kstat_waitq_to_runq);
8205 
8206 	mutex_exit(ST_MUTEX);
8207 
8208 	status = scsi_transport(BP_PKT(bp));
8209 
8210 	mutex_enter(ST_MUTEX);
8211 
8212 	if (status != TRAN_ACCEPT) {
8213 		ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
8214 		mutex_exit(ST_MUTEX);
8215 
8216 		if (status == TRAN_BUSY) {
8217 			if (st_handle_intr_busy(un, bp,
8218 			    ST_TRAN_BUSY_TIMEOUT) == 0)
8219 				return;	/* timeout is setup again */
8220 		}
8221 
8222 	} else {
8223 		un->un_tran_retry_ct = 0;
8224 		if (un->un_last_throttle) {
8225 			un->un_throttle = un->un_last_throttle;
8226 		}
8227 		mutex_exit(ST_MUTEX);
8228 		return;
8229 	}
8230 
8231 done_error:
8232 	ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
8233 	    "restart transport rejected\n");
8234 	bp->b_resid = bp->b_bcount;
8235 
8236 #ifndef __lock_lint
8237 	/*
8238 	 * warlock doesn't understand this potential
8239 	 * recursion?
8240 	 */
8241 	mutex_enter(ST_MUTEX);
8242 	if (un->un_last_throttle) {
8243 		un->un_throttle = un->un_last_throttle;
8244 	}
8245 	if (status != TRAN_ACCEPT)
8246 		ST_DO_ERRSTATS(un, st_transerrs);
8247 	ST_DO_KSTATS(bp, kstat_waitq_exit);
8248 	SET_PE_FLAG(un);
8249 	st_bioerror(bp, EIO);
8250 	st_done_and_mutex_exit(un, bp);
8251 #endif
8252 	ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
8253 	    "busy restart aborted\n");
8254 }
8255 
8256 /*
8257  * st_check_media():
8258  * Periodically check the media state using scsi_watch service;
8259  * this service calls back after TUR and possibly request sense
8260  * the callback handler (st_media_watch_cb()) decodes the request sense
8261  * data (if any)
8262  */
8263 
8264 static int
8265 st_check_media(dev_t dev, enum mtio_state state)
8266 {
8267 	int rval = 0;
8268 	enum mtio_state	prev_state;
8269 	opaque_t token = NULL;
8270 
8271 	GET_SOFT_STATE(dev);
8272 
8273 	mutex_enter(ST_MUTEX);
8274 
8275 	ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8276 	    "st_check_media:state=%x, mediastate=%x\n",
8277 	    state, un->un_mediastate);
8278 
8279 	prev_state = un->un_mediastate;
8280 
8281 	/*
8282 	 * is there anything to do?
8283 	 */
8284 retry:
8285 	if (state == un->un_mediastate || un->un_mediastate == MTIO_NONE) {
8286 		/*
8287 		 * submit the request to the scsi_watch service;
8288 		 * scsi_media_watch_cb() does the real work
8289 		 */
8290 		mutex_exit(ST_MUTEX);
8291 		token = scsi_watch_request_submit(ST_SCSI_DEVP,
8292 			st_check_media_time, SENSE_LENGTH,
8293 			st_media_watch_cb, (caddr_t)dev);
8294 		if (token == NULL) {
8295 			rval = EAGAIN;
8296 			goto done;
8297 		}
8298 		mutex_enter(ST_MUTEX);
8299 
8300 		un->un_swr_token = token;
8301 		un->un_specified_mediastate = state;
8302 
8303 		/*
8304 		 * now wait for media change
8305 		 * we will not be signalled unless mediastate == state but it
8306 		 * still better to test for this condition, since there
8307 		 * is a 5 sec cv_broadcast delay when
8308 		 *  mediastate == MTIO_INSERTED
8309 		 */
8310 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8311 			"st_check_media:waiting for media state change\n");
8312 		while (un->un_mediastate == state) {
8313 			if (cv_wait_sig(&un->un_state_cv, ST_MUTEX) == 0) {
8314 				mutex_exit(ST_MUTEX);
8315 				ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8316 				    "st_check_media:waiting for media state "
8317 				    "was interrupted\n");
8318 				rval = EINTR;
8319 				goto done;
8320 			}
8321 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8322 			    "st_check_media:received signal, state=%x\n",
8323 			    un->un_mediastate);
8324 		}
8325 	}
8326 
8327 	/*
8328 	 * if we transitioned to MTIO_INSERTED, media has really been
8329 	 * inserted.  If TUR fails, it is probably a exabyte slow spin up.
8330 	 * Reset and retry the state change.  If everything is ok, replay
8331 	 * the open() logic.
8332 	 */
8333 	if ((un->un_mediastate == MTIO_INSERTED) &&
8334 	    (un->un_state == ST_STATE_OFFLINE)) {
8335 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8336 		    "st_check_media: calling st_cmd to confirm inserted\n");
8337 
8338 		/*
8339 		 * set this early so that TUR will make it through strategy
8340 		 * without triggering a st_tape_init().  We needed it set
8341 		 * before calling st_tape_init() ourselves anyway.  If TUR
8342 		 * fails, set it back
8343 		 */
8344 		un->un_state = ST_STATE_INITIALIZING;
8345 
8346 		/*
8347 		 * If not reserved fail as getting reservation conflict
8348 		 * will make this hang forever.
8349 		 */
8350 		if ((un->un_rsvd_status &
8351 		    (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) {
8352 			mutex_exit(ST_MUTEX);
8353 			rval = EACCES;
8354 			goto done;
8355 		}
8356 		rval = st_cmd(dev, SCMD_TEST_UNIT_READY, 0, SYNC_CMD);
8357 		if (rval == EACCES) {
8358 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8359 			    "st_check_media: TUR got Reservation Conflict\n");
8360 			mutex_exit(ST_MUTEX);
8361 			goto done;
8362 		}
8363 		if (rval) {
8364 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8365 			    "st_check_media: TUR failed, going to retry\n");
8366 			un->un_mediastate = prev_state;
8367 			un->un_state = ST_STATE_OFFLINE;
8368 			goto retry;
8369 		}
8370 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8371 		    "st_check_media: media inserted\n");
8372 
8373 		/* this also rewinds the tape */
8374 		rval = st_tape_init(dev);
8375 		if (rval != 0) {
8376 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8377 			    "st_check_media : OFFLINE init failure ");
8378 			un->un_state = ST_STATE_OFFLINE;
8379 			un->un_fileno = -1;
8380 		} else {
8381 			un->un_state = ST_STATE_OPEN_PENDING_IO;
8382 			un->un_fileno = 0;
8383 			un->un_blkno = 0;
8384 		}
8385 	} else if ((un->un_mediastate == MTIO_EJECTED) &&
8386 		(un->un_state != ST_STATE_OFFLINE)) {
8387 		/*
8388 		 * supported devices must be rewound before ejection
8389 		 * rewind resets fileno & blkno
8390 		 */
8391 		un->un_laststate = un->un_state;
8392 		un->un_state = ST_STATE_OFFLINE;
8393 	}
8394 	mutex_exit(ST_MUTEX);
8395 done:
8396 	if (token) {
8397 		(void) scsi_watch_request_terminate(token,
8398 				SCSI_WATCH_TERMINATE_WAIT);
8399 		mutex_enter(ST_MUTEX);
8400 		un->un_swr_token = (opaque_t)NULL;
8401 		mutex_exit(ST_MUTEX);
8402 	}
8403 
8404 	ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG, "st_check_media: done\n");
8405 
8406 	return (rval);
8407 }
8408 
8409 /*
8410  * st_media_watch_cb() is called by scsi_watch_thread for
8411  * verifying the request sense data (if any)
8412  */
8413 static int
8414 st_media_watch_cb(caddr_t arg, struct scsi_watch_result *resultp)
8415 {
8416 	struct scsi_status *statusp = resultp->statusp;
8417 	struct scsi_extended_sense *sensep = resultp->sensep;
8418 	uchar_t actual_sense_length = resultp->actual_sense_length;
8419 	struct scsi_tape *un;
8420 	enum mtio_state state = MTIO_NONE;
8421 	int instance;
8422 	dev_t dev = (dev_t)arg;
8423 
8424 	instance = MTUNIT(dev);
8425 	if ((un = ddi_get_soft_state(st_state, instance)) == NULL) {
8426 		return (-1);
8427 	}
8428 
8429 	mutex_enter(ST_MUTEX);
8430 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8431 		"st_media_watch_cb: status=%x, sensep=%p, len=%x\n",
8432 			*((char *)statusp), (void *)sensep,
8433 			actual_sense_length);
8434 
8435 	/*
8436 	 * if there was a check condition then sensep points to valid
8437 	 * sense data
8438 	 * if status was not a check condition but a reservation or busy
8439 	 * status then the new state is MTIO_NONE
8440 	 */
8441 	if (sensep) {
8442 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8443 		    "st_media_watch_cb: KEY=%x, ASC=%x, ASCQ=%x\n",
8444 		    sensep->es_key, sensep->es_add_code, sensep->es_qual_code);
8445 
8446 		switch (un->un_dp->type) {
8447 		default:
8448 			ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8449 	    "st_media_watch_cb: unknown drive type %d, default to ST_TYPE_HP\n",
8450 	    un->un_dp->type);
8451 		/* FALLTHROUGH */
8452 
8453 		case ST_TYPE_STC3490:	/* STK 4220 1/2" cartridge */
8454 		case ST_TYPE_FUJI:	/* 1/2" cartridge */
8455 		case ST_TYPE_HP:	/* HP 88780 1/2" reel */
8456 			if (un->un_dp->type == ST_TYPE_FUJI) {
8457 				ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
8458 				    "st_media_watch_cb: ST_TYPE_FUJI\n");
8459 			} else {
8460 				ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
8461 				    "st_media_watch_cb: ST_TYPE_HP\n");
8462 			}
8463 			switch (sensep->es_key) {
8464 			case KEY_UNIT_ATTENTION:
8465 				/* not ready to ready transition */
8466 				/* hp/es_qual_code == 80 on>off>on */
8467 				/* hp/es_qual_code == 0 on>off>unld>ld>on */
8468 				if (sensep->es_add_code == 0x28) {
8469 					state = MTIO_INSERTED;
8470 				}
8471 				break;
8472 			case KEY_NOT_READY:
8473 				/* in process, rewinding or loading */
8474 				if ((sensep->es_add_code == 0x04) &&
8475 				    (sensep->es_qual_code == 0x00)) {
8476 					state = MTIO_EJECTED;
8477 				}
8478 				break;
8479 			}
8480 			break;
8481 
8482 		case ST_TYPE_EXB8500:	/* Exabyte 8500 */
8483 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
8484 			    "st_media_watch_cb: ST_TYPE_EXB8500\n");
8485 			switch (sensep->es_key) {
8486 			case KEY_UNIT_ATTENTION:
8487 				/* operator medium removal request */
8488 				if ((sensep->es_add_code == 0x5a) &&
8489 				    (sensep->es_qual_code == 0x01)) {
8490 					state = MTIO_EJECTED;
8491 				/* not ready to ready transition */
8492 				} else if ((sensep->es_add_code == 0x28) &&
8493 				    (sensep->es_qual_code == 0x00)) {
8494 					state = MTIO_INSERTED;
8495 				}
8496 				break;
8497 			case KEY_NOT_READY:
8498 				/* medium not present */
8499 				if (sensep->es_add_code == 0x3a) {
8500 					state = MTIO_EJECTED;
8501 				}
8502 				break;
8503 			}
8504 			break;
8505 		case ST_TYPE_EXABYTE:	/* Exabyte 8200 */
8506 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
8507 			    "st_media_watch_cb: ST_TYPE_EXABYTE\n");
8508 			switch (sensep->es_key) {
8509 			case KEY_NOT_READY:
8510 				if ((sensep->es_add_code == 0x04) &&
8511 				    (sensep->es_qual_code == 0x00)) {
8512 					/* volume not mounted? */
8513 					state = MTIO_EJECTED;
8514 				} else if (sensep->es_add_code == 0x3a) {
8515 					state = MTIO_EJECTED;
8516 				}
8517 				break;
8518 			case KEY_UNIT_ATTENTION:
8519 				state = MTIO_EJECTED;
8520 				break;
8521 			}
8522 			break;
8523 
8524 		case ST_TYPE_DLT:		/* quantum DLT4xxx */
8525 			switch (sensep->es_key) {
8526 			case KEY_UNIT_ATTENTION:
8527 				if (sensep->es_add_code == 0x28) {
8528 					state = MTIO_INSERTED;
8529 				}
8530 				break;
8531 			case KEY_NOT_READY:
8532 				if (sensep->es_add_code == 0x04) {
8533 					/* in transition but could be either */
8534 					state = un->un_specified_mediastate;
8535 				} else if ((sensep->es_add_code == 0x3a) &&
8536 				    (sensep->es_qual_code == 0x00)) {
8537 					state = MTIO_EJECTED;
8538 				}
8539 				break;
8540 			}
8541 			break;
8542 		}
8543 	} else if (*((char *)statusp) == STATUS_GOOD) {
8544 		state = MTIO_INSERTED;
8545 	}
8546 
8547 	ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
8548 	    "st_media_watch_cb:state=%x, specified=%x\n",
8549 	    state, un->un_specified_mediastate);
8550 
8551 	/*
8552 	 * now signal the waiting thread if this is *not* the specified state;
8553 	 * delay the signal if the state is MTIO_INSERTED
8554 	 * to allow the target to recover
8555 	 */
8556 	if (state != un->un_specified_mediastate) {
8557 		un->un_mediastate = state;
8558 		if (state == MTIO_INSERTED) {
8559 			/*
8560 			 * delay the signal to give the drive a chance
8561 			 * to do what it apparently needs to do
8562 			 */
8563 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
8564 			    "st_media_watch_cb:delayed cv_broadcast\n");
8565 			un->un_delay_tid = timeout(st_delayed_cv_broadcast,
8566 			    un, drv_usectohz((clock_t)MEDIA_ACCESS_DELAY));
8567 		} else {
8568 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
8569 			    "st_media_watch_cb:immediate cv_broadcast\n");
8570 			cv_broadcast(&un->un_state_cv);
8571 		}
8572 	}
8573 	mutex_exit(ST_MUTEX);
8574 	return (0);
8575 }
8576 
8577 /*
8578  * delayed cv_broadcast to allow for target to recover
8579  * from media insertion
8580  */
8581 static void
8582 st_delayed_cv_broadcast(void *arg)
8583 {
8584 	struct scsi_tape *un = arg;
8585 
8586 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8587 	    "st_delayed_cv_broadcast:delayed cv_broadcast\n");
8588 
8589 	mutex_enter(ST_MUTEX);
8590 	cv_broadcast(&un->un_state_cv);
8591 	mutex_exit(ST_MUTEX);
8592 }
8593 
8594 /*
8595  * restart cmd currently at the start of the waitq
8596  */
8597 static void
8598 st_start_restart(void *arg)
8599 {
8600 	struct scsi_tape *un = arg;
8601 
8602 	ASSERT(un != NULL);
8603 
8604 	mutex_enter(ST_MUTEX);
8605 
8606 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8607 		"st_tran_restart()\n");
8608 
8609 	if (un->un_quef) {
8610 		st_start(un);
8611 	}
8612 
8613 	mutex_exit(ST_MUTEX);
8614 }
8615 
8616 
8617 /*
8618  * Command completion processing
8619  *
8620  */
8621 static void
8622 st_intr(struct scsi_pkt *pkt)
8623 {
8624 	struct scsi_tape *un;
8625 	struct buf *last_runqf;
8626 	struct buf *bp;
8627 	int action = COMMAND_DONE;
8628 	clock_t	timout;
8629 	int	status;
8630 
8631 	bp = (struct buf *)pkt->pkt_private;
8632 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
8633 
8634 	mutex_enter(ST_MUTEX);
8635 
8636 	un->un_rqs_state &= ~(ST_RQS_ERROR);
8637 
8638 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_intr()\n");
8639 
8640 	if (pkt->pkt_reason != CMD_CMPLT) {
8641 
8642 		/* If device has gone away not much else to do */
8643 		if (pkt->pkt_reason == CMD_DEV_GONE) {
8644 			action = COMMAND_DONE_ERROR;
8645 		} else if (un->un_state == ST_STATE_SENSING) {
8646 			ST_DO_ERRSTATS(un, st_transerrs);
8647 			action = COMMAND_DONE_ERROR;
8648 		} else {
8649 			action = st_handle_incomplete(un, bp);
8650 		}
8651 	/*
8652 	 * At this point we know that the command was successfully
8653 	 * completed. Now what?
8654 	 */
8655 	} else if (un->un_arq_enabled &&
8656 	    (pkt->pkt_state & STATE_ARQ_DONE)) {
8657 		/*
8658 		 * the transport layer successfully completed an autorqsense
8659 		 */
8660 		action = st_handle_autosense(un, bp);
8661 
8662 	} else if (un->un_state == ST_STATE_SENSING) {
8663 		/*
8664 		 * okay. We were running a REQUEST SENSE. Find
8665 		 * out what to do next.
8666 		 * some actions are based on un_state, hence
8667 		 * restore the state st was in before ST_STATE_SENSING.
8668 		 */
8669 		un->un_state = un->un_laststate;
8670 		action = st_handle_sense(un, bp);
8671 		/*
8672 		 * set pkt back to original packet in case we will have
8673 		 * to requeue it
8674 		 */
8675 		pkt = BP_PKT(bp);
8676 	} else  if ((SCBP(pkt)->sts_busy) || (SCBP(pkt)->sts_chk)) {
8677 		/*
8678 		 * Okay, we weren't running a REQUEST SENSE. Call a routine
8679 		 * to see if the status bits we're okay. If a request sense
8680 		 * is to be run, that will happen.
8681 		 */
8682 		action = st_check_error(un, pkt);
8683 	}
8684 
8685 	if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
8686 		switch (action) {
8687 			case QUE_COMMAND:
8688 				/*
8689 				 * return cmd to head to the queue
8690 				 * since we are suspending so that
8691 				 * it gets restarted during resume
8692 				 */
8693 				if (un->un_runqf) {
8694 					last_runqf = un->un_runqf;
8695 					un->un_runqf = bp;
8696 					bp->b_actf = last_runqf;
8697 				} else {
8698 					bp->b_actf = NULL;
8699 					un->un_runqf = bp;
8700 					un->un_runql = bp;
8701 				}
8702 				action = JUST_RETURN;
8703 				break;
8704 
8705 			case QUE_SENSE:
8706 				action = COMMAND_DONE_ERROR;
8707 				break;
8708 
8709 			default:
8710 				break;
8711 		}
8712 	}
8713 
8714 	/*
8715 	 * Restore old state if we were sensing.
8716 	 */
8717 	if (un->un_state == ST_STATE_SENSING && action != QUE_SENSE) {
8718 		un->un_state = un->un_laststate;
8719 	}
8720 
8721 	ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
8722 	    "st_intr: pkt=%p, bp=%p, action=%x, status=%x\n",
8723 	    (void *)pkt, (void *)bp, action, SCBP_C(pkt));
8724 
8725 
8726 	switch (action) {
8727 	case COMMAND_DONE_EACCES:
8728 		/* this is to report a reservation conflict */
8729 		st_bioerror(bp, EACCES);
8730 		ST_DEBUG(ST_DEVINFO, st_label, SCSI_DEBUG,
8731 			"Reservation Conflict \n");
8732 
8733 		/*FALLTHROUGH*/
8734 	case COMMAND_DONE_ERROR:
8735 		if (un->un_eof < ST_EOT_PENDING &&
8736 		    un->un_state >= ST_STATE_OPEN) {
8737 			/*
8738 			 * all errors set state of the tape to 'unknown'
8739 			 * unless we're at EOT or are doing append testing.
8740 			 * If sense key was illegal request, preserve state.
8741 			 */
8742 			if (un->un_status != KEY_ILLEGAL_REQUEST) {
8743 				un->un_fileno = -1;
8744 			}
8745 		}
8746 		un->un_err_resid = bp->b_resid = bp->b_bcount;
8747 		/*
8748 		 * since we have an error (COMMAND_DONE_ERROR), we want to
8749 		 * make sure an error ocurrs, so make sure at least EIO is
8750 		 * returned
8751 		 */
8752 		if (geterror(bp) == 0)
8753 			st_bioerror(bp, EIO);
8754 
8755 		SET_PE_FLAG(un);
8756 		if (!(un->un_rqs_state & ST_RQS_ERROR) &&
8757 		    (un->un_errno == EIO)) {
8758 			un->un_rqs_state &= ~(ST_RQS_VALID);
8759 		}
8760 		goto done;
8761 
8762 	case COMMAND_DONE_ERROR_RECOVERED:
8763 		un->un_err_resid = bp->b_resid = bp->b_bcount;
8764 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
8765 		    "st_intr(): COMMAND_DONE_ERROR_RECOVERED");
8766 		if (geterror(bp) == 0)
8767 			st_bioerror(bp, EIO);
8768 		SET_PE_FLAG(un);
8769 		if (!(un->un_rqs_state & ST_RQS_ERROR) &&
8770 		    (un->un_errno == EIO)) {
8771 			un->un_rqs_state &= ~(ST_RQS_VALID);
8772 		}
8773 		/*FALLTHROUGH*/
8774 	case COMMAND_DONE:
8775 		st_set_state(un);
8776 done:
8777 		ST_DO_KSTATS(bp, kstat_runq_exit);
8778 		st_done_and_mutex_exit(un, bp);
8779 		return;
8780 
8781 	case QUE_SENSE:
8782 		if ((un->un_ncmds > 1) && !un->un_flush_on_errors)
8783 			goto sense_error;
8784 
8785 		if (un->un_state != ST_STATE_SENSING) {
8786 			un->un_laststate = un->un_state;
8787 			un->un_state = ST_STATE_SENSING;
8788 		}
8789 
8790 		un->un_rqs->pkt_private = (opaque_t)bp;
8791 		bzero(ST_RQSENSE, SENSE_LENGTH);
8792 
8793 		if (un->un_throttle) {
8794 			un->un_last_throttle = un->un_throttle;
8795 			un->un_throttle = 0;
8796 		}
8797 
8798 		mutex_exit(ST_MUTEX);
8799 
8800 		/*
8801 		 * never retry this, some other command will have nuked the
8802 		 * sense, anyway
8803 		 */
8804 		status = scsi_transport(un->un_rqs);
8805 
8806 		mutex_enter(ST_MUTEX);
8807 
8808 		if (un->un_last_throttle) {
8809 			un->un_throttle = un->un_last_throttle;
8810 		}
8811 
8812 		if (status == TRAN_ACCEPT) {
8813 			mutex_exit(ST_MUTEX);
8814 			return;
8815 		}
8816 		if (status != TRAN_BUSY)
8817 			ST_DO_ERRSTATS(un, st_transerrs);
8818 sense_error:
8819 		un->un_fileno = -1;
8820 		st_bioerror(bp, EIO);
8821 		SET_PE_FLAG(un);
8822 		goto done;
8823 
8824 	case QUE_BUSY_COMMAND:
8825 		/* longish timeout */
8826 		timout = ST_STATUS_BUSY_TIMEOUT;
8827 		goto que_it_up;
8828 
8829 	case QUE_COMMAND:
8830 		/* short timeout */
8831 		timout = ST_TRAN_BUSY_TIMEOUT;
8832 que_it_up:
8833 		/*
8834 		 * let st_handle_intr_busy put this bp back on waitq and make
8835 		 * checks to see if it is ok to requeue the command.
8836 		 */
8837 		ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
8838 
8839 		/*
8840 		 * Save the throttle before setting up the timeout
8841 		 */
8842 		if (un->un_throttle) {
8843 			un->un_last_throttle = un->un_throttle;
8844 		}
8845 		mutex_exit(ST_MUTEX);
8846 		if (st_handle_intr_busy(un, bp, timout) == 0)
8847 			return;		/* timeout is setup again */
8848 
8849 		mutex_enter(ST_MUTEX);
8850 		un->un_fileno = -1;
8851 		un->un_err_resid = bp->b_resid = bp->b_bcount;
8852 		st_bioerror(bp, EIO);
8853 		SET_PE_FLAG(un);
8854 		goto done;
8855 
8856 	case QUE_LAST_COMMAND:
8857 
8858 		if ((un->un_ncmds > 1) && !un->un_flush_on_errors) {
8859 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
8860 			    "un_ncmds: %d can't retry cmd \n", un->un_ncmds);
8861 			goto last_command_error;
8862 		}
8863 		mutex_exit(ST_MUTEX);
8864 		if (st_handle_intr_retry_lcmd(un, bp) == 0)
8865 			return;
8866 		mutex_enter(ST_MUTEX);
8867 last_command_error:
8868 		un->un_err_resid = bp->b_resid = bp->b_bcount;
8869 		un->un_fileno = -1;
8870 		st_bioerror(bp, EIO);
8871 		SET_PE_FLAG(un);
8872 		goto done;
8873 
8874 	case JUST_RETURN:
8875 	default:
8876 		ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
8877 		mutex_exit(ST_MUTEX);
8878 		return;
8879 	}
8880 	/*NOTREACHED*/
8881 }
8882 
8883 static int
8884 st_handle_incomplete(struct scsi_tape *un, struct buf *bp)
8885 {
8886 	static char *fail = "SCSI transport failed: reason '%s': %s\n";
8887 	int rval = COMMAND_DONE_ERROR;
8888 	struct scsi_pkt *pkt = (un->un_state == ST_STATE_SENSING) ?
8889 			un->un_rqs : BP_PKT(bp);
8890 	int result;
8891 
8892 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
8893 		"st_handle_incomplete(): dev = 0x%lx\n", un->un_dev);
8894 
8895 	ASSERT(mutex_owned(ST_MUTEX));
8896 
8897 	switch (pkt->pkt_reason) {
8898 	case CMD_INCOMPLETE:	/* tran stopped with not normal state */
8899 		/*
8900 		 * this occurs when accessing a powered down drive, no
8901 		 * need to complain; just fail the open
8902 		 */
8903 #ifdef STDEBUG
8904 		if (st_debug >= 1) {
8905 			st_clean_print(ST_DEVINFO, st_label, CE_WARN,
8906 			    "Failed CDB", (char *)pkt->pkt_cdbp, CDB_SIZE);
8907 		}
8908 
8909 #endif
8910 		/*
8911 		 * if we have commands outstanding in HBA, and a command
8912 		 * comes back incomplete, we're hosed, so reset target
8913 		 * If we have the bus, but cmd_incomplete, we probably just
8914 		 * have a failed selection, so don't reset the target, just
8915 		 * requeue the command and try again
8916 		 */
8917 		if ((un->un_ncmds > 1) || (pkt->pkt_state != STATE_GOT_BUS)) {
8918 			goto reset_target;
8919 		}
8920 
8921 		/*
8922 		 * Retry selection a couple more times if we're
8923 		 * open.  If opening, we only try just once to
8924 		 * reduce probe time for nonexistant devices.
8925 		 */
8926 		if ((un->un_laststate > ST_STATE_OPENING) &&
8927 		    ((int)un->un_retry_ct < st_selection_retry_count)) {
8928 			rval = QUE_COMMAND;
8929 		}
8930 		ST_DO_ERRSTATS(un, st_transerrs);
8931 		break;
8932 
8933 	case CMD_ABORTED:
8934 		/*
8935 		 * most likely this is caused by flush-on-error support. If
8936 		 * it was not there, the we're in trouble.
8937 		 */
8938 		if (!un->un_flush_on_errors) {
8939 			un->un_status = SUN_KEY_FATAL;
8940 			goto reset_target;
8941 		}
8942 
8943 		st_set_pe_errno(un);
8944 		bioerror(bp, un->un_errno);
8945 		if (un->un_errno)
8946 			return (COMMAND_DONE_ERROR);
8947 		else
8948 			return (COMMAND_DONE);
8949 
8950 	case CMD_TIMEOUT:	/* Command timed out */
8951 		un->un_status = SUN_KEY_TIMEOUT;
8952 
8953 		/*FALLTHROUGH*/
8954 	default:
8955 reset_target:
8956 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
8957 		    "transport completed with %s\n",
8958 		    scsi_rname(pkt->pkt_reason));
8959 		ST_DO_ERRSTATS(un, st_transerrs);
8960 		if ((pkt->pkt_state & STATE_GOT_TARGET) &&
8961 		    ((pkt->pkt_statistics & (STAT_BUS_RESET | STAT_DEV_RESET |
8962 			STAT_ABORTED)) == 0)) {
8963 
8964 			/*
8965 			 * If we haven't reserved the drive don't reset it.
8966 			 */
8967 			if ((un->un_rsvd_status &
8968 			    (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) {
8969 				return (rval);
8970 			}
8971 
8972 			mutex_exit(ST_MUTEX);
8973 
8974 			result = scsi_reset(ROUTE, RESET_TARGET);
8975 			/*
8976 			 * if target reset fails, then pull the chain
8977 			 */
8978 			if (result == 0) {
8979 				result = scsi_reset(ROUTE, RESET_ALL);
8980 			}
8981 			mutex_enter(ST_MUTEX);
8982 
8983 			if ((result == 0) && (un->un_state >= ST_STATE_OPEN)) {
8984 				/* no hope left to recover */
8985 				scsi_log(ST_DEVINFO, st_label, CE_WARN,
8986 				    "recovery by resets failed\n");
8987 				return (rval);
8988 			}
8989 		}
8990 	}
8991 
8992 	if ((pkt->pkt_reason == CMD_RESET) || (pkt->pkt_statistics &
8993 		(STAT_BUS_RESET | STAT_DEV_RESET))) {
8994 		if ((un->un_rsvd_status & ST_RESERVE)) {
8995 			un->un_rsvd_status |= ST_LOST_RESERVE;
8996 			ST_DEBUG3(ST_DEVINFO, st_label, CE_WARN,
8997 				"Lost Reservation\n");
8998 		}
8999 	}
9000 
9001 	if ((int)un->un_retry_ct++ < st_retry_count) {
9002 		if (un->un_pwr_mgmt == ST_PWR_SUSPENDED) {
9003 			rval = QUE_COMMAND;
9004 		} else if (bp == un->un_sbufp) {
9005 			switch ((uchar_t)(uintptr_t)bp->b_forw) {
9006 			case SCMD_MODE_SENSE:
9007 			case SCMD_MODE_SELECT:
9008 			case SCMD_READ_BLKLIM:
9009 			case SCMD_REWIND:
9010 			case SCMD_LOAD:
9011 			case SCMD_TEST_UNIT_READY:
9012 				/*
9013 				 * These commands can be rerun with impunity
9014 				 */
9015 				rval = QUE_COMMAND;
9016 				break;
9017 
9018 			default:
9019 				break;
9020 			}
9021 		}
9022 	} else {
9023 		rval = COMMAND_DONE_ERROR;
9024 	}
9025 
9026 	if (un->un_state >= ST_STATE_OPEN) {
9027 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
9028 		    fail, scsi_rname(pkt->pkt_reason),
9029 		    (rval == COMMAND_DONE_ERROR)?
9030 		    "giving up" : "retrying command");
9031 	}
9032 	return (rval);
9033 }
9034 
9035 /*
9036  * if the device is busy, then put this bp back on the waitq, on the
9037  * interrupt thread, where we want the head of the queue and not the
9038  * end
9039  *
9040  * The callers of this routine should take measures to save the
9041  * un_throttle in un_last_throttle which will be restored in
9042  * st_intr_restart(). The only exception should be st_intr_restart()
9043  * calling this routine for which the saving is already done.
9044  */
9045 static int
9046 st_handle_intr_busy(struct scsi_tape *un, struct buf *bp,
9047 	clock_t timeout_interval)
9048 {
9049 	struct buf *last_quef;
9050 	int rval = 0;
9051 
9052 	mutex_enter(ST_MUTEX);
9053 
9054 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9055 	    "st_handle_intr_busy(), un = 0x%p\n", (void *)un);
9056 
9057 	/*
9058 	 * Check to see if we hit the retry timeout. We check to make sure
9059 	 * this is the first one on the runq and make sure we have not
9060 	 * queued up any more, so this one has to be the last on the list
9061 	 * also. If it is not, we have to fail.  If it is not the first, but
9062 	 * is the last we are in trouble anyway, as we are in the interrupt
9063 	 * context here.
9064 	 */
9065 	if (((int)un->un_tran_retry_ct++ > st_retry_count) ||
9066 	    ((un->un_runqf != bp) && (un->un_runql != bp))) {
9067 		rval = -1;
9068 		goto exit;
9069 	}
9070 
9071 	/* put the bp back on the waitq */
9072 	if (un->un_quef) {
9073 		last_quef = un->un_quef;
9074 		un->un_quef = bp;
9075 		bp->b_actf = last_quef;
9076 	} else  {
9077 		bp->b_actf = NULL;
9078 		un->un_quef = bp;
9079 		un->un_quel = bp;
9080 	}
9081 
9082 	/*
9083 	 * We know that this is the first and last on the runq at this time,
9084 	 * so we just nullify those two queues
9085 	 */
9086 	un->un_runqf = NULL;
9087 	un->un_runql = NULL;
9088 
9089 	/*
9090 	 * We don't want any other commands being started in the mean time.
9091 	 * If start had just released mutex after putting something on the
9092 	 * runq, we won't even get here.
9093 	 */
9094 	un->un_throttle = 0;
9095 
9096 	/*
9097 	 * send a marker pkt, if appropriate
9098 	 */
9099 	st_hba_unflush(un);
9100 
9101 	/*
9102 	 * all queues are aligned, we are just waiting to
9103 	 * transport
9104 	 */
9105 	un->un_hib_tid = timeout(st_intr_restart, un, timeout_interval);
9106 
9107 exit:
9108 	mutex_exit(ST_MUTEX);
9109 	return (rval);
9110 }
9111 
9112 static int
9113 st_handle_sense(struct scsi_tape *un, struct buf *bp)
9114 {
9115 	struct scsi_pkt *rqpkt = un->un_rqs;
9116 	int rval = COMMAND_DONE_ERROR;
9117 	int amt;
9118 
9119 	ASSERT(mutex_owned(ST_MUTEX));
9120 
9121 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9122 		"st_handle_sense()\n");
9123 
9124 	if (SCBP(rqpkt)->sts_busy) {
9125 		ST_DEBUG4(ST_DEVINFO, st_label, CE_WARN,
9126 		    "busy unit on request sense\n");
9127 		if ((int)un->un_retry_ct++ < st_retry_count) {
9128 			rval = QUE_BUSY_COMMAND;
9129 		}
9130 		return (rval);
9131 	} else if (SCBP(rqpkt)->sts_chk) {
9132 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9133 		    "Check Condition on REQUEST SENSE\n");
9134 		return (rval);
9135 	}
9136 
9137 	/* was there enough data? */
9138 	amt = (int)SENSE_LENGTH - rqpkt->pkt_resid;
9139 	if ((rqpkt->pkt_state & STATE_XFERRED_DATA) == 0 ||
9140 	    (amt < SUN_MIN_SENSE_LENGTH)) {
9141 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9142 		    "REQUEST SENSE couldn't get sense data\n");
9143 		return (rval);
9144 	}
9145 	return (st_decode_sense(un, bp, amt, SCBP(rqpkt)));
9146 }
9147 
9148 static int
9149 st_handle_autosense(struct scsi_tape *un, struct buf *bp)
9150 {
9151 	struct scsi_pkt *pkt = BP_PKT(bp);
9152 	struct scsi_arq_status *arqstat =
9153 	    (struct scsi_arq_status *)pkt->pkt_scbp;
9154 	int rval = COMMAND_DONE_ERROR;
9155 	int amt;
9156 
9157 	ASSERT(mutex_owned(ST_MUTEX));
9158 
9159 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9160 		"st_handle_autosense()\n");
9161 
9162 	if (arqstat->sts_rqpkt_status.sts_busy) {
9163 		ST_DEBUG4(ST_DEVINFO, st_label, CE_WARN,
9164 		    "busy unit on request sense\n");
9165 		/*
9166 		 * we return QUE_SENSE so st_intr will setup the SENSE cmd.
9167 		 * the disadvantage is that we do not have any delay for the
9168 		 * second retry of rqsense and we have to keep a packet around
9169 		 */
9170 		return (QUE_SENSE);
9171 
9172 	} else if (arqstat->sts_rqpkt_reason != CMD_CMPLT) {
9173 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9174 		    "transport error on REQUEST SENSE\n");
9175 		if ((arqstat->sts_rqpkt_state & STATE_GOT_TARGET) &&
9176 		    ((arqstat->sts_rqpkt_statistics &
9177 		    (STAT_BUS_RESET | STAT_DEV_RESET | STAT_ABORTED)) == 0)) {
9178 			mutex_exit(ST_MUTEX);
9179 			if (scsi_reset(ROUTE, RESET_TARGET) == 0) {
9180 				/*
9181 				 * if target reset fails, then pull the chain
9182 				 */
9183 				if (scsi_reset(ROUTE, RESET_ALL) == 0) {
9184 					ST_DEBUG6(ST_DEVINFO, st_label,
9185 					    CE_WARN,
9186 					    "recovery by resets failed\n");
9187 				}
9188 			}
9189 			mutex_enter(ST_MUTEX);
9190 		}
9191 		return (rval);
9192 
9193 	} else if (arqstat->sts_rqpkt_status.sts_chk) {
9194 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9195 		    "Check Condition on REQUEST SENSE\n");
9196 		return (rval);
9197 	}
9198 
9199 
9200 	/* was there enough data? */
9201 	amt = (int)SENSE_LENGTH - arqstat->sts_rqpkt_resid;
9202 	if ((arqstat->sts_rqpkt_state & STATE_XFERRED_DATA) == 0 ||
9203 	    (amt < SUN_MIN_SENSE_LENGTH)) {
9204 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9205 		    "REQUEST SENSE couldn't get sense data\n");
9206 		return (rval);
9207 	}
9208 
9209 	bcopy(&arqstat->sts_sensedata, ST_RQSENSE, SENSE_LENGTH);
9210 
9211 	return (st_decode_sense(un, bp, amt, &arqstat->sts_rqpkt_status));
9212 }
9213 
9214 static int
9215 st_decode_sense(struct scsi_tape *un, struct buf *bp,  int amt,
9216 	struct scsi_status *statusp)
9217 {
9218 	struct scsi_pkt *pkt = BP_PKT(bp);
9219 	int rval = COMMAND_DONE_ERROR;
9220 	long resid;
9221 	struct scsi_extended_sense *sensep = ST_RQSENSE;
9222 	int severity;
9223 	int get_error;
9224 
9225 	ASSERT(mutex_owned(ST_MUTEX));
9226 
9227 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9228 		"st_decode_sense()\n");
9229 
9230 	/*
9231 	 * For uscsi commands, squirrel away a copy of the
9232 	 * results of the Request Sense.
9233 	 */
9234 	if (USCSI_CMD(bp)) {
9235 		struct uscsi_cmd *ucmd = BP_UCMD(bp);
9236 		ucmd->uscsi_rqstatus = *(uchar_t *)statusp;
9237 		if (ucmd->uscsi_rqlen && un->un_srqbufp) {
9238 			uchar_t rqlen = min((uchar_t)amt, ucmd->uscsi_rqlen);
9239 			ucmd->uscsi_rqresid = ucmd->uscsi_rqlen - rqlen;
9240 			bcopy(ST_RQSENSE, un->un_srqbufp, rqlen);
9241 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
9242 				"st_decode_sense: stat=0x%x resid=0x%x\n",
9243 				ucmd->uscsi_rqstatus, ucmd->uscsi_rqresid);
9244 		}
9245 	}
9246 
9247 	/*
9248 	 * If the drive is an MT-02, reposition the
9249 	 * secondary error code into the proper place.
9250 	 *
9251 	 * XXX	MT-02 is non-CCS tape, so secondary error code
9252 	 * is in byte 8.  However, in SCSI-2, tape has CCS definition
9253 	 * so it's in byte 12.
9254 	 */
9255 	if (un->un_dp->type == ST_TYPE_EMULEX) {
9256 		sensep->es_code = sensep->es_add_info[0];
9257 	}
9258 
9259 	/* for normal I/O check extract the resid values. */
9260 	if (bp != un->un_sbufp) {
9261 		if (sensep->es_valid) {
9262 			resid = (sensep->es_info_1 << 24) |
9263 				(sensep->es_info_2 << 16) |
9264 				(sensep->es_info_3 << 8)  |
9265 				(sensep->es_info_4);
9266 			if (un->un_bsize) {
9267 				resid *= un->un_bsize;
9268 			}
9269 		} else if (pkt->pkt_state & STATE_XFERRED_DATA) {
9270 			resid = pkt->pkt_resid;
9271 		} else {
9272 			resid = bp->b_bcount;
9273 		}
9274 		ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9275 		    "st_handle_sense (rw): xferred bit = %d, resid=%ld (%d), "
9276 		    "pkt_resid=%ld\n", pkt->pkt_state & STATE_XFERRED_DATA,
9277 		    resid,
9278 		    (sensep->es_info_1 << 24) |
9279 		    (sensep->es_info_2 << 16) |
9280 		    (sensep->es_info_3 << 8)  |
9281 		    (sensep->es_info_4),
9282 		    pkt->pkt_resid);
9283 		/*
9284 		 * The problem is, what should we believe?
9285 		 */
9286 		if (resid && (pkt->pkt_resid == 0)) {
9287 			pkt->pkt_resid = resid;
9288 		}
9289 	} else {
9290 		/*
9291 		 * If the command is SCMD_SPACE, we need to get the
9292 		 * residual as returned in the sense data, to adjust
9293 		 * our idea of current tape position correctly
9294 		 */
9295 		if ((CDBP(pkt)->scc_cmd == SCMD_SPACE ||
9296 		    CDBP(pkt)->scc_cmd == SCMD_WRITE_FILE_MARK) &&
9297 		    (sensep->es_valid)) {
9298 			resid = (sensep->es_info_1 << 24) |
9299 			    (sensep->es_info_2 << 16) |
9300 			    (sensep->es_info_3 << 8)  |
9301 			    (sensep->es_info_4);
9302 			bp->b_resid = resid;
9303 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9304 			    "st_handle_sense(other):	resid=%ld\n",
9305 			    resid);
9306 		} else {
9307 			/*
9308 			 * If the special command is SCMD_READ,
9309 			 * the correct resid will be set later.
9310 			 */
9311 			resid = bp->b_bcount;
9312 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9313 			    "st_handle_sense(special read):  resid=%ld\n",
9314 				resid);
9315 		}
9316 	}
9317 
9318 	if ((un->un_state >= ST_STATE_OPEN) &&
9319 	    (DEBUGGING || st_error_level == SCSI_ERR_ALL)) {
9320 		st_clean_print(ST_DEVINFO, st_label, CE_NOTE,
9321 		    "Failed CDB", (char *)pkt->pkt_cdbp, CDB_SIZE);
9322 		st_clean_print(ST_DEVINFO, st_label, CE_CONT,
9323 		    "sense data", (char *)sensep, amt);
9324 		scsi_log(ST_DEVINFO, st_label, CE_CONT,
9325 		    "count 0x%lx resid 0x%lx pktresid 0x%lx\n",
9326 		    bp->b_bcount, resid, pkt->pkt_resid);
9327 	}
9328 
9329 	switch (un->un_status = sensep->es_key) {
9330 	case KEY_NO_SENSE:
9331 		severity = SCSI_ERR_INFO;
9332 		goto common;
9333 
9334 	case KEY_RECOVERABLE_ERROR:
9335 		severity = SCSI_ERR_RECOVERED;
9336 		if ((sensep->es_class == CLASS_EXTENDED_SENSE) &&
9337 		    (sensep->es_code == ST_DEFERRED_ERROR)) {
9338 		    if (un->un_dp->options &
9339 			ST_RETRY_ON_RECOVERED_DEFERRED_ERROR) {
9340 			    rval = QUE_LAST_COMMAND;
9341 			    scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, severity,
9342 				un->un_blkno, un->un_err_blkno, scsi_cmds,
9343 				sensep);
9344 			    scsi_log(ST_DEVINFO, st_label, CE_CONT,
9345 				"Command will be retried\n");
9346 			} else {
9347 			    severity = SCSI_ERR_FATAL;
9348 			    rval = COMMAND_DONE_ERROR_RECOVERED;
9349 			    ST_DO_ERRSTATS(un, st_softerrs);
9350 			    scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, severity,
9351 				un->un_blkno, un->un_err_blkno, scsi_cmds,
9352 				sensep);
9353 			}
9354 			break;
9355 		}
9356 common:
9357 		/*
9358 		 * XXX only want reads to be stopped by filemarks.
9359 		 * Don't want them to be stopped by EOT.  EOT matters
9360 		 * only on write.
9361 		 */
9362 		if (sensep->es_filmk && !sensep->es_eom) {
9363 			rval = COMMAND_DONE;
9364 		} else if (sensep->es_eom) {
9365 			rval = COMMAND_DONE;
9366 		} else if (sensep->es_ili) {
9367 			/*
9368 			 * Fun with variable length record devices:
9369 			 * for specifying larger blocks sizes than the
9370 			 * actual physical record size.
9371 			 */
9372 			if (un->un_bsize == 0 && resid > 0) {
9373 				/*
9374 				 * XXX! Ugly.
9375 				 * The requested blocksize is > tape blocksize,
9376 				 * so this is ok, so we just return the
9377 				 * actual size xferred.
9378 				 */
9379 				pkt->pkt_resid = resid;
9380 				rval = COMMAND_DONE;
9381 			} else if (un->un_bsize == 0 && resid < 0) {
9382 				/*
9383 				 * The requested blocksize is < tape blocksize,
9384 				 * so this is not ok, so we err with ENOMEM
9385 				 */
9386 				rval = COMMAND_DONE_ERROR_RECOVERED;
9387 				st_bioerror(bp, ENOMEM);
9388 			} else {
9389 				ST_DO_ERRSTATS(un, st_softerrs);
9390 				severity = SCSI_ERR_FATAL;
9391 				rval = COMMAND_DONE_ERROR;
9392 				st_bioerror(bp, EINVAL);
9393 			}
9394 		} else {
9395 			/*
9396 			 * we hope and pray for this just being
9397 			 * something we can ignore (ie. a
9398 			 * truly recoverable soft error)
9399 			 */
9400 			rval = COMMAND_DONE;
9401 		}
9402 		if (sensep->es_filmk) {
9403 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9404 			    "filemark\n");
9405 			un->un_status = SUN_KEY_EOF;
9406 			un->un_eof = ST_EOF_PENDING;
9407 			SET_PE_FLAG(un);
9408 		}
9409 
9410 		/*
9411 		 * ignore eom when reading, a fmk should terminate reading
9412 		 */
9413 		if ((sensep->es_eom) &&
9414 		    (CDBP(pkt)->scc_cmd != SCMD_READ)) {
9415 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "eom\n");
9416 			un->un_status = SUN_KEY_EOT;
9417 			un->un_eof = ST_EOM;
9418 			SET_PE_FLAG(un);
9419 		}
9420 
9421 		break;
9422 
9423 	case KEY_ILLEGAL_REQUEST:
9424 
9425 		if (un->un_laststate >= ST_STATE_OPEN) {
9426 			ST_DO_ERRSTATS(un, st_softerrs);
9427 			severity = SCSI_ERR_FATAL;
9428 		} else {
9429 			severity = SCSI_ERR_INFO;
9430 		}
9431 		break;
9432 
9433 	case KEY_MEDIUM_ERROR:
9434 		ST_DO_ERRSTATS(un, st_harderrs);
9435 		severity = SCSI_ERR_FATAL;
9436 
9437 		/*
9438 		 * for (buffered) writes, a medium error must be fatal
9439 		 */
9440 		if (CDBP(pkt)->scc_cmd != SCMD_WRITE) {
9441 			rval = COMMAND_DONE_ERROR_RECOVERED;
9442 		}
9443 
9444 check_keys:
9445 		/*
9446 		 * attempt to process the keys in the presence of
9447 		 * other errors
9448 		 */
9449 		if (sensep->es_ili && rval != COMMAND_DONE_ERROR) {
9450 			/*
9451 			 * Fun with variable length record devices:
9452 			 * for specifying larger blocks sizes than the
9453 			 * actual physical record size.
9454 			 */
9455 			if (un->un_bsize == 0 && resid > 0) {
9456 				/*
9457 				 * XXX! Ugly
9458 				 */
9459 				pkt->pkt_resid = resid;
9460 			} else if (un->un_bsize == 0 && resid < 0) {
9461 				st_bioerror(bp, EINVAL);
9462 			} else {
9463 				severity = SCSI_ERR_FATAL;
9464 				rval = COMMAND_DONE_ERROR;
9465 				st_bioerror(bp, EINVAL);
9466 			}
9467 		}
9468 		if (sensep->es_filmk) {
9469 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9470 			    "filemark\n");
9471 			un->un_status = SUN_KEY_EOF;
9472 			un->un_eof = ST_EOF_PENDING;
9473 			SET_PE_FLAG(un);
9474 		}
9475 
9476 		/*
9477 		 * ignore eom when reading, a fmk should terminate reading
9478 		 */
9479 		if ((sensep->es_eom) &&
9480 		    (CDBP(pkt)->scc_cmd != SCMD_READ)) {
9481 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG, "eom\n");
9482 			un->un_status = SUN_KEY_EOT;
9483 			un->un_eof = ST_EOM;
9484 			SET_PE_FLAG(un);
9485 		}
9486 
9487 		break;
9488 
9489 	case KEY_VOLUME_OVERFLOW:
9490 		ST_DO_ERRSTATS(un, st_softerrs);
9491 		un->un_eof = ST_EOM;
9492 		severity = SCSI_ERR_FATAL;
9493 		rval = COMMAND_DONE_ERROR;
9494 		goto check_keys;
9495 
9496 	case KEY_HARDWARE_ERROR:
9497 		ST_DO_ERRSTATS(un, st_harderrs);
9498 		severity = SCSI_ERR_FATAL;
9499 		rval = COMMAND_DONE_ERROR;
9500 		if (un->un_dp->options & ST_EJECT_ON_CHANGER_FAILURE)
9501 			un->un_eject_tape_on_failure = st_check_asc_ascq(un);
9502 		break;
9503 
9504 	case KEY_BLANK_CHECK:
9505 		ST_DO_ERRSTATS(un, st_softerrs);
9506 		severity = SCSI_ERR_INFO;
9507 
9508 		/*
9509 		 * if not a special request and some data was xferred then it
9510 		 * it is not an error yet
9511 		 */
9512 		if (bp != un->un_sbufp && (bp->b_flags & B_READ)) {
9513 			/*
9514 			 * no error for read with or without data xferred
9515 			 */
9516 			un->un_status = SUN_KEY_EOT;
9517 			un->un_eof = ST_EOT;
9518 			rval = COMMAND_DONE_ERROR;
9519 			SET_PE_FLAG(un);
9520 			goto check_keys;
9521 		} else if (bp != un->un_sbufp &&
9522 		    (pkt->pkt_state & STATE_XFERRED_DATA)) {
9523 			rval = COMMAND_DONE;
9524 		} else {
9525 			rval = COMMAND_DONE_ERROR_RECOVERED;
9526 		}
9527 
9528 		if (un->un_laststate >= ST_STATE_OPEN) {
9529 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9530 			    "blank check\n");
9531 			un->un_eof = ST_EOM;
9532 		}
9533 		if ((CDBP(pkt)->scc_cmd == SCMD_SPACE) &&
9534 		    (un->un_dp->options & ST_KNOWS_EOD) &&
9535 		    (severity = SCSI_ERR_INFO)) {
9536 			/*
9537 			 * we were doing a fast forward by skipping
9538 			 * multiple fmk at the time
9539 			 */
9540 			st_bioerror(bp, EIO);
9541 			severity = SCSI_ERR_RECOVERED;
9542 			rval	 = COMMAND_DONE;
9543 		}
9544 		SET_PE_FLAG(un);
9545 		goto check_keys;
9546 
9547 	case KEY_WRITE_PROTECT:
9548 		if (st_wrongtapetype(un)) {
9549 			un->un_status = SUN_KEY_WRONGMEDIA;
9550 			ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9551 		"wrong tape for writing- use DC6150 tape (or equivalent)\n");
9552 			severity = SCSI_ERR_UNKNOWN;
9553 		} else {
9554 			severity = SCSI_ERR_FATAL;
9555 		}
9556 		ST_DO_ERRSTATS(un, st_harderrs);
9557 		rval = COMMAND_DONE_ERROR;
9558 		st_bioerror(bp, EACCES);
9559 		break;
9560 
9561 	case KEY_UNIT_ATTENTION:
9562 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9563 		    "KEY_UNIT_ATTENTION : un_state = %d\n", un->un_state);
9564 
9565 		/*
9566 		 * If we have detected a Bus Reset and the tape
9567 		 * drive has been reserved.
9568 		 */
9569 		if (ST_RQSENSE->es_add_code == 0x29 &&
9570 			(un->un_rsvd_status & ST_RESERVE)) {
9571 			un->un_rsvd_status |= ST_LOST_RESERVE;
9572 			ST_DEBUG(ST_DEVINFO, st_label, CE_WARN,
9573 				"st_decode_sense: Lost Reservation\n");
9574 		}
9575 
9576 		if (un->un_state <= ST_STATE_OPENING) {
9577 			/*
9578 			 * Look, the tape isn't open yet, now determine
9579 			 * if the cause is a BUS RESET, Save the file and
9580 			 * Block positions for the callers to recover from
9581 			 * the loss of position.
9582 			 */
9583 			if ((un->un_fileno >= 0) &&
9584 			(un->un_fileno || un->un_blkno)) {
9585 				if (ST_RQSENSE->es_add_code == 0x29) {
9586 					un->un_save_fileno = un->un_fileno;
9587 					un->un_save_blkno = un->un_blkno;
9588 					un->un_restore_pos = 1;
9589 				}
9590 			}
9591 
9592 			if ((int)un->un_retry_ct++ < st_retry_count) {
9593 				rval = QUE_COMMAND;
9594 			} else {
9595 				rval = COMMAND_DONE_ERROR;
9596 			}
9597 			severity = SCSI_ERR_INFO;
9598 
9599 		} else {
9600 			/*
9601 			 * Check if it is an Unexpected Unit Attention.
9602 			 * If state is >= ST_STATE_OPEN, we have
9603 			 * already done the initialization .
9604 			 * In this case it is Fatal Error
9605 			 * since no further reading/writing
9606 			 * can be done with fileno set to < 0.
9607 			 */
9608 			if (un->un_state >= ST_STATE_OPEN) {
9609 				ST_DO_ERRSTATS(un, st_harderrs);
9610 				severity = SCSI_ERR_FATAL;
9611 			} else {
9612 				severity = SCSI_ERR_INFO;
9613 			}
9614 			rval = COMMAND_DONE_ERROR;
9615 		}
9616 		un->un_fileno = -1;
9617 
9618 		break;
9619 
9620 	case KEY_NOT_READY:
9621 		/*
9622 		 * If in process of getting ready retry.
9623 		 */
9624 		if (sensep->es_add_code  == 0x04 &&
9625 		    sensep->es_qual_code == 0x01 &&
9626 		    un->un_retry_ct++ < st_retry_count) {
9627 			rval = QUE_COMMAND;
9628 			severity = SCSI_ERR_INFO;
9629 		} else {
9630 			/* give up */
9631 			rval = COMMAND_DONE_ERROR;
9632 			severity = SCSI_ERR_FATAL;
9633 		}
9634 
9635 		/*
9636 		 * If this was an error and after device opened
9637 		 * do error stats.
9638 		 */
9639 		if (rval == COMMAND_DONE_ERROR &&
9640 		    un->un_state > ST_STATE_OPENING) {
9641 			ST_DO_ERRSTATS(un, st_harderrs);
9642 		}
9643 
9644 		if (ST_RQSENSE->es_add_code == 0x3a) {
9645 			if (st_error_level >= SCSI_ERR_FATAL)
9646 				scsi_log(ST_DEVINFO, st_label, CE_NOTE,
9647 				    "Tape not inserted in drive\n");
9648 			un->un_mediastate = MTIO_EJECTED;
9649 			cv_broadcast(&un->un_state_cv);
9650 		}
9651 		if ((un->un_dp->options & ST_EJECT_ON_CHANGER_FAILURE) &&
9652 		    (rval != QUE_COMMAND))
9653 			un->un_eject_tape_on_failure = st_check_asc_ascq(un);
9654 		break;
9655 
9656 	case KEY_ABORTED_COMMAND:
9657 
9658 		/*
9659 		 * Probably a parity error...
9660 		 * if we retry here then this may cause data to be
9661 		 * written twice or data skipped during reading
9662 		 */
9663 		ST_DO_ERRSTATS(un, st_harderrs);
9664 		severity = SCSI_ERR_FATAL;
9665 		rval = COMMAND_DONE_ERROR;
9666 		goto check_keys;
9667 
9668 	default:
9669 		/*
9670 		 * Undecoded sense key.	 Try retries and hope
9671 		 * that will fix the problem.  Otherwise, we're
9672 		 * dead.
9673 		 */
9674 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9675 		    "Unhandled Sense Key '%s'\n",
9676 		    sense_keys[un->un_status]);
9677 		ST_DO_ERRSTATS(un, st_harderrs);
9678 		severity = SCSI_ERR_FATAL;
9679 		rval = COMMAND_DONE_ERROR;
9680 		goto check_keys;
9681 	}
9682 
9683 	if ((!(pkt->pkt_flags & FLAG_SILENT) &&
9684 	    un->un_state >= ST_STATE_OPEN) && (DEBUGGING ||
9685 		(un->un_laststate > ST_STATE_OPENING) &&
9686 		(severity >= st_error_level))) {
9687 
9688 		scsi_errmsg(ST_SCSI_DEVP, pkt, st_label, severity,
9689 		    un->un_blkno, un->un_err_blkno, scsi_cmds, sensep);
9690 		if (sensep->es_filmk) {
9691 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
9692 			    "File Mark Detected\n");
9693 		}
9694 		if (sensep->es_eom) {
9695 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
9696 			    "End-of-Media Detected\n");
9697 		}
9698 		if (sensep->es_ili) {
9699 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
9700 			    "Incorrect Length Indicator Set\n");
9701 		}
9702 	}
9703 	get_error = geterror(bp);
9704 	if (((rval == COMMAND_DONE_ERROR) ||
9705 	    (rval == COMMAND_DONE_ERROR_RECOVERED)) &&
9706 	    ((get_error == EIO) || (get_error == 0))) {
9707 		un->un_rqs_state |= (ST_RQS_ERROR | ST_RQS_VALID);
9708 		bcopy(ST_RQSENSE, un->un_uscsi_rqs_buf, SENSE_LENGTH);
9709 		if (un->un_rqs_state & ST_RQS_READ) {
9710 		    un->un_rqs_state &= ~(ST_RQS_READ);
9711 		} else {
9712 		    un->un_rqs_state |= ST_RQS_OVR;
9713 		}
9714 	}
9715 
9716 	return (rval);
9717 }
9718 
9719 
9720 static int
9721 st_handle_intr_retry_lcmd(struct scsi_tape *un, struct buf *bp)
9722 {
9723 	int status = TRAN_ACCEPT;
9724 
9725 	mutex_enter(ST_MUTEX);
9726 
9727 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9728 		"st_handle_intr_rtr_lcmd(), un = 0x%p\n", (void *)un);
9729 
9730 	/*
9731 	 * Check to see if we hit the retry timeout. We check to make sure
9732 	 * this is the first one on the runq and make sure we have not
9733 	 * queued up any more, so this one has to be the last on the list
9734 	 * also. If it is not, we have to fail.  If it is not the first, but
9735 	 * is the last we are in trouble anyway, as we are in the interrupt
9736 	 * context here.
9737 	 */
9738 	if (((int)un->un_retry_ct > st_retry_count) ||
9739 	    ((un->un_runqf != bp) && (un->un_runql != bp))) {
9740 	    goto exit;
9741 	}
9742 
9743 	if (un->un_throttle) {
9744 		un->un_last_throttle = un->un_throttle;
9745 		un->un_throttle = 0;
9746 	}
9747 
9748 	/*
9749 	 * Here we know : bp is the first and last one on the runq
9750 	 * it is not necessary to put it back on the head of the
9751 	 * waitq and then move from waitq to runq. Save this queuing
9752 	 * and call scsi_transport.
9753 	 */
9754 
9755 	mutex_exit(ST_MUTEX);
9756 
9757 	status = scsi_transport(BP_PKT(bp));
9758 
9759 	mutex_enter(ST_MUTEX);
9760 
9761 	if (status == TRAN_ACCEPT) {
9762 		un->un_tran_retry_ct = 0;
9763 		if (un->un_last_throttle) {
9764 			un->un_throttle = un->un_last_throttle;
9765 		}
9766 		mutex_exit(ST_MUTEX);
9767 
9768 		ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9769 		    "restart transport \n");
9770 		return (0);
9771 	}
9772 
9773 	ST_DO_KSTATS(bp, kstat_runq_back_to_waitq);
9774 	mutex_exit(ST_MUTEX);
9775 
9776 	if (status == TRAN_BUSY) {
9777 	    if (st_handle_intr_busy(un, bp,
9778 		ST_TRAN_BUSY_TIMEOUT) == 0)
9779 		return (0);
9780 	}
9781 	ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
9782 		"restart transport rejected\n");
9783 	mutex_enter(ST_MUTEX);
9784 	ST_DO_ERRSTATS(un, st_transerrs);
9785 	if (un->un_last_throttle) {
9786 		un->un_throttle = un->un_last_throttle;
9787 	}
9788 exit:
9789 	mutex_exit(ST_MUTEX);
9790 	return (-1);
9791 }
9792 
9793 static int
9794 st_wrongtapetype(struct scsi_tape *un)
9795 {
9796 
9797 	ASSERT(mutex_owned(ST_MUTEX));
9798 
9799 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9800 		"st_wrongtapetype()\n");
9801 
9802 	/*
9803 	 * Hack to handle  600A, 600XTD, 6150 && 660 vs. 300XL tapes...
9804 	 */
9805 	if (un->un_dp && (un->un_dp->options & ST_QIC) && un->un_mspl) {
9806 		switch (un->un_dp->type) {
9807 		case ST_TYPE_WANGTEK:
9808 		case ST_TYPE_ARCHIVE:
9809 			/*
9810 			 * If this really worked, we could go off of
9811 			 * the density codes set in the modesense
9812 			 * page. For this drive, 0x10 == QIC-120,
9813 			 * 0xf == QIC-150, and 0x5 should be for
9814 			 * both QIC-24 and, maybe, QIC-11. However,
9815 			 * the h/w doesn't do what the manual says
9816 			 * that it should, so we'll key off of
9817 			 * getting a WRITE PROTECT error AND wp *not*
9818 			 * set in the mode sense information.
9819 			 */
9820 			/*
9821 			 * XXX but we already know that status is
9822 			 * write protect, so don't check it again.
9823 			 */
9824 
9825 			if (un->un_status == KEY_WRITE_PROTECT &&
9826 			    un->un_mspl->wp == 0) {
9827 				return (1);
9828 			}
9829 			break;
9830 		default:
9831 			break;
9832 		}
9833 	}
9834 	return (0);
9835 }
9836 
9837 static int
9838 st_check_error(struct scsi_tape *un, struct scsi_pkt *pkt)
9839 {
9840 	int action;
9841 
9842 	ASSERT(mutex_owned(ST_MUTEX));
9843 
9844 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_check_error()\n");
9845 
9846 	if (SCBP_C(pkt) == STATUS_RESERVATION_CONFLICT) {
9847 		action = COMMAND_DONE_EACCES;
9848 		un->un_rsvd_status |= ST_RESERVATION_CONFLICT;
9849 	} else if (SCBP(pkt)->sts_busy) {
9850 		ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG, "unit busy\n");
9851 		if ((int)un->un_retry_ct++ < st_retry_count) {
9852 			action = QUE_BUSY_COMMAND;
9853 		} else if ((un->un_rsvd_status &
9854 		    (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) == 0) {
9855 			/*
9856 			 * If this is a command done before reserve is done
9857 			 * don't reset.
9858 			 */
9859 			action = COMMAND_DONE_ERROR;
9860 		} else {
9861 			ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN,
9862 			    "unit busy too long\n");
9863 			mutex_exit(ST_MUTEX);
9864 			if (scsi_reset(ROUTE, RESET_TARGET) == 0) {
9865 				(void) scsi_reset(ROUTE, RESET_ALL);
9866 			}
9867 			mutex_enter(ST_MUTEX);
9868 			action = COMMAND_DONE_ERROR;
9869 		}
9870 	} else if (SCBP(pkt)->sts_chk) {
9871 		/*
9872 		 * we should only get here if the auto rqsense failed
9873 		 * thru a uscsi cmd without autorequest sense
9874 		 * so we just try again
9875 		 */
9876 		action = QUE_SENSE;
9877 	} else {
9878 		action = COMMAND_DONE;
9879 	}
9880 	return (action);
9881 }
9882 
9883 static void
9884 st_calc_bnum(struct scsi_tape *un, struct buf *bp)
9885 {
9886 	int n;
9887 
9888 	ASSERT(mutex_owned(ST_MUTEX));
9889 
9890 	if (un->un_bsize == 0) {
9891 		n = ((bp->b_bcount - bp->b_resid  == 0) ? 0 : 1);
9892 		un->un_kbytes_xferred += (bp->b_bcount - bp->b_resid)/1000;
9893 	} else {
9894 		n = ((bp->b_bcount - bp->b_resid) / un->un_bsize);
9895 	}
9896 	un->un_blkno += n;
9897 }
9898 
9899 static void
9900 st_set_state(struct scsi_tape *un)
9901 {
9902 	struct buf *bp = un->un_runqf;
9903 	struct scsi_pkt *sp = BP_PKT(bp);
9904 	struct uscsi_cmd *ucmd;
9905 
9906 	ASSERT(mutex_owned(ST_MUTEX));
9907 
9908 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
9909 	    "st_set_state(): un_eof=%x	fmneeded=%x  pkt_resid=0x%lx (%ld)\n",
9910 		un->un_eof, un->un_fmneeded, sp->pkt_resid, sp->pkt_resid);
9911 
9912 	if (bp != un->un_sbufp) {
9913 #ifdef STDEBUG
9914 		if (DEBUGGING && sp->pkt_resid) {
9915 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
9916 			    "pkt_resid %ld bcount %ld\n",
9917 			    sp->pkt_resid, bp->b_bcount);
9918 		}
9919 #endif
9920 		bp->b_resid = sp->pkt_resid;
9921 		st_calc_bnum(un, bp);
9922 		if (bp->b_flags & B_READ) {
9923 			un->un_lastop = ST_OP_READ;
9924 			un->un_fmneeded = 0;
9925 		} else {
9926 			un->un_lastop = ST_OP_WRITE;
9927 			if (un->un_dp->options & ST_REEL) {
9928 				un->un_fmneeded = 2;
9929 			} else {
9930 				un->un_fmneeded = 1;
9931 			}
9932 		}
9933 		/*
9934 		 * all is honky dory at this point, so let's
9935 		 * readjust the throttle, to increase speed, if we
9936 		 * have not throttled down.
9937 		 */
9938 		if (un->un_throttle)
9939 			un->un_throttle = un->un_max_throttle;
9940 	} else {
9941 		char saved_lastop = un->un_lastop;
9942 		uchar_t cmd = (uchar_t)(intptr_t)bp->b_forw;
9943 
9944 		un->un_lastop = ST_OP_CTL;
9945 
9946 		switch (cmd) {
9947 		case SCMD_WRITE:
9948 			bp->b_resid = sp->pkt_resid;
9949 			un->un_lastop = ST_OP_WRITE;
9950 			st_calc_bnum(un, bp);
9951 			if (un->un_dp->options & ST_REEL) {
9952 				un->un_fmneeded = 2;
9953 			} else {
9954 				un->un_fmneeded = 1;
9955 			}
9956 			break;
9957 		case SCMD_READ:
9958 			bp->b_resid = sp->pkt_resid;
9959 			un->un_lastop = ST_OP_READ;
9960 			st_calc_bnum(un, bp);
9961 			un->un_fmneeded = 0;
9962 			break;
9963 		case SCMD_WRITE_FILE_MARK:
9964 			if (un->un_eof != ST_EOM)
9965 				un->un_eof = ST_NO_EOF;
9966 			un->un_lastop = ST_OP_WEOF;
9967 			un->un_fileno += (bp->b_bcount - bp->b_resid);
9968 			un->un_blkno = 0;
9969 			if (un->un_dp->options & ST_REEL) {
9970 				un->un_fmneeded -=
9971 					(bp->b_bcount - bp->b_resid);
9972 				if (un->un_fmneeded < 0) {
9973 					un->un_fmneeded = 0;
9974 				}
9975 			} else {
9976 				un->un_fmneeded = 0;
9977 			}
9978 
9979 			break;
9980 		case SCMD_REWIND:
9981 			un->un_eof = ST_NO_EOF;
9982 			un->un_fileno = 0;
9983 			un->un_blkno = 0;
9984 			break;
9985 
9986 		case SCMD_SPACE:
9987 		{
9988 			int space_fmk, count;
9989 			long resid;
9990 
9991 			count = (int)space_cnt(bp->b_bcount);
9992 			resid = (long)space_cnt(bp->b_resid);
9993 			space_fmk = ((bp->b_bcount) & (1<<24)) ? 1 : 0;
9994 
9995 
9996 			if (count >= 0) {
9997 				if (space_fmk) {
9998 					if (un->un_eof <= ST_EOF) {
9999 						un->un_eof = ST_NO_EOF;
10000 					}
10001 					un->un_fileno += (count - resid);
10002 					un->un_blkno = 0;
10003 				} else {
10004 					un->un_blkno += count - resid;
10005 				}
10006 			} else if (count < 0) {
10007 				if (space_fmk) {
10008 					un->un_fileno -=
10009 					    ((-count) - resid);
10010 					if (un->un_fileno < 0) {
10011 						un->un_fileno = 0;
10012 						un->un_blkno = 0;
10013 					} else {
10014 						un->un_blkno = INF;
10015 					}
10016 				} else {
10017 					if (un->un_eof >= ST_EOF_PENDING) {
10018 					/*
10019 					 * we stepped back into
10020 					 * a previous file; we are not
10021 					 * making an effort to pretend that
10022 					 * we are still in the current file
10023 					 * ie. logical == physical position
10024 					 * and leave it to st_ioctl to correct
10025 					 */
10026 						if (un->un_fileno > 0) {
10027 							un->un_fileno--;
10028 							un->un_blkno = INF;
10029 						} else {
10030 							un->un_blkno = 0;
10031 						}
10032 					} else {
10033 						un->un_blkno -=
10034 						    (-count) - resid;
10035 					}
10036 				}
10037 			}
10038 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10039 			    "aft_space rs %ld fil %d blk %ld\n",
10040 			    resid, un->un_fileno, un->un_blkno);
10041 			break;
10042 		}
10043 		case SCMD_LOAD:
10044 			if (bp->b_bcount & 0x1) {
10045 				un->un_fileno = 0;
10046 			} else {
10047 				un->un_state = ST_STATE_OFFLINE;
10048 				un->un_fileno = -1;
10049 			}
10050 			un->un_density_known = 0;
10051 			un->un_eof = ST_NO_EOF;
10052 			un->un_blkno = 0;
10053 			break;
10054 		case SCMD_ERASE:
10055 			un->un_eof = ST_NO_EOF;
10056 			un->un_blkno = 0;
10057 			un->un_fileno = 0;
10058 			break;
10059 		case SCMD_RESERVE:
10060 			un->un_rsvd_status |= ST_RESERVE;
10061 			un->un_rsvd_status &=
10062 			    ~(ST_RELEASE | ST_LOST_RESERVE |
10063 			    ST_RESERVATION_CONFLICT);
10064 			un->un_lastop = saved_lastop;
10065 			break;
10066 		case SCMD_RELEASE:
10067 			un->un_rsvd_status |= ST_RELEASE;
10068 			un->un_rsvd_status &=
10069 			    ~(ST_RESERVE | ST_LOST_RESERVE |
10070 			    ST_RESERVATION_CONFLICT);
10071 			un->un_lastop = saved_lastop;
10072 			break;
10073 		case SCMD_PERSISTENT_RESERVE_IN:
10074 			ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
10075 			    "PGR_IN command\n");
10076 			break;
10077 		case SCMD_PERSISTENT_RESERVE_OUT:
10078 			switch (sp->pkt_cdbp[1] & ST_SA_MASK) {
10079 			case ST_SA_SCSI3_RESERVE:
10080 			case ST_SA_SCSI3_PREEMPT:
10081 			case ST_SA_SCSI3_PREEMPTANDABORT:
10082 				un->un_rsvd_status |=
10083 				    ST_APPLICATION_RESERVATIONS;
10084 				ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
10085 				    "PGR Reserve and set: entering"
10086 				    " ST_APPLICATION_RESERVATIONS mode");
10087 				break;
10088 			case ST_SA_SCSI3_RELEASE:
10089 			case ST_SA_SCSI3_CLEAR:
10090 				un->un_rsvd_status &=
10091 				    ~ST_APPLICATION_RESERVATIONS;
10092 				ST_DEBUG6(ST_DEVINFO, st_label, CE_WARN,
10093 				    "PGR Release and reset: exiting"
10094 				    " ST_APPLICATION_RESERVATIONS mode");
10095 				break;
10096 			}
10097 			break;
10098 		case SCMD_TEST_UNIT_READY:
10099 		case SCMD_READ_BLKLIM:
10100 		case SCMD_REQUEST_SENSE:
10101 		case SCMD_INQUIRY:
10102 		case SCMD_RECOVER_BUF:
10103 		case SCMD_MODE_SELECT:
10104 		case SCMD_MODE_SENSE:
10105 		case SCMD_DOORLOCK:
10106 		case SCMD_READ_POSITION:
10107 		case SCMD_READ_BUFFER:
10108 		case SCMD_REPORT_DENSITIES:
10109 		case SCMD_LOG_SELECT_G1:
10110 		case SCMD_LOG_SENSE_G1:
10111 		case SCMD_REPORT_LUNS:
10112 			un->un_lastop = saved_lastop;
10113 			break;
10114 		case SCMD_LOCATE:	/* Locate makes position unknown */
10115 		default:
10116 			/*
10117 			 * Unknown command, If was USCSI and USCSI_SILENT
10118 			 * flag was not set, set position to unknown.
10119 			 */
10120 			if ((((ucmd = BP_UCMD(bp)) != NULL) &&
10121 			    (ucmd->uscsi_flags & USCSI_SILENT) == 0)) {
10122 				ST_DEBUG2(ST_DEVINFO, st_label, CE_WARN,
10123 				    "unknown cmd 0x%X caused loss of state\n",
10124 				    cmd);
10125 			} else {
10126 				break;
10127 			}
10128 			/* FALLTHROUGH */
10129 		case SCMD_WRITE_BUFFER: /* Writes new firmware to device */
10130 			un->un_fileno = -1;
10131 			break;
10132 		}
10133 	}
10134 
10135 	/*
10136 	 * In the st driver we have a logical and physical file position.
10137 	 * Under BSD behavior, when you get a zero read, the logical position
10138 	 * is before the filemark but after the last record of the file.
10139 	 * The physical position is after the filemark. MTIOCGET should always
10140 	 * return the logical file position.
10141 	 *
10142 	 * The next read gives a silent skip to the next file.
10143 	 * Under SVR4, the logical file position remains before the filemark
10144 	 * until the file is closed or a space operation is performed.
10145 	 * Hence set err_resid and err_file before changing fileno if case
10146 	 * BSD Behaviour.
10147 	 */
10148 	un->un_err_resid = bp->b_resid;
10149 	un->un_err_fileno = un->un_fileno;
10150 	un->un_err_blkno = un->un_blkno;
10151 	un->un_retry_ct = 0;
10152 
10153 
10154 	/*
10155 	 * If we've seen a filemark via the last read operation
10156 	 * advance the file counter, but mark things such that
10157 	 * the next read operation gets a zero count. We have
10158 	 * to put this here to handle the case of sitting right
10159 	 * at the end of a tape file having seen the file mark,
10160 	 * but the tape is closed and then re-opened without
10161 	 * any further i/o. That is, the position information
10162 	 * must be updated before a close.
10163 	 */
10164 
10165 	if (un->un_lastop == ST_OP_READ && un->un_eof == ST_EOF_PENDING) {
10166 		/*
10167 		 * If we're a 1/2" tape, and we get a filemark
10168 		 * right on block 0, *AND* we were not in the
10169 		 * first file on the tape, and we've hit logical EOM.
10170 		 * We'll mark the state so that later we do the
10171 		 * right thing (in st_close(), st_strategy() or
10172 		 * st_ioctl()).
10173 		 *
10174 		 */
10175 		if ((un->un_dp->options & ST_REEL) &&
10176 			!(un->un_dp->options & ST_READ_IGNORE_EOFS) &&
10177 		    un->un_blkno == 0 && un->un_fileno > 0) {
10178 			un->un_eof = ST_EOT_PENDING;
10179 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10180 			    "eot pending\n");
10181 			un->un_fileno++;
10182 			un->un_blkno = 0;
10183 		} else if (BSD_BEHAVIOR) {
10184 			/*
10185 			 * If the read of the filemark was a side effect
10186 			 * of reading some blocks (i.e., data was actually
10187 			 * read), then the EOF mark is pending and the
10188 			 * bump into the next file awaits the next read
10189 			 * operation (which will return a zero count), or
10190 			 * a close or a space operation, else the bump
10191 			 * into the next file occurs now.
10192 			 */
10193 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10194 			    "resid=%lx, bcount=%lx\n",
10195 				bp->b_resid, bp->b_bcount);
10196 			if (bp->b_resid != bp->b_bcount) {
10197 				un->un_eof = ST_EOF;
10198 			} else {
10199 				un->un_silent_skip = 1;
10200 				un->un_eof = ST_NO_EOF;
10201 				un->un_fileno++;
10202 				un->un_save_blkno = un->un_blkno;
10203 				un->un_blkno = 0;
10204 			}
10205 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10206 			    "eof of file %d, un_eof=%d\n",
10207 			    un->un_fileno, un->un_eof);
10208 		} else if (SVR4_BEHAVIOR) {
10209 			/*
10210 			 * If the read of the filemark was a side effect
10211 			 * of reading some blocks (i.e., data was actually
10212 			 * read), then the next read should return 0
10213 			 */
10214 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10215 			    "resid=%lx, bcount=%lx\n",
10216 			    bp->b_resid, bp->b_bcount);
10217 			if (bp->b_resid == bp->b_bcount) {
10218 				un->un_eof = ST_EOF;
10219 			}
10220 			ST_DEBUG6(ST_DEVINFO, st_label, SCSI_DEBUG,
10221 			    "eof of file=%d, un_eof=%d\n",
10222 			    un->un_fileno, un->un_eof);
10223 		}
10224 	}
10225 }
10226 
10227 /*
10228  * set the correct un_errno, to take corner cases into consideration
10229  */
10230 static void
10231 st_set_pe_errno(struct scsi_tape *un)
10232 {
10233 	ASSERT(mutex_owned(ST_MUTEX));
10234 
10235 	/* if errno is already set, don't reset it */
10236 	if (un->un_errno)
10237 		return;
10238 
10239 	/* here un_errno == 0 */
10240 	/*
10241 	 * if the last transfer before flushing all the
10242 	 * waiting I/O's, was 0 (resid = count), then we
10243 	 * want to give the user an error on all the rest,
10244 	 * so here.  If there was a transfer, we set the
10245 	 * resid and counts to 0, and let it drop through,
10246 	 * giving a zero return.  the next I/O will then
10247 	 * give an error.
10248 	 */
10249 	if (un->un_last_resid == un->un_last_count) {
10250 		switch (un->un_eof) {
10251 		case ST_EOM:
10252 			un->un_errno = ENOMEM;
10253 			break;
10254 		case ST_EOT:
10255 		case ST_EOF:
10256 			un->un_errno = EIO;
10257 			break;
10258 		}
10259 	} else {
10260 		/*
10261 		 * we know they did not have a zero, so make
10262 		 * sure they get one
10263 		 */
10264 		un->un_last_resid = un->un_last_count = 0;
10265 	}
10266 }
10267 
10268 
10269 /*
10270  * send in a marker pkt to terminate flushing of commands by BBA (via
10271  * flush-on-errors) property.  The HBA will always return TRAN_ACCEPT
10272  */
10273 static void
10274 st_hba_unflush(struct scsi_tape *un)
10275 {
10276 	ASSERT(mutex_owned(ST_MUTEX));
10277 
10278 	if (!un->un_flush_on_errors)
10279 		return;
10280 
10281 #ifdef FLUSH_ON_ERRORS
10282 
10283 	if (!un->un_mkr_pkt) {
10284 		un->un_mkr_pkt = scsi_init_pkt(ROUTE, NULL, (struct buf *)NULL,
10285 		    NULL, 0, 0, 0, SLEEP_FUNC, NULL);
10286 
10287 		/* we slept, so it must be there */
10288 		pkt->pkt_flags |= FLAG_FLUSH_MARKER;
10289 	}
10290 
10291 	mutex_exit(ST_MUTEX);
10292 	scsi_transport(un->un_mkr_pkt);
10293 	mutex_enter(ST_MUTEX);
10294 #endif
10295 }
10296 
10297 static void
10298 st_clean_print(dev_info_t *dev, char *label, uint_t level,
10299 	char *title, char *data, int len)
10300 {
10301 	int	i;
10302 	char	buf[256];
10303 
10304 	(void) sprintf(buf, "%s: ", title);
10305 	for (i = 0; i < len; i++) {
10306 		(void) sprintf(&buf[(int)strlen(buf)], "0x%x ",
10307 			(data[i] & 0xff));
10308 	}
10309 	(void) sprintf(&buf[(int)strlen(buf)], "\n");
10310 
10311 	scsi_log(dev, label, level, "%s", buf);
10312 }
10313 
10314 /*
10315  * Conditionally enabled debugging
10316  */
10317 #ifdef	STDEBUG
10318 static void
10319 st_debug_cmds(struct scsi_tape *un, int com, int count, int wait)
10320 {
10321 	char tmpbuf[64];
10322 
10323 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10324 	    "cmd=%s count=0x%x (%d)	 %ssync\n",
10325 	    scsi_cmd_name(com, scsi_cmds, tmpbuf),
10326 	    count, count,
10327 	    wait == ASYNC_CMD ? "a" : "");
10328 }
10329 
10330 /*
10331  * Returns pointer to name of minor node name of device 'dev'.
10332  */
10333 static char *
10334 st_dev_name(dev_t dev)
10335 {
10336 	const char density[] = { 'l', 'm', 'h', 'c' };
10337 	static char name[4];
10338 	minor_t minor;
10339 	int nprt = 0;
10340 
10341 	minor = getminor(dev);
10342 	name[nprt] = density[(minor & MT_DENSITY_MASK) >> 3];
10343 
10344 	if (minor & MT_BSD) {
10345 		name[++nprt] = 'b';
10346 	}
10347 
10348 	if (minor & MT_NOREWIND) {
10349 		name[++nprt] = 'n';
10350 	}
10351 
10352 	/* NULL terminator */
10353 	name[++nprt] = 0;
10354 
10355 	return (name);
10356 }
10357 #endif	/* STDEBUG */
10358 
10359 /*
10360  * Soft error reporting, so far unique to each drive
10361  *
10362  * Currently supported: exabyte and DAT soft error reporting
10363  */
10364 static int
10365 st_report_exabyte_soft_errors(dev_t dev, int flag)
10366 {
10367 	uchar_t *sensep;
10368 	int amt;
10369 	int rval = 0;
10370 	char cdb[CDB_GROUP0], *c = cdb;
10371 	struct uscsi_cmd *com;
10372 
10373 	GET_SOFT_STATE(dev);
10374 
10375 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10376 	    "st_report_exabyte_soft_errors(dev = 0x%lx, flag = %d)\n",
10377 	    dev, flag);
10378 
10379 	ASSERT(mutex_owned(ST_MUTEX));
10380 
10381 	com = kmem_zalloc(sizeof (*com), KM_SLEEP);
10382 	sensep = kmem_zalloc(TAPE_SENSE_LENGTH, KM_SLEEP);
10383 
10384 	*c++ = SCMD_REQUEST_SENSE;
10385 	*c++ = 0;
10386 	*c++ = 0;
10387 	*c++ = 0;
10388 	*c++ = TAPE_SENSE_LENGTH;
10389 	/*
10390 	 * set CLRCNT (byte 5, bit 7 which clears the error counts)
10391 	 */
10392 	*c   = (char)0x80;
10393 
10394 	com->uscsi_cdb = cdb;
10395 	com->uscsi_cdblen = CDB_GROUP0;
10396 	com->uscsi_bufaddr = (caddr_t)sensep;
10397 	com->uscsi_buflen = TAPE_SENSE_LENGTH;
10398 	com->uscsi_flags = USCSI_DIAGNOSE | USCSI_SILENT
10399 		| USCSI_READ | USCSI_RQENABLE;
10400 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
10401 
10402 	rval = st_ioctl_cmd(dev, com, UIO_SYSSPACE, UIO_SYSSPACE,
10403 		UIO_SYSSPACE);
10404 	if (rval || com->uscsi_status) {
10405 		goto done;
10406 	}
10407 
10408 	/*
10409 	 * was there enough data?
10410 	 */
10411 	amt = (int)TAPE_SENSE_LENGTH - com->uscsi_resid;
10412 
10413 	if ((amt >= 19) && un->un_kbytes_xferred) {
10414 		uint_t count, error_rate;
10415 		uint_t rate;
10416 
10417 		if (sensep[21] & CLN) {
10418 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
10419 			    "Periodic head cleaning required");
10420 		}
10421 		if (un->un_kbytes_xferred < (EXABYTE_MIN_TRANSFER/1000))
10422 			goto done;
10423 		/*
10424 		 * check if soft error reporting needs to be done.
10425 		 */
10426 		count = sensep[16] << 16 | sensep[17] << 8 | sensep[18];
10427 		count &= 0xffffff;
10428 		error_rate = (count * 100)/un->un_kbytes_xferred;
10429 
10430 #ifdef	STDEBUG
10431 		if (st_soft_error_report_debug) {
10432 			scsi_log(ST_DEVINFO, st_label, CE_NOTE,
10433 			    "Exabyte Soft Error Report:\n");
10434 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
10435 			    "read/write error counter: %d\n", count);
10436 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
10437 			    "number of bytes transferred: %dK\n",
10438 				un->un_kbytes_xferred);
10439 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
10440 			    "error_rate: %d%%\n", error_rate);
10441 
10442 			if (amt >= 22) {
10443 				scsi_log(ST_DEVINFO, st_label, CE_CONT,
10444 				    "unit sense: 0x%b 0x%b 0x%b\n",
10445 				    sensep[19], SENSE_19_BITS,
10446 				    sensep[20], SENSE_20_BITS,
10447 				    sensep[21], SENSE_21_BITS);
10448 			}
10449 			if (amt >= 27) {
10450 				scsi_log(ST_DEVINFO, st_label, CE_CONT,
10451 				    "tracking retry counter: %d\n",
10452 				    sensep[26]);
10453 				scsi_log(ST_DEVINFO, st_label, CE_CONT,
10454 				    "read/write retry counter: %d\n",
10455 				    sensep[27]);
10456 			}
10457 		}
10458 #endif
10459 
10460 		if (flag & FWRITE) {
10461 			rate = EXABYTE_WRITE_ERROR_THRESHOLD;
10462 		} else {
10463 			rate = EXABYTE_READ_ERROR_THRESHOLD;
10464 		}
10465 		if (error_rate >= rate) {
10466 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
10467 			    "Soft error rate (%d%%) during %s was too high",
10468 			    error_rate,
10469 			    ((flag & FWRITE) ? wrg_str : rdg_str));
10470 			scsi_log(ST_DEVINFO, st_label, CE_CONT,
10471 			    "Please, replace tape cartridge\n");
10472 		}
10473 	}
10474 
10475 done:
10476 	kmem_free(com, sizeof (*com));
10477 	kmem_free(sensep, TAPE_SENSE_LENGTH);
10478 
10479 	if (rval != 0) {
10480 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
10481 		    "exabyte soft error reporting failed\n");
10482 	}
10483 	return (rval);
10484 }
10485 
10486 /*
10487  * this is very specific to Archive 4mm dat
10488  */
10489 #define	ONEGIG	(1024 * 1024 * 1024)
10490 
10491 static int
10492 st_report_dat_soft_errors(dev_t dev, int flag)
10493 {
10494 	uchar_t *sensep;
10495 	int amt, i;
10496 	int rval = 0;
10497 	char cdb[CDB_GROUP1], *c = cdb;
10498 	struct uscsi_cmd *com;
10499 
10500 	GET_SOFT_STATE(dev);
10501 
10502 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10503 	    "st_report_dat_soft_errors(dev = 0x%lx, flag = %d)\n", dev, flag);
10504 
10505 	ASSERT(mutex_owned(ST_MUTEX));
10506 
10507 	com = kmem_zalloc(sizeof (*com), KM_SLEEP);
10508 	sensep = kmem_zalloc(LOG_SENSE_LENGTH, KM_SLEEP);
10509 
10510 	*c++ = SCMD_LOG_SENSE_G1;
10511 	*c++ = 0;
10512 	*c++ = (flag & FWRITE) ? 0x42 : 0x43;
10513 	*c++ = 0;
10514 	*c++ = 0;
10515 	*c++ = 0;
10516 	*c++ = 2;
10517 	*c++ = 0;
10518 	*c++ = (char)LOG_SENSE_LENGTH;
10519 	*c   = 0;
10520 	com->uscsi_cdb    = cdb;
10521 	com->uscsi_cdblen  = CDB_GROUP1;
10522 	com->uscsi_bufaddr = (caddr_t)sensep;
10523 	com->uscsi_buflen  = LOG_SENSE_LENGTH;
10524 	com->uscsi_flags   =
10525 	    USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ | USCSI_RQENABLE;
10526 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
10527 	rval =
10528 	    st_ioctl_cmd(dev, com, UIO_SYSSPACE, UIO_SYSSPACE, UIO_SYSSPACE);
10529 	if (rval) {
10530 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
10531 		    "DAT soft error reporting failed\n");
10532 	}
10533 	if (rval || com->uscsi_status) {
10534 		goto done;
10535 	}
10536 
10537 	/*
10538 	 * was there enough data?
10539 	 */
10540 	amt = (int)LOG_SENSE_LENGTH - com->uscsi_resid;
10541 
10542 	if ((amt >= MIN_LOG_SENSE_LENGTH) && un->un_kbytes_xferred) {
10543 		int total, retries, param_code;
10544 
10545 		total = -1;
10546 		retries = -1;
10547 		amt = sensep[3] + 4;
10548 
10549 
10550 #ifdef STDEBUG
10551 		if (st_soft_error_report_debug) {
10552 			(void) printf("logsense:");
10553 			for (i = 0; i < MIN_LOG_SENSE_LENGTH; i++) {
10554 				if (i % 16 == 0) {
10555 					(void) printf("\t\n");
10556 				}
10557 				(void) printf(" %x", sensep[i]);
10558 			}
10559 			(void) printf("\n");
10560 		}
10561 #endif
10562 
10563 		/*
10564 		 * parse the param_codes
10565 		 */
10566 		if (sensep[0] == 2 || sensep[0] == 3) {
10567 			for (i = 4; i < amt; i++) {
10568 				param_code = (sensep[i++] << 8);
10569 				param_code += sensep[i++];
10570 				i++; /* skip control byte */
10571 				if (param_code == 5) {
10572 					if (sensep[i++] == 4) {
10573 						total = (sensep[i++] << 24);
10574 						total += (sensep[i++] << 16);
10575 						total += (sensep[i++] << 8);
10576 						total += sensep[i];
10577 					}
10578 				} else if (param_code == 0x8007) {
10579 					if (sensep[i++] == 2) {
10580 						retries = sensep[i++] << 8;
10581 						retries += sensep[i];
10582 					}
10583 				} else {
10584 					i += sensep[i];
10585 				}
10586 			}
10587 		}
10588 
10589 		/*
10590 		 * if the log sense returned valid numbers then determine
10591 		 * the read and write error thresholds based on the amount of
10592 		 * data transferred
10593 		 */
10594 
10595 		if (total > 0 && retries > 0) {
10596 			short normal_retries = 0;
10597 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
10598 			"total xferred (%s) =%x, retries=%x\n",
10599 				((flag & FWRITE) ? wrg_str : rdg_str),
10600 				total, retries);
10601 
10602 			if (flag & FWRITE) {
10603 				if (total <=
10604 					WRITE_SOFT_ERROR_WARNING_THRESHOLD) {
10605 					normal_retries =
10606 						DAT_SMALL_WRITE_ERROR_THRESHOLD;
10607 				} else {
10608 					normal_retries =
10609 						DAT_LARGE_WRITE_ERROR_THRESHOLD;
10610 				}
10611 			} else {
10612 				if (total <=
10613 					READ_SOFT_ERROR_WARNING_THRESHOLD) {
10614 					normal_retries =
10615 						DAT_SMALL_READ_ERROR_THRESHOLD;
10616 				} else {
10617 					normal_retries =
10618 						DAT_LARGE_READ_ERROR_THRESHOLD;
10619 				}
10620 			}
10621 
10622 			ST_DEBUG4(ST_DEVINFO, st_label, SCSI_DEBUG,
10623 			"normal retries=%d\n", normal_retries);
10624 
10625 			if (retries >= normal_retries) {
10626 				scsi_log(ST_DEVINFO, st_label, CE_WARN,
10627 				    "Soft error rate (retries = %d) during "
10628 				    "%s was too high",  retries,
10629 				    ((flag & FWRITE) ? wrg_str : rdg_str));
10630 				scsi_log(ST_DEVINFO, st_label, CE_CONT,
10631 				    "Periodic head cleaning required "
10632 				    "and/or replace tape cartridge\n");
10633 			}
10634 
10635 		} else if (total == -1 || retries == -1) {
10636 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
10637 			    "log sense parameter code does not make sense\n");
10638 		}
10639 	}
10640 
10641 	/*
10642 	 * reset all values
10643 	 */
10644 	c = cdb;
10645 	*c++ = SCMD_LOG_SELECT_G1;
10646 	*c++ = 2;	/* this resets all values */
10647 	*c++ = (char)0xc0;
10648 	*c++ = 0;
10649 	*c++ = 0;
10650 	*c++ = 0;
10651 	*c++ = 0;
10652 	*c++ = 0;
10653 	*c++ = 0;
10654 	*c   = 0;
10655 	com->uscsi_bufaddr = NULL;
10656 	com->uscsi_buflen  = 0;
10657 	com->uscsi_flags   = USCSI_DIAGNOSE | USCSI_SILENT | USCSI_RQENABLE;
10658 	rval =
10659 	    st_ioctl_cmd(dev, com, UIO_SYSSPACE, UIO_SYSSPACE, UIO_SYSSPACE);
10660 	if (rval) {
10661 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
10662 		    "DAT soft error reset failed\n");
10663 	}
10664 done:
10665 	kmem_free(com, sizeof (*com));
10666 	kmem_free(sensep, LOG_SENSE_LENGTH);
10667 	return (rval);
10668 }
10669 
10670 static int
10671 st_report_soft_errors(dev_t dev, int flag)
10672 {
10673 	GET_SOFT_STATE(dev);
10674 
10675 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10676 	    "st_report_soft_errors(dev = 0x%lx, flag = %d)\n", dev, flag);
10677 
10678 	ASSERT(mutex_owned(ST_MUTEX));
10679 
10680 	switch (un->un_dp->type) {
10681 	case ST_TYPE_EXB8500:
10682 	case ST_TYPE_EXABYTE:
10683 		return (st_report_exabyte_soft_errors(dev, flag));
10684 		/*NOTREACHED*/
10685 	case ST_TYPE_PYTHON:
10686 		return (st_report_dat_soft_errors(dev, flag));
10687 		/*NOTREACHED*/
10688 	default:
10689 		un->un_dp->options &= ~ST_SOFT_ERROR_REPORTING;
10690 		return (-1);
10691 	}
10692 }
10693 
10694 /*
10695  * persistent error routines
10696  */
10697 
10698 /*
10699  * enable persistent errors, and set the throttle appropriately, checking
10700  * for flush-on-errors capability
10701  */
10702 static void
10703 st_turn_pe_on(struct scsi_tape *un)
10704 {
10705 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_on\n");
10706 	ASSERT(mutex_owned(ST_MUTEX));
10707 
10708 	un->un_persistence = 1;
10709 
10710 	/*
10711 	 * only use flush-on-errors if auto-request-sense and untagged-qing are
10712 	 * enabled.  This will simplify the error handling for request senses
10713 	 */
10714 
10715 	if (un->un_arq_enabled && un->un_untagged_qing) {
10716 		uchar_t f_o_e;
10717 
10718 		mutex_exit(ST_MUTEX);
10719 		f_o_e = (scsi_ifsetcap(ROUTE, "flush-on-errors", 1, 1) == 1) ?
10720 		    1 : 0;
10721 		mutex_enter(ST_MUTEX);
10722 
10723 		un->un_flush_on_errors = f_o_e;
10724 	} else {
10725 		un->un_flush_on_errors = 0;
10726 	}
10727 
10728 	if (un->un_flush_on_errors)
10729 		un->un_max_throttle = (uchar_t)st_max_throttle;
10730 	else
10731 		un->un_max_throttle = 1;
10732 
10733 	if (un->un_dp->options & ST_RETRY_ON_RECOVERED_DEFERRED_ERROR)
10734 		un->un_max_throttle = 1;
10735 
10736 	/* this will send a marker pkt */
10737 	CLEAR_PE(un);
10738 }
10739 
10740 /*
10741  * This turns persistent errors permanently off
10742  */
10743 static void
10744 st_turn_pe_off(struct scsi_tape *un)
10745 {
10746 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_off\n");
10747 	ASSERT(mutex_owned(ST_MUTEX));
10748 
10749 	/* turn it off for good */
10750 	un->un_persistence = 0;
10751 
10752 	/* this will send a marker pkt */
10753 	CLEAR_PE(un);
10754 
10755 	/* turn off flush on error capability, if enabled */
10756 	if (un->un_flush_on_errors) {
10757 		mutex_exit(ST_MUTEX);
10758 		(void) scsi_ifsetcap(ROUTE, "flush-on-errors", 0, 1);
10759 		mutex_enter(ST_MUTEX);
10760 	}
10761 
10762 
10763 	un->un_flush_on_errors = 0;
10764 }
10765 
10766 /*
10767  * This clear persistent errors, allowing more commands through, and also
10768  * sending a marker packet.
10769  */
10770 static void
10771 st_clear_pe(struct scsi_tape *un)
10772 {
10773 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_clear\n");
10774 	ASSERT(mutex_owned(ST_MUTEX));
10775 
10776 	un->un_persist_errors = 0;
10777 	un->un_throttle = un->un_last_throttle = 1;
10778 	un->un_errno = 0;
10779 	st_hba_unflush(un);
10780 }
10781 
10782 /*
10783  * This will flag persistent errors, shutting everything down, if the
10784  * application had enabled persistent errors via MTIOCPERSISTENT
10785  */
10786 static void
10787 st_set_pe_flag(struct scsi_tape *un)
10788 {
10789 	ASSERT(mutex_owned(ST_MUTEX));
10790 
10791 	if (un->un_persistence) {
10792 		ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG, "st_pe_flag\n");
10793 		un->un_persist_errors = 1;
10794 		un->un_throttle = un->un_last_throttle = 0;
10795 	}
10796 }
10797 
10798 /*
10799  * List of commands that are allowed to be done while another host holds
10800  * the reservation.
10801  */
10802 struct {
10803 	uchar_t cmd;
10804 	uchar_t byte;	/* byte to look for data */
10805 	uint32_t mask;	/* bits that matter in the above data */
10806 } rcmds[] = {
10807 	{ SCMD_TEST_UNIT_READY, 0, 0 }, /* may fail on older drives */
10808 	{ SCMD_REQUEST_SENSE, 0, 0 },
10809 	{ SCMD_READ_BLKLIM, 0, 0 },
10810 	{ SCMD_INQUIRY, 0, 0 },
10811 	{ SCMD_RESERVE, 0, 0 },
10812 	{ SCMD_RELEASE, 0, 0 },
10813 	{ SCMD_DOORLOCK, 4, 3 },	/* allow (unlock) media access only */
10814 	{ SCMD_REPORT_DENSITIES, 0, 0 },
10815 	{ SCMD_LOG_SENSE_G1, 0, 0 },
10816 	{ SCMD_PERSISTENT_RESERVE_IN, 0, 0 },
10817 	{ SCMD_PERSISTENT_RESERVE_OUT, 0, 0 },
10818 	{ SCMD_REPORT_LUNS, 0, 0 }
10819 };
10820 
10821 static int
10822 st_do_reserve(struct scsi_tape *un)
10823 {
10824 	int rval;
10825 
10826 	/*
10827 	 * Issue a Throw-Away reserve command to clear the
10828 	 * check condition.
10829 	 * If the current behaviour of reserve/release is to
10830 	 * hold reservation across opens , and if a Bus reset
10831 	 * has been issued between opens then this command
10832 	 * would set the ST_LOST_RESERVE flags in rsvd_status.
10833 	 * In this case return an EACCES so that user knows that
10834 	 * reservation has been lost in between opens.
10835 	 * If this error is not returned and we continue with
10836 	 * successful open , then user may think position of the
10837 	 * tape is still the same but inreality we would rewind the
10838 	 * tape and continue from BOT.
10839 	 */
10840 	rval = st_reserve_release(un, ST_RESERVE);
10841 	if (rval) {
10842 		if ((un->un_rsvd_status & ST_LOST_RESERVE_BETWEEN_OPENS) ==
10843 		    ST_LOST_RESERVE_BETWEEN_OPENS) {
10844 			un->un_rsvd_status &= ~(ST_LOST_RESERVE | ST_RESERVE);
10845 			un->un_errno = EACCES;
10846 			return (EACCES);
10847 		}
10848 		rval = st_reserve_release(un, ST_RESERVE);
10849 	}
10850 	if (rval == 0) {
10851 		un->un_rsvd_status |= ST_INIT_RESERVE;
10852 	}
10853 
10854 	return (rval);
10855 }
10856 
10857 static int
10858 st_check_cdb_for_need_to_reserve(struct scsi_tape *un, caddr_t cdb)
10859 {
10860 	int i;
10861 	int rval = 0;
10862 
10863 	/*
10864 	 * If already reserved no need to do it again.
10865 	 * Also if Reserve and Release are disabled Just return.
10866 	 */
10867 	if ((un->un_rsvd_status & (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) ||
10868 	    (un->un_dp->options & ST_NO_RESERVE_RELEASE)) {
10869 		ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE,
10870 		    "st_check_cdb_for_need_to_reserve() reserve unneeded 0x%x",
10871 		    cdb[0]);
10872 		return (0);
10873 	}
10874 
10875 	/* See if command is on the list */
10876 	for (i = 0; i < ST_NUM_MEMBERS(rcmds); i++) {
10877 		if ((uchar_t)cdb[0] == rcmds[i].cmd) {
10878 			/*
10879 			 * cmd is on list.
10880 			 * if byte is zero always allowed.
10881 			 */
10882 			if (rcmds[i].byte == 0) {
10883 				return (rval);
10884 			}
10885 			if (((cdb[rcmds[i].byte]) & (rcmds[i].mask)) == 0) {
10886 				return (rval);
10887 			}
10888 			break;
10889 		}
10890 	}
10891 
10892 	ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE,
10893 	    "Command 0x%x requires reservation", cdb[0]);
10894 
10895 	rval = st_do_reserve(un);
10896 
10897 	return (rval);
10898 }
10899 
10900 static int
10901 st_check_cmd_for_need_to_reserve(struct scsi_tape *un, uchar_t cmd, int cnt)
10902 {
10903 	int i;
10904 	int rval = 0;
10905 
10906 	if ((un->un_rsvd_status & (ST_RESERVE | ST_APPLICATION_RESERVATIONS)) ||
10907 	    (un->un_dp->options & ST_NO_RESERVE_RELEASE)) {
10908 		ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE,
10909 		    "st_check_cmd_for_need_to_reserve() reserve unneeded 0x%x",
10910 		    cmd);
10911 		return (0);
10912 	}
10913 
10914 	/* See if command is on the list */
10915 	for (i = 0; i < ST_NUM_MEMBERS(rcmds); i++) {
10916 		if (cmd == rcmds[i].cmd) {
10917 			/*
10918 			 * cmd is on list.
10919 			 * if byte is zero always allowed.
10920 			 */
10921 			if (rcmds[i].byte == 0) {
10922 				return (rval);
10923 			}
10924 			if (((rcmds[i].mask) & cnt) == 0) {
10925 				return (rval);
10926 			}
10927 			break;
10928 		}
10929 	}
10930 
10931 	ST_DEBUG6(ST_DEVINFO, st_label, CE_NOTE,
10932 	    "Cmd 0x%x requires reservation", cmd);
10933 
10934 	rval = st_do_reserve(un);
10935 
10936 	return (rval);
10937 }
10938 
10939 static int
10940 st_reserve_release(struct scsi_tape *un, int cmd)
10941 {
10942 	struct uscsi_cmd	uscsi_cmd;
10943 	struct uscsi_cmd	*com = &uscsi_cmd;
10944 	int			rval;
10945 	char			cdb[CDB_GROUP0];
10946 
10947 
10948 	ASSERT(mutex_owned(ST_MUTEX));
10949 
10950 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10951 	    "st_reserve_release: %s \n",
10952 	    (cmd == ST_RELEASE)?  "Releasing":"Reserving");
10953 
10954 	bzero(cdb, CDB_GROUP0);
10955 	if (cmd == ST_RELEASE) {
10956 		cdb[0] = SCMD_RELEASE;
10957 	} else {
10958 		cdb[0] = SCMD_RESERVE;
10959 	}
10960 	bzero(com, sizeof (struct uscsi_cmd));
10961 	com->uscsi_flags = USCSI_WRITE;
10962 	com->uscsi_cdb = cdb;
10963 	com->uscsi_cdblen = CDB_GROUP0;
10964 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
10965 
10966 	rval = st_ioctl_cmd(un->un_dev, com, UIO_SYSSPACE, UIO_SYSSPACE,
10967 	    UIO_SYSSPACE);
10968 
10969 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10970 	    "st_reserve_release: rval(1)=%d\n", rval);
10971 
10972 	if (rval) {
10973 		if (com->uscsi_status == STATUS_RESERVATION_CONFLICT) {
10974 			rval = EACCES;
10975 		}
10976 		/*
10977 		 * dynamically turn off reserve/release support
10978 		 * in case of drives which do not support
10979 		 * reserve/release command(ATAPI drives).
10980 		 */
10981 		if (un->un_status == KEY_ILLEGAL_REQUEST) {
10982 			if (un->un_dp->options & ST_NO_RESERVE_RELEASE) {
10983 				un->un_dp->options |= ST_NO_RESERVE_RELEASE;
10984 				ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
10985 				    "Tape unit does not support "
10986 				    "reserve/release \n");
10987 			}
10988 			rval = 0;
10989 		}
10990 	}
10991 	return (rval);
10992 }
10993 
10994 static int
10995 st_take_ownership(dev_t dev)
10996 {
10997 	int rval;
10998 
10999 	GET_SOFT_STATE(dev);
11000 	ASSERT(mutex_owned(ST_MUTEX));
11001 
11002 	ST_DEBUG3(ST_DEVINFO, st_label, SCSI_DEBUG,
11003 		"st_take_ownership: Entering ...\n");
11004 
11005 
11006 	rval = st_reserve_release(un, ST_RESERVE);
11007 	/*
11008 	 * XXX -> Should reset be done only if we get EACCES.
11009 	 * .
11010 	 */
11011 	if (rval) {
11012 		mutex_exit(ST_MUTEX);
11013 		if (scsi_reset(ROUTE, RESET_TARGET) == 0) {
11014 			if (scsi_reset(ROUTE, RESET_ALL) == 0) {
11015 				mutex_enter(ST_MUTEX);
11016 				return (EIO);
11017 			}
11018 		}
11019 		mutex_enter(ST_MUTEX);
11020 		un->un_rsvd_status &=
11021 			~(ST_LOST_RESERVE | ST_RESERVATION_CONFLICT);
11022 
11023 		mutex_exit(ST_MUTEX);
11024 		delay(drv_usectohz(ST_RESERVATION_DELAY));
11025 		mutex_enter(ST_MUTEX);
11026 		/*
11027 		 * remove the check condition.
11028 		 */
11029 		(void) st_reserve_release(un, ST_RESERVE);
11030 		if ((rval = st_reserve_release(un, ST_RESERVE)) != 0) {
11031 			if ((st_reserve_release(un, ST_RESERVE)) != 0) {
11032 				rval = (un->un_rsvd_status &
11033 					ST_RESERVATION_CONFLICT) ? EACCES : EIO;
11034 				return (rval);
11035 			}
11036 		}
11037 		/*
11038 		 * Set tape state to ST_STATE_OFFLINE , in case if
11039 		 * the user wants to continue and start using
11040 		 * the tape.
11041 		 */
11042 		un->un_state = ST_STATE_OFFLINE;
11043 		un->un_rsvd_status |= ST_INIT_RESERVE;
11044 	}
11045 	return (rval);
11046 }
11047 
11048 static int
11049 st_create_errstats(struct scsi_tape *un, int instance)
11050 {
11051 	char	kstatname[KSTAT_STRLEN];
11052 
11053 	/*
11054 	 * Create device error kstats
11055 	 */
11056 
11057 	if (un->un_errstats == (kstat_t *)0) {
11058 		(void) sprintf(kstatname, "st%d,err", instance);
11059 		un->un_errstats = kstat_create("sterr", instance, kstatname,
11060 			"device_error", KSTAT_TYPE_NAMED,
11061 			sizeof (struct st_errstats) / sizeof (kstat_named_t),
11062 			KSTAT_FLAG_PERSISTENT);
11063 
11064 		if (un->un_errstats) {
11065 			struct st_errstats	*stp;
11066 
11067 			stp = (struct st_errstats *)un->un_errstats->ks_data;
11068 			kstat_named_init(&stp->st_softerrs, "Soft Errors",
11069 				KSTAT_DATA_ULONG);
11070 			kstat_named_init(&stp->st_harderrs, "Hard Errors",
11071 				KSTAT_DATA_ULONG);
11072 			kstat_named_init(&stp->st_transerrs, "Transport Errors",
11073 				KSTAT_DATA_ULONG);
11074 			kstat_named_init(&stp->st_vid, "Vendor",
11075 				KSTAT_DATA_CHAR);
11076 			kstat_named_init(&stp->st_pid, "Product",
11077 				KSTAT_DATA_CHAR);
11078 			kstat_named_init(&stp->st_revision, "Revision",
11079 				KSTAT_DATA_CHAR);
11080 			kstat_named_init(&stp->st_serial, "Serial No",
11081 				KSTAT_DATA_CHAR);
11082 			un->un_errstats->ks_private = un;
11083 			un->un_errstats->ks_update = nulldev;
11084 			kstat_install(un->un_errstats);
11085 			/*
11086 			 * Fill in the static data
11087 			 */
11088 			(void) strncpy(&stp->st_vid.value.c[0],
11089 					ST_INQUIRY->inq_vid, 8);
11090 			/*
11091 			 * XXX:  Emulex MT-02 (and emulators) predates
11092 			 *	 SCSI-1 and has no vid & pid inquiry data.
11093 			 */
11094 			if (ST_INQUIRY->inq_len != 0) {
11095 				(void) strncpy(&stp->st_pid.value.c[0],
11096 					ST_INQUIRY->inq_pid, 16);
11097 				(void) strncpy(&stp->st_revision.value.c[0],
11098 					ST_INQUIRY->inq_revision, 4);
11099 				(void) strncpy(&stp->st_serial.value.c[0],
11100 					ST_INQUIRY->inq_serial, 12);
11101 			}
11102 		}
11103 	}
11104 	return (0);
11105 }
11106 
11107 static int
11108 st_validate_tapemarks(struct scsi_tape *un, int fileno, daddr_t blkno)
11109 {
11110 	dev_t dev;
11111 	int rval;
11112 
11113 	ASSERT(MUTEX_HELD(&un->un_sd->sd_mutex));
11114 	ASSERT(mutex_owned(ST_MUTEX));
11115 
11116 	dev = un->un_dev;
11117 
11118 	scsi_log(ST_DEVINFO, st_label, CE_NOTE, "Restoring tape"
11119 	" position at fileno=%x, blkno=%lx....", fileno, blkno);
11120 
11121 	/*
11122 	 * Rewind ? Oh yeah, Fidelity has got the STK F/W changed
11123 	 * so as not to rewind tape on RESETS: Gee, Has life ever
11124 	 * been simple in tape land ?
11125 	 */
11126 	rval = st_cmd(dev, SCMD_REWIND, 0, SYNC_CMD);
11127 	if (rval) {
11128 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
11129 		"Failed to restore the last file and block position: In"
11130 		" this state, Tape will be loaded at BOT during next open");
11131 		un->un_fileno = -1;
11132 		return (rval);
11133 	}
11134 
11135 	if (fileno) {
11136 		rval = st_cmd(dev, SCMD_SPACE, Fmk(fileno), SYNC_CMD);
11137 		if (rval) {
11138 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
11139 			"Failed to restore the last file position: In this "
11140 			" state, Tape will be loaded at BOT during next open");
11141 			un->un_fileno = -1;
11142 			return (rval);
11143 		}
11144 	}
11145 
11146 	if (blkno) {
11147 		rval = st_cmd(dev, SCMD_SPACE, Blk(blkno), SYNC_CMD);
11148 		if (rval) {
11149 			scsi_log(ST_DEVINFO, st_label, CE_WARN,
11150 			"Failed to restore the last block position: In this"
11151 			" state, tape will be loaded at BOT during next open");
11152 			un->un_fileno = -1;
11153 			return (rval);
11154 		}
11155 	}
11156 
11157 	return (0);
11158 }
11159 
11160 /*
11161  * check sense key, ASC, ASCQ in order to determine if the tape needs
11162  * to be ejected
11163  */
11164 
11165 static int
11166 st_check_asc_ascq(struct scsi_tape *un)
11167 {
11168 	struct scsi_extended_sense *sensep = ST_RQSENSE;
11169 	struct tape_failure_code   *code;
11170 
11171 	for (code = st_tape_failure_code; code->key != 0xff; code++) {
11172 		if ((code->key  == sensep->es_key) &&
11173 		    (code->add_code  == sensep->es_add_code) &&
11174 		    (code->qual_code == sensep->es_qual_code))
11175 			return (1);
11176 	}
11177 	return (0);
11178 }
11179 
11180 /*
11181  * st_logpage_supported() sends a Log Sense command with
11182  * page code = 0 = Supported Log Pages Page to the device,
11183  * to see whether the page 'page' is supported.
11184  * Return values are:
11185  * -1 if the Log Sense command fails
11186  * 0 if page is not supported
11187  * 1 if page is supported
11188  */
11189 
11190 static int
11191 st_logpage_supported(dev_t dev, uchar_t page)
11192 {
11193 	uchar_t *sp, *sensep;
11194 	unsigned length;
11195 	struct uscsi_cmd *com;
11196 	int rval;
11197 	char cdb[CDB_GROUP1] = {
11198 		SCMD_LOG_SENSE_G1,
11199 		0,
11200 		SUPPORTED_LOG_PAGES_PAGE,
11201 		0,
11202 		0,
11203 		0,
11204 		0,
11205 		0,
11206 		(char)LOG_SENSE_LENGTH,
11207 		0
11208 	};
11209 
11210 	GET_SOFT_STATE(dev);
11211 	ASSERT(mutex_owned(ST_MUTEX));
11212 
11213 	com = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
11214 	sensep = kmem_zalloc(LOG_SENSE_LENGTH, KM_SLEEP);
11215 
11216 	com->uscsi_cdb = cdb;
11217 	com->uscsi_cdblen = CDB_GROUP1;
11218 	com->uscsi_bufaddr = (caddr_t)sensep;
11219 	com->uscsi_buflen = LOG_SENSE_LENGTH;
11220 	com->uscsi_flags =
11221 		USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ | USCSI_RQENABLE;
11222 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
11223 	rval = st_ioctl_cmd(dev, com, UIO_SYSSPACE, UIO_SYSSPACE, UIO_SYSSPACE);
11224 	if (rval || com->uscsi_status) {
11225 		/* uscsi-command failed */
11226 		rval = -1;
11227 	} else {
11228 
11229 		sp = sensep + 3;
11230 
11231 		for (length = *sp++; length > 0; length--, sp++) {
11232 
11233 			if (*sp == page) {
11234 				rval = 1;
11235 				break;
11236 			}
11237 		}
11238 	}
11239 	kmem_free(com, sizeof (struct uscsi_cmd));
11240 	kmem_free(sensep, LOG_SENSE_LENGTH);
11241 	return (rval);
11242 }
11243 
11244 
11245 /*
11246  * st_check_clean_bit() gets the status of the tape's cleaning bit.
11247  *
11248  * If the device does support the TapeAlert log page, then the cleaning bit
11249  * information will be read from this page. Otherwise we will see if one of
11250  * ST_CLN_TYPE_1, ST_CLN_TYPE_2 or ST_CLN_TYPE_3 is set in the properties of
11251  * the device, which means, that we can get the cleaning bit information via
11252  * a RequestSense command.
11253  * If both methods of getting cleaning bit information are not supported
11254  * st_check_clean_bit() will return with 0. Otherwise st_check_clean_bit()
11255  * returns with
11256  * - MTF_TAPE_CLN_SUPPORTED if cleaning bit is not set or
11257  * - MTF_TAPE_CLN_SUPPORTED | MTF_TAPE_HEAD_DIRTY if cleaning bit is set.
11258  * If the call to st_ioctl_cmd() to do the Log Sense or the Request Sense
11259  * command fails, or if the amount of Request Sense data is not enough, then
11260  *  st_check_clean_bit() returns with -1.
11261  */
11262 
11263 static int
11264 st_check_clean_bit(dev_t dev)
11265 {
11266 	int rval = 0;
11267 
11268 	GET_SOFT_STATE(dev);
11269 
11270 	ASSERT(mutex_owned(ST_MUTEX));
11271 
11272 	if (un->un_HeadClean & TAPE_ALERT_NOT_SUPPORTED) {
11273 		return (rval);
11274 	}
11275 
11276 	if (un->un_HeadClean == TAPE_ALERT_SUPPORT_UNKNOWN) {
11277 
11278 		rval = st_logpage_supported(dev, TAPE_SEQUENTIAL_PAGE);
11279 		if (rval == 1) {
11280 
11281 			un->un_HeadClean |= TAPE_SEQUENTIAL_SUPPORTED;
11282 		}
11283 
11284 		rval = st_logpage_supported(dev, TAPE_ALERT_PAGE);
11285 		if (rval == 1) {
11286 
11287 			un->un_HeadClean |= TAPE_ALERT_SUPPORTED;
11288 		}
11289 
11290 		if (un->un_HeadClean == TAPE_ALERT_SUPPORT_UNKNOWN) {
11291 
11292 			un->un_HeadClean = TAPE_ALERT_NOT_SUPPORTED;
11293 		}
11294 	}
11295 
11296 	rval = 0;
11297 
11298 	if (un->un_HeadClean & TAPE_SEQUENTIAL_SUPPORTED) {
11299 
11300 		rval = st_check_sequential_clean_bit(dev);
11301 	}
11302 
11303 	if ((rval <= 0) && (un->un_HeadClean & TAPE_ALERT_SUPPORTED)) {
11304 
11305 		rval = st_check_alert_clean_bit(dev);
11306 	}
11307 
11308 	if ((rval <= 0) && (un->un_dp->options & ST_CLN_MASK)) {
11309 
11310 		rval = st_check_sense_clean_bit(dev);
11311 	}
11312 
11313 	if (rval < 0) {
11314 		return (rval);
11315 	}
11316 
11317 	/*
11318 	 * If found a supported means to check need to clean.
11319 	 */
11320 	if (rval & MTF_TAPE_CLN_SUPPORTED) {
11321 
11322 		/*
11323 		 * head needs to be cleaned.
11324 		 */
11325 		if (rval & MTF_TAPE_HEAD_DIRTY) {
11326 
11327 			/*
11328 			 * Print log message only first time
11329 			 * found needing cleaned.
11330 			 */
11331 			if ((un->un_HeadClean & TAPE_PREVIOUSLY_DIRTY) == 0) {
11332 
11333 				scsi_log(ST_DEVINFO, st_label, CE_WARN,
11334 				    "Periodic head cleaning required");
11335 
11336 				un->un_HeadClean |= TAPE_PREVIOUSLY_DIRTY;
11337 			}
11338 
11339 		} else {
11340 
11341 			un->un_HeadClean &= ~TAPE_PREVIOUSLY_DIRTY;
11342 		}
11343 	}
11344 
11345 	return (rval);
11346 }
11347 
11348 
11349 static int
11350 st_check_sequential_clean_bit(dev_t dev)
11351 {
11352 	int rval;
11353 	int ix;
11354 	ushort_t parameter;
11355 	struct uscsi_cmd *cmd;
11356 	struct log_sequential_page *sp;
11357 	struct log_sequential_page_parameter *prm;
11358 	char cdb[CDB_GROUP1] = {
11359 		SCMD_LOG_SENSE_G1,
11360 		0,
11361 		TAPE_SEQUENTIAL_PAGE | CURRENT_CUMULATIVE_VALUES,
11362 		0,
11363 		0,
11364 		0,
11365 		0,
11366 		(char)(sizeof (struct log_sequential_page) >> 8),
11367 		(char)(sizeof (struct log_sequential_page)),
11368 		0
11369 	};
11370 
11371 	GET_SOFT_STATE(dev);
11372 
11373 	cmd = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
11374 	sp  = kmem_zalloc(sizeof (struct log_sequential_page), KM_SLEEP);
11375 
11376 	cmd->uscsi_flags   =
11377 		USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ | USCSI_RQENABLE;
11378 	cmd->uscsi_timeout = un->un_dp->non_motion_timeout;
11379 	cmd->uscsi_cdb	   = cdb;
11380 	cmd->uscsi_cdblen  = CDB_GROUP1;
11381 	cmd->uscsi_bufaddr = (caddr_t)sp;
11382 	cmd->uscsi_buflen  = sizeof (struct log_sequential_page);
11383 
11384 	rval = st_ioctl_cmd(dev, cmd, UIO_SYSSPACE, UIO_SYSSPACE, UIO_SYSSPACE);
11385 
11386 	if (rval || cmd->uscsi_status || cmd->uscsi_resid) {
11387 
11388 		rval = -1;
11389 
11390 	} else if (sp->log_page.code != TAPE_SEQUENTIAL_PAGE) {
11391 
11392 		rval = -1;
11393 	}
11394 
11395 	prm = &sp->param[0];
11396 
11397 	for (ix = 0; rval == 0 && ix < TAPE_SEQUENTIAL_PAGE_PARA; ix++) {
11398 
11399 		if (prm->log_param.length == 0) {
11400 			break;
11401 		}
11402 
11403 		parameter = (((prm->log_param.pc_hi << 8) & 0xff00) +
11404 			(prm->log_param.pc_lo & 0xff));
11405 
11406 		if (parameter == SEQUENTIAL_NEED_CLN) {
11407 
11408 			rval = MTF_TAPE_CLN_SUPPORTED;
11409 			if (prm->param_value[prm->log_param.length - 1]) {
11410 
11411 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11412 					    "sequential log says head dirty\n");
11413 				rval |= MTF_TAPE_HEAD_DIRTY;
11414 			}
11415 		}
11416 		prm = (struct log_sequential_page_parameter *)
11417 			&prm->param_value[prm->log_param.length];
11418 	}
11419 
11420 	kmem_free(cmd, sizeof (struct uscsi_cmd));
11421 	kmem_free(sp,  sizeof (struct log_sequential_page));
11422 
11423 	return (rval);
11424 }
11425 
11426 
11427 static int
11428 st_check_alert_clean_bit(dev_t dev)
11429 {
11430 	struct st_tape_alert *ta;
11431 	struct uscsi_cmd *com;
11432 	unsigned ix, length;
11433 	int rval;
11434 	ushort_t parameter;
11435 	char cdb[CDB_GROUP1] = {
11436 		SCMD_LOG_SENSE_G1,
11437 		0,
11438 		TAPE_ALERT_PAGE | CURRENT_THRESHOLD_VALUES,
11439 		0,
11440 		0,
11441 		0,
11442 		0,
11443 		(char)(sizeof (struct st_tape_alert) >> 8),
11444 		(char)(sizeof (struct st_tape_alert)),
11445 		0
11446 	};
11447 
11448 	GET_SOFT_STATE(dev);
11449 
11450 	com = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
11451 	ta  = kmem_zalloc(sizeof (struct st_tape_alert), KM_SLEEP);
11452 
11453 	com->uscsi_cdb = cdb;
11454 	com->uscsi_cdblen = CDB_GROUP1;
11455 	com->uscsi_bufaddr = (caddr_t)ta;
11456 	com->uscsi_buflen = sizeof (struct st_tape_alert);
11457 	com->uscsi_flags =
11458 		USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ | USCSI_RQENABLE;
11459 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
11460 
11461 	rval = st_ioctl_cmd(dev, com, UIO_SYSSPACE, UIO_SYSSPACE, UIO_SYSSPACE);
11462 
11463 	if (rval || com->uscsi_status || com->uscsi_resid) {
11464 
11465 		rval = -1; /* uscsi-command failed */
11466 
11467 	} else if (ta->log_page.code != TAPE_ALERT_PAGE) {
11468 
11469 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11470 		"Not Alert Log Page returned 0x%X\n", ta->log_page.code);
11471 		rval = -1;
11472 	}
11473 
11474 	length = (ta->log_page.length_hi << 8) + ta->log_page.length_lo;
11475 
11476 
11477 	if (length != TAPE_ALERT_PARAMETER_LENGTH) {
11478 
11479 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11480 		    "TapeAlert length %d\n", length);
11481 	}
11482 
11483 
11484 	for (ix = 0; ix < TAPE_ALERT_MAX_PARA; ix++) {
11485 
11486 		/*
11487 		 * if rval is bad before the first pass don't bother
11488 		 */
11489 		if (ix == 0 && rval != 0) {
11490 
11491 			break;
11492 		}
11493 
11494 		parameter = ((ta->param[ix].log_param.pc_hi << 8) +
11495 			ta->param[ix].log_param.pc_lo);
11496 
11497 		/*
11498 		 * check to see if current parameter is of interest.
11499 		 * CLEAN_FOR_ERRORS is vendor specific to 9840 9940 stk's.
11500 		 */
11501 		if ((parameter == CLEAN_NOW) ||
11502 		    (parameter == CLEAN_PERIODIC) ||
11503 		    ((parameter == CLEAN_FOR_ERRORS) &&
11504 		    (un->un_dp->type == ST_TYPE_STK9840))) {
11505 
11506 			rval = MTF_TAPE_CLN_SUPPORTED;
11507 
11508 			if (ta->param[ix].param_value & 1) {
11509 
11510 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11511 					    "alert_page drive needs clean %d\n",
11512 					    parameter);
11513 				un->un_HeadClean |= TAPE_ALERT_STILL_DIRTY;
11514 				rval |= MTF_TAPE_HEAD_DIRTY;
11515 			}
11516 
11517 		} else if (parameter == CLEANING_MEDIA) {
11518 
11519 			if (ta->param[ix].param_value & 1) {
11520 
11521 				ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11522 					    "alert_page drive was cleaned\n");
11523 				un->un_HeadClean &= ~TAPE_ALERT_STILL_DIRTY;
11524 			}
11525 		}
11526 
11527 	}
11528 
11529 	/*
11530 	 * Report it as dirty till we see it cleaned
11531 	 */
11532 	if (un->un_HeadClean & TAPE_ALERT_STILL_DIRTY) {
11533 
11534 		ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11535 			    "alert_page still dirty\n");
11536 		rval |= MTF_TAPE_HEAD_DIRTY;
11537 	}
11538 
11539 	kmem_free(com, sizeof (struct uscsi_cmd));
11540 	kmem_free(ta,  sizeof (struct st_tape_alert));
11541 
11542 	return (rval);
11543 }
11544 
11545 
11546 static int
11547 st_check_sense_clean_bit(dev_t dev)
11548 {
11549 	uchar_t *sensep;
11550 	char cdb[CDB_GROUP0];
11551 	struct uscsi_cmd *com;
11552 	ushort_t byte_pos;
11553 	uchar_t bit_mask;
11554 	unsigned length;
11555 	int index;
11556 	int rval;
11557 
11558 	GET_SOFT_STATE(dev);
11559 
11560 	/*
11561 	 * Since this tape does not support Tape Alert,
11562 	 * we now try to get the cleanbit status via
11563 	 * Request Sense.
11564 	 */
11565 
11566 	if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_1) {
11567 
11568 		index = 0;
11569 
11570 	} else if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_2) {
11571 
11572 		index = 1;
11573 
11574 	} else if ((un->un_dp->options & ST_CLN_MASK) == ST_CLN_TYPE_3) {
11575 
11576 		index = 2;
11577 
11578 	} else {
11579 
11580 		return (-1);
11581 	}
11582 
11583 	byte_pos  = st_cln_bit_position[index].cln_bit_byte;
11584 	bit_mask  = st_cln_bit_position[index].cln_bit_mask;
11585 	length = byte_pos + 1;
11586 
11587 	com    = kmem_zalloc(sizeof (struct uscsi_cmd), KM_SLEEP);
11588 	sensep = kmem_zalloc(length, KM_SLEEP);
11589 
11590 	cdb[0] = SCMD_REQUEST_SENSE;
11591 	cdb[1] = 0;
11592 	cdb[2] = 0;
11593 	cdb[3] = 0;
11594 	cdb[4] = (char)length;
11595 	cdb[5] = 0;
11596 
11597 	com->uscsi_cdb = cdb;
11598 	com->uscsi_cdblen = CDB_GROUP0;
11599 	com->uscsi_bufaddr = (caddr_t)sensep;
11600 	com->uscsi_buflen = length;
11601 	com->uscsi_flags =
11602 		USCSI_DIAGNOSE | USCSI_SILENT | USCSI_READ | USCSI_RQENABLE;
11603 	com->uscsi_timeout = un->un_dp->non_motion_timeout;
11604 
11605 	rval = st_ioctl_cmd(dev, com, UIO_SYSSPACE, UIO_SYSSPACE,
11606 			UIO_SYSSPACE);
11607 
11608 	if (rval || com->uscsi_status || com->uscsi_resid) {
11609 
11610 		rval = -1;
11611 
11612 	} else {
11613 
11614 		rval = MTF_TAPE_CLN_SUPPORTED;
11615 		if ((sensep[byte_pos] & bit_mask) == bit_mask) {
11616 
11617 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11618 				    "sense data says head dirty\n");
11619 			rval |= MTF_TAPE_HEAD_DIRTY;
11620 		}
11621 	}
11622 
11623 	kmem_free(com, sizeof (struct uscsi_cmd));
11624 	kmem_free(sensep, length);
11625 	return (rval);
11626 }
11627 
11628 /*
11629  * st_clear_unit_attention
11630  *
11631  *  	run test unit ready's to clear out outstanding
11632  * 	unit attentions.
11633  * 	returns zero for SUCCESS or the errno from st_cmd call
11634  */
11635 static int
11636 st_clear_unit_attentions(dev_t dev_instance, int max_trys)
11637 {
11638 	int	i    = 0;
11639 	int	rval;
11640 
11641 	do {
11642 		rval = st_cmd(dev_instance, SCMD_TEST_UNIT_READY, 0, SYNC_CMD);
11643 	} while ((rval != 0) && (rval != ENXIO) && (++i < max_trys));
11644 	return (rval);
11645 }
11646 
11647 static void
11648 st_calculate_timeouts(struct scsi_tape *un)
11649 {
11650 	if (un->un_dp->non_motion_timeout == 0) {
11651 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
11652 			un->un_dp->non_motion_timeout =
11653 				st_io_time * st_long_timeout_x;
11654 		} else {
11655 			un->un_dp->non_motion_timeout = (ushort_t)st_io_time;
11656 		}
11657 	}
11658 
11659 	if (un->un_dp->io_timeout == 0) {
11660 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
11661 			un->un_dp->io_timeout = st_io_time * st_long_timeout_x;
11662 		} else {
11663 			un->un_dp->io_timeout = (ushort_t)st_io_time;
11664 		}
11665 	}
11666 
11667 	if (un->un_dp->rewind_timeout == 0) {
11668 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
11669 			un->un_dp->rewind_timeout =
11670 				st_space_time * st_long_timeout_x;
11671 		} else {
11672 			un->un_dp->rewind_timeout = (ushort_t)st_space_time;
11673 		}
11674 	}
11675 
11676 	if (un->un_dp->space_timeout == 0) {
11677 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
11678 			un->un_dp->space_timeout =
11679 				st_space_time * st_long_timeout_x;
11680 		} else {
11681 			un->un_dp->space_timeout = (ushort_t)st_space_time;
11682 		}
11683 	}
11684 
11685 	if (un->un_dp->load_timeout == 0) {
11686 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
11687 			un->un_dp->load_timeout =
11688 				st_space_time * st_long_timeout_x;
11689 		} else {
11690 			un->un_dp->load_timeout = (ushort_t)st_space_time;
11691 		}
11692 	}
11693 
11694 	if (un->un_dp->unload_timeout == 0) {
11695 		if (un->un_dp->options & ST_LONG_TIMEOUTS) {
11696 			un->un_dp->unload_timeout =
11697 				st_space_time * st_long_timeout_x;
11698 		} else {
11699 			un->un_dp->unload_timeout = (ushort_t)st_space_time;
11700 		}
11701 	}
11702 
11703 	if (un->un_dp->erase_timeout == 0) {
11704 		if (un->un_dp->options & ST_LONG_ERASE) {
11705 			un->un_dp->erase_timeout =
11706 				st_space_time * st_long_space_time_x;
11707 		} else {
11708 			un->un_dp->erase_timeout = (ushort_t)st_space_time;
11709 		}
11710 	}
11711 }
11712 
11713 #if defined(__i386) || defined(__amd64)
11714 
11715 /*
11716  * release contig_mem and wake up waiting thread, if any
11717  */
11718 static void
11719 st_release_contig_mem(struct scsi_tape *un, struct contig_mem *cp)
11720 {
11721 	mutex_enter(ST_MUTEX);
11722 
11723 	cp->cm_next = un->un_contig_mem;
11724 	un->un_contig_mem = cp;
11725 	un->un_contig_mem_available_num++;
11726 	cv_broadcast(&un->un_contig_mem_cv);
11727 
11728 	mutex_exit(ST_MUTEX);
11729 }
11730 
11731 /*
11732  * St_get_contig_mem will return a contig_mem if there is one available
11733  * in current system. Otherwise, it will try to alloc one, if the total
11734  * number of contig_mem is within st_max_contig_mem_num.
11735  * It will sleep, if allowed by caller or return NULL, if no contig_mem
11736  * is available for now.
11737  */
11738 static struct contig_mem *
11739 st_get_contig_mem(struct scsi_tape *un, size_t len, int alloc_flags)
11740 {
11741 	size_t rlen;
11742 	struct contig_mem *cp = NULL;
11743 	ddi_acc_handle_t acc_hdl;
11744 	caddr_t addr;
11745 	int big_enough = 0;
11746 	int (*dma_alloc_cb)() = (alloc_flags == KM_SLEEP) ?
11747 		DDI_DMA_SLEEP : DDI_DMA_DONTWAIT;
11748 
11749 	/* Try to get one available contig_mem */
11750 	mutex_enter(ST_MUTEX);
11751 	if (un->un_contig_mem_available_num > 0) {
11752 		ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough);
11753 	} else if (un->un_contig_mem_total_num < st_max_contig_mem_num) {
11754 		/*
11755 		 * we failed to get one. we're going to
11756 		 * alloc one more contig_mem for this I/O
11757 		 */
11758 		mutex_exit(ST_MUTEX);
11759 		cp = (struct contig_mem *)kmem_zalloc(
11760 		    sizeof (struct contig_mem) + biosize(),
11761 		    alloc_flags);
11762 		if (cp == NULL) {
11763 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11764 			    "alloc contig_mem failure\n");
11765 			return (NULL); /* cannot get one */
11766 		}
11767 		cp->cm_bp = (struct buf *)
11768 		    (((caddr_t)cp) + sizeof (struct contig_mem));
11769 		bioinit(cp->cm_bp);
11770 		mutex_enter(ST_MUTEX);
11771 		un->un_contig_mem_total_num++; /* one more available */
11772 	} else {
11773 		/*
11774 		 * we failed to get one and we're NOT allowed to
11775 		 * alloc more contig_mem
11776 		 */
11777 		if (alloc_flags == KM_SLEEP) {
11778 			while (un->un_contig_mem_available_num <= 0) {
11779 				cv_wait(&un->un_contig_mem_cv,
11780 				    ST_MUTEX);
11781 			}
11782 			ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough);
11783 		} else {
11784 			mutex_exit(ST_MUTEX);
11785 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11786 			    "alloc contig_mem failure\n");
11787 			return (NULL); /* cannot get one */
11788 		}
11789 	}
11790 	mutex_exit(ST_MUTEX);
11791 
11792 	/* We need to check if this block of mem is big enough for this I/O */
11793 	if (cp->cm_len < len) {
11794 		/* not big enough, need to alloc a new one */
11795 		if (ddi_dma_mem_alloc(un->un_contig_mem_hdl, len, &st_acc_attr,
11796 			DDI_DMA_STREAMING, dma_alloc_cb, NULL,
11797 			&addr, &rlen, &acc_hdl) != DDI_SUCCESS) {
11798 			ST_DEBUG2(ST_DEVINFO, st_label, SCSI_DEBUG,
11799 			    "alloc contig_mem failure: not enough mem\n");
11800 			st_release_contig_mem(un, cp);
11801 			cp = NULL;
11802 		} else {
11803 			if (cp->cm_addr) {
11804 				/* release previous one before attach new one */
11805 				ddi_dma_mem_free(&cp->cm_acc_hdl);
11806 			}
11807 			mutex_enter(ST_MUTEX);
11808 			un->un_max_contig_mem_len =
11809 			    un->un_max_contig_mem_len >= len ?
11810 			    un->un_max_contig_mem_len : len;
11811 			mutex_exit(ST_MUTEX);
11812 
11813 			/* attach new mem to this cp */
11814 			cp->cm_addr = addr;
11815 			cp->cm_acc_hdl = acc_hdl;
11816 			cp->cm_len = len;
11817 
11818 			goto alloc_ok; /* get one usable cp */
11819 		}
11820 	} else {
11821 		goto alloc_ok; /* get one usable cp */
11822 	}
11823 
11824 	/* cannot find/alloc a usable cp, when we get here */
11825 
11826 	if ((un->un_max_contig_mem_len < len) ||
11827 	    (alloc_flags != KM_SLEEP)) {
11828 		return (NULL);
11829 	}
11830 
11831 	/*
11832 	 * we're allowed to sleep, and there is one big enough
11833 	 * contig mem in the system, which is currently in use,
11834 	 * wait for it...
11835 	 */
11836 	mutex_enter(ST_MUTEX);
11837 	big_enough = 1;
11838 	do {
11839 		cv_wait(&un->un_contig_mem_cv, ST_MUTEX);
11840 		ST_GET_CONTIG_MEM_HEAD(un, cp, len, big_enough);
11841 	} while (cp == NULL);
11842 	mutex_exit(ST_MUTEX);
11843 
11844 	/* we get the big enough contig mem, finally */
11845 
11846 alloc_ok:
11847 	/* init bp attached to this cp */
11848 	bioreset(cp->cm_bp);
11849 	cp->cm_bp->b_un.b_addr = cp->cm_addr;
11850 	cp->cm_bp->b_private = (void *)cp;
11851 
11852 	return (cp);
11853 }
11854 
11855 /*
11856  * this is the biodone func for the bp used in big block I/O
11857  */
11858 static int
11859 st_bigblk_xfer_done(struct buf *bp)
11860 {
11861 	struct contig_mem *cp;
11862 	struct buf *orig_bp;
11863 	int remapped = 0;
11864 	int ioerr;
11865 	struct scsi_tape *un;
11866 
11867 	/* sanity check */
11868 	if (bp == NULL) {
11869 		return (DDI_FAILURE);
11870 	}
11871 
11872 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
11873 	if (un == NULL) {
11874 		return (DDI_FAILURE);
11875 	}
11876 
11877 	cp = (struct contig_mem *)bp->b_private;
11878 	orig_bp = cp->cm_bp; /* get back the bp we have replaced */
11879 	cp->cm_bp = bp;
11880 
11881 	/* special handling for special I/O */
11882 	if (cp->cm_use_sbuf) {
11883 		ASSERT(un->un_sbuf_busy);
11884 		un->un_sbufp = orig_bp;
11885 		cp->cm_use_sbuf = 0;
11886 	}
11887 
11888 	orig_bp->b_resid = bp->b_resid;
11889 	ioerr = geterror(bp);
11890 	if (ioerr != 0) {
11891 		bioerror(orig_bp, ioerr);
11892 	} else if (orig_bp->b_flags & B_READ) {
11893 		/* copy data back to original bp */
11894 		if (orig_bp->b_flags & (B_PHYS | B_PAGEIO)) {
11895 			bp_mapin(orig_bp);
11896 			remapped = 1;
11897 		}
11898 		bcopy(bp->b_un.b_addr, orig_bp->b_un.b_addr,
11899 			bp->b_bcount - bp->b_resid);
11900 		if (remapped)
11901 			bp_mapout(orig_bp);
11902 	}
11903 
11904 	st_release_contig_mem(un, cp);
11905 
11906 	biodone(orig_bp);
11907 
11908 	return (DDI_SUCCESS);
11909 }
11910 
11911 /*
11912  * We use this func to replace original bp that may not be able to do I/O
11913  * in big block size with one that can
11914  */
11915 static struct buf *
11916 st_get_bigblk_bp(struct buf *bp)
11917 {
11918 	struct contig_mem *cp;
11919 	struct scsi_tape *un;
11920 	struct buf *cont_bp;
11921 	int remapped = 0;
11922 
11923 	un = ddi_get_soft_state(st_state, MTUNIT(bp->b_edev));
11924 	if (un == NULL) {
11925 		return (bp);
11926 	}
11927 
11928 	/* try to get one contig_mem */
11929 	cp = st_get_contig_mem(un, bp->b_bcount, KM_SLEEP);
11930 	if (!cp) {
11931 		scsi_log(ST_DEVINFO, st_label, CE_WARN,
11932 			"Cannot alloc contig buf for I/O for %lu blk size",
11933 			bp->b_bcount);
11934 		return (bp);
11935 	}
11936 	cont_bp = cp->cm_bp;
11937 	cp->cm_bp = bp;
11938 
11939 	/* make sure that we "are" using un_sbufp for special I/O */
11940 	if (bp == un->un_sbufp) {
11941 		ASSERT(un->un_sbuf_busy);
11942 		un->un_sbufp = cont_bp;
11943 		cp->cm_use_sbuf = 1;
11944 	}
11945 
11946 	/* clone bp */
11947 	cont_bp->b_bcount = bp->b_bcount;
11948 	cont_bp->b_resid = bp->b_resid;
11949 	cont_bp->b_iodone = st_bigblk_xfer_done;
11950 	cont_bp->b_file = bp->b_file;
11951 	cont_bp->b_offset = bp->b_offset;
11952 	cont_bp->b_dip = bp->b_dip;
11953 	cont_bp->b_error = 0;
11954 	cont_bp->b_proc = NULL;
11955 	cont_bp->b_flags = bp->b_flags & ~(B_PAGEIO | B_PHYS | B_SHADOW);
11956 	cont_bp->b_shadow = NULL;
11957 	cont_bp->b_pages = NULL;
11958 	cont_bp->b_edev = bp->b_edev;
11959 	cont_bp->b_dev = bp->b_dev;
11960 	cont_bp->b_lblkno = bp->b_lblkno;
11961 	cont_bp->b_forw = bp->b_forw;
11962 	cont_bp->b_back = bp->b_back;
11963 	cont_bp->av_forw = bp->av_forw;
11964 	cont_bp->av_back = bp->av_back;
11965 	cont_bp->b_bufsize = bp->b_bufsize;
11966 
11967 	/* get data in original bp */
11968 	if (bp->b_flags & B_WRITE) {
11969 		if (bp->b_flags & (B_PHYS | B_PAGEIO)) {
11970 			bp_mapin(bp);
11971 			remapped = 1;
11972 		}
11973 		bcopy(bp->b_un.b_addr, cont_bp->b_un.b_addr, bp->b_bcount);
11974 		if (remapped)
11975 			bp_mapout(bp);
11976 	}
11977 
11978 	return (cont_bp);
11979 }
11980 #endif
11981