4BSD/usr/src/cmd/berknet/dz1.c
/*
* DZ-11 driver
* ------------
*
* OPTIMIZED dz driver to handle multiple dzs as efficiently
* as possible. The efficiency is gained by disabling all
* dz transmitter interrupts and using a KW11-P to generate
* suitable interrupts. Carrier is supported but not Ring.
*
* Ian Johnstone UNSW
* May 1979
*/
#include "../defines.h"
#include "../param.h"
#include "../conf.h"
#include "../user.h"
#include "../tty.h"
#include "../proc.h"
#define NDZ 7 /* no. of dz-11s */
#define NDZLIN 8 /* no. of lines per dz DO NOT ALTER */
#define NLINES (NDZLIN*NDZ) /* total no. of lines available */
#define SSPEED 11 /* standard speed 2400 bd */
#define CLOCK 0172540 /* kw11-p lives here */
struct
{
int csr; /* control and status */
#define GO 0101 /* down, single, 100K, run */
unsigned counter; /* counter */
};
struct tty dz11[NLINES]; /* tty structures for this dz */
struct dz /* one for each dz-11 */
{
int *dzaddr; /* control registers for this dz */
char nocarr; /* set for lines WITHOUT carrier */
char sopen; /* set for lines with exclusive use */
struct tty *ttys[NDZLIN]; /* address of tty structs this dz */
/* that is only ONE `open' allowed */
char openl; /* flags for open lines */
char closl; /* flags to indicate closing lines */
char xmit; /* set for lines to transmit on */
unsigned pyerrors; /* number of parity errors on input */
unsigned overrors; /* number of overrun errors on input */
int closet[NDZLIN]; /* handle closing via this field */
}
dz[NDZ]
{
{
0160100, 0377, 0000,
&dz11[000],&dz11[001],&dz11[002],&dz11[003],
&dz11[004],&dz11[005],&dz11[006],&dz11[007]
},
{
0160110, 0007, 0000,
&dz11[010],&dz11[011],&dz11[012],&dz11[013],
&dz11[014],&dz11[015],&dz11[016],&dz11[017]
},
{
0160120, 0320, 0020,
&dz11[020],&dz11[021],&dz11[022],&dz11[023],
&dz11[024],&dz11[025],&dz11[026],&dz11[027]
},
{
0160130, 0000, 0000,
&dz11[030],&dz11[031],&dz11[032],&dz11[033],
&dz11[034],&dz11[035],&dz11[036],&dz11[037]
},
{
0160140, 0000, 0000,
&dz11[040],&dz11[041],&dz11[042],&dz11[043],
&dz11[044],&dz11[045],&dz11[046],&dz11[047]
},
{
0160150, 0360, 0100,
&dz11[050],&dz11[051],&dz11[052],&dz11[053],
&dz11[054],&dz11[055],&dz11[056],&dz11[057]
},
{
0160160, 0110, 0013,
&dz11[060],&dz11[061],&dz11[062],&dz11[063],
&dz11[064],&dz11[065],&dz11[066],&dz11[067]
},
/*
{
0160170, 0377, 0000,
&dz11[070],&dz11[071],&dz11[072],&dz11[073],
&dz11[074],&dz11[075],&dz11[076],&dz11[077]
}
*/
};
int dzopenc; /* equal to total number of 'open' lines */
int dzrcvscan; /* when <= 0 scan receiver silos */
char dzbitab[NDZLIN] /* convert line numbers to bit pattern */
{
0001, 0002, 0004, 0010, 0020, 0040, 0100, 0200
};
#define SPLDZ spl5 /* dz interrupts at this priority */
/*
* DZ11 register layout
*/
struct dzr_read
{
int dzcsr; /* r/w */
int dzrbuf; /* no bit, byte, or tst ops */
char dztcr; /* r/w */
char dzdtr; /* r/w */
char dzring;
char dzcarr;
};
struct dzr_write
{
int dzcsr;
int dzlpr; /* no bit or byte ops */
char dztcr;
char dzdtr;
char dztbuf; /* no bit ops */
char dzbrk; /* no bit ops */
};
/*
* register control bits
*/
#define SAE 010000 /* dzcsr */
#define RIE 0100
#define MSE 040
#define RCVR_ON 010000 /* dzlpr */
#define ODD_PAR 0300
#define EVN_PAR 0100
#define TWOSBIT 040
#define C8BIT 030
#define C7BIT 020
#define RERROR 070000 /* dzrbuf */
#define OVR_RUN 040000
#define FRAME 020000
#define PARITY 010000
/*
* Table to map UNIX standard speeds to DZ11 speeds.
* Illegal speeds are ignored, and are indicated by 0200 bit.
*/
char dzspeedmap[16]
{
0200 /* 0 - zero */
, 0220 /* 1 - 50 */
, 0221 /* 2 - 75 */
, 0222 /* 3 - 110 */
, 0223 /* 4 - 134.5 */
, 0224 /* 5 - 150 */
, 0200 /* 6 - ILLEGAL */
#define LOWSPEED 7 /* lowest speed allowed on dz */
, 025 /* 7 - 300 */
, 026 /* 8 - 600 */
, 027 /* 9 - 1200 */
, 0230 /* 10 - 1800 */
, 032 /* 11 - 2400 */
, 034 /* 12 - 4800 */
, 036 /* 13 - 9600 */
, 0231 /* 14 - ext A - maps to 2000 */
, 0237 /* 15 - ext B - maps to 19200 */
};
/*
* Table to map UNIX standard speeds to time between interrupts for
* a line running at that speed. The value in the table is multiplied
* by 10 to get a value in microseconds. A nominal 20 microseconds
* is subtracted to make up for interrupt overhead.
*/
unsigned dzmicmap[16]
{
0 /* 0 - zero */
, 19998 /* 1 - 50 */
, 13331 /* 2 - 75 */
, 9088 /* 3 - 110 */
, 7433 /* 4 - 134.5 */
, 6665 /* 5 - 150 */
, 0 /* 6 - ILLEGAL */
, 3331 /* 7 - 300 */
, 1665 /* 8 - 600 */
, 831 /* 9 - 1200 */
, 554 /* 10 - 1800 */
, 415 /* 11 - 2400 */
, 206 /* 12 - 4800 */
, 102 /* 13 - 9600 */
, 498 /* 14 - ext A - maps to 2000 */
, 50 /* 15 - ext B - maps to 19200 */
};
/*
* open a DZ11 line
*/
dzopen(dev, flag)
{
extern dzstart();
register struct tty *tp;
register struct dz *dzp;
register lino;
lino = dev.d_minor;
if(lino >= NLINES)
{
u.u_error = ENXIO;
return;
}
dzp = &dz[lino>>3];
if(!fkword(dzp->dzaddr)) /* fix036 */
{
u.u_error = ENXIO;
return;
} /* fix036 */
tp = &dz11[lino];
lino =& 07;
if( (dzp->sopen&dzbitab[lino]) && (dzp->openl&dzbitab[lino]) )
{
u.u_error = EOPENFAIL;
return;
}
if(u.u_procp->p_ttyp == 0)
u.u_procp->p_ttyp = tp;
SPLDZ();
if( (dzp->openl&dzbitab[lino]) == 0 )
{
tp->t_dev = dev;
tp->t_state = (ISOPEN|CARR_ON|SSTART);
tp->t_addr = &dzstart;
tp->t_speeds = SSPEED|(SSPEED<<8);
tp->t_flags = ODDP|EVENP|XTABS|RAW;
tp->t_erase = CERASE;
tp->t_kill = CKILL;
dzparam(tp);
if(dzp->openl == 0)
dzp->dzaddr->dzcsr =| (RIE|SAE|MSE); /* init */
dzp->openl =| dzbitab[lino];
if(dzopenc++ == 0)
dzxint(); /* start transmitting */
}
else
dzp->closl =& ~dzbitab[lino];
spl0();
}
/*
* close a DZ11 line
*/
dzclose(dev)
{
register struct tty *tp;
register struct dz *dzp;
register lino;
lino = dev.d_minor;
dzp = &dz[lino>>3];
tp = &dz11[lino];
lino =& 07;
dzp->closet[lino] = tp->t_outq.c_cc << 1; /* time for close */
dzp->closl =| dzbitab[lino];
dzp->xmit =| dzbitab[lino]; /* start transmitting */
dzp->dzaddr->dztcr =| dzbitab[lino]; /* start transmitting */
}
/*
* read from a DZ11 line
*/
dzread(dev)
{
ttread( &dz11[dev.d_minor] );
}
/*
* write on a DZ11 line
*/
dzwrite(dev)
{
ttwrite( &dz11[dev.d_minor] );
}
/*
* stty/gtty for DZ11
*/
dzsgtty(dev, av)
{
register struct tty *tp;
if((av == 0) && (dzspeedmap[u.u_arg[0]&017] < 0))
{
u.u_error = ENXIO; /* illegal speed */
return;
}
tp = &dz11[dev.d_minor];
if(ttystty(tp, av))
return;
dzparam(tp);
}
/*
* set parameters from open or stty into DZ hardware registers
*/
dzparam(tp)
register struct tty *tp;
{
register lpr, x;
extern wakeup();
lpr = dzspeedmap[tp->t_speeds&017]<<8;
if((x = tp->t_flags)&EVENP)
if((x&ODDP) == 0)
lpr =| (EVN_PAR|C7BIT);
else
lpr =| C8BIT;
else if(x&ODDP)
lpr =| (ODD_PAR|C7BIT);
else
lpr =| C8BIT;
/* set new speed, char currently in uart may be screwed */
dz[tp->t_dev.d_minor>>3].dzaddr->dzlpr = lpr|(tp->t_dev.d_minor&07);
}
/*
* dz start routine
*/
dzstart(tp) /* at SPLDZ */
struct tty *tp;
{
register lino = tp->t_dev.d_minor;
register struct dz *dzp;
dzp = &dz[lino>>3];
lino =& 07;
dzp->xmit =| dzbitab[lino]; /* start transmitting */
dzp->dzaddr->dztcr =| dzbitab[lino]; /* start transmitting */
}
/*
* DZ11 transmitter interrupt.
*
* Scan every line on each dz. Internal dz limitations
* force this scan to take an unusual form. One line
* from each dz is serviced each scan until no dz requires
* service. This is less efficient than servicing
* entirely a dz prior to scanning the next dz but it
* it is necessary.
*
* dzxint is not actually invoked by a dz interrupt
* rather it is invoked by a clock interrupt.
* to drive multiple dz's efficiently utilizing dz
* transmitter interrupts is just NOT possible.
*/
int dzxc;
dzxint() /* at SPLDZ */
{
extern ttrstrt();
register struct dz *dzp;
int hspeed = LOWSPEED; /* to determine clock speed */
int flag; /* control dz scanning */
dzxc++; /* count */
if( dzopenc == 0 ) return; /* stop if inactive */
/* scan every dz for characters to transmit */
do
{
for(dzp = &dz[0], flag=0; dzp < &dz[NDZ]; dzp++ )
{
register struct tty *tp;
register struct dzr_read *dza = dzp->dzaddr;
int lino, t_bit;
if((lino = dza->dzcsr.hibyte) < 0) /* xmit ?? */
{
lino =& 07; /* isolate line number */
tp = dzp->ttys[lino];
t_bit = dzbitab[lino]; /* bit mask, not line number */
flag++; /* note service */
if( (dzp->closl & t_bit)
&& ((--(dzp->closet[lino]) <= 0) || (tp->t_outq.c_cc == 0)) )
{
/* line closed, no time or chars left */
flushtty(tp);
tp->t_state = SSTART;
dzp->closl =& ~t_bit;
dzp->openl =& ~t_bit;
dzp->xmit =& ~t_bit;
dza->dztcr =& ~t_bit;
dza->dzdtr =& ~t_bit;
if( (dzp->closl==0) && (dzp->openl==0) )
dza->dzcsr = 0;
if( --dzopenc == 0 )
return;
}
else if(tp->t_outq.c_cc == 0)
{
dzp->xmit =& ~t_bit;
dza->dztcr =& ~t_bit;
}
else if((dzp->nocarr&t_bit)||(dza->dzcarr&t_bit))
{
int c = getc(&tp->t_outq);
if( c <= 0177 || tp->t_flags == RAW )
{
/* transmit the char for this line */
dza->dztbuf = c;
if( tp->t_speeds.lobyte > hspeed )
hspeed = tp->t_speeds.lobyte;
}
else
{
dzp->xmit =& ~t_bit;
dza->dztcr =& ~t_bit;
timeout( &ttrstrt, tp, c&0177 );
tp->t_state =| TIMEOUT;
}
/* if low water mark then want more */
if( tp->t_state&ASLEEP
&& tp->t_outq.c_cc <= TTLOWAT )
{
tp->t_state =& ~ASLEEP;
wakeup(&tp->t_outq);
}
}
else
{
dza->dztcr =& ~t_bit;
}
}
}
} while( flag );
/* finalize state of DZs prior to exitting */
for(dzp = &dz[0]; dzp < &dz[NDZ]; dzp++ )
{
register struct dzr_read *dza = dzp->dzaddr;
/* dtr to reflect state of carrier, for carrier lines */
dza->dzdtr = (dza->dzcarr | dzp->nocarr) & dzp->openl;
/* Enable all lines still with characters to send */
dza->dztcr = dzp->xmit;
}
/* setup for next interrupt */
CLOCK->counter = dzmicmap[hspeed]; /* count in 10microseconds */
CLOCK->csr = GO;
/* call dzrint if needed */
if( dzrcvscan <= 0 )
dzrint(0);
dzrcvscan =- dzmicmap[hspeed];
}
/*
* DZ11 receiver interrupt
*
* Scan each dz commencing with the particular device that caused this call
* Scan at least every dzmicmap[LOWSPEED] microseconds.
*/
dzrint(dev)
{
register struct tty *tp;
register struct dz *dzp;
register int lino;
int i, c;
for(dzp = &dz[dev], i = 0; i < NDZ; i++)
{
while((c = dzp->dzaddr->dzrbuf) < 0) /* char present in silo */
{
lino = c.hibyte; lino =& 07;
if( ((dzp->nocarr&dzbitab[lino]) == 0 )
&& ((dzp->dzaddr->dzcarr&dzbitab[lino]) == 0 )) continue;
if( (dzp->openl&dzbitab[lino]) == 0 ) continue;
tp = dzp->ttys[lino];
if(c&RERROR)
{
if( (c & FRAME) && (tp->t_flags & RAW ) )
ttyinput(0, tp); /* break for getty */
else if(c & OVR_RUN)
dzp->overrors++;
else if(c & PARITY)
dzp->pyerrors++;
}
else
{
ttyinput(c, tp);
}
}
if( ++dzp >= &dz[NDZ] ) dzp = &dz[0];
}
dzrcvscan = dzmicmap[LOWSPEED];
}