Return to ct.c CVS log

Up to [CSRG BSD Unix] / 42BSD / sys / vaxuba

Annotation of 42BSD/sys/vaxuba/ct.c, revision 1.1

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

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