Return to ct.c CVS log

Up to [Research Unix] / researchv8dc / sys / dev

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

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