Return to ct.c CVS log

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

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

1.1     ! root        1: /*     ct.c    4.6     81/07/05        */
        !             2: 
        !             3: #include "ct.h"
        !             4: #if NCT > 0
        !             5: /*
        !             6:  * GP DR11C driver used for C/A/T
        !             7:  *
        !             8:  * BUGS:
        !             9:  *     This driver hasn't been tested in 4.1bsd
        !            10:  */
        !            11: 
        !            12: #include "../h/param.h"
        !            13: #include "../h/systm.h"
        !            14: #include "../h/tty.h"
        !            15: #include "../h/pte.h"
        !            16: #include "../h/map.h"
        !            17: #include "../h/buf.h"
        !            18: #include "../h/ubareg.h"
        !            19: #include "../h/ubavar.h"
        !            20: #include "../h/conf.h"
        !            21: #include "../h/dir.h"
        !            22: #include "../h/user.h"
        !            23: 
        !            24: #define        PCAT    (PZERO+9)
        !            25: #define        CATHIWAT        100
        !            26: #define        CATLOWAT        30
        !            27: 
        !            28: struct ct_softc {
        !            29:        int     sc_openf;
        !            30:        struct  clist sc_oq;
        !            31: } ct_softc[NCT];
        !            32: 
        !            33: struct ctdevice {
        !            34:        short   ctcsr;
        !            35:        short   ctbuf;
        !            36: };
        !            37: 
        !            38: int    ctprobe(), ctattach(), ctintr();
        !            39: struct uba_device *ctdinfo[NCT];
        !            40: u_short        ctstd[] = { 0 };
        !            41: struct uba_driver ctdriver = 
        !            42:     { ctprobe, 0, ctattach, 0, ctstd, "ct", ctdinfo };
        !            43: 
        !            44: #define        CTUNIT(dev)     (minor(dev))
        !            45: 
        !            46: ctprobe(reg)
        !            47:        caddr_t reg;
        !            48: {
        !            49:        register int br, cvec;          /* value-result */
        !            50:        register struct ctdevice *ctaddr = (struct ctdevice *)reg;
        !            51: 
        !            52:        ctaddr->ctcsr = IENABLE;
        !            53:        DELAY(10000);
        !            54:        ctaddr->ctcsr = 0;
        !            55: }
        !            56: 
        !            57: /*ARGSUSED*/
        !            58: ctattach(ui)
        !            59:        register struct uba_device *ui;
        !            60: {
        !            61: 
        !            62: }
        !            63: 
        !            64: ctopen(dev)
        !            65:        dev_t dev;
        !            66: {
        !            67:        register struct ct_softc *sc;
        !            68:        register struct uba_device *ui;
        !            69:        register struct ctdevice *ctaddr;
        !            70: 
        !            71:        if (CTUNIT(dev) >= NCT || (ui = ctdinfo[CTUNIT(dev)]) == 0 ||
        !            72:            ui->ui_alive == 0 || (sc = &ct_softc[CTUNIT(dev)])->sc_openf) {
        !            73:                u.u_error = ENXIO;
        !            74:                return;
        !            75:        }
        !            76:        sc->sc_openf = 1;
        !            77:        ctaddr->ctcsr |= IENABLE;
        !            78: }
        !            79: 
        !            80: ctclose(dev)
        !            81:        dev_t dev;
        !            82: {
        !            83: 
        !            84:        ct_softc[CTUNIT(dev)].sc_openf = 0;
        !            85:        ctintr(dev);
        !            86: }
        !            87: 
        !            88: ctwrite(dev)
        !            89:        dev_t dev;
        !            90: {
        !            91:        register struct ct_softc *sc = &ct_softc[CTUNIT(dev)];
        !            92:        register int c;
        !            93: 
        !            94:        while ((c=cpass()) >= 0) {
        !            95:                (void) spl5();
        !            96:                while (sc->sc_oq.c_cc > CATHIWAT)
        !            97:                        sleep((caddr_t)&sc->sc_oq, PCAT);
        !            98:                while (putc(c, &sc->sc_oq) < 0)
        !            99:                        sleep((caddr_t)&lbolt, PCAT);
        !           100:                ctintr(dev);
        !           101:                (void) spl0();
        !           102:        }
        !           103: }
        !           104: 
        !           105: ctintr(dev)
        !           106:        dev_t dev;
        !           107: {
        !           108:        register int c;
        !           109:        register struct ct_softc *sc = &ct_softc[CTUNIT(dev)];
        !           110:        register struct ctdevice *ctaddr =
        !           111:            (struct ctdevice *)ctdinfo[CTUNIT(dev)]->ui_addr;
        !           112: 
        !           113:        if (ctaddr->ctcsr&DONE) {
        !           114:                if ((c = getc(&sc->sc_oq)) >= 0) {
        !           115: #if MH135A
        !           116:                        c |= (c & 01) << 8;     /* for dr11c bug */
        !           117: #endif         
        !           118:                        ctaddr->ctbuf = c;
        !           119:                        if (sc->sc_oq.c_cc==0 || sc->sc_oq.c_cc==CATLOWAT)
        !           120:                                wakeup(&sc->sc_oq);
        !           121:                } else {
        !           122:                        if (sc->sc_openf==0)
        !           123:                                ctaddr->ctcsr = 0;
        !           124:                }
        !           125:        }
        !           126: 
        !           127: }
        !           128: #endif

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