4.3BSD - /usr/src/sys/vaxuba/rx.c

   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:  *	@(#)rx.c	7.1 (Berkeley) 6/5/86
   7:  */
   8: 
   9: #include "rx.h"
  10: #if NFX > 0
  11: /*
  12:  * RX02 floppy disk device driver
  13:  *
  14:  */
  15: 
  16: /*
  17:  * TODO:
  18:  *	- clean up the code for multisector transfers using
  19:  *	  a 'transfer in progress' flag
  20:  *	- Test Deleted Data read/write
  21:  *	- Test error handling/reporting and 'volume valid' stuff
  22:  *
  23:  * 	Note: If the drive subsystem is
  24:  * 	powered off at boot time, the controller won't interrupt!
  25:  */
  26: 
  27: #include "../machine/pte.h"
  28: 
  29: #include "param.h"
  30: #include "buf.h"
  31: #include "systm.h"
  32: #include "conf.h"
  33: #include "errno.h"
  34: #include "time.h"
  35: #include "kernel.h"
  36: #include "uio.h"
  37: #include "file.h"
  38: 
  39: #include "../vax/cpu.h"
  40: #include "../vax/nexus.h"
  41: 
  42: #include "ubavar.h"
  43: #include "ubareg.h"
  44: #include "rxreg.h"
  45: 
  46: #define b_cylin b_resid
  47: 
  48: /* per-controller data */
  49: struct  rx_ctlr {
  50:     int rxc_state;  /* controller state */
  51: #define RXS_READ    1   /* read started	*/
  52: #define RXS_EMPTY   2   /* empty started */
  53: #define RXS_FILL    3   /* fill started	*/
  54: #define RXS_WRITE   4   /* write started */
  55: #define RXS_FORMAT  5   /* format started */
  56: #define RXS_RDSTAT  6   /* status read started */
  57: #define RXS_RDERR   7   /* error read started */
  58: #define RXS_IDLE    8   /* device is idle */
  59:     u_short rxc_rxcs;   /* extended error status */
  60:     u_short rxc_rxdb;
  61:     u_short rxc_rxxt[4];
  62:     int rxc_tocnt;  /* for watchdog routine */
  63: #define RX_MAXTIMEOUT   30  /* # seconds to wait before giving up */
  64: } rx_ctlr[NFX];
  65: 
  66: /* per-drive buffers */
  67: struct buf  rrxbuf[NRX];    /* buffers for raw I/O */
  68: struct buf  erxbuf[NRX];    /* buffers for reading error status */
  69: struct buf  rxutab[NRX];    /* per drive buffers */
  70: 
  71: /* per-drive data */
  72: struct rx_softc {
  73:     int sc_flags;   /* drive status flags */
  74: #define RXF_DIRECT  0x01    /* if set: use direct sector mapping */
  75: #define RXF_TRKONE  0x02    /* if set: start mapping on track 1 */
  76: #define RXF_DBLDEN  0x04    /* use double density */
  77: #define RXF_DEVTYPE 0x07    /* mapping flags */
  78: #define RXF_LOCK    0x10    /* exclusive use */
  79: #define RXF_DDMK    0x20    /* deleted-data mark detected */
  80: #define RXF_USEWDDS 0x40    /* write deleted-data sector */
  81: #define RXF_FORMAT  0x80    /* format in progress */
  82: #define RXF_BAD     0x100   /* drive bad, cannot be used */
  83:     int sc_csbits;  /* constant bits for CS register */
  84:     int sc_open;    /* count number of opens */
  85:     int sc_offset;  /* raw mode kludge to avoid restricting */
  86:                 /* single sector transfers to start on */
  87:                 /* DEV_BSIZE boundaries */
  88:     /*
  89: 	 * The rest of this structure is used to
  90: 	 * store temporaries while simulating multi
  91: 	 * sector transfers
  92: 	 */
  93:     caddr_t sc_uaddr;   /* unibus base address */
  94:     long    sc_bcnt;    /* total transfer count */
  95:     long    sc_resid;   /* no. of bytes left to transfer */
  96: } rx_softc[NRX];
  97: 
  98: struct rxerr {
  99:     short   rxcs;
 100:     short   rxdb;
 101:     short   rxxt[4];    /* error code dump from controller */
 102: } rxerr[NRX];
 103: /* End of per-drive data */
 104: 
 105: struct  uba_device *rxdinfo[NRX];
 106: struct  uba_ctlr *rxminfo[NFX];
 107: 
 108: struct buf *savebp;
 109: 
 110: int rxprobe(), rxslave(), rxattach(), rxdgo(), rxintr(), rxwatch(), rxphys();
 111: u_short rxstd[] = { 0177170, 0177150, 0 };
 112: struct uba_driver fxdriver =
 113:   { rxprobe, rxslave, rxattach, rxdgo, rxstd, "rx", rxdinfo, "fx", rxminfo };
 114: 
 115: int rxwstart;
 116: #define RXUNIT(dev) (minor(dev)>>3)
 117: #define MASKREG(reg)    (reg&0xffff)
 118: 
 119: /* constants related to floppy data capacity */
 120: #define RXSECS  2002                /* # sectors on a floppy */
 121: #define DDSTATE (sc->sc_csbits&RX_DDEN)
 122: #define NBPS    (DDSTATE ? 256 : 128)       /* # bytes per sector */
 123: #define RXSIZE  (DDSTATE ? 512512 : 256256) /* # bytes per disk */
 124: #define SECMASK (DDSTATE ? 0xff : 0x7f)     /* shifted-out bits of offset */
 125: 
 126: #define B_CTRL      0x80000000      /* control (format) request */
 127: #define B_RDSTAT    0x40000000      /* read drive status (open) */
 128: 
 129: /*ARGSUSED*/
 130: rxprobe (reg)
 131:     caddr_t reg;
 132: {
 133:     register int br, cvec;          /* value-result */
 134:     struct rxdevice *rxaddr = (struct rxdevice *)reg;
 135: 
 136: #ifdef lint
 137:     br = 0; cvec = br; br = cvec;
 138:     rxintr(0);
 139: #endif lint
 140:     rxaddr->rxcs = RX_INTR;
 141:     DELAY(10);
 142:     rxaddr->rxcs = 0;
 143:     return (sizeof (*rxaddr));
 144: }
 145: 
 146: rxslave(ui, reg)
 147:     struct uba_device *ui;
 148:     caddr_t reg;
 149: {
 150: 
 151:     ui->ui_dk = 1;
 152:     return (ui->ui_slave == 0 || ui->ui_slave == 1);
 153: }
 154: 
 155: /*ARGSUSED*/
 156: rxattach(ui)
 157:     struct uba_device *ui;
 158: {
 159: 
 160: }
 161: 
 162: /*ARGSUSED1*/
 163: rxopen(dev, flag)
 164:     dev_t dev;
 165: {
 166:     register int unit = RXUNIT(dev);
 167:     register struct rx_softc *sc;
 168:     register struct uba_device *ui;
 169:     struct rx_ctlr *rxc;
 170: 
 171:     if (unit >= NRX || (ui = rxdinfo[unit]) == 0 || ui->ui_alive == 0)
 172:         return (ENXIO);
 173:     sc = &rx_softc[unit];
 174:     if (sc->sc_open == 0 && sc->sc_csbits == 0) {
 175:         struct buf *bp = &erxbuf[unit];
 176:         /*
 177: 		 * lock the device while an open
 178: 		 * is in progress
 179: 		 */
 180:         sc->sc_flags = (minor(dev) & RXF_DEVTYPE) | RXF_LOCK;
 181:         sc->sc_csbits = RX_INTR;
 182:         sc->sc_csbits |= ui->ui_slave == 0 ? RX_DRV0 : RX_DRV1;
 183: 
 184:         bp->b_dev = dev;
 185:         bp->b_flags = B_RDSTAT | B_BUSY;
 186:         bp->b_error = 0;
 187:         bp->b_blkno = 0;
 188:         sc->sc_offset = 0;
 189:         sc->sc_resid  = 0;
 190:         /*
 191: 		 * read device status to determine if
 192: 		 * a floppy is present in the drive and
 193: 		 * what density it is
 194: 		 */
 195:         rxstrategy(bp);
 196:         iowait(bp);
 197:         if (bp->b_flags & B_ERROR) {
 198:             sc->sc_csbits = 0;
 199:             sc->sc_flags &= ~RXF_LOCK;
 200:             return (bp->b_error);
 201:         }
 202:         if (rxwstart++ == 0) {
 203:             rxc = &rx_ctlr[ui->ui_mi->um_ctlr];
 204:             rxc->rxc_tocnt = 0;
 205:             timeout(rxwatch, (caddr_t)0, hz);  /* start watchdog */
 206:         }
 207: #ifdef RXDEBUG
 208:         printf("rxopen: csbits=0x%x\n", sc->sc_csbits);
 209: #endif
 210:         sc->sc_flags &= ~RXF_LOCK;
 211:     } else  {
 212:         if (sc->sc_flags & RXF_LOCK)
 213:             return(EBUSY);
 214:     }
 215:     sc->sc_open = 1;
 216:     return (0);
 217: }
 218: 
 219: /*ARGSUSED1*/
 220: rxclose(dev, flag)
 221:     dev_t dev;
 222: {
 223:     register struct rx_softc *sc = &rx_softc[RXUNIT(dev)];
 224: 
 225:     sc->sc_open = 0;
 226: #ifdef RXDEBUG
 227:     printf("rxclose: dev=0x%x, sc_open=%d\n", dev, sc->sc_open);
 228: #endif
 229: }
 230: 
 231: rxstrategy(bp)
 232:     register struct buf *bp;
 233: {
 234:     struct uba_device *ui;
 235:     register struct buf *dp;
 236:     struct rx_softc *sc;
 237:     int s, unit = RXUNIT(bp->b_dev);
 238: 
 239:     if (unit >= NRX)
 240:         goto bad;
 241:     ui = rxdinfo[unit];
 242:     if (ui == 0 || ui->ui_alive == 0)
 243:         goto bad;
 244:     sc = &rx_softc[unit];
 245:     if (bp->b_blkno < 0 || dbtob(bp->b_blkno) > RXSIZE)
 246:         goto bad;
 247:     if (sc->sc_flags & RXF_BAD) {
 248:         bp->b_error = EIO;
 249:         goto dbad;
 250:     }
 251:     s = spl5();
 252: #ifdef RXDEBUG
 253:     printf("rxstrat: bp=0x%x, fl=0x%x, un=%d, bl=%d, cnt=%d\n",
 254:         bp, bp->b_flags, unit, bp->b_blkno, bp->b_bcount);
 255: #endif
 256:     bp->b_cylin = bp->b_blkno;  /* don't care to calculate trackno */
 257:     dp = &rxutab[unit];
 258:     disksort(dp, bp);
 259:     if (dp->b_active == 0) {
 260:         rxustart(ui);
 261:         bp = &ui->ui_mi->um_tab;
 262:         if (bp->b_actf && bp->b_active == 0)
 263:             rxstart(ui->ui_mi);
 264:     }
 265:     splx(s);
 266:     return;
 267: 
 268: bad:
 269:     bp->b_error = ENXIO;
 270: dbad:
 271:     bp->b_flags |= B_ERROR;
 272:     iodone(bp);
 273:     return;
 274: }
 275: 
 276: /*
 277:  * Unit start routine.
 278:  * Put this unit on the ready queue for the controller
 279:  */
 280: rxustart(ui)
 281:     register struct uba_device *ui;
 282: {
 283:     struct buf *dp = &rxutab[ui->ui_unit];
 284:     struct uba_ctlr *um = ui->ui_mi;
 285: 
 286:     dp->b_forw = NULL;
 287:     if (um->um_tab.b_actf == NULL)
 288:         um->um_tab.b_actf = dp;
 289:     else
 290:         um->um_tab.b_actl->b_forw = dp;
 291:     um->um_tab.b_actl = dp;
 292:     dp->b_active++;
 293: }
 294: /*
 295:  * Sector mapping routine.
 296:  * Two independent sets of choices are available:
 297:  *
 298:  * (a) The first logical sector may either be on track 1 or track 0.
 299:  * (b) The sectors on a track may either be taken in 2-for-1 interleaved
 300:  *	 fashion or directly.
 301:  * This gives a total of four possible mapping schemes.
 302:  *
 303:  * Physical tracks on the RX02 are numbered 0-76.  Physical sectors on
 304:  * each track are numbered 1-26.
 305:  *
 306:  * When interleaving is used, sectors on the first logical track are
 307:  * taken in the order 1, 3, 5, ..., 25, 2, 4, 6, ..., 26.  A skew of
 308:  * six sectors per track is also used (to allow time for the heads to
 309:  * move); hence, the sectors on the second logical track are taken in
 310:  * the order 7, 9, 11, ..., 25, 1, 3, 5, 8, 10, 12, ..., 26, 2, 4, 6;
 311:  * the third logical track starts with sector 13; and so on.
 312:  *
 313:  * When the mapping starts with track 1, track 0 is the last logical
 314:  * track, and this track is always handled directly (without inter-
 315:  * leaving), even when the rest of the disk is interleaved.  (This is
 316:  * still compatible with DEC RT-11, which does not use track 0 at all.)
 317:  */
 318: rxmap(bp, psector, ptrack)
 319:     struct buf *bp;
 320:     int *psector, *ptrack;
 321: {
 322:     register int lt, ls, ptoff;
 323:     struct rx_softc *sc = &rx_softc[RXUNIT(bp->b_dev)];
 324: 
 325:     ls = (dbtob(bp->b_blkno) + (sc->sc_offset - sc->sc_resid)) / NBPS;
 326:     lt = ls / 26;
 327:     ls %= 26;
 328:     /*
 329: 	 * The "physical track offset" (ptoff) takes the
 330: 	 * starting physical track (0 or 1) and the desired
 331: 	 * interleaving into account.  If lt+ptoff >= 77,
 332: 	 * then interleaving is not performed.
 333: 	 */
 334:     ptoff = 0;
 335:     if (sc->sc_flags & RXF_DIRECT)
 336:         ptoff = 77;
 337:     if (sc->sc_flags & RXF_TRKONE)
 338:         ptoff++;
 339:     if (lt + ptoff < 77)
 340:         ls = ((ls << 1) + (ls >= 13) + (6*lt)) % 26;
 341:     *ptrack = (lt + ptoff) % 77;
 342:     *psector = ls + 1;
 343: }
 344: 
 345: /*
 346:  * Controller start routine.
 347:  * Start a new transfer or continue a multisector
 348:  * transfer. If this is a new transfer (dp->b_active == 1)
 349:  * save the start address of the data buffer and the total
 350:  * byte count in the soft control structure. These are
 351:  * restored into the buffer structure when the transfer has
 352:  * been completed, before calling 'iodone'.
 353:  */
 354: rxstart(um)
 355:     register struct uba_ctlr *um;
 356: {
 357:     register struct rxdevice *rxaddr;
 358:     register struct rx_ctlr *rxc;
 359:     register struct rx_softc *sc;
 360:     struct buf *dp, *bp;
 361:     int unit, sector, track;
 362: 
 363:     if (um->um_tab.b_active)
 364:         return;
 365: loop:
 366:     if ((dp = um->um_tab.b_actf) == NULL)
 367:         return;
 368:     if ((bp = dp->b_actf) == NULL) {
 369:         um->um_tab.b_actf = dp->b_forw;
 370:         goto loop;
 371:     }
 372:     um->um_tab.b_active++;
 373:     unit = RXUNIT(bp->b_dev);
 374:     sc = &rx_softc[unit];
 375:     if (sc->sc_flags & RXF_BAD) {
 376:         rxpurge(um);
 377:         return;
 378:     }
 379:     if (dp->b_active == 1) {
 380:         sc->sc_resid = bp->b_bcount;
 381:         sc->sc_uaddr = bp->b_un.b_addr;
 382:         sc->sc_bcnt = bp->b_bcount;
 383:         sc->sc_offset += sc->sc_bcnt;
 384:         dp->b_active++;
 385:     }
 386:     rxaddr = (struct rxdevice *)um->um_addr;
 387:     rxc = &rx_ctlr[um->um_ctlr];
 388:     bp->b_bcount = sc->sc_resid;
 389:     if (bp->b_bcount > NBPS)
 390:         bp->b_bcount = NBPS;
 391:     rxc->rxc_tocnt = 0;
 392: #ifdef RXDEBUG
 393:     printf("rxstart: ");
 394: #endif
 395:     if (rxaddr->rxcs == 0x800) {
 396:         /*
 397: 		 * 'Volume valid'? (check if the
 398: 		 * drive unit has been powered down)
 399: 		 */
 400:         rxaddr->rxcs = RX_INIT;
 401:         while((rxaddr->rxcs&RX_DONE) == 0)
 402:             ;
 403:     }
 404:     if (bp->b_flags & B_CTRL) {             /* format */
 405:         rxc->rxc_state = RXS_FORMAT;
 406:         rxaddr->rxcs = RX_FORMAT | sc->sc_csbits;
 407:         while ((rxaddr->rxcs&RX_TREQ) == 0)
 408:             ;
 409:         rxaddr->rxdb = 'I';
 410:         return;
 411:     }
 412:     if (bp->b_flags & B_RDSTAT) {           /* read drive status */
 413:         rxc->rxc_state = RXS_RDSTAT;
 414:         rxaddr->rxcs = RX_RDSTAT | sc->sc_csbits;
 415:         return;
 416:     }
 417: 
 418:     if (bp->b_flags & B_READ) {
 419:         rxmap(bp, &sector, &track);         /* read */
 420: #ifdef RXDEBUG
 421:         printf("read tr=%d, sc=%d", track, sector);
 422: #endif
 423:         rxc->rxc_state = RXS_READ;
 424:         rxaddr->rxcs = RX_READ | sc->sc_csbits;
 425:         while ((rxaddr->rxcs&RX_TREQ) == 0)
 426:             ;
 427:         rxaddr->rxdb = (u_short)sector;
 428:         while ((rxaddr->rxcs&RX_TREQ) == 0)
 429:             ;
 430:         rxaddr->rxdb = (u_short)track;
 431:     } else {
 432: #ifdef RXDEBUG
 433:         printf("write");
 434: #endif
 435:         rxc->rxc_state = RXS_FILL;          /* write */
 436:         um->um_cmd = RX_FILL;
 437:         (void) ubago(rxdinfo[unit]);
 438:     }
 439: #ifdef RXDEBUG
 440:     printf("\n");
 441: #endif
 442: }
 443: 
 444: rxdgo(um)
 445:     struct uba_ctlr *um;
 446: {
 447:     register struct rxdevice *rxaddr = (struct rxdevice *)um->um_addr;
 448:     int ubinfo = um->um_ubinfo;
 449:     struct buf *bp = um->um_tab.b_actf->b_actf;
 450:     struct rx_softc *sc = &rx_softc[RXUNIT(bp->b_dev)];
 451:     struct rx_ctlr *rxc = &rx_ctlr[um->um_ctlr];
 452: 
 453:     rxaddr->rxcs = um->um_cmd | ((ubinfo & 0x30000) >> 4) | sc->sc_csbits;
 454:     if (rxc->rxc_state != RXS_RDERR) {
 455:         while ((rxaddr->rxcs&RX_TREQ) == 0)
 456:             ;
 457:         rxaddr->rxdb = (u_short) bp->b_bcount >> 1;
 458:     }
 459:     while ((rxaddr->rxcs&RX_TREQ) == 0)
 460:         ;
 461:     rxaddr->rxdb = (u_short) ubinfo;
 462: }
 463: 
 464: rxintr(ctlr)
 465:     int ctlr;
 466: {
 467:     int unit, sector, track;
 468:     struct uba_ctlr *um = rxminfo[ctlr];
 469:     register struct rxdevice *rxaddr;
 470:     register struct buf *bp, *dp;
 471:     register struct rx_softc *sc;
 472:     struct uba_device *ui;
 473:     struct rxerr *er;
 474:     struct rx_ctlr *rxc;
 475: 
 476:     if (!um->um_tab.b_active)
 477:         return;
 478:     dp = um->um_tab.b_actf;
 479:     if (!dp->b_active)
 480:         return;
 481:     bp = dp->b_actf;
 482:     unit = RXUNIT(bp->b_dev);
 483:     sc = &rx_softc[unit];
 484:     ui = rxdinfo[unit];
 485:     rxaddr = (struct rxdevice *)um->um_addr;
 486:     rxc = &rx_ctlr[um->um_ctlr];
 487:     rxc->rxc_tocnt = 0;
 488:     er = &rxerr[unit];
 489: #ifdef RXDEBUG
 490:     printf("rxint: dev=%x, st=%d, cs=0x%x, db=0x%x\n",
 491:         bp->b_dev, rxc->rxc_state, rxaddr->rxcs, rxaddr->rxdb);
 492: #endif
 493:     if ((rxaddr->rxcs & RX_ERR) &&
 494:         (rxc->rxc_state != RXS_RDSTAT) && (rxc->rxc_state != RXS_RDERR))
 495:         goto error;
 496:     switch (rxc->rxc_state) {
 497: 
 498:     /*
 499: 	 * Incomplete commands.  Perform next step
 500: 	 * and return.  Note that b_active is set on
 501: 	 * entrance and, therefore, also on exit.
 502: 	 */
 503:     case RXS_READ:
 504:         if (rxaddr->rxdb & RXES_DDMARK)
 505:             sc->sc_flags |= RXF_DDMK;
 506:         else
 507:             sc->sc_flags &= ~RXF_DDMK;
 508:         rxc->rxc_state = RXS_EMPTY;
 509:         um->um_cmd = RX_EMPTY;
 510:         (void) ubago(ui);
 511:         return;
 512: 
 513:     case RXS_FILL:
 514:         rxc->rxc_state = RXS_WRITE;
 515:         if (sc->sc_flags & RXF_USEWDDS) {
 516:             rxaddr->rxcs = RX_WDDS | sc->sc_csbits;
 517:             sc->sc_flags &= ~RXF_USEWDDS;
 518:         } else
 519:             rxaddr->rxcs = RX_WRITE | sc->sc_csbits;
 520:         rxmap(bp, &sector, &track);
 521:         while ((rxaddr->rxcs&RX_TREQ) == 0)
 522:             ;
 523:         rxaddr->rxdb = sector;
 524:         while ((rxaddr->rxcs&RX_TREQ) == 0)
 525:             ;
 526:         rxaddr->rxdb = track;
 527:         return;
 528: 
 529:     /*
 530: 	 * Possibly completed command.
 531: 	 */
 532:     case RXS_RDSTAT:
 533:         if (bp->b_flags & B_RDSTAT) {
 534:             if ((rxaddr->rxdb&RXES_READY) == 0) {
 535:                 bp->b_flags |= B_ERROR;
 536:                 bp->b_error = ENODEV;
 537:             } else {
 538:                 sc->sc_csbits |= rxaddr->rxdb&RXES_DBLDEN ?
 539:                     RX_DDEN : RX_SDEN;
 540:             }
 541:             goto rdone;
 542:         }
 543:         if (rxaddr->rxdb&RXES_READY)
 544:             goto rderr;
 545:         bp->b_error = ENODEV;
 546:         bp->b_flags |= B_ERROR;
 547:         goto done;
 548: 
 549:     /*
 550: 	 * Command completed.
 551: 	 */
 552:     case RXS_EMPTY:
 553:     case RXS_WRITE:
 554:         goto done;
 555: 
 556:     case RXS_FORMAT:
 557:         goto rdone;
 558: 
 559:     case RXS_RDERR:
 560:         bp = savebp;
 561:         rxmap(bp, &sector, &track);
 562:         printf("rx%d: hard error, trk %d psec %d ",
 563:             unit, track, sector);
 564:         printf("cs=%b, db=%b, err=", MASKREG(er->rxcs),
 565:             RXCS_BITS, MASKREG(er->rxdb), RXES_BITS);
 566:         printf("%x, %x, %x, %x\n", MASKREG(er->rxxt[0]),
 567:             MASKREG(er->rxxt[1]), MASKREG(er->rxxt[2]),
 568:             MASKREG(er->rxxt[3]));
 569:         goto done;
 570: 
 571:     default:
 572:         printf("rx%d: state %d (reset)\n", unit, rxc->rxc_state);
 573:         rxreset(um->um_ubanum);
 574:         return;
 575:     }
 576: error:
 577:     /*
 578: 	 * In case of an error:
 579: 	 *  (a) Give up now if a format (ioctl) was in progress, if a
 580: 	 *	  density error was detected, or if the drive went offline
 581: 	 *  (b) Retry up to nine times if a CRC (data) error was detected,
 582: 	 *	  then give up if the error persists.
 583: 	 *  (c) In all other cases, reinitialize the drive and try the
 584: 	 *	  operation once more before giving up.
 585: 	 */
 586:     if (rxc->rxc_state == RXS_FORMAT || (rxaddr->rxdb&RXES_DENERR))
 587:         goto giveup;
 588:     if (rxaddr->rxdb & RXES_CRCERR) {
 589:         if (++um->um_tab.b_errcnt >= 10)
 590:             goto giveup;
 591:         goto retry;
 592:     }
 593:     um->um_tab.b_errcnt += 9;
 594:     if (um->um_tab.b_errcnt >= 10)
 595:         goto giveup;
 596:     rxaddr->rxcs = RX_INIT;
 597:     /* no way to get an interrupt for "init done", so just wait */
 598:     while ((rxaddr->rxcs&RX_DONE) == 0)
 599:         ;
 600:     /* if someone opened the drive: give up */
 601:     if ((rxaddr->rxdb&RXES_READY) == 0)
 602:         goto giveup;
 603: retry:
 604:     /*
 605: 	 * In case we already have UNIBUS resources, give
 606: 	 * them back since we reallocate things in rxstart.
 607: 	 */
 608:     if (um->um_ubinfo)
 609:         ubadone(um);
 610:     um->um_tab.b_active = 0;
 611:     rxstart(um);
 612:     return;
 613: 
 614: giveup:
 615:     /*
 616: 	 * Hard I/O error --
 617: 	 * ALL errors are considered fatal and will abort the
 618: 	 * transfer and purge the i/o request queue
 619: 	 */
 620:     sc->sc_flags |= RXF_BAD;
 621:     sc->sc_resid = 0;   /* make sure the transfer is terminated */
 622:     rxc->rxc_state = RXS_RDSTAT;
 623:     rxaddr->rxcs = RX_RDSTAT | sc->sc_csbits;
 624:     return;
 625: 
 626: rderr:
 627:     /*
 628: 	 * A hard error (other than not ready) has occurred.
 629: 	 * Read the extended error status information.
 630: 	 * Before doing this, save the current CS and DB register values,
 631: 	 * because the read error status operation may modify them.
 632: 	 * Insert buffer with request at the head of the queue.
 633: 	 */
 634:     bp->b_error = EIO;
 635:     bp->b_flags |= B_ERROR;
 636:     if (um->um_ubinfo)
 637:         ubadone(um);
 638:     savebp = bp;
 639:     er->rxcs = rxaddr->rxcs;
 640:     er->rxdb = rxaddr->rxdb;
 641:     bp = &erxbuf[unit];
 642:     bp->b_un.b_addr = (caddr_t)er->rxxt;
 643:     bp->b_bcount = sizeof (er->rxxt);
 644:     bp->b_flags &= ~(B_DIRTY|B_UAREA|B_PHYS|B_PAGET);
 645:     if (dp->b_actf == NULL)
 646:         dp->b_actl = bp;
 647:     bp->b_forw = dp->b_actf;
 648:     dp->b_actf = bp;
 649:     rxc->rxc_state = RXS_RDERR;
 650:     um->um_cmd = RX_RDERR;
 651:     (void) ubago(ui);
 652:     return;
 653: 
 654: done:
 655:     ubadone(um);
 656: rdone:
 657:     um->um_tab.b_active = 0;
 658:     um->um_tab.b_errcnt = 0;
 659:     if ((sc->sc_resid -= NBPS) > 0) {
 660:         bp->b_un.b_addr += NBPS;
 661:         rxstart(um);
 662:         return;
 663:     }
 664:     bp->b_un.b_addr = sc->sc_uaddr;
 665:     bp->b_resid = 0;
 666:     bp->b_bcount = sc->sc_bcnt;
 667:     dp->b_actf = bp->av_forw;
 668:     iodone(bp);
 669:     sc->sc_offset = 0;
 670:     rxc->rxc_state = RXS_IDLE;
 671:     um->um_tab.b_actf = dp->b_forw;
 672:     dp->b_active = 0;
 673:     dp->b_errcnt = 0;
 674: #ifdef RXDEBUG
 675:     printf(".. bp=%x, new=%x\n", bp, dp->b_actf);
 676: #endif
 677:     /*
 678: 	 * If this unit has more work to do,
 679: 	 * start it up right away
 680: 	 */
 681:     if (dp->b_actf)
 682:         rxustart(ui);
 683: 
 684:     rxstart(um);
 685: }
 686: 
 687: /*ARGSUSED*/
 688: 
 689: rxwatch()
 690: {
 691:     register struct uba_device *ui;
 692:     register struct uba_ctlr *um;
 693:     register struct rx_softc *sc;
 694:     struct rx_ctlr *rxc;
 695:     int i, dopen = 0;
 696: 
 697:     for (i=0; i<NRX; i++) {
 698:         ui = rxdinfo[i];
 699:         if (ui == 0 || ui->ui_alive == 0)
 700:             continue;
 701:         sc = &rx_softc[i];
 702:         if ((sc->sc_open == 0) && (rxutab[i].b_active == 0)) {
 703:             sc->sc_csbits = 0;
 704:             continue;
 705:         }
 706:         dopen++;
 707:         um = ui->ui_mi;
 708:         rxc = &rx_ctlr[um->um_ctlr];
 709:         if (++rxc->rxc_tocnt >= RX_MAXTIMEOUT) {
 710:             rxc->rxc_tocnt = 0;
 711:             if (um->um_tab.b_active) {
 712:                 printf("rx%d: timeout\n", i);/* for debugging */
 713:                 rxintr(um->um_ctlr);
 714:             }
 715:         }
 716:     }
 717:     if (dopen)
 718:         timeout(rxwatch, (caddr_t)0, hz);
 719:     else
 720:         rxwstart = 0;
 721: }
 722: 
 723: rxreset(uban)
 724:     int uban;
 725: {
 726:     register struct uba_ctlr *um;
 727:     register struct rxdevice *rxaddr;
 728:     register int ctlr;
 729: 
 730:     for (ctlr = 0; ctlr < NFX; ctlr++) {
 731:         if ((um = rxminfo[ctlr]) == 0 || um->um_ubanum != uban ||
 732:             um->um_alive == 0)
 733:             continue;
 734:         if (um->um_ubinfo)
 735:             um->um_ubinfo = 0;
 736:         rx_ctlr[ctlr].rxc_state = RXS_IDLE;
 737:         rxaddr = (struct rxdevice *)um->um_addr;
 738:         rxaddr->rxcs = RX_INIT;
 739:         while ((rxaddr->rxcs&RX_DONE) == 0)
 740:             ;
 741:         rxstart(um);
 742:     }
 743: }
 744: 
 745: rxread(dev, uio)
 746:     dev_t dev;
 747:     struct uio *uio;
 748: {
 749:     int unit = RXUNIT(dev);
 750:     struct rx_softc *sc = &rx_softc[unit];
 751: 
 752:     if (uio->uio_offset + uio->uio_resid > RXSIZE)
 753:         return (ENXIO);
 754:     if (uio->uio_offset < 0 || (uio->uio_offset & SECMASK) != 0)
 755:         return (ENXIO);
 756:     sc->sc_offset = uio->uio_offset % DEV_BSIZE;
 757:     return (physio(rxstrategy, &rrxbuf[unit], dev, B_READ, minphys, uio));
 758: }
 759: 
 760: rxwrite(dev, uio)
 761:     dev_t dev;
 762:     struct uio *uio;
 763: {
 764:     int unit = RXUNIT(dev);
 765:     struct rx_softc *sc = &rx_softc[unit];
 766: 
 767:     if (uio->uio_offset + uio->uio_resid > RXSIZE)
 768:         return (ENXIO);
 769:     if (uio->uio_offset < 0 || (uio->uio_offset & SECMASK) != 0)
 770:         return (ENXIO);
 771:     sc->sc_offset = uio->uio_offset % DEV_BSIZE;
 772:     return(physio(rxstrategy, &rrxbuf[unit], dev, B_WRITE, minphys, uio));
 773: }
 774: 
 775: /*
 776:  * Control routine:
 777:  * processes four kinds of requests:
 778:  *
 779:  *	(1) Set density (i.e., format the diskette) according to
 780:  *		  that specified data parameter
 781:  *	(2) Arrange for the next sector to be written with a deleted-
 782:  *		  data mark.
 783:  *	(3) Report whether the last sector read had a deleted-data mark
 784:  *	(4) Report the density of the diskette in the indicated drive
 785:  *	    (since the density it automatically determined by the driver,
 786:  *	     this is the only way to let an application program know the
 787:  *	     density)
 788:  *
 789:  * Requests relating to deleted-data marks can be handled right here.
 790:  * A "set density" (format) request, however, must additionally be
 791:  * processed through "rxstart", just like a read or write request.
 792:  */
 793: 
 794: /*ARGSUSED3*/
 795: rxioctl(dev, cmd, data, flag)
 796:     dev_t dev;
 797:     caddr_t data;
 798: {
 799:     int unit = RXUNIT(dev);
 800:     struct rx_softc *sc = &rx_softc[unit];
 801: 
 802:     switch (cmd) {
 803: 
 804:     case RXIOC_FORMAT:
 805:         if ((flag&FWRITE) == 0)
 806:             return (EBADF);
 807:         if (sc->sc_open > 1)
 808:             return (EBUSY);
 809:         if (*(int *)data)
 810:             sc->sc_csbits |= RX_DDEN;
 811:         else
 812:             sc->sc_csbits &= ~RX_DDEN;
 813:         return (rxformat(dev));
 814: 
 815:     case RXIOC_WDDS:
 816:         sc->sc_flags |= RXF_USEWDDS;
 817:         return (0);
 818: 
 819:     case RXIOC_RDDSMK:
 820:         *(int *)data = sc->sc_flags & RXF_DDMK;
 821:         return (0);
 822: 
 823:     case RXIOC_GDENS:
 824:         *(int *)data = sc->sc_csbits & RX_DDEN;
 825:         return (0);
 826:     }
 827:     return (ENXIO);
 828: }
 829: 
 830: /*
 831:  * Initiate a format command.
 832:  */
 833: rxformat(dev)
 834:     dev_t dev;
 835: {
 836:     int unit = RXUNIT(dev);
 837:     struct buf *bp;
 838:     struct rx_softc *sc = &rx_softc[unit];
 839:     int s, error = 0;
 840: 
 841:     bp = &rrxbuf[unit];
 842:     bp->b_flags = B_BUSY | B_CTRL;
 843:     sc->sc_flags = RXF_FORMAT | RXF_LOCK;
 844:     bp->b_dev = dev;
 845:     bp->b_error = 0;
 846:     bp->b_blkno = 0;
 847:     rxstrategy(bp);
 848:     iowait(bp);
 849:     if (bp->b_flags & B_ERROR)
 850:         error = bp->b_error;
 851:     bp->b_flags &= ~B_BUSY;
 852:     sc->sc_flags &= ~RXF_LOCK;
 853:     return (error);
 854: }
 855: 
 856: /*
 857:  * A permanent hard error condition has occured,
 858:  * purge the buffer queue
 859:  */
 860: rxpurge(um)
 861:     register struct uba_ctlr *um;
 862: {
 863:     register struct buf *bp, *dp;
 864: 
 865:     dp = um->um_tab.b_actf;
 866:     while (dp->b_actf) {
 867:         dp->b_errcnt++;
 868:         bp = dp->b_actf;
 869:         bp->b_error = EIO;
 870:         bp->b_flags |= B_ERROR;
 871:         iodone(bp);
 872:         dp->b_actf = bp->av_forw;
 873:     }
 874: }
 875: #endif

Defined functions

Defined variables

Defined struct's

Defined macros