Return to kbd.c CVS log

Up to [Research Unix] / researchv9 / jerq / src / mux / term

Annotation of researchv9/jerq/src/mux/term/kbd.c, revision 1.1

1.1     ! root        1: #include <jerq.h>
        !             2: #include <queue.h>
        !             3: #include <kbd.h>
        !             4: #include <setup.h>
        !             5: 
        !             6: int    kbdrepeat;
        !             7: int    rptcount;
        !             8: int    kbdstatus;
        !             9: 
        !            10: kbdchar(){
        !            11:        return qgetc(&KBDQUEUE);
        !            12: }
        !            13: kbdinit()
        !            14: {
        !            15:        /* init the keyboard */
        !            16:        DUART->b_cmnd=RESET_RECV|DIS_TX|DIS_RX;
        !            17:        DUART->b_cmnd=RESET_TRANS;
        !            18:        DUART->b_cmnd=RESET_ERR;
        !            19:        DUART->b_cmnd=RESET_MR;
        !            20:        DUART->mr1_2b=CHAR_ERR|NO_PAR|CBITS8;
        !            21:        DUART->mr1_2b=NRML_MOD|ONEP000SB;
        !            22:        DUART->b_sr_csr=BD300BPS;
        !            23:        DUART->b_cmnd=RESET_MR|ENB_TX|ENB_RX;
        !            24:        DUART->scc_ropbc=0x08; /* set output pins for kbd tx port*/
        !            25: #ifdef ftang
        !            26:        /* turn chirps on/off depending on BRAM */
        !            27:        if(VALKEYTONE)
        !            28:                kbdstatus=0;    /* no chirp */
        !            29:        else
        !            30:                kbdstatus=TTY_CHIRP;    /* chirp, chirp */
        !            31:        DUART->b_data=kbdstatus|0x02; /* request status */
        !            32: #endif
        !            33: }
        !            34: auto2(){
        !            35:        register unsigned s, c;
        !            36:        s=DUART->b_sr_csr;
        !            37:        c=DUART->b_data;
        !            38:        if(s&(FRM_ERR|OVR_RUN)) 
        !            39:                return;
        !            40: #ifdef ftang
        !            41:        if(s&PAR_ERR){  /* control word: caps lock or repeat */
        !            42:                checkbram();
        !            43:                VALCAPS=(c&0x04)? 0 : 1; /* set the caps lock flag */
        !            44:                setbram();
        !            45:                if(c&0x10)      /* turn repeat off */
        !            46:                        kbdrepeat=rptcount=0;
        !            47:                else            /* the next character is to be repeated */
        !            48:                        kbdrepeat=RPTON;
        !            49:                /*
        !            50:                 * Don't actually set the repeat bit until the character
        !            51:                 * after the control code
        !            52:                 */
        !            53:        }else{          /* ordinary character */
        !            54:                rptcount=0;     /* new char so restart repeat timer */
        !            55:                if(c&0x80)
        !            56:                        c=defkeymap[c&0x7f];
        !            57:                qputc(&KBDQUEUE, (int)c);
        !            58:                if((kbdrepeat&RPTMASK) == RPTON){
        !            59:                        kbdrepeat=RPTHAVECHR|RPTON;
        !            60:                        kbdrepeat|=c;
        !            61:                }
        !            62:        }
        !            63: #else
        !            64:        qputc(&KBDQUEUE, (int)c);
        !            65: }
        !            66: kbdrpt(){
        !            67: #ifdef ftang
        !            68:        qputc(&KBDQUEUE, kbdrepeat&0xff);
        !            69: #endif
        !            70: }

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