Context Navigation

source: rtems/cpukit/libcsupport/src/termios.c @ b295019

Last change on this file since b295019 was b295019, checked in by Joel Sherrill <joel.sherrill@…>, on 10/25/06 at 11:27:28

2006-10-25 Jennifer Averett <jennifer@…>

libcsupport/src/termios.c: Change attribute of semaphore. It was counting interrupts not acting as a condition synchronization mutex. Since the caller did not always need to obtain the semaphore, it was not being decremented until there was no data. This could occur after hours of running a system and thousands of interrupts. The code in fillBufferQueue would spin until it had consumed all of those semaphore counts.

Property mode set to 100644

File size: 38.3 KB

Line
1	/*
2	* TERMIOS serial line support
3	*
4	* Author:
5	* W. Eric Norum
6	* Saskatchewan Accelerator Laboratory
7	* University of Saskatchewan
8	* Saskatoon, Saskatchewan, CANADA
9	* eric@skatter.usask.ca
10	*
11	* The license and distribution terms for this file may be
12	* found in the file LICENSE in this distribution or at
13	* http://www.rtems.com/license/LICENSE.
14	*
15	* $Id$
16	*/
17
18	#if HAVE_CONFIG_H
19	#include "config.h"
20	#endif
21
22	#include <rtems.h>
23	#include <rtems/libio.h>
24	#include <ctype.h>
25	#include <errno.h>
26	#include <stdio.h>
27	#include <stdlib.h>
28	#include <termios.h>
29	#include <unistd.h>
30	#include <sys/ttycom.h>
31
32	#include <rtems/termiostypes.h>
33
34	/*
35	* The size of the cooked buffer
36	*/
37	#define CBUFSIZE (rtems_termios_cbufsize)
38
39	/*
40	* The sizes of the raw message buffers.
41	* On most architectures it is quite a bit more
42	* efficient if these are powers of two.
43	*/
44	#define RAW_INPUT_BUFFER_SIZE (rtems_termios_raw_input_size)
45	#define RAW_OUTPUT_BUFFER_SIZE (rtems_termios_raw_output_size)
46
47	/* fields for "flow_ctrl" status */
48	#define FL_IREQXOF 1 /* input queue requests stop of incoming data */
49	#define FL_ISNTXOF 2 /* XOFF has been sent to other side of line */
50	#define FL_IRTSOFF 4 /* RTS has been turned off for other side.. */
51
52	#define FL_ORCVXOF 0x10 /* XOFF has been received */
53	#define FL_OSTOP 0x20 /* output has been stopped due to XOFF */
54
55	#define FL_MDRTS 0x100 /* input controlled with RTS/CTS handshake */
56	#define FL_MDXON 0x200 /* input controlled with XON/XOFF protocol */
57	#define FL_MDXOF 0x400 /* output controlled with XON/XOFF protocol */
58
59	#define NODISC(n) \
60	{ NULL, NULL, NULL, NULL, \
61	NULL, NULL, NULL, NULL }
62	/*
63	* FIXME: change linesw entries consistant with linesw entry usage...
64	*/
65	struct linesw linesw[MAXLDISC] =
66	{
67	NODISC(0), /* 0- termios-built-in */
68	NODISC(1), /* 1- defunct */
69	NODISC(2), /* 2- NTTYDISC */
70	NODISC(3), /* TABLDISC */
71	NODISC(4), /* SLIPDISC */
72	NODISC(5), /* PPPDISC */
73	NODISC(6), /* loadable */
74	NODISC(7), /* loadable */
75	};
76
77	int nlinesw = sizeof (linesw) / sizeof (linesw[0]);
78
79	extern struct rtems_termios_tty *rtems_termios_ttyHead;
80	extern struct rtems_termios_tty *rtems_termios_ttyTail;
81	extern rtems_id rtems_termios_ttyMutex;
82
83	static int rtems_termios_cbufsize = 256;
84	static int rtems_termios_raw_input_size = 128;
85	static int rtems_termios_raw_output_size = 64;
86
87	static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument);
88	static rtems_task rtems_termios_txdaemon(rtems_task_argument argument);
89	/*
90	* some constants for I/O daemon task creation
91	*/
92	#define TERMIOS_TXTASK_PRIO 10
93	#define TERMIOS_RXTASK_PRIO 9
94	#define TERMIOS_TXTASK_STACKSIZE 1024
95	#define TERMIOS_RXTASK_STACKSIZE 1024
96	/*
97	* some events to be sent to the I/O tasks
98	*/
99	#define TERMIOS_TX_START_EVENT RTEMS_EVENT_1
100	#define TERMIOS_TX_TERMINATE_EVENT RTEMS_EVENT_0
101
102	#define TERMIOS_RX_PROC_EVENT RTEMS_EVENT_1
103	#define TERMIOS_RX_TERMINATE_EVENT RTEMS_EVENT_0
104
105	/*
106	* Open a termios device
107	*/
108	rtems_status_code
109	rtems_termios_open (
110	rtems_device_major_number major,
111	rtems_device_minor_number minor,
112	void *arg,
113	const rtems_termios_callbacks *callbacks
114	)
115	{
116	rtems_status_code sc;
117	rtems_libio_open_close_args_t *args = arg;
118	struct rtems_termios_tty *tty;
119
120	/*
121	* See if the device has already been opened
122	*/
123	sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
124	RTEMS_WAIT, RTEMS_NO_TIMEOUT);
125	if (sc != RTEMS_SUCCESSFUL)
126	return sc;
127	for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
128	if ((tty->major == major) && (tty->minor == minor))
129	break;
130	}
131	if (tty == NULL) {
132	static char c = 'a';
133
134	/*
135	* Create a new device
136	*/
137	tty = calloc (1, sizeof (struct rtems_termios_tty));
138	if (tty == NULL) {
139	rtems_semaphore_release (rtems_termios_ttyMutex);
140	return RTEMS_NO_MEMORY;
141	}
142	/*
143	* allocate raw input buffer
144	*/
145	tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
146	tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
147	if (tty->rawInBuf.theBuf == NULL) {
148	free(tty);
149	rtems_semaphore_release (rtems_termios_ttyMutex);
150	return RTEMS_NO_MEMORY;
151	}
152	/*
153	* allocate raw output buffer
154	*/
155	tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
156	tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
157	if (tty->rawOutBuf.theBuf == NULL) {
158	free((void *)(tty->rawInBuf.theBuf));
159	free(tty);
160	rtems_semaphore_release (rtems_termios_ttyMutex);
161	return RTEMS_NO_MEMORY;
162	}
163	/*
164	* allocate cooked buffer
165	*/
166	tty->cbuf = malloc (CBUFSIZE);
167	if (tty->cbuf == NULL) {
168	free((void *)(tty->rawOutBuf.theBuf));
169	free((void *)(tty->rawInBuf.theBuf));
170	free(tty);
171	rtems_semaphore_release (rtems_termios_ttyMutex);
172	return RTEMS_NO_MEMORY;
173	}
174	/*
175	* Initialize wakeup callbacks
176	*/
177	tty->tty_snd.sw_pfn = NULL;
178	tty->tty_snd.sw_arg = NULL;
179	tty->tty_rcv.sw_pfn = NULL;
180	tty->tty_rcv.sw_arg = NULL;
181	tty->tty_rcvwakeup = 0;
182
183	/*
184	* link tty
185	*/
186	tty->forw = rtems_termios_ttyHead;
187	tty->back = NULL;
188	if (rtems_termios_ttyHead != NULL)
189	rtems_termios_ttyHead->back = tty;
190	rtems_termios_ttyHead = tty;
191	if (rtems_termios_ttyTail == NULL)
192	rtems_termios_ttyTail = tty;
193
194	tty->minor = minor;
195	tty->major = major;
196
197	/*
198	* Set up mutex semaphores
199	*/
200	sc = rtems_semaphore_create (
201	rtems_build_name ('T', 'R', 'i', c),
202	1,
203	RTEMS_BINARY_SEMAPHORE \| RTEMS_INHERIT_PRIORITY \| RTEMS_PRIORITY,
204	RTEMS_NO_PRIORITY,
205	&tty->isem);
206	if (sc != RTEMS_SUCCESSFUL)
207	rtems_fatal_error_occurred (sc);
208	sc = rtems_semaphore_create (
209	rtems_build_name ('T', 'R', 'o', c),
210	1,
211	RTEMS_BINARY_SEMAPHORE \| RTEMS_INHERIT_PRIORITY \| RTEMS_PRIORITY,
212	RTEMS_NO_PRIORITY,
213	&tty->osem);
214	if (sc != RTEMS_SUCCESSFUL)
215	rtems_fatal_error_occurred (sc);
216	sc = rtems_semaphore_create (
217	rtems_build_name ('T', 'R', 'x', c),
218	0,
219	RTEMS_SIMPLE_BINARY_SEMAPHORE \| RTEMS_FIFO,
220	RTEMS_NO_PRIORITY,
221	&tty->rawOutBuf.Semaphore);
222	if (sc != RTEMS_SUCCESSFUL)
223	rtems_fatal_error_occurred (sc);
224	tty->rawOutBufState = rob_idle;
225
226	/*
227	* Set callbacks
228	*/
229	tty->device = *callbacks;
230
231	/*
232	* Create I/O tasks
233	*/
234	if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
235	sc = rtems_task_create (
236	rtems_build_name ('T', 'x', 'T', c),
237	TERMIOS_TXTASK_PRIO,
238	TERMIOS_TXTASK_STACKSIZE,
239	RTEMS_NO_PREEMPT \| RTEMS_NO_TIMESLICE \|
240	RTEMS_NO_ASR,
241	RTEMS_NO_FLOATING_POINT \| RTEMS_LOCAL,
242	&tty->txTaskId);
243	if (sc != RTEMS_SUCCESSFUL)
244	rtems_fatal_error_occurred (sc);
245	sc = rtems_task_create (
246	rtems_build_name ('R', 'x', 'T', c),
247	TERMIOS_RXTASK_PRIO,
248	TERMIOS_RXTASK_STACKSIZE,
249	RTEMS_NO_PREEMPT \| RTEMS_NO_TIMESLICE \|
250	RTEMS_NO_ASR,
251	RTEMS_NO_FLOATING_POINT \| RTEMS_LOCAL,
252	&tty->rxTaskId);
253	if (sc != RTEMS_SUCCESSFUL)
254	rtems_fatal_error_occurred (sc);
255
256	}
257	if ((tty->device.pollRead == NULL) \|\|
258	(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
259	sc = rtems_semaphore_create (
260	rtems_build_name ('T', 'R', 'r', c),
261	0,
262	RTEMS_SIMPLE_BINARY_SEMAPHORE \| RTEMS_PRIORITY,
263	RTEMS_NO_PRIORITY,
264	&tty->rawInBuf.Semaphore);
265	if (sc != RTEMS_SUCCESSFUL)
266	rtems_fatal_error_occurred (sc);
267	}
268
269	/*
270	* Set default parameters
271	*/
272	tty->termios.c_iflag = BRKINT \| ICRNL \| IXON \| IMAXBEL;
273	tty->termios.c_oflag = OPOST \| ONLCR \| XTABS;
274	tty->termios.c_cflag = B9600 \| CS8 \| CREAD \| CLOCAL;
275	tty->termios.c_lflag = ISIG \| ICANON \| IEXTEN \| ECHO \| ECHOK \| ECHOE \| ECHOCTL;
276
277	tty->termios.c_cc[VINTR] = '\003';
278	tty->termios.c_cc[VQUIT] = '\034';
279	tty->termios.c_cc[VERASE] = '\177';
280	tty->termios.c_cc[VKILL] = '\025';
281	tty->termios.c_cc[VEOF] = '\004';
282	tty->termios.c_cc[VEOL] = '\000';
283	tty->termios.c_cc[VEOL2] = '\000';
284	tty->termios.c_cc[VSTART] = '\021';
285	tty->termios.c_cc[VSTOP] = '\023';
286	tty->termios.c_cc[VSUSP] = '\032';
287	tty->termios.c_cc[VREPRINT] = '\022';
288	tty->termios.c_cc[VDISCARD] = '\017';
289	tty->termios.c_cc[VWERASE] = '\027';
290	tty->termios.c_cc[VLNEXT] = '\026';
291
292	/* start with no flow control, clear flow control flags */
293	tty->flow_ctrl = 0;
294	/*
295	* set low/highwater mark for XON/XOFF support
296	*/
297	tty->lowwater = tty->rawInBuf.Size * 1/2;
298	tty->highwater = tty->rawInBuf.Size * 3/4;
299	/*
300	* Bump name characer
301	*/
302	if (c++ == 'z')
303	c = 'a';
304
305	}
306	args->iop->data1 = tty;
307	if (!tty->refcount++) {
308	if (tty->device.firstOpen)
309	(*tty->device.firstOpen)(major, minor, arg);
310	/*
311	* start I/O tasks, if needed
312	*/
313	if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
314	sc = rtems_task_start(tty->rxTaskId,
315	rtems_termios_rxdaemon,
316	(rtems_task_argument)tty);
317	if (sc != RTEMS_SUCCESSFUL)
318	rtems_fatal_error_occurred (sc);
319
320	sc = rtems_task_start(tty->txTaskId,
321	rtems_termios_txdaemon,
322	(rtems_task_argument)tty);
323	if (sc != RTEMS_SUCCESSFUL)
324	rtems_fatal_error_occurred (sc);
325	}
326	}
327	rtems_semaphore_release (rtems_termios_ttyMutex);
328	return RTEMS_SUCCESSFUL;
329	}
330
331	/*
332	* Drain output queue
333	*/
334	static void
335	drainOutput (struct rtems_termios_tty *tty)
336	{
337	rtems_interrupt_level level;
338	rtems_status_code sc;
339
340	if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
341	rtems_interrupt_disable (level);
342	while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
343	tty->rawOutBufState = rob_wait;
344	rtems_interrupt_enable (level);
345	sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
346	RTEMS_WAIT,
347	RTEMS_NO_TIMEOUT);
348	if (sc != RTEMS_SUCCESSFUL)
349	rtems_fatal_error_occurred (sc);
350	rtems_interrupt_disable (level);
351	}
352	rtems_interrupt_enable (level);
353	}
354	}
355
356	rtems_status_code
357	rtems_termios_close (void *arg)
358	{
359	rtems_libio_open_close_args_t *args = arg;
360	struct rtems_termios_tty *tty = args->iop->data1;
361	rtems_status_code sc;
362
363	sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
364	if (sc != RTEMS_SUCCESSFUL)
365	rtems_fatal_error_occurred (sc);
366	if (--tty->refcount == 0) {
367	if (linesw[tty->t_line].l_close != NULL) {
368	/*
369	* call discipline-specific close
370	*/
371	sc = linesw[tty->t_line].l_close(tty);
372	}
373	else {
374	/*
375	* default: just flush output buffer
376	*/
377	drainOutput (tty);
378	}
379
380	if (tty->device.outputUsesInterrupts
381	== TERMIOS_TASK_DRIVEN) {
382	/*
383	* send "terminate" to I/O tasks
384	*/
385	sc = rtems_event_send(
386	tty->rxTaskId,
387	TERMIOS_RX_TERMINATE_EVENT);
388	if (sc != RTEMS_SUCCESSFUL)
389	rtems_fatal_error_occurred (sc);
390	sc = rtems_event_send(
391	tty->txTaskId,
392	TERMIOS_TX_TERMINATE_EVENT);
393	if (sc != RTEMS_SUCCESSFUL)
394	rtems_fatal_error_occurred (sc);
395	}
396	if (tty->device.lastClose)
397	(*tty->device.lastClose)(tty->major, tty->minor, arg);
398	if (tty->forw == NULL) {
399	rtems_termios_ttyTail = tty->back;
400	if ( rtems_termios_ttyTail != NULL ) {
401	rtems_termios_ttyTail->forw = NULL;
402	}
403	}
404	else {
405	tty->forw->back = tty->back;
406	}
407	if (tty->back == NULL) {
408	rtems_termios_ttyHead = tty->forw;
409	if ( rtems_termios_ttyHead != NULL ) {
410	rtems_termios_ttyHead->back = NULL;
411	}
412	}
413	else {
414	tty->back->forw = tty->forw;
415	}
416	rtems_semaphore_delete (tty->isem);
417	rtems_semaphore_delete (tty->osem);
418	rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
419	if ((tty->device.pollRead == NULL) \|\|
420	(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
421	rtems_semaphore_delete (tty->rawInBuf.Semaphore);
422	free (tty->rawInBuf.theBuf);
423	free (tty->rawOutBuf.theBuf);
424	free (tty->cbuf);
425	free (tty);
426	}
427	rtems_semaphore_release (rtems_termios_ttyMutex);
428	return RTEMS_SUCCESSFUL;
429	}
430
431	rtems_status_code rtems_termios_bufsize (
432	int cbufsize,
433	int raw_input,
434	int raw_output
435	)
436	{
437	rtems_termios_cbufsize = cbufsize;
438	rtems_termios_raw_input_size = raw_input;
439	rtems_termios_raw_output_size = raw_output;
440	return RTEMS_SUCCESSFUL;
441	}
442
443	static void
444	termios_set_flowctrl(struct rtems_termios_tty *tty)
445	{
446	rtems_interrupt_level level;
447	/*
448	* check for flow control options to be switched off
449	*/
450
451	/* check for outgoing XON/XOFF flow control switched off */
452	if (( tty->flow_ctrl & FL_MDXON) &&
453	!(tty->termios.c_iflag & IXON)) {
454	/* clear related flags in flow_ctrl */
455	tty->flow_ctrl &= ~(FL_MDXON \| FL_ORCVXOF);
456
457	/* has output been stopped due to received XOFF? */
458	if (tty->flow_ctrl & FL_OSTOP) {
459	/* disable interrupts */
460	rtems_interrupt_disable(level);
461	tty->flow_ctrl &= ~FL_OSTOP;
462	/* check for chars in output buffer (or rob_state?) */
463	if (tty->rawOutBufState != rob_idle) {
464	/* if chars available, call write function... */
465	(*tty->device.write)(tty->minor,
466	&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
467	}
468	/* reenable interrupts */
469	rtems_interrupt_enable(level);
470	}
471	}
472	/* check for incoming XON/XOFF flow control switched off */
473	if (( tty->flow_ctrl & FL_MDXOF) &&
474	!(tty->termios.c_iflag & IXOFF)) {
475	/* clear related flags in flow_ctrl */
476	tty->flow_ctrl &= ~(FL_MDXOF);
477	/* FIXME: what happens, if we had sent XOFF but not yet XON? */
478	tty->flow_ctrl &= ~(FL_ISNTXOF);
479	}
480
481	/* check for incoming RTS/CTS flow control switched off */
482	if (( tty->flow_ctrl & FL_MDRTS) &&
483	!(tty->termios.c_cflag & CRTSCTS)) {
484	/* clear related flags in flow_ctrl */
485	tty->flow_ctrl &= ~(FL_MDRTS);
486
487	/* restart remote Tx, if it was stopped */
488	if ((tty->flow_ctrl & FL_IRTSOFF) &&
489	(tty->device.startRemoteTx != NULL)) {
490	tty->device.startRemoteTx(tty->minor);
491	}
492	tty->flow_ctrl &= ~(FL_IRTSOFF);
493	}
494
495	/*
496	* check for flow control options to be switched on
497	*/
498	/* check for incoming RTS/CTS flow control switched on */
499	if (tty->termios.c_cflag & CRTSCTS) {
500	tty->flow_ctrl \|= FL_MDRTS;
501	}
502	/* check for incoming XON/XOF flow control switched on */
503	if (tty->termios.c_iflag & IXOFF) {
504	tty->flow_ctrl \|= FL_MDXOF;
505	}
506	/* check for outgoing XON/XOF flow control switched on */
507	if (tty->termios.c_iflag & IXON) {
508	tty->flow_ctrl \|= FL_MDXON;
509	}
510	}
511
512	rtems_status_code
513	rtems_termios_ioctl (void *arg)
514	{
515	rtems_libio_ioctl_args_t *args = arg;
516	struct rtems_termios_tty *tty = args->iop->data1;
517	struct ttywakeup wakeup = (struct ttywakeup )args->buffer;
518	rtems_status_code sc;
519
520	args->ioctl_return = 0;
521	sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
522	if (sc != RTEMS_SUCCESSFUL) {
523	args->ioctl_return = sc;
524	return sc;
525	}
526	switch (args->command) {
527	default:
528	if (linesw[tty->t_line].l_ioctl != NULL) {
529	sc = linesw[tty->t_line].l_ioctl(tty,args);
530	}
531	else {
532	sc = RTEMS_INVALID_NUMBER;
533	}
534	break;
535
536	case RTEMS_IO_GET_ATTRIBUTES:
537	(struct termios )args->buffer = tty->termios;
538	break;
539
540	case RTEMS_IO_SET_ATTRIBUTES:
541	tty->termios = (struct termios )args->buffer;
542
543	/* check for and process change in flow control options */
544	termios_set_flowctrl(tty);
545
546	if (tty->termios.c_lflag & ICANON) {
547	tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
548	tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
549	tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
550	}
551	else {
552	rtems_interval ticksPerSecond;
553	rtems_clock_get (RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticksPerSecond);
554	tty->vtimeTicks = tty->termios.c_cc[VTIME] * ticksPerSecond / 10;
555	if (tty->termios.c_cc[VTIME]) {
556	tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
557	tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
558	if (tty->termios.c_cc[VMIN])
559	tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
560	else
561	tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
562	}
563	else {
564	if (tty->termios.c_cc[VMIN]) {
565	tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
566	tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
567	tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
568	}
569	else {
570	tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
571	}
572	}
573	}
574	if (tty->device.setAttributes)
575	(*tty->device.setAttributes)(tty->minor, &tty->termios);
576	break;
577
578	case RTEMS_IO_TCDRAIN:
579	drainOutput (tty);
580	break;
581
582	case RTEMS_IO_SNDWAKEUP:
583	tty->tty_snd = *wakeup;
584	break;
585
586	case RTEMS_IO_RCVWAKEUP:
587	tty->tty_rcv = *wakeup;
588	break;
589
590	/*
591	* FIXME: add various ioctl code handlers
592	*/
593
594	#if 1 /* FIXME */
595	case TIOCSETD:
596	/*
597	* close old line discipline
598	*/
599	if (linesw[tty->t_line].l_close != NULL) {
600	sc = linesw[tty->t_line].l_close(tty);
601	}
602	tty->t_line=(int)(args->buffer);
603	tty->t_sc = NULL; /* ensure that no more valid data */
604	/*
605	* open new line discipline
606	*/
607	if (linesw[tty->t_line].l_open != NULL) {
608	sc = linesw[tty->t_line].l_open(tty);
609	}
610	break;
611	case TIOCGETD:
612	(int)(args->buffer)=tty->t_line;
613	break;
614	#endif
615	case FIONREAD:
616	{
617	int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
618	if ( rawnc < 0 )
619	rawnc += tty->rawInBuf.Size;
620	/* Half guess that this is the right operation */
621	(int )args->buffer = tty->ccount - tty->cindex + rawnc;
622	}
623	break;
624	}
625	rtems_semaphore_release (tty->osem);
626	args->ioctl_return = sc;
627	return sc;
628	}
629
630	/*
631	* Send characters to device-specific code
632	*/
633	void
634	rtems_termios_puts (
635	const void _buf, int len, struct rtems_termios_tty tty)
636	{
637	const unsigned char *buf = _buf;
638	unsigned int newHead;
639	rtems_interrupt_level level;
640	rtems_status_code sc;
641
642	if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
643	(tty->device.write)(tty->minor, (void )buf, len);
644	return;
645	}
646	newHead = tty->rawOutBuf.Head;
647	while (len) {
648	/*
649	* Performance improvement could be made here.
650	* Copy multiple bytes to raw buffer:
651	* if (len > 1) && (space to buffer end, or tail > 1)
652	* ncopy = MIN (len, space to buffer end or tail)
653	* memcpy (raw buffer, buf, ncopy)
654	* buf += ncopy
655	* len -= ncopy
656	*
657	* To minimize latency, the memcpy should be done
658	* with interrupts enabled.
659	*/
660	newHead = (newHead + 1) % tty->rawOutBuf.Size;
661	rtems_interrupt_disable (level);
662	while (newHead == tty->rawOutBuf.Tail) {
663	tty->rawOutBufState = rob_wait;
664	rtems_interrupt_enable (level);
665	sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
666	RTEMS_WAIT,
667	RTEMS_NO_TIMEOUT);
668	if (sc != RTEMS_SUCCESSFUL)
669	rtems_fatal_error_occurred (sc);
670	rtems_interrupt_disable (level);
671	}
672	tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
673	tty->rawOutBuf.Head = newHead;
674	if (tty->rawOutBufState == rob_idle) {
675	/* check, whether XOFF has been received */
676	if (!(tty->flow_ctrl & FL_ORCVXOF)) {
677	(*tty->device.write)(tty->minor,
678	(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
679	}
680	else {
681	/* remember that output has been stopped due to flow ctrl*/
682	tty->flow_ctrl \|= FL_OSTOP;
683	}
684	tty->rawOutBufState = rob_busy;
685	}
686	rtems_interrupt_enable (level);
687	len--;
688	}
689	}
690
691	/*
692	* Handle output processing
693	*/
694	static void
695	oproc (unsigned char c, struct rtems_termios_tty *tty)
696	{
697	int i;
698
699	if (tty->termios.c_oflag & OPOST) {
700	switch (c) {
701	case '\n':
702	if (tty->termios.c_oflag & ONLRET)
703	tty->column = 0;
704	if (tty->termios.c_oflag & ONLCR) {
705	rtems_termios_puts ("\r", 1, tty);
706	tty->column = 0;
707	}
708	break;
709
710	case '\r':
711	if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
712	return;
713	if (tty->termios.c_oflag & OCRNL) {
714	c = '\n';
715	if (tty->termios.c_oflag & ONLRET)
716	tty->column = 0;
717	break;
718	}
719	tty->column = 0;
720	break;
721
722	case '\t':
723	i = 8 - (tty->column & 7);
724	if ((tty->termios.c_oflag & TABDLY) == XTABS) {
725	tty->column += i;
726	rtems_termios_puts ( " ", i, tty);
727	return;
728	}
729	tty->column += i;
730	break;
731
732	case '\b':
733	if (tty->column > 0)
734	tty->column--;
735	break;
736
737	default:
738	if (tty->termios.c_oflag & OLCUC)
739	c = toupper(c);
740	if (!iscntrl(c))
741	tty->column++;
742	break;
743	}
744	}
745	rtems_termios_puts (&c, 1, tty);
746	}
747
748	rtems_status_code
749	rtems_termios_write (void *arg)
750	{
751	rtems_libio_rw_args_t *args = arg;
752	struct rtems_termios_tty *tty = args->iop->data1;
753	rtems_status_code sc;
754
755	sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
756	if (sc != RTEMS_SUCCESSFUL)
757	return sc;
758	if (linesw[tty->t_line].l_write != NULL) {
759	sc = linesw[tty->t_line].l_write(tty,args);
760	rtems_semaphore_release (tty->osem);
761	return sc;
762	}
763	if (tty->termios.c_oflag & OPOST) {
764	uint32_t count = args->count;
765	char *buffer = args->buffer;
766	while (count--)
767	oproc (*buffer++, tty);
768	args->bytes_moved = args->count;
769	}
770	else {
771	rtems_termios_puts (args->buffer, args->count, tty);
772	args->bytes_moved = args->count;
773	}
774	rtems_semaphore_release (tty->osem);
775	return sc;
776	}
777
778	/*
779	* Echo a typed character
780	*/
781	static void
782	echo (unsigned char c, struct rtems_termios_tty *tty)
783	{
784	if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
785	char echobuf[2];
786
787	echobuf[0] = '^';
788	echobuf[1] = c ^ 0x40;
789	rtems_termios_puts (echobuf, 2, tty);
790	tty->column += 2;
791	}
792	else {
793	oproc (c, tty);
794	}
795	}
796
797	/*
798	* Erase a character or line
799	* FIXME: Needs support for WERASE and ECHOPRT.
800	* FIXME: Some of the tests should check for IEXTEN, too.
801	*/
802	static void
803	erase (struct rtems_termios_tty *tty, int lineFlag)
804	{
805	if (tty->ccount == 0)
806	return;
807	if (lineFlag) {
808	if (!(tty->termios.c_lflag & ECHO)) {
809	tty->ccount = 0;
810	return;
811	}
812	if (!(tty->termios.c_lflag & ECHOE)) {
813	tty->ccount = 0;
814	echo (tty->termios.c_cc[VKILL], tty);
815	if (tty->termios.c_lflag & ECHOK)
816	echo ('\n', tty);
817	return;
818	}
819	}
820	while (tty->ccount) {
821	unsigned char c = tty->cbuf[--tty->ccount];
822
823	if (tty->termios.c_lflag & ECHO) {
824	if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
825	echo (tty->termios.c_cc[VERASE], tty);
826	}
827	else if (c == '\t') {
828	int col = tty->read_start_column;
829	int i = 0;
830
831	/*
832	* Find the character before the tab
833	*/
834	while (i != tty->ccount) {
835	c = tty->cbuf[i++];
836	if (c == '\t') {
837	col = (col \| 7) + 1;
838	}
839	else if (iscntrl (c)) {
840	if (tty->termios.c_lflag & ECHOCTL)
841	col += 2;
842	}
843	else {
844	col++;
845	}
846	}
847
848	/*
849	* Back up over the tab
850	*/
851	while (tty->column > col) {
852	rtems_termios_puts ("\b", 1, tty);
853	tty->column--;
854	}
855	}
856	else {
857	if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
858	rtems_termios_puts ("\b \b", 3, tty);
859	if (tty->column)
860	tty->column--;
861	}
862	if (!iscntrl (c) \|\| (tty->termios.c_lflag & ECHOCTL)) {
863	rtems_termios_puts ("\b \b", 3, tty);
864	if (tty->column)
865	tty->column--;
866	}
867	}
868	}
869	if (!lineFlag)
870	break;
871	}
872	}
873
874	/*
875	* Process a single input character
876	*/
877	static int
878	iproc (unsigned char c, struct rtems_termios_tty *tty)
879	{
880	if (tty->termios.c_iflag & ISTRIP)
881	c &= 0x7f;
882	if (tty->termios.c_iflag & IUCLC)
883	c = tolower (c);
884	if (c == '\r') {
885	if (tty->termios.c_iflag & IGNCR)
886	return 0;
887	if (tty->termios.c_iflag & ICRNL)
888	c = '\n';
889	}
890	else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
891	c = '\r';
892	}
893	if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
894	if (c == tty->termios.c_cc[VERASE]) {
895	erase (tty, 0);
896	return 0;
897	}
898	else if (c == tty->termios.c_cc[VKILL]) {
899	erase (tty, 1);
900	return 0;
901	}
902	else if (c == tty->termios.c_cc[VEOF]) {
903	return 1;
904	}
905	else if (c == '\n') {
906	if (tty->termios.c_lflag & (ECHO \| ECHONL))
907	echo (c, tty);
908	tty->cbuf[tty->ccount++] = c;
909	return 1;
910	}
911	else if ((c == tty->termios.c_cc[VEOL])
912	\|\| (c == tty->termios.c_cc[VEOL2])) {
913	if (tty->termios.c_lflag & ECHO)
914	echo (c, tty);
915	tty->cbuf[tty->ccount++] = c;
916	return 1;
917	}
918	}
919
920	/*
921	* FIXME: Should do IMAXBEL handling somehow
922	*/
923	if (tty->ccount < (CBUFSIZE-1)) {
924	if (tty->termios.c_lflag & ECHO)
925	echo (c, tty);
926	tty->cbuf[tty->ccount++] = c;
927	}
928	return 0;
929	}
930
931	/*
932	* Process input character, with semaphore.
933	*/
934	static int
935	siproc (unsigned char c, struct rtems_termios_tty *tty)
936	{
937	int i;
938
939	/*
940	* Obtain output semaphore if character will be echoed
941	*/
942	if (tty->termios.c_lflag & (ECHO\|ECHOE\|ECHOK\|ECHONL\|ECHOPRT\|ECHOCTL\|ECHOKE)) {
943	rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
944	i = iproc (c, tty);
945	rtems_semaphore_release (tty->osem);
946	}
947	else {
948	i = iproc (c, tty);
949	}
950	return i;
951	}
952
953	/*
954	* Fill the input buffer by polling the device
955	*/
956	static rtems_status_code
957	fillBufferPoll (struct rtems_termios_tty *tty)
958	{
959	int n;
960
961	if (tty->termios.c_lflag & ICANON) {
962	for (;;) {
963	n = (*tty->device.pollRead)(tty->minor);
964	if (n < 0) {
965	rtems_task_wake_after (1);
966	}
967	else {
968	if (siproc (n, tty))
969	break;
970	}
971	}
972	}
973	else {
974	rtems_interval then, now;
975	if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
976	rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
977	for (;;) {
978	n = (*tty->device.pollRead)(tty->minor);
979	if (n < 0) {
980	if (tty->termios.c_cc[VMIN]) {
981	if (tty->termios.c_cc[VTIME] && tty->ccount) {
982	rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
983	if ((now - then) > tty->vtimeTicks) {
984	break;
985	}
986	}
987	}
988	else {
989	if (!tty->termios.c_cc[VTIME])
990	break;
991	rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
992	if ((now - then) > tty->vtimeTicks) {
993	break;
994	}
995	}
996	rtems_task_wake_after (1);
997	}
998	else {
999	siproc (n, tty);
1000	if (tty->ccount >= tty->termios.c_cc[VMIN])
1001	break;
1002	if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
1003	rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
1004	}
1005	}
1006	}
1007	return RTEMS_SUCCESSFUL;
1008	}
1009
1010	/*
1011	* Fill the input buffer from the raw input queue
1012	*/
1013	static rtems_status_code
1014	fillBufferQueue (struct rtems_termios_tty *tty)
1015	{
1016	rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
1017	rtems_status_code sc;
1018	int wait = (int)1;
1019
1020	while ( wait ) {
1021	/*
1022	* Process characters read from raw queue
1023	*/
1024	while (tty->rawInBuf.Head != tty->rawInBuf.Tail) {
1025	unsigned char c;
1026	unsigned int newHead;
1027
1028	newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
1029	c = tty->rawInBuf.theBuf[newHead];
1030	tty->rawInBuf.Head = newHead;
1031	if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
1032	% tty->rawInBuf.Size)
1033	< tty->lowwater) {
1034	tty->flow_ctrl &= ~FL_IREQXOF;
1035	/* if tx stopped and XON should be sent... */
1036	if (((tty->flow_ctrl & (FL_MDXON \| FL_ISNTXOF))
1037	== (FL_MDXON \| FL_ISNTXOF))
1038	&& ((tty->rawOutBufState == rob_idle)
1039	\|\| (tty->flow_ctrl & FL_OSTOP))) {
1040	/* XON should be sent now... */
1041	(*tty->device.write)(tty->minor,
1042	(void *)&(tty->termios.c_cc[VSTART]),
1043	1);
1044	}
1045	else if (tty->flow_ctrl & FL_MDRTS) {
1046	tty->flow_ctrl &= ~FL_IRTSOFF;
1047	/* activate RTS line */
1048	if (tty->device.startRemoteTx != NULL) {
1049	tty->device.startRemoteTx(tty->minor);
1050	}
1051	}
1052	}
1053
1054	/* continue processing new character */
1055	if (tty->termios.c_lflag & ICANON) {
1056	if (siproc (c, tty))
1057	wait = 0;
1058	}
1059	else {
1060	siproc (c, tty);
1061	if (tty->ccount >= tty->termios.c_cc[VMIN])
1062	wait = 0;
1063	}
1064	timeout = tty->rawInBufSemaphoreTimeout;
1065	}
1066
1067	/*
1068	* Wait for characters
1069	*/
1070	if ( wait ) {
1071	sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore,
1072	tty->rawInBufSemaphoreOptions,
1073	timeout);
1074	if (sc != RTEMS_SUCCESSFUL)
1075	break;
1076	}
1077	}
1078	return RTEMS_SUCCESSFUL;
1079	}
1080
1081	rtems_status_code
1082	rtems_termios_read (void *arg)
1083	{
1084	rtems_libio_rw_args_t *args = arg;
1085	struct rtems_termios_tty *tty = args->iop->data1;
1086	uint32_t count = args->count;
1087	char *buffer = args->buffer;
1088	rtems_status_code sc;
1089
1090	sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
1091	if (sc != RTEMS_SUCCESSFUL)
1092	return sc;
1093	if (linesw[tty->t_line].l_read != NULL) {
1094	sc = linesw[tty->t_line].l_read(tty,args);
1095	tty->tty_rcvwakeup = 0;
1096	rtems_semaphore_release (tty->isem);
1097	return sc;
1098	}
1099	if (tty->cindex == tty->ccount) {
1100	tty->cindex = tty->ccount = 0;
1101	tty->read_start_column = tty->column;
1102	if (tty->device.pollRead != NULL
1103	&& tty->device.outputUsesInterrupts == TERMIOS_POLLED)
1104	sc = fillBufferPoll (tty);
1105	else
1106	sc = fillBufferQueue (tty);
1107	if (sc != RTEMS_SUCCESSFUL)
1108	tty->cindex = tty->ccount = 0;
1109	}
1110	while (count && (tty->cindex < tty->ccount)) {
1111	*buffer++ = tty->cbuf[tty->cindex++];
1112	count--;
1113	}
1114	args->bytes_moved = args->count - count;
1115	tty->tty_rcvwakeup = 0;
1116	rtems_semaphore_release (tty->isem);
1117	return sc;
1118	}
1119
1120	/*
1121	* signal receive interrupt to rx daemon
1122	* NOTE: This routine runs in the context of the
1123	* device receive interrupt handler.
1124	*/
1125	void rtems_termios_rxirq_occured(struct rtems_termios_tty *tty)
1126	{
1127	/*
1128	* send event to rx daemon task
1129	*/
1130	rtems_event_send(tty->rxTaskId,TERMIOS_RX_PROC_EVENT);
1131	}
1132
1133	/*
1134	* Place characters on raw queue.
1135	* NOTE: This routine runs in the context of the
1136	* device receive interrupt handler.
1137	* Returns the number of characters dropped because of overflow.
1138	*/
1139	int
1140	rtems_termios_enqueue_raw_characters (void ttyp, char buf, int len)
1141	{
1142	struct rtems_termios_tty *tty = ttyp;
1143	unsigned int newTail;
1144	char c;
1145	int dropped = 0;
1146	boolean flow_rcv = FALSE; /* TRUE, if flow control char received */
1147	rtems_interrupt_level level;
1148
1149	if (linesw[tty->t_line].l_rint != NULL) {
1150	while (len--) {
1151	c = *buf++;
1152	linesw[tty->t_line].l_rint(c,tty);
1153	}
1154
1155	/*
1156	* check to see if rcv wakeup callback was set
1157	*/
1158	if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
1159	(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
1160	tty->tty_rcvwakeup = 1;
1161	}
1162	return 0;
1163	}
1164
1165	while (len--) {
1166	c = *buf++;
1167	/* FIXME: implement IXANY: any character restarts output */
1168	/* if incoming XON/XOFF controls outgoing stream: */
1169	if (tty->flow_ctrl & FL_MDXON) {
1170	/* if received char is V_STOP and V_START (both are equal value) */
1171	if (c == tty->termios.c_cc[VSTOP]) {
1172	if (c == tty->termios.c_cc[VSTART]) {
1173	/* received VSTOP and VSTART==VSTOP? */
1174	/* then toggle "stop output" status */
1175	tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
1176	}
1177	else {
1178	/* VSTOP received (other code than VSTART) */
1179	/* stop output */
1180	tty->flow_ctrl \|= FL_ORCVXOF;
1181	}
1182	flow_rcv = TRUE;
1183	}
1184	else if (c == tty->termios.c_cc[VSTART]) {
1185	/* VSTART received */
1186	/* restart output */
1187	tty->flow_ctrl &= ~FL_ORCVXOF;
1188	flow_rcv = TRUE;
1189	}
1190	}
1191	if (flow_rcv) {
1192	/* restart output according to FL_ORCVXOF flag */
1193	if ((tty->flow_ctrl & (FL_ORCVXOF \| FL_OSTOP)) == FL_OSTOP) {
1194	/* disable interrupts */
1195	rtems_interrupt_disable(level);
1196	tty->flow_ctrl &= ~FL_OSTOP;
1197	/* check for chars in output buffer (or rob_state?) */
1198	if (tty->rawOutBufState != rob_idle) {
1199	/* if chars available, call write function... */
1200	(*tty->device.write)(tty->minor,
1201	&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
1202	}
1203	/* reenable interrupts */
1204	rtems_interrupt_enable(level);
1205	}
1206	}
1207	else {
1208	newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
1209	/* if chars_in_buffer > highwater */
1210	rtems_interrupt_disable(level);
1211	if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
1212	% tty->rawInBuf.Size)
1213	> tty->highwater) &&
1214	!(tty->flow_ctrl & FL_IREQXOF)) {
1215	/* incoming data stream should be stopped */
1216	tty->flow_ctrl \|= FL_IREQXOF;
1217	if ((tty->flow_ctrl & (FL_MDXOF \| FL_ISNTXOF))
1218	== (FL_MDXOF ) ){
1219	if ((tty->flow_ctrl & FL_OSTOP) \|\|
1220	(tty->rawOutBufState == rob_idle)) {
1221	/* if tx is stopped due to XOFF or out of data */
1222	/* call write function here */
1223	tty->flow_ctrl \|= FL_ISNTXOF;
1224	(*tty->device.write)(tty->minor,
1225	(void *)&(tty->termios.c_cc[VSTOP]),
1226	1);
1227	}
1228	}
1229	else if ((tty->flow_ctrl & (FL_MDRTS \| FL_IRTSOFF))
1230	== (FL_MDRTS ) ) {
1231	tty->flow_ctrl \|= FL_IRTSOFF;
1232	/* deactivate RTS line */
1233	if (tty->device.stopRemoteTx != NULL) {
1234	tty->device.stopRemoteTx(tty->minor);
1235	}
1236	}
1237	}
1238	/* reenable interrupts */
1239	rtems_interrupt_enable(level);
1240
1241	if (newTail == tty->rawInBuf.Head) {
1242	dropped++;
1243	}
1244	else {
1245	tty->rawInBuf.theBuf[newTail] = c;
1246	tty->rawInBuf.Tail = newTail;
1247
1248	/*
1249	* check to see if rcv wakeup callback was set
1250	*/
1251	if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
1252	(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
1253	tty->tty_rcvwakeup = 1;
1254	}
1255	}
1256	}
1257	}
1258	tty->rawInBufDropped += dropped;
1259	rtems_semaphore_release (tty->rawInBuf.Semaphore);
1260	return dropped;
1261	}
1262
1263	/*
1264	* in task-driven mode, this function is called in Tx task context
1265	* in interrupt-driven mode, this function is called in TxIRQ context
1266	*/
1267	int
1268	rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
1269	{
1270	unsigned int newTail;
1271	int nToSend;
1272	rtems_interrupt_level level;
1273	int len;
1274
1275	/* check for XOF/XON to send */
1276	if ((tty->flow_ctrl & (FL_MDXOF \| FL_IREQXOF \| FL_ISNTXOF))
1277	== (FL_MDXOF \| FL_IREQXOF)) {
1278	/* XOFF should be sent now... */
1279	(*tty->device.write)(tty->minor,
1280	(void *)&(tty->termios.c_cc[VSTOP]), 1);
1281
1282	rtems_interrupt_disable(level);
1283	tty->t_dqlen--;
1284	tty->flow_ctrl \|= FL_ISNTXOF;
1285	rtems_interrupt_enable(level);
1286
1287	nToSend = 1;
1288	}
1289	else if ((tty->flow_ctrl & (FL_IREQXOF \| FL_ISNTXOF))
1290	== FL_ISNTXOF) {
1291	/* NOTE: send XON even, if no longer in XON/XOFF mode... */
1292	/* XON should be sent now... */
1293	/*
1294	* FIXME: this .write call will generate another
1295	* dequeue callback. This will advance the "Tail" in the data
1296	* buffer, although the corresponding data is not yet out!
1297	* Therefore the dequeue "length" should be reduced by 1
1298	*/
1299	(*tty->device.write)(tty->minor,
1300	(void *)&(tty->termios.c_cc[VSTART]), 1);
1301
1302	rtems_interrupt_disable(level);
1303	tty->t_dqlen--;
1304	tty->flow_ctrl &= ~FL_ISNTXOF;
1305	rtems_interrupt_enable(level);
1306
1307	nToSend = 1;
1308	}
1309	else {
1310	if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
1311	/*
1312	* buffer was empty
1313	*/
1314	if (tty->rawOutBufState == rob_wait) {
1315	/*
1316	* this should never happen...
1317	*/
1318	rtems_semaphore_release (tty->rawOutBuf.Semaphore);
1319	}
1320	return 0;
1321	}
1322
1323	rtems_interrupt_disable(level);
1324	len = tty->t_dqlen;
1325	tty->t_dqlen = 0;
1326	rtems_interrupt_enable(level);
1327
1328	newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
1329	tty->rawOutBuf.Tail = newTail;
1330	if (tty->rawOutBufState == rob_wait) {
1331	/*
1332	* wake up any pending writer task
1333	*/
1334	rtems_semaphore_release (tty->rawOutBuf.Semaphore);
1335	}
1336	if (newTail == tty->rawOutBuf.Head) {
1337	/*
1338	* Buffer has become empty
1339	*/
1340	tty->rawOutBufState = rob_idle;
1341	nToSend = 0;
1342
1343	/*
1344	* check to see if snd wakeup callback was set
1345	*/
1346	if ( tty->tty_snd.sw_pfn != NULL) {
1347	(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
1348	}
1349	}
1350	/* check, whether output should stop due to received XOFF */
1351	else if ((tty->flow_ctrl & (FL_MDXON \| FL_ORCVXOF))
1352	== (FL_MDXON \| FL_ORCVXOF)) {
1353	/* Buffer not empty, but output stops due to XOFF */
1354	/* set flag, that output has been stopped */
1355	rtems_interrupt_disable(level);
1356	tty->flow_ctrl \|= FL_OSTOP;
1357	tty->rawOutBufState = rob_busy; /apm/
1358	rtems_interrupt_enable(level);
1359	nToSend = 0;
1360	}
1361	else {
1362	/*
1363	* Buffer not empty, start tranmitter
1364	*/
1365	if (newTail > tty->rawOutBuf.Head)
1366	nToSend = tty->rawOutBuf.Size - newTail;
1367	else
1368	nToSend = tty->rawOutBuf.Head - newTail;
1369	/* when flow control XON or XOF, don't send blocks of data */
1370	/* to allow fast reaction on incoming flow ctrl and low latency*/
1371	/* for outgoing flow control */
1372	if (tty->flow_ctrl & (FL_MDXON \| FL_MDXOF)) {
1373	nToSend = 1;
1374	}
1375	tty->rawOutBufState = rob_busy; /apm/
1376	(*tty->device.write)(tty->minor,
1377	&tty->rawOutBuf.theBuf[newTail],
1378	nToSend);
1379	}
1380	tty->rawOutBuf.Tail = newTail; /apm/
1381	}
1382	return nToSend;
1383	}
1384
1385	/*
1386	* Characters have been transmitted
1387	* NOTE: This routine runs in the context of the
1388	* device transmit interrupt handler.
1389	* The second argument is the number of characters transmitted so far.
1390	* This value will always be 1 for devices which generate an interrupt
1391	* for each transmitted character.
1392	* It returns number of characters left to transmit
1393	*/
1394	int
1395	rtems_termios_dequeue_characters (void *ttyp, int len)
1396	{
1397	struct rtems_termios_tty *tty = ttyp;
1398	rtems_status_code sc;
1399
1400	/*
1401	* sum up character count already sent
1402	*/
1403	tty->t_dqlen += len;
1404
1405	if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
1406	/*
1407	* send wake up to transmitter task
1408	*/
1409	sc = rtems_event_send(tty->txTaskId,
1410	TERMIOS_TX_START_EVENT);
1411	if (sc != RTEMS_SUCCESSFUL)
1412	rtems_fatal_error_occurred (sc);
1413	return 0; /* nothing to output in IRQ... */
1414	}
1415	else if (tty->t_line == PPPDISC ) {
1416	/*
1417	* call any line discipline start function
1418	*/
1419	if (linesw[tty->t_line].l_start != NULL) {
1420	linesw[tty->t_line].l_start(tty);
1421	}
1422	return 0; /* nothing to output in IRQ... */
1423	}
1424	else {
1425	return rtems_termios_refill_transmitter(tty);
1426	}
1427	}
1428
1429	/*
1430	* this task actually processes any transmit events
1431	*/
1432	static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
1433	{
1434	struct rtems_termios_tty tty = (struct rtems_termios_tty )argument;
1435	rtems_event_set the_event;
1436
1437	while (1) {
1438	/*
1439	* wait for rtems event
1440	*/
1441	rtems_event_receive((TERMIOS_TX_START_EVENT \|
1442	TERMIOS_TX_TERMINATE_EVENT),
1443	RTEMS_EVENT_ANY \| RTEMS_WAIT,
1444	RTEMS_NO_TIMEOUT,
1445	&the_event);
1446	if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
1447	tty->txTaskId = 0;
1448	rtems_task_delete(RTEMS_SELF);
1449	}
1450	else {
1451	/*
1452	* call any line discipline start function
1453	*/
1454	if (linesw[tty->t_line].l_start != NULL) {
1455	linesw[tty->t_line].l_start(tty);
1456	}
1457	/*
1458	* try to push further characters to device
1459	*/
1460	rtems_termios_refill_transmitter(tty);
1461	}
1462	}
1463	}
1464
1465	/*
1466	* this task actually processes any receive events
1467	*/
1468	static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
1469	{
1470	struct rtems_termios_tty tty = (struct rtems_termios_tty )argument;
1471	rtems_event_set the_event;
1472	int c;
1473	char c_buf;
1474	while (1) {
1475	/*
1476	* wait for rtems event
1477	*/
1478	rtems_event_receive((TERMIOS_RX_PROC_EVENT \|
1479	TERMIOS_RX_TERMINATE_EVENT),
1480	RTEMS_EVENT_ANY \| RTEMS_WAIT,
1481	RTEMS_NO_TIMEOUT,
1482	&the_event);
1483	if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
1484	tty->rxTaskId = 0;
1485	rtems_task_delete(RTEMS_SELF);
1486	}
1487	else {
1488	/*
1489	* do something
1490	*/
1491	c = tty->device.pollRead(tty->minor);
1492	if (c != EOF) {
1493	/*
1494	* pollRead did call enqueue on its own
1495	*/
1496	c_buf = c;
1497	rtems_termios_enqueue_raw_characters (
1498	tty,&c_buf,1);
1499	}
1500	}
1501	}
1502	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: