Return to mg.c CVS log

Up to [Research Unix] / researchv10dc / sys / io

Annotation of researchv10dc/sys/io/mg.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * DR11C for Mergenthaler 202
        !             3:  */
        !             4: #include "sys/param.h"
        !             5: #include "sys/conf.h"
        !             6: #include "sys/stream.h"
        !             7: #include "sys/ubaddr.h"
        !             8: #include "sys/mg.h"
        !             9: 
        !            10: /*
        !            11:  * hardware
        !            12:  */
        !            13: struct device {
        !            14:        u_short csr;
        !            15:        u_short wbuf;
        !            16:        u_short rbuf;
        !            17: };
        !            18: 
        !            19: #define CSR0 1
        !            20: #define CSR1 2
        !            21: #define REQA 0200
        !            22: #define REQB 0100000
        !            23: #define INTA 0100
        !            24: #define INTB 040
        !            25: 
        !            26: /*
        !            27:  * stream glue
        !            28:  */
        !            29: long mgopen();
        !            30: int nodev(), mgclose(), mgoput();
        !            31: 
        !            32: static struct qinit mgrinit = {
        !            33:        nodev, NULL, mgopen, mgclose, 0, 0
        !            34: };
        !            35: static struct qinit mgwinit = {
        !            36:        mgoput, NULL, mgopen, mgclose, 200, 100
        !            37: };
        !            38: struct streamtab mginfo = {
        !            39:        &mgrinit, &mgwinit
        !            40: };
        !            41: 
        !            42: /*
        !            43:  * config glue
        !            44:  */
        !            45: extern struct mg mg[];                 /* one per device */
        !            46: extern struct ubaddr mgaddr[];         /* one per device */
        !            47: extern int mgcnt;                      /* one per device or what? */
        !            48: struct cdevsw mgcdev = cstrinit(&mginfo);
        !            49: 
        !            50: long
        !            51: mgopen(q, d)
        !            52: register struct queue *q;
        !            53: {
        !            54:        register struct mg *mp;
        !            55:        register dev, s;
        !            56: 
        !            57:        if((dev = (minor(d) >> 1)) >= mgcnt)
        !            58:                return 0;
        !            59:        mp = &mg[dev];
        !            60:        if((mp->addr = (struct device *)ubaddr(&mgaddr[dev])) == 0
        !            61:          || ubbadaddr(mgaddr[dev].ubno, mp->addr, sizeof(u_short))) {
        !            62:                printf("mg%d absent\n", d);
        !            63:                return 0;
        !            64:        }
        !            65:        mp->addr->csr |= CSR0 | CSR1;
        !            66:        if(d & 01) {
        !            67:                if(mp->wq != NULL)
        !            68:                        return 0;
        !            69:                mp->addr->csr |= INTA;
        !            70:                mp->wq = WR(q);
        !            71:        }
        !            72:        else {
        !            73:                if(mp->rq != NULL)
        !            74:                        return 0;
        !            75:                s = mp->addr->rbuf;
        !            76:                mp->addr->csr |= INTB;
        !            77:                mp->rq = q;
        !            78:        }
        !            79:        WR(q)->ptr = q->ptr = (caddr_t) minor(d);
        !            80:        return 1;
        !            81: }
        !            82: 
        !            83: mgclose(q)
        !            84: register struct queue *q;
        !            85: {
        !            86:        register struct mg *mp = &mg[((int)q->ptr) >> 1];
        !            87: 
        !            88:        if(((int)q->ptr) & 01) {
        !            89:                mp->wq = NULL;
        !            90:        }
        !            91:        else {
        !            92:                mp->addr->csr &= (~INTB);
        !            93:                flushq(WR(q), 1);
        !            94:                mp->rq = NULL;
        !            95:        }
        !            96: }
        !            97: 
        !            98: mg1int(dev)
        !            99: {
        !           100:        register struct mg *mp = &mg[dev];
        !           101:        register c;
        !           102: 
        !           103:        c = mp->addr->rbuf;
        !           104:        if(mp->rq && (mp->rq->flag & QFULL) == 0)
        !           105:                putd(mp->rq->next->qinfo->putp, mp->rq->next, c);
        !           106: }
        !           107: 
        !           108: mg0int(dev)
        !           109: {
        !           110:        register struct mg *mp = &mg[dev];
        !           111: 
        !           112:        mp->busy = 0;
        !           113:        mgstart(mp);
        !           114: }
        !           115: 
        !           116: mgoput(q, bp)
        !           117: register struct queue *q;
        !           118: register struct block *bp;
        !           119: {
        !           120:        switch(bp->type) {
        !           121: 
        !           122:        case M_IOCTL:
        !           123:                bp->type = M_IOCNAK;
        !           124:                bp->wptr = bp->rptr;
        !           125:                qreply(q, bp);
        !           126:                return;
        !           127: 
        !           128:        case M_FLUSH:
        !           129:                flushq(q, 0);
        !           130:                break;
        !           131: 
        !           132:        case M_DATA:
        !           133:                putq(q, bp);
        !           134:                mgstart(&mg[((int)q->ptr) >> 1]);
        !           135:                return;
        !           136: 
        !           137:        default:
        !           138:                break;
        !           139:        }
        !           140:        freeb(bp);
        !           141: }
        !           142: 
        !           143: mgstart(mp)
        !           144: register struct mg *mp;
        !           145: {
        !           146:        register struct block *bp;
        !           147:        register s;
        !           148: 
        !           149:        if(mp->wq == NULL)
        !           150:                return;
        !           151:        s = spl6();
        !           152:        if((mp->busy == 0) && mp->wq->count) {
        !           153:                bp = getq(mp->wq);
        !           154:                switch(bp->type) {
        !           155: 
        !           156:                case M_DATA:
        !           157:                        mp->addr->wbuf = *bp->rptr++;
        !           158:                        mp->busy = 1;
        !           159:                        if(bp->rptr >= bp->wptr)
        !           160:                                freeb(bp);
        !           161:                        else
        !           162:                                putbq(mp->wq, bp);
        !           163:                        break;
        !           164: 
        !           165:                default:
        !           166:                        freeb(bp);
        !           167:                        break;
        !           168:                }
        !           169:        }
        !           170:        splx(s);
        !           171: }

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