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

   1: #include "../h/param.h"
   2: #include "../h/conf.h"
   3: #include "../h/dir.h"
   4: #include "../h/user.h"
   5: #include "../h/tty.h"
   6: #include "../h/systm.h"
   7: 
   8: /*
   9:  * Base address of DC-11's. Minor device  i  is at
  10:  * DCADDR + 10*i.
  11:  */
  12: #define DCADDR  (struct device *)0174000
  13: 
  14: /*
  15:  * Number of DC's for which table space is allocated.
  16:  */
  17: #define NDC11   4
  18: 
  19: /*
  20:  * Control bits in device registers
  21:  */
  22: #define CDLEAD  01
  23: #define CARRIER 04
  24: #define SPEED1  010
  25: #define STOP1   0400
  26: #define RQSEND  01
  27: #define PARITY  040
  28: #define ERROR   0100000
  29: #define CTRANS  040000
  30: #define RINGIND 020000
  31: 
  32: 
  33: struct  tty dc11[NDC11];
  34: 
  35: struct device {
  36:     int dcrcsr;
  37:     int dcrbuf;
  38:     int dctcsr;
  39:     int dctbuf;
  40: };
  41: 
  42: /*
  43:  * Input-side speed and control bit table.
  44:  * Each DC11 has 4 speeds which correspond to the 4 non-zero entries.
  45:  * The table index is the same as the speed-selector
  46:  * number for the DH11.
  47:  * Attempts to set the speed to a zero entry are ignored.
  48:  */
  49: int dcrstab[] = {
  50:     0,      /* 0 baud */
  51:     0,      /* 50 baud */
  52:     0,      /* 75 baud */
  53:     0,      /* 110 baud */
  54:     01101,      /* 134.5 baud: 7b/ch, speed 0 */
  55:     0111,       /* 150 baud: 8b/ch, speed 1 */
  56:     0,      /* 200 baud */
  57:     0121,       /* 300 baud: 8b/ch, speed 2 */
  58:     0,      /* 600 baud */
  59:     0131,       /* 1200 baud */
  60:     0,      /* 1800 baud */
  61:     0,      /* 2400 baud */
  62:     0,      /* 4800 baud */
  63:     0,      /* 9600 baud */
  64:     0,      /* X0 */
  65:     0,      /* X1 */
  66: };
  67: 
  68: /*
  69:  * Transmitter speed table
  70:  */
  71: int dctstab[] = {
  72:     0,      /* 0 baud */
  73:     0,      /* 50 baud */
  74:     0,      /* 75 baud */
  75:     0,      /* 110 baud */
  76:     0501,       /* 134.5 baud: stop 1 */
  77:     0511,       /* 150 baud */
  78:     0,      /* 200 baud */
  79:     0521,       /* 300 baud */
  80:     0,      /* 600 baud */
  81:     0531,       /* 1200 baud */
  82:     0,      /* 1800 baud */
  83:     0,      /* 2400 baud */
  84:     0,      /* 4800 baud */
  85:     0,      /* 9600 baud */
  86:     0,      /* X0 */
  87:     0,      /* X1 */
  88: };
  89: 
  90: /*
  91:  * Open a DC11, waiting until carrier is established.
  92:  * Default initial conditions are set up on the first open.
  93:  * t_state's CARR_ON bit is a pure copy of the hardware
  94:  * CARRIER bit, and is only used to regularize
  95:  * carrier tests in general tty routines.
  96:  */
  97: dcopen(dev, flag)
  98: dev_t dev;
  99: {
 100:     register struct tty *tp;
 101:     register struct device *addr;
 102:     extern int klstart();
 103:     int s;
 104: 
 105:     if (minor(dev) >= NDC11) {
 106:         u.u_error = ENXIO;
 107:         return;
 108:     }
 109:     tp = &dc11[minor(dev)];
 110:     addr = DCADDR + minor(dev);
 111:     tp->t_addr = (caddr_t)addr;
 112:     tp->t_state |= WOPEN;
 113:     s = spl5();
 114:     addr->dcrcsr |= IENABLE|CDLEAD;
 115:     if ((tp->t_state&ISOPEN) == 0) {
 116:         tp->t_erase = CERASE;
 117:         tp->t_kill = CKILL;
 118:         addr->dcrcsr = IENABLE|CDLEAD|SPEED1;
 119:         addr->dctcsr = IENABLE|SPEED1|STOP1|RQSEND;
 120:         tp->t_state = ISOPEN | WOPEN;
 121:         tp->t_flags = ODDP|EVENP|ECHO;
 122:         tp->t_oproc = klstart;
 123:     }
 124:     if (addr->dcrcsr & CARRIER)
 125:         tp->t_state |= CARR_ON;
 126:     splx(s);
 127:     while ((tp->t_state & CARR_ON) == 0)
 128:         sleep((caddr_t)&tp->t_rawq, TTIPRI);
 129:     ttyopen(dev, tp);
 130: }
 131: 
 132: /*
 133:  * Close a dc11
 134:  */
 135: dcclose(dev)
 136: dev_t dev;
 137: {
 138:     register struct tty *tp;
 139: 
 140:     tp = &dc11[minor(dev)];
 141:     if (tp->t_state&HUPCLS)
 142:         ((struct device *)(tp->t_addr))->dcrcsr &= ~CDLEAD;
 143:     ttyclose(tp);
 144: }
 145: 
 146: /*
 147:  * Read a DC11
 148:  */
 149: dcread(dev)
 150: dev_t dev;
 151: {
 152:     ttread(&dc11[minor(dev)]);
 153: }
 154: 
 155: /*
 156:  * Write a DC11
 157:  */
 158: dcwrite(dev)
 159: dev_t dev;
 160: {
 161:     ttwrite(&dc11[minor(dev)]);
 162: }
 163: 
 164: /*
 165:  * DC11 transmitter interrupt.
 166:  */
 167: dcxint(dev)
 168: dev_t dev;
 169: {
 170:     register struct tty *tp;
 171: 
 172:     tp = &dc11[minor(dev)];
 173:     ttstart(tp);
 174:     if (tp->t_outq.c_cc == 0 || tp->t_outq.c_cc == TTLOWAT)
 175:         wakeup((caddr_t)&tp->t_outq);
 176: }
 177: 
 178: /*
 179:  * DC11 receiver interrupt.
 180:  */
 181: dcrint(dev)
 182: dev_t dev;
 183: {
 184:     register struct tty *tp;
 185:     register int c, csr;
 186: 
 187:     tp = &dc11[minor(dev)];
 188:     c = ((struct device *)(tp->t_addr))->dcrbuf;
 189:     /*
 190: 	 * If carrier is off, and an open is not in progress,
 191: 	 * knock down the CD lead to hang up the local dataset
 192: 	 * and signal a hangup.
 193: 	 */
 194:     if (((csr = ((struct device *)(tp->t_addr))->dcrcsr) & CARRIER) == 0) {
 195:         if ((tp->t_state&WOPEN) == 0) {
 196:             ((struct device *)(tp->t_addr))->dcrcsr &= ~CDLEAD;
 197:             if (tp->t_state & CARR_ON)
 198:                 signal(tp->t_pgrp, SIGHUP);
 199:             flushtty(tp);
 200:         }
 201:         tp->t_state &= ~CARR_ON;
 202:         return;
 203:     }
 204:     if (csr&ERROR || (tp->t_state&ISOPEN)==0) {
 205:         if (tp->t_state&WOPEN && csr&CARRIER)
 206:             tp->t_state |= CARR_ON;
 207:         wakeup((caddr_t)tp);
 208:         return;
 209:     }
 210:     csr &= PARITY;
 211:     if (csr&&(tp->t_flags&ODDP) || !csr&&(tp->t_flags&EVENP))
 212:         ttyinput(c, tp);
 213: }
 214: 
 215: /*
 216:  * DC11 stty/gtty.
 217:  * Perform general functions and set speeds.
 218:  */
 219: dcioctl(dev, cmd, addr, flag)
 220: dev_t dev;
 221: caddr_t addr;
 222: {
 223:     register struct tty *tp;
 224:     register r;
 225: 
 226:     tp = &dc11[minor(dev)];
 227:     if (ttioccom(cmd, &dc11[minor(dev)], addr, dev) == 0) {
 228:         u.u_error = ENOTTY;
 229:         return;
 230:     }
 231:     if (cmd == TIOCSETP) {
 232:         r = dcrstab[tp->t_ispeed];
 233:         if (r)
 234:             ((struct device *)(tp->t_addr))->dcrcsr = r;
 235:         else
 236:             ((struct device *)(tp->t_addr))->dcrcsr &= ~CDLEAD;
 237:         r = dctstab[tp->t_ospeed];
 238:         ((struct device *)(tp->t_addr))->dctcsr = r;
 239:     }
 240: }

Defined functions

Defined variables

Defined struct's

Defined macros