![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / tahoevba|
Return to cy.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / tahoevba |
1.1 ! root 1: /* ! 2: * Copyright (c) 1988 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * This code is derived from software contributed to Berkeley by ! 6: * Computer Consoles Inc. ! 7: * ! 8: * Redistribution and use in source and binary forms are permitted ! 9: * provided that the above copyright notice and this paragraph are ! 10: * duplicated in all such forms and that any documentation, ! 11: * advertising materials, and other materials related to such ! 12: * distribution and use acknowledge that the software was developed ! 13: * by the University of California, Berkeley. The name of the ! 14: * University may not be used to endorse or promote products derived ! 15: * from this software without specific prior written permission. ! 16: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 17: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 18: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 19: * ! 20: * @(#)cy.c 7.2 (Berkeley) 6/29/88 ! 21: */ ! 22: ! 23: #include "yc.h" ! 24: #if NCY > 0 ! 25: /* ! 26: * Cipher Tapemaster driver. ! 27: */ ! 28: #define CYDEBUG ! 29: #ifdef CYDEBUG ! 30: int cydebug = 0; ! 31: #define dlog(params) if (cydebug) log params ! 32: #else ! 33: #define dlog(params) /* */ ! 34: #endif ! 35: ! 36: #include "param.h" ! 37: #include "systm.h" ! 38: #include "vm.h" ! 39: #include "buf.h" ! 40: #include "file.h" ! 41: #include "dir.h" ! 42: #include "user.h" ! 43: #include "proc.h" ! 44: #include "signal.h" ! 45: #include "uio.h" ! 46: #include "ioctl.h" ! 47: #include "mtio.h" ! 48: #include "errno.h" ! 49: #include "cmap.h" ! 50: #include "kernel.h" ! 51: #include "syslog.h" ! 52: #include "tty.h" ! 53: ! 54: #include "../tahoe/cpu.h" ! 55: #include "../tahoe/mtpr.h" ! 56: #include "../tahoe/pte.h" ! 57: ! 58: #include "../tahoevba/vbavar.h" ! 59: #define CYERROR ! 60: #include "../tahoevba/cyreg.h" ! 61: ! 62: /* ! 63: * There is a ccybuf per tape controller. ! 64: * It is used as the token to pass to the internal routines ! 65: * to execute tape ioctls, and also acts as a lock on the slaves ! 66: * on the controller, since there is only one per controller. ! 67: * In particular, when the tape is rewinding on close we release ! 68: * the user process but any further attempts to use the tape drive ! 69: * before the rewind completes will hang waiting for ccybuf. ! 70: */ ! 71: struct buf ccybuf[NCY]; ! 72: ! 73: int cyprobe(), cyslave(), cyattach(); ! 74: struct buf ycutab[NYC]; ! 75: short yctocy[NYC]; ! 76: struct vba_ctlr *cyminfo[NCY]; ! 77: struct vba_device *ycdinfo[NYC]; ! 78: long cystd[] = { 0 }; ! 79: struct vba_driver cydriver = ! 80: { cyprobe, cyslave, cyattach, 0, cystd, "yc", ycdinfo, "cy", cyminfo }; ! 81: ! 82: /* bits in minor device */ ! 83: #define YCUNIT(dev) (minor(dev)&03) ! 84: #define CYUNIT(dev) (yctocy[YCUNIT(dev)]) ! 85: #define T_NOREWIND 0x04 ! 86: #define T_1600BPI 0x00 /* pseudo */ ! 87: #define T_3200BPI 0x08 /* unused */ ! 88: ! 89: #define INF 1000000L /* close to infinity */ ! 90: ! 91: /* ! 92: * Software state and shared command areas per controller. ! 93: * ! 94: * The i/o intermediate buffer must be allocated in startup() ! 95: * so its address will fit in 20-bits (YECH!!!!!!!!!!!!!!). ! 96: */ ! 97: struct cy_softc { ! 98: int cy_bs; /* controller's buffer size */ ! 99: struct cyscp *cy_scp; /* system configuration block address */ ! 100: struct cyccb cy_ccb; /* channel control block */ ! 101: struct cyscb cy_scb; /* system configuration block */ ! 102: struct cytpb cy_tpb; /* tape parameter block */ ! 103: struct cytpb cy_nop; /* nop parameter block for cyintr */ ! 104: struct vb_buf cy_rbuf; /* vba resources */ ! 105: } cy_softc[NCY]; ! 106: ! 107: /* ! 108: * Software state per tape transport. ! 109: */ ! 110: struct yc_softc { ! 111: char yc_openf; /* lock against multiple opens */ ! 112: char yc_lastiow; /* last operation was a write */ ! 113: short yc_tact; /* timeout is active */ ! 114: long yc_timo; /* time until timeout expires */ ! 115: u_short yc_control; /* copy of last tpcb.tpcontrol */ ! 116: u_short yc_status; /* copy of last tpcb.tpstatus */ ! 117: u_short yc_resid; /* copy of last bc */ ! 118: u_short yc_dens; /* prototype control word with density info */ ! 119: struct tty *yc_ttyp; /* user's tty for errors */ ! 120: daddr_t yc_blkno; /* block number, for block device tape */ ! 121: daddr_t yc_nxrec; /* position of end of tape, if known */ ! 122: int yc_blksize; /* current tape blocksize estimate */ ! 123: int yc_blks; /* number of I/O operations since open */ ! 124: int yc_softerrs; /* number of soft I/O errors since open */ ! 125: } yc_softc[NYC]; ! 126: ! 127: /* ! 128: * States for vm->um_tab.b_active, the per controller state flag. ! 129: * This is used to sequence control in the driver. ! 130: */ ! 131: #define SSEEK 1 /* seeking */ ! 132: #define SIO 2 /* doing seq i/o */ ! 133: #define SCOM 3 /* sending control command */ ! 134: #define SREW 4 /* sending a rewind */ ! 135: #define SERASE 5 /* erase inter-record gap */ ! 136: #define SERASED 6 /* erased inter-record gap */ ! 137: ! 138: /* there's no way to figure these out dynamically? -- yech */ ! 139: struct cyscp *cyscp[] = ! 140: { (struct cyscp *)0xc0000c06, (struct cyscp *)0xc0000c16 }; ! 141: #define NCYSCP (sizeof (cyscp) / sizeof (cyscp[0])) ! 142: ! 143: cyprobe(reg, vm) ! 144: caddr_t reg; ! 145: struct vba_ctlr *vm; ! 146: { ! 147: register br, cvec; /* must be r12, r11 */ ! 148: register struct cy_softc *cy; ! 149: int ctlr = vm->um_ctlr; ! 150: ! 151: #ifdef lint ! 152: br = 0; cvec = br; br = cvec; ! 153: cyintr(0); ! 154: #endif ! 155: if (badcyaddr(reg+1)) ! 156: return (0); ! 157: if (ctlr > NCYSCP || cyscp[ctlr] == 0) /* XXX */ ! 158: return (0); ! 159: cy = &cy_softc[ctlr]; ! 160: cy->cy_scp = cyscp[ctlr]; /* XXX */ ! 161: /* ! 162: * Tapemaster controller must have interrupt handler ! 163: * disable interrupt, so we'll just kludge things ! 164: * (stupid multibus non-vectored interrupt crud). ! 165: */ ! 166: if (cyinit(ctlr, reg)) { ! 167: uncache(&cy->cy_tpb.tpcount); ! 168: cy->cy_bs = htoms(cy->cy_tpb.tpcount); ! 169: /* ! 170: * Setup nop parameter block for clearing interrupts. ! 171: */ ! 172: cy->cy_nop.tpcmd = CY_NOP; ! 173: cy->cy_nop.tpcontrol = 0; ! 174: /* ! 175: * Allocate page tables. ! 176: */ ! 177: if (cybuf == 0) { ! 178: printf("no cy buffer!!!\n"); ! 179: return (0); ! 180: } ! 181: cy->cy_rbuf.vb_rawbuf = cybuf + ctlr * CYMAXIO; ! 182: if (vbainit(&cy->cy_rbuf, CYMAXIO, VB_20BIT) == 0) { ! 183: printf("cy%d: vbainit failed\n", ctlr); ! 184: return (0); ! 185: } ! 186: ! 187: br = 0x13, cvec = 0x80; /* XXX */ ! 188: return (sizeof (struct cyccb)); ! 189: } else ! 190: return (0); ! 191: } ! 192: ! 193: /* ! 194: * Check to see if a drive is attached to a controller. ! 195: * Since we can only tell that a drive is there if a tape is loaded and ! 196: * the drive is placed online, we always indicate the slave is present. ! 197: */ ! 198: cyslave(vi, addr) ! 199: struct vba_device *vi; ! 200: caddr_t addr; ! 201: { ! 202: ! 203: #ifdef lint ! 204: vi = vi; addr = addr; ! 205: #endif ! 206: return (1); ! 207: } ! 208: ! 209: cyattach(vi) ! 210: struct vba_device *vi; ! 211: { ! 212: register struct cy_softc *cy; ! 213: int ctlr = vi->ui_mi->um_ctlr; ! 214: ! 215: yctocy[vi->ui_unit] = ctlr; ! 216: cy = &cy_softc[ctlr]; ! 217: if (vi->ui_slave == 0 && cy->cy_bs) ! 218: printf("; %dkb buffer", cy->cy_bs/1024); ! 219: } ! 220: ! 221: /* ! 222: * Initialize the controller after a controller reset or ! 223: * during autoconfigure. All of the system control blocks ! 224: * are initialized and the controller is asked to configure ! 225: * itself for later use. ! 226: */ ! 227: cyinit(ctlr, addr) ! 228: int ctlr; ! 229: register caddr_t addr; ! 230: { ! 231: register struct cy_softc *cy = &cy_softc[ctlr]; ! 232: register int *pte; ! 233: ! 234: /* ! 235: * Initialize the system configuration pointer. ! 236: */ ! 237: /* make kernel writable */ ! 238: pte = (int *)&Sysmap[btop((int)cy->cy_scp &~ KERNBASE)]; ! 239: *pte &= ~PG_PROT; *pte |= PG_KW; ! 240: mtpr(TBIS, cy->cy_scp); ! 241: /* load the correct values in the scp */ ! 242: cy->cy_scp->csp_buswidth = CSP_16BITS; ! 243: cyldmba(cy->cy_scp->csp_scb, (caddr_t)&cy->cy_scb); ! 244: /* put it back to read-only */ ! 245: *pte &= ~PG_PROT; *pte |= PG_KR; ! 246: mtpr(TBIS, cy->cy_scp); ! 247: ! 248: /* ! 249: * Init system configuration block. ! 250: */ ! 251: cy->cy_scb.csb_fixed = CSB_FIXED; ! 252: /* set pointer to the channel control block */ ! 253: cyldmba(cy->cy_scb.csb_ccb, (caddr_t)&cy->cy_ccb); ! 254: ! 255: /* ! 256: * Initialize the chanel control block. ! 257: */ ! 258: cy->cy_ccb.cbcw = CBCW_CLRINT; ! 259: cy->cy_ccb.cbgate = GATE_OPEN; ! 260: /* set pointer to the tape parameter block */ ! 261: cyldmba(cy->cy_ccb.cbtpb, (caddr_t)&cy->cy_tpb); ! 262: ! 263: /* ! 264: * Issue a nop cmd and get the internal buffer size for buffered i/o. ! 265: */ ! 266: cy->cy_tpb.tpcmd = CY_NOP; ! 267: cy->cy_tpb.tpcontrol = CYCW_16BITS; ! 268: cy->cy_ccb.cbgate = GATE_CLOSED; ! 269: CY_GO(addr); ! 270: if (cywait(&cy->cy_ccb) || (cy->cy_tpb.tpstatus&CYS_ERR)) { ! 271: uncache(&cy->cy_tpb.tpstatus); ! 272: printf("cy%d: timeout or err during init, status=%b\n", ctlr, ! 273: cy->cy_tpb.tpstatus, CYS_BITS); ! 274: return (0); ! 275: } ! 276: cy->cy_tpb.tpcmd = CY_CONFIG; ! 277: cy->cy_tpb.tpcontrol = CYCW_16BITS; ! 278: cy->cy_ccb.cbgate = GATE_CLOSED; ! 279: CY_GO(addr); ! 280: if (cywait(&cy->cy_ccb) || (cy->cy_tpb.tpstatus&CYS_ERR)) { ! 281: uncache(&cy->cy_tpb.tpstatus); ! 282: printf("cy%d: configuration failure, status=%b\n", ctlr, ! 283: cy->cy_tpb.tpstatus, CYS_BITS); ! 284: return (0); ! 285: } ! 286: return (1); ! 287: } ! 288: ! 289: int cytimer(); ! 290: /* ! 291: * Open the device. Tapes are unique open ! 292: * devices, so we refuse if it is already open. ! 293: * We also check that a tape is available, and ! 294: * don't block waiting here; if you want to wait ! 295: * for a tape you should timeout in user code. ! 296: */ ! 297: cyopen(dev, flag) ! 298: dev_t dev; ! 299: register int flag; ! 300: { ! 301: register int ycunit; ! 302: register struct vba_device *vi; ! 303: register struct yc_softc *yc; ! 304: ! 305: ycunit = YCUNIT(dev); ! 306: if (ycunit >= NYC || (vi = ycdinfo[ycunit]) == 0 || vi->ui_alive == 0) ! 307: return (ENXIO); ! 308: if ((yc = &yc_softc[ycunit])->yc_openf) ! 309: return (EBUSY); ! 310: yc->yc_openf = 1; ! 311: #define PACKUNIT(vi) \ ! 312: (((vi->ui_slave&1)<<11)|((vi->ui_slave&2)<<9)|((vi->ui_slave&4)>>2)) ! 313: /* no way to select density */ ! 314: yc->yc_dens = PACKUNIT(vi)|CYCW_IE|CYCW_16BITS; ! 315: if (yc->yc_tact == 0) { ! 316: yc->yc_timo = INF; ! 317: yc->yc_tact = 1; ! 318: timeout(cytimer, (caddr_t)dev, 5*hz); ! 319: } ! 320: cycommand(dev, CY_SENSE, 1); ! 321: if ((yc->yc_status&CYS_OL) == 0) { /* not on-line */ ! 322: uprintf("cy%d: not online\n", ycunit); ! 323: yc->yc_openf = 0; ! 324: return (EIO); ! 325: } ! 326: if ((flag&FWRITE) && (yc->yc_status&CYS_WP)) { ! 327: uprintf("cy%d: no write ring\n", ycunit); ! 328: yc->yc_openf = 0; ! 329: return (EIO); ! 330: } ! 331: yc->yc_blkno = (daddr_t)0; ! 332: yc->yc_nxrec = INF; ! 333: yc->yc_lastiow = 0; ! 334: yc->yc_blksize = CYMAXIO; /* guess > 0 */ ! 335: yc->yc_blks = 0; ! 336: yc->yc_softerrs = 0; ! 337: yc->yc_ttyp = u.u_ttyp; ! 338: return (0); ! 339: } ! 340: ! 341: /* ! 342: * Close tape device. ! 343: * ! 344: * If tape was open for writing or last operation was a write, ! 345: * then write two EOF's and backspace over the last one. ! 346: * Unless this is a non-rewinding special file, rewind the tape. ! 347: * Make the tape available to others. ! 348: */ ! 349: cyclose(dev, flag) ! 350: dev_t dev; ! 351: int flag; ! 352: { ! 353: struct yc_softc *yc = &yc_softc[YCUNIT(dev)]; ! 354: ! 355: if (flag == FWRITE || (flag&FWRITE) && yc->yc_lastiow) { ! 356: cycommand(dev, CY_WEOF, 1); /* can't use count with WEOF */ ! 357: cycommand(dev, CY_WEOF, 1); ! 358: cycommand(dev, CY_SREV, 1); ! 359: } ! 360: if ((minor(dev)&T_NOREWIND) == 0) ! 361: /* ! 362: * 0 count means don't hang waiting for rewind complete ! 363: * rather ccybuf stays busy until the operation completes ! 364: * preventing further opens from completing by preventing ! 365: * a CY_SENSE from completing. ! 366: */ ! 367: cycommand(dev, CY_REW, 0); ! 368: if (yc->yc_blks > 10 && yc->yc_softerrs > yc->yc_blks / 10) ! 369: log(LOG_INFO, "yc%d: %d soft errors in %d blocks\n", ! 370: YCUNIT(dev), yc->yc_softerrs, yc->yc_blks); ! 371: dlog((LOG_INFO, "%d soft errors in %d blocks\n", ! 372: yc->yc_softerrs, yc->yc_blks)); ! 373: yc->yc_openf = 0; ! 374: return (0); ! 375: } ! 376: ! 377: /* ! 378: * Execute a command on the tape drive a specified number of times. ! 379: */ ! 380: cycommand(dev, com, count) ! 381: dev_t dev; ! 382: int com, count; ! 383: { ! 384: register struct buf *bp; ! 385: int s; ! 386: ! 387: bp = &ccybuf[CYUNIT(dev)]; ! 388: s = spl3(); ! 389: dlog((LOG_INFO, "cycommand(%o, %x, %d), b_flags %x\n", ! 390: dev, com, count, bp->b_flags)); ! 391: while (bp->b_flags&B_BUSY) { ! 392: /* ! 393: * This special check is because B_BUSY never ! 394: * gets cleared in the non-waiting rewind case. ! 395: */ ! 396: if (bp->b_repcnt == 0 && (bp->b_flags&B_DONE)) ! 397: break; ! 398: bp->b_flags |= B_WANTED; ! 399: sleep((caddr_t)bp, PRIBIO); ! 400: } ! 401: bp->b_flags = B_BUSY|B_READ; ! 402: splx(s); ! 403: bp->b_dev = dev; ! 404: bp->b_repcnt = count; ! 405: bp->b_command = com; ! 406: bp->b_blkno = 0; ! 407: cystrategy(bp); ! 408: /* ! 409: * In case of rewind from close; don't wait. ! 410: * This is the only case where count can be 0. ! 411: */ ! 412: if (count == 0) ! 413: return; ! 414: biowait(bp); ! 415: if (bp->b_flags&B_WANTED) ! 416: wakeup((caddr_t)bp); ! 417: bp->b_flags &= B_ERROR; ! 418: } ! 419: ! 420: cystrategy(bp) ! 421: register struct buf *bp; ! 422: { ! 423: int ycunit = YCUNIT(bp->b_dev); ! 424: register struct vba_ctlr *vm; ! 425: register struct buf *dp; ! 426: int s; ! 427: ! 428: /* ! 429: * Put transfer at end of unit queue. ! 430: */ ! 431: dlog((LOG_INFO, "cystrategy(%o, %x)\n", bp->b_dev, bp->b_command)); ! 432: dp = &ycutab[ycunit]; ! 433: bp->av_forw = NULL; ! 434: vm = ycdinfo[ycunit]->ui_mi; ! 435: /* BEGIN GROT */ ! 436: if (bp->b_flags & B_RAW) { ! 437: if (bp->b_bcount >= CYMAXIO) { ! 438: uprintf("cy%d: i/o size too large\n", vm->um_ctlr); ! 439: bp->b_error = EINVAL; ! 440: bp->b_resid = bp->b_bcount; ! 441: bp->b_flags |= B_ERROR; ! 442: biodone(bp); ! 443: return; ! 444: } ! 445: } ! 446: /* END GROT */ ! 447: s = spl3(); ! 448: if (dp->b_actf == NULL) { ! 449: dp->b_actf = bp; ! 450: /* ! 451: * Transport not already active... ! 452: * put at end of controller queue. ! 453: */ ! 454: dp->b_forw = NULL; ! 455: if (vm->um_tab.b_actf == NULL) ! 456: vm->um_tab.b_actf = dp; ! 457: else ! 458: vm->um_tab.b_actl->b_forw = dp; ! 459: } else ! 460: dp->b_actl->av_forw = bp; ! 461: dp->b_actl = bp; ! 462: /* ! 463: * If the controller is not busy, get it going. ! 464: */ ! 465: if (vm->um_tab.b_active == 0) ! 466: cystart(vm); ! 467: splx(s); ! 468: } ! 469: ! 470: /* ! 471: * Start activity on a cy controller. ! 472: */ ! 473: cystart(vm) ! 474: register struct vba_ctlr *vm; ! 475: { ! 476: register struct buf *bp, *dp; ! 477: register struct yc_softc *yc; ! 478: register struct cy_softc *cy; ! 479: int ycunit; ! 480: daddr_t blkno; ! 481: ! 482: dlog((LOG_INFO, "cystart()\n")); ! 483: /* ! 484: * Look for an idle transport on the controller. ! 485: */ ! 486: loop: ! 487: if ((dp = vm->um_tab.b_actf) == NULL) ! 488: return; ! 489: if ((bp = dp->b_actf) == NULL) { ! 490: vm->um_tab.b_actf = dp->b_forw; ! 491: goto loop; ! 492: } ! 493: ycunit = YCUNIT(bp->b_dev); ! 494: yc = &yc_softc[ycunit]; ! 495: cy = &cy_softc[CYUNIT(bp->b_dev)]; ! 496: /* ! 497: * Default is that last command was NOT a write command; ! 498: * if we do a write command we will notice this in cyintr(). ! 499: */ ! 500: yc->yc_lastiow = 0; ! 501: if (yc->yc_openf < 0 || ! 502: (bp->b_command != CY_SENSE && (cy->cy_tpb.tpstatus&CYS_OL) == 0)) { ! 503: /* ! 504: * Have had a hard error on a non-raw tape ! 505: * or the tape unit is now unavailable (e.g. ! 506: * taken off line). ! 507: */ ! 508: dlog((LOG_INFO, "openf %d command %x status %b\n", ! 509: yc->yc_openf, bp->b_command, cy->cy_tpb.tpstatus, CYS_BITS)); ! 510: bp->b_flags |= B_ERROR; ! 511: goto next; ! 512: } ! 513: if (bp == &ccybuf[CYUNIT(bp->b_dev)]) { ! 514: /* ! 515: * Execute control operation with the specified count. ! 516: * ! 517: * Set next state; give 5 minutes to complete ! 518: * rewind or file mark search, or 10 seconds per ! 519: * iteration (minimum 60 seconds and max 5 minutes) ! 520: * to complete other ops. ! 521: */ ! 522: if (bp->b_command == CY_REW) { ! 523: vm->um_tab.b_active = SREW; ! 524: yc->yc_timo = 5*60; ! 525: } else if (bp->b_command == CY_FSF || ! 526: bp->b_command == CY_BSF) { ! 527: vm->um_tab.b_active = SCOM; ! 528: yc->yc_timo = 5*60; ! 529: } else { ! 530: vm->um_tab.b_active = SCOM; ! 531: yc->yc_timo = imin(imax(10*(int)bp->b_repcnt,60),5*60); ! 532: } ! 533: cy->cy_tpb.tprec = htoms(bp->b_repcnt); ! 534: dlog((LOG_INFO, "bpcmd ")); ! 535: goto dobpcmd; ! 536: } ! 537: /* ! 538: * For raw I/O, save the current block ! 539: * number in case we have to retry. ! 540: */ ! 541: if (bp->b_flags & B_RAW) { ! 542: if (vm->um_tab.b_errcnt == 0) { ! 543: yc->yc_blkno = bp->b_blkno; ! 544: yc->yc_nxrec = yc->yc_blkno + 1; ! 545: } ! 546: } else { ! 547: /* ! 548: * Handle boundary cases for operation ! 549: * on non-raw tapes. ! 550: */ ! 551: if (bp->b_blkno > yc->yc_nxrec) { ! 552: /* ! 553: * Can't read past known end-of-file. ! 554: */ ! 555: bp->b_flags |= B_ERROR; ! 556: bp->b_error = ENXIO; ! 557: goto next; ! 558: } ! 559: if (bp->b_blkno == yc->yc_nxrec && bp->b_flags&B_READ) { ! 560: /* ! 561: * Reading at end of file returns 0 bytes. ! 562: */ ! 563: bp->b_resid = bp->b_bcount; ! 564: clrbuf(bp); ! 565: goto next; ! 566: } ! 567: if ((bp->b_flags&B_READ) == 0) ! 568: /* ! 569: * Writing sets EOF. ! 570: */ ! 571: yc->yc_nxrec = bp->b_blkno + 1; ! 572: } ! 573: if ((blkno = yc->yc_blkno) == bp->b_blkno) { ! 574: caddr_t addr; ! 575: int cmd; ! 576: ! 577: /* ! 578: * Choose the appropriate i/o command based on the ! 579: * transfer size, the estimated block size, ! 580: * and the controller's internal buffer size. ! 581: * If the request length is longer than the tape ! 582: * block length, a buffered read will fail, ! 583: * thus, we request at most the size that we expect. ! 584: * We then check for larger records when the read completes. ! 585: * If we're retrying a read on a raw device because ! 586: * the original try was a buffer request which failed ! 587: * due to a record length error, then we force the use ! 588: * of the raw controller read (YECH!!!!). ! 589: */ ! 590: if (bp->b_flags&B_READ) { ! 591: if (yc->yc_blksize <= cy->cy_bs && ! 592: vm->um_tab.b_errcnt == 0) ! 593: cmd = CY_BRCOM; ! 594: else ! 595: cmd = CY_RCOM; ! 596: } else { ! 597: /* ! 598: * On write error retries erase the ! 599: * inter-record gap before rewriting. ! 600: */ ! 601: if (vm->um_tab.b_errcnt && ! 602: vm->um_tab.b_active != SERASED) { ! 603: vm->um_tab.b_active = SERASE; ! 604: bp->b_command = CY_ERASE; ! 605: yc->yc_timo = 60; ! 606: goto dobpcmd; ! 607: } ! 608: cmd = (bp->b_bcount > cy->cy_bs) ? CY_WCOM : CY_BWCOM; ! 609: } ! 610: vm->um_tab.b_active = SIO; ! 611: addr = (caddr_t)vbasetup(bp, &cy->cy_rbuf, 1); ! 612: cy->cy_tpb.tpcmd = cmd; ! 613: cy->cy_tpb.tpcontrol = yc->yc_dens; ! 614: if (cmd == CY_RCOM || cmd == CY_WCOM) ! 615: cy->cy_tpb.tpcontrol |= CYCW_LOCK; ! 616: cy->cy_tpb.tpstatus = 0; ! 617: cy->cy_tpb.tpcount = 0; ! 618: cyldmba(cy->cy_tpb.tpdata, (caddr_t)addr); ! 619: cy->cy_tpb.tprec = 0; ! 620: if (cmd == CY_BRCOM) ! 621: cy->cy_tpb.tpsize = htoms(imin(yc->yc_blksize, ! 622: (int)bp->b_bcount)); ! 623: else ! 624: cy->cy_tpb.tpsize = htoms(bp->b_bcount); ! 625: cyldmba(cy->cy_tpb.tplink, (caddr_t)0); ! 626: do ! 627: uncache(&cy->cy_ccb.cbgate); ! 628: while (cy->cy_ccb.cbgate == GATE_CLOSED); ! 629: cyldmba(cy->cy_ccb.cbtpb, (caddr_t)&cy->cy_tpb); ! 630: cy->cy_ccb.cbcw = CBCW_IE; ! 631: cy->cy_ccb.cbgate = GATE_CLOSED; ! 632: dlog((LOG_INFO, "CY_GO(%x) cmd %x control %x size %d\n", ! 633: vm->um_addr, cy->cy_tpb.tpcmd, cy->cy_tpb.tpcontrol, ! 634: htoms(cy->cy_tpb.tpsize))); ! 635: CY_GO(vm->um_addr); ! 636: return; ! 637: } ! 638: /* ! 639: * Tape positioned incorrectly; set to seek forwards ! 640: * or backwards to the correct spot. This happens ! 641: * for raw tapes only on error retries. ! 642: */ ! 643: vm->um_tab.b_active = SSEEK; ! 644: if (blkno < bp->b_blkno) { ! 645: bp->b_command = CY_SFORW; ! 646: cy->cy_tpb.tprec = htoms(bp->b_blkno - blkno); ! 647: } else { ! 648: bp->b_command = CY_SREV; ! 649: cy->cy_tpb.tprec = htoms(blkno - bp->b_blkno); ! 650: } ! 651: yc->yc_timo = imin(imax((int)(10 * htoms(cy->cy_tpb.tprec)), 60), 5*60); ! 652: dobpcmd: ! 653: /* ! 654: * Do the command in bp. Reverse direction commands ! 655: * are indicated by having CYCW_REV or'd into their ! 656: * value. For these we must set the appropriate bit ! 657: * in the control field. ! 658: */ ! 659: if (bp->b_command&CYCW_REV) { ! 660: cy->cy_tpb.tpcmd = bp->b_command &~ CYCW_REV; ! 661: cy->cy_tpb.tpcontrol = yc->yc_dens | CYCW_REV; ! 662: dlog((LOG_INFO, "cmd %x control %x\n", cy->cy_tpb.tpcmd, cy->cy_tpb.tpcontrol)); ! 663: } else { ! 664: cy->cy_tpb.tpcmd = bp->b_command; ! 665: cy->cy_tpb.tpcontrol = yc->yc_dens; ! 666: dlog((LOG_INFO, "cmd %x control %x\n", cy->cy_tpb.tpcmd, cy->cy_tpb.tpcontrol)); ! 667: } ! 668: cy->cy_tpb.tpstatus = 0; ! 669: cy->cy_tpb.tpcount = 0; ! 670: cyldmba(cy->cy_tpb.tplink, (caddr_t)0); ! 671: do ! 672: uncache(&cy->cy_ccb.cbgate); ! 673: while (cy->cy_ccb.cbgate == GATE_CLOSED); ! 674: cyldmba(cy->cy_ccb.cbtpb, (caddr_t)&cy->cy_tpb); ! 675: cy->cy_ccb.cbcw = CBCW_IE; ! 676: cy->cy_ccb.cbgate = GATE_CLOSED; ! 677: dlog((LOG_INFO, "CY_GO(%x) cmd %x control %x rec %d\n", ! 678: vm->um_addr, cy->cy_tpb.tpcmd, cy->cy_tpb.tpcontrol, ! 679: htoms(cy->cy_tpb.tprec))); ! 680: CY_GO(vm->um_addr); ! 681: return; ! 682: next: ! 683: /* ! 684: * Done with this operation due to error or the ! 685: * fact that it doesn't do anything. ! 686: * Dequeue the transfer and continue ! 687: * processing this slave. ! 688: */ ! 689: vm->um_tab.b_errcnt = 0; ! 690: dp->b_actf = bp->av_forw; ! 691: biodone(bp); ! 692: goto loop; ! 693: } ! 694: ! 695: /* ! 696: * Cy interrupt routine. ! 697: */ ! 698: cyintr(cyunit) ! 699: int cyunit; ! 700: { ! 701: struct buf *dp; ! 702: register struct buf *bp; ! 703: register struct vba_ctlr *vm = cyminfo[cyunit]; ! 704: register struct cy_softc *cy; ! 705: register struct yc_softc *yc; ! 706: int err; ! 707: register state; ! 708: ! 709: dlog((LOG_INFO, "cyintr(%d)\n", cyunit)); ! 710: /* ! 711: * First, turn off the interrupt from the controller ! 712: * (device uses Multibus non-vectored interrupts...yech). ! 713: */ ! 714: cy = &cy_softc[vm->um_ctlr]; ! 715: cy->cy_ccb.cbcw = CBCW_CLRINT; ! 716: cyldmba(cy->cy_ccb.cbtpb, (caddr_t)&cy->cy_nop); ! 717: cy->cy_ccb.cbgate = GATE_CLOSED; ! 718: CY_GO(vm->um_addr); ! 719: if ((dp = vm->um_tab.b_actf) == NULL) { ! 720: dlog((LOG_ERR, "cy%d: stray interrupt", vm->um_ctlr)); ! 721: return; ! 722: } ! 723: bp = dp->b_actf; ! 724: cy = &cy_softc[cyunit]; ! 725: cyuncachetpb(cy); ! 726: yc = &yc_softc[YCUNIT(bp->b_dev)]; ! 727: /* ! 728: * If last command was a rewind and tape is ! 729: * still moving, wait for the operation to complete. ! 730: */ ! 731: if (vm->um_tab.b_active == SREW) { ! 732: vm->um_tab.b_active = SCOM; ! 733: if ((cy->cy_tpb.tpstatus&CYS_RDY) == 0) { ! 734: yc->yc_timo = 5*60; /* 5 minutes */ ! 735: return; ! 736: } ! 737: } ! 738: /* ! 739: * An operation completed...record status. ! 740: */ ! 741: yc->yc_timo = INF; ! 742: yc->yc_control = cy->cy_tpb.tpcontrol; ! 743: yc->yc_status = cy->cy_tpb.tpstatus; ! 744: yc->yc_resid = bp->b_bcount - htoms(cy->cy_tpb.tpcount); ! 745: dlog((LOG_INFO, "cmd %x control %b status %b resid %d\n", ! 746: cy->cy_tpb.tpcmd, yc->yc_control, CYCW_BITS, ! 747: yc->yc_status, CYS_BITS, yc->yc_resid)); ! 748: if ((bp->b_flags&B_READ) == 0) ! 749: yc->yc_lastiow = 1; ! 750: state = vm->um_tab.b_active; ! 751: vm->um_tab.b_active = 0; ! 752: /* ! 753: * Check for errors. ! 754: */ ! 755: if (cy->cy_tpb.tpstatus&CYS_ERR) { ! 756: err = cy->cy_tpb.tpstatus&CYS_ERR; ! 757: dlog((LOG_INFO, "error %d\n", err)); ! 758: /* ! 759: * If we hit the end of tape file, update our position. ! 760: */ ! 761: if (err == CYER_FM) { ! 762: yc->yc_status |= CYS_FM; ! 763: state = SCOM; /* force completion */ ! 764: cyseteof(bp); /* set blkno and nxrec */ ! 765: goto opdone; ! 766: } ! 767: /* ! 768: * Fix up errors which occur due to backspacing over ! 769: * the beginning of the tape. ! 770: */ ! 771: if (err == CYER_BOT && cy->cy_tpb.tpcontrol&CYCW_REV) { ! 772: yc->yc_status |= CYS_BOT; ! 773: goto ignoreerr; ! 774: } ! 775: /* ! 776: * If we were reading raw tape and the only error was that the ! 777: * record was too long, then we don't consider this an error. ! 778: */ ! 779: if ((bp->b_flags & (B_READ|B_RAW)) == (B_READ|B_RAW) && ! 780: err == CYER_STROBE) { ! 781: /* ! 782: * Retry reads with the command changed to ! 783: * a raw read if necessary. Setting b_errcnt ! 784: * here causes cystart (above) to force a CY_RCOM. ! 785: */ ! 786: if (cy->cy_tpb.tpcmd == CY_BRCOM && ! 787: vm->um_tab.b_errcnt++ == 0) { ! 788: yc->yc_blkno++; ! 789: goto opcont; ! 790: } else ! 791: goto ignoreerr; ! 792: } ! 793: /* ! 794: * If error is not hard, and this was an i/o operation ! 795: * retry up to 8 times. ! 796: */ ! 797: if (state == SIO && (CYMASK(err) & ! 798: ((bp->b_flags&B_READ) ? CYER_RSOFT : CYER_WSOFT))) { ! 799: if (++vm->um_tab.b_errcnt < 7) { ! 800: yc->yc_blkno++; ! 801: goto opcont; ! 802: } ! 803: } else ! 804: /* ! 805: * Hard or non-i/o errors on non-raw tape ! 806: * cause it to close. ! 807: */ ! 808: if ((bp->b_flags&B_RAW) == 0 && ! 809: yc->yc_openf > 0) ! 810: yc->yc_openf = -1; ! 811: /* ! 812: * Couldn't recover from error. ! 813: */ ! 814: tprintf(yc->yc_ttyp, ! 815: "yc%d: hard error bn%d status=%b, %s\n", YCUNIT(bp->b_dev), ! 816: bp->b_blkno, yc->yc_status, CYS_BITS, ! 817: (err < NCYERROR) ? cyerror[err] : ""); ! 818: bp->b_flags |= B_ERROR; ! 819: goto opdone; ! 820: } else if (cy->cy_tpb.tpcmd == CY_BRCOM) { ! 821: int reclen = htoms(cy->cy_tpb.tprec); ! 822: ! 823: /* ! 824: * If we did a buffered read, check whether the read ! 825: * was long enough. If we asked the controller for less ! 826: * than the user asked for because the previous record ! 827: * was shorter, update our notion of record size ! 828: * and retry. If the record is longer than the buffer, ! 829: * bump the errcnt so the retry will use direct read. ! 830: */ ! 831: if (reclen > yc->yc_blksize && bp->b_bcount > yc->yc_blksize) { ! 832: yc->yc_blksize = reclen; ! 833: if (reclen > cy->cy_bs) ! 834: vm->um_tab.b_errcnt++; ! 835: yc->yc_blkno++; ! 836: goto opcont; ! 837: } ! 838: } ! 839: /* ! 840: * Advance tape control FSM. ! 841: */ ! 842: ignoreerr: ! 843: /* ! 844: * If we hit a tape mark update our position. ! 845: */ ! 846: if (yc->yc_status&CYS_FM && bp->b_flags&B_READ) { ! 847: cyseteof(bp); ! 848: goto opdone; ! 849: } ! 850: switch (state) { ! 851: ! 852: case SIO: ! 853: /* ! 854: * Read/write increments tape block number. ! 855: */ ! 856: yc->yc_blkno++; ! 857: yc->yc_blks++; ! 858: if (vm->um_tab.b_errcnt || yc->yc_status & CYS_CR) ! 859: yc->yc_softerrs++; ! 860: yc->yc_blksize = htoms(cy->cy_tpb.tpcount); ! 861: dlog((LOG_ERR, "blocksize %d", yc->yc_blksize)); ! 862: goto opdone; ! 863: ! 864: case SCOM: ! 865: /* ! 866: * For forward/backward space record update current position. ! 867: */ ! 868: if (bp == &ccybuf[CYUNIT(bp->b_dev)]) ! 869: switch ((int)bp->b_command) { ! 870: ! 871: case CY_SFORW: ! 872: yc->yc_blkno -= bp->b_repcnt; ! 873: break; ! 874: ! 875: case CY_SREV: ! 876: yc->yc_blkno += bp->b_repcnt; ! 877: break; ! 878: } ! 879: goto opdone; ! 880: ! 881: case SSEEK: ! 882: yc->yc_blkno = bp->b_blkno; ! 883: goto opcont; ! 884: ! 885: case SERASE: ! 886: /* ! 887: * Completed erase of the inter-record gap due to a ! 888: * write error; now retry the write operation. ! 889: */ ! 890: vm->um_tab.b_active = SERASED; ! 891: goto opcont; ! 892: } ! 893: ! 894: opdone: ! 895: /* ! 896: * Reset error count and remove from device queue. ! 897: */ ! 898: vm->um_tab.b_errcnt = 0; ! 899: dp->b_actf = bp->av_forw; ! 900: /* ! 901: * Save resid and release resources. ! 902: */ ! 903: bp->b_resid = bp->b_bcount - htoms(cy->cy_tpb.tpcount); ! 904: if (bp != &ccybuf[cyunit]) ! 905: vbadone(bp, &cy->cy_rbuf); ! 906: biodone(bp); ! 907: /* ! 908: * Circulate slave to end of controller ! 909: * queue to give other slaves a chance. ! 910: */ ! 911: vm->um_tab.b_actf = dp->b_forw; ! 912: if (dp->b_actf) { ! 913: dp->b_forw = NULL; ! 914: if (vm->um_tab.b_actf == NULL) ! 915: vm->um_tab.b_actf = dp; ! 916: else ! 917: vm->um_tab.b_actl->b_forw = dp; ! 918: } ! 919: if (vm->um_tab.b_actf == 0) ! 920: return; ! 921: opcont: ! 922: cystart(vm); ! 923: } ! 924: ! 925: cytimer(dev) ! 926: int dev; ! 927: { ! 928: register struct yc_softc *yc = &yc_softc[YCUNIT(dev)]; ! 929: int s; ! 930: ! 931: if (yc->yc_openf == 0 && yc->yc_timo == INF) { ! 932: yc->yc_tact = 0; ! 933: return; ! 934: } ! 935: if (yc->yc_timo != INF && (yc->yc_timo -= 5) < 0) { ! 936: printf("yc%d: lost interrupt\n", YCUNIT(dev)); ! 937: yc->yc_timo = INF; ! 938: s = spl3(); ! 939: cyintr(CYUNIT(dev)); ! 940: splx(s); ! 941: } ! 942: timeout(cytimer, (caddr_t)dev, 5*hz); ! 943: } ! 944: ! 945: cyseteof(bp) ! 946: register struct buf *bp; ! 947: { ! 948: register int cyunit = CYUNIT(bp->b_dev); ! 949: register struct cy_softc *cy = &cy_softc[cyunit]; ! 950: register struct yc_softc *yc = &yc_softc[YCUNIT(bp->b_dev)]; ! 951: ! 952: if (bp == &ccybuf[cyunit]) { ! 953: if (yc->yc_blkno > bp->b_blkno) { ! 954: /* reversing */ ! 955: yc->yc_nxrec = bp->b_blkno - htoms(cy->cy_tpb.tpcount); ! 956: yc->yc_blkno = yc->yc_nxrec; ! 957: } else { ! 958: yc->yc_blkno = bp->b_blkno + htoms(cy->cy_tpb.tpcount); ! 959: yc->yc_nxrec = yc->yc_blkno - 1; ! 960: } ! 961: return; ! 962: } ! 963: /* eof on read */ ! 964: yc->yc_nxrec = bp->b_blkno; ! 965: } ! 966: ! 967: /*ARGSUSED*/ ! 968: cyioctl(dev, cmd, data, flag) ! 969: caddr_t data; ! 970: dev_t dev; ! 971: { ! 972: int ycunit = YCUNIT(dev); ! 973: register struct yc_softc *yc = &yc_softc[ycunit]; ! 974: register struct buf *bp = &ccybuf[CYUNIT(dev)]; ! 975: register callcount; ! 976: int fcount, op; ! 977: struct mtop *mtop; ! 978: struct mtget *mtget; ! 979: /* we depend of the values and order of the MT codes here */ ! 980: static cyops[] = ! 981: {CY_WEOF,CY_FSF,CY_BSF,CY_SFORW,CY_SREV,CY_REW,CY_OFFL,CY_SENSE}; ! 982: ! 983: switch (cmd) { ! 984: ! 985: case MTIOCTOP: /* tape operation */ ! 986: mtop = (struct mtop *)data; ! 987: switch (op = mtop->mt_op) { ! 988: ! 989: case MTWEOF: ! 990: callcount = mtop->mt_count; ! 991: fcount = 1; ! 992: break; ! 993: ! 994: case MTFSR: case MTBSR: ! 995: callcount = 1; ! 996: fcount = mtop->mt_count; ! 997: break; ! 998: ! 999: case MTFSF: case MTBSF: ! 1000: callcount = mtop->mt_count; ! 1001: fcount = 1; ! 1002: break; ! 1003: ! 1004: case MTREW: case MTOFFL: case MTNOP: ! 1005: callcount = 1; ! 1006: fcount = 1; ! 1007: break; ! 1008: ! 1009: default: ! 1010: return (ENXIO); ! 1011: } ! 1012: if (callcount <= 0 || fcount <= 0) ! 1013: return (EINVAL); ! 1014: while (--callcount >= 0) { ! 1015: #ifdef notdef ! 1016: /* ! 1017: * Gagh, this controller is the pits... ! 1018: */ ! 1019: if (op == MTFSF || op == MTBSF) { ! 1020: do ! 1021: cycommand(dev, cyops[op], 1); ! 1022: while ((bp->b_flags&B_ERROR) == 0 && ! 1023: (yc->yc_status&(CYS_EOT|CYS_BOT|CYS_FM)) == 0); ! 1024: } else ! 1025: #endif ! 1026: cycommand(dev, cyops[op], fcount); ! 1027: dlog((LOG_INFO, ! 1028: "cyioctl: status %x, b_flags %x, resid %d\n", ! 1029: yc->yc_status, bp->b_flags, bp->b_resid)); ! 1030: if ((bp->b_flags&B_ERROR) || ! 1031: (yc->yc_status&(CYS_BOT|CYS_EOT))) ! 1032: break; ! 1033: } ! 1034: bp->b_resid = callcount + 1; ! 1035: return (geterror(bp)); ! 1036: ! 1037: case MTIOCGET: ! 1038: cycommand(dev, CY_SENSE, 1); ! 1039: mtget = (struct mtget *)data; ! 1040: mtget->mt_dsreg = yc->yc_status; ! 1041: mtget->mt_erreg = yc->yc_control; ! 1042: mtget->mt_resid = yc->yc_resid; ! 1043: mtget->mt_type = MT_ISCY; ! 1044: break; ! 1045: ! 1046: default: ! 1047: return (ENXIO); ! 1048: } ! 1049: return (0); ! 1050: } ! 1051: ! 1052: /* ! 1053: * Poll until the controller is ready. ! 1054: */ ! 1055: cywait(cp) ! 1056: register struct cyccb *cp; ! 1057: { ! 1058: register int i = 5000; ! 1059: ! 1060: uncache(&cp->cbgate); ! 1061: while (i-- > 0 && cp->cbgate == GATE_CLOSED) { ! 1062: DELAY(1000); ! 1063: uncache(&cp->cbgate); ! 1064: } ! 1065: return (i <= 0); ! 1066: } ! 1067: ! 1068: /* ! 1069: * Load a 20 bit pointer into a Tapemaster pointer. ! 1070: */ ! 1071: cyldmba(reg, value) ! 1072: register u_char *reg; ! 1073: caddr_t value; ! 1074: { ! 1075: register int v = (int)value; ! 1076: ! 1077: *reg++ = v; ! 1078: *reg++ = v >> 8; ! 1079: *reg++ = 0; ! 1080: *reg = (v&0xf0000) >> 12; ! 1081: } ! 1082: ! 1083: /* ! 1084: * Unconditionally reset all controllers to their initial state. ! 1085: */ ! 1086: cyreset(vba) ! 1087: int vba; ! 1088: { ! 1089: register caddr_t addr; ! 1090: register int ctlr; ! 1091: ! 1092: for (ctlr = 0; ctlr < NCY; ctlr++) ! 1093: if (cyminfo[ctlr] && cyminfo[ctlr]->um_vbanum == vba) { ! 1094: addr = cyminfo[ctlr]->um_addr; ! 1095: CY_RESET(addr); ! 1096: if (!cyinit(ctlr, addr)) { ! 1097: printf("cy%d: reset failed\n", ctlr); ! 1098: cyminfo[ctlr] = NULL; ! 1099: } ! 1100: } ! 1101: } ! 1102: ! 1103: cyuncachetpb(cy) ! 1104: struct cy_softc *cy; ! 1105: { ! 1106: register long *lp = (long *)&cy->cy_tpb; ! 1107: register int i; ! 1108: ! 1109: for (i = 0; i < howmany(sizeof (struct cytpb), sizeof (long)); i++) ! 1110: uncache(lp++); ! 1111: } ! 1112: ! 1113: /* ! 1114: * Dump routine. ! 1115: */ ! 1116: #define DUMPREC (32*1024) ! 1117: cydump(dev) ! 1118: dev_t dev; ! 1119: { ! 1120: register struct cy_softc *cy; ! 1121: register int bs, num, start; ! 1122: register caddr_t addr; ! 1123: int unit = CYUNIT(dev), error; ! 1124: ! 1125: if (unit >= NCY || cyminfo[unit] == 0 || ! 1126: (cy = &cy_softc[unit])->cy_bs == 0 || YCUNIT(dev) >= NYC) ! 1127: return (ENXIO); ! 1128: if (cywait(&cy->cy_ccb)) ! 1129: return (EFAULT); ! 1130: #define phys(a) ((caddr_t)((int)(a)&~0xc0000000)) ! 1131: addr = phys(cyminfo[unit]->um_addr); ! 1132: num = maxfree, start = NBPG*2; ! 1133: while (num > 0) { ! 1134: bs = num > btoc(DUMPREC) ? btoc(DUMPREC) : num; ! 1135: error = cydwrite(cy, start, bs, addr); ! 1136: if (error) ! 1137: return (error); ! 1138: start += bs, num -= bs; ! 1139: } ! 1140: cyweof(cy, addr); ! 1141: cyweof(cy, addr); ! 1142: uncache(&cy->cy_tpb); ! 1143: if (cy->cy_tpb.tpstatus&CYS_ERR) ! 1144: return (EIO); ! 1145: cyrewind(cy, addr); ! 1146: return (0); ! 1147: } ! 1148: ! 1149: cydwrite(cy, pf, npf, addr) ! 1150: register struct cy_softc *cy; ! 1151: int pf, npf; ! 1152: caddr_t addr; ! 1153: { ! 1154: ! 1155: cy->cy_tpb.tpcmd = CY_WCOM; ! 1156: cy->cy_tpb.tpcontrol = CYCW_LOCK|CYCW_25IPS|CYCW_16BITS; ! 1157: cy->cy_tpb.tpstatus = 0; ! 1158: cy->cy_tpb.tpsize = htoms(npf*NBPG); ! 1159: cyldmba(cy->cy_tpb.tplink, (caddr_t)0); ! 1160: cyldmba(cy->cy_tpb.tpdata, (caddr_t)(pf*NBPG)); ! 1161: cyldmba(cy->cy_ccb.cbtpb, (caddr_t)&cy->cy_tpb); ! 1162: cy->cy_ccb.cbgate = GATE_CLOSED; ! 1163: CY_GO(addr); ! 1164: if (cywait(&cy->cy_ccb)) ! 1165: return (EFAULT); ! 1166: uncache(&cy->cy_tpb); ! 1167: if (cy->cy_tpb.tpstatus&CYS_ERR) ! 1168: return (EIO); ! 1169: return (0); ! 1170: } ! 1171: ! 1172: cyweof(cy, addr) ! 1173: register struct cy_softc *cy; ! 1174: caddr_t addr; ! 1175: { ! 1176: ! 1177: cy->cy_tpb.tpcmd = CY_WEOF; ! 1178: cy->cy_tpb.tpcount = htoms(1); ! 1179: cy->cy_ccb.cbgate = GATE_CLOSED; ! 1180: CY_GO(addr); ! 1181: (void) cywait(&cy->cy_ccb); ! 1182: } ! 1183: ! 1184: cyrewind(cy, addr) ! 1185: register struct cy_softc *cy; ! 1186: caddr_t addr; ! 1187: { ! 1188: ! 1189: cy->cy_tpb.tpcmd = CY_REW; ! 1190: cy->cy_tpb.tpcount = htoms(1); ! 1191: cy->cy_ccb.cbgate = GATE_CLOSED; ! 1192: CY_GO(addr); ! 1193: (void) cywait(&cy->cy_ccb); ! 1194: } ! 1195: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.