[unix-history] / sys / kern / tty_chu.c

/* tty_chu.c,v 3.1 1993/07/06 01:07:30 jbj Exp
 * tty_chu.c - CHU line driver
 */

#include "chu.h"
#if NCHU > 0

#include "../h/param.h"
#include "../h/types.h"
#include "../h/systm.h"
#include "../h/dir.h"
#include "../h/user.h"
#include "../h/ioctl.h"
#include "../h/tty.h"
#include "../h/proc.h"
#include "../h/file.h"
#include "../h/conf.h"
#include "../h/buf.h"
#include "../h/uio.h"

#include "../h/chudefs.h"

/*
 * Line discipline for receiving CHU time codes.
 * Does elementary noise elimination, takes time stamps after
 * the arrival of each character, returns a buffer full of the
 * received 10 character code and the associated time stamps.
 */
#define	NUMCHUBUFS	3

struct chudata {
	u_char used;		/* Set to 1 when structure in use */
	u_char lastindex;	/* least recently used buffer */
	u_char curindex;	/* buffer to use */
	u_char sleeping;	/* set to 1 when we're sleeping on a buffer */
	struct chucode chubuf[NUMCHUBUFS];
} chu_data[NCHU];

/*
 * Number of microseconds we allow between
 * character arrivals.  The speed is 300 baud
 * so this should be somewhat more than 30 msec
 */
#define	CHUMAXUSEC	(50*1000)	/* 50 msec */

int chu_debug = 0;

/*
 * Open as CHU time discipline.  Called when discipline changed
 * with ioctl, and changes the interpretation of the information
 * in the tty structure.
 */
/*ARGSUSED*/
chuopen(dev, tp)
	dev_t dev;
	register struct tty *tp;
{
	register struct chudata *chu;

	/*
	 * Don't allow multiple opens.  This will also protect us
	 * from someone opening /dev/tty
	 */
	if (tp->t_line == CHULDISC)
		return (EBUSY);
	ttywflush(tp);
	for (chu = chu_data; chu < &chu_data[NCHU]; chu++)
		if (!chu->used)
			break;
	if (chu >= &chu[NCHU])
		return (EBUSY);
	chu->used++;
	chu->lastindex = chu->curindex = 0;
	chu->sleeping = 0;
	chu->chubuf[0].ncodechars = 0;
	tp->T_LINEP = (caddr_t) chu;
	return (0);
}

/*
 * Break down... called when discipline changed or from device
 * close routine.
 */
chuclose(tp)
	register struct tty *tp;
{
	register int s = spl5();

	((struct chudata *) tp->T_LINEP)->used = 0;
	tp->t_cp = 0;
	tp->t_inbuf = 0;
	tp->t_rawq.c_cc = 0;		/* clear queues -- paranoid */
	tp->t_canq.c_cc = 0;
	tp->t_line = 0;			/* paranoid: avoid races */
	splx(s);
}

/*
 * Read a CHU buffer.  Sleep on the current buffer
 */
churead(tp, uio)
	register struct tty *tp;
	struct uio *uio;
{
	register struct chudata *chu;
	register struct chucode *chucode;
	register int s;

	if ((tp->t_state&TS_CARR_ON)==0)
		return (EIO);

	chu = (struct chudata *) (tp->T_LINEP);

	s = spl5();
	chucode = &(chu->chubuf[chu->lastindex]);
	while (chu->curindex == chu->lastindex) {
		chu->sleeping = 1;
		sleep((caddr_t)chucode, TTIPRI);
	}
	chu->sleeping = 0;
	if (++(chu->lastindex) >= NUMCHUBUFS)
		chu->lastindex = 0;
	splx(s);

	return (uiomove((caddr_t)chucode, sizeof(*chucode), UIO_READ, uio));
}

/*
 * Low level character input routine.
 * If the character looks okay, grab a time stamp.  If the stuff in
 * the buffer is too old, dump it and start fresh.  If the character is
 * non-BCDish, everything in the buffer too.
 */
chuinput(c, tp)
	register int c;
	register struct tty *tp;
{
	register struct chudata *chu = (struct chudata *) tp->T_LINEP;
	register struct chucode *chuc;
	register int i;
	long sec, usec;
	struct timeval tv;

	/*
	 * Do a check on the BSDness of the character.  This delays
	 * the time stamp a bit but saves a fair amount of overhead
	 * when the static is bad.
	 */
	if (((c) & 0xf) > 9 || (((c)>>4) & 0xf) > 9) {
		chuc = &(chu->chubuf[chu->curindex]);
		chuc->ncodechars = 0;	/* blow all previous away */
		return;
	}

	/*
	 * Call microtime() to get the current time of day
	 */
	microtime(&tv);

	/*
	 * Compute the difference in this character's time stamp
	 * and the last.  If it exceeds the margin, blow away all
	 * the characters currently in the buffer.
	 */
	chuc = &(chu->chubuf[chu->curindex]);
	i = (int)chuc->ncodechars;
	if (i > 0) {
		sec = tv.tv_sec - chuc->codetimes[i-1].tv_sec;
		usec = tv.tv_usec - chuc->codetimes[i-1].tv_usec;
		if (usec < 0) {
			sec -= 1;
			usec += 1000000;
		}
		if (sec != 0 || usec > CHUMAXUSEC) {
			i = 0;
			chuc->ncodechars = 0;
		}
	}

	/*
	 * Store the character.  If we're done, have to tell someone
	 */
	chuc->codechars[i] = (u_char)c;
	chuc->codetimes[i] = tv;

	if (++i < NCHUCHARS) {
		/*
		 * Not much to do here.  Save the count and wait
		 * for another character.
		 */
		chuc->ncodechars = (u_char)i;
	} else {
		/*
		 * Mark this buffer full and point at next.  If the
		 * next buffer is full we overwrite it by bumping the
		 * next pointer.
		 */
		chuc->ncodechars = NCHUCHARS;
		if (++(chu->curindex) >= NUMCHUBUFS)
			chu->curindex = 0;
		if (chu->curindex == chu->lastindex)
			if (++(chu->lastindex) >= NUMCHUBUFS)
				chu->lastindex = 0;
		chu->chubuf[chu->curindex].ncodechars = 0;

		/*
		 * Wake up anyone sleeping on this.  Also wake up
		 * selectors and/or deliver a SIGIO as required.
		 */
		if (tp->t_rsel) {
			selwakeup(tp->t_rsel, tp->t_state&TS_RCOLL);
			tp->t_state &= ~TS_RCOLL;
			tp->t_rsel = 0;
		}
		if (tp->t_state & TS_ASYNC)
			gsignal(tp->t_pgrp, SIGIO);
		if (chu->sleeping)
			(void) wakeup((caddr_t)chuc);
	}
}

/*
 * Handle ioctls.  We reject all tty-style except those that
 * change the line discipline.
 */
chuioctl(tp, cmd, data, flag)
	struct tty *tp;
	int cmd;
	caddr_t data;
	int flag;
{

	if ((cmd>>8) != 't')
		return (-1);
	switch (cmd) {
	case TIOCSETD:
	case TIOCGETD:
	case TIOCGETP:
	case TIOCGETC:
		return (-1);
	}
	return (ENOTTY);	/* not quite appropriate */
}


chuselect(dev, rw)
	dev_t dev;
	int rw;
{
	register struct tty *tp = &cdevsw[major(dev)].d_ttys[minor(dev)];
	struct chudata *chu;
	int s = spl5();

	chu = (struct chudata *) (tp->T_LINEP);

	switch (rw) {

	case FREAD:
		if (chu->curindex != chu->lastindex)
			goto win;
		if (tp->t_rsel && tp->t_rsel->p_wchan == (caddr_t)&selwait)
			tp->t_state |= TS_RCOLL;
		else
			tp->t_rsel = u.u_procp;
		break;

	case FWRITE:
		goto win;
	}
	splx(s);
	return (0);
win:
	splx(s);
	return (1);
}
#endif NCHU
Commit	Line	Data
c4794f91 GW	1	/* tty_chu.c,v 3.1 1993/07/06 01:07:30 jbj Exp
	2	* tty_chu.c - CHU line driver
	3	*/
	4
	5	#include "chu.h"
	6	#if NCHU > 0
	7
	8	#include "../h/param.h"
	9	#include "../h/types.h"
	10	#include "../h/systm.h"
	11	#include "../h/dir.h"
	12	#include "../h/user.h"
	13	#include "../h/ioctl.h"
	14	#include "../h/tty.h"
	15	#include "../h/proc.h"
	16	#include "../h/file.h"
	17	#include "../h/conf.h"
	18	#include "../h/buf.h"
	19	#include "../h/uio.h"
	20
	21	#include "../h/chudefs.h"
	22
	23	/*
	24	* Line discipline for receiving CHU time codes.
	25	* Does elementary noise elimination, takes time stamps after
	26	* the arrival of each character, returns a buffer full of the
	27	* received 10 character code and the associated time stamps.
	28	*/
	29	#define NUMCHUBUFS 3
	30
	31	struct chudata {
	32	u_char used; /* Set to 1 when structure in use */
	33	u_char lastindex; /* least recently used buffer */
	34	u_char curindex; /* buffer to use */
	35	u_char sleeping; /* set to 1 when we're sleeping on a buffer */
	36	struct chucode chubuf[NUMCHUBUFS];
	37	} chu_data[NCHU];
	38
	39	/*
	40	* Number of microseconds we allow between
	41	* character arrivals. The speed is 300 baud
	42	* so this should be somewhat more than 30 msec
	43	*/
	44	#define CHUMAXUSEC (501000) / 50 msec */
	45
	46	int chu_debug = 0;
	47
	48	/*
	49	* Open as CHU time discipline. Called when discipline changed
	50	* with ioctl, and changes the interpretation of the information
	51	* in the tty structure.
	52	*/
	53	/ARGSUSED/
	54	chuopen(dev, tp)
	55	dev_t dev;
	56	register struct tty *tp;
	57	{
	58	register struct chudata *chu;
	59
	60	/*
	61	* Don't allow multiple opens. This will also protect us
	62	* from someone opening /dev/tty
	63	*/
	64	if (tp->t_line == CHULDISC)
65	return (EBUSY);
66	ttywflush(tp);
67	for (chu = chu_data; chu < &chu_data[NCHU]; chu++)
68	if (!chu->used)
69	break;
70	if (chu >= &chu[NCHU])
71	return (EBUSY);
72	chu->used++;
73	chu->lastindex = chu->curindex = 0;
74	chu->sleeping = 0;
75	chu->chubuf[0].ncodechars = 0;
76	tp->T_LINEP = (caddr_t) chu;
77	return (0);
78	}
79
80	/*
81	* Break down... called when discipline changed or from device
82	* close routine.
83	*/
84	chuclose(tp)
85	register struct tty *tp;
86	{
87	register int s = spl5();
88
89	((struct chudata *) tp->T_LINEP)->used = 0;
90	tp->t_cp = 0;
91	tp->t_inbuf = 0;
92	tp->t_rawq.c_cc = 0; /* clear queues -- paranoid */
93	tp->t_canq.c_cc = 0;
94	tp->t_line = 0; /* paranoid: avoid races */
95	splx(s);
96	}
97
98	/*
99	* Read a CHU buffer. Sleep on the current buffer
100	*/
101	churead(tp, uio)
102	register struct tty *tp;
103	struct uio *uio;
104	{
105	register struct chudata *chu;
106	register struct chucode *chucode;
107	register int s;
108
109	if ((tp->t_state&TS_CARR_ON)==0)
110	return (EIO);
111
112	chu = (struct chudata *) (tp->T_LINEP);
113
114	s = spl5();
115	chucode = &(chu->chubuf[chu->lastindex]);
116	while (chu->curindex == chu->lastindex) {
117	chu->sleeping = 1;
118	sleep((caddr_t)chucode, TTIPRI);
119	}
120	chu->sleeping = 0;
121	if (++(chu->lastindex) >= NUMCHUBUFS)
122	chu->lastindex = 0;
123	splx(s);
124
125	return (uiomove((caddr_t)chucode, sizeof(*chucode), UIO_READ, uio));
126	}
127
128	/*
129	* Low level character input routine.
130	* If the character looks okay, grab a time stamp. If the stuff in
131	* the buffer is too old, dump it and start fresh. If the character is
132	* non-BCDish, everything in the buffer too.
133	*/
134	chuinput(c, tp)
135	register int c;
136	register struct tty *tp;
137	{
138	register struct chudata chu = (struct chudata ) tp->T_LINEP;
139	register struct chucode *chuc;
140	register int i;
141	long sec, usec;
142	struct timeval tv;
143
144	/*
145	* Do a check on the BSDness of the character. This delays
146	* the time stamp a bit but saves a fair amount of overhead
147	* when the static is bad.
148	*/
149	if (((c) & 0xf) > 9 \|\| (((c)>>4) & 0xf) > 9) {
150	chuc = &(chu->chubuf[chu->curindex]);
151	chuc->ncodechars = 0; /* blow all previous away */
152	return;
153	}
154
155	/*
156	* Call microtime() to get the current time of day
157	*/
158	microtime(&tv);
159
160	/*
161	* Compute the difference in this character's time stamp
162	* and the last. If it exceeds the margin, blow away all
163	* the characters currently in the buffer.
164	*/
165	chuc = &(chu->chubuf[chu->curindex]);
166	i = (int)chuc->ncodechars;
167	if (i > 0) {
168	sec = tv.tv_sec - chuc->codetimes[i-1].tv_sec;
169	usec = tv.tv_usec - chuc->codetimes[i-1].tv_usec;
170	if (usec < 0) {
171	sec -= 1;
172	usec += 1000000;
173	}
174	if (sec != 0 \|\| usec > CHUMAXUSEC) {
175	i = 0;
176	chuc->ncodechars = 0;
177	}
178	}
179
180	/*
181	* Store the character. If we're done, have to tell someone
182	*/
183	chuc->codechars[i] = (u_char)c;
184	chuc->codetimes[i] = tv;
185
186	if (++i < NCHUCHARS) {
187	/*
188	* Not much to do here. Save the count and wait
189	* for another character.
190	*/
191	chuc->ncodechars = (u_char)i;
192	} else {
193	/*
194	* Mark this buffer full and point at next. If the
195	* next buffer is full we overwrite it by bumping the
196	* next pointer.
197	*/
198	chuc->ncodechars = NCHUCHARS;
199	if (++(chu->curindex) >= NUMCHUBUFS)
200	chu->curindex = 0;
201	if (chu->curindex == chu->lastindex)
202	if (++(chu->lastindex) >= NUMCHUBUFS)
203	chu->lastindex = 0;
204	chu->chubuf[chu->curindex].ncodechars = 0;
205
206	/*
207	* Wake up anyone sleeping on this. Also wake up
208	* selectors and/or deliver a SIGIO as required.
209	*/
210	if (tp->t_rsel) {
211	selwakeup(tp->t_rsel, tp->t_state&TS_RCOLL);
212	tp->t_state &= ~TS_RCOLL;
213	tp->t_rsel = 0;
214	}
215	if (tp->t_state & TS_ASYNC)
216	gsignal(tp->t_pgrp, SIGIO);
217	if (chu->sleeping)
218	(void) wakeup((caddr_t)chuc);
219	}
220	}
221
222	/*
223	* Handle ioctls. We reject all tty-style except those that
224	* change the line discipline.
225	*/
226	chuioctl(tp, cmd, data, flag)
227	struct tty *tp;
228	int cmd;
229	caddr_t data;
230	int flag;
231	{
232
233	if ((cmd>>8) != 't')
234	return (-1);
235	switch (cmd) {
236	case TIOCSETD:
237	case TIOCGETD:
238	case TIOCGETP:
239	case TIOCGETC:
240	return (-1);
241	}
242	return (ENOTTY); /* not quite appropriate */
243	}
244
245
246	chuselect(dev, rw)
247	dev_t dev;
248	int rw;
249	{
250	register struct tty *tp = &cdevsw[major(dev)].d_ttys[minor(dev)];
251	struct chudata *chu;
252	int s = spl5();
253
254	chu = (struct chudata *) (tp->T_LINEP);
255
256	switch (rw) {
257
258	case FREAD:
259	if (chu->curindex != chu->lastindex)
260	goto win;
261	if (tp->t_rsel && tp->t_rsel->p_wchan == (caddr_t)&selwait)
262	tp->t_state \|= TS_RCOLL;
263	else
264	tp->t_rsel = u.u_procp;
265	break;
266
267	case FWRITE:
268	goto win;
269	}
270	splx(s);
271	return (0);
272	win:
273	splx(s);
274	return (1);
275	}
276	#endif NCHU