projects / unix-history / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
BSD 4 development
[unix-history] / usr / src / cmd / berknet / dz2.c
/*
* DZ-11 driver
* ------------
*
* Written to handle single dz - `carrier'|`ring' support non-existent
*
* Piers Lauder
* SYDNEY UNIVERSITY
* July 1977
*
* Re-written to handle multiple dz's and `carrier'|`ring'.
*
* Ian Johnstone
* UNSW
* December 1977
* January 1978
*
* General tidy up, new comments etc. Removal of ifdefs
* for CARRIER and RING. If you don't want them, tough.
*
* Chris Maltby
* Basser October 1979
*/
/* ( no messages )
#define MESSAGES
/*
* Define this if you want parity and framing errors
* to be logged (via printf). It can be very wordy.
*/
#define INTR_ON_BREAK
/*
* Define this to translate framing errors (breaks)
* to CINTR for terminals which lack a DEL key.
* Can be nasty if you get lots of line errors.
*/
/* (not DEBUG)
#define DEBUG
/*
* Define to debug info for dialup lines.
* costs approximately 128 bytes
*/
#include "../defines.h"
#include "../param.h"
#ifdef DEBUG
#ifdef AUSAML
#include "../lnode.h"
#endif AUSAML
#include "../systm.h"
#endif DEBUG
#include "../conf.h"
#include "../user.h"
#include "../tty.h"
#include "../proc.h"
#define NDZ 2 /* number of DZ-11s */
#define NLINES 8*NDZ /* total number of lines */
#define TSCANRATE 2 /* dzscan called every 2 tics */
/* Must be >= 2 always */
#define RESPONDTIME (25*HZ) /* Carrier must be raised inside this */
#define CARRIERTIME (1*HZ) /* Carrier must drop for this before hangup */
#define FLUSHTIME 5 /* time required to allow hardware buffered
* characters to flush before setting speed */
#define SSPEED 12 /* standard speed 4800 bd */
struct dz /* one for each dz-11 */
{
int *dzaddr; /* dz device address */
char sopen; /* bit set for single open lines */
char carrier; /* bits set for carrier controlled lines */
char ring; /* bits set for lines with dial in modems */
char active; /* bits set for active dialup lines */
char openl; /* bits set for open lines */
unsigned pyerrors; /* count of of parity errors on input */
unsigned overrors; /* count of of overrun errors on input */
}
dz[NDZ]
{
/* dzaddr sopen carr ring */
{ 0160040, 0002, 0077, 0074 },
{ 0160050, 0000, 0000, 0000 }
};
int dzscanning; /* set when scanning for input and modem change */
/*
* 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; /* r/w */
int dzlpr; /* no bit or byte ops */
char dztcr; /* r/w */
char dzdtr; /* r/w */
char dztbuf; /* no bit ops */
char dzbrk; /* no bit ops */
};
/*
* register control bits
*/
#define TRDY 0100000 /* dzcsr */
#define TIE 040000
#define SA 020000
#define SAE 010000
#define TLINE 03400
#define RDONE 0200
#define RIE 0100
#define MSE 040
#define CLR 020
#define RCVR_ON 010000 /* dzlpr */
#define S9600 07000
#define S300 02400
#define S134_5 01400
#define S110 01000
#define ODD_PAR 0300
#define EVN_PAR 0100
#define TWOSBIT 040
#define C8BIT 030
#define C7BIT 020
#define C6BIT 010
/*
#define IBM2741 RCVR_ON|S134_5|ODD_PAR|C6BIT /* if you must */
#define RERROR 070000 /* dzrbuf */
#define OVR_RUN 040000
#define FRAME 020000
#define PARITY 010000
#define LINE_NO 03400
/*
* table to map UNIX standard speeds to DZ11 speeds
* illegal speeds are ignored.
*/
char dzspeedmap[16]
{
0 /* 0 - zero */
, 020 /* 1 - 50 */
, 021 /* 2 - 75 */
, 022 /* 3 - 110 */
, 023 /* 4 - 134.5 */
, 024 /* 5 - 150 */
,0200 /* 6 - 200 -- ## ILLEGAL ## */
, 025 /* 7 - 300 */
, 026 /* 8 - 600 */
, 027 /* 9 - 1200 */
, 030 /* 10 - 1800 */
, 032 /* 11 - 2400 */
, 034 /* 12 - 4800 */
, 036 /* 13 - 9600 */
, 031 /* 14 - ext A - maps to 2000 */
, 037 /* 15 - ext B - maps to 19200 */
};
struct tty dz11[NLINES];
char dzdelays[NLINES]; /* Count of clock ticks for per-line
* delays. Count of <= 0 means no delay.
* Reduces requirement of timeouts.
*/
int dzringt[NLINES]; /* Delay counts for modem control */
/*
* open a DZ11 line
*/
dzopen(dev, flag)
{
register struct tty *tp;
register struct dz *dzp;
register int t_bit;
extern dzstart(), dzscan();
if(dev.d_minor >= NLINES)
{
u.u_error = ENXIO;
return;
}
dzp = &dz[dev.d_minor>>3];
t_bit = (1<<(dev.d_minor&07));
if((dzp->sopen&t_bit) && (dzp->openl&t_bit))
{
u.u_error = EOPENFAIL;
return;
}
tp = &dz11[dev.d_minor];
if(u.u_procp->p_ttyp == 0)
u.u_procp->p_ttyp = tp;
if((tp->t_state&ISOPEN) == 0)
{
tp->t_dev = dev;
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;
if(dzp->openl == 0)
dzp->dzaddr->dzcsr =| (TIE|RIE|SAE|MSE); /* reciever interrupt every 16 chars */
dzp->openl =| t_bit;
spl5();
if(dzscanning == 0)
dzscan(); /* start scanning */
if(!(dzp->ring&t_bit) && !(dzp->carrier&t_bit))
dzp->dzaddr->dzdtr =| t_bit; /* turn on DTR for non-dialup lines */
else
{
# ifdef DEBUG
printf("%d wo%d\n", time.loint, dev.d_minor);
# endif DEBUG
while(!(dzp->dzaddr->dzcarr&t_bit))
{
tp->t_state =| WOPEN;
sleep(&tp->t_rawq, TTIPRI);
}
# ifdef DEBUG
printf("%d op%d\n", time.loint, dev.d_minor);
# endif DEBUG
}
spl0();
tp->t_state = (ISOPEN|CARR_ON|SSTART);
dzparam(tp, 1);
}
}
/*
* scan open lines for:
* 1. modem status changes
* 2. process timeouts as dictated by dzdelays
* 3. input by calling dzrint
*/
dzscan() /* at spl5 */
{
register struct dz *dzp;
struct tty *tp;
int *p;
extern dzstart(), dzrint(), dzscan();
# define openring (dzp->openl & dzp->ring)
# define opencarrier (dzp->openl & dzp->carrier)
/*
* scan open dialup/carrier lines.
*/
tp = &dz11[0];
p = &dzringt[0];
for(dzp = dz; dzp < &dz[NDZ]; dzp++)
{
register int *dzaddr;
char scanl, scanc;
dzaddr = dzp->dzaddr;
if((scanl = openring) | (scanc = opencarrier))
{
register int t_bit;
for(t_bit = 1; t_bit&0377; t_bit =<< 1, tp++, p++)
{
if(scanl&t_bit)
{
/* this is an open `dialup' line */
if(dzp->active&t_bit)
{
if(!(dzaddr->dzcarr&t_bit))
{
if(*p == 0)
*p = CARRIERTIME;
else if((*p =- TSCANRATE) <= 0)
{
*p = 0; /* disable */
# ifdef DEBUG
printf("%d hu%d\n", time.loint, tp->t_dev.d_minor);
# endif DEBUG
dzaddr->dzdtr =& ~t_bit; /* hang up the phone */
signal(tp, SIGHUP);
flushtty(tp);
dzaddr->dztcr =& ~t_bit; /* disable transmit */
dzp->active =& ~t_bit;
}
}
else
{
if(tp->t_state&WOPEN)
wakeup(&tp->t_rawq);
*p = 0;
if(!(tp->t_state&TIMEOUT) && (tp->t_outq.c_cc))
dzaddr->dztcr =| t_bit;
}
}
else
{
if(!(dzaddr->dzdtr&t_bit) && (dzaddr->dzring&t_bit))
{
dzaddr->dzdtr =| t_bit; /* answer the phone */
*p = RESPONDTIME;
dzp->active =| t_bit;
# ifdef DEBUG
printf("%d ap%d\n", time.loint, tp->t_dev.d_minor);
# endif DEBUG
}
}
}
else if((scanc&t_bit) && (dzaddr->dzcarr&t_bit))
{ /* carrier only line */
if(tp->t_state&WOPEN)
{
dzaddr->dzdtr =| t_bit;
wakeup(&tp->t_rawq);
}
else if((!(tp->t_state&TIMEOUT)) && (tp->t_outq.c_cc))
dzaddr->dztcr =| t_bit;
}
}
}
else
{
tp =+ 8; p =+ 8; /* in the case where no dialup/carrier lines on current dz */
}
}
/*
* process timeouts for each line
*/
{
register i;
for(i = 0; i < NLINES; i++)
if((dzdelays[i] > 0) && (--dzdelays[i] <= 0))
{
dz11[i].t_state =& ~TIMEOUT;
dzstart(&dz11[i]);
}
}
/*
* scan each dz for input
*/
dzrint(0);
/*
* restart scanning if necessary
*/
dzp = dz;
do
{
if(dzp->openl)
{
dzscanning = timeout(&dzscan, 0, TSCANRATE);
return;
}
dzp++;
} while(dzp < &dz[NDZ]);
dzscanning = 0;
}
/*
* close a DZ11 line
*/
dzclose(dev)
{
register struct tty *tp;
register t_bit;
register struct dz *dzp;
tp = &dz11[dev.d_minor];
wflushtty(tp);
tp->t_state = SSTART;
dzp = &dz[dev.d_minor>>3];
t_bit = 1<<(dev.d_minor&07);
if(dzp->ring&t_bit)
{
if(tp->t_flags&HUPCL)
dzp->dzaddr->dzdtr =& ~t_bit; /* hang up the phone */
}
else
{
dzp->dzaddr->dzdtr =& ~t_bit; /* turn off dtr for non-dialup lines */
}
if((dzp->openl =& ~t_bit) == 0)
dzp->dzaddr->dzcsr = 0; /* disable receive on final close */
}
/*
* 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)
int *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, 1);
}
/*
* set parameters from open or stty into DZ hardware registers
*/
dzparam(tp, dflag)
register struct tty *tp;
{
register lpr, x;
extern wakeup();
lpr = dzspeedmap[tp->t_speeds&017]<<8;
#ifdef IBM2741
if(lpr == (RCVR_ON|S134_5))
lpr = IBM2741;
else
{
#endif IBM2741
if(lpr == (RCVR_ON|S110))
lpr =| TWOSBIT;
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;
#ifdef IBM2741
}
#endif IBM2741
if(dflag)
{
/* delay only if it is permissible */
#ifndef DELAY
timeout(&wakeup, tp, FLUSHTIME); /* wakeup in 5 tics */
sleep(tp, TTOPRI); /* delay while controller flushes */
#else
delay(FLUSHTIME); /* hang 5 */
#endif DELAY
}
dz[tp->t_dev.d_minor>>3].dzaddr->dzlpr = lpr|(tp->t_dev.d_minor&07);
}
/*
* start (restart) transmission on a DZ11 line
*/
dzstart(tp)
register struct tty *tp;
{
register t_bit;
register struct dz *dzp;
t_bit = 1<<(tp->t_dev.d_minor&07);
dzp = &dz[tp->t_dev.d_minor>>3];
if((!(dzp->carrier&t_bit)) || (dzp->dzaddr->dzcarr&t_bit))
dzp->dzaddr->dztcr =| t_bit;
}
/*
* DZ11 transmitter interrupt.
*
* Scan every line on each dz.
* Commencing with the device that caused
* dzxint to be called.
*/
dzxint(dev)
{
register struct tty *tp;
register c;
register struct dzr_read *dzaddr;
struct dz *dzp;
struct tty *dzbase;
int t_bit, lino, i, n;
n = dev.d_minor;
for(i = 0; i < NDZ; i++)
{
dzaddr = (dzp = &dz[n])->dzaddr;
dzbase = &dz11[n*8];
while((c = dzaddr->dzcsr) < 0) /* xmit line ready */
{
t_bit = 1<<(lino = (c>>8)&07);
tp = &dzbase[lino];
if((!(dzp->carrier&t_bit) || (dzaddr->dzcarr&t_bit)) && (c = getc(&tp->t_outq)) >= 0)
if(c <= 0177 || tp->t_flags == RAW)
dzaddr->dztbuf = c;
else
{
dzaddr->dztcr =& ~t_bit;
tp->t_state =| TIMEOUT;
dzdelays[tp-dz11] = ((c&0177)+(TSCANRATE-1))/TSCANRATE+1; /* set up timeout */
continue;
}
else
dzaddr->dztcr =& ~t_bit;
#ifdef TTY_HISPEED
if(tp->t_outq.c_cc <= ((tp->t_speeds&017) > B1200?TTHSLOWAT:TTLOWAT) && (tp->t_state&ASLEEP))
#else
if(tp->t_outq.c_cc <= TTLOWAT && (tp->t_state&ASLEEP))
#endif TTY_HISPEED
{
tp->t_state =& ~ASLEEP;
wakeup(&tp->t_outq);
}
}
if(++n >= NDZ)
n = 0;
}
}
/*
* DZ11 receiver interrupt
*
* Scan each dz commencing with the
* particular device that caused this call.
* Storing each charater as it comes.
*/
dzrint(dev)
{
register struct tty *tp;
register c;
register struct dzr_read *dzaddr;
struct dz *dzp;
struct tty *dzbase;
int i, n, lino, t_bit;
n = dev.d_minor;
for(i = 0; i < NDZ; i++)
{
dzp = &dz[n];
if(dzp->openl)
{
dzbase = &dz11[n*8];
while((c = dzp->dzaddr->dzrbuf) < 0) /* char present in silo */
{
tp = &dzbase[lino = ((c>>8)&07)];
t_bit = 1<<lino;
if(c&RERROR)
{
if(c&OVR_RUN)
{
dzp->overrors++;
# ifdef MESSAGES
printf("over run on dz %d/%d\n", n, lino);
# endif MESSAGES
}
if(c&FRAME) /* break */
if(tp->t_flags&RAW)
c = 0; /* null ( for getty ) */
else
# ifdef INTR_ON_BREAK
c = CINTR; /* del for NCRs. */
# else
continue; /* ignore framing errors if not raw */
# endif INTR_ON_BREAK
else if(c&PARITY)
{
dzp->pyerrors++;
# ifdef MESSAGES
printf("parity on dz %d/%d\n", n, lino);
# endif MESSAGES
continue; /* throw away bad chars */
}
}
if((!(dzp->carrier&t_bit)) || (dzp->dzaddr->dzcarr&t_bit))
ttyinput(c, tp);
}
}
if(++n >= NDZ)
n = 0;
}
}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.