Return to dn.c CVS log

Up to [CSRG BSD Unix] / 41BSD / 4.0.upgrade / sys / dev

Annotation of 41BSD/4.0.upgrade/sys/dev/dn.c, revision 1.1

1.1     ! root        1: /*     dn.c    4.4     82/01/12        */
        !             2: 
        !             3: #include "dn.h"
        !             4: #if NDN > 0
        !             5: /*
        !             6:  * DN-11 ACU interface
        !             7:  */
        !             8: 
        !             9: #include "../h/param.h"
        !            10: #include "../h/systm.h"
        !            11: #include "../h/dir.h"
        !            12: #include "../h/user.h"
        !            13: #include "../h/buf.h"
        !            14: #include "../h/map.h"
        !            15: #include "../h/pte.h"
        !            16: #include "../h/ubavar.h"
        !            17: #include "../h/conf.h"
        !            18: #include "../h/ioctl.h"
        !            19: 
        !            20: struct dndevice {
        !            21:        u_short dn_reg[4];
        !            22: };
        !            23: 
        !            24: struct uba_device *dninfo[NDN];
        !            25: int dnprobe(), dnattach();
        !            26: u_short dnstd[] = { 0175200 };
        !            27: struct uba_driver dndriver =
        !            28:        { dnprobe, 0, dnattach, 0, dnstd, "dn", dninfo };
        !            29: 
        !            30: #define        CRQ     0x001           /* call request */
        !            31: #define        DPR     0x002           /* digit present */
        !            32: #define        MENABLE 0x004           /* master enable */
        !            33: #define MAINT  0x008           /* maintenance mode */
        !            34: #define        PND     0x010           /* present next digit */
        !            35: #define        DSS     0x020           /* data set status */
        !            36: #define        IENABLE 0x040           /* interrupt enable */
        !            37: #define        DONE    0x080           /* operation complete */
        !            38: #define        DLO     0x1000          /* data line occupied */
        !            39: #define        ACR     0x4000          /* abandon call and retry */
        !            40: #define        PWI     0x8000          /* power indicate */
        !            41: 
        !            42: #define        DNPRI   (PZERO+5)
        !            43: #define DNUNIT(dev)    (minor(dev)>>2)
        !            44: #define DNREG(dev)     ((dev)&03)
        !            45: 
        !            46: #define OBUFSIZ        40              /* largest phone # dialer can handle */
        !            47: 
        !            48: /*
        !            49:  * There's no good way to determine the correct number of dialers attached
        !            50:  * to a single device (especially when dialers such as Vadic-821 MACS
        !            51:  * exist which can address four chassis, each with its own dialer).
        !            52:  */
        !            53: dnprobe(reg)
        !            54:        caddr_t reg;
        !            55: {
        !            56:        register int br, cvec;  /* value-result, must be r11, r10 */
        !            57:        register struct dndevice *dnaddr = (struct dndevice *)reg;
        !            58: 
        !            59:        /*
        !            60:         * If there's at least one dialer out there it better be
        !            61:         *  at chassis 0.
        !            62:         */
        !            63:        dnaddr->dn_reg[0] = MENABLE|IENABLE|DONE;
        !            64:        DELAY(5);
        !            65:        dnaddr->dn_reg[0] = 0;
        !            66: }
        !            67: 
        !            68: dnattach(ui)
        !            69:        struct uba_device *ui;
        !            70: {}
        !            71: 
        !            72: /*ARGSUSED*/
        !            73: dnopen(dev, flag)
        !            74:        dev_t dev;
        !            75: {
        !            76:        register struct dndevice *dp;
        !            77:        register u_short unit, *dnreg;
        !            78:        register struct uba_device *ui;
        !            79:        register short dialer;
        !            80: 
        !            81:        if ((unit = DNUNIT(dev)) >= NDN || (ui = dninfo[unit]) == 0 ||
        !            82:            ui->ui_alive == 0) {
        !            83:                u.u_error = ENXIO;
        !            84:                return;
        !            85:        }
        !            86:        dialer = DNREG(dev);
        !            87:        dp = (struct dndevice *)ui->ui_addr;
        !            88:        if (dp->dn_reg[dialer] & PWI) {
        !            89:                u.u_error = ENXIO;
        !            90:                return;
        !            91:        }
        !            92:        dnreg = &(dp->dn_reg[dialer]);
        !            93:        if (*dnreg&(DLO|CRQ)) {
        !            94:                u.u_error = EBUSY;
        !            95:                return;
        !            96:        }
        !            97:        dp->dn_reg[0] |= MENABLE;
        !            98:        *dnreg = IENABLE|MENABLE|CRQ;
        !            99: }
        !           100: 
        !           101: /*ARGSUSED*/
        !           102: dnclose(dev, flag)
        !           103:        dev_t dev;
        !           104: {
        !           105:        register struct dndevice *dp;
        !           106: 
        !           107:        dp = (struct dndevice *)dninfo[DNUNIT(dev)]->ui_addr;
        !           108:        dp->dn_reg[DNREG(dev)] = MENABLE;
        !           109: }
        !           110: 
        !           111: dnwrite(dev)
        !           112:        dev_t dev;
        !           113: {
        !           114:        register u_short *dnreg;
        !           115:        register int cc;
        !           116:        register struct dndevice *dp;
        !           117:        char buf[OBUFSIZ];
        !           118:        register char *cp;
        !           119:        extern lbolt;
        !           120: 
        !           121:        dp = (struct dndevice *)dninfo[DNUNIT(dev)]->ui_addr;
        !           122:        dnreg = &(dp->dn_reg[DNREG(dev)]);
        !           123:        cc = MIN(u.u_count, OBUFSIZ);
        !           124:        cp = buf;
        !           125:        iomove(cp, (unsigned)cc, B_WRITE);
        !           126:        if (u.u_error)
        !           127:                return;
        !           128:        while ((*dnreg & (PWI|ACR|DSS)) == 0 && cc >= 0) {
        !           129:                spl4();
        !           130:                if ((*dnreg & PND) == 0 || cc == 0)
        !           131:                        sleep((caddr_t)dnreg, DNPRI);
        !           132:                else switch(*cp) {
        !           133:                
        !           134:                case '-':
        !           135:                        sleep((caddr_t)&lbolt, DNPRI);
        !           136:                        sleep((caddr_t)&lbolt, DNPRI);
        !           137:                        break;
        !           138: 
        !           139:                case 'f':
        !           140:                        *dnreg &= ~CRQ;
        !           141:                        sleep((caddr_t)&lbolt, DNPRI);
        !           142:                        *dnreg |= CRQ;
        !           143:                        break;
        !           144: 
        !           145:                case '*': case ':':
        !           146:                        *cp = 012;
        !           147:                        goto dial;
        !           148: 
        !           149:                case '#': case ';':
        !           150:                        *cp = 013;
        !           151:                        goto dial;
        !           152: 
        !           153:                case 'e': case '<':
        !           154:                        *cp = 014;
        !           155:                        goto dial;
        !           156: 
        !           157:                case 'w': case '=':
        !           158:                        *cp = 015;
        !           159:                        goto dial;
        !           160: 
        !           161:                default:
        !           162:                        if (*cp < '0' || *cp > '9')
        !           163:                                break;
        !           164:                dial:
        !           165:                        *dnreg = (*cp << 8) | (IENABLE|MENABLE|DPR|CRQ);
        !           166:                        sleep((caddr_t)dnreg, DNPRI);
        !           167:                }
        !           168:                cp++, cc--;
        !           169:                spl0();
        !           170:        }
        !           171:        if (*dnreg & (PWI|ACR))
        !           172:                u.u_error = EIO;
        !           173: }
        !           174: 
        !           175: dnintr(dev)
        !           176:        dev_t dev;
        !           177: {
        !           178:        register u_short *basereg, *dnreg;
        !           179: 
        !           180:        basereg = (u_short *)dninfo[dev]->ui_addr;
        !           181:        *basereg &= ~MENABLE;
        !           182:        for (dnreg = basereg; dnreg < basereg + 4; dnreg++)
        !           183:                if (*dnreg & DONE) {
        !           184:                        *dnreg &= ~(DONE|DPR);
        !           185:                        wakeup((caddr_t)dnreg);
        !           186:                }
        !           187:        *basereg |= MENABLE;
        !           188: }
        !           189: #endif

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