1 /* $NetBSD: ch.c,v 1.95 2021/09/26 14:57:19 thorpej Exp $ */
2
3 /*-
4 * Copyright (c) 1996, 1997, 1998, 1999, 2004 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
9 * NASA Ames Research Center.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #include <sys/cdefs.h>
34 __KERNEL_RCSID(0, "$NetBSD: ch.c,v 1.95 2021/09/26 14:57:19 thorpej Exp $");
35
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/kernel.h>
39 #include <sys/errno.h>
40 #include <sys/ioctl.h>
41 #include <sys/buf.h>
42 #include <sys/proc.h>
43 #include <sys/chio.h>
44 #include <sys/device.h>
45 #include <sys/malloc.h>
46 #include <sys/conf.h>
47 #include <sys/fcntl.h>
48 #include <sys/vnode.h>
49 #include <sys/time.h>
50 #include <sys/select.h>
51 #include <sys/poll.h>
52
53 #include <dev/scsipi/scsipi_all.h>
54 #include <dev/scsipi/scsi_all.h>
55 #include <dev/scsipi/scsi_changer.h>
56 #include <dev/scsipi/scsiconf.h>
57
58 #define CHRETRIES 2
59 #define CHTIMEOUT (5 * 60 * 1000)
60
61 #define CHUNIT(x) (minor((x)))
62
63 struct ch_softc {
64 device_t sc_dev; /* generic device info */
65 struct scsipi_periph *sc_periph;/* our periph data */
66
67 u_int sc_events; /* event bitmask */
68 struct selinfo sc_selq; /* select/poll queue for events */
69
70 int sc_flags; /* misc. info */
71
72 int sc_picker; /* current picker */
73
74 /*
75 * The following information is obtained from the
76 * element address assignment page.
77 */
78 int sc_firsts[4]; /* firsts, indexed by CHET_* */
79 int sc_counts[4]; /* counts, indexed by CHET_* */
80
81 /*
82 * The following mask defines the legal combinations
83 * of elements for the MOVE MEDIUM command.
84 */
85 u_int8_t sc_movemask[4];
86
87 /*
88 * As above, but for EXCHANGE MEDIUM.
89 */
90 u_int8_t sc_exchangemask[4];
91
92 /*
93 * Quirks; see below.
94 */
95 int sc_settledelay; /* delay for settle */
96
97 };
98
99 /* sc_flags */
100 #define CHF_ROTATE 0x01 /* picker can rotate */
101
102 /* Autoconfiguration glue */
103 static int chmatch(device_t, cfdata_t, void *);
104 static void chattach(device_t, device_t, void *);
105
106 CFATTACH_DECL_NEW(ch, sizeof(struct ch_softc),
107 chmatch, chattach, NULL, NULL);
108
109 extern struct cfdriver ch_cd;
110
111 static struct scsipi_inquiry_pattern ch_patterns[] = {
112 {T_CHANGER, T_REMOV,
113 "", "", ""},
114 };
115
116 static dev_type_open(chopen);
117 static dev_type_close(chclose);
118 static dev_type_read(chread);
119 static dev_type_ioctl(chioctl);
120 static dev_type_poll(chpoll);
121 static dev_type_kqfilter(chkqfilter);
122
123 const struct cdevsw ch_cdevsw = {
124 .d_open = chopen,
125 .d_close = chclose,
126 .d_read = chread,
127 .d_write = nowrite,
128 .d_ioctl = chioctl,
129 .d_stop = nostop,
130 .d_tty = notty,
131 .d_poll = chpoll,
132 .d_mmap = nommap,
133 .d_kqfilter = chkqfilter,
134 .d_discard = nodiscard,
135 .d_flag = D_OTHER | D_MPSAFE
136 };
137
138 /* SCSI glue */
139 static int ch_interpret_sense(struct scsipi_xfer *);
140
141 static const struct scsipi_periphsw ch_switch = {
142 ch_interpret_sense, /* check our error handler first */
143 NULL, /* no queue; our commands are synchronous */
144 NULL, /* have no async handler */
145 NULL, /* nothing to be done when xfer is done */
146 };
147
148 static int ch_move(struct ch_softc *, struct changer_move_request *);
149 static int ch_exchange(struct ch_softc *,
150 struct changer_exchange_request *);
151 static int ch_position(struct ch_softc *,
152 struct changer_position_request *);
153 static int ch_ielem(struct ch_softc *);
154 static int ch_ousergetelemstatus(struct ch_softc *, int, u_int8_t *);
155 static int ch_usergetelemstatus(struct ch_softc *,
156 struct changer_element_status_request *);
157 static int ch_getelemstatus(struct ch_softc *, int, int, void *,
158 size_t, int, int);
159 static int ch_setvoltag(struct ch_softc *,
160 struct changer_set_voltag_request *);
161 static int ch_get_params(struct ch_softc *, int);
162 static void ch_get_quirks(struct ch_softc *,
163 struct scsipi_inquiry_pattern *);
164 static void ch_event(struct ch_softc *, u_int);
165 static int ch_map_element(struct ch_softc *, u_int16_t, int *, int *);
166
167 static void ch_voltag_convert_in(const struct changer_volume_tag *,
168 struct changer_voltag *);
169 static int ch_voltag_convert_out(const struct changer_voltag *,
170 struct changer_volume_tag *);
171
172 /*
173 * SCSI changer quirks.
174 */
175 struct chquirk {
176 struct scsipi_inquiry_pattern cq_match; /* device id pattern */
177 int cq_settledelay; /* settle delay, in seconds */
178 };
179
180 static const struct chquirk chquirks[] = {
181 {{T_CHANGER, T_REMOV,
182 "SPECTRA", "9000", "0200"},
183 75},
184 };
185
186 static int
chmatch(device_t parent,cfdata_t match,void * aux)187 chmatch(device_t parent, cfdata_t match,
188 void *aux)
189 {
190 struct scsipibus_attach_args *sa = aux;
191 int priority;
192
193 (void)scsipi_inqmatch(&sa->sa_inqbuf,
194 (void *)ch_patterns, sizeof(ch_patterns) / sizeof(ch_patterns[0]),
195 sizeof(ch_patterns[0]), &priority);
196
197 return (priority);
198 }
199
200 static void
chattach(device_t parent,device_t self,void * aux)201 chattach(device_t parent, device_t self, void *aux)
202 {
203 struct ch_softc *sc = device_private(self);
204 struct scsipibus_attach_args *sa = aux;
205 struct scsipi_periph *periph = sa->sa_periph;
206
207 sc->sc_dev = self;
208 selinit(&sc->sc_selq);
209
210 /* Glue into the SCSI bus */
211 sc->sc_periph = periph;
212 periph->periph_dev = sc->sc_dev;
213 periph->periph_switch = &ch_switch;
214
215 printf("\n");
216
217 /*
218 * Find out our device's quirks.
219 */
220 ch_get_quirks(sc, &sa->sa_inqbuf);
221
222 /*
223 * Some changers require a long time to settle out, to do
224 * tape inventory, for instance.
225 */
226 if (sc->sc_settledelay) {
227 printf("%s: waiting %d seconds for changer to settle...\n",
228 device_xname(sc->sc_dev), sc->sc_settledelay);
229 delay(1000000 * sc->sc_settledelay);
230 }
231
232 /*
233 * Get information about the device. Note we can't use
234 * interrupts yet.
235 */
236 if (ch_get_params(sc, XS_CTL_DISCOVERY|XS_CTL_IGNORE_MEDIA_CHANGE))
237 printf("%s: offline\n", device_xname(sc->sc_dev));
238 else {
239 #define PLURAL(c) (c) == 1 ? "" : "s"
240 printf("%s: %d slot%s, %d drive%s, %d picker%s, %d portal%s\n",
241 device_xname(sc->sc_dev),
242 sc->sc_counts[CHET_ST], PLURAL(sc->sc_counts[CHET_ST]),
243 sc->sc_counts[CHET_DT], PLURAL(sc->sc_counts[CHET_DT]),
244 sc->sc_counts[CHET_MT], PLURAL(sc->sc_counts[CHET_MT]),
245 sc->sc_counts[CHET_IE], PLURAL(sc->sc_counts[CHET_IE]));
246 #undef PLURAL
247 #ifdef CHANGER_DEBUG
248 printf("%s: move mask: 0x%x 0x%x 0x%x 0x%x\n",
249 device_xname(sc->sc_dev),
250 sc->sc_movemask[CHET_MT], sc->sc_movemask[CHET_ST],
251 sc->sc_movemask[CHET_IE], sc->sc_movemask[CHET_DT]);
252 printf("%s: exchange mask: 0x%x 0x%x 0x%x 0x%x\n",
253 device_xname(sc->sc_dev),
254 sc->sc_exchangemask[CHET_MT], sc->sc_exchangemask[CHET_ST],
255 sc->sc_exchangemask[CHET_IE], sc->sc_exchangemask[CHET_DT]);
256 #endif /* CHANGER_DEBUG */
257 }
258
259 /* Default the current picker. */
260 sc->sc_picker = sc->sc_firsts[CHET_MT];
261 }
262
263 static int
chopen(dev_t dev,int flags,int fmt,struct lwp * l)264 chopen(dev_t dev, int flags, int fmt, struct lwp *l)
265 {
266 struct ch_softc *sc;
267 struct scsipi_periph *periph;
268 struct scsipi_adapter *adapt;
269 int unit, error;
270
271 unit = CHUNIT(dev);
272 sc = device_lookup_private(&ch_cd, unit);
273 if (sc == NULL)
274 return (ENXIO);
275
276 periph = sc->sc_periph;
277 adapt = periph->periph_channel->chan_adapter;
278
279 /*
280 * Only allow one open at a time.
281 */
282 if (periph->periph_flags & PERIPH_OPEN)
283 return (EBUSY);
284
285 if ((error = scsipi_adapter_addref(adapt)) != 0)
286 return (error);
287
288 /*
289 * Make sure the unit is on-line. If a UNIT ATTENTION
290 * occurs, we will mark that an Init-Element-Status is
291 * needed in ch_get_params().
292 *
293 * We ignore NOT READY in case e.g a magazine isn't actually
294 * loaded into the changer or a tape isn't in the drive.
295 */
296 error = scsipi_test_unit_ready(periph, XS_CTL_IGNORE_NOT_READY);
297 if (error)
298 goto bad;
299
300 periph->periph_flags |= PERIPH_OPEN;
301
302 /*
303 * Make sure our parameters are up to date.
304 */
305 if ((error = ch_get_params(sc, 0)) != 0)
306 goto bad;
307
308 return (0);
309
310 bad:
311 scsipi_adapter_delref(adapt);
312 periph->periph_flags &= ~PERIPH_OPEN;
313 return (error);
314 }
315
316 static int
chclose(dev_t dev,int flags,int fmt,struct lwp * l)317 chclose(dev_t dev, int flags, int fmt, struct lwp *l)
318 {
319 struct ch_softc *sc = device_lookup_private(&ch_cd, CHUNIT(dev));
320 struct scsipi_periph *periph = sc->sc_periph;
321 struct scsipi_adapter *adapt = periph->periph_channel->chan_adapter;
322
323 scsipi_wait_drain(periph);
324
325 scsipi_adapter_delref(adapt);
326
327 sc->sc_events = 0;
328
329 periph->periph_flags &= ~PERIPH_OPEN;
330 return (0);
331 }
332
333 static int
chread(dev_t dev,struct uio * uio,int flags)334 chread(dev_t dev, struct uio *uio, int flags)
335 {
336 struct ch_softc *sc = device_lookup_private(&ch_cd, CHUNIT(dev));
337 int error;
338
339 if (uio->uio_resid != CHANGER_EVENT_SIZE)
340 return (EINVAL);
341
342 /*
343 * Read never blocks; if there are no events pending, we just
344 * return an all-clear bitmask.
345 */
346 error = uiomove(&sc->sc_events, CHANGER_EVENT_SIZE, uio);
347 if (error == 0)
348 sc->sc_events = 0;
349 return (error);
350 }
351
352 static int
chioctl(dev_t dev,u_long cmd,void * data,int flags,struct lwp * l)353 chioctl(dev_t dev, u_long cmd, void *data, int flags, struct lwp *l)
354 {
355 struct ch_softc *sc = device_lookup_private(&ch_cd, CHUNIT(dev));
356 int error = 0;
357
358 /*
359 * If this command can change the device's state, we must
360 * have the device open for writing.
361 */
362 switch (cmd) {
363 case CHIOGPICKER:
364 case CHIOGPARAMS:
365 case OCHIOGSTATUS:
366 break;
367
368 default:
369 if ((flags & FWRITE) == 0)
370 return (EBADF);
371 }
372
373 switch (cmd) {
374 case CHIOMOVE:
375 error = ch_move(sc, (struct changer_move_request *)data);
376 break;
377
378 case CHIOEXCHANGE:
379 error = ch_exchange(sc,
380 (struct changer_exchange_request *)data);
381 break;
382
383 case CHIOPOSITION:
384 error = ch_position(sc,
385 (struct changer_position_request *)data);
386 break;
387
388 case CHIOGPICKER:
389 *(int *)data = sc->sc_picker - sc->sc_firsts[CHET_MT];
390 break;
391
392 case CHIOSPICKER:
393 {
394 int new_picker = *(int *)data;
395
396 if (new_picker > (sc->sc_counts[CHET_MT] - 1))
397 return (EINVAL);
398 sc->sc_picker = sc->sc_firsts[CHET_MT] + new_picker;
399 break;
400 }
401
402 case CHIOGPARAMS:
403 {
404 struct changer_params *cp = (struct changer_params *)data;
405
406 cp->cp_curpicker = sc->sc_picker - sc->sc_firsts[CHET_MT];
407 cp->cp_npickers = sc->sc_counts[CHET_MT];
408 cp->cp_nslots = sc->sc_counts[CHET_ST];
409 cp->cp_nportals = sc->sc_counts[CHET_IE];
410 cp->cp_ndrives = sc->sc_counts[CHET_DT];
411 break;
412 }
413
414 case CHIOIELEM:
415 error = ch_ielem(sc);
416 if (error == 0) {
417 sc->sc_periph->periph_flags |= PERIPH_MEDIA_LOADED;
418 }
419 break;
420
421 case OCHIOGSTATUS:
422 {
423 struct ochanger_element_status_request *cesr =
424 (struct ochanger_element_status_request *)data;
425
426 error = ch_ousergetelemstatus(sc, cesr->cesr_type,
427 cesr->cesr_data);
428 break;
429 }
430
431 case CHIOGSTATUS:
432 error = ch_usergetelemstatus(sc,
433 (struct changer_element_status_request *)data);
434 break;
435
436 case CHIOSVOLTAG:
437 error = ch_setvoltag(sc,
438 (struct changer_set_voltag_request *)data);
439 break;
440
441 /* Implement prevent/allow? */
442
443 default:
444 error = scsipi_do_ioctl(sc->sc_periph, dev, cmd, data,
445 flags, l);
446 break;
447 }
448
449 return (error);
450 }
451
452 static int
chpoll(dev_t dev,int events,struct lwp * l)453 chpoll(dev_t dev, int events, struct lwp *l)
454 {
455 struct ch_softc *sc = device_lookup_private(&ch_cd, CHUNIT(dev));
456 int revents;
457
458 revents = events & (POLLOUT | POLLWRNORM);
459
460 if ((events & (POLLIN | POLLRDNORM)) == 0)
461 return (revents);
462
463 if (sc->sc_events == 0)
464 revents |= events & (POLLIN | POLLRDNORM);
465 else
466 selrecord(l, &sc->sc_selq);
467
468 return (revents);
469 }
470
471 static void
filt_chdetach(struct knote * kn)472 filt_chdetach(struct knote *kn)
473 {
474 struct ch_softc *sc = kn->kn_hook;
475
476 selremove_knote(&sc->sc_selq, kn);
477 }
478
479 static int
filt_chread(struct knote * kn,long hint)480 filt_chread(struct knote *kn, long hint)
481 {
482 struct ch_softc *sc = kn->kn_hook;
483
484 if (sc->sc_events == 0)
485 return (0);
486 kn->kn_data = CHANGER_EVENT_SIZE;
487 return (1);
488 }
489
490 static const struct filterops chread_filtops = {
491 .f_flags = FILTEROP_ISFD,
492 .f_attach = NULL,
493 .f_detach = filt_chdetach,
494 .f_event = filt_chread,
495 };
496
497 static int
chkqfilter(dev_t dev,struct knote * kn)498 chkqfilter(dev_t dev, struct knote *kn)
499 {
500 struct ch_softc *sc = device_lookup_private(&ch_cd, CHUNIT(dev));
501
502 switch (kn->kn_filter) {
503 case EVFILT_READ:
504 kn->kn_fop = &chread_filtops;
505 kn->kn_hook = sc;
506 selrecord_knote(&sc->sc_selq, kn);
507 break;
508
509 case EVFILT_WRITE:
510 kn->kn_fop = &seltrue_filtops;
511 break;
512
513 default:
514 return (EINVAL);
515 }
516
517 return (0);
518 }
519
520 static int
ch_interpret_sense(struct scsipi_xfer * xs)521 ch_interpret_sense(struct scsipi_xfer *xs)
522 {
523 struct scsipi_periph *periph = xs->xs_periph;
524 struct scsi_sense_data *sense = &xs->sense.scsi_sense;
525 struct ch_softc *sc = device_private(periph->periph_dev);
526 u_int16_t asc_ascq;
527
528 /*
529 * If the periph is already recovering, just do the
530 * normal error recovering.
531 */
532 if (periph->periph_flags & PERIPH_RECOVERING)
533 return (EJUSTRETURN);
534
535 /*
536 * If it isn't an extended or extended/deferred error, let
537 * the generic code handle it.
538 */
539 if (SSD_RCODE(sense->response_code) != SSD_RCODE_CURRENT &&
540 SSD_RCODE(sense->response_code) != SSD_RCODE_DEFERRED)
541 return (EJUSTRETURN);
542
543 /*
544 * We're only interested in condtions that
545 * indicate potential inventory violation.
546 *
547 * We use ASC/ASCQ codes for this.
548 */
549
550 asc_ascq = (((u_int16_t) sense->asc) << 8) |
551 sense->ascq;
552
553 switch (asc_ascq) {
554 case 0x2800:
555 /* "Not Ready To Ready Transition (Medium May Have Changed)" */
556 case 0x2900:
557 /* "Power On, Reset, or Bus Device Reset Occurred" */
558 sc->sc_periph->periph_flags &= ~PERIPH_MEDIA_LOADED;
559 /*
560 * Enqueue an Element-Status-Changed event, and wake up
561 * any processes waiting for them.
562 */
563 if ((xs->xs_control & XS_CTL_IGNORE_MEDIA_CHANGE) == 0)
564 ch_event(sc, CHEV_ELEMENT_STATUS_CHANGED);
565 break;
566 default:
567 break;
568 }
569
570 return (EJUSTRETURN);
571 }
572
573 static void
ch_event(struct ch_softc * sc,u_int event)574 ch_event(struct ch_softc *sc, u_int event)
575 {
576
577 sc->sc_events |= event;
578 selnotify(&sc->sc_selq, 0, 0);
579 }
580
581 static int
ch_move(struct ch_softc * sc,struct changer_move_request * cm)582 ch_move(struct ch_softc *sc, struct changer_move_request *cm)
583 {
584 struct scsi_move_medium cmd;
585 u_int16_t fromelem, toelem;
586
587 /*
588 * Check arguments.
589 */
590 if ((cm->cm_fromtype > CHET_DT) || (cm->cm_totype > CHET_DT))
591 return (EINVAL);
592 if ((cm->cm_fromunit > (sc->sc_counts[cm->cm_fromtype] - 1)) ||
593 (cm->cm_tounit > (sc->sc_counts[cm->cm_totype] - 1)))
594 return (ENODEV);
595
596 /*
597 * Check the request against the changer's capabilities.
598 */
599 if ((sc->sc_movemask[cm->cm_fromtype] & (1 << cm->cm_totype)) == 0)
600 return (ENODEV);
601
602 /*
603 * Calculate the source and destination elements.
604 */
605 fromelem = sc->sc_firsts[cm->cm_fromtype] + cm->cm_fromunit;
606 toelem = sc->sc_firsts[cm->cm_totype] + cm->cm_tounit;
607
608 /*
609 * Build the SCSI command.
610 */
611 memset(&cmd, 0, sizeof(cmd));
612 cmd.opcode = MOVE_MEDIUM;
613 _lto2b(sc->sc_picker, cmd.tea);
614 _lto2b(fromelem, cmd.src);
615 _lto2b(toelem, cmd.dst);
616 if (cm->cm_flags & CM_INVERT)
617 cmd.flags |= MOVE_MEDIUM_INVERT;
618
619 /*
620 * Send command to changer.
621 */
622 return (scsipi_command(sc->sc_periph, (void *)&cmd, sizeof(cmd), 0, 0,
623 CHRETRIES, CHTIMEOUT, NULL, 0));
624 }
625
626 static int
ch_exchange(struct ch_softc * sc,struct changer_exchange_request * ce)627 ch_exchange(struct ch_softc *sc, struct changer_exchange_request *ce)
628 {
629 struct scsi_exchange_medium cmd;
630 u_int16_t src, dst1, dst2;
631
632 /*
633 * Check arguments.
634 */
635 if ((ce->ce_srctype > CHET_DT) || (ce->ce_fdsttype > CHET_DT) ||
636 (ce->ce_sdsttype > CHET_DT))
637 return (EINVAL);
638 if ((ce->ce_srcunit > (sc->sc_counts[ce->ce_srctype] - 1)) ||
639 (ce->ce_fdstunit > (sc->sc_counts[ce->ce_fdsttype] - 1)) ||
640 (ce->ce_sdstunit > (sc->sc_counts[ce->ce_sdsttype] - 1)))
641 return (ENODEV);
642
643 /*
644 * Check the request against the changer's capabilities.
645 */
646 if (((sc->sc_exchangemask[ce->ce_srctype] &
647 (1 << ce->ce_fdsttype)) == 0) ||
648 ((sc->sc_exchangemask[ce->ce_fdsttype] &
649 (1 << ce->ce_sdsttype)) == 0))
650 return (ENODEV);
651
652 /*
653 * Calculate the source and destination elements.
654 */
655 src = sc->sc_firsts[ce->ce_srctype] + ce->ce_srcunit;
656 dst1 = sc->sc_firsts[ce->ce_fdsttype] + ce->ce_fdstunit;
657 dst2 = sc->sc_firsts[ce->ce_sdsttype] + ce->ce_sdstunit;
658
659 /*
660 * Build the SCSI command.
661 */
662 memset(&cmd, 0, sizeof(cmd));
663 cmd.opcode = EXCHANGE_MEDIUM;
664 _lto2b(sc->sc_picker, cmd.tea);
665 _lto2b(src, cmd.src);
666 _lto2b(dst1, cmd.fdst);
667 _lto2b(dst2, cmd.sdst);
668 if (ce->ce_flags & CE_INVERT1)
669 cmd.flags |= EXCHANGE_MEDIUM_INV1;
670 if (ce->ce_flags & CE_INVERT2)
671 cmd.flags |= EXCHANGE_MEDIUM_INV2;
672
673 /*
674 * Send command to changer.
675 */
676 return (scsipi_command(sc->sc_periph, (void *)&cmd, sizeof(cmd), 0, 0,
677 CHRETRIES, CHTIMEOUT, NULL, 0));
678 }
679
680 static int
ch_position(struct ch_softc * sc,struct changer_position_request * cp)681 ch_position(struct ch_softc *sc, struct changer_position_request *cp)
682 {
683 struct scsi_position_to_element cmd;
684 u_int16_t dst;
685
686 /*
687 * Check arguments.
688 */
689 if (cp->cp_type > CHET_DT)
690 return (EINVAL);
691 if (cp->cp_unit > (sc->sc_counts[cp->cp_type] - 1))
692 return (ENODEV);
693
694 /*
695 * Calculate the destination element.
696 */
697 dst = sc->sc_firsts[cp->cp_type] + cp->cp_unit;
698
699 /*
700 * Build the SCSI command.
701 */
702 memset(&cmd, 0, sizeof(cmd));
703 cmd.opcode = POSITION_TO_ELEMENT;
704 _lto2b(sc->sc_picker, cmd.tea);
705 _lto2b(dst, cmd.dst);
706 if (cp->cp_flags & CP_INVERT)
707 cmd.flags |= POSITION_TO_ELEMENT_INVERT;
708
709 /*
710 * Send command to changer.
711 */
712 return (scsipi_command(sc->sc_periph, (void *)&cmd, sizeof(cmd), 0, 0,
713 CHRETRIES, CHTIMEOUT, NULL, 0));
714 }
715
716 /*
717 * Perform a READ ELEMENT STATUS on behalf of the user, and return to
718 * the user only the data the user is interested in. This returns the
719 * old data format.
720 */
721 static int
ch_ousergetelemstatus(struct ch_softc * sc,int chet,u_int8_t * uptr)722 ch_ousergetelemstatus(struct ch_softc *sc, int chet, u_int8_t *uptr)
723 {
724 struct read_element_status_header *st_hdrp, st_hdr;
725 struct read_element_status_page_header *pg_hdrp;
726 struct read_element_status_descriptor *desc;
727 size_t size, desclen;
728 void *data;
729 int avail, i, error = 0;
730 u_int8_t user_data;
731
732 /*
733 * If there are no elements of the requested type in the changer,
734 * the request is invalid.
735 */
736 if (sc->sc_counts[chet] == 0)
737 return (EINVAL);
738
739 /*
740 * Do the request the user wants, but only read the status header.
741 * This will tell us the amount of storage we must allocate in
742 * order to read all data.
743 */
744 error = ch_getelemstatus(sc, sc->sc_firsts[chet],
745 sc->sc_counts[chet], &st_hdr, sizeof(st_hdr), 0, 0);
746 if (error)
747 return (error);
748
749 size = sizeof(struct read_element_status_header) +
750 _3btol(st_hdr.nbytes);
751
752 /*
753 * We must have at least room for the status header and
754 * one page header (since we only ask for one element type
755 * at a time).
756 */
757 if (size < (sizeof(struct read_element_status_header) +
758 sizeof(struct read_element_status_page_header)))
759 return (EIO);
760
761 /*
762 * Allocate the storage and do the request again.
763 */
764 data = malloc(size, M_DEVBUF, M_WAITOK);
765 error = ch_getelemstatus(sc, sc->sc_firsts[chet],
766 sc->sc_counts[chet], data, size, 0, 0);
767 if (error)
768 goto done;
769
770 st_hdrp = (struct read_element_status_header *)data;
771 pg_hdrp = (struct read_element_status_page_header *)((u_long)st_hdrp +
772 sizeof(struct read_element_status_header));
773 desclen = _2btol(pg_hdrp->edl);
774
775 /*
776 * Fill in the user status array.
777 */
778 avail = _2btol(st_hdrp->count);
779
780 if (avail != sc->sc_counts[chet])
781 printf("%s: warning, READ ELEMENT STATUS avail != count\n",
782 device_xname(sc->sc_dev));
783
784 desc = (struct read_element_status_descriptor *)((u_long)data +
785 sizeof(struct read_element_status_header) +
786 sizeof(struct read_element_status_page_header));
787 for (i = 0; i < avail; ++i) {
788 user_data = desc->flags1;
789 error = copyout(&user_data, &uptr[i], avail);
790 if (error)
791 break;
792 desc = (struct read_element_status_descriptor *)((u_long)desc
793 + desclen);
794 }
795
796 done:
797 if (data != NULL)
798 free(data, M_DEVBUF);
799 return (error);
800 }
801
802 /*
803 * Perform a READ ELEMENT STATUS on behalf of the user. This returns
804 * the new (more complete) data format.
805 */
806 static int
ch_usergetelemstatus(struct ch_softc * sc,struct changer_element_status_request * cesr)807 ch_usergetelemstatus(struct ch_softc *sc,
808 struct changer_element_status_request *cesr)
809 {
810 struct scsipi_channel *chan = sc->sc_periph->periph_channel;
811 struct scsipi_periph *dtperiph;
812 struct read_element_status_header *st_hdrp, st_hdr;
813 struct read_element_status_page_header *pg_hdrp;
814 struct read_element_status_descriptor *desc;
815 struct changer_volume_tag *avol, *pvol;
816 size_t size, desclen, stddesclen, offset;
817 int first, avail, i, error = 0;
818 void *data;
819 void *uvendptr;
820 struct changer_element_status ces;
821
822 /*
823 * Check arguments.
824 */
825 if (cesr->cesr_type > CHET_DT)
826 return (EINVAL);
827 if (sc->sc_counts[cesr->cesr_type] == 0)
828 return (ENODEV);
829 if (cesr->cesr_unit > (sc->sc_counts[cesr->cesr_type] - 1))
830 return (ENODEV);
831 if (cesr->cesr_count >
832 (sc->sc_counts[cesr->cesr_type] + cesr->cesr_unit))
833 return (EINVAL);
834
835 /*
836 * Do the request the user wants, but only read the status header.
837 * This will tell us the amount of storage we must allocate
838 * in order to read all the data.
839 */
840 error = ch_getelemstatus(sc, sc->sc_firsts[cesr->cesr_type] +
841 cesr->cesr_unit, cesr->cesr_count, &st_hdr, sizeof(st_hdr), 0,
842 cesr->cesr_flags);
843 if (error)
844 return (error);
845
846 size = sizeof(struct read_element_status_header) +
847 _3btol(st_hdr.nbytes);
848
849 /*
850 * We must have at least room for the status header and
851 * one page header (since we only ask for oen element type
852 * at a time).
853 */
854 if (size < (sizeof(struct read_element_status_header) +
855 sizeof(struct read_element_status_page_header)))
856 return (EIO);
857
858 /*
859 * Allocate the storage and do the request again.
860 */
861 data = malloc(size, M_DEVBUF, M_WAITOK);
862 error = ch_getelemstatus(sc, sc->sc_firsts[cesr->cesr_type] +
863 cesr->cesr_unit, cesr->cesr_count, data, size, 0,
864 cesr->cesr_flags);
865 if (error)
866 goto done;
867
868 st_hdrp = (struct read_element_status_header *)data;
869 pg_hdrp = (struct read_element_status_page_header *)((u_long)st_hdrp +
870 sizeof(struct read_element_status_header));
871 desclen = _2btol(pg_hdrp->edl);
872
873 /*
874 * Fill in the user status array.
875 */
876 first = _2btol(st_hdrp->fear);
877 if (first < (sc->sc_firsts[cesr->cesr_type] + cesr->cesr_unit) ||
878 first >= (sc->sc_firsts[cesr->cesr_type] + cesr->cesr_unit +
879 cesr->cesr_count)) {
880 error = EIO;
881 goto done;
882 }
883 first -= sc->sc_firsts[cesr->cesr_type] + cesr->cesr_unit;
884
885 avail = _2btol(st_hdrp->count);
886 if (avail <= 0 || avail > cesr->cesr_count) {
887 error = EIO;
888 goto done;
889 }
890
891 offset = sizeof(struct read_element_status_header) +
892 sizeof(struct read_element_status_page_header);
893
894 for (i = 0; i < cesr->cesr_count; i++) {
895 memset(&ces, 0, sizeof(ces));
896 if (i < first || i >= (first + avail)) {
897 error = copyout(&ces, &cesr->cesr_data[i],
898 sizeof(ces));
899 if (error)
900 goto done;
901 }
902
903 desc = (struct read_element_status_descriptor *)
904 ((char *)data + offset);
905 stddesclen = sizeof(struct read_element_status_descriptor);
906 offset += desclen;
907
908 ces.ces_flags = CESTATUS_STATUS_VALID;
909
910 /*
911 * The SCSI flags conveniently map directly to the
912 * chio API flags.
913 */
914 ces.ces_flags |= (desc->flags1 & 0x3f);
915
916 ces.ces_asc = desc->sense_code;
917 ces.ces_ascq = desc->sense_qual;
918
919 /*
920 * For Data Transport elemenets, get the SCSI ID and LUN,
921 * and attempt to map them to a device name if they're
922 * on the same SCSI bus.
923 */
924 if (desc->dt_scsi_flags & READ_ELEMENT_STATUS_DT_IDVALID) {
925 ces.ces_target = desc->dt_scsi_addr;
926 ces.ces_flags |= CESTATUS_TARGET_VALID;
927 }
928 if (desc->dt_scsi_flags & READ_ELEMENT_STATUS_DT_LUVALID) {
929 ces.ces_lun = desc->dt_scsi_flags &
930 READ_ELEMENT_STATUS_DT_LUNMASK;
931 ces.ces_flags |= CESTATUS_LUN_VALID;
932 }
933 if (desc->dt_scsi_flags & READ_ELEMENT_STATUS_DT_NOTBUS)
934 ces.ces_flags |= CESTATUS_NOTBUS;
935 else if ((ces.ces_flags &
936 (CESTATUS_TARGET_VALID|CESTATUS_LUN_VALID)) ==
937 (CESTATUS_TARGET_VALID|CESTATUS_LUN_VALID)) {
938 if (ces.ces_target < chan->chan_ntargets &&
939 ces.ces_lun < chan->chan_nluns &&
940 (dtperiph = scsipi_lookup_periph(chan,
941 ces.ces_target, ces.ces_lun)) != NULL &&
942 dtperiph->periph_dev != NULL) {
943 strlcpy(ces.ces_xname,
944 device_xname(dtperiph->periph_dev),
945 sizeof(ces.ces_xname));
946 ces.ces_flags |= CESTATUS_XNAME_VALID;
947 }
948 }
949
950 if (desc->flags2 & READ_ELEMENT_STATUS_INVERT)
951 ces.ces_flags |= CESTATUS_INVERTED;
952
953 if (desc->flags2 & READ_ELEMENT_STATUS_SVALID) {
954 if (ch_map_element(sc, _2btol(desc->ssea),
955 &ces.ces_from_type, &ces.ces_from_unit))
956 ces.ces_flags |= CESTATUS_FROM_VALID;
957 }
958
959 /*
960 * Extract volume tag information.
961 */
962 switch (pg_hdrp->flags &
963 (READ_ELEMENT_STATUS_PVOLTAG|READ_ELEMENT_STATUS_AVOLTAG)) {
964 case (READ_ELEMENT_STATUS_PVOLTAG|READ_ELEMENT_STATUS_AVOLTAG):
965 pvol = (struct changer_volume_tag *)(desc + 1);
966 avol = pvol + 1;
967 break;
968
969 case READ_ELEMENT_STATUS_PVOLTAG:
970 pvol = (struct changer_volume_tag *)(desc + 1);
971 avol = NULL;
972 break;
973
974 case READ_ELEMENT_STATUS_AVOLTAG:
975 pvol = NULL;
976 avol = (struct changer_volume_tag *)(desc + 1);
977 break;
978
979 default:
980 avol = pvol = NULL;
981 break;
982 }
983
984 if (pvol != NULL) {
985 ch_voltag_convert_in(pvol, &ces.ces_pvoltag);
986 ces.ces_flags |= CESTATUS_PVOL_VALID;
987 stddesclen += sizeof(struct changer_volume_tag);
988 }
989 if (avol != NULL) {
990 ch_voltag_convert_in(avol, &ces.ces_avoltag);
991 ces.ces_flags |= CESTATUS_AVOL_VALID;
992 stddesclen += sizeof(struct changer_volume_tag);
993 }
994
995 /*
996 * Compute vendor-specific length. Note the 4 reserved
997 * bytes between the volume tags and the vendor-specific
998 * data. Copy it out of the user wants it.
999 */
1000 stddesclen += 4;
1001 if (desclen > stddesclen)
1002 ces.ces_vendor_len = desclen - stddesclen;
1003
1004 if (ces.ces_vendor_len != 0 && cesr->cesr_vendor_data != NULL) {
1005 error = copyin(&cesr->cesr_vendor_data[i], &uvendptr,
1006 sizeof(uvendptr));
1007 if (error)
1008 goto done;
1009 error = copyout((void *)((u_long)desc + stddesclen),
1010 uvendptr, ces.ces_vendor_len);
1011 if (error)
1012 goto done;
1013 }
1014
1015 /*
1016 * Now copy out the status descriptor we've constructed.
1017 */
1018 error = copyout(&ces, &cesr->cesr_data[i], sizeof(ces));
1019 if (error)
1020 goto done;
1021 }
1022
1023 done:
1024 if (data != NULL)
1025 free(data, M_DEVBUF);
1026 return (error);
1027 }
1028
1029 static int
ch_getelemstatus(struct ch_softc * sc,int first,int count,void * data,size_t datalen,int scsiflags,int flags)1030 ch_getelemstatus(struct ch_softc *sc, int first, int count, void *data,
1031 size_t datalen, int scsiflags, int flags)
1032 {
1033 struct scsi_read_element_status cmd;
1034
1035 /*
1036 * Build SCSI command.
1037 */
1038 memset(&cmd, 0, sizeof(cmd));
1039 cmd.opcode = READ_ELEMENT_STATUS;
1040 cmd.byte2 = ELEMENT_TYPE_ALL;
1041 if (flags & CESR_VOLTAGS)
1042 cmd.byte2 |= READ_ELEMENT_STATUS_VOLTAG;
1043 _lto2b(first, cmd.sea);
1044 _lto2b(count, cmd.count);
1045 _lto3b(datalen, cmd.len);
1046
1047 /*
1048 * Send command to changer.
1049 */
1050 return (scsipi_command(sc->sc_periph, (void *)&cmd, sizeof(cmd),
1051 (void *)data, datalen,
1052 CHRETRIES, CHTIMEOUT, NULL, scsiflags | XS_CTL_DATA_IN));
1053 }
1054
1055 static int
ch_setvoltag(struct ch_softc * sc,struct changer_set_voltag_request * csvr)1056 ch_setvoltag(struct ch_softc *sc, struct changer_set_voltag_request *csvr)
1057 {
1058 struct scsi_send_volume_tag cmd;
1059 struct changer_volume_tag voltag;
1060 void *data = NULL;
1061 size_t datalen = 0;
1062 int error;
1063 u_int16_t dst;
1064
1065 /*
1066 * Check arguments.
1067 */
1068 if (csvr->csvr_type > CHET_DT)
1069 return (EINVAL);
1070 if (csvr->csvr_unit > (sc->sc_counts[csvr->csvr_type] - 1))
1071 return (ENODEV);
1072
1073 dst = sc->sc_firsts[csvr->csvr_type] + csvr->csvr_unit;
1074
1075 /*
1076 * Build the SCSI command.
1077 */
1078 memset(&cmd, 0, sizeof(cmd));
1079 cmd.opcode = SEND_VOLUME_TAG;
1080 _lto2b(dst, cmd.eaddr);
1081
1082 #define ALTERNATE (csvr->csvr_flags & CSVR_ALTERNATE)
1083
1084 switch (csvr->csvr_flags & CSVR_MODE_MASK) {
1085 case CSVR_MODE_SET:
1086 cmd.sac = ALTERNATE ? SAC_ASSERT_ALT : SAC_ASSERT_PRIMARY;
1087 break;
1088
1089 case CSVR_MODE_REPLACE:
1090 cmd.sac = ALTERNATE ? SAC_REPLACE_ALT : SAC_REPLACE_PRIMARY;
1091 break;
1092
1093 case CSVR_MODE_CLEAR:
1094 cmd.sac = ALTERNATE ? SAC_UNDEFINED_ALT : SAC_UNDEFINED_PRIMARY;
1095 break;
1096
1097 default:
1098 return (EINVAL);
1099 }
1100
1101 #undef ALTERNATE
1102
1103 if (cmd.sac < SAC_UNDEFINED_PRIMARY) {
1104 error = ch_voltag_convert_out(&csvr->csvr_voltag, &voltag);
1105 if (error)
1106 return (error);
1107 data = &voltag;
1108 datalen = sizeof(voltag);
1109 _lto2b(datalen, cmd.length);
1110 }
1111
1112 /*
1113 * Send command to changer.
1114 */
1115 return (scsipi_command(sc->sc_periph, (void *)&cmd, sizeof(cmd),
1116 (void *)data, datalen, CHRETRIES, CHTIMEOUT, NULL,
1117 datalen ? XS_CTL_DATA_OUT : 0));
1118 }
1119
1120 static int
ch_ielem(struct ch_softc * sc)1121 ch_ielem(struct ch_softc *sc)
1122 {
1123 int tmo;
1124 struct scsi_initialize_element_status cmd;
1125
1126 /*
1127 * Build SCSI command.
1128 */
1129 memset(&cmd, 0, sizeof(cmd));
1130 cmd.opcode = INITIALIZE_ELEMENT_STATUS;
1131
1132 /*
1133 * Send command to changer.
1134 *
1135 * The problem is, how long to allow for the command?
1136 * It can take a *really* long time, and also depends
1137 * on unknowable factors such as whether there are
1138 * *almost* readable labels on tapes that a barcode
1139 * reader is trying to decipher.
1140 *
1141 * I'm going to make this long enough to allow 5 minutes
1142 * per element plus an initial 10 minute wait.
1143 */
1144 tmo = sc->sc_counts[CHET_MT] +
1145 sc->sc_counts[CHET_ST] +
1146 sc->sc_counts[CHET_IE] +
1147 sc->sc_counts[CHET_DT];
1148 tmo *= 5 * 60 * 1000;
1149 tmo += (10 * 60 * 1000);
1150
1151 return (scsipi_command(sc->sc_periph, (void *)&cmd, sizeof(cmd), 0, 0,
1152 CHRETRIES, tmo, NULL, XS_CTL_IGNORE_ILLEGAL_REQUEST));
1153 }
1154
1155 /*
1156 * Ask the device about itself and fill in the parameters in our
1157 * softc.
1158 */
1159 static int
ch_get_params(struct ch_softc * sc,int scsiflags)1160 ch_get_params(struct ch_softc *sc, int scsiflags)
1161 {
1162 struct scsi_mode_sense_data {
1163 struct scsi_mode_parameter_header_6 header;
1164 union {
1165 struct page_element_address_assignment ea;
1166 struct page_transport_geometry_parameters tg;
1167 struct page_device_capabilities cap;
1168 } pages;
1169 } sense_data;
1170 int error, from;
1171 u_int8_t *moves, *exchanges;
1172
1173 /*
1174 * Grab info from the element address assignment page.
1175 */
1176 memset(&sense_data, 0, sizeof(sense_data));
1177 error = scsipi_mode_sense(sc->sc_periph, SMS_DBD, 0x1d,
1178 &sense_data.header, sizeof(sense_data),
1179 scsiflags, CHRETRIES, 6000);
1180 if (error) {
1181 aprint_error_dev(sc->sc_dev, "could not sense element address page\n");
1182 return (error);
1183 }
1184
1185 sc->sc_firsts[CHET_MT] = _2btol(sense_data.pages.ea.mtea);
1186 sc->sc_counts[CHET_MT] = _2btol(sense_data.pages.ea.nmte);
1187 sc->sc_firsts[CHET_ST] = _2btol(sense_data.pages.ea.fsea);
1188 sc->sc_counts[CHET_ST] = _2btol(sense_data.pages.ea.nse);
1189 sc->sc_firsts[CHET_IE] = _2btol(sense_data.pages.ea.fieea);
1190 sc->sc_counts[CHET_IE] = _2btol(sense_data.pages.ea.niee);
1191 sc->sc_firsts[CHET_DT] = _2btol(sense_data.pages.ea.fdtea);
1192 sc->sc_counts[CHET_DT] = _2btol(sense_data.pages.ea.ndte);
1193
1194 /* XXX ask for transport geometry page XXX */
1195
1196 /*
1197 * Grab info from the capabilities page.
1198 */
1199 memset(&sense_data, 0, sizeof(sense_data));
1200 /*
1201 * XXX: Note: not all changers can deal with disabled block descriptors
1202 */
1203 error = scsipi_mode_sense(sc->sc_periph, SMS_DBD, 0x1f,
1204 &sense_data.header, sizeof(sense_data),
1205 scsiflags, CHRETRIES, 6000);
1206 if (error) {
1207 aprint_error_dev(sc->sc_dev, "could not sense capabilities page\n");
1208 return (error);
1209 }
1210
1211 memset(sc->sc_movemask, 0, sizeof(sc->sc_movemask));
1212 memset(sc->sc_exchangemask, 0, sizeof(sc->sc_exchangemask));
1213 moves = &sense_data.pages.cap.move_from_mt;
1214 exchanges = &sense_data.pages.cap.exchange_with_mt;
1215 for (from = CHET_MT; from <= CHET_DT; ++from) {
1216 sc->sc_movemask[from] = moves[from];
1217 sc->sc_exchangemask[from] = exchanges[from];
1218 }
1219
1220 #ifdef CH_AUTOMATIC_IELEM_POLICY
1221 /*
1222 * If we need to do an Init-Element-Status,
1223 * do that now that we know what's in the changer.
1224 */
1225 if ((scsiflags & XS_CTL_IGNORE_MEDIA_CHANGE) == 0) {
1226 if ((sc->sc_periph->periph_flags & PERIPH_MEDIA_LOADED) == 0)
1227 error = ch_ielem(sc);
1228 if (error == 0)
1229 sc->sc_periph->periph_flags |= PERIPH_MEDIA_LOADED;
1230 else
1231 sc->sc_periph->periph_flags &= ~PERIPH_MEDIA_LOADED;
1232 }
1233 #endif
1234 return (error);
1235 }
1236
1237 static void
ch_get_quirks(struct ch_softc * sc,struct scsipi_inquiry_pattern * inqbuf)1238 ch_get_quirks(struct ch_softc *sc, struct scsipi_inquiry_pattern *inqbuf)
1239 {
1240 const struct chquirk *match;
1241 int priority;
1242
1243 sc->sc_settledelay = 0;
1244
1245 match = scsipi_inqmatch(inqbuf, chquirks,
1246 sizeof(chquirks) / sizeof(chquirks[0]),
1247 sizeof(chquirks[0]), &priority);
1248 if (priority != 0)
1249 sc->sc_settledelay = match->cq_settledelay;
1250 }
1251
1252 static int
ch_map_element(struct ch_softc * sc,u_int16_t elem,int * typep,int * unitp)1253 ch_map_element(struct ch_softc *sc, u_int16_t elem, int *typep, int *unitp)
1254 {
1255 int chet;
1256
1257 for (chet = CHET_MT; chet <= CHET_DT; chet++) {
1258 if (elem >= sc->sc_firsts[chet] &&
1259 elem < (sc->sc_firsts[chet] + sc->sc_counts[chet])) {
1260 *typep = chet;
1261 *unitp = elem - sc->sc_firsts[chet];
1262 return (1);
1263 }
1264 }
1265 return (0);
1266 }
1267
1268 static void
ch_voltag_convert_in(const struct changer_volume_tag * sv,struct changer_voltag * cv)1269 ch_voltag_convert_in(const struct changer_volume_tag *sv,
1270 struct changer_voltag *cv)
1271 {
1272 int i;
1273
1274 memset(cv, 0, sizeof(struct changer_voltag));
1275
1276 /*
1277 * Copy the volume tag string from the SCSI representation.
1278 * Per the SCSI-2 spec, we stop at the first blank character.
1279 */
1280 for (i = 0; i < sizeof(sv->volid); i++) {
1281 if (sv->volid[i] == ' ')
1282 break;
1283 cv->cv_tag[i] = sv->volid[i];
1284 }
1285 cv->cv_tag[i] = '\0';
1286
1287 cv->cv_serial = _2btol(sv->volseq);
1288 }
1289
1290 static int
ch_voltag_convert_out(const struct changer_voltag * cv,struct changer_volume_tag * sv)1291 ch_voltag_convert_out(const struct changer_voltag *cv,
1292 struct changer_volume_tag *sv)
1293 {
1294 int i;
1295
1296 memset(sv, ' ', sizeof(struct changer_volume_tag));
1297
1298 for (i = 0; i < sizeof(sv->volid); i++) {
1299 if (cv->cv_tag[i] == '\0')
1300 break;
1301 /*
1302 * Limit the character set to what is suggested in
1303 * the SCSI-2 spec.
1304 */
1305 if ((cv->cv_tag[i] < '0' || cv->cv_tag[i] > '9') &&
1306 (cv->cv_tag[i] < 'A' || cv->cv_tag[i] > 'Z') &&
1307 (cv->cv_tag[i] != '_'))
1308 return (EINVAL);
1309 sv->volid[i] = cv->cv_tag[i];
1310 }
1311
1312 _lto2b(cv->cv_serial, sv->volseq);
1313
1314 return (0);
1315 }
1316