UNIX 7th Ed. - /usr/sys/dev/dz.c

   1: /*
   2:  *	DZ11 driver
   3:  * CAUTION -- MODIFIED FROM WORKING VERSION BUT NEVER PROPERLY TESTED
   4:  */
   5: 
   6: #include "../h/param.h"
   7: #include "../h/dir.h"
   8: #include "../h/user.h"
   9: #include "../h/tty.h"
  10: 
  11: struct device *dz_addr[] = { (struct device *)0160100, (struct device *)0160110};
  12: int dz_cnt = 16;
  13: struct tty dz_tty[16];
  14: char    dz_stat;
  15: 
  16: char    dz_speeds[] = {
  17:     0, 020, 021, 022, 023, 024, 0, 025,
  18:     026, 027, 030, 032, 034, 036, 0, 0,
  19:     };
  20: 
  21: #define BITS7   020
  22: #define BITS8   030
  23: #define TWOSB   040
  24: #define PENABLE 0100
  25: #define OPAR    0200
  26: #define RCVENA  010000
  27: 
  28: #define IE  040140
  29: #define PERROR  010000
  30: #define FRERROR 020000
  31: #define SSPEED  7   /* standard speed: 300 baud */
  32: 
  33: struct device {
  34:     int dzcsr, dzrbuf;
  35:     char    dztcr, dzdtr;
  36:     char    dztbuf, dzbrk;
  37: };
  38: #define dzlpr   dzrbuf
  39: #define dzmsr   dzbrk
  40: 
  41: #define ON  1
  42: #define OFF 0
  43: 
  44: 
  45: dzopen(dev, flag)
  46: {
  47:     register struct tty *tp;
  48:     int x;
  49:     extern dzstart(), dzscan();
  50: 
  51:     x = dev;
  52:     dev = minor(dev);
  53:     if (dev >= dz_cnt) {
  54:         u.u_error = ENXIO;
  55:         return;
  56:     }
  57:     tp = &dz_tty[dev];
  58:     if ((tp->t_state&(ISOPEN|WOPEN)) == 0) {
  59:         tp->t_oproc = dzstart;
  60:         tp->t_iproc = NULL;
  61:         ttychars(tp);
  62:         tp->t_ispeed = SSPEED;
  63:         tp->t_ospeed = SSPEED;
  64:         tp->t_flags = ODDP|EVENP|ECHO;
  65:         dzparam(dev);
  66:     }
  67:     dzmodem(dev, ON);
  68:     spl6();
  69:     while ((tp->t_state&CARR_ON)==0) {
  70:         tp->t_state |= WOPEN;
  71:         sleep((caddr_t)&tp->t_rawq, TTIPRI);
  72:     }
  73:     ttyopen(x,tp);
  74:     spl0();
  75: }
  76: 
  77: dzclose(dev)
  78: {
  79:     register struct tty *tp;
  80: 
  81:     dev = minor(dev);
  82:     tp = &dz_tty[dev];
  83:     wflushtty(tp);
  84:     if (tp->t_state&HUPCLS) {
  85:         dzmodem(dev, OFF);
  86:     }
  87:     tp->t_state &= CARR_ON;
  88: }
  89: 
  90: dzread(dev)
  91: {
  92:     dev = minor(dev);
  93:     ttread(&dz_tty[dev]);
  94: }
  95: 
  96: dzwrite(dev)
  97: {
  98:     dev = minor(dev);
  99:     ttwrite(&dz_tty[dev]);
 100: }
 101: 
 102: dzioctl(dev, cmd, addr, flag)
 103: {
 104:     register struct tty *tp;
 105: 
 106:     dev = minor(dev);
 107:     tp = &dz_tty[dev];
 108:     if (ttioccomm(cmd, tp, (caddr_t)addr, dev)) {
 109:         if (cmd==TIOCSETP||cmd==TIOCSETN)
 110:             dzparam(dev);
 111:     } else {
 112:         u.u_error = ENOTTY;
 113:     }
 114: }
 115: 
 116: dzparam(dev)
 117: {
 118:     register struct tty *tp;
 119:     register struct device *dzaddr;
 120:     register lpr;
 121: 
 122:     tp = &dz_tty[dev];
 123:     dzaddr= dz_addr[dev>>3];
 124:     dzaddr->dzcsr = IE;
 125:     if (dz_stat==0) {
 126:         dzscan();
 127:         dz_stat++;
 128:     }
 129:     if (tp->t_ispeed==0) {  /* Hang up line */
 130:         dzmodem(dev, OFF);
 131:         return;
 132:     }
 133:     lpr = (dz_speeds[tp->t_ispeed]<<8)|(dev&07);
 134:     if (tp->t_flags&RAW)
 135:         lpr |= BITS8;
 136:     else
 137:         lpr |= BITS7|PENABLE;
 138:     if ((tp->t_flags&EVENP)==0)
 139:         lpr |= OPAR;
 140:     if (tp->t_ispeed == 3)  /* 110 baud */
 141:         lpr |= TWOSB;
 142:     dzaddr->dzlpr = lpr;
 143: }
 144: 
 145: dzrint(dev)
 146: {
 147:     register struct tty *tp;
 148:     register c;
 149:     register struct device *dzaddr;
 150: 
 151:     dzaddr = dz_addr[dev];
 152:     while ((c = dzaddr->dzrbuf) < 0) {  /* char. present */
 153:         tp = &dz_tty[((c>>8)&07)|(dev<<3)];
 154:         if (tp >= &dz_tty[dz_cnt])
 155:             continue;
 156:         if((tp->t_state&ISOPEN)==0) {
 157:             wakeup((caddr_t)&tp->t_rawq);
 158:             continue;
 159:         }
 160:         if (c&FRERROR)      /* break */
 161:             if (tp->t_flags&RAW)
 162:                 c = 0;      /* null (for getty) */
 163:             else
 164:                 c = 0177;   /* DEL (intr) */
 165:         if (c&PERROR)
 166:             if ((tp->t_flags&(EVENP|ODDP))==EVENP
 167:              || (tp->t_flags&(EVENP|ODDP))==ODDP )
 168:                 continue;
 169:         ttyinput(c, tp);
 170:     }
 171: }
 172: 
 173: dzxint(dev)
 174: {
 175:     register struct tty *tp;
 176:     register struct device *dzaddr;
 177: 
 178:     dzaddr = dz_addr[dev];
 179:     while(dzaddr->dzcsr<0) {    /* TX rdy */
 180:         tp = &dz_tty[((dev<<3)|(dzaddr->dzcsr>>8)&07)];
 181:         dzaddr->dztbuf = tp->t_char;
 182:         tp->t_state &= ~BUSY;
 183:         dzstart(tp);
 184:     }
 185: }
 186: 
 187: dzstart(tp)
 188: register struct tty *tp;
 189: {
 190:     register unit, c;
 191:     int s;
 192:     struct device *dzaddr;
 193:     extern ttrstrt();
 194: 
 195:     unit = tp - dz_tty;
 196:     dzaddr = dz_addr[unit>>3];
 197:     unit = 1<<(unit&07);
 198:     s = spl5();
 199:     if (tp->t_state&(TIMEOUT|BUSY)) {
 200:         splx(s);
 201:         return;
 202:     }
 203:     if (tp->t_state&TTSTOP) {
 204:         dzaddr->dztcr &= ~unit;
 205:         splx(s);
 206:         return;
 207:     }
 208:     if ((c=getc(&tp->t_outq)) >= 0) {
 209:         if (c>=0200 && (tp->t_flags&RAW)==0) {
 210:             dzaddr->dztcr &= ~unit;
 211:             tp->t_state |= TIMEOUT;
 212:             timeout(ttrstrt, (caddr_t)tp, (c&0177)+6);
 213:         } else {
 214:             tp->t_char = c;
 215:             tp->t_state |= BUSY;
 216:             dzaddr->dztcr |= unit;
 217:         }
 218:         if (tp->t_outq.c_cc<=TTLOWAT && tp->t_state&ASLEEP) {
 219:             tp->t_state &= ~ASLEEP;
 220:             wakeup((caddr_t)&tp->t_outq);
 221:         }
 222:     } else
 223:         dzaddr->dztcr &= ~unit;
 224:     splx(s);
 225: }
 226: 
 227: dzmodem(dev, flag)
 228: {
 229:     register struct device *dzaddr;
 230:     register bit;
 231: 
 232:     dzaddr = dz_addr[dev>>3];
 233:     bit = 1<<(dev&07);
 234:     if (flag==OFF)
 235:         dzaddr->dzdtr &= ~bit;
 236:     else    dzaddr->dzdtr |= bit;
 237: }
 238: 
 239: dzscan()
 240: {
 241:     register i;
 242:     register struct device *dzaddr;
 243:     register struct tty *tp;
 244:     char    bit;
 245: 
 246:     for (i=0; i<dz_cnt; i++) {
 247:         dzaddr = dz_addr[i>>3];
 248:         tp = &dz_tty[i];
 249:         bit = 1<<(i&07);
 250:         if (dzaddr->dzmsr&bit) {
 251:             if ((tp->t_state&CARR_ON)==0) {
 252:                 wakeup((caddr_t)&tp->t_rawq);
 253:                 tp->t_state |= CARR_ON;
 254:             }
 255:         } else {
 256:             if (tp->t_state&CARR_ON) {
 257:                 if (tp->t_state&ISOPEN) {
 258:                     signal(tp->t_pgrp, SIGHUP);
 259:                     dzaddr->dzdtr &= ~bit;
 260:                     flushtty(tp);
 261:                 }
 262:                 tp->t_state &= ~CARR_ON;
 263:             }
 264:         }
 265:     }
 266:     timeout(dzscan, (caddr_t)0, 120);
 267: }

Defined functions

Defined variables

Defined struct's

Defined macros