1 /* $NetBSD: ch.c,v 1.80 2008/04/05 15:47:00 cegger 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 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 #include <sys/cdefs.h> 41 __KERNEL_RCSID(0, "$NetBSD: ch.c,v 1.80 2008/04/05 15:47:00 cegger Exp $"); 42 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/kernel.h> 46 #include <sys/errno.h> 47 #include <sys/ioctl.h> 48 #include <sys/buf.h> 49 #include <sys/proc.h> 50 #include <sys/user.h> 51 #include <sys/chio.h> 52 #include <sys/device.h> 53 #include <sys/malloc.h> 54 #include <sys/conf.h> 55 #include <sys/fcntl.h> 56 #include <sys/vnode.h> 57 #include <sys/time.h> 58 #include <sys/select.h> 59 #include <sys/poll.h> 60 61 #include <dev/scsipi/scsipi_all.h> 62 #include <dev/scsipi/scsi_all.h> 63 #include <dev/scsipi/scsi_changer.h> 64 #include <dev/scsipi/scsiconf.h> 65 66 #define CHRETRIES 2 67 #define CHUNIT(x) (minor((x))) 68 69 struct ch_softc { 70 struct device sc_dev; /* generic device info */ 71 struct scsipi_periph *sc_periph;/* our periph data */ 72 73 u_int sc_events; /* event bitmask */ 74 struct selinfo sc_selq; /* select/poll queue for events */ 75 76 int sc_flags; /* misc. info */ 77 78 int sc_picker; /* current picker */ 79 80 /* 81 * The following information is obtained from the 82 * element address assignment page. 83 */ 84 int sc_firsts[4]; /* firsts, indexed by CHET_* */ 85 int sc_counts[4]; /* counts, indexed by CHET_* */ 86 87 /* 88 * The following mask defines the legal combinations 89 * of elements for the MOVE MEDIUM command. 90 */ 91 u_int8_t sc_movemask[4]; 92 93 /* 94 * As above, but for EXCHANGE MEDIUM. 95 */ 96 u_int8_t sc_exchangemask[4]; 97 98 /* 99 * Quirks; see below. 100 */ 101 int sc_settledelay; /* delay for settle */ 102 103 }; 104 105 /* sc_flags */ 106 #define CHF_ROTATE 0x01 /* picker can rotate */ 107 108 /* Autoconfiguration glue */ 109 static int chmatch(struct device *, struct cfdata *, void *); 110 static void chattach(struct device *, struct device *, void *); 111 112 CFATTACH_DECL(ch, sizeof(struct ch_softc), 113 chmatch, chattach, NULL, NULL); 114 115 extern struct cfdriver ch_cd; 116 117 static struct scsipi_inquiry_pattern ch_patterns[] = { 118 {T_CHANGER, T_REMOV, 119 "", "", ""}, 120 }; 121 122 static dev_type_open(chopen); 123 static dev_type_close(chclose); 124 static dev_type_read(chread); 125 static dev_type_ioctl(chioctl); 126 static dev_type_poll(chpoll); 127 static dev_type_kqfilter(chkqfilter); 128 129 const struct cdevsw ch_cdevsw = { 130 chopen, chclose, chread, nowrite, chioctl, 131 nostop, notty, chpoll, nommap, chkqfilter, D_OTHER 132 }; 133 134 /* SCSI glue */ 135 static int ch_interpret_sense(struct scsipi_xfer *); 136 137 static const struct scsipi_periphsw ch_switch = { 138 ch_interpret_sense, /* check our error handler first */ 139 NULL, /* no queue; our commands are synchronous */ 140 NULL, /* have no async handler */ 141 NULL, /* nothing to be done when xfer is done */ 142 }; 143 144 static int ch_move(struct ch_softc *, struct changer_move_request *); 145 static int ch_exchange(struct ch_softc *, 146 struct changer_exchange_request *); 147 static int ch_position(struct ch_softc *, 148 struct changer_position_request *); 149 static int ch_ielem(struct ch_softc *); 150 static int ch_ousergetelemstatus(struct ch_softc *, int, u_int8_t *); 151 static int ch_usergetelemstatus(struct ch_softc *, 152 struct changer_element_status_request *); 153 static int ch_getelemstatus(struct ch_softc *, int, int, void *, 154 size_t, int, int); 155 static int ch_setvoltag(struct ch_softc *, 156 struct changer_set_voltag_request *); 157 static int ch_get_params(struct ch_softc *, int); 158 static void ch_get_quirks(struct ch_softc *, 159 struct scsipi_inquiry_pattern *); 160 static void ch_event(struct ch_softc *, u_int); 161 static int ch_map_element(struct ch_softc *, u_int16_t, int *, int *); 162 163 static void ch_voltag_convert_in(const struct changer_volume_tag *, 164 struct changer_voltag *); 165 static int ch_voltag_convert_out(const struct changer_voltag *, 166 struct changer_volume_tag *); 167 168 /* 169 * SCSI changer quirks. 170 */ 171 struct chquirk { 172 struct scsipi_inquiry_pattern cq_match; /* device id pattern */ 173 int cq_settledelay; /* settle delay, in seconds */ 174 }; 175 176 static const struct chquirk chquirks[] = { 177 {{T_CHANGER, T_REMOV, 178 "SPECTRA", "9000", "0200"}, 179 75}, 180 }; 181 182 static int 183 chmatch(struct device *parent, struct cfdata *match, 184 void *aux) 185 { 186 struct scsipibus_attach_args *sa = aux; 187 int priority; 188 189 (void)scsipi_inqmatch(&sa->sa_inqbuf, 190 (void *)ch_patterns, sizeof(ch_patterns) / sizeof(ch_patterns[0]), 191 sizeof(ch_patterns[0]), &priority); 192 193 return (priority); 194 } 195 196 static void 197 chattach(struct device *parent, struct device *self, void *aux) 198 { 199 struct ch_softc *sc = device_private(self); 200 struct scsipibus_attach_args *sa = aux; 201 struct scsipi_periph *periph = sa->sa_periph; 202 203 selinit(&sc->sc_selq); 204 205 /* Glue into the SCSI bus */ 206 sc->sc_periph = periph; 207 periph->periph_dev = &sc->sc_dev; 208 periph->periph_switch = &ch_switch; 209 210 printf("\n"); 211 212 /* 213 * Find out our device's quirks. 214 */ 215 ch_get_quirks(sc, &sa->sa_inqbuf); 216 217 /* 218 * Some changers require a long time to settle out, to do 219 * tape inventory, for instance. 220 */ 221 if (sc->sc_settledelay) { 222 printf("%s: waiting %d seconds for changer to settle...\n", 223 device_xname(&sc->sc_dev), sc->sc_settledelay); 224 delay(1000000 * sc->sc_settledelay); 225 } 226 227 /* 228 * Get information about the device. Note we can't use 229 * interrupts yet. 230 */ 231 if (ch_get_params(sc, XS_CTL_DISCOVERY|XS_CTL_IGNORE_MEDIA_CHANGE)) 232 printf("%s: offline\n", device_xname(&sc->sc_dev)); 233 else { 234 #define PLURAL(c) (c) == 1 ? "" : "s" 235 printf("%s: %d slot%s, %d drive%s, %d picker%s, %d portal%s\n", 236 device_xname(&sc->sc_dev), 237 sc->sc_counts[CHET_ST], PLURAL(sc->sc_counts[CHET_ST]), 238 sc->sc_counts[CHET_DT], PLURAL(sc->sc_counts[CHET_DT]), 239 sc->sc_counts[CHET_MT], PLURAL(sc->sc_counts[CHET_MT]), 240 sc->sc_counts[CHET_IE], PLURAL(sc->sc_counts[CHET_IE])); 241 #undef PLURAL 242 #ifdef CHANGER_DEBUG 243 printf("%s: move mask: 0x%x 0x%x 0x%x 0x%x\n", 244 device_xname(&sc->sc_dev), 245 sc->sc_movemask[CHET_MT], sc->sc_movemask[CHET_ST], 246 sc->sc_movemask[CHET_IE], sc->sc_movemask[CHET_DT]); 247 printf("%s: exchange mask: 0x%x 0x%x 0x%x 0x%x\n", 248 device_xname(&sc->sc_dev), 249 sc->sc_exchangemask[CHET_MT], sc->sc_exchangemask[CHET_ST], 250 sc->sc_exchangemask[CHET_IE], sc->sc_exchangemask[CHET_DT]); 251 #endif /* CHANGER_DEBUG */ 252 } 253 254 /* Default the current picker. */ 255 sc->sc_picker = sc->sc_firsts[CHET_MT]; 256 } 257 258 static int 259 chopen(dev_t dev, int flags, int fmt, struct lwp *l) 260 { 261 struct ch_softc *sc; 262 struct scsipi_periph *periph; 263 struct scsipi_adapter *adapt; 264 int unit, error; 265 266 unit = CHUNIT(dev); 267 if ((unit >= ch_cd.cd_ndevs) || 268 ((sc = ch_cd.cd_devs[unit]) == NULL)) 269 return (ENXIO); 270 271 periph = sc->sc_periph; 272 adapt = periph->periph_channel->chan_adapter; 273 274 /* 275 * Only allow one open at a time. 276 */ 277 if (periph->periph_flags & PERIPH_OPEN) 278 return (EBUSY); 279 280 if ((error = scsipi_adapter_addref(adapt)) != 0) 281 return (error); 282 283 /* 284 * Make sure the unit is on-line. If a UNIT ATTENTION 285 * occurs, we will mark that an Init-Element-Status is 286 * needed in ch_get_params(). 287 * 288 * We ignore NOT READY in case e.g a magazine isn't actually 289 * loaded into the changer or a tape isn't in the drive. 290 */ 291 error = scsipi_test_unit_ready(periph, XS_CTL_IGNORE_NOT_READY); 292 if (error) 293 goto bad; 294 295 periph->periph_flags |= PERIPH_OPEN; 296 297 /* 298 * Make sure our parameters are up to date. 299 */ 300 if ((error = ch_get_params(sc, 0)) != 0) 301 goto bad; 302 303 return (0); 304 305 bad: 306 scsipi_adapter_delref(adapt); 307 periph->periph_flags &= ~PERIPH_OPEN; 308 return (error); 309 } 310 311 static int 312 chclose(dev_t dev, int flags, int fmt, struct lwp *l) 313 { 314 struct ch_softc *sc = ch_cd.cd_devs[CHUNIT(dev)]; 315 struct scsipi_periph *periph = sc->sc_periph; 316 struct scsipi_adapter *adapt = periph->periph_channel->chan_adapter; 317 318 scsipi_wait_drain(periph); 319 320 scsipi_adapter_delref(adapt); 321 322 sc->sc_events = 0; 323 324 periph->periph_flags &= ~PERIPH_OPEN; 325 return (0); 326 } 327 328 static int 329 chread(dev_t dev, struct uio *uio, int flags) 330 { 331 struct ch_softc *sc = ch_cd.cd_devs[CHUNIT(dev)]; 332 int error; 333 334 if (uio->uio_resid != CHANGER_EVENT_SIZE) 335 return (EINVAL); 336 337 /* 338 * Read never blocks; if there are no events pending, we just 339 * return an all-clear bitmask. 340 */ 341 error = uiomove(&sc->sc_events, CHANGER_EVENT_SIZE, uio); 342 if (error == 0) 343 sc->sc_events = 0; 344 return (error); 345 } 346 347 static int 348 chioctl(dev_t dev, u_long cmd, void *data, int flags, struct lwp *l) 349 { 350 struct ch_softc *sc = ch_cd.cd_devs[CHUNIT(dev)]; 351 int error = 0; 352 353 /* 354 * If this command can change the device's state, we must 355 * have the device open for writing. 356 */ 357 switch (cmd) { 358 case CHIOGPICKER: 359 case CHIOGPARAMS: 360 case OCHIOGSTATUS: 361 break; 362 363 default: 364 if ((flags & FWRITE) == 0) 365 return (EBADF); 366 } 367 368 switch (cmd) { 369 case CHIOMOVE: 370 error = ch_move(sc, (struct changer_move_request *)data); 371 break; 372 373 case CHIOEXCHANGE: 374 error = ch_exchange(sc, 375 (struct changer_exchange_request *)data); 376 break; 377 378 case CHIOPOSITION: 379 error = ch_position(sc, 380 (struct changer_position_request *)data); 381 break; 382 383 case CHIOGPICKER: 384 *(int *)data = sc->sc_picker - sc->sc_firsts[CHET_MT]; 385 break; 386 387 case CHIOSPICKER: 388 { 389 int new_picker = *(int *)data; 390 391 if (new_picker > (sc->sc_counts[CHET_MT] - 1)) 392 return (EINVAL); 393 sc->sc_picker = sc->sc_firsts[CHET_MT] + new_picker; 394 break; 395 } 396 397 case CHIOGPARAMS: 398 { 399 struct changer_params *cp = (struct changer_params *)data; 400 401 cp->cp_curpicker = sc->sc_picker - sc->sc_firsts[CHET_MT]; 402 cp->cp_npickers = sc->sc_counts[CHET_MT]; 403 cp->cp_nslots = sc->sc_counts[CHET_ST]; 404 cp->cp_nportals = sc->sc_counts[CHET_IE]; 405 cp->cp_ndrives = sc->sc_counts[CHET_DT]; 406 break; 407 } 408 409 case CHIOIELEM: 410 error = ch_ielem(sc); 411 if (error == 0) { 412 sc->sc_periph->periph_flags |= PERIPH_MEDIA_LOADED; 413 } 414 break; 415 416 case OCHIOGSTATUS: 417 { 418 struct ochanger_element_status_request *cesr = 419 (struct ochanger_element_status_request *)data; 420 421 error = ch_ousergetelemstatus(sc, cesr->cesr_type, 422 cesr->cesr_data); 423 break; 424 } 425 426 case CHIOGSTATUS: 427 error = ch_usergetelemstatus(sc, 428 (struct changer_element_status_request *)data); 429 break; 430 431 case CHIOSVOLTAG: 432 error = ch_setvoltag(sc, 433 (struct changer_set_voltag_request *)data); 434 break; 435 436 /* Implement prevent/allow? */ 437 438 default: 439 error = scsipi_do_ioctl(sc->sc_periph, dev, cmd, data, 440 flags, l); 441 break; 442 } 443 444 return (error); 445 } 446 447 static int 448 chpoll(dev_t dev, int events, struct lwp *l) 449 { 450 struct ch_softc *sc = ch_cd.cd_devs[CHUNIT(dev)]; 451 int revents; 452 453 revents = events & (POLLOUT | POLLWRNORM); 454 455 if ((events & (POLLIN | POLLRDNORM)) == 0) 456 return (revents); 457 458 if (sc->sc_events == 0) 459 revents |= events & (POLLIN | POLLRDNORM); 460 else 461 selrecord(l, &sc->sc_selq); 462 463 return (revents); 464 } 465 466 static void 467 filt_chdetach(struct knote *kn) 468 { 469 struct ch_softc *sc = kn->kn_hook; 470 471 SLIST_REMOVE(&sc->sc_selq.sel_klist, kn, knote, kn_selnext); 472 } 473 474 static int 475 filt_chread(struct knote *kn, long hint) 476 { 477 struct ch_softc *sc = kn->kn_hook; 478 479 if (sc->sc_events == 0) 480 return (0); 481 kn->kn_data = CHANGER_EVENT_SIZE; 482 return (1); 483 } 484 485 static const struct filterops chread_filtops = 486 { 1, NULL, filt_chdetach, filt_chread }; 487 488 static const struct filterops chwrite_filtops = 489 { 1, NULL, filt_chdetach, filt_seltrue }; 490 491 static int 492 chkqfilter(dev_t dev, struct knote *kn) 493 { 494 struct ch_softc *sc = ch_cd.cd_devs[CHUNIT(dev)]; 495 struct klist *klist; 496 497 switch (kn->kn_filter) { 498 case EVFILT_READ: 499 klist = &sc->sc_selq.sel_klist; 500 kn->kn_fop = &chread_filtops; 501 break; 502 503 case EVFILT_WRITE: 504 klist = &sc->sc_selq.sel_klist; 505 kn->kn_fop = &chwrite_filtops; 506 break; 507 508 default: 509 return (EINVAL); 510 } 511 512 kn->kn_hook = sc; 513 514 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 515 516 return (0); 517 } 518 519 static int 520 ch_interpret_sense(struct scsipi_xfer *xs) 521 { 522 struct scsipi_periph *periph = xs->xs_periph; 523 struct scsi_sense_data *sense = &xs->sense.scsi_sense; 524 struct ch_softc *sc = (void *)periph->periph_dev; 525 u_int16_t asc_ascq; 526 527 /* 528 * If the periph is already recovering, just do the 529 * normal error recovering. 530 */ 531 if (periph->periph_flags & PERIPH_RECOVERING) 532 return (EJUSTRETURN); 533 534 /* 535 * If it isn't an extended or extended/deferred error, let 536 * the generic code handle it. 537 */ 538 if (SSD_RCODE(sense->response_code) != SSD_RCODE_CURRENT && 539 SSD_RCODE(sense->response_code) != SSD_RCODE_DEFERRED) 540 return (EJUSTRETURN); 541 542 /* 543 * We're only interested in condtions that 544 * indicate potential inventory violation. 545 * 546 * We use ASC/ASCQ codes for this. 547 */ 548 549 asc_ascq = (((u_int16_t) sense->asc) << 8) | 550 sense->ascq; 551 552 switch (asc_ascq) { 553 case 0x2800: 554 /* "Not Ready To Ready Transition (Medium May Have Changed)" */ 555 case 0x2900: 556 /* "Power On, Reset, or Bus Device Reset Occurred" */ 557 sc->sc_periph->periph_flags &= ~PERIPH_MEDIA_LOADED; 558 /* 559 * Enqueue an Element-Status-Changed event, and wake up 560 * any processes waiting for them. 561 */ 562 if ((xs->xs_control & XS_CTL_IGNORE_MEDIA_CHANGE) == 0) 563 ch_event(sc, CHEV_ELEMENT_STATUS_CHANGED); 564 break; 565 default: 566 break; 567 } 568 569 return (EJUSTRETURN); 570 } 571 572 static void 573 ch_event(struct ch_softc *sc, u_int event) 574 { 575 576 sc->sc_events |= event; 577 selnotify(&sc->sc_selq, 0, 0); 578 } 579 580 static int 581 ch_move(struct ch_softc *sc, struct changer_move_request *cm) 582 { 583 struct scsi_move_medium cmd; 584 u_int16_t fromelem, toelem; 585 586 /* 587 * Check arguments. 588 */ 589 if ((cm->cm_fromtype > CHET_DT) || (cm->cm_totype > CHET_DT)) 590 return (EINVAL); 591 if ((cm->cm_fromunit > (sc->sc_counts[cm->cm_fromtype] - 1)) || 592 (cm->cm_tounit > (sc->sc_counts[cm->cm_totype] - 1))) 593 return (ENODEV); 594 595 /* 596 * Check the request against the changer's capabilities. 597 */ 598 if ((sc->sc_movemask[cm->cm_fromtype] & (1 << cm->cm_totype)) == 0) 599 return (ENODEV); 600 601 /* 602 * Calculate the source and destination elements. 603 */ 604 fromelem = sc->sc_firsts[cm->cm_fromtype] + cm->cm_fromunit; 605 toelem = sc->sc_firsts[cm->cm_totype] + cm->cm_tounit; 606 607 /* 608 * Build the SCSI command. 609 */ 610 memset(&cmd, 0, sizeof(cmd)); 611 cmd.opcode = MOVE_MEDIUM; 612 _lto2b(sc->sc_picker, cmd.tea); 613 _lto2b(fromelem, cmd.src); 614 _lto2b(toelem, cmd.dst); 615 if (cm->cm_flags & CM_INVERT) 616 cmd.flags |= MOVE_MEDIUM_INVERT; 617 618 /* 619 * Send command to changer. 620 */ 621 return (scsipi_command(sc->sc_periph, (void *)&cmd, sizeof(cmd), 0, 0, 622 CHRETRIES, 100000, NULL, 0)); 623 } 624 625 static int 626 ch_exchange(struct ch_softc *sc, struct changer_exchange_request *ce) 627 { 628 struct scsi_exchange_medium cmd; 629 u_int16_t src, dst1, dst2; 630 631 /* 632 * Check arguments. 633 */ 634 if ((ce->ce_srctype > CHET_DT) || (ce->ce_fdsttype > CHET_DT) || 635 (ce->ce_sdsttype > CHET_DT)) 636 return (EINVAL); 637 if ((ce->ce_srcunit > (sc->sc_counts[ce->ce_srctype] - 1)) || 638 (ce->ce_fdstunit > (sc->sc_counts[ce->ce_fdsttype] - 1)) || 639 (ce->ce_sdstunit > (sc->sc_counts[ce->ce_sdsttype] - 1))) 640 return (ENODEV); 641 642 /* 643 * Check the request against the changer's capabilities. 644 */ 645 if (((sc->sc_exchangemask[ce->ce_srctype] & 646 (1 << ce->ce_fdsttype)) == 0) || 647 ((sc->sc_exchangemask[ce->ce_fdsttype] & 648 (1 << ce->ce_sdsttype)) == 0)) 649 return (ENODEV); 650 651 /* 652 * Calculate the source and destination elements. 653 */ 654 src = sc->sc_firsts[ce->ce_srctype] + ce->ce_srcunit; 655 dst1 = sc->sc_firsts[ce->ce_fdsttype] + ce->ce_fdstunit; 656 dst2 = sc->sc_firsts[ce->ce_sdsttype] + ce->ce_sdstunit; 657 658 /* 659 * Build the SCSI command. 660 */ 661 memset(&cmd, 0, sizeof(cmd)); 662 cmd.opcode = EXCHANGE_MEDIUM; 663 _lto2b(sc->sc_picker, cmd.tea); 664 _lto2b(src, cmd.src); 665 _lto2b(dst1, cmd.fdst); 666 _lto2b(dst2, cmd.sdst); 667 if (ce->ce_flags & CE_INVERT1) 668 cmd.flags |= EXCHANGE_MEDIUM_INV1; 669 if (ce->ce_flags & CE_INVERT2) 670 cmd.flags |= EXCHANGE_MEDIUM_INV2; 671 672 /* 673 * Send command to changer. 674 */ 675 return (scsipi_command(sc->sc_periph, (void *)&cmd, sizeof(cmd), 0, 0, 676 CHRETRIES, 100000, NULL, 0)); 677 } 678 679 static int 680 ch_position(struct ch_softc *sc, struct changer_position_request *cp) 681 { 682 struct scsi_position_to_element cmd; 683 u_int16_t dst; 684 685 /* 686 * Check arguments. 687 */ 688 if (cp->cp_type > CHET_DT) 689 return (EINVAL); 690 if (cp->cp_unit > (sc->sc_counts[cp->cp_type] - 1)) 691 return (ENODEV); 692 693 /* 694 * Calculate the destination element. 695 */ 696 dst = sc->sc_firsts[cp->cp_type] + cp->cp_unit; 697 698 /* 699 * Build the SCSI command. 700 */ 701 memset(&cmd, 0, sizeof(cmd)); 702 cmd.opcode = POSITION_TO_ELEMENT; 703 _lto2b(sc->sc_picker, cmd.tea); 704 _lto2b(dst, cmd.dst); 705 if (cp->cp_flags & CP_INVERT) 706 cmd.flags |= POSITION_TO_ELEMENT_INVERT; 707 708 /* 709 * Send command to changer. 710 */ 711 return (scsipi_command(sc->sc_periph, (void *)&cmd, sizeof(cmd), 0, 0, 712 CHRETRIES, 100000, NULL, 0)); 713 } 714 715 /* 716 * Perform a READ ELEMENT STATUS on behalf of the user, and return to 717 * the user only the data the user is interested in. This returns the 718 * old data format. 719 */ 720 static int 721 ch_ousergetelemstatus(struct ch_softc *sc, int chet, u_int8_t *uptr) 722 { 723 struct read_element_status_header *st_hdrp, st_hdr; 724 struct read_element_status_page_header *pg_hdrp; 725 struct read_element_status_descriptor *desc; 726 size_t size, desclen; 727 void *data; 728 int avail, i, error = 0; 729 u_int8_t user_data; 730 731 /* 732 * If there are no elements of the requested type in the changer, 733 * the request is invalid. 734 */ 735 if (sc->sc_counts[chet] == 0) 736 return (EINVAL); 737 738 /* 739 * Do the request the user wants, but only read the status header. 740 * This will tell us the amount of storage we must allocate in 741 * order to read all data. 742 */ 743 error = ch_getelemstatus(sc, sc->sc_firsts[chet], 744 sc->sc_counts[chet], &st_hdr, sizeof(st_hdr), 745 XS_CTL_DATA_ONSTACK, 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 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 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, 100000, NULL, scsiflags | XS_CTL_DATA_IN)); 1053 } 1054 1055 static int 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, 100000, NULL, 1117 datalen ? XS_CTL_DATA_OUT | XS_CTL_DATA_ONSTACK : 0)); 1118 } 1119 1120 static int 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 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 | XS_CTL_DATA_ONSTACK, 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 | XS_CTL_DATA_ONSTACK, 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 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 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 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 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