Return to dn.c CVS log

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

Annotation of researchv10no/sys/io/dn.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * DN-11 ACU interface
        !             3:  *  Minor devices < <128 are standard 801's
        !             4:  *  Minor devices >= 128 are Parker shared
        !             5:  *  units in which the 1st digit selects a line.
        !             6:  *  The only interface difference is that DLO
        !             7:  *  can appear some time after the line is selected
        !             8:  *  to indicate that the line is busy or out of service.
        !             9:  *
        !            10:  *  If the system has an accessible DR-11C, allow some of
        !            11:  *  its bits to be fiddled.
        !            12:  */
        !            13: 
        !            14: #include "sys/param.h"
        !            15: #include "sys/user.h"
        !            16: #include "sys/conf.h"
        !            17: #include "sys/ubaddr.h"
        !            18: 
        !            19: struct device {
        !            20:        u_short dn_reg[4];
        !            21: };
        !            22: 
        !            23: #define        PWI     0100000
        !            24: #define        ACR     040000
        !            25: #define        DLO     010000
        !            26: #define        DONE    0200
        !            27: #define        IENABLE 0100
        !            28: #define        DSS     040
        !            29: #define        PND     020
        !            30: #define        MAINT   010
        !            31: #define        MENABLE 04
        !            32: #define        DPR     02
        !            33: #define        CRQ     01
        !            34: 
        !            35: #define        DNPRI   (PZERO+5)
        !            36: 
        !            37: extern int dncnt;
        !            38: extern struct ubaddr dnaddr[];
        !            39: extern caddr_t dnreg[];
        !            40: 
        !            41: static int dnindex();
        !            42: 
        !            43: int    dnopen(), dnclose(), dnwrite();
        !            44: struct cdevsw dncdev = cdinit(dnopen, dnclose, nodev, dnwrite, nodev);
        !            45: 
        !            46: dnopen(dev)
        !            47: register dev;
        !            48: {
        !            49:        register struct device *dp;
        !            50:        register unit;
        !            51: 
        !            52:        dev = minor(dev) & 0177;
        !            53:        unit = dev>>2;
        !            54:        if (unit > dncnt) {
        !            55:                u.u_error = ENXIO;
        !            56:                return;
        !            57:        }
        !            58:        if ((dp = (struct device *)dnreg[unit]) == NULL) {
        !            59:                if ((dp = (struct device *)ubaddr(&dnaddr[unit])) == NULL
        !            60:                ||  ubbadaddr(dnaddr[unit].ubno, &dp->dn_reg[0], sizeof(short))) {
        !            61:                        printf("dn%d absent\n", unit);
        !            62:                        u.u_error = ENXIO;
        !            63:                        return;
        !            64:                }
        !            65:                dnreg[unit] = (caddr_t)dp;
        !            66:        }
        !            67:        if (dp->dn_reg[dev&03]&(PWI|DLO|CRQ)) {
        !            68:                u.u_error = ENXIO;
        !            69:                return;
        !            70:        }
        !            71:        dp->dn_reg[0] |= MENABLE;
        !            72:        dp->dn_reg[dev&03] = IENABLE|MENABLE|CRQ;
        !            73: }
        !            74: 
        !            75: dnclose(dev)
        !            76: {
        !            77:        dev = minor(dev) & 0177;
        !            78:        ((struct device *)dnreg[dev>>2])->dn_reg[dev&03] = MENABLE;
        !            79: }
        !            80: 
        !            81: dnwrite(dev)
        !            82: {
        !            83:        register c;
        !            84:        register u_short *dp;
        !            85:        register first;
        !            86:        extern lbolt;
        !            87:        int ldlo;
        !            88:        register int setspeed = -1;
        !            89:        register k;
        !            90: 
        !            91:        ldlo = 0;
        !            92:        if (dev & 0200)
        !            93:                ldlo = DLO;
        !            94:        dev = minor(dev) & 0177;
        !            95:        dp = &((struct device *)dnreg[dev>>2])->dn_reg[dev&03];
        !            96:        if (*dp & DLO) {
        !            97:                u.u_error = EIO;
        !            98:                return;
        !            99:        }
        !           100:        *dp |= CRQ;
        !           101:        first = 0;
        !           102:        while ((*dp & (PWI|ACR|DSS|ldlo)) == 0) {
        !           103:                spl4();
        !           104:                if ((*dp&PND) == 0 || u.u_count == 0 || (c=cpass()) < 0)
        !           105:                        sleep((caddr_t)dp, DNPRI);
        !           106:                else if (c == '-') {
        !           107:                        sleep((caddr_t)&lbolt, DNPRI);
        !           108:                        sleep((caddr_t)&lbolt, DNPRI);
        !           109:                } else if ((k = dnindex (c, "abcdefghABCDEFGH")) >= 0) {
        !           110:                        setspeed = k;
        !           111:                } else {
        !           112:                        *dp = (c<<8)|IENABLE|MENABLE|DPR|CRQ;
        !           113:                        if (first == 0) {
        !           114:                                while (first <  800)
        !           115:                                        first++;
        !           116:                                if (*dp&ldlo) {
        !           117:                                        *dp = MENABLE;
        !           118:                                        break;
        !           119:                                }
        !           120:                                ldlo = 0;
        !           121:                        }
        !           122:                        sleep((caddr_t)dp, DNPRI);
        !           123:                }
        !           124:                spl0();
        !           125:        }
        !           126:        if (*dp&(PWI|ACR|ldlo))
        !           127:                u.u_error = EIO;
        !           128:        else if (setspeed >= 0)
        !           129:                drsetbit (setspeed % 8, setspeed / 8);
        !           130: }
        !           131: 
        !           132: /*
        !           133:  * interrupt-- "dev" is
        !           134:  * system unit number, not minor device
        !           135:  */
        !           136: dn0int(dev)
        !           137: {
        !           138:        register u_short *ep;
        !           139:        register struct device *dp;
        !           140: 
        !           141:        dp = (struct device *)dnreg[dev];
        !           142:        dp->dn_reg[0] &= ~MENABLE;
        !           143:        for (ep = &dp->dn_reg[0]; ep < &dp->dn_reg[4]; ep++)
        !           144:                if (*ep&DONE) {
        !           145:                        *ep &= ~DONE;
        !           146:                        wakeup((caddr_t)ep);
        !           147:                }
        !           148:        dp->dn_reg[0] |= MENABLE;
        !           149: }
        !           150: 
        !           151: static int
        !           152: dnindex (c, s)
        !           153:        register char c, *s;
        !           154: {
        !           155:        register char *p;
        !           156: 
        !           157:        p = s;
        !           158:        while (*p) {
        !           159:                if (c == *p)
        !           160:                        return p - s;
        !           161:                p++;
        !           162:        }
        !           163:        return -1;
        !           164: }

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