ct.c revision 1.7
1 /* $NetBSD: ct.c,v 1.7 2006/03/25 22:59:59 thorpej Exp $ */ 2 3 /*- 4 * Copyright (c) 1996-2003 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. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 /* 40 * Copyright (c) 1982, 1990, 1993 41 * The Regents of the University of California. All rights reserved. 42 * 43 * This code is derived from software contributed to Berkeley by 44 * the Systems Programming Group of the University of Utah Computer 45 * Science Department. 46 * 47 * Redistribution and use in source and binary forms, with or without 48 * modification, are permitted provided that the following conditions 49 * are met: 50 * 1. Redistributions of source code must retain the above copyright 51 * notice, this list of conditions and the following disclaimer. 52 * 2. Redistributions in binary form must reproduce the above copyright 53 * notice, this list of conditions and the following disclaimer in the 54 * documentation and/or other materials provided with the distribution. 55 * 3. Neither the name of the University nor the names of its contributors 56 * may be used to endorse or promote products derived from this software 57 * without specific prior written permission. 58 * 59 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 60 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 61 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 62 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 63 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 64 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 65 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 66 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 67 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 68 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 69 * SUCH DAMAGE. 70 * 71 * from: Utah $Hdr: rd.c 1.44 92/12/26$ 72 * 73 * @(#)rd.c 8.2 (Berkeley) 5/19/94 74 */ 75 76 /* 77 * Copyright (c) 1988 University of Utah. 78 * 79 * This code is derived from software contributed to Berkeley by 80 * the Systems Programming Group of the University of Utah Computer 81 * Science Department. 82 * 83 * Redistribution and use in source and binary forms, with or without 84 * modification, are permitted provided that the following conditions 85 * are met: 86 * 1. Redistributions of source code must retain the above copyright 87 * notice, this list of conditions and the following disclaimer. 88 * 2. Redistributions in binary form must reproduce the above copyright 89 * notice, this list of conditions and the following disclaimer in the 90 * documentation and/or other materials provided with the distribution. 91 * 3. All advertising materials mentioning features or use of this software 92 * must display the following acknowledgement: 93 * This product includes software developed by the University of 94 * California, Berkeley and its contributors. 95 * 4. Neither the name of the University nor the names of its contributors 96 * may be used to endorse or promote products derived from this software 97 * without specific prior written permission. 98 * 99 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 100 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 101 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 102 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 103 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 104 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 105 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 106 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 107 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 108 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 109 * SUCH DAMAGE. 110 * 111 * from: Utah $Hdr: rd.c 1.44 92/12/26$ 112 * 113 * @(#)rd.c 8.2 (Berkeley) 5/19/94 114 */ 115 116 /* 117 * CS/80 cartridge tape driver (HP9144, HP88140, HP9145) 118 * 119 * Reminder: 120 * C_CC bit (character count option) when used in the CS/80 command 121 * 'set options' will cause the tape not to stream. 122 * 123 * TODO: 124 * make filesystem compatible 125 * make block mode work according to mtio(4) spec. (if possible) 126 * merge with CS/80 disk driver 127 * finish support of HP9145 128 */ 129 130 #include <sys/cdefs.h> 131 __KERNEL_RCSID(0, "$NetBSD: ct.c,v 1.7 2006/03/25 22:59:59 thorpej Exp $"); 132 133 #include <sys/param.h> 134 #include <sys/systm.h> 135 #include <sys/buf.h> 136 #include <sys/bufq.h> 137 #include <sys/conf.h> 138 #include <sys/device.h> 139 #include <sys/ioctl.h> 140 #include <sys/mtio.h> 141 #include <sys/proc.h> 142 #include <sys/tprintf.h> 143 144 #include <dev/gpib/ctreg.h> /* XXX must be before cs80busvar.h ATM */ 145 146 #include <dev/gpib/gpibvar.h> 147 #include <dev/gpib/cs80busvar.h> 148 149 /* number of eof marks to remember */ 150 #define EOFS 128 151 152 #ifdef DEBUG 153 int ctdebug = 0xff; 154 #define CDB_FILES 0x01 155 #define CDB_BSF 0x02 156 #define CDB_IDENT 0x04 157 #define CDB_FAIL 0x08 158 #define CDB_FOLLOW 0x10 159 #define DPRINTF(mask, str) if (ctdebug & (mask)) printf str 160 #else 161 #define DPRINTF(mask, str) /* nothing */ 162 #endif 163 164 struct ct_softc { 165 struct device sc_dev; 166 167 gpib_chipset_tag_t sc_ic; 168 gpib_handle_t sc_hdl; 169 170 int sc_slave; /* GPIB slave ID */ 171 int sc_punit; /* physical unit */ 172 struct ct_iocmd sc_ioc; 173 struct ct_rscmd sc_rsc; 174 struct cs80_stat sc_stat; 175 struct bufq_state *sc_tab; 176 int sc_active; 177 struct buf *sc_bp; 178 struct buf sc_bufstore; /* XXX */ 179 int sc_blkno; 180 int sc_cmd; 181 int sc_resid; 182 char *sc_addr; 183 int sc_flags; 184 #define CTF_OPEN 0x01 185 #define CTF_ALIVE 0x02 186 #define CTF_WRT 0x04 187 #define CTF_CMD 0x08 188 #define CTF_IO 0x10 189 #define CTF_BEOF 0x20 190 #define CTF_AEOF 0x40 191 #define CTF_EOT 0x80 192 #define CTF_STATWAIT 0x100 193 #define CTF_CANSTREAM 0x200 194 #define CTF_WRTTN 0x400 195 short sc_type; 196 tpr_t sc_tpr; 197 int sc_eofp; 198 int sc_eofs[EOFS]; 199 }; 200 201 int ctmatch(struct device *, struct cfdata *, void *); 202 void ctattach(struct device *, struct device *, void *); 203 204 CFATTACH_DECL(ct, sizeof(struct ct_softc), 205 ctmatch, ctattach, NULL, NULL); 206 207 int ctident(struct device *, struct ct_softc *, 208 struct cs80bus_attach_args *); 209 210 int ctlookup(int, int, int); 211 void ctaddeof(struct ct_softc *); 212 void ctustart(struct ct_softc *); 213 void cteof(struct ct_softc *, struct buf *); 214 void ctdone(struct ct_softc *, struct buf *); 215 216 void ctcallback(void *, int); 217 void ctstart(struct ct_softc *); 218 void ctintr(struct ct_softc *); 219 220 void ctcommand(dev_t, int, int); 221 222 dev_type_open(ctopen); 223 dev_type_close(ctclose); 224 dev_type_read(ctread); 225 dev_type_write(ctwrite); 226 dev_type_ioctl(ctioctl); 227 dev_type_strategy(ctstrategy); 228 229 const struct bdevsw ct_bdevsw = { 230 ctopen, ctclose, ctstrategy, ctioctl, nodump, nosize, D_TAPE 231 }; 232 233 const struct cdevsw ct_cdevsw = { 234 ctopen, ctclose, ctread, ctwrite, ctioctl, 235 nostop, notty, nopoll, nommap, nokqfilter, D_TAPE 236 }; 237 238 extern struct cfdriver ct_cd; 239 240 struct ctinfo { 241 short hwid; 242 short punit; 243 char *desc; 244 } ctinfo[] = { 245 { CT7946ID, 1, "7946A" }, 246 { CT7912PID, 1, "7912P" }, 247 { CT7914PID, 1, "7914P" }, 248 { CT9144ID, 0, "9144" }, 249 { CT9145ID, 0, "9145" }, 250 { CT35401ID, 0, "35401A"}, 251 }; 252 int nctinfo = sizeof(ctinfo) / sizeof(ctinfo[0]); 253 254 #define CT_NOREW 4 255 #define CT_STREAM 8 256 #define CTUNIT(x) (minor(x) & 0x03) 257 258 int 259 ctlookup(id, slave, punit) 260 int id; 261 int slave; 262 int punit; 263 { 264 int i; 265 266 for (i = 0; i < nctinfo; i++) 267 if (ctinfo[i].hwid == id) 268 break; 269 if (i == nctinfo) 270 return (-1); 271 return (i); 272 } 273 274 int 275 ctmatch(parent, match, aux) 276 struct device *parent; 277 struct cfdata *match; 278 void *aux; 279 { 280 struct cs80bus_attach_args *ca = aux; 281 int i; 282 283 if ((i = ctlookup(ca->ca_id, ca->ca_slave, ca->ca_punit)) < 0) 284 return (0); 285 ca->ca_punit = ctinfo[i].punit; 286 return (1); 287 } 288 289 void 290 ctattach(parent, self, aux) 291 struct device *parent, *self; 292 void *aux; 293 { 294 struct ct_softc *sc = (struct ct_softc *)self; 295 struct cs80bus_attach_args *ca = aux; 296 struct cs80_description csd; 297 char name[7]; 298 int type, i, n, canstream = 0; 299 300 sc->sc_ic = ca->ca_ic; 301 sc->sc_slave = ca->ca_slave; 302 sc->sc_punit = ca->ca_punit; 303 304 if ((type = ctlookup(ca->ca_id, ca->ca_slave, ca->ca_punit)) < 0) 305 return; 306 307 if (cs80reset(parent, sc->sc_slave, sc->sc_punit)) { 308 printf("\n%s: can't reset device\n", sc->sc_dev.dv_xname); 309 return; 310 } 311 312 if (cs80describe(parent, sc->sc_slave, sc->sc_punit, &csd)) { 313 printf("\n%s: didn't respond to describe command\n", 314 sc->sc_dev.dv_xname); 315 return; 316 } 317 memset(name, 0, sizeof(name)); 318 for (i=0, n=0; i<3; i++) { 319 name[n++] = (csd.d_name[i] >> 4) + '0'; 320 name[n++] = (csd.d_name[i] & 0x0f) + '0'; 321 } 322 323 #ifdef DEBUG 324 if (ctdebug & CDB_IDENT) { 325 printf("\n%s: name: ('%s')\n", 326 sc->sc_dev.dv_xname,name); 327 printf(" iuw %x, maxxfr %d, ctype %d\n", 328 csd.d_iuw, csd.d_cmaxxfr, csd.d_ctype); 329 printf(" utype %d, bps %d, blkbuf %d, burst %d, blktime %d\n", 330 csd.d_utype, csd.d_sectsize, 331 csd.d_blkbuf, csd.d_burstsize, csd.d_blocktime); 332 printf(" avxfr %d, ort %d, atp %d, maxint %d, fv %x, rv %x\n", 333 csd.d_uavexfr, csd.d_retry, csd.d_access, 334 csd.d_maxint, csd.d_fvbyte, csd.d_rvbyte); 335 printf(" maxcyl/head/sect %d/%d/%d, maxvsect %d, inter %d\n", 336 csd.d_maxcylhead >> 8 , csd.d_maxcylhead & 0xff, 337 csd.d_maxsect, csd.d_maxvsectl, csd.d_interleave); 338 printf("%s", sc->sc_dev.dv_xname); 339 } 340 #endif 341 342 switch (ca->ca_id) { 343 case CT7946ID: 344 if (memcmp(name, "079450", 6) == 0) 345 return; /* not really a 7946 */ 346 /* fall into... */ 347 case CT9144ID: 348 case CT9145ID: 349 case CT35401ID: 350 sc->sc_type = CT9144; 351 canstream = 1; 352 break; 353 354 case CT7912PID: 355 case CT7914PID: 356 sc->sc_type = CT88140; 357 break; 358 default: 359 sc->sc_type = type; 360 break; 361 } 362 363 sc->sc_type = type; 364 sc->sc_flags = canstream ? CTF_CANSTREAM : 0; 365 printf(": %s %stape\n", ctinfo[type].desc, 366 canstream ? "streaming " : ""); 367 368 bufq_alloc(&sc->sc_tab, "fcfs", 0); 369 370 if (gpibregister(sc->sc_ic, sc->sc_slave, ctcallback, sc, 371 &sc->sc_hdl)) { 372 printf("%s: can't register callback\n", sc->sc_dev.dv_xname); 373 return; 374 } 375 376 sc->sc_flags |= CTF_ALIVE; 377 } 378 379 /*ARGSUSED*/ 380 int 381 ctopen(dev, flag, type, p) 382 dev_t dev; 383 int flag, type; 384 struct proc *p; 385 { 386 struct ct_softc *sc; 387 u_int8_t opt; 388 389 sc = device_lookup(&ct_cd, CTUNIT(dev)); 390 if (sc == NULL || (sc->sc_flags & CTF_ALIVE) == 0) 391 return (ENXIO); 392 393 if (sc->sc_flags & CTF_OPEN) 394 return (EBUSY); 395 396 if ((dev & CT_STREAM) && (sc->sc_flags & CTF_CANSTREAM)) 397 opt = C_SPAR | C_IMRPT; 398 else 399 opt = C_SPAR; 400 401 if (cs80setoptions(device_parent(&sc->sc_dev), sc->sc_slave, 402 sc->sc_punit, opt)) 403 return (EBUSY); 404 405 sc->sc_tpr = tprintf_open(p); 406 sc->sc_flags |= CTF_OPEN; 407 408 return (0); 409 } 410 411 /*ARGSUSED*/ 412 int 413 ctclose(dev, flag, fmt, p) 414 dev_t dev; 415 int flag, fmt; 416 struct proc *p; 417 { 418 struct ct_softc *sc; 419 420 sc = device_lookup(&ct_cd, CTUNIT(dev)); 421 if (sc == NULL) 422 return (ENXIO); 423 424 if ((sc->sc_flags & (CTF_WRT|CTF_WRTTN)) == (CTF_WRT|CTF_WRTTN) && 425 (sc->sc_flags & CTF_EOT) == 0 ) { /* XXX return error if EOT ?? */ 426 ctcommand(dev, MTWEOF, 2); 427 ctcommand(dev, MTBSR, 1); 428 if (sc->sc_eofp == EOFS - 1) 429 sc->sc_eofs[EOFS - 1]--; 430 else 431 sc->sc_eofp--; 432 DPRINTF(CDB_BSF, ("%s: ctclose backup eofs prt %d blk %d\n", 433 sc->sc_dev.dv_xname, sc->sc_eofp, 434 sc->sc_eofs[sc->sc_eofp])); 435 } 436 437 if ((minor(dev) & CT_NOREW) == 0) 438 ctcommand(dev, MTREW, 1); 439 sc->sc_flags &= ~(CTF_OPEN | CTF_WRT | CTF_WRTTN); 440 tprintf_close(sc->sc_tpr); 441 DPRINTF(CDB_FILES, ("ctclose: flags %x\n", sc->sc_flags)); 442 443 return (0); /* XXX */ 444 } 445 446 void 447 ctcommand(dev, cmd, cnt) 448 dev_t dev; 449 int cmd; 450 int cnt; 451 { 452 struct ct_softc *sc; 453 struct buf *bp; 454 struct buf *nbp = 0; 455 456 sc = device_lookup(&ct_cd, CTUNIT(dev)); 457 bp = &sc->sc_bufstore; 458 459 DPRINTF(CDB_FOLLOW, ("ctcommand: called\n")); 460 461 if (cmd == MTBSF && sc->sc_eofp == EOFS - 1) { 462 cnt = sc->sc_eofs[EOFS - 1] - cnt; 463 ctcommand(dev, MTREW, 1); 464 ctcommand(dev, MTFSF, cnt); 465 cnt = 2; 466 cmd = MTBSR; 467 } 468 469 if (cmd == MTBSF && sc->sc_eofp - cnt < 0) { 470 cnt = 1; 471 cmd = MTREW; 472 } 473 474 sc->sc_flags |= CTF_CMD; 475 sc->sc_bp = bp; 476 sc->sc_cmd = cmd; 477 bp->b_dev = dev; 478 if (cmd == MTFSF) { 479 nbp = (struct buf *)geteblk(MAXBSIZE); 480 bp->b_data = nbp->b_data; 481 bp->b_bcount = MAXBSIZE; 482 } 483 484 while (cnt-- > 0) { 485 bp->b_flags = B_BUSY; 486 if (cmd == MTBSF) { 487 sc->sc_blkno = sc->sc_eofs[sc->sc_eofp]; 488 sc->sc_eofp--; 489 DPRINTF(CDB_BSF, ("%s: backup eof pos %d blk %d\n", 490 sc->sc_dev.dv_xname, sc->sc_eofp, 491 sc->sc_eofs[sc->sc_eofp])); 492 } 493 ctstrategy(bp); 494 biowait(bp); 495 } 496 bp->b_flags = 0; 497 sc->sc_flags &= ~CTF_CMD; 498 if (nbp) 499 brelse(nbp); 500 } 501 502 void 503 ctstrategy(bp) 504 struct buf *bp; 505 { 506 struct ct_softc *sc; 507 int s; 508 509 DPRINTF(CDB_FOLLOW, ("cdstrategy(%p): dev %x, bn %x, bcount %lx, %c\n", 510 bp, bp->b_dev, bp->b_blkno, bp->b_bcount, 511 (bp->b_flags & B_READ) ? 'R' : 'W')); 512 513 sc = device_lookup(&ct_cd, CTUNIT(bp->b_dev)); 514 515 s = splbio(); 516 BUFQ_PUT(sc->sc_tab, bp); 517 if (sc->sc_active == 0) { 518 sc->sc_active = 1; 519 ctustart(sc); 520 } 521 splx(s); 522 } 523 524 void 525 ctustart(sc) 526 struct ct_softc *sc; 527 { 528 struct buf *bp; 529 530 bp = BUFQ_PEEK(sc->sc_tab); 531 sc->sc_addr = bp->b_data; 532 sc->sc_resid = bp->b_bcount; 533 if (gpibrequest(sc->sc_ic, sc->sc_hdl)) 534 ctstart(sc); 535 } 536 537 void 538 ctstart(sc) 539 struct ct_softc *sc; 540 { 541 struct buf *bp; 542 struct ct_ulcmd ul; 543 struct ct_wfmcmd wfm; 544 int i, slave, punit; 545 546 slave = sc->sc_slave; 547 punit = sc->sc_punit; 548 549 bp = BUFQ_PEEK(sc->sc_tab); 550 if ((sc->sc_flags & CTF_CMD) && sc->sc_bp == bp) { 551 switch(sc->sc_cmd) { 552 case MTFSF: 553 bp->b_flags |= B_READ; 554 goto mustio; 555 556 case MTBSF: 557 goto gotaddr; 558 559 case MTOFFL: 560 sc->sc_blkno = 0; 561 ul.unit = CS80CMD_SUNIT(punit); 562 ul.cmd = CS80CMD_UNLOAD; 563 (void) cs80send(device_parent(&sc->sc_dev), slave, 564 punit, CS80CMD_SCMD, &ul, sizeof(ul)); 565 break; 566 567 case MTWEOF: 568 sc->sc_blkno++; 569 sc->sc_flags |= CTF_WRT; 570 wfm.unit = CS80CMD_SUNIT(sc->sc_punit); 571 wfm.cmd = CS80CMD_WFM; 572 (void) cs80send(device_parent(&sc->sc_dev), slave, 573 punit, CS80CMD_SCMD, &wfm, sizeof(wfm)); 574 ctaddeof(sc); 575 break; 576 577 case MTBSR: 578 sc->sc_blkno--; 579 goto gotaddr; 580 581 case MTFSR: 582 sc->sc_blkno++; 583 goto gotaddr; 584 585 case MTREW: 586 sc->sc_blkno = 0; 587 DPRINTF(CDB_BSF, ("%s: clearing eofs\n", 588 sc->sc_dev.dv_xname)); 589 for (i=0; i<EOFS; i++) 590 sc->sc_eofs[i] = 0; 591 sc->sc_eofp = 0; 592 593 gotaddr: 594 sc->sc_ioc.unit = CS80CMD_SUNIT(sc->sc_punit); 595 sc->sc_ioc.saddr = CS80CMD_SADDR; 596 sc->sc_ioc.addr0 = 0; 597 sc->sc_ioc.addr = htobe32(sc->sc_blkno); 598 sc->sc_ioc.nop2 = CS80CMD_NOP; 599 sc->sc_ioc.slen = CS80CMD_SLEN; 600 sc->sc_ioc.len = htobe32(0); 601 sc->sc_ioc.nop3 = CS80CMD_NOP; 602 sc->sc_ioc.cmd = CS80CMD_READ; 603 (void) cs80send(device_parent(&sc->sc_dev), slave, 604 punit, CS80CMD_SCMD, &sc->sc_ioc, 605 sizeof(sc->sc_ioc)); 606 break; 607 } 608 } else { 609 mustio: 610 if ((bp->b_flags & B_READ) && 611 sc->sc_flags & (CTF_BEOF|CTF_EOT)) { 612 DPRINTF(CDB_FILES, ("ctstart: before %x\n", 613 sc->sc_flags)); 614 if (sc->sc_flags & CTF_BEOF) { 615 sc->sc_flags &= ~CTF_BEOF; 616 sc->sc_flags |= CTF_AEOF; 617 DPRINTF(CDB_FILES, ("ctstart: after %x\n", 618 sc->sc_flags)); 619 } 620 bp->b_resid = bp->b_bcount; 621 ctdone(sc, bp); 622 return; 623 } 624 sc->sc_flags |= CTF_IO; 625 sc->sc_ioc.unit = CS80CMD_SUNIT(sc->sc_punit); 626 sc->sc_ioc.saddr = CS80CMD_SADDR; 627 sc->sc_ioc.addr0 = 0; 628 sc->sc_ioc.addr = htobe32(sc->sc_blkno); 629 sc->sc_ioc.nop2 = CS80CMD_NOP; 630 sc->sc_ioc.slen = CS80CMD_SLEN; 631 sc->sc_ioc.len = htobe32(sc->sc_resid); 632 sc->sc_ioc.nop3 = CS80CMD_NOP; 633 if (bp->b_flags & B_READ) 634 sc->sc_ioc.cmd = CS80CMD_READ; 635 else { 636 sc->sc_ioc.cmd = CS80CMD_WRITE; 637 sc->sc_flags |= (CTF_WRT | CTF_WRTTN); 638 } 639 (void) cs80send(device_parent(&sc->sc_dev), slave, punit, 640 CS80CMD_SCMD, &sc->sc_ioc, sizeof(sc->sc_ioc)); 641 } 642 gpibawait(sc->sc_ic); 643 } 644 645 /* 646 * Hideous grue to handle EOF/EOT (mostly for reads) 647 */ 648 void 649 cteof(sc, bp) 650 struct ct_softc *sc; 651 struct buf *bp; 652 { 653 long blks; 654 655 /* 656 * EOT on a write is an error. 657 */ 658 if ((bp->b_flags & B_READ) == 0) { 659 bp->b_resid = bp->b_bcount; 660 bp->b_flags |= B_ERROR; 661 bp->b_error = ENOSPC; 662 sc->sc_flags |= CTF_EOT; 663 return; 664 } 665 /* 666 * Use returned block position to determine how many blocks 667 * we really read and update b_resid. 668 */ 669 blks = sc->sc_stat.c_blk - sc->sc_blkno - 1; 670 DPRINTF(CDB_FILES, ("cteof: bc %ld oblk %d nblk %d read %ld, resid %ld\n", 671 bp->b_bcount, sc->sc_blkno, sc->sc_stat.c_blk, 672 blks, bp->b_bcount - CTKTOB(blks))); 673 if (blks == -1) { /* 9145 on EOF does not change sc_stat.c_blk */ 674 blks = 0; 675 sc->sc_blkno++; 676 } 677 else { 678 sc->sc_blkno = sc->sc_stat.c_blk; 679 } 680 bp->b_resid = bp->b_bcount - CTKTOB(blks); 681 /* 682 * If we are at physical EOV or were after an EOF, 683 * we are now at logical EOT. 684 */ 685 if ((sc->sc_stat.c_aef & AEF_EOV) || 686 (sc->sc_flags & CTF_AEOF)) { 687 sc->sc_flags |= CTF_EOT; 688 sc->sc_flags &= ~(CTF_AEOF|CTF_BEOF); 689 } 690 /* 691 * If we were before an EOF or we have just completed a FSF, 692 * we are now after EOF. 693 */ 694 else if ((sc->sc_flags & CTF_BEOF) || 695 ((sc->sc_flags & CTF_CMD) && sc->sc_cmd == MTFSF)) { 696 sc->sc_flags |= CTF_AEOF; 697 sc->sc_flags &= ~CTF_BEOF; 698 } 699 /* 700 * Otherwise if we read something we are now before EOF 701 * (and no longer after EOF). 702 */ 703 else if (blks) { 704 sc->sc_flags |= CTF_BEOF; 705 sc->sc_flags &= ~CTF_AEOF; 706 } 707 /* 708 * Finally, if we didn't read anything we just passed an EOF 709 */ 710 else 711 sc->sc_flags |= CTF_AEOF; 712 DPRINTF(CDB_FILES, ("cteof: leaving flags %x\n", sc->sc_flags)); 713 } 714 715 716 void 717 ctcallback(v, action) 718 void *v; 719 int action; 720 { 721 struct ct_softc *sc = v; 722 723 DPRINTF(CDB_FOLLOW, ("ctcallback: v=%p, action=%d\n", v, action)); 724 725 switch (action) { 726 case GPIBCBF_START: 727 ctstart(sc); 728 break; 729 case GPIBCBF_INTR: 730 ctintr(sc); 731 break; 732 #ifdef DEBUG 733 default: 734 DPRINTF(CDB_FAIL, ("ctcallback: unknown action %d\n", action)); 735 break; 736 #endif 737 } 738 } 739 740 void 741 ctintr(sc) 742 struct ct_softc *sc; 743 { 744 struct buf *bp; 745 u_int8_t stat; 746 int slave, punit; 747 int dir; 748 749 slave = sc->sc_slave; 750 punit = sc->sc_punit; 751 752 bp = BUFQ_PEEK(sc->sc_tab); 753 if (bp == NULL) { 754 printf("%s: bp == NULL\n", sc->sc_dev.dv_xname); 755 return; 756 } 757 if (sc->sc_flags & CTF_IO) { 758 sc->sc_flags &= ~CTF_IO; 759 dir = (bp->b_flags & B_READ ? GPIB_READ : GPIB_WRITE); 760 gpibxfer(sc->sc_ic, slave, CS80CMD_EXEC, sc->sc_addr, 761 sc->sc_resid, dir, dir == GPIB_READ); 762 return; 763 } 764 if ((sc->sc_flags & CTF_STATWAIT) == 0) { 765 if (gpibpptest(sc->sc_ic, slave) == 0) { 766 sc->sc_flags |= CTF_STATWAIT; 767 gpibawait(sc->sc_ic); 768 return; 769 } 770 } else 771 sc->sc_flags &= ~CTF_STATWAIT; 772 (void) gpibrecv(sc->sc_ic, slave, CS80CMD_QSTAT, &stat, 1); 773 DPRINTF(CDB_FILES, ("ctintr: before flags %x\n", sc->sc_flags)); 774 if (stat) { 775 sc->sc_rsc.unit = CS80CMD_SUNIT(punit); 776 sc->sc_rsc.cmd = CS80CMD_STATUS; 777 (void) gpibsend(sc->sc_ic, slave, CS80CMD_SCMD, &sc->sc_rsc, 778 sizeof(sc->sc_rsc)); 779 (void) gpibrecv(sc->sc_ic, slave, CS80CMD_EXEC, &sc->sc_stat, 780 sizeof(sc->sc_stat)); 781 (void) gpibrecv(sc->sc_ic, slave, CS80CMD_QSTAT, &stat, 1); 782 DPRINTF(CDB_FILES, ("ctintr: return stat 0x%x, A%x F%x blk %d\n", 783 stat, sc->sc_stat.c_aef, 784 sc->sc_stat.c_fef, sc->sc_stat.c_blk)); 785 if (stat == 0) { 786 if (sc->sc_stat.c_aef & (AEF_EOF | AEF_EOV)) { 787 cteof(sc, bp); 788 ctaddeof(sc); 789 goto done; 790 } 791 if (sc->sc_stat.c_fef & FEF_PF) { 792 cs80reset(sc, slave, punit); 793 ctstart(sc); 794 return; 795 } 796 if (sc->sc_stat.c_fef & FEF_REXMT) { 797 ctstart(sc); 798 return; 799 } 800 if (sc->sc_stat.c_aef & 0x5800) { 801 if (sc->sc_stat.c_aef & 0x4000) 802 tprintf(sc->sc_tpr, 803 "%s: uninitialized media\n", 804 sc->sc_dev.dv_xname); 805 if (sc->sc_stat.c_aef & 0x1000) 806 tprintf(sc->sc_tpr, 807 "%s: not ready\n", 808 sc->sc_dev.dv_xname); 809 if (sc->sc_stat.c_aef & 0x0800) 810 tprintf(sc->sc_tpr, 811 "%s: write protect\n", 812 sc->sc_dev.dv_xname); 813 } else { 814 printf("%s err: v%d u%d ru%d bn%d, ", 815 sc->sc_dev.dv_xname, 816 (sc->sc_stat.c_vu>>4)&0xF, 817 sc->sc_stat.c_vu&0xF, 818 sc->sc_stat.c_pend, 819 sc->sc_stat.c_blk); 820 printf("R0x%x F0x%x A0x%x I0x%x\n", 821 sc->sc_stat.c_ref, 822 sc->sc_stat.c_fef, 823 sc->sc_stat.c_aef, 824 sc->sc_stat.c_ief); 825 } 826 } else 827 printf("%s: request status failed\n", 828 sc->sc_dev.dv_xname); 829 bp->b_flags |= B_ERROR; 830 bp->b_error = EIO; 831 goto done; 832 } else 833 bp->b_resid = 0; 834 if (sc->sc_flags & CTF_CMD) { 835 switch (sc->sc_cmd) { 836 case MTFSF: 837 sc->sc_flags &= ~(CTF_BEOF|CTF_AEOF); 838 sc->sc_blkno += CTBTOK(sc->sc_resid); 839 ctstart(sc); 840 return; 841 case MTBSF: 842 sc->sc_flags &= ~(CTF_AEOF|CTF_BEOF|CTF_EOT); 843 break; 844 case MTBSR: 845 sc->sc_flags &= ~CTF_BEOF; 846 if (sc->sc_flags & CTF_EOT) { 847 sc->sc_flags |= CTF_AEOF; 848 sc->sc_flags &= ~CTF_EOT; 849 } else if (sc->sc_flags & CTF_AEOF) { 850 sc->sc_flags |= CTF_BEOF; 851 sc->sc_flags &= ~CTF_AEOF; 852 } 853 break; 854 case MTWEOF: 855 sc->sc_flags &= ~CTF_BEOF; 856 if (sc->sc_flags & (CTF_AEOF|CTF_EOT)) { 857 sc->sc_flags |= CTF_EOT; 858 sc->sc_flags &= ~CTF_AEOF; 859 } else 860 sc->sc_flags |= CTF_AEOF; 861 break; 862 case MTREW: 863 case MTOFFL: 864 sc->sc_flags &= ~(CTF_BEOF|CTF_AEOF|CTF_EOT); 865 break; 866 } 867 } else { 868 sc->sc_flags &= ~CTF_AEOF; 869 sc->sc_blkno += CTBTOK(sc->sc_resid); 870 } 871 done: 872 DPRINTF(CDB_FILES, ("ctintr: after flags %x\n", sc->sc_flags)); 873 ctdone(sc, bp); 874 } 875 876 void 877 ctdone(sc, bp) 878 struct ct_softc *sc; 879 struct buf *bp; 880 { 881 882 (void)BUFQ_GET(sc->sc_tab); 883 biodone(bp); 884 gpibrelease(sc->sc_ic, sc->sc_hdl); 885 if (BUFQ_PEEK(sc->sc_tab) == NULL) { 886 sc->sc_active = 0; 887 return; 888 } 889 ctustart(sc); 890 } 891 892 int 893 ctread(dev, uio, flags) 894 dev_t dev; 895 struct uio *uio; 896 int flags; 897 { 898 return (physio(ctstrategy, NULL, dev, B_READ, minphys, uio)); 899 } 900 901 int 902 ctwrite(dev, uio, flags) 903 dev_t dev; 904 struct uio *uio; 905 int flags; 906 { 907 /* XXX: check for hardware write-protect? */ 908 return (physio(ctstrategy, NULL, dev, B_WRITE, minphys, uio)); 909 } 910 911 /*ARGSUSED*/ 912 int 913 ctioctl(dev, cmd, data, flag, p) 914 dev_t dev; 915 u_long cmd; 916 int flag; 917 caddr_t data; 918 struct proc *p; 919 { 920 struct mtop *op; 921 int cnt; 922 923 switch (cmd) { 924 925 case MTIOCTOP: 926 op = (struct mtop *)data; 927 switch(op->mt_op) { 928 929 case MTWEOF: 930 case MTFSF: 931 case MTBSR: 932 case MTBSF: 933 case MTFSR: 934 cnt = op->mt_count; 935 break; 936 937 case MTREW: 938 case MTOFFL: 939 cnt = 1; 940 break; 941 942 default: 943 return (EINVAL); 944 } 945 ctcommand(dev, op->mt_op, cnt); 946 break; 947 948 case MTIOCGET: 949 break; 950 951 default: 952 return (EINVAL); 953 } 954 return (0); 955 } 956 957 void 958 ctaddeof(sc) 959 struct ct_softc *sc; 960 { 961 962 if (sc->sc_eofp == EOFS - 1) 963 sc->sc_eofs[EOFS - 1]++; 964 else { 965 sc->sc_eofp++; 966 if (sc->sc_eofp == EOFS - 1) 967 sc->sc_eofs[EOFS - 1] = EOFS; 968 else 969 /* save blkno */ 970 sc->sc_eofs[sc->sc_eofp] = sc->sc_blkno - 1; 971 } 972 DPRINTF(CDB_BSF, ("%s: add eof pos %d blk %d\n", 973 sc->sc_dev.dv_xname, sc->sc_eofp, 974 sc->sc_eofs[sc->sc_eofp])); 975 } 976
Indexes created Thu Sep 25 08:09:54 GMT 2025