1 /* 2 * Copyright (c) 1991 University of Utah. 3 * Copyright (c) 1990, 1993 4 * The Regents of the University of California. All rights reserved. 5 * 6 * This code is derived from software contributed to Berkeley by 7 * the Systems Programming Group of the University of Utah Computer 8 * Science Department. 9 * 10 * %sccs.include.redist.c% 11 * 12 * from: Utah $Hdr: ac.c 1.5 92/01/21$ 13 * 14 * @(#)ac.c 8.1 (Berkeley) 06/10/93 15 */ 16 17 /* 18 * SCSI driver for MO autochanger. 19 * 20 * Very crude. Because of the lack of connect/disconnect support in the 21 * scsi driver, this driver can tie up the SCSI bus for a long time. It 22 * also grabs a DMA channel and holds it for the duration even though it 23 * never uses it. 24 */ 25 26 #include "ac.h" 27 #if NAC > 0 28 29 #include <sys/param.h> 30 #include <sys/buf.h> 31 #include <sys/errno.h> 32 #include <sys/ioctl.h> 33 #include <sys/kernel.h> 34 #include <sys/malloc.h> 35 36 #include <hp/dev/device.h> 37 #include <hp300/dev/scsireg.h> 38 #include <hp300/dev/acioctl.h> 39 #include <hp300/dev/acvar.h> 40 41 extern int scsi_test_unit_rdy(); 42 extern int scsi_request_sense(); 43 extern int scsiustart(); 44 extern int scsigo(); 45 extern void scsifree(); 46 extern void scsireset(); 47 extern void scsi_delay(); 48 49 extern int scsi_immed_command(); 50 51 int acinit(), acstart(), acgo(), acintr(); 52 53 struct driver acdriver = { 54 acinit, "ac", acstart, acgo, acintr, 55 }; 56 57 struct ac_softc ac_softc[NAC]; 58 static struct buf acbuf[NAC]; 59 static struct scsi_fmt_cdb accmd[NAC]; 60 61 #ifdef DEBUG 62 int ac_debug = 0x0000; 63 #define ACD_FOLLOW 0x0001 64 #define ACD_OPEN 0x0002 65 #endif 66 67 acinit(hd) 68 register struct hp_device *hd; 69 { 70 int unit = hd->hp_unit; 71 register struct ac_softc *sc = &ac_softc[unit]; 72 73 sc->sc_hd = hd; 74 sc->sc_punit = hd->hp_flags & 7; 75 if (acident(sc, hd) < 0) 76 return(0); 77 sc->sc_dq.dq_unit = unit; 78 sc->sc_dq.dq_ctlr = hd->hp_ctlr; 79 sc->sc_dq.dq_slave = hd->hp_slave; 80 sc->sc_dq.dq_driver = &acdriver; 81 sc->sc_bp = &acbuf[unit]; 82 sc->sc_cmd = &accmd[unit]; 83 sc->sc_flags = ACF_ALIVE; 84 return(1); 85 } 86 87 acident(sc, hd) 88 register struct ac_softc *sc; 89 register struct hp_device *hd; 90 { 91 int unit; 92 register int ctlr, slave; 93 int i, stat; 94 int tries = 5; 95 char idstr[32]; 96 struct scsi_inquiry inqbuf; 97 static struct scsi_fmt_cdb inq = { 98 6, 99 CMD_INQUIRY, 0, 0, 0, sizeof(inqbuf), 0 100 }; 101 102 ctlr = hd->hp_ctlr; 103 slave = hd->hp_slave; 104 unit = sc->sc_punit; 105 scsi_delay(-1); 106 107 /* 108 * See if device is ready 109 */ 110 while ((i = scsi_test_unit_rdy(ctlr, slave, unit)) != 0) { 111 if (i == -1 || --tries < 0) 112 /* doesn't exist or not a CCS device */ 113 goto failed; 114 if (i == STS_CHECKCOND) { 115 u_char sensebuf[128]; 116 struct scsi_xsense *sp; 117 118 scsi_request_sense(ctlr, slave, unit, 119 sensebuf, sizeof(sensebuf)); 120 sp = (struct scsi_xsense *) sensebuf; 121 if (sp->class == 7 && sp->key == 6) 122 /* drive doing an RTZ -- give it a while */ 123 DELAY(1000000); 124 } 125 DELAY(1000); 126 } 127 /* 128 * Find out if it is an autochanger 129 */ 130 if (scsi_immed_command(ctlr, slave, unit, &inq, 131 (u_char *)&inqbuf, sizeof(inqbuf), B_READ)) 132 goto failed; 133 134 if (inqbuf.type != 8 || inqbuf.qual != 0x80 || inqbuf.version != 2) 135 goto failed; 136 137 bcopy((caddr_t)&inqbuf.vendor_id, (caddr_t)idstr, 28); 138 for (i = 27; i > 23; --i) 139 if (idstr[i] != ' ') 140 break; 141 idstr[i+1] = 0; 142 for (i = 23; i > 7; --i) 143 if (idstr[i] != ' ') 144 break; 145 idstr[i+1] = 0; 146 for (i = 7; i >= 0; --i) 147 if (idstr[i] != ' ') 148 break; 149 idstr[i+1] = 0; 150 printf("ac%d: %s %s rev %s\n", hd->hp_unit, 151 &idstr[0], &idstr[8], &idstr[24]); 152 153 scsi_delay(0); 154 return(inqbuf.type); 155 failed: 156 scsi_delay(0); 157 return(-1); 158 } 159 160 /*ARGSUSED*/ 161 acopen(dev, flag, mode, p) 162 dev_t dev; 163 int flag, mode; 164 struct proc *p; 165 { 166 register int unit = minor(dev); 167 register struct ac_softc *sc = &ac_softc[unit]; 168 int error = 0; 169 170 if (unit >= NAC || (sc->sc_flags & ACF_ALIVE) == 0) 171 return(ENXIO); 172 if (sc->sc_flags & ACF_OPEN) 173 return(EBUSY); 174 /* 175 * Since acgeteinfo can block we mark the changer open now. 176 */ 177 sc->sc_flags |= ACF_OPEN; 178 if (acgeteinfo(dev)) { 179 sc->sc_flags &= ~ACF_OPEN; 180 return(EIO); 181 return(0); 182 } 183 184 /*ARGSUSED*/ 185 acclose(dev, flag, mode, p) 186 dev_t dev; 187 int flag, mode; 188 struct proc *p; 189 { 190 struct ac_softc *sc = &ac_softc[minor(dev)]; 191 192 sc->sc_flags &= ~ACF_OPEN; 193 } 194 195 #define ACRESLEN(ep) \ 196 (8 + (ep)->nmte*12 + (ep)->nse*12 + (ep)->niee*12 + (ep)->ndte*20) 197 198 /*ARGSUSED*/ 199 acioctl(dev, cmd, data, flag, p) 200 dev_t dev; 201 int cmd; 202 caddr_t data; 203 int flag; 204 struct proc *p; 205 { 206 register struct ac_softc *sc = &ac_softc[minor(dev)]; 207 char *dp; 208 int dlen, error = 0; 209 210 switch (cmd) { 211 212 default: 213 return (EINVAL); 214 215 /* perform an init element status and mode sense to reset state */ 216 case ACIOCINIT: 217 error = accommand(dev, ACCMD_INITES, (caddr_t)0, 0); 218 if (!error) 219 error = acgeteinfo(dev); 220 break; 221 222 /* copy internal element information */ 223 case ACIOCGINFO: 224 *(struct acinfo *)data = sc->sc_einfo; 225 break; 226 227 case ACIOCRAWES: 228 { 229 struct acbuffer *acbp = (struct acbuffer *)data; 230 231 dlen = ACRESLEN(&sc->sc_einfo); 232 dp = (char *) malloc(dlen, M_DEVBUF, M_WAITOK); 233 error = accommand(dev, ACCMD_READES, dp, dlen); 234 if (!error) { 235 dlen = *(int *)&dp[4] + 8; 236 if (dlen > acbp->buflen) 237 dlen = acbp->buflen; 238 error = copyout(dp, acbp->bufptr, dlen); 239 } 240 break; 241 } 242 243 case ACIOCGSTAT: 244 { 245 struct acbuffer *acbp = (struct acbuffer *)data; 246 247 dlen = ACRESLEN(&sc->sc_einfo); 248 dp = (char *) malloc(dlen, M_DEVBUF, M_WAITOK); 249 error = accommand(dev, ACCMD_READES, dp, dlen); 250 if (!error) { 251 int ne; 252 char *tbuf; 253 254 ne = sc->sc_einfo.nmte + sc->sc_einfo.nse + 255 sc->sc_einfo.niee + sc->sc_einfo.ndte; 256 dlen = ne * sizeof(struct aceltstat); 257 tbuf = (char *) malloc(dlen, M_DEVBUF, M_WAITOK); 258 acconvert(dp, tbuf, ne); 259 if (dlen > acbp->buflen) 260 dlen = acbp->buflen; 261 error = copyout(tbuf, acbp->bufptr, dlen); 262 free(tbuf, M_DEVBUF); 263 } 264 free(dp, M_DEVBUF); 265 break; 266 } 267 268 case ACIOCMOVE: 269 error = accommand(dev, ACCMD_MOVEM, data, 270 sizeof(struct acmove)); 271 break; 272 } 273 return(error); 274 } 275 276 accommand(dev, command, bufp, buflen) 277 dev_t dev; 278 int command; 279 char *bufp; 280 int buflen; 281 { 282 int unit = minor(dev); 283 register struct ac_softc *sc = &ac_softc[unit]; 284 register struct buf *bp = sc->sc_bp; 285 register struct scsi_fmt_cdb *cmd = sc->sc_cmd; 286 int error; 287 288 #ifdef DEBUG 289 if (ac_debug & ACD_FOLLOW) 290 printf("accommand(dev=%x, cmd=%x, buf=%x, buflen=%x)\n", 291 dev, command, bufp, buflen); 292 #endif 293 if (sc->sc_flags & ACF_ACTIVE) 294 panic("accommand: active!"); 295 296 sc->sc_flags |= ACF_ACTIVE; 297 bzero((caddr_t)cmd->cdb, sizeof(cmd->cdb)); 298 cmd->cdb[0] = command; 299 300 switch (command) { 301 case ACCMD_INITES: 302 cmd->len = 6; 303 break; 304 case ACCMD_READES: 305 cmd->len = 12; 306 *(short *)&cmd->cdb[2] = 0; 307 *(short *)&cmd->cdb[4] = 308 sc->sc_einfo.nmte + sc->sc_einfo.nse + 309 sc->sc_einfo.niee + sc->sc_einfo.ndte; 310 cmd->cdb[7] = buflen >> 16; 311 cmd->cdb[8] = buflen >> 8; 312 cmd->cdb[9] = buflen; 313 break; 314 case ACCMD_MODESENSE: 315 cmd->len = 6; 316 cmd->cdb[2] = 0x3F; /* all pages */ 317 cmd->cdb[4] = buflen; 318 break; 319 case ACCMD_MOVEM: 320 cmd->len = 12; 321 *(short *)&cmd->cdb[2] = sc->sc_picker; 322 *(short *)&cmd->cdb[4] = *(short *)&bufp[0]; 323 *(short *)&cmd->cdb[6] = *(short *)&bufp[2]; 324 if (*(short *)&bufp[4] & AC_INVERT) 325 cmd->cdb[10] = 1; 326 bufp = 0; 327 buflen = 0; 328 break; 329 default: 330 panic("accommand: bad command"); 331 } 332 bp->b_flags = B_BUSY|B_READ; 333 bp->b_dev = dev; 334 bp->b_un.b_addr = bufp; 335 bp->b_bcount = buflen; 336 bp->b_resid = 0; 337 bp->b_blkno = 0; 338 bp->b_error = 0; 339 if (scsireq(&sc->sc_dq)) 340 acstart(unit); 341 error = biowait(bp); 342 sc->sc_flags &= ~ACF_ACTIVE; 343 return (error); 344 } 345 346 acstart(unit) 347 int unit; 348 { 349 #ifdef DEBUG 350 if (ac_debug & ACD_FOLLOW) 351 printf("acstart(unit=%x)\n", unit); 352 #endif 353 if (scsiustart(ac_softc[unit].sc_hd->hp_ctlr)) 354 acgo(unit); 355 } 356 357 acgo(unit) 358 int unit; 359 { 360 register struct ac_softc *sc = &ac_softc[unit]; 361 register struct buf *bp = sc->sc_bp; 362 struct hp_device *hp = sc->sc_hd; 363 int stat; 364 365 #ifdef DEBUG 366 if (ac_debug & ACD_FOLLOW) 367 printf("acgo(unit=%x): ", unit); 368 #endif 369 stat = scsigo(hp->hp_ctlr, hp->hp_slave, sc->sc_punit, 370 bp, sc->sc_cmd, 0); 371 #ifdef DEBUG 372 if (ac_debug & ACD_FOLLOW) 373 printf("scsigo returns %x\n", stat); 374 #endif 375 if (stat) { 376 bp->b_error = EIO; 377 bp->b_flags |= B_ERROR; 378 (void) biodone(bp); 379 scsifree(&sc->sc_dq); 380 } 381 } 382 383 acintr(unit, stat) 384 int unit, stat; 385 { 386 register struct ac_softc *sc = &ac_softc[unit]; 387 register struct buf *bp = sc->sc_bp; 388 u_char sensebuf[78]; 389 struct scsi_xsense *sp; 390 391 #ifdef DEBUG 392 if (ac_debug & ACD_FOLLOW) 393 printf("acintr(unit=%x, stat=%x)\n", unit, stat); 394 #endif 395 switch (stat) { 396 case 0: 397 bp->b_resid = 0; 398 break; 399 case STS_CHECKCOND: 400 scsi_request_sense(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, 401 sc->sc_punit, sensebuf, sizeof sensebuf); 402 sp = (struct scsi_xsense *)sensebuf; 403 printf("ac%d: acintr sense key=%x, ac=%x, acq=%x\n", 404 unit, sp->key, sp->info4, sp->len); 405 bp->b_flags |= B_ERROR; 406 bp->b_error = EIO; 407 break; 408 default: 409 printf("ac%d: acintr unknown status 0x%x\n", unit, stat); 410 break; 411 } 412 (void) biodone(sc->sc_bp); 413 scsifree(&sc->sc_dq); 414 } 415 416 acgeteinfo(dev) 417 dev_t dev; 418 { 419 register struct ac_softc *sc = &ac_softc[minor(dev)]; 420 register char *bp; 421 char msbuf[48]; 422 int error; 423 424 bzero(msbuf, sizeof msbuf); 425 error = accommand(dev, ACCMD_MODESENSE, msbuf, sizeof msbuf); 426 if (error) 427 return(error); 428 bp = &msbuf[4]; 429 while (bp < &msbuf[48]) { 430 switch (bp[0] & 0x3F) { 431 case 0x1D: 432 sc->sc_einfo = *(struct acinfo *)&bp[2]; 433 sc->sc_picker = sc->sc_einfo.fmte; /* XXX */ 434 return(0); 435 case 0x1E: 436 bp += 4; 437 break; 438 case 0x1F: 439 bp += 20; 440 break; 441 default: 442 printf("acgeteinfo: bad page type %x\n", bp[0]); 443 return(EIO); 444 } 445 } 446 return(EIO); 447 } 448 449 acconvert(sbuf, dbuf, ne) 450 char *sbuf, *dbuf; 451 int ne; 452 { 453 register struct aceltstat *ep = (struct aceltstat *)dbuf; 454 register struct ac_restatphdr *phdr; 455 register struct ac_restatdb *dbp; 456 struct ac_restathdr *hdr; 457 #ifdef DEBUG 458 register int bcount; 459 #endif 460 461 hdr = (struct ac_restathdr *)&sbuf[0]; 462 sbuf += sizeof *hdr; 463 #ifdef DEBUG 464 if (ac_debug & ACD_FOLLOW) 465 printf("element status: first=%d, num=%d, len=%d\n", 466 hdr->ac_felt, hdr->ac_nelt, hdr->ac_bcount); 467 if (hdr->ac_nelt != ne) { 468 printf("acconvert: # of elements, %d != %d\n", 469 hdr->ac_nelt, ne); 470 if (hdr->ac_nelt < ne) 471 ne = hdr->ac_nelt; 472 } 473 bcount = hdr->ac_bcount; 474 #endif 475 while (ne) { 476 phdr = (struct ac_restatphdr *)sbuf; 477 sbuf += sizeof *phdr; 478 #ifdef DEBUG 479 bcount -= sizeof *phdr; 480 #endif 481 dbp = (struct ac_restatdb *)sbuf; 482 sbuf += phdr->ac_bcount; 483 #ifdef DEBUG 484 bcount -= phdr->ac_bcount; 485 #endif 486 while (dbp < (struct ac_restatdb *)sbuf) { 487 ep->type = phdr->ac_type; 488 ep->eaddr = dbp->ac_eaddr; 489 ep->flags = 0; 490 if (dbp->ac_full) 491 ep->flags |= AC_FULL; 492 if (dbp->ac_exc) 493 ep->flags |= AC_ERROR; 494 if (dbp->ac_acc) 495 ep->flags |= AC_ACCESS; 496 dbp = (struct ac_restatdb *) 497 ((char *)dbp + phdr->ac_dlen); 498 ep++; 499 ne--; 500 } 501 #ifdef DEBUG 502 if (ne < 0 || bcount < 0) 503 panic("acconvert: inconsistant"); 504 #endif 505 } 506 } 507 #endif 508