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

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.