1: /*
   2:  * Copyright (c) 1982, 1986 Regents of the University of California.
   3:  * All rights reserved.  The Berkeley software License Agreement
   4:  * specifies the terms and conditions for redistribution.
   5:  *
   6:  *	@(#)ct.c	7.1 (Berkeley) 6/5/86
   7:  */
   8: 
   9: #include "ct.h"
  10: #if NCT > 0
  11: /*
  12:  * GP DR11C driver used for C/A/T or Autologic APS micro-5
  13:  */
  14: #include "../machine/pte.h"
  15: 
  16: #include "param.h"
  17: #include "systm.h"
  18: #include "ioctl.h"
  19: #include "tty.h"
  20: #include "map.h"
  21: #include "buf.h"
  22: #include "conf.h"
  23: #include "dir.h"
  24: #include "user.h"
  25: #include "kernel.h"
  26: 
  27: #include "ubareg.h"
  28: #include "ubavar.h"
  29: 
  30: #define PCAT    (PZERO+9)
  31: #define CATHIWAT    100
  32: #define CATLOWAT    30
  33: 
  34: #define REQUEST_B   0x8000
  35: #define REQUEST_A   0x80
  36: #define INT_ENB_A   0x40
  37: #define INT_ENB_B   0x20
  38: #define CSR1        0x2
  39: #define CSR0        0x1
  40: 
  41: struct ct_softc {
  42:     int sc_state;
  43:     struct  clist sc_oq;
  44: } ct_softc[NCT];
  45: 
  46: #define CT_OPEN     0x1
  47: #define CT_RUNNING  0x2
  48: 
  49: struct ctdevice {
  50:     u_short ctcsr;
  51:     u_short ctobuf;
  52:     u_short ctibuf;
  53: };
  54: 
  55: int ctprobe(), ctattach(), ctintr();
  56: struct  uba_device *ctdinfo[NCT];
  57: u_short ctstd[] = { 0167770, 0 };
  58: struct  uba_driver ctdriver =
  59:     { ctprobe, 0, ctattach, 0, ctstd, "ct", ctdinfo };
  60: 
  61: #define CTUNIT(dev) (minor(dev))
  62: 
  63: int ct_init = 0;    /* set to CSR1 for testing loopback on controller */
  64: 
  65: ctprobe(reg)
  66:     caddr_t reg;
  67: {
  68:     register int br, cvec;      /* value-result */
  69:     register struct ctdevice *ctaddr = (struct ctdevice *)reg;
  70: 
  71: #ifdef lint
  72:     br = 0; cvec = br; br = cvec;
  73:     ctintr(0);
  74: #endif
  75:     /*
  76: 	 * There is no way to make a DR11c interrupt without some
  77: 	 * external support. We can't always trust that the typesetter
  78: 	 * will be online and ready so we've made other provisions.
  79: 	 * This probe assumes setting the B Int Enb will generate
  80: 	 * an interrupt. To do this, we set CSR0 and loop this back
  81: 	 * to REQUEST_B in the second plug on the controller.
  82: 	 * Then, we reset the vector to be that for the "real" device.
  83: 	 */
  84:     ctaddr->ctcsr = INT_ENB_B | CSR0; /* Assume hardware loopback! */
  85:     DELAY(1000);
  86:     ctaddr->ctcsr = ct_init; /* should be CSR1 for loopback testing */
  87:     if (cvec & 04) {
  88:         printf("ct: resetting vector %o to %o\n", cvec, cvec&0773);
  89:         cvec &= 0773;
  90:     }
  91:     return (sizeof (struct ctdevice));
  92: }
  93: 
  94: /*ARGSUSED*/
  95: ctattach(ui)
  96:     struct uba_device *ui;
  97: {
  98: }
  99: 
 100: ctopen(dev)
 101:     dev_t dev;
 102: {
 103:     register struct ct_softc *sc;
 104:     register struct uba_device *ui;
 105:     register struct ctdevice *ctaddr;
 106: 
 107:     if (CTUNIT(dev) >= NCT || (ui = ctdinfo[CTUNIT(dev)]) == 0 ||
 108:         ui->ui_alive == 0)
 109:         return (ENODEV);
 110:     if ((sc = &ct_softc[CTUNIT(dev)])->sc_state&CT_OPEN)
 111:         return (EBUSY);
 112:     sc->sc_state = CT_OPEN;
 113:     ctaddr = (struct ctdevice *)ui->ui_addr;
 114:     ctaddr->ctcsr |= INT_ENB_A;
 115:     return (0);
 116: }
 117: 
 118: ctclose(dev)
 119:     dev_t dev;
 120: {
 121:     ct_softc[CTUNIT(dev)].sc_state = 0;
 122:     ctintr(dev);
 123:     return (0);
 124: }
 125: 
 126: ctwrite(dev, uio)
 127:     dev_t dev;
 128:     struct uio *uio;
 129: {
 130:     register struct ct_softc *sc = &ct_softc[CTUNIT(dev)];
 131:     register int c;
 132:     int s;
 133: 
 134:     while ((c = uwritec(uio)) >= 0) {
 135:         s = spl5();
 136:         while (sc->sc_oq.c_cc > CATHIWAT)
 137:             sleep((caddr_t)&sc->sc_oq, PCAT);
 138:         while (putc(c, &sc->sc_oq) < 0)
 139:             sleep((caddr_t)&lbolt, PCAT);
 140:         if ( ! (sc->sc_state & CT_RUNNING) )
 141:             ctintr(dev);
 142:         splx(s);
 143:     }
 144:     return (0);
 145: }
 146: 
 147: /*
 148:  * The C/A/T is usually wired to accept data on the .5us DATA_AVAIL strobe.
 149:  * If you use this with a C/A/T you can remove the lines with "APSu5" below.
 150:  * This is way out of spec for the Autologic APS micro-5 which requires
 151:  * at least a 40 microsec strobe. We therefore use CSR1 output as the
 152:  * "strobe". It is set after data is loaded and reset only in the
 153:  * interrupt routine. Therefore, the "strobe" is high for adequate time.
 154:  * The constant "ctdelay" determines the "low" time for the strobe
 155:  * and may have to be larger on a 780. "2" gives about 10us on a 750.
 156:  */
 157: int ctdelay = 2;    /* here so it's visible & changeable */
 158: 
 159: ctintr(dev)
 160:     dev_t dev;
 161: {
 162:     register int c;
 163:     register struct ct_softc *sc = &ct_softc[CTUNIT(dev)];
 164:     register struct ctdevice *ctaddr =
 165:         (struct ctdevice *)ctdinfo[CTUNIT(dev)]->ui_addr;
 166: 
 167:     if ((ctaddr->ctcsr&(INT_ENB_B|REQUEST_B)) == (INT_ENB_B|REQUEST_B)) {
 168:         ctaddr->ctcsr &= ~(CSR0 | INT_ENB_B);   /* set in ctprobe */
 169:     }
 170:     if ((ctaddr->ctcsr&(INT_ENB_A|REQUEST_A)) == (INT_ENB_A|REQUEST_A)) {
 171:         if ((c = getc(&sc->sc_oq)) >= 0) {
 172:             ctaddr->ctcsr &= ~CSR1; /* APSu5 - drop strobe */
 173:             ctaddr->ctobuf = c;
 174:             DELAY(ctdelay);     /* APSu5 - pause a bit */
 175:             ctaddr->ctcsr |= CSR1;  /* APSu5 - raise strobe */
 176:             sc->sc_state |= CT_RUNNING;
 177:             if (sc->sc_oq.c_cc==0 || sc->sc_oq.c_cc==CATLOWAT)
 178:                 wakeup((caddr_t)&sc->sc_oq);
 179:         } else if (sc->sc_state == 0) {
 180:                 ctaddr->ctcsr = 0;
 181:         } else
 182:             sc->sc_state &= ~CT_RUNNING;
 183:     }
 184: }
 185: #endif

Defined functions

ctattach defined in line 95; used 2 times
ctclose defined in line 118; never used
ctintr defined in line 159; used 4 times
ctopen defined in line 100; never used
ctprobe defined in line 65; used 2 times
ctwrite defined in line 126; never used

Defined variables

ct_init defined in line 63; used 1 times
  • in line 86
ct_softc defined in line 44; used 4 times
ctdelay defined in line 157; used 1 times
ctdinfo defined in line 56; used 3 times
ctdriver defined in line 58; never used
ctstd defined in line 57; used 1 times
  • in line 59

Defined struct's

ct_softc defined in line 41; used 6 times
ctdevice defined in line 49; used 14 times

Defined macros

CATHIWAT defined in line 31; used 1 times
CATLOWAT defined in line 32; used 1 times
CSR0 defined in line 39; used 2 times
CSR1 defined in line 38; used 2 times
CTUNIT defined in line 61; used 7 times
CT_OPEN defined in line 46; used 2 times
CT_RUNNING defined in line 47; used 3 times
INT_ENB_A defined in line 36; used 3 times
INT_ENB_B defined in line 37; used 4 times
PCAT defined in line 30; used 2 times
REQUEST_A defined in line 35; used 2 times
  • in line 170(2)
REQUEST_B defined in line 34; used 2 times
  • in line 167(2)
Last modified: 1986-06-05
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 1400
Valid CSS Valid XHTML 1.0 Strict