xref: /freebsd/sys/cam/scsi/scsi_ch.c (revision 78007886c995898a9494648343e5236bca1cbba3)
1 /*-
2  * Copyright (c) 1997 Justin T. Gibbs.
3  * Copyright (c) 1997, 1998, 1999 Kenneth D. Merry.
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions, and the following disclaimer,
11  *    without modification, immediately at the beginning of the file.
12  * 2. The name of the author may not be used to endorse or promote products
13  *    derived from this software without specific prior written permission.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
19  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  */
27 
28 /*
29  * Derived from the NetBSD SCSI changer driver.
30  *
31  *	$NetBSD: ch.c,v 1.32 1998/01/12 09:49:12 thorpej Exp $
32  *
33  */
34 /*-
35  * Copyright (c) 1996, 1997 Jason R. Thorpe <thorpej@and.com>
36  * All rights reserved.
37  *
38  * Partially based on an autochanger driver written by Stefan Grefen
39  * and on an autochanger driver written by the Systems Programming Group
40  * at the University of Utah Computer Science Department.
41  *
42  * Redistribution and use in source and binary forms, with or without
43  * modification, are permitted provided that the following conditions
44  * are met:
45  * 1. Redistributions of source code must retain the above copyright
46  *    notice, this list of conditions and the following disclaimer.
47  * 2. Redistributions in binary form must reproduce the above copyright
48  *    notice, this list of conditions and the following disclaimer in the
49  *    documentation and/or other materials provided with the distribution.
50  * 3. All advertising materials mentioning features or use of this software
51  *    must display the following acknowledgements:
52  *	This product includes software developed by Jason R. Thorpe
53  *	for And Communications, http://www.and.com/
54  * 4. The name of the author may not be used to endorse or promote products
55  *    derived from this software without specific prior written permission.
56  *
57  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
58  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
59  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
60  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
61  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
62  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
63  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
64  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
65  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
66  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
67  * SUCH DAMAGE.
68  */
69 
70 #include <sys/cdefs.h>
71 __FBSDID("$FreeBSD$");
72 
73 #include <sys/param.h>
74 #include <sys/queue.h>
75 #include <sys/systm.h>
76 #include <sys/kernel.h>
77 #include <sys/types.h>
78 #include <sys/malloc.h>
79 #include <sys/fcntl.h>
80 #include <sys/conf.h>
81 #include <sys/chio.h>
82 #include <sys/errno.h>
83 #include <sys/devicestat.h>
84 
85 #include <cam/cam.h>
86 #include <cam/cam_ccb.h>
87 #include <cam/cam_periph.h>
88 #include <cam/cam_xpt_periph.h>
89 #include <cam/cam_debug.h>
90 
91 #include <cam/scsi/scsi_all.h>
92 #include <cam/scsi/scsi_message.h>
93 #include <cam/scsi/scsi_ch.h>
94 
95 /*
96  * Timeout definitions for various changer related commands.  They may
97  * be too short for some devices (especially the timeout for INITIALIZE
98  * ELEMENT STATUS).
99  */
100 
101 static const u_int32_t	CH_TIMEOUT_MODE_SENSE                = 6000;
102 static const u_int32_t	CH_TIMEOUT_MOVE_MEDIUM               = 100000;
103 static const u_int32_t	CH_TIMEOUT_EXCHANGE_MEDIUM           = 100000;
104 static const u_int32_t	CH_TIMEOUT_POSITION_TO_ELEMENT       = 100000;
105 static const u_int32_t	CH_TIMEOUT_READ_ELEMENT_STATUS       = 10000;
106 static const u_int32_t	CH_TIMEOUT_SEND_VOLTAG		     = 10000;
107 static const u_int32_t	CH_TIMEOUT_INITIALIZE_ELEMENT_STATUS = 500000;
108 
109 typedef enum {
110 	CH_FLAG_INVALID		= 0x001,
111 	CH_FLAG_OPEN		= 0x002
112 } ch_flags;
113 
114 typedef enum {
115 	CH_STATE_PROBE,
116 	CH_STATE_NORMAL
117 } ch_state;
118 
119 typedef enum {
120 	CH_CCB_PROBE,
121 	CH_CCB_WAITING
122 } ch_ccb_types;
123 
124 typedef enum {
125 	CH_Q_NONE	= 0x00,
126 	CH_Q_NO_DBD	= 0x01
127 } ch_quirks;
128 
129 #define ccb_state	ppriv_field0
130 #define ccb_bp		ppriv_ptr1
131 
132 struct scsi_mode_sense_data {
133 	struct scsi_mode_header_6 header;
134 	struct scsi_mode_blk_desc blk_desc;
135 	union {
136 		struct page_element_address_assignment ea;
137 		struct page_transport_geometry_parameters tg;
138 		struct page_device_capabilities cap;
139 	} pages;
140 };
141 
142 struct ch_softc {
143 	ch_flags	flags;
144 	ch_state	state;
145 	ch_quirks	quirks;
146 	union ccb	saved_ccb;
147 	struct devstat	*device_stats;
148 	struct cdev *dev;
149 
150 	int		sc_picker;	/* current picker */
151 
152 	/*
153 	 * The following information is obtained from the
154 	 * element address assignment page.
155 	 */
156 	int		sc_firsts[CHET_MAX + 1];	/* firsts */
157 	int		sc_counts[CHET_MAX + 1];	/* counts */
158 
159 	/*
160 	 * The following mask defines the legal combinations
161 	 * of elements for the MOVE MEDIUM command.
162 	 */
163 	u_int8_t	sc_movemask[CHET_MAX + 1];
164 
165 	/*
166 	 * As above, but for EXCHANGE MEDIUM.
167 	 */
168 	u_int8_t	sc_exchangemask[CHET_MAX + 1];
169 
170 	/*
171 	 * Quirks; see below.  XXX KDM not implemented yet
172 	 */
173 	int		sc_settledelay;	/* delay for settle */
174 };
175 
176 static	d_open_t	chopen;
177 static	d_close_t	chclose;
178 static	d_ioctl_t	chioctl;
179 static	periph_init_t	chinit;
180 static  periph_ctor_t	chregister;
181 static	periph_oninv_t	choninvalidate;
182 static  periph_dtor_t   chcleanup;
183 static  periph_start_t  chstart;
184 static	void		chasync(void *callback_arg, u_int32_t code,
185 				struct cam_path *path, void *arg);
186 static	void		chdone(struct cam_periph *periph,
187 			       union ccb *done_ccb);
188 static	int		cherror(union ccb *ccb, u_int32_t cam_flags,
189 				u_int32_t sense_flags);
190 static	int		chmove(struct cam_periph *periph,
191 			       struct changer_move *cm);
192 static	int		chexchange(struct cam_periph *periph,
193 				   struct changer_exchange *ce);
194 static	int		chposition(struct cam_periph *periph,
195 				   struct changer_position *cp);
196 static	int		chgetelemstatus(struct cam_periph *periph,
197 				struct changer_element_status_request *csr);
198 static	int		chsetvoltag(struct cam_periph *periph,
199 				    struct changer_set_voltag_request *csvr);
200 static	int		chielem(struct cam_periph *periph,
201 				unsigned int timeout);
202 static	int		chgetparams(struct cam_periph *periph);
203 
204 static struct periph_driver chdriver =
205 {
206 	chinit, "ch",
207 	TAILQ_HEAD_INITIALIZER(chdriver.units), /* generation */ 0
208 };
209 
210 PERIPHDRIVER_DECLARE(ch, chdriver);
211 
212 static struct cdevsw ch_cdevsw = {
213 	.d_version =	D_VERSION,
214 	.d_flags =	0,
215 	.d_open =	chopen,
216 	.d_close =	chclose,
217 	.d_ioctl =	chioctl,
218 	.d_name =	"ch",
219 };
220 
221 static void
222 chinit(void)
223 {
224 	cam_status status;
225 	struct cam_path *path;
226 
227 	/*
228 	 * Install a global async callback.  This callback will
229 	 * receive async callbacks like "new device found".
230 	 */
231 	status = xpt_create_path(&path, /*periph*/NULL, CAM_XPT_PATH_ID,
232 				 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD);
233 
234 	if (status == CAM_REQ_CMP) {
235 		struct ccb_setasync csa;
236 
237                 xpt_setup_ccb(&csa.ccb_h, path, /*priority*/5);
238                 csa.ccb_h.func_code = XPT_SASYNC_CB;
239                 csa.event_enable = AC_FOUND_DEVICE;
240                 csa.callback = chasync;
241                 csa.callback_arg = NULL;
242                 xpt_action((union ccb *)&csa);
243 		status = csa.ccb_h.status;
244                 xpt_free_path(path);
245         }
246 
247 	if (status != CAM_REQ_CMP) {
248 		printf("ch: Failed to attach master async callback "
249 		       "due to status 0x%x!\n", status);
250 	}
251 }
252 
253 static void
254 choninvalidate(struct cam_periph *periph)
255 {
256 	struct ch_softc *softc;
257 	struct ccb_setasync csa;
258 
259 	softc = (struct ch_softc *)periph->softc;
260 
261 	/*
262 	 * De-register any async callbacks.
263 	 */
264 	xpt_setup_ccb(&csa.ccb_h, periph->path,
265 		      /* priority */ 5);
266 	csa.ccb_h.func_code = XPT_SASYNC_CB;
267 	csa.event_enable = 0;
268 	csa.callback = chasync;
269 	csa.callback_arg = periph;
270 	xpt_action((union ccb *)&csa);
271 
272 	softc->flags |= CH_FLAG_INVALID;
273 
274 	xpt_print(periph->path, "lost device\n");
275 
276 }
277 
278 static void
279 chcleanup(struct cam_periph *periph)
280 {
281 	struct ch_softc *softc;
282 
283 	softc = (struct ch_softc *)periph->softc;
284 
285 	devstat_remove_entry(softc->device_stats);
286 	destroy_dev(softc->dev);
287 	xpt_print(periph->path, "removing device entry\n");
288 	free(softc, M_DEVBUF);
289 }
290 
291 static void
292 chasync(void *callback_arg, u_int32_t code, struct cam_path *path, void *arg)
293 {
294 	struct cam_periph *periph;
295 
296 	periph = (struct cam_periph *)callback_arg;
297 
298 	switch(code) {
299 	case AC_FOUND_DEVICE:
300 	{
301 		struct ccb_getdev *cgd;
302 		cam_status status;
303 
304 		cgd = (struct ccb_getdev *)arg;
305 		if (cgd == NULL)
306 			break;
307 
308 		if (SID_TYPE(&cgd->inq_data)!= T_CHANGER)
309 			break;
310 
311 		/*
312 		 * Allocate a peripheral instance for
313 		 * this device and start the probe
314 		 * process.
315 		 */
316 		status = cam_periph_alloc(chregister, choninvalidate,
317 					  chcleanup, chstart, "ch",
318 					  CAM_PERIPH_BIO, cgd->ccb_h.path,
319 					  chasync, AC_FOUND_DEVICE, cgd);
320 
321 		if (status != CAM_REQ_CMP
322 		 && status != CAM_REQ_INPROG)
323 			printf("chasync: Unable to probe new device "
324 			       "due to status 0x%x\n", status);
325 
326 		break;
327 
328 	}
329 	default:
330 		cam_periph_async(periph, code, path, arg);
331 		break;
332 	}
333 }
334 
335 static cam_status
336 chregister(struct cam_periph *periph, void *arg)
337 {
338 	struct ch_softc *softc;
339 	struct ccb_setasync csa;
340 	struct ccb_getdev *cgd;
341 
342 	cgd = (struct ccb_getdev *)arg;
343 	if (periph == NULL) {
344 		printf("chregister: periph was NULL!!\n");
345 		return(CAM_REQ_CMP_ERR);
346 	}
347 
348 	if (cgd == NULL) {
349 		printf("chregister: no getdev CCB, can't register device\n");
350 		return(CAM_REQ_CMP_ERR);
351 	}
352 
353 	softc = (struct ch_softc *)malloc(sizeof(*softc),M_DEVBUF,M_NOWAIT);
354 
355 	if (softc == NULL) {
356 		printf("chregister: Unable to probe new device. "
357 		       "Unable to allocate softc\n");
358 		return(CAM_REQ_CMP_ERR);
359 	}
360 
361 	bzero(softc, sizeof(*softc));
362 	softc->state = CH_STATE_PROBE;
363 	periph->softc = softc;
364 	softc->quirks = CH_Q_NONE;
365 
366 	/*
367 	 * Changers don't have a blocksize, and obviously don't support
368 	 * tagged queueing.
369 	 */
370 	softc->device_stats = devstat_new_entry("ch",
371 			  periph->unit_number, 0,
372 			  DEVSTAT_NO_BLOCKSIZE | DEVSTAT_NO_ORDERED_TAGS,
373 			  SID_TYPE(&cgd->inq_data)| DEVSTAT_TYPE_IF_SCSI,
374 			  DEVSTAT_PRIORITY_OTHER);
375 
376 	/* Register the device */
377 	cam_periph_unlock(periph);
378 	softc->dev = make_dev(&ch_cdevsw, periph->unit_number, UID_ROOT,
379 			      GID_OPERATOR, 0600, "%s%d", periph->periph_name,
380 			      periph->unit_number);
381 	cam_periph_lock(periph);
382 	softc->dev->si_drv1 = periph;
383 
384 	/*
385 	 * Add an async callback so that we get
386 	 * notified if this device goes away.
387 	 */
388 	xpt_setup_ccb(&csa.ccb_h, periph->path, /* priority */ 5);
389 	csa.ccb_h.func_code = XPT_SASYNC_CB;
390 	csa.event_enable = AC_LOST_DEVICE;
391 	csa.callback = chasync;
392 	csa.callback_arg = periph;
393 	xpt_action((union ccb *)&csa);
394 
395 	/*
396 	 * Lock this periph until we are setup.
397 	 * This first call can't block
398 	 */
399 	(void)cam_periph_hold(periph, PRIBIO);
400 	xpt_schedule(periph, /*priority*/5);
401 
402 	return(CAM_REQ_CMP);
403 }
404 
405 static int
406 chopen(struct cdev *dev, int flags, int fmt, struct thread *td)
407 {
408 	struct cam_periph *periph;
409 	struct ch_softc *softc;
410 	int error;
411 
412 	periph = (struct cam_periph *)dev->si_drv1;
413 	if (cam_periph_acquire(periph) != CAM_REQ_CMP)
414 		return (ENXIO);
415 
416 	softc = (struct ch_softc *)periph->softc;
417 
418 	cam_periph_lock(periph);
419 
420 	if (softc->flags & CH_FLAG_INVALID) {
421 		cam_periph_unlock(periph);
422 		cam_periph_release(periph);
423 		return(ENXIO);
424 	}
425 
426 	if ((softc->flags & CH_FLAG_OPEN) == 0)
427 		softc->flags |= CH_FLAG_OPEN;
428 	else
429 		cam_periph_release(periph);
430 
431 	if ((error = cam_periph_hold(periph, PRIBIO | PCATCH)) != 0) {
432 		cam_periph_unlock(periph);
433 		cam_periph_release(periph);
434 		return (error);
435 	}
436 
437 	/*
438 	 * Load information about this changer device into the softc.
439 	 */
440 	if ((error = chgetparams(periph)) != 0) {
441 		softc->flags &= ~CH_FLAG_OPEN;
442 		cam_periph_unlock(periph);
443 		cam_periph_release(periph);
444 		return(error);
445 	}
446 
447 	cam_periph_unhold(periph);
448 	cam_periph_unlock(periph);
449 
450 	return(error);
451 }
452 
453 static int
454 chclose(struct cdev *dev, int flag, int fmt, struct thread *td)
455 {
456 	struct	cam_periph *periph;
457 	struct	ch_softc *softc;
458 	int	error;
459 
460 	error = 0;
461 
462 	periph = (struct cam_periph *)dev->si_drv1;
463 	if (periph == NULL)
464 		return(ENXIO);
465 
466 	softc = (struct ch_softc *)periph->softc;
467 
468 	cam_periph_lock(periph);
469 
470 	softc->flags &= ~CH_FLAG_OPEN;
471 
472 	cam_periph_unlock(periph);
473 	cam_periph_release(periph);
474 
475 	return(0);
476 }
477 
478 static void
479 chstart(struct cam_periph *periph, union ccb *start_ccb)
480 {
481 	struct ch_softc *softc;
482 
483 	softc = (struct ch_softc *)periph->softc;
484 
485 	switch (softc->state) {
486 	case CH_STATE_NORMAL:
487 	{
488 		if (periph->immediate_priority <= periph->pinfo.priority){
489 			start_ccb->ccb_h.ccb_state = CH_CCB_WAITING;
490 
491 			SLIST_INSERT_HEAD(&periph->ccb_list, &start_ccb->ccb_h,
492 					  periph_links.sle);
493 			periph->immediate_priority = CAM_PRIORITY_NONE;
494 			wakeup(&periph->ccb_list);
495 		}
496 		break;
497 	}
498 	case CH_STATE_PROBE:
499 	{
500 		int mode_buffer_len;
501 		void *mode_buffer;
502 
503 		/*
504 		 * Include the block descriptor when calculating the mode
505 		 * buffer length,
506 		 */
507 		mode_buffer_len = sizeof(struct scsi_mode_header_6) +
508 				  sizeof(struct scsi_mode_blk_desc) +
509 				 sizeof(struct page_element_address_assignment);
510 
511 		mode_buffer = malloc(mode_buffer_len, M_TEMP, M_NOWAIT);
512 
513 		if (mode_buffer == NULL) {
514 			printf("chstart: couldn't malloc mode sense data\n");
515 			break;
516 		}
517 		bzero(mode_buffer, mode_buffer_len);
518 
519 		/*
520 		 * Get the element address assignment page.
521 		 */
522 		scsi_mode_sense(&start_ccb->csio,
523 				/* retries */ 1,
524 				/* cbfcnp */ chdone,
525 				/* tag_action */ MSG_SIMPLE_Q_TAG,
526 				/* dbd */ (softc->quirks & CH_Q_NO_DBD) ?
527 					FALSE : TRUE,
528 				/* page_code */ SMS_PAGE_CTRL_CURRENT,
529 				/* page */ CH_ELEMENT_ADDR_ASSIGN_PAGE,
530 				/* param_buf */ (u_int8_t *)mode_buffer,
531 				/* param_len */ mode_buffer_len,
532 				/* sense_len */ SSD_FULL_SIZE,
533 				/* timeout */ CH_TIMEOUT_MODE_SENSE);
534 
535 		start_ccb->ccb_h.ccb_bp = NULL;
536 		start_ccb->ccb_h.ccb_state = CH_CCB_PROBE;
537 		xpt_action(start_ccb);
538 		break;
539 	}
540 	}
541 }
542 
543 static void
544 chdone(struct cam_periph *periph, union ccb *done_ccb)
545 {
546 	struct ch_softc *softc;
547 	struct ccb_scsiio *csio;
548 
549 	softc = (struct ch_softc *)periph->softc;
550 	csio = &done_ccb->csio;
551 
552 	switch(done_ccb->ccb_h.ccb_state) {
553 	case CH_CCB_PROBE:
554 	{
555 		struct scsi_mode_header_6 *mode_header;
556 		struct page_element_address_assignment *ea;
557 		char announce_buf[80];
558 
559 
560 		mode_header = (struct scsi_mode_header_6 *)csio->data_ptr;
561 
562 		ea = (struct page_element_address_assignment *)
563 			find_mode_page_6(mode_header);
564 
565 		if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP){
566 
567 			softc->sc_firsts[CHET_MT] = scsi_2btoul(ea->mtea);
568 			softc->sc_counts[CHET_MT] = scsi_2btoul(ea->nmte);
569 			softc->sc_firsts[CHET_ST] = scsi_2btoul(ea->fsea);
570 			softc->sc_counts[CHET_ST] = scsi_2btoul(ea->nse);
571 			softc->sc_firsts[CHET_IE] = scsi_2btoul(ea->fieea);
572 			softc->sc_counts[CHET_IE] = scsi_2btoul(ea->niee);
573 			softc->sc_firsts[CHET_DT] = scsi_2btoul(ea->fdtea);
574 			softc->sc_counts[CHET_DT] = scsi_2btoul(ea->ndte);
575 			softc->sc_picker = softc->sc_firsts[CHET_MT];
576 
577 #define PLURAL(c)	(c) == 1 ? "" : "s"
578 			snprintf(announce_buf, sizeof(announce_buf),
579 				"%d slot%s, %d drive%s, "
580 				"%d picker%s, %d portal%s",
581 		    		softc->sc_counts[CHET_ST],
582 				PLURAL(softc->sc_counts[CHET_ST]),
583 		    		softc->sc_counts[CHET_DT],
584 				PLURAL(softc->sc_counts[CHET_DT]),
585 		    		softc->sc_counts[CHET_MT],
586 				PLURAL(softc->sc_counts[CHET_MT]),
587 		    		softc->sc_counts[CHET_IE],
588 				PLURAL(softc->sc_counts[CHET_IE]));
589 #undef PLURAL
590 		} else {
591 			int error;
592 
593 			error = cherror(done_ccb, CAM_RETRY_SELTO,
594 					SF_RETRY_UA | SF_NO_PRINT);
595 			/*
596 			 * Retry any UNIT ATTENTION type errors.  They
597 			 * are expected at boot.
598 			 */
599 			if (error == ERESTART) {
600 				/*
601 				 * A retry was scheuled, so
602 				 * just return.
603 				 */
604 				return;
605 			} else if (error != 0) {
606 				int retry_scheduled;
607 				struct scsi_mode_sense_6 *sms;
608 
609 				sms = (struct scsi_mode_sense_6 *)
610 					done_ccb->csio.cdb_io.cdb_bytes;
611 
612 				/*
613 				 * Check to see if block descriptors were
614 				 * disabled.  Some devices don't like that.
615 				 * We're taking advantage of the fact that
616 				 * the first few bytes of the 6 and 10 byte
617 				 * mode sense commands are the same.  If
618 				 * block descriptors were disabled, enable
619 				 * them and re-send the command.
620 				 */
621 				if (sms->byte2 & SMS_DBD) {
622 					sms->byte2 &= ~SMS_DBD;
623 					xpt_action(done_ccb);
624 					softc->quirks |= CH_Q_NO_DBD;
625 					retry_scheduled = 1;
626 				} else
627 					retry_scheduled = 0;
628 
629 				/* Don't wedge this device's queue */
630 				cam_release_devq(done_ccb->ccb_h.path,
631 						 /*relsim_flags*/0,
632 						 /*reduction*/0,
633 						 /*timeout*/0,
634 						 /*getcount_only*/0);
635 
636 				if (retry_scheduled)
637 					return;
638 
639 				if ((done_ccb->ccb_h.status & CAM_STATUS_MASK)
640 				    == CAM_SCSI_STATUS_ERROR)
641 					scsi_sense_print(&done_ccb->csio);
642 				else {
643 					xpt_print(periph->path,
644 					    "got CAM status %#x\n",
645 					    done_ccb->ccb_h.status);
646 				}
647 				xpt_print(periph->path, "fatal error, failed "
648 				    "to attach to device\n");
649 
650 				cam_periph_invalidate(periph);
651 
652 				announce_buf[0] = '\0';
653 			}
654 		}
655 		if (announce_buf[0] != '\0')
656 			xpt_announce_periph(periph, announce_buf);
657 		softc->state = CH_STATE_NORMAL;
658 		free(mode_header, M_TEMP);
659 		/*
660 		 * Since our peripheral may be invalidated by an error
661 		 * above or an external event, we must release our CCB
662 		 * before releasing the probe lock on the peripheral.
663 		 * The peripheral will only go away once the last lock
664 		 * is removed, and we need it around for the CCB release
665 		 * operation.
666 		 */
667 		xpt_release_ccb(done_ccb);
668 		cam_periph_unhold(periph);
669 		return;
670 	}
671 	case CH_CCB_WAITING:
672 	{
673 		/* Caller will release the CCB */
674 		wakeup(&done_ccb->ccb_h.cbfcnp);
675 		return;
676 	}
677 	default:
678 		break;
679 	}
680 	xpt_release_ccb(done_ccb);
681 }
682 
683 static int
684 cherror(union ccb *ccb, u_int32_t cam_flags, u_int32_t sense_flags)
685 {
686 	struct ch_softc *softc;
687 	struct cam_periph *periph;
688 
689 	periph = xpt_path_periph(ccb->ccb_h.path);
690 	softc = (struct ch_softc *)periph->softc;
691 
692 	return (cam_periph_error(ccb, cam_flags, sense_flags,
693 				 &softc->saved_ccb));
694 }
695 
696 static int
697 chioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td)
698 {
699 	struct cam_periph *periph;
700 	struct ch_softc *softc;
701 	int error;
702 
703 	periph = (struct cam_periph *)dev->si_drv1;
704 	if (periph == NULL)
705 		return(ENXIO);
706 
707 	cam_periph_lock(periph);
708 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("entering chioctl\n"));
709 
710 	softc = (struct ch_softc *)periph->softc;
711 
712 	error = 0;
713 
714 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE,
715 		  ("trying to do ioctl %#lx\n", cmd));
716 
717 	/*
718 	 * If this command can change the device's state, we must
719 	 * have the device open for writing.
720 	 */
721 	switch (cmd) {
722 	case CHIOGPICKER:
723 	case CHIOGPARAMS:
724 	case CHIOGSTATUS:
725 		break;
726 
727 	default:
728 		if ((flag & FWRITE) == 0) {
729 			cam_periph_unlock(periph);
730 			return (EBADF);
731 		}
732 	}
733 
734 	switch (cmd) {
735 	case CHIOMOVE:
736 		error = chmove(periph, (struct changer_move *)addr);
737 		break;
738 
739 	case CHIOEXCHANGE:
740 		error = chexchange(periph, (struct changer_exchange *)addr);
741 		break;
742 
743 	case CHIOPOSITION:
744 		error = chposition(periph, (struct changer_position *)addr);
745 		break;
746 
747 	case CHIOGPICKER:
748 		*(int *)addr = softc->sc_picker - softc->sc_firsts[CHET_MT];
749 		break;
750 
751 	case CHIOSPICKER:
752 	{
753 		int new_picker = *(int *)addr;
754 
755 		if (new_picker > (softc->sc_counts[CHET_MT] - 1)) {
756 			error = EINVAL;
757 			break;
758 		}
759 		softc->sc_picker = softc->sc_firsts[CHET_MT] + new_picker;
760 		break;
761 	}
762 	case CHIOGPARAMS:
763 	{
764 		struct changer_params *cp = (struct changer_params *)addr;
765 
766 		cp->cp_npickers = softc->sc_counts[CHET_MT];
767 		cp->cp_nslots = softc->sc_counts[CHET_ST];
768 		cp->cp_nportals = softc->sc_counts[CHET_IE];
769 		cp->cp_ndrives = softc->sc_counts[CHET_DT];
770 		break;
771 	}
772 	case CHIOIELEM:
773 		error = chielem(periph, *(unsigned int *)addr);
774 		break;
775 
776 	case CHIOGSTATUS:
777 	{
778 		error = chgetelemstatus(periph,
779 			       (struct changer_element_status_request *) addr);
780 		break;
781 	}
782 
783 	case CHIOSETVOLTAG:
784 	{
785 		error = chsetvoltag(periph,
786 				    (struct changer_set_voltag_request *) addr);
787 		break;
788 	}
789 
790 	/* Implement prevent/allow? */
791 
792 	default:
793 		error = cam_periph_ioctl(periph, cmd, addr, cherror);
794 		break;
795 	}
796 
797 	cam_periph_unlock(periph);
798 	return (error);
799 }
800 
801 static int
802 chmove(struct cam_periph *periph, struct changer_move *cm)
803 {
804 	struct ch_softc *softc;
805 	u_int16_t fromelem, toelem;
806 	union ccb *ccb;
807 	int error;
808 
809 	error = 0;
810 	softc = (struct ch_softc *)periph->softc;
811 
812 	/*
813 	 * Check arguments.
814 	 */
815 	if ((cm->cm_fromtype > CHET_DT) || (cm->cm_totype > CHET_DT))
816 		return (EINVAL);
817 	if ((cm->cm_fromunit > (softc->sc_counts[cm->cm_fromtype] - 1)) ||
818 	    (cm->cm_tounit > (softc->sc_counts[cm->cm_totype] - 1)))
819 		return (ENODEV);
820 
821 	/*
822 	 * Check the request against the changer's capabilities.
823 	 */
824 	if ((softc->sc_movemask[cm->cm_fromtype] & (1 << cm->cm_totype)) == 0)
825 		return (ENODEV);
826 
827 	/*
828 	 * Calculate the source and destination elements.
829 	 */
830 	fromelem = softc->sc_firsts[cm->cm_fromtype] + cm->cm_fromunit;
831 	toelem = softc->sc_firsts[cm->cm_totype] + cm->cm_tounit;
832 
833 	ccb = cam_periph_getccb(periph, /*priority*/ 1);
834 
835 	scsi_move_medium(&ccb->csio,
836 			 /* retries */ 1,
837 			 /* cbfcnp */ chdone,
838 			 /* tag_action */ MSG_SIMPLE_Q_TAG,
839 			 /* tea */ softc->sc_picker,
840 			 /* src */ fromelem,
841 			 /* dst */ toelem,
842 			 /* invert */ (cm->cm_flags & CM_INVERT) ? TRUE : FALSE,
843 			 /* sense_len */ SSD_FULL_SIZE,
844 			 /* timeout */ CH_TIMEOUT_MOVE_MEDIUM);
845 
846 	error = cam_periph_runccb(ccb, cherror, /*cam_flags*/CAM_RETRY_SELTO,
847 				  /*sense_flags*/ SF_RETRY_UA,
848 				  softc->device_stats);
849 
850 	xpt_release_ccb(ccb);
851 
852 	return(error);
853 }
854 
855 static int
856 chexchange(struct cam_periph *periph, struct changer_exchange *ce)
857 {
858 	struct ch_softc *softc;
859 	u_int16_t src, dst1, dst2;
860 	union ccb *ccb;
861 	int error;
862 
863 	error = 0;
864 	softc = (struct ch_softc *)periph->softc;
865 	/*
866 	 * Check arguments.
867 	 */
868 	if ((ce->ce_srctype > CHET_DT) || (ce->ce_fdsttype > CHET_DT) ||
869 	    (ce->ce_sdsttype > CHET_DT))
870 		return (EINVAL);
871 	if ((ce->ce_srcunit > (softc->sc_counts[ce->ce_srctype] - 1)) ||
872 	    (ce->ce_fdstunit > (softc->sc_counts[ce->ce_fdsttype] - 1)) ||
873 	    (ce->ce_sdstunit > (softc->sc_counts[ce->ce_sdsttype] - 1)))
874 		return (ENODEV);
875 
876 	/*
877 	 * Check the request against the changer's capabilities.
878 	 */
879 	if (((softc->sc_exchangemask[ce->ce_srctype] &
880 	     (1 << ce->ce_fdsttype)) == 0) ||
881 	    ((softc->sc_exchangemask[ce->ce_fdsttype] &
882 	     (1 << ce->ce_sdsttype)) == 0))
883 		return (ENODEV);
884 
885 	/*
886 	 * Calculate the source and destination elements.
887 	 */
888 	src = softc->sc_firsts[ce->ce_srctype] + ce->ce_srcunit;
889 	dst1 = softc->sc_firsts[ce->ce_fdsttype] + ce->ce_fdstunit;
890 	dst2 = softc->sc_firsts[ce->ce_sdsttype] + ce->ce_sdstunit;
891 
892 	ccb = cam_periph_getccb(periph, /*priority*/ 1);
893 
894 	scsi_exchange_medium(&ccb->csio,
895 			     /* retries */ 1,
896 			     /* cbfcnp */ chdone,
897 			     /* tag_action */ MSG_SIMPLE_Q_TAG,
898 			     /* tea */ softc->sc_picker,
899 			     /* src */ src,
900 			     /* dst1 */ dst1,
901 			     /* dst2 */ dst2,
902 			     /* invert1 */ (ce->ce_flags & CE_INVERT1) ?
903 			                   TRUE : FALSE,
904 			     /* invert2 */ (ce->ce_flags & CE_INVERT2) ?
905 			                   TRUE : FALSE,
906 			     /* sense_len */ SSD_FULL_SIZE,
907 			     /* timeout */ CH_TIMEOUT_EXCHANGE_MEDIUM);
908 
909 	error = cam_periph_runccb(ccb, cherror, /*cam_flags*/CAM_RETRY_SELTO,
910 				  /*sense_flags*/ SF_RETRY_UA,
911 				  softc->device_stats);
912 
913 	xpt_release_ccb(ccb);
914 
915 	return(error);
916 }
917 
918 static int
919 chposition(struct cam_periph *periph, struct changer_position *cp)
920 {
921 	struct ch_softc *softc;
922 	u_int16_t dst;
923 	union ccb *ccb;
924 	int error;
925 
926 	error = 0;
927 	softc = (struct ch_softc *)periph->softc;
928 
929 	/*
930 	 * Check arguments.
931 	 */
932 	if (cp->cp_type > CHET_DT)
933 		return (EINVAL);
934 	if (cp->cp_unit > (softc->sc_counts[cp->cp_type] - 1))
935 		return (ENODEV);
936 
937 	/*
938 	 * Calculate the destination element.
939 	 */
940 	dst = softc->sc_firsts[cp->cp_type] + cp->cp_unit;
941 
942 	ccb = cam_periph_getccb(periph, /*priority*/ 1);
943 
944 	scsi_position_to_element(&ccb->csio,
945 				 /* retries */ 1,
946 				 /* cbfcnp */ chdone,
947 				 /* tag_action */ MSG_SIMPLE_Q_TAG,
948 				 /* tea */ softc->sc_picker,
949 				 /* dst */ dst,
950 				 /* invert */ (cp->cp_flags & CP_INVERT) ?
951 					      TRUE : FALSE,
952 				 /* sense_len */ SSD_FULL_SIZE,
953 				 /* timeout */ CH_TIMEOUT_POSITION_TO_ELEMENT);
954 
955 	error = cam_periph_runccb(ccb, cherror, /*cam_flags*/ CAM_RETRY_SELTO,
956 				  /*sense_flags*/ SF_RETRY_UA,
957 				  softc->device_stats);
958 
959 	xpt_release_ccb(ccb);
960 
961 	return(error);
962 }
963 
964 /*
965  * Copy a volume tag to a volume_tag struct, converting SCSI byte order
966  * to host native byte order in the volume serial number.  The volume
967  * label as returned by the changer is transferred to user mode as
968  * nul-terminated string.  Volume labels are truncated at the first
969  * space, as suggested by SCSI-2.
970  */
971 static	void
972 copy_voltag(struct changer_voltag *uvoltag, struct volume_tag *voltag)
973 {
974 	int i;
975 	for (i=0; i<CH_VOLTAG_MAXLEN; i++) {
976 		char c = voltag->vif[i];
977 		if (c && c != ' ')
978 			uvoltag->cv_volid[i] = c;
979 	        else
980 			break;
981 	}
982 	uvoltag->cv_serial = scsi_2btoul(voltag->vsn);
983 }
984 
985 /*
986  * Copy an an element status descriptor to a user-mode
987  * changer_element_status structure.
988  */
989 
990 static	void
991 copy_element_status(struct ch_softc *softc,
992 		    u_int16_t flags,
993 		    struct read_element_status_descriptor *desc,
994 		    struct changer_element_status *ces)
995 {
996 	u_int16_t eaddr = scsi_2btoul(desc->eaddr);
997 	u_int16_t et;
998 
999 	ces->ces_int_addr = eaddr;
1000 	/* set up logical address in element status */
1001 	for (et = CHET_MT; et <= CHET_DT; et++) {
1002 		if ((softc->sc_firsts[et] <= eaddr)
1003 		    && ((softc->sc_firsts[et] + softc->sc_counts[et])
1004 			> eaddr)) {
1005 			ces->ces_addr = eaddr - softc->sc_firsts[et];
1006 			ces->ces_type = et;
1007 			break;
1008 		}
1009 	}
1010 
1011 	ces->ces_flags = desc->flags1;
1012 
1013 	ces->ces_sensecode = desc->sense_code;
1014 	ces->ces_sensequal = desc->sense_qual;
1015 
1016 	if (desc->flags2 & READ_ELEMENT_STATUS_INVERT)
1017 		ces->ces_flags |= CES_INVERT;
1018 
1019 	if (desc->flags2 & READ_ELEMENT_STATUS_SVALID) {
1020 
1021 		eaddr = scsi_2btoul(desc->ssea);
1022 
1023 		/* convert source address to logical format */
1024 		for (et = CHET_MT; et <= CHET_DT; et++) {
1025 			if ((softc->sc_firsts[et] <= eaddr)
1026 			    && ((softc->sc_firsts[et] + softc->sc_counts[et])
1027 				> eaddr)) {
1028 				ces->ces_source_addr =
1029 					eaddr - softc->sc_firsts[et];
1030 				ces->ces_source_type = et;
1031 				ces->ces_flags |= CES_SOURCE_VALID;
1032 				break;
1033 			}
1034 		}
1035 
1036 		if (!(ces->ces_flags & CES_SOURCE_VALID))
1037 			printf("ch: warning: could not map element source "
1038 			       "address %ud to a valid element type\n",
1039 			       eaddr);
1040 	}
1041 
1042 
1043 	if (flags & READ_ELEMENT_STATUS_PVOLTAG)
1044 		copy_voltag(&(ces->ces_pvoltag), &(desc->pvoltag));
1045 	if (flags & READ_ELEMENT_STATUS_AVOLTAG)
1046 		copy_voltag(&(ces->ces_avoltag), &(desc->avoltag));
1047 
1048 	if (desc->dt_scsi_flags & READ_ELEMENT_STATUS_DT_IDVALID) {
1049 		ces->ces_flags |= CES_SCSIID_VALID;
1050 		ces->ces_scsi_id = desc->dt_scsi_addr;
1051 	}
1052 
1053 	if (desc->dt_scsi_addr & READ_ELEMENT_STATUS_DT_LUVALID) {
1054 		ces->ces_flags |= CES_LUN_VALID;
1055 		ces->ces_scsi_lun =
1056 			desc->dt_scsi_flags & READ_ELEMENT_STATUS_DT_LUNMASK;
1057 	}
1058 }
1059 
1060 static int
1061 chgetelemstatus(struct cam_periph *periph,
1062 		struct changer_element_status_request *cesr)
1063 {
1064 	struct read_element_status_header *st_hdr;
1065 	struct read_element_status_page_header *pg_hdr;
1066 	struct read_element_status_descriptor *desc;
1067 	caddr_t data = NULL;
1068 	size_t size, desclen;
1069 	int avail, i, error = 0;
1070 	struct changer_element_status *user_data = NULL;
1071 	struct ch_softc *softc;
1072 	union ccb *ccb;
1073 	int chet = cesr->cesr_element_type;
1074 	int want_voltags = (cesr->cesr_flags & CESR_VOLTAGS) ? 1 : 0;
1075 
1076 	softc = (struct ch_softc *)periph->softc;
1077 
1078 	/* perform argument checking */
1079 
1080 	/*
1081 	 * Perform a range check on the cesr_element_{base,count}
1082 	 * request argument fields.
1083 	 */
1084 	if ((softc->sc_counts[chet] - cesr->cesr_element_base) <= 0
1085 	    || (cesr->cesr_element_base + cesr->cesr_element_count)
1086 	        > softc->sc_counts[chet])
1087 		return (EINVAL);
1088 
1089 	/*
1090 	 * Request one descriptor for the given element type.  This
1091 	 * is used to determine the size of the descriptor so that
1092 	 * we can allocate enough storage for all of them.  We assume
1093 	 * that the first one can fit into 1k.
1094 	 */
1095 	cam_periph_unlock(periph);
1096 	data = (caddr_t)malloc(1024, M_DEVBUF, M_WAITOK);
1097 
1098 	cam_periph_lock(periph);
1099 	ccb = cam_periph_getccb(periph, /*priority*/ 1);
1100 
1101 	scsi_read_element_status(&ccb->csio,
1102 				 /* retries */ 1,
1103 				 /* cbfcnp */ chdone,
1104 				 /* tag_action */ MSG_SIMPLE_Q_TAG,
1105 				 /* voltag */ want_voltags,
1106 				 /* sea */ softc->sc_firsts[chet],
1107 				 /* count */ 1,
1108 				 /* data_ptr */ data,
1109 				 /* dxfer_len */ 1024,
1110 				 /* sense_len */ SSD_FULL_SIZE,
1111 				 /* timeout */ CH_TIMEOUT_READ_ELEMENT_STATUS);
1112 
1113 	error = cam_periph_runccb(ccb, cherror, /*cam_flags*/ CAM_RETRY_SELTO,
1114 				  /*sense_flags*/ SF_RETRY_UA,
1115 				  softc->device_stats);
1116 
1117 	if (error)
1118 		goto done;
1119 	cam_periph_unlock(periph);
1120 
1121 	st_hdr = (struct read_element_status_header *)data;
1122 	pg_hdr = (struct read_element_status_page_header *)((uintptr_t)st_hdr +
1123 		  sizeof(struct read_element_status_header));
1124 	desclen = scsi_2btoul(pg_hdr->edl);
1125 
1126 	size = sizeof(struct read_element_status_header) +
1127 	       sizeof(struct read_element_status_page_header) +
1128 	       (desclen * cesr->cesr_element_count);
1129 
1130 	/*
1131 	 * Reallocate storage for descriptors and get them from the
1132 	 * device.
1133 	 */
1134 	free(data, M_DEVBUF);
1135 	data = (caddr_t)malloc(size, M_DEVBUF, M_WAITOK);
1136 
1137 	cam_periph_lock(periph);
1138 	scsi_read_element_status(&ccb->csio,
1139 				 /* retries */ 1,
1140 				 /* cbfcnp */ chdone,
1141 				 /* tag_action */ MSG_SIMPLE_Q_TAG,
1142 				 /* voltag */ want_voltags,
1143 				 /* sea */ softc->sc_firsts[chet]
1144 				 + cesr->cesr_element_base,
1145 				 /* count */ cesr->cesr_element_count,
1146 				 /* data_ptr */ data,
1147 				 /* dxfer_len */ size,
1148 				 /* sense_len */ SSD_FULL_SIZE,
1149 				 /* timeout */ CH_TIMEOUT_READ_ELEMENT_STATUS);
1150 
1151 	error = cam_periph_runccb(ccb, cherror, /*cam_flags*/ CAM_RETRY_SELTO,
1152 				  /*sense_flags*/ SF_RETRY_UA,
1153 				  softc->device_stats);
1154 
1155 	if (error)
1156 		goto done;
1157 	cam_periph_unlock(periph);
1158 
1159 	/*
1160 	 * Fill in the user status array.
1161 	 */
1162 	st_hdr = (struct read_element_status_header *)data;
1163 	pg_hdr = (struct read_element_status_page_header *)((uintptr_t)st_hdr +
1164 		  sizeof(struct read_element_status_header));
1165 	avail = scsi_2btoul(st_hdr->count);
1166 
1167 	if (avail != cesr->cesr_element_count) {
1168 		xpt_print(periph->path,
1169 		    "warning, READ ELEMENT STATUS avail != count\n");
1170 	}
1171 
1172 	user_data = (struct changer_element_status *)
1173 		malloc(avail * sizeof(struct changer_element_status),
1174 		       M_DEVBUF, M_WAITOK | M_ZERO);
1175 
1176 	desc = (struct read_element_status_descriptor *)((uintptr_t)data +
1177 		sizeof(struct read_element_status_header) +
1178 		sizeof(struct read_element_status_page_header));
1179 	/*
1180 	 * Set up the individual element status structures
1181 	 */
1182 	for (i = 0; i < avail; ++i) {
1183 		struct changer_element_status *ces = &(user_data[i]);
1184 
1185 		copy_element_status(softc, pg_hdr->flags, desc, ces);
1186 
1187 		desc = (struct read_element_status_descriptor *)
1188 		       ((uintptr_t)desc + desclen);
1189 	}
1190 
1191 	/* Copy element status structures out to userspace. */
1192 	error = copyout(user_data,
1193 			cesr->cesr_element_status,
1194 			avail * sizeof(struct changer_element_status));
1195 	cam_periph_lock(periph);
1196 
1197  done:
1198 	xpt_release_ccb(ccb);
1199 
1200 	if (data != NULL)
1201 		free(data, M_DEVBUF);
1202 	if (user_data != NULL)
1203 		free(user_data, M_DEVBUF);
1204 
1205 	return (error);
1206 }
1207 
1208 static int
1209 chielem(struct cam_periph *periph,
1210 	unsigned int timeout)
1211 {
1212 	union ccb *ccb;
1213 	struct ch_softc *softc;
1214 	int error;
1215 
1216 	if (!timeout) {
1217 		timeout = CH_TIMEOUT_INITIALIZE_ELEMENT_STATUS;
1218 	} else {
1219 		timeout *= 1000;
1220 	}
1221 
1222 	error = 0;
1223 	softc = (struct ch_softc *)periph->softc;
1224 
1225 	ccb = cam_periph_getccb(periph, /*priority*/ 1);
1226 
1227 	scsi_initialize_element_status(&ccb->csio,
1228 				      /* retries */ 1,
1229 				      /* cbfcnp */ chdone,
1230 				      /* tag_action */ MSG_SIMPLE_Q_TAG,
1231 				      /* sense_len */ SSD_FULL_SIZE,
1232 				      /* timeout */ timeout);
1233 
1234 	error = cam_periph_runccb(ccb, cherror, /*cam_flags*/ CAM_RETRY_SELTO,
1235 				  /*sense_flags*/ SF_RETRY_UA,
1236 				  softc->device_stats);
1237 
1238 	xpt_release_ccb(ccb);
1239 
1240 	return(error);
1241 }
1242 
1243 static int
1244 chsetvoltag(struct cam_periph *periph,
1245 	    struct changer_set_voltag_request *csvr)
1246 {
1247 	union ccb *ccb;
1248 	struct ch_softc *softc;
1249 	u_int16_t ea;
1250 	u_int8_t sac;
1251 	struct scsi_send_volume_tag_parameters ssvtp;
1252 	int error;
1253 	int i;
1254 
1255 	error = 0;
1256 	softc = (struct ch_softc *)periph->softc;
1257 
1258 	bzero(&ssvtp, sizeof(ssvtp));
1259 	for (i=0; i<sizeof(ssvtp.vitf); i++) {
1260 		ssvtp.vitf[i] = ' ';
1261 	}
1262 
1263 	/*
1264 	 * Check arguments.
1265 	 */
1266 	if (csvr->csvr_type > CHET_DT)
1267 		return EINVAL;
1268 	if (csvr->csvr_addr > (softc->sc_counts[csvr->csvr_type] - 1))
1269 		return ENODEV;
1270 
1271 	ea = softc->sc_firsts[csvr->csvr_type] + csvr->csvr_addr;
1272 
1273 	if (csvr->csvr_flags & CSVR_ALTERNATE) {
1274 		switch (csvr->csvr_flags & CSVR_MODE_MASK) {
1275 		case CSVR_MODE_SET:
1276 			sac = SEND_VOLUME_TAG_ASSERT_ALTERNATE;
1277 			break;
1278 		case CSVR_MODE_REPLACE:
1279 			sac = SEND_VOLUME_TAG_REPLACE_ALTERNATE;
1280 			break;
1281 		case CSVR_MODE_CLEAR:
1282 			sac = SEND_VOLUME_TAG_UNDEFINED_ALTERNATE;
1283 			break;
1284 		default:
1285 			error = EINVAL;
1286 			goto out;
1287 		}
1288 	} else {
1289 		switch (csvr->csvr_flags & CSVR_MODE_MASK) {
1290 		case CSVR_MODE_SET:
1291 			sac = SEND_VOLUME_TAG_ASSERT_PRIMARY;
1292 			break;
1293 		case CSVR_MODE_REPLACE:
1294 			sac = SEND_VOLUME_TAG_REPLACE_PRIMARY;
1295 			break;
1296 		case CSVR_MODE_CLEAR:
1297 			sac = SEND_VOLUME_TAG_UNDEFINED_PRIMARY;
1298 			break;
1299 		default:
1300 			error = EINVAL;
1301 			goto out;
1302 		}
1303 	}
1304 
1305 	memcpy(ssvtp.vitf, csvr->csvr_voltag.cv_volid,
1306 	       min(strlen(csvr->csvr_voltag.cv_volid), sizeof(ssvtp.vitf)));
1307 	scsi_ulto2b(csvr->csvr_voltag.cv_serial, ssvtp.minvsn);
1308 
1309 	ccb = cam_periph_getccb(periph, /*priority*/ 1);
1310 
1311 	scsi_send_volume_tag(&ccb->csio,
1312 			     /* retries */ 1,
1313 			     /* cbfcnp */ chdone,
1314 			     /* tag_action */ MSG_SIMPLE_Q_TAG,
1315 			     /* element_address */ ea,
1316 			     /* send_action_code */ sac,
1317 			     /* parameters */ &ssvtp,
1318 			     /* sense_len */ SSD_FULL_SIZE,
1319 			     /* timeout */ CH_TIMEOUT_SEND_VOLTAG);
1320 
1321 	error = cam_periph_runccb(ccb, cherror, /*cam_flags*/ CAM_RETRY_SELTO,
1322 				  /*sense_flags*/ SF_RETRY_UA,
1323 				  softc->device_stats);
1324 
1325 	xpt_release_ccb(ccb);
1326 
1327  out:
1328 	return error;
1329 }
1330 
1331 static int
1332 chgetparams(struct cam_periph *periph)
1333 {
1334 	union ccb *ccb;
1335 	struct ch_softc *softc;
1336 	void *mode_buffer;
1337 	int mode_buffer_len;
1338 	struct page_element_address_assignment *ea;
1339 	struct page_device_capabilities *cap;
1340 	int error, from, dbd;
1341 	u_int8_t *moves, *exchanges;
1342 
1343 	error = 0;
1344 
1345 	softc = (struct ch_softc *)periph->softc;
1346 
1347 	ccb = cam_periph_getccb(periph, /*priority*/ 1);
1348 
1349 	/*
1350 	 * The scsi_mode_sense_data structure is just a convenience
1351 	 * structure that allows us to easily calculate the worst-case
1352 	 * storage size of the mode sense buffer.
1353 	 */
1354 	mode_buffer_len = sizeof(struct scsi_mode_sense_data);
1355 
1356 	mode_buffer = malloc(mode_buffer_len, M_TEMP, M_NOWAIT);
1357 
1358 	if (mode_buffer == NULL) {
1359 		printf("chgetparams: couldn't malloc mode sense data\n");
1360 		return(ENOSPC);
1361 	}
1362 
1363 	bzero(mode_buffer, mode_buffer_len);
1364 
1365 	if (softc->quirks & CH_Q_NO_DBD)
1366 		dbd = FALSE;
1367 	else
1368 		dbd = TRUE;
1369 
1370 	/*
1371 	 * Get the element address assignment page.
1372 	 */
1373 	scsi_mode_sense(&ccb->csio,
1374 			/* retries */ 1,
1375 			/* cbfcnp */ chdone,
1376 			/* tag_action */ MSG_SIMPLE_Q_TAG,
1377 			/* dbd */ dbd,
1378 			/* page_code */ SMS_PAGE_CTRL_CURRENT,
1379 			/* page */ CH_ELEMENT_ADDR_ASSIGN_PAGE,
1380 			/* param_buf */ (u_int8_t *)mode_buffer,
1381 			/* param_len */ mode_buffer_len,
1382 			/* sense_len */ SSD_FULL_SIZE,
1383 			/* timeout */ CH_TIMEOUT_MODE_SENSE);
1384 
1385 	error = cam_periph_runccb(ccb, cherror, /*cam_flags*/ CAM_RETRY_SELTO,
1386 				  /* sense_flags */ SF_RETRY_UA|SF_NO_PRINT,
1387 				  softc->device_stats);
1388 
1389 	if (error) {
1390 		if (dbd) {
1391 			struct scsi_mode_sense_6 *sms;
1392 
1393 			sms = (struct scsi_mode_sense_6 *)
1394 				ccb->csio.cdb_io.cdb_bytes;
1395 
1396 			sms->byte2 &= ~SMS_DBD;
1397 			error = cam_periph_runccb(ccb, cherror,
1398 						  /*cam_flags*/ CAM_RETRY_SELTO,
1399 				  		  /*sense_flags*/ SF_RETRY_UA,
1400 						  softc->device_stats);
1401 		} else {
1402 			/*
1403 			 * Since we disabled sense printing above, print
1404 			 * out the sense here since we got an error.
1405 			 */
1406 			scsi_sense_print(&ccb->csio);
1407 		}
1408 
1409 		if (error) {
1410 			xpt_print(periph->path,
1411 			    "chgetparams: error getting element "
1412 			    "address page\n");
1413 			xpt_release_ccb(ccb);
1414 			free(mode_buffer, M_TEMP);
1415 			return(error);
1416 		}
1417 	}
1418 
1419 	ea = (struct page_element_address_assignment *)
1420 		find_mode_page_6((struct scsi_mode_header_6 *)mode_buffer);
1421 
1422 	softc->sc_firsts[CHET_MT] = scsi_2btoul(ea->mtea);
1423 	softc->sc_counts[CHET_MT] = scsi_2btoul(ea->nmte);
1424 	softc->sc_firsts[CHET_ST] = scsi_2btoul(ea->fsea);
1425 	softc->sc_counts[CHET_ST] = scsi_2btoul(ea->nse);
1426 	softc->sc_firsts[CHET_IE] = scsi_2btoul(ea->fieea);
1427 	softc->sc_counts[CHET_IE] = scsi_2btoul(ea->niee);
1428 	softc->sc_firsts[CHET_DT] = scsi_2btoul(ea->fdtea);
1429 	softc->sc_counts[CHET_DT] = scsi_2btoul(ea->ndte);
1430 
1431 	bzero(mode_buffer, mode_buffer_len);
1432 
1433 	/*
1434 	 * Now get the device capabilities page.
1435 	 */
1436 	scsi_mode_sense(&ccb->csio,
1437 			/* retries */ 1,
1438 			/* cbfcnp */ chdone,
1439 			/* tag_action */ MSG_SIMPLE_Q_TAG,
1440 			/* dbd */ dbd,
1441 			/* page_code */ SMS_PAGE_CTRL_CURRENT,
1442 			/* page */ CH_DEVICE_CAP_PAGE,
1443 			/* param_buf */ (u_int8_t *)mode_buffer,
1444 			/* param_len */ mode_buffer_len,
1445 			/* sense_len */ SSD_FULL_SIZE,
1446 			/* timeout */ CH_TIMEOUT_MODE_SENSE);
1447 
1448 	error = cam_periph_runccb(ccb, cherror, /*cam_flags*/ CAM_RETRY_SELTO,
1449 				  /* sense_flags */ SF_RETRY_UA | SF_NO_PRINT,
1450 				  softc->device_stats);
1451 
1452 	if (error) {
1453 		if (dbd) {
1454 			struct scsi_mode_sense_6 *sms;
1455 
1456 			sms = (struct scsi_mode_sense_6 *)
1457 				ccb->csio.cdb_io.cdb_bytes;
1458 
1459 			sms->byte2 &= ~SMS_DBD;
1460 			error = cam_periph_runccb(ccb, cherror,
1461 						  /*cam_flags*/ CAM_RETRY_SELTO,
1462 				  		  /*sense_flags*/ SF_RETRY_UA,
1463 						  softc->device_stats);
1464 		} else {
1465 			/*
1466 			 * Since we disabled sense printing above, print
1467 			 * out the sense here since we got an error.
1468 			 */
1469 			scsi_sense_print(&ccb->csio);
1470 		}
1471 
1472 		if (error) {
1473 			xpt_print(periph->path,
1474 			    "chgetparams: error getting device "
1475 			    "capabilities page\n");
1476 			xpt_release_ccb(ccb);
1477 			free(mode_buffer, M_TEMP);
1478 			return(error);
1479 		}
1480 	}
1481 
1482 	xpt_release_ccb(ccb);
1483 
1484 	cap = (struct page_device_capabilities *)
1485 		find_mode_page_6((struct scsi_mode_header_6 *)mode_buffer);
1486 
1487 	bzero(softc->sc_movemask, sizeof(softc->sc_movemask));
1488 	bzero(softc->sc_exchangemask, sizeof(softc->sc_exchangemask));
1489 	moves = cap->move_from;
1490 	exchanges = cap->exchange_with;
1491 	for (from = CHET_MT; from <= CHET_MAX; ++from) {
1492 		softc->sc_movemask[from] = moves[from];
1493 		softc->sc_exchangemask[from] = exchanges[from];
1494 	}
1495 
1496 	free(mode_buffer, M_TEMP);
1497 
1498 	return(error);
1499 }
1500 
1501 void
1502 scsi_move_medium(struct ccb_scsiio *csio, u_int32_t retries,
1503 		 void (*cbfcnp)(struct cam_periph *, union ccb *),
1504 		 u_int8_t tag_action, u_int32_t tea, u_int32_t src,
1505 		 u_int32_t dst, int invert, u_int8_t sense_len,
1506 		 u_int32_t timeout)
1507 {
1508 	struct scsi_move_medium *scsi_cmd;
1509 
1510 	scsi_cmd = (struct scsi_move_medium *)&csio->cdb_io.cdb_bytes;
1511 	bzero(scsi_cmd, sizeof(*scsi_cmd));
1512 
1513 	scsi_cmd->opcode = MOVE_MEDIUM;
1514 
1515 	scsi_ulto2b(tea, scsi_cmd->tea);
1516 	scsi_ulto2b(src, scsi_cmd->src);
1517 	scsi_ulto2b(dst, scsi_cmd->dst);
1518 
1519 	if (invert)
1520 		scsi_cmd->invert |= MOVE_MEDIUM_INVERT;
1521 
1522 	cam_fill_csio(csio,
1523 		      retries,
1524 		      cbfcnp,
1525 		      /*flags*/ CAM_DIR_NONE,
1526 		      tag_action,
1527 		      /*data_ptr*/ NULL,
1528 		      /*dxfer_len*/ 0,
1529 		      sense_len,
1530 		      sizeof(*scsi_cmd),
1531 		      timeout);
1532 }
1533 
1534 void
1535 scsi_exchange_medium(struct ccb_scsiio *csio, u_int32_t retries,
1536 		     void (*cbfcnp)(struct cam_periph *, union ccb *),
1537 		     u_int8_t tag_action, u_int32_t tea, u_int32_t src,
1538 		     u_int32_t dst1, u_int32_t dst2, int invert1,
1539 		     int invert2, u_int8_t sense_len, u_int32_t timeout)
1540 {
1541 	struct scsi_exchange_medium *scsi_cmd;
1542 
1543 	scsi_cmd = (struct scsi_exchange_medium *)&csio->cdb_io.cdb_bytes;
1544 	bzero(scsi_cmd, sizeof(*scsi_cmd));
1545 
1546 	scsi_cmd->opcode = EXCHANGE_MEDIUM;
1547 
1548 	scsi_ulto2b(tea, scsi_cmd->tea);
1549 	scsi_ulto2b(src, scsi_cmd->src);
1550 	scsi_ulto2b(dst1, scsi_cmd->fdst);
1551 	scsi_ulto2b(dst2, scsi_cmd->sdst);
1552 
1553 	if (invert1)
1554 		scsi_cmd->invert |= EXCHANGE_MEDIUM_INV1;
1555 
1556 	if (invert2)
1557 		scsi_cmd->invert |= EXCHANGE_MEDIUM_INV2;
1558 
1559 	cam_fill_csio(csio,
1560 		      retries,
1561 		      cbfcnp,
1562 		      /*flags*/ CAM_DIR_NONE,
1563 		      tag_action,
1564 		      /*data_ptr*/ NULL,
1565 		      /*dxfer_len*/ 0,
1566 		      sense_len,
1567 		      sizeof(*scsi_cmd),
1568 		      timeout);
1569 }
1570 
1571 void
1572 scsi_position_to_element(struct ccb_scsiio *csio, u_int32_t retries,
1573 			 void (*cbfcnp)(struct cam_periph *, union ccb *),
1574 			 u_int8_t tag_action, u_int32_t tea, u_int32_t dst,
1575 			 int invert, u_int8_t sense_len, u_int32_t timeout)
1576 {
1577 	struct scsi_position_to_element *scsi_cmd;
1578 
1579 	scsi_cmd = (struct scsi_position_to_element *)&csio->cdb_io.cdb_bytes;
1580 	bzero(scsi_cmd, sizeof(*scsi_cmd));
1581 
1582 	scsi_cmd->opcode = POSITION_TO_ELEMENT;
1583 
1584 	scsi_ulto2b(tea, scsi_cmd->tea);
1585 	scsi_ulto2b(dst, scsi_cmd->dst);
1586 
1587 	if (invert)
1588 		scsi_cmd->invert |= POSITION_TO_ELEMENT_INVERT;
1589 
1590 	cam_fill_csio(csio,
1591 		      retries,
1592 		      cbfcnp,
1593 		      /*flags*/ CAM_DIR_NONE,
1594 		      tag_action,
1595 		      /*data_ptr*/ NULL,
1596 		      /*dxfer_len*/ 0,
1597 		      sense_len,
1598 		      sizeof(*scsi_cmd),
1599 		      timeout);
1600 }
1601 
1602 void
1603 scsi_read_element_status(struct ccb_scsiio *csio, u_int32_t retries,
1604 			 void (*cbfcnp)(struct cam_periph *, union ccb *),
1605 			 u_int8_t tag_action, int voltag, u_int32_t sea,
1606 			 u_int32_t count, u_int8_t *data_ptr,
1607 			 u_int32_t dxfer_len, u_int8_t sense_len,
1608 			 u_int32_t timeout)
1609 {
1610 	struct scsi_read_element_status *scsi_cmd;
1611 
1612 	scsi_cmd = (struct scsi_read_element_status *)&csio->cdb_io.cdb_bytes;
1613 	bzero(scsi_cmd, sizeof(*scsi_cmd));
1614 
1615 	scsi_cmd->opcode = READ_ELEMENT_STATUS;
1616 
1617 	scsi_ulto2b(sea, scsi_cmd->sea);
1618 	scsi_ulto2b(count, scsi_cmd->count);
1619 	scsi_ulto3b(dxfer_len, scsi_cmd->len);
1620 
1621 	if (voltag)
1622 		scsi_cmd->byte2 |= READ_ELEMENT_STATUS_VOLTAG;
1623 
1624 	cam_fill_csio(csio,
1625 		      retries,
1626 		      cbfcnp,
1627 		      /*flags*/ CAM_DIR_IN,
1628 		      tag_action,
1629 		      data_ptr,
1630 		      dxfer_len,
1631 		      sense_len,
1632 		      sizeof(*scsi_cmd),
1633 		      timeout);
1634 }
1635 
1636 void
1637 scsi_initialize_element_status(struct ccb_scsiio *csio, u_int32_t retries,
1638 			       void (*cbfcnp)(struct cam_periph *, union ccb *),
1639 			       u_int8_t tag_action, u_int8_t sense_len,
1640 			       u_int32_t timeout)
1641 {
1642 	struct scsi_initialize_element_status *scsi_cmd;
1643 
1644 	scsi_cmd = (struct scsi_initialize_element_status *)
1645 		    &csio->cdb_io.cdb_bytes;
1646 	bzero(scsi_cmd, sizeof(*scsi_cmd));
1647 
1648 	scsi_cmd->opcode = INITIALIZE_ELEMENT_STATUS;
1649 
1650 	cam_fill_csio(csio,
1651 		      retries,
1652 		      cbfcnp,
1653 		      /*flags*/ CAM_DIR_NONE,
1654 		      tag_action,
1655 		      /* data_ptr */ NULL,
1656 		      /* dxfer_len */ 0,
1657 		      sense_len,
1658 		      sizeof(*scsi_cmd),
1659 		      timeout);
1660 }
1661 
1662 void
1663 scsi_send_volume_tag(struct ccb_scsiio *csio, u_int32_t retries,
1664 		     void (*cbfcnp)(struct cam_periph *, union ccb *),
1665 		     u_int8_t tag_action,
1666 		     u_int16_t element_address,
1667 		     u_int8_t send_action_code,
1668 		     struct scsi_send_volume_tag_parameters *parameters,
1669 		     u_int8_t sense_len, u_int32_t timeout)
1670 {
1671 	struct scsi_send_volume_tag *scsi_cmd;
1672 
1673 	scsi_cmd = (struct scsi_send_volume_tag *) &csio->cdb_io.cdb_bytes;
1674 	bzero(scsi_cmd, sizeof(*scsi_cmd));
1675 
1676 	scsi_cmd->opcode = SEND_VOLUME_TAG;
1677 	scsi_ulto2b(element_address, scsi_cmd->ea);
1678 	scsi_cmd->sac = send_action_code;
1679 	scsi_ulto2b(sizeof(*parameters), scsi_cmd->pll);
1680 
1681 	cam_fill_csio(csio,
1682 		      retries,
1683 		      cbfcnp,
1684 		      /*flags*/ CAM_DIR_OUT,
1685 		      tag_action,
1686 		      /* data_ptr */ (u_int8_t *) parameters,
1687 		      sizeof(*parameters),
1688 		      sense_len,
1689 		      sizeof(*scsi_cmd),
1690 		      timeout);
1691 }
1692