1 /* 2 * Copyright (c) 1991 University of Utah. 3 * Copyright (c) 1990 The Regents of the University of California. 4 * 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 7.5 (Berkeley) 12/27/92 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 error = ENXIO; 172 else if (sc->sc_flags & ACF_OPEN) 173 error = EBUSY; 174 else if (acgeteinfo(dev)) 175 error = EIO; 176 else 177 sc->sc_flags |= ACF_OPEN; 178 return(error); 179 } 180 181 /*ARGSUSED*/ 182 acclose(dev, flag, mode, p) 183 dev_t dev; 184 int flag, mode; 185 struct proc *p; 186 { 187 struct ac_softc *sc = &ac_softc[minor(dev)]; 188 189 sc->sc_flags &= ~ACF_OPEN; 190 } 191 192 #define ACRESLEN(ep) \ 193 (8 + (ep)->nmte*12 + (ep)->nse*12 + (ep)->niee*12 + (ep)->ndte*20) 194 195 /*ARGSUSED*/ 196 acioctl(dev, cmd, data, flag, p) 197 dev_t dev; 198 int cmd; 199 caddr_t data; 200 int flag; 201 struct proc *p; 202 { 203 register struct ac_softc *sc = &ac_softc[minor(dev)]; 204 char *dp; 205 int dlen, error = 0; 206 207 switch (cmd) { 208 209 default: 210 return (EINVAL); 211 212 /* perform an init element status and mode sense to reset state */ 213 case ACIOCINIT: 214 error = accommand(dev, ACCMD_INITES, (caddr_t)0, 0); 215 if (!error) 216 error = acgeteinfo(dev); 217 break; 218 219 /* copy internal element information */ 220 case ACIOCGINFO: 221 *(struct acinfo *)data = sc->sc_einfo; 222 break; 223 224 case ACIOCRAWES: 225 { 226 struct acbuffer *acbp = (struct acbuffer *)data; 227 228 dlen = ACRESLEN(&sc->sc_einfo); 229 dp = (char *) malloc(dlen, M_DEVBUF, M_WAITOK); 230 error = accommand(dev, ACCMD_READES, dp, dlen); 231 if (!error) { 232 dlen = *(int *)&dp[4] + 8; 233 if (dlen > acbp->buflen) 234 dlen = acbp->buflen; 235 error = copyout(dp, acbp->bufptr, dlen); 236 } 237 break; 238 } 239 240 case ACIOCGSTAT: 241 { 242 struct acbuffer *acbp = (struct acbuffer *)data; 243 244 dlen = ACRESLEN(&sc->sc_einfo); 245 dp = (char *) malloc(dlen, M_DEVBUF, M_WAITOK); 246 error = accommand(dev, ACCMD_READES, dp, dlen); 247 if (!error) { 248 int ne; 249 char *tbuf; 250 251 ne = sc->sc_einfo.nmte + sc->sc_einfo.nse + 252 sc->sc_einfo.niee + sc->sc_einfo.ndte; 253 dlen = ne * sizeof(struct aceltstat); 254 tbuf = (char *) malloc(dlen, M_DEVBUF, M_WAITOK); 255 acconvert(dp, tbuf, ne); 256 if (dlen > acbp->buflen) 257 dlen = acbp->buflen; 258 error = copyout(tbuf, acbp->bufptr, dlen); 259 free(tbuf, M_DEVBUF); 260 } 261 free(dp, M_DEVBUF); 262 break; 263 } 264 265 case ACIOCMOVE: 266 error = accommand(dev, ACCMD_MOVEM, data, 267 sizeof(struct acmove)); 268 break; 269 } 270 return(error); 271 } 272 273 accommand(dev, command, bufp, buflen) 274 dev_t dev; 275 int command; 276 char *bufp; 277 int buflen; 278 { 279 int unit = minor(dev); 280 register struct ac_softc *sc = &ac_softc[unit]; 281 register struct buf *bp = sc->sc_bp; 282 register struct scsi_fmt_cdb *cmd = sc->sc_cmd; 283 int error; 284 285 #ifdef DEBUG 286 if (ac_debug & ACD_FOLLOW) 287 printf("accommand(dev=%x, cmd=%x, buf=%x, buflen=%x)\n", 288 dev, command, bufp, buflen); 289 #endif 290 if (sc->sc_flags & ACF_ACTIVE) 291 panic("accommand: active!"); 292 293 sc->sc_flags |= ACF_ACTIVE; 294 bzero((caddr_t)cmd->cdb, sizeof(cmd->cdb)); 295 cmd->cdb[0] = command; 296 297 switch (command) { 298 case ACCMD_INITES: 299 cmd->len = 6; 300 break; 301 case ACCMD_READES: 302 cmd->len = 12; 303 *(short *)&cmd->cdb[2] = 0; 304 *(short *)&cmd->cdb[4] = 305 sc->sc_einfo.nmte + sc->sc_einfo.nse + 306 sc->sc_einfo.niee + sc->sc_einfo.ndte; 307 cmd->cdb[7] = buflen >> 16; 308 cmd->cdb[8] = buflen >> 8; 309 cmd->cdb[9] = buflen; 310 break; 311 case ACCMD_MODESENSE: 312 cmd->len = 6; 313 cmd->cdb[2] = 0x3F; /* all pages */ 314 cmd->cdb[4] = buflen; 315 break; 316 case ACCMD_MOVEM: 317 cmd->len = 12; 318 *(short *)&cmd->cdb[2] = sc->sc_picker; 319 *(short *)&cmd->cdb[4] = *(short *)&bufp[0]; 320 *(short *)&cmd->cdb[6] = *(short *)&bufp[2]; 321 if (*(short *)&bufp[4] & AC_INVERT) 322 cmd->cdb[10] = 1; 323 bufp = 0; 324 buflen = 0; 325 break; 326 default: 327 panic("accommand: bad command"); 328 } 329 bp->b_flags = B_BUSY|B_READ; 330 bp->b_dev = dev; 331 bp->b_un.b_addr = bufp; 332 bp->b_bcount = buflen; 333 bp->b_resid = 0; 334 bp->b_blkno = 0; 335 bp->b_error = 0; 336 if (scsireq(&sc->sc_dq)) 337 acstart(unit); 338 error = biowait(bp); 339 sc->sc_flags &= ~ACF_ACTIVE; 340 return (error); 341 } 342 343 acstart(unit) 344 int unit; 345 { 346 #ifdef DEBUG 347 if (ac_debug & ACD_FOLLOW) 348 printf("acstart(unit=%x)\n", unit); 349 #endif 350 if (scsiustart(ac_softc[unit].sc_hd->hp_ctlr)) 351 acgo(unit); 352 } 353 354 acgo(unit) 355 int unit; 356 { 357 register struct ac_softc *sc = &ac_softc[unit]; 358 register struct buf *bp = sc->sc_bp; 359 struct hp_device *hp = sc->sc_hd; 360 int stat; 361 362 #ifdef DEBUG 363 if (ac_debug & ACD_FOLLOW) 364 printf("acgo(unit=%x): ", unit); 365 #endif 366 stat = scsigo(hp->hp_ctlr, hp->hp_slave, sc->sc_punit, 367 bp, sc->sc_cmd, 0); 368 #ifdef DEBUG 369 if (ac_debug & ACD_FOLLOW) 370 printf("scsigo returns %x\n", stat); 371 #endif 372 if (stat) { 373 bp->b_error = EIO; 374 bp->b_flags |= B_ERROR; 375 (void) biodone(bp); 376 scsifree(&sc->sc_dq); 377 } 378 } 379 380 acintr(unit, stat) 381 int unit, stat; 382 { 383 register struct ac_softc *sc = &ac_softc[unit]; 384 register struct buf *bp = sc->sc_bp; 385 u_char sensebuf[78]; 386 struct scsi_xsense *sp; 387 388 #ifdef DEBUG 389 if (ac_debug & ACD_FOLLOW) 390 printf("acintr(unit=%x, stat=%x)\n", unit, stat); 391 #endif 392 switch (stat) { 393 case 0: 394 bp->b_resid = 0; 395 break; 396 case STS_CHECKCOND: 397 scsi_request_sense(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, 398 sc->sc_punit, sensebuf, sizeof sensebuf); 399 sp = (struct scsi_xsense *)sensebuf; 400 printf("ac%d: acintr sense key=%x, ac=%x, acq=%x\n", 401 unit, sp->key, sp->info4, sp->len); 402 bp->b_flags |= B_ERROR; 403 bp->b_error = EIO; 404 break; 405 default: 406 printf("ac%d: acintr unknown status 0x%x\n", unit, stat); 407 break; 408 } 409 (void) biodone(sc->sc_bp); 410 scsifree(&sc->sc_dq); 411 } 412 413 acgeteinfo(dev) 414 dev_t dev; 415 { 416 register struct ac_softc *sc = &ac_softc[minor(dev)]; 417 register char *bp; 418 char msbuf[48]; 419 int error; 420 421 bzero(msbuf, sizeof msbuf); 422 error = accommand(dev, ACCMD_MODESENSE, msbuf, sizeof msbuf); 423 if (error) 424 return(error); 425 bp = &msbuf[4]; 426 while (bp < &msbuf[48]) { 427 switch (bp[0] & 0x3F) { 428 case 0x1D: 429 sc->sc_einfo = *(struct acinfo *)&bp[2]; 430 sc->sc_picker = sc->sc_einfo.fmte; /* XXX */ 431 return(0); 432 case 0x1E: 433 bp += 4; 434 break; 435 case 0x1F: 436 bp += 20; 437 break; 438 default: 439 printf("acgeteinfo: bad page type %x\n", bp[0]); 440 return(EIO); 441 } 442 } 443 return(EIO); 444 } 445 446 acconvert(sbuf, dbuf, ne) 447 char *sbuf, *dbuf; 448 int ne; 449 { 450 register struct aceltstat *ep = (struct aceltstat *)dbuf; 451 register struct ac_restatphdr *phdr; 452 register struct ac_restatdb *dbp; 453 struct ac_restathdr *hdr; 454 #ifdef DEBUG 455 register int bcount; 456 #endif 457 458 hdr = (struct ac_restathdr *)&sbuf[0]; 459 sbuf += sizeof *hdr; 460 #ifdef DEBUG 461 if (ac_debug & ACD_FOLLOW) 462 printf("element status: first=%d, num=%d, len=%d\n", 463 hdr->ac_felt, hdr->ac_nelt, hdr->ac_bcount); 464 if (hdr->ac_nelt != ne) { 465 printf("acconvert: # of elements, %d != %d\n", 466 hdr->ac_nelt, ne); 467 if (hdr->ac_nelt < ne) 468 ne = hdr->ac_nelt; 469 } 470 bcount = hdr->ac_bcount; 471 #endif 472 while (ne) { 473 phdr = (struct ac_restatphdr *)sbuf; 474 sbuf += sizeof *phdr; 475 #ifdef DEBUG 476 bcount -= sizeof *phdr; 477 #endif 478 dbp = (struct ac_restatdb *)sbuf; 479 sbuf += phdr->ac_bcount; 480 #ifdef DEBUG 481 bcount -= phdr->ac_bcount; 482 #endif 483 while (dbp < (struct ac_restatdb *)sbuf) { 484 ep->type = phdr->ac_type; 485 ep->eaddr = dbp->ac_eaddr; 486 ep->flags = 0; 487 if (dbp->ac_full) 488 ep->flags |= AC_FULL; 489 if (dbp->ac_exc) 490 ep->flags |= AC_ERROR; 491 if (dbp->ac_acc) 492 ep->flags |= AC_ACCESS; 493 dbp = (struct ac_restatdb *) 494 ((char *)dbp + phdr->ac_dlen); 495 ep++; 496 ne--; 497 } 498 #ifdef DEBUG 499 if (ne < 0 || bcount < 0) 500 panic("acconvert: inconsistant"); 501 #endif 502 } 503 } 504 #endif 505