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