Return to rk.c CVS log

Up to [CSRG BSD Unix] / 3BSD / sys / dev

Annotation of 3BSD/sys/dev/rk.c, revision 1.1.1.1

1.1       root        1: /*     rk.c    2.2     1/23/80 */
                      2: 
                      3: /*
                      4:  * RK disk driver
                      5:  */
                      6: 
                      7: #include "../h/param.h"
                      8: #include "../h/systm.h"
                      9: #include "../h/buf.h"
                     10: #include "../h/conf.h"
                     11: #include "../h/dir.h"
                     12: #include "../h/user.h"
                     13: #include "../h/uba.h"
                     14: 
                     15: #define        RKADDR  ((struct rk_regs *)( UBA0_DEV + 0177400))
                     16: #define        NRK     4
                     17: #define        NRKBLK  4872
                     18: 
                     19: #define        RESET   0
                     20: #define        WCOM    2
                     21: #define        RCOM    4
                     22: #define        GO      01
                     23: #define        DRESET  014
                     24: #define        IENABLE 0100
                     25: #define        DRY     0200
                     26: #define        ARDY    0100
                     27: #define        WLO     020000
                     28: #define        CTLRDY  0200
                     29: 
                     30: /*
                     31:  * Monitoring device bit
                     32:  */
                     33: #define        DK_N    1
                     34: 
                     35: struct rk_regs
                     36: {
                     37:        short   rkds;
                     38:        short   rker;
                     39:        short   rkcs;
                     40:        short   rkwc;
                     41:        unsigned short  rkba;
                     42:        short   rkda;
                     43: };
                     44: 
                     45: struct buf     rktab;
                     46: struct buf     rrkbuf;
                     47: 
                     48: int rk_ubinfo;
                     49: 
                     50: rkstrategy(bp)
                     51: register struct buf *bp;
                     52: {
                     53: 
                     54:        if (bp->b_blkno >= NRKBLK) {
                     55:                bp->b_flags |= B_ERROR;
                     56:                iodone(bp);
                     57:                return;
                     58:        }
                     59:        bp->av_forw = (struct buf *)NULL;
                     60:        VOID spl5();
                     61:        if(rktab.b_actf == NULL)
                     62:                rktab.b_actf = bp;
                     63:        else
                     64:                rktab.b_actl->av_forw = bp;
                     65:        rktab.b_actl = bp;
                     66:        if(rktab.b_active == NULL)
                     67:                rkstart();
                     68:        VOID spl0();
                     69: }
                     70: 
                     71: rkstart()
                     72: {
                     73:        register struct buf *bp;
                     74:        register com;
                     75:        daddr_t bn;
                     76:        int dn, cn, sn;
                     77: 
                     78:        if ((bp = rktab.b_actf) == NULL)
                     79:                return;
                     80:        rktab.b_active++;
                     81:        rk_ubinfo = ubasetup( bp, 1 );
                     82:        bn = bp->b_blkno;
                     83:        dn = minor(bp->b_dev);
                     84:        cn = bn/12;
                     85:        sn = bn%12;
                     86:        RKADDR->rkda = (dn<<13) | (cn<<4) | sn;
                     87:        RKADDR->rkba = rk_ubinfo;
                     88:        RKADDR->rkwc = -(bp->b_bcount>>1);
                     89:        com = ((rk_ubinfo & 0x30000) >> 8 ) | IENABLE | GO;
                     90:        if(bp->b_flags & B_READ)
                     91:                com |= RCOM; else
                     92:                com |= WCOM;
                     93:        RKADDR->rkcs = com;
                     94: /*
                     95:        dk_busy |= 1<<DK_N;
                     96:        dk_numb[DK_N] += 1;
                     97:        com = bp->b_bcount>>6;
                     98:        dk_wds[DK_N] += com;
                     99: */
                    100: }
                    101: 
                    102: rkintr()
                    103: {
                    104:        register struct buf *bp;
                    105: 
                    106:        if (rktab.b_active == NULL)
                    107:                return;
                    108:        dk_busy &= ~(1<<DK_N);
                    109:        bp = rktab.b_actf;
                    110:        rktab.b_active = NULL;
                    111:        if (RKADDR->rkcs < 0) {         /* error bit */
                    112:                deverror(bp, RKADDR->rker, RKADDR->rkds);
                    113:                RKADDR->rkcs = RESET|GO;
                    114:                while((RKADDR->rkcs&CTLRDY) == 0)
                    115:                        ;
                    116:                if (++rktab.b_errcnt <= 10) {
                    117:                        ubafree(rk_ubinfo);
                    118:                        rkstart();
                    119:                        return;
                    120:                }
                    121:                bp->b_flags |= B_ERROR;
                    122:        }
                    123:        rktab.b_errcnt = 0;
                    124:        rktab.b_actf = bp->av_forw;
                    125:        bp->b_resid = 0;
                    126:        ubafree(rk_ubinfo);
                    127:        iodone(bp);
                    128:        rkstart();
                    129: }
                    130: 
                    131: rkread(dev)
                    132: dev_t dev;
                    133: {
                    134: 
                    135:        physio(rkstrategy, &rrkbuf, dev, B_READ, minphys);
                    136: }
                    137: 
                    138: rkwrite(dev)
                    139: dev_t dev;
                    140: {
                    141: 
                    142:        physio(rkstrategy, &rrkbuf, dev, B_WRITE, minphys);
                    143: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.