![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tty_chu.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / kernel|
Return to tty_chu.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / kernel |
1.1 misho 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 (50*1000) /* 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