![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to flp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / vax|
Return to flp.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / vax |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: * ! 6: * @(#)flp.c 7.3 (Berkeley) 2/17/90 ! 7: */ ! 8: ! 9: #if VAX780 ! 10: #include "param.h" ! 11: #include "systm.h" ! 12: #include "conf.h" ! 13: #include "user.h" ! 14: #include "buf.h" ! 15: ! 16: #include "cons.h" ! 17: #include "cpu.h" ! 18: #include "flp.h" ! 19: #include "mtpr.h" ! 20: ! 21: struct { ! 22: short fl_state; /* open and busy flags */ ! 23: short fl_active; /* driver state flag */ ! 24: struct buf *fl_buf; /* buffer we're using */ ! 25: unsigned char *fl_xaddr; /* transfer address */ ! 26: short fl_errcnt; ! 27: } fltab; ! 28: ! 29: /*ARGSUSED*/ ! 30: flopen(dev, flag) ! 31: dev_t dev; ! 32: int flag; ! 33: { ! 34: struct buf *geteblk(); ! 35: ! 36: if (cpu != VAX_780) ! 37: return (ENXIO); ! 38: if (fltab.fl_state != 0) ! 39: return (ENXIO); ! 40: fltab.fl_state = FL_OPEN; ! 41: fltab.fl_buf = geteblk(512); ! 42: fltab.fl_active = FL_IDLE; ! 43: return (0); ! 44: } ! 45: ! 46: /*ARGSUSED*/ ! 47: flclose(dev, flag) ! 48: dev_t dev; ! 49: int flag; ! 50: { ! 51: ! 52: brelse(fltab.fl_buf); ! 53: fltab.fl_state = 0; ! 54: } ! 55: ! 56: /*ARGSUSED*/ ! 57: flrw(dev, uio, flag) ! 58: dev_t dev; ! 59: struct uio *uio; ! 60: int flag; ! 61: { ! 62: register struct buf *bp; ! 63: register int i; ! 64: int error; ! 65: ! 66: /* ! 67: * Assume one block read/written for each call - ! 68: * and enforce this by checking for block size of 128. ! 69: * Use the b_blkno field to address ! 70: * physical, 128-byte blocks (u.u_offset/128). ! 71: * This is checked for validity, and is further interpreted as: ! 72: * ! 73: * track# * (sectors/track) + sector # ! 74: */ ! 75: if (uio->uio_resid == 0) ! 76: return (0); ! 77: (void) spl4(); ! 78: while (fltab.fl_state & FL_BUSY) ! 79: sleep((caddr_t)&fltab, PRIBIO); ! 80: fltab.fl_state |= FL_BUSY; ! 81: (void) spl0(); ! 82: ! 83: bp = fltab.fl_buf; ! 84: error = 0; ! 85: while ((i = imin(RXBYSEC, uio->uio_resid)) > 0) { ! 86: bp->b_blkno = uio->uio_offset>>7; ! 87: if (bp->b_blkno >= MAXSEC || (uio->uio_offset & 0177) != 0) { ! 88: error = ENXIO; ! 89: break; ! 90: } ! 91: if (uio->uio_rw == UIO_WRITE) { ! 92: error = uiomove(bp->b_un.b_addr, i, uio); ! 93: if (error) ! 94: break; ! 95: } ! 96: bp->b_flags = uio->uio_rw == UIO_WRITE ? B_WRITE : B_READ; ! 97: (void) spl4(); ! 98: flstart(); ! 99: while ((bp->b_flags & B_DONE) == 0) ! 100: sleep((caddr_t)bp, PRIBIO); ! 101: (void) spl0(); ! 102: if (bp->b_flags & B_ERROR) { ! 103: error = EIO; ! 104: break; ! 105: } ! 106: if (uio->uio_rw == UIO_READ) { ! 107: error = uiomove(bp->b_un.b_addr, i, uio); ! 108: if (error) ! 109: break; ! 110: } ! 111: } ! 112: fltab.fl_state &= ~FL_BUSY; ! 113: wakeup((caddr_t)&fltab); ! 114: return (error); ! 115: } ! 116: ! 117: flstart() ! 118: { ! 119: register struct buf *bp; ! 120: ! 121: bp = fltab.fl_buf; ! 122: fltab.fl_active = FL_MAND; ! 123: fltab.fl_errcnt = 0; ! 124: fltab.fl_xaddr = (unsigned char *) bp->b_un.b_addr; ! 125: bp->b_resid = 0; ! 126: bp->b_bcount = RXBYSEC; /* always transfer a full sector */ ! 127: ! 128: if ((mfpr(TXCS) & TXCS_RDY) == 0) ! 129: /* not ready to receive order */ ! 130: return; ! 131: /* ! 132: * Wake up floppy LSI software with command ! 133: */ ! 134: fltab.fl_active = FL_SEC; ! 135: if ((bp->b_flags&B_READ) == B_READ) ! 136: mtpr(TXDB, FL_RS); ! 137: else ! 138: mtpr(TXDB, FL_WS); ! 139: } ! 140: ! 141: /* ! 142: * See if we want to transmit something ! 143: * to the floppy - and do it ! 144: */ ! 145: conxfl() ! 146: { ! 147: register int databyte; ! 148: register struct buf *bp; ! 149: ! 150: bp = fltab.fl_buf; ! 151: switch (fltab.fl_active) { ! 152: ! 153: case FL_MAND: /* send command */ ! 154: if ((bp->b_flags&B_READ) == B_READ) ! 155: mtpr(TXDB,FL_RS); ! 156: else ! 157: mtpr(TXDB, FL_WS); ! 158: fltab.fl_active = FL_SEC; ! 159: break; ! 160: ! 161: case FL_SEC: /* send sector address */ ! 162: databyte = (int)bp->b_blkno % RXSTRK + 1; ! 163: mtpr(TXDB, FL_DATA | databyte); ! 164: fltab.fl_active = FL_TRACK; ! 165: break; ! 166: ! 167: case FL_TRACK: /* send track address */ ! 168: databyte = (int)bp->b_blkno / RXSTRK; ! 169: mtpr(TXDB , FL_DATA | databyte); ! 170: if ((bp->b_flags&B_READ) == B_READ) ! 171: /* prepare to receive complete */ ! 172: fltab.fl_active = FL_COM; ! 173: else ! 174: /* prepare to send data */ ! 175: fltab.fl_active = FL_DAX; ! 176: break; ! 177: ! 178: case FL_DAX: ! 179: databyte = *(fltab.fl_xaddr++); ! 180: mtpr(TXDB, FL_DATA | databyte); ! 181: if (--bp->b_bcount == 0) ! 182: fltab.fl_active = FL_COM; ! 183: break; ! 184: ! 185: case FL_CAN: /* give cancel order */ ! 186: mtpr(TXDB, FL_CANCEL); ! 187: if (++fltab.fl_errcnt <= FLERRS) { ! 188: /* If error count permits, retry order */ ! 189: fltab.fl_active = FL_MAND; ! 190: bp->b_bcount = RXBYSEC; ! 191: fltab.fl_xaddr = (unsigned char *) bp->b_un.b_addr; ! 192: } else { ! 193: /* ! 194: * We're really stupid today - call it an ! 195: * error and give up ! 196: */ ! 197: bp->b_flags |= B_ERROR | B_DONE; ! 198: bp->b_resid = -RXBYSEC; ! 199: fltab.fl_active = FL_IDLE; ! 200: wakeup((caddr_t)bp); ! 201: } ! 202: } ! 203: } ! 204: ! 205: cnrfl(c) ! 206: int c; ! 207: { ! 208: register int datum; ! 209: register struct buf *bp; ! 210: ! 211: datum = c; ! 212: bp = fltab.fl_buf; ! 213: if (datum == FL_PERR) { ! 214: /* ! 215: * Got a protocol error - cancel the ! 216: * current function and try again if error count isn't ! 217: * too great. First, though, make sure that an actual ! 218: * transaction is in progress (so a spurious error from ! 219: * the LSI won't screw us up too much! ! 220: */ ! 221: if (fltab.fl_active != FL_IDLE) ! 222: fltab.fl_active = FL_CAN; ! 223: } else switch(fltab.fl_active ) { ! 224: ! 225: case FL_DAR: /* expecting a datum */ ! 226: if ((c&RXDB_ID) != FL_DATA) ! 227: goto error; ! 228: *(fltab.fl_xaddr++) = (c & RXDB_DATA); ! 229: if (--bp->b_bcount==0) { ! 230: fltab.fl_active = FL_IDLE; ! 231: bp->b_flags |= B_DONE; ! 232: wakeup((caddr_t)bp); ! 233: } ! 234: break; ! 235: ! 236: case FL_COM: /* expecting a "function complete" */ ! 237: if ((c&RXDB_ID)!= FL_FFC || (c&FL_ERR) == FL_ERR){ ! 238: error: ! 239: bp->b_flags |= B_ERROR | B_DONE; ! 240: bp->b_resid = -bp->b_bcount; ! 241: fltab.fl_active = FL_IDLE; ! 242: wakeup((caddr_t)bp); ! 243: } else if ((bp->b_flags&B_READ) == B_READ) ! 244: /* got function complete, now get data */ ! 245: fltab.fl_active = FL_DAR; ! 246: else { ! 247: /* got function complete on write - finish up */ ! 248: fltab.fl_active = FL_IDLE; ! 249: bp->b_flags |= B_DONE; ! 250: wakeup((caddr_t)bp); ! 251: } ! 252: break; ! 253: } ! 254: } ! 255: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.