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     ! 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.