Return to cons.c CVS log

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

Annotation of researchv9/sys/dev/cons.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * SUN-3 console driver
                      3:  */
                      4: #include "../h/param.h"
                      5: #include "../h/inode.h"
                      6: #include "../h/stream.h"
                      7: #include "../h/ttyio.h"
                      8: #include "../h/ttyld.h"
                      9: #include "../h/conf.h"
                     10: #include "../machine/sunromvec.h"
                     11: 
                     12: #define        TIMEOUT 04
                     13: 
                     14: short  cnstate;
                     15: struct queue   *cnrq;
                     16: struct queue   *cnwq;
                     17: 
                     18: int    cnopen(), cnclose(), cnoput(), nodev();
                     19: 
                     20: static struct qinit cnrinit = { nodev, NULL, cnopen, cnclose, 0, 0 };
                     21: static struct qinit cnwinit = { cnoput, NULL, cnopen, cnclose, 200, 100 };
                     22: struct streamtab cninfo = { &cnrinit, &cnwinit };
                     23: 
                     24: cnopen(qp, dev)
                     25: register struct queue *qp;
                     26: {
                     27:        cnrq = qp;
                     28:        cnwq = WR(qp);
                     29:        return(1);
                     30: }
                     31: 
                     32: cnclose(qp)
                     33: {
                     34:        cnrq = NULL;
                     35:        cnwq = NULL;
                     36: }
                     37: 
                     38: /*
                     39:  * Console write put routine
                     40:  */
                     41: cnoput(q, bp)
                     42: register struct queue *q;
                     43: register struct block *bp;
                     44: {
                     45:        register union stmsg *sp;
                     46: 
                     47:        switch(bp->type) {
                     48: 
                     49:        case M_IOCTL:
                     50:                sp = (union stmsg *)bp->rptr;
                     51:                switch (sp->ioc0.com) {
                     52: 
                     53:                case TIOCGDEV:
                     54:                        sp->ioc3.sb.ispeed =
                     55:                          sp->ioc3.sb.ospeed = B9600;
                     56:                        bp->type = M_IOCACK;
                     57:                        qreply(q, bp);
                     58:                        return;
                     59:                case TIOCSDEV:
                     60:                        bp->wptr = bp->rptr;
                     61:                        bp->type = M_IOCACK;
                     62:                        qreply(q, bp);
                     63:                        return;
                     64:                default:
                     65:                        bp->type = M_IOCNAK;
                     66:                        bp->wptr = bp->rptr;
                     67:                        qreply(q, bp);
                     68:                        return;
                     69:                }
                     70: 
                     71:        case M_STOP:
                     72:                cnstate |= TTSTOP;
                     73:                break;
                     74: 
                     75:        case M_START:
                     76:                cnstate &= ~TTSTOP;
                     77:                cnstart();
                     78:                break;
                     79: 
                     80:        case M_FLUSH:
                     81:                flushq(q, 0);
                     82:                break;
                     83: 
                     84:        case M_DELAY:
                     85:        case M_DATA:
                     86:                putq(q, bp);
                     87:                cnstart();
                     88:                return;
                     89:        
                     90:        default:
                     91:                break;
                     92:        }
                     93:        freeb(bp);
                     94: }
                     95: 
                     96: /*
                     97:  * Console receive interrupt
                     98:  */
                     99: /*ARGSUSED*/
                    100: /*
                    101: cnrint(dev)
                    102: {
                    103:        register int c;
                    104: 
                    105:        c = mfpr(RXDB);
                    106:        if (c&RXDB_ID || cnrq==NULL)
                    107:                return;
                    108:        if ((cnrq->next->flag & QFULL) == 0)
                    109:                putd(cnrq->next->qinfo->putp, cnrq->next, c);
                    110: }
                    111: */
                    112: 
                    113: cntime()
                    114: {
                    115:        cnstate &= ~TIMEOUT;
                    116:        cnstart();
                    117: }
                    118: 
                    119: cnstart()
                    120: {
                    121:        register s;
                    122:        register struct block *bp;
                    123:        register u_char *cp;
                    124: 
                    125:        if (cnwq==NULL)
                    126:                return;
                    127:        s = spl1();
                    128:        while ((cnstate & (TIMEOUT|TTSTOP))==0 && cnwq->count) {
                    129:                bp = getq(cnwq);
                    130:                switch (bp->type) {
                    131: 
                    132:                case M_DATA:
                    133:                        /* Must clear high bit for monitor */
                    134:                        for(cp = bp->rptr; cp < bp->wptr; cp++)
                    135:                                *cp &= 0177;
                    136:                        (*romp->v_fwritestr)(bp->rptr, bp->wptr - bp->rptr,
                    137:                                        romp->v_fbaddr);
                    138:                        freeb(bp);
                    139:                        break;
                    140: 
                    141:                case M_DELAY:
                    142:                        timeout(cntime, (caddr_t)NULL, (int)*bp->rptr);
                    143:                        cnstate |= TIMEOUT;
                    144:                        freeb(bp);
                    145:                        splx(s);
                    146:                        return;
                    147:                default:
                    148:                        freeb(bp);
                    149:                        break;
                    150:                }
                    151:        }
                    152:        splx(s);
                    153: }
                    154: 
                    155: /*
                    156:  * Print a character on console.
                    157:  */
                    158: cnputc(c)
                    159:        register int c;
                    160: {
                    161:        register int s;
                    162: 
                    163:        s = spl7();
                    164:        if (c == '\n')
                    165:                (*romp->v_putchar)('\r');
                    166:        (*romp->v_putchar)(c);
                    167:        (void) splx(s);
                    168: }
                    169: 
                    170: cngetc()
                    171: {
                    172:        register int c;
                    173: 
                    174:        while ((c = (*romp->v_mayget)()) == -1)
                    175:                ;
                    176:        return (c);
                    177: }

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