Context Navigation

sci.c @ 1c6926c1

Last change on this file since 1c6926c1 was 1c6926c1, checked in by Kevin Kirspel <kevin-kirspel@…>, on 03/21/17 at 19:39:48

termios: Synchronize with latest FreeBSD headers

Adding modified FreeBSD headers to synchronize RTEMS termios with
FreeBSD. Modify termios to support dedicated input and output baud for
termios structure. Updated BSPs to use dedicated input and output baud
in termios structure. Updated tools to use dedicated input and output
baud in termios structure. Updated termios testsuites to use dedicated
input and output baud in termios structure.

Close #2897.

Property mode set to 100644

File size: 50.5 KB

Line
1	/*****************************************************************************
2	* File: sci.c
3	*
4	* Desc: This file contains the console IO routines for the SCI port.
5	* There are two interfaces in this module. One is for the rtems
6	* termios/console code and the other is a device driver interface.
7	* This module works together with the termio module which is
8	* sometimes referred to as the "line disciplines" which implements
9	* terminal i/o processing like tabs, backspaces, and newlines.
10	* The rtems printf uses interrupt io and the rtems printk routine
11	* uses polled io which is better for debugging.
12	*
13	* Index: Documentation
14	* Section A - Include Files
15	* Section B - Manifest Constants
16	* Section C - External Data
17	* Section D - External Functions
18	* Section E - Local Functions
19	* Section F - Local Variables
20	* Section G - A circular data buffer for rcv chars
21	* Section H - RTEMS termios callbacks for the interrupt api
22	* Section I - RTEMS termios callbacks for the polled api
23
24	* Section 0 - Miscellaneous routines
25	* Section 1 - Routines to manipulate the circular buffer
26	* Section 2 - Interrupt based entry points for the termios module
27	* Section 3 - Polling based entry points for the termios module
28	* Section 4 - Device driver public api entry points
29	* Section 5 - Hardware level routines
30	* Section 6 - Testing and debugging code
31	*
32	* Refer: Motorola QSM Reference Manual - Chapter 5 - SCI sub-module
33	*
34	* Note: See bsp.h,confdefs.h,system.h for installing drivers into RTEMS.
35	*
36	*****************************************************************************/
37
38	/*****************************************************************************
39	Overview of serial port console terminal input/output
40	*****************************************************************************/
41
42	/*
43	+-----------+ +---------+
44	\| app \| \| app \|
45	+-----------+ +---------+
46	\| \|
47	\| (printf,scanf,etc.) \|
48	v \|
49	+-----------+ \|
50	\| libc \| \|
51	+-----------+ \|
52	\| \|
53	\| \|
54	\| (open,close,read,write,ioctl) \|
55	======\|==========================================\|========================
56	\| /dev/console \| /dev/sci
57	\| (stdin,stdout,stderr) \|
58	======\|==========================================\|========================
59	\| \|
60	\| \|
61	v v
62	+-----------+ +-----------+ +---------+
63	\| console \| <---> \| termios \| <---> \| sci \|
64	\| driver \| \| module \| \| driver \|
65	+-----------+ +-----------+ +---------+
66	\|
67	\|
68	v
69	+---------+
70	\| \|
71	\| uart \|
72	\| \|
73	+---------+
74	*/
75
76
77	/*****************************************************************************
78	Section A - Include Files
79	*****************************************************************************/
80
81	#include <rtems.h>
82	#include <bsp.h>
83	#include <rtems/bspIo.h>
84	#include <stdio.h>
85	#include <rtems/libio.h>
86	#include <libchip/serial.h>
87	#include <libchip/sersupp.h>
88	#include "sci.h"
89	#include <rtems/m68k/qsm.h>
90	/#include "../misc/include/cpu332.h" /
91
92	/*****************************************************************************
93	Section B - Manifest Constants
94	*****************************************************************************/
95
96	#define SCI_MINOR 0 /* minor device number */
97
98	/* IMPORTANT - if the device driver api is opened, it means the sci is being
99	* used for direct hardware access, so other users (like termios) get ignored
100	*/
101	#define DRIVER_CLOSED 0 /* the device driver api is closed */
102	#define DRIVER_OPENED 1 /* the device driver api is opened */
103
104	/* system clock definitions, i dont have documentation on this... */
105
106	#if 0 /* Not needed, this is provided in mrm332.h */
107	#define XTAL 32768.0 /* crystal frequency in Hz */
108	#define NUMB_W 0 /* system clock parameters */
109	#define NUMB_X 1
110	#define NUMB_Y 0x38 /* for 14.942 Mhz */
111	#define NUMB_Y 0x3F /* for 16.777 Mhz */
112
113	#define SYS_CLOCK (XTAL * 4.0 * (NUMB_Y+1) * (1 << (2 * NUMB_W + NUMB_X)))
114
115	#endif
116
117
118	/*****************************************************************************
119	Section C - External Data
120	*****************************************************************************/
121
122
123
124	/*****************************************************************************
125	Section D - External Functions
126	*****************************************************************************/
127
128
129
130	/*****************************************************************************
131	Section E - Local Functions
132	*****************************************************************************/
133
134	void SCI_output_char(char c);
135
136	/rtems_isr SciIsr( rtems_vector_number vector ); interrupt handler /
137
138	const rtems_termios_callbacks * SciGetTermiosHandlers( int32_t polled );
139
140	rtems_device_driver SciInitialize( /* device driver api */
141	rtems_device_major_number, rtems_device_minor_number, void *);
142	rtems_device_driver SciOpen( /* device driver api */
143	rtems_device_major_number, rtems_device_minor_number, void *);
144	rtems_device_driver SciClose( /* device driver api */
145	rtems_device_major_number, rtems_device_minor_number, void *);
146	rtems_device_driver SciRead( /* device driver api */
147	rtems_device_major_number, rtems_device_minor_number, void *);
148	rtems_device_driver SciWrite( /* device driver api */
149	rtems_device_major_number, rtems_device_minor_number, void *);
150	rtems_device_driver SciControl( /* device driver api */
151	rtems_device_major_number, rtems_device_minor_number, void *);
152	rtems_device_driver SciRead (
153	rtems_device_major_number, rtems_device_minor_number, void *);
154
155	rtems_isr SciIsr( rtems_vector_number vector );
156
157	int SciInterruptOpen(int, int, void ); / termios api */
158	int SciInterruptClose(int, int, void ); / termios api */
159	ssize_t SciInterruptWrite(int, const char , size_t); / termios api */
160
161	int SciSetAttributes(int, const struct termios); / termios api */
162	int SciPolledOpen(int, int, void ); / termios api */
163	int SciPolledClose(int, int, void ); / termios api */
164	int SciPolledRead(int); /* termios api */
165	ssize_t SciPolledWrite(int, const char , size_t); / termios api */
166
167	static void SciSetBaud(uint32_t rate); /* hardware routine */
168	static void SciSetDataBits(uint16_t bits); /* hardware routine */
169	static void SciSetParity(uint16_t parity); /* hardware routine */
170
171	static void inline SciDisableAllInterrupts( void ); /* hardware routine */
172	static void inline SciDisableTransmitInterrupts( void );/* hardware routine */
173	static void inline SciDisableReceiveInterrupts( void ); /* hardware routine */
174
175	static void inline SciEnableTransmitInterrupts( void ); /* hardware routine */
176	static void inline SciEnableReceiveInterrupts( void ); /* hardware routine */
177
178	static void inline SciDisableReceiver( void ); /* hardware routine */
179	static void inline SciDisableTransmitter( void ); /* hardware routine */
180
181	static void inline SciEnableReceiver( void ); /* hardware routine */
182	static void inline SciEnableTransmitter( void ); /* hardware routine */
183
184	void SciWriteCharWait ( uint8_t ); /* hardware routine */
185	void SciWriteCharNoWait( uint8_t ); /* hardware routine */
186
187	uint8_t inline SciCharAvailable( void ); /* hardware routine */
188
189	static uint8_t inline SciReadCharWait( void ); /* hardware routine */
190	static uint8_t inline SciReadCharNoWait( void ); /* hardware routine */
191
192	void SciSendBreak( void ); /* test routine */
193
194	static int8_t SciRcvBufGetChar(void); /* circular rcv buf */
195	static void SciRcvBufPutChar( uint8_t); /* circular rcv buf */
196	#if 0
197	static void SciRcvBufFlush( void ); /* unused routine */
198	#endif
199
200	void SciUnitTest(void); /* test routine */
201	void SciPrintStats(void); /* test routine */
202
203
204	/*****************************************************************************
205	Section F - Local Variables
206	*****************************************************************************/
207
208	static struct rtems_termios_tty *SciTermioTty;
209
210	static uint8_t SciInited = 0; /* has the driver been inited */
211
212	static uint8_t SciOpened; /* has the driver been opened */
213
214	static uint8_t SciMajor; /* major device number */
215
216	static uint16_t SciBaud; /* current value in baud register */
217
218	static uint32_t SciBytesIn = 0; /* bytes received */
219	static uint32_t SciBytesOut = 0; /* bytes transmitted */
220
221	static uint32_t SciErrorsParity = 0; /* error counter */
222	static uint32_t SciErrorsNoise = 0; /* error counter */
223	static uint32_t SciErrorsFraming = 0; /* error counter */
224	static uint32_t SciErrorsOverrun = 0; /* error counter */
225
226	#if defined(CONSOLE_SCI)
227
228	/* this is what rtems printk uses to do polling based output */
229
230	BSP_output_char_function_type BSP_output_char = SCI_output_char;
231	BSP_polling_getchar_function_type BSP_poll_char = NULL;
232
233	#endif
234
235	/*****************************************************************************
236	Section G - A circular buffer for rcv chars when the driver interface is used.
237	*****************************************************************************/
238
239	/* it is trivial to wrap your buffer pointers when size is a power of two */
240
241	#define SCI_RCV_BUF_SIZE 256 /* must be a power of 2 !!! */
242
243	/* if someone opens the sci device using the device driver interface,
244	* then the receive data interrupt handler will put characters in this buffer
245	* instead of sending them up to the termios module for the console
246	*/
247	static uint8_t SciRcvBuffer[SCI_RCV_BUF_SIZE];
248
249	static uint8_t SciRcvBufPutIndex = 0; /* array index to put in next char */
250
251	static uint8_t SciRcvBufGetIndex = 0; /* array index to take out next char */
252
253	static uint16_t SciRcvBufCount = 0; /* how many bytes are in the buffer */
254
255
256
257	/*****************************************************************************
258	Section H - RTEMS termios callbacks for the interrupt version of the driver
259	*****************************************************************************/
260
261	static const rtems_termios_callbacks SciInterruptCallbacks =
262	{
263	SciInterruptOpen, /* first open */
264	SciInterruptClose, /* last close */
265	NULL, /* polled read (not required) */
266	SciInterruptWrite, /* write */
267	SciSetAttributes, /* set attributes */
268	NULL, /* stop remote xmit */
269	NULL, /* start remote xmit */
270	TRUE /* output uses interrupts */
271	};
272
273	/*****************************************************************************
274	Section I - RTEMS termios callbacks for the polled version of the driver
275	*****************************************************************************/
276
277	static const rtems_termios_callbacks SciPolledCallbacks =
278	{
279	SciPolledOpen, /* first open */
280	SciPolledClose, /* last close */
281	SciPolledRead, /* polled read */
282	SciPolledWrite, /* write */
283	SciSetAttributes, /* set attributes */
284	NULL, /* stop remote xmit */
285	NULL, /* start remote xmit */
286	FALSE /* output uses interrupts */
287	};
288
289
290	/*
291	* SECTION 0
292	* MISCELLANEOUS ROUTINES
293	*/
294
295	/****************************************************************************
296	* Func: SCI_output_char
297	* Desc: used by rtems printk function to send a char to the uart
298	* Inputs: the character to transmit
299	* Outputs: none
300	* Errors: none
301	* Scope: public
302	****************************************************************************/
303
304	void SCI_output_char(char c)
305	{
306	/* ( minor device number, pointer to the character, length ) */
307
308	SciPolledWrite( SCI_MINOR, &c, 1);
309
310	return;
311	}
312
313
314	/****************************************************************************
315	* Func: SciGetTermiosHandlers
316	* Desc: returns a pointer to the table of serial io functions
317	* this is called from console_open with polled set to false
318	* Inputs: flag indicating whether we want polled or interrupt driven io
319	* Outputs: pointer to function table
320	* Errors: none
321	* Scope: public
322	****************************************************************************/
323
324	const rtems_termios_callbacks * SciGetTermiosHandlers( int32_t polled )
325	{
326	if ( polled )
327	{
328	return &SciPolledCallbacks; /* polling based */
329	}
330	else
331	{
332	return &SciInterruptCallbacks; /* interrupt driven */
333	}
334	}
335
336
337	/****************************************************************************
338	* Func: SciIsr
339	* Desc: interrupt handler for serial communications interface
340	* Inputs: vector number - unused
341	* Outputs: none
342	* Errors: none
343	* Scope: public API
344	****************************************************************************/
345
346	rtems_isr SciIsr( rtems_vector_number vector )
347	{
348	uint8_t ch;
349
350	if ( (*SCSR) & SCI_ERROR_PARITY ) SciErrorsParity ++;
351	if ( (*SCSR) & SCI_ERROR_FRAMING ) SciErrorsFraming ++;
352	if ( (*SCSR) & SCI_ERROR_NOISE ) SciErrorsNoise ++;
353	if ( (*SCSR) & SCI_ERROR_OVERRUN ) SciErrorsOverrun ++;
354
355	/* see if it was a transmit interrupt */
356	/* data reg empty, xmt complete */
357	if ( ( SCCR1 & SCI_ENABLE_INT_TX ) && ( (SCSR) & SCI_XMTR_AVAILABLE ) )
358	{
359	SciDisableTransmitInterrupts();
360
361	/* tell termios module that the charcter was sent */
362	/* he will call us later to transmit more if there are any */
363
364	if (rtems_termios_dequeue_characters( SciTermioTty, 1 ))
365	{
366	/* there are more bytes to transmit so enable TX interrupt */
367
368	SciEnableTransmitInterrupts();
369	}
370	}
371
372	/* see if it was a receive interrupt */
373	/* on the sci uart we just get one character per interrupt */
374
375	while ( SciCharAvailable() ) /* char in data register? */
376	{
377	ch = SciReadCharNoWait(); /* get the char from the uart */
378
379	/* IMPORTANT!!! */
380	/* either send it to the termios module or keep it locally */
381
382	if ( SciOpened == DRIVER_OPENED ) /* the driver is open */
383	{
384	SciRcvBufPutChar(ch); /* keep it locally */
385	}
386	else /* put in termios buffer */
387	{
388	char c = (char) ch;
389	rtems_termios_enqueue_raw_characters( SciTermioTty, &c, 1 );
390	}
391
392	SCSR &= SCI_CLEAR_RX_INT; / clear the interrupt */
393	}
394	}
395
396
397	/*
398	* SECTION 1
399	* ROUTINES TO MANIPULATE THE CIRCULAR BUFFER
400	*/
401
402	/****************************************************************************
403	* Func: SciRcvBufGetChar
404	* Desc: read a character from the circular buffer
405	* make sure there is data before you call this!
406	* Inputs: none
407	* Outputs: the character or -1
408	* Errors: none
409	* Scope: private
410	****************************************************************************/
411
412	static int8_t SciRcvBufGetChar(void)
413	{
414	rtems_interrupt_level level;
415	uint8_t ch;
416
417	if ( SciRcvBufCount == 0 )
418	{
419	rtems_fatal_error_occurred(0xDEAD); /* check the count first! */
420	}
421
422	rtems_interrupt_disable( level ); /* disable interrupts */
423
424	ch = SciRcvBuffer[SciRcvBufGetIndex]; /* get next byte */
425
426	SciRcvBufGetIndex++; /* bump the index */
427
428	SciRcvBufGetIndex &= SCI_RCV_BUF_SIZE - 1; /* and wrap it */
429
430	SciRcvBufCount--; /* decrement counter */
431
432	rtems_interrupt_enable( level ); /* restore interrupts */
433
434	return ch; /* return the char */
435	}
436
437
438	/****************************************************************************
439	* Func: SciRcvBufPutChar
440	* Desc: put a character into the rcv data circular buffer
441	* Inputs: the character
442	* Outputs: none
443	* Errors: none
444	* Scope: private
445	****************************************************************************/
446
447	static void SciRcvBufPutChar( uint8_t ch )
448	{
449	rtems_interrupt_level level;
450
451	if ( SciRcvBufCount == SCI_RCV_BUF_SIZE ) /* is there room? */
452	{
453	return; /* no, throw it away */
454	}
455
456	rtems_interrupt_disable( level ); /* disable interrupts */
457
458	SciRcvBuffer[SciRcvBufPutIndex] = ch; /* put it in the buf */
459
460	SciRcvBufPutIndex++; /* bump the index */
461
462	SciRcvBufPutIndex &= SCI_RCV_BUF_SIZE - 1; /* and wrap it */
463
464	SciRcvBufCount++; /* increment counter */
465
466	rtems_interrupt_enable( level ); /* restore interrupts */
467
468	return; /* return */
469	}
470
471
472	/****************************************************************************
473	* Func: SciRcvBufFlush
474	* Desc: completely reset and clear the rcv buffer
475	* Inputs: none
476	* Outputs: none
477	* Errors: none
478	* Scope: private
479	****************************************************************************/
480
481	#if 0 /* prevents compiler warning */
482	static void SciRcvBufFlush( void )
483	{
484	rtems_interrupt_level level;
485
486	rtems_interrupt_disable( level ); /* disable interrupts */
487
488	memset( SciRcvBuffer, 0, sizeof(SciRcvBuffer) );
489
490	SciRcvBufPutIndex = 0; /* clear */
491
492	SciRcvBufGetIndex = 0; /* clear */
493
494	SciRcvBufCount = 0; /* clear */
495
496	rtems_interrupt_enable( level ); /* restore interrupts */
497
498	return; /* return */
499	}
500	#endif
501
502
503	/*
504	*
505	* SECTION 2
506	* INTERRUPT BASED ENTRY POINTS FOR THE TERMIOS MODULE
507	*/
508
509	/****************************************************************************
510	* Func: SciInterruptOpen
511	* Desc: open routine for the interrupt based device driver
512	* Default state is 9600 baud, 8 bits, No parity, and 1 stop bit. ??
513	CHANGED Default baud rate is now 19200, 8N1
514	* called from rtems_termios_open which is called from console_open
515	* Inputs: major - device number
516	* minor - device number
517	* args - points to terminal info
518	* Outputs: success/fail
519	* Errors: none
520	* Scope: public API
521	****************************************************************************/
522
523	int SciInterruptOpen(
524	int major,
525	int minor,
526	void *arg
527	)
528	{
529	rtems_libio_open_close_args_t * args = arg;
530	rtems_isr_entry old_vector;
531
532	if ( minor != SCI_MINOR ) /* check minor device num */
533	{
534	return -1;
535	}
536
537	if ( !args ) /* must have args */
538	{
539	return -1;
540	}
541
542	SciTermioTty = args->iop->data1; /* save address of struct */
543
544	SciDisableAllInterrupts(); /* turn off sci interrupts */
545
546	/* THIS IS ACTUALLY A BAD THING - SETTING LINE PARAMETERS HERE */
547	/* IT SHOULD BE DONE THROUGH TCSETATTR() WHEN THE CONSOLE IS OPENED!!! */
548
549	/* SciSetBaud(115200); set the baud rate */
550	/* SciSetBaud( 57600); set the baud rate */
551	/* SciSetBaud( 38400); set the baud rate */
552	/* SciSetBaud( 19200); set the baud rate */
553	SciSetBaud( 9600); /* set the baud rate */
554
555	SciSetParity(SCI_PARITY_NONE); /* set parity to none */
556
557	SciSetDataBits(SCI_8_DATA_BITS); /* set data bits to 8 */
558
559	/* Install our interrupt handler into RTEMS. */
560	/* 68 is an unused user-defined vector. Note that the vector must be */
561	/* even - it sets the low bit for SPI interrupts, and clears it for */
562	/* SCI interrupts. Also note that vector 66 is used by CPU32bug on */
563	/* the mrm332. */
564
565	rtems_interrupt_catch( SciIsr, 68, &old_vector );
566
567	QSMCR = (QSMCR & ~IARB) \| 1; // Is 1 a good value for qsm iarb?
568	*QIVR = 68;
569	*QILR &= 0xf8;
570	*QILR \|= 0x06 & 0x07;
571
572	SciEnableTransmitter(); /* enable the transmitter */
573
574	SciEnableReceiver(); /* enable the receiver */
575
576	SciEnableReceiveInterrupts(); /* enable rcv interrupts */
577
578	return RTEMS_SUCCESSFUL;
579	}
580
581
582	/****************************************************************************
583	* Func: SciInterruptClose
584	* Desc: close routine called by the termios module
585	* Inputs: major - device number
586	* minor - device number
587	* args - unused
588	* Outputs: success/fail
589	* Errors: none
590	* Scope: public - termio entry point
591	****************************************************************************/
592
593	int SciInterruptClose(
594	int major,
595	int minor,
596	void *arg
597	)
598	{
599	SciDisableAllInterrupts();
600
601	return RTEMS_SUCCESSFUL;
602	}
603
604
605	/****************************************************************************
606	* Func: SciInterruptWrite
607	* Desc: writes data to the uart using transmit interrupts
608	* Inputs: minor - device number
609	* buf - points to the data
610	* len - number of bytes to send
611	* Outputs: success/fail
612	* Errors: none
613	* Scope: public API
614	****************************************************************************/
615
616	ssize_t SciInterruptWrite(
617	int minor,
618	const char *buf,
619	size_t len
620	)
621	{
622	/* We are using interrupt driven output so termios only sends us */
623	/* one character at a time. The sci does not have a fifo. */
624
625	if ( !len ) /* no data? */
626	{
627	return -1; /* return error */
628	}
629
630	if ( minor != SCI_MINOR ) /* check the minor dev num */
631	{
632	return -1; /* return error */
633	}
634
635	if ( SciOpened == DRIVER_OPENED ) /* is the driver api open? */
636	{
637	return -1; /* yep, throw this away */
638	}
639
640	SciWriteCharNoWait(buf); / try to send a char */
641
642	SCSR &= SCI_CLEAR_TDRE; / clear tx data reg empty flag */
643
644	SciEnableTransmitInterrupts(); /* enable the tx interrupt */
645
646	return 0; /* return success */
647	}
648
649
650	/****************************************************************************
651	* Func: SciSetAttributes
652	* Desc: setup the uart based on the termios modules requests
653	* Inputs: minor - device number
654	* t - pointer to the termios info struct
655	* Outputs: none
656	* Errors: none
657	* Scope: public API
658	****************************************************************************/
659
660	int SciSetAttributes(
661	int minor,
662	const struct termios *t
663	)
664	{
665	uint32_t baud_requested;
666	uint32_t sci_rate = 0;
667	uint16_t sci_parity = 0;
668	uint16_t sci_databits = 0;
669
670	if ( minor != SCI_MINOR ) /* check the minor dev num */
671	{
672	return -1; /* return error */
673	}
674
675	/* if you look closely you will see this is the only thing we use */
676	/* set the baud rate */
677
678	baud_requested = t->c_ospeed; /* baud rate */
679
680	if (!baud_requested)
681	{
682	baud_requested = B9600; /* default to 9600 baud */
683	/* baud_requested = B19200; default to 19200 baud */
684	}
685
686	sci_rate = rtems_termios_baud_to_number( baud_requested );
687
688	/* parity error detection */
689
690	if (t->c_cflag & PARENB) /* enable parity detection? */
691	{
692	if (t->c_cflag & PARODD)
693	{
694	sci_parity = SCI_PARITY_ODD; /* select odd parity */
695	}
696	else
697	{
698	sci_parity = SCI_PARITY_EVEN; /* select even parity */
699	}
700	}
701	else
702	{
703	sci_parity = SCI_PARITY_NONE; /* no parity, most common */
704	}
705
706	/* set the number of data bits, 8 is most common */
707
708	if (t->c_cflag & CSIZE) /* was it specified? */
709	{
710	switch (t->c_cflag & CSIZE)
711	{
712	case CS8: sci_databits = SCI_8_DATA_BITS; break;
713	default : sci_databits = SCI_9_DATA_BITS; break;
714	}
715	}
716	else
717	{
718	sci_databits = SCI_8_DATA_BITS; /* default to 8 data bits */
719	}
720
721	/* the number of stop bits; always 1 for SCI */
722
723	if (t->c_cflag & CSTOPB)
724	{
725	/* do nothing */
726	}
727
728	/* setup the hardware with these serial port parameters */
729
730	SciSetBaud(sci_rate); /* set the baud rate */
731	SciSetParity(sci_parity); /* set the parity type */
732	SciSetDataBits(sci_databits); /* set the data bits */
733
734	return RTEMS_SUCCESSFUL;
735	}
736
737
738	/*
739	*
740	* SECTION 3
741	* POLLING BASED ENTRY POINTS FOR THE TERMIOS MODULE
742	*/
743
744	/****************************************************************************
745	* Func: SciPolledOpen
746	* Desc: open routine for the polled i/o version of the driver
747	* called from rtems_termios_open which is called from console_open
748	* Inputs: major - device number
749	* minor - device number
750	* args - points to terminal info struct
751	* Outputs: success/fail
752	* Errors: none
753	* Scope: public - termios entry point
754	****************************************************************************/
755
756	int SciPolledOpen(
757	int major,
758	int minor,
759	void *arg
760	)
761	{
762	rtems_libio_open_close_args_t * args = arg;
763
764	if ( minor != SCI_MINOR ) /* check minor device num */
765	{
766	return -1;
767	}
768
769	if ( !args ) /* must have args */
770	{
771	return -1;
772	}
773
774	SciTermioTty = args->iop->data1; /* Store tty pointer */
775
776	SciDisableAllInterrupts(); /* don't generate interrupts */
777
778	/* THIS IS ACTUALLY A BAD THING - SETTING LINE PARAMETERS HERE */
779	/* IT SHOULD BE DONE THROUGH TCSETATTR() WHEN THE CONSOLE IS OPENED!!! */
780
781	/* SciSetBaud(115200); set the baud rate */
782	/* SciSetBaud( 57600); set the baud rate */
783	/* SciSetBaud( 38400); set the baud rate */
784	/* SciSetBaud( 19200); * set the baud rate */
785	SciSetBaud( 9600); /* set the baud rate */
786
787	SciSetParity(SCI_PARITY_NONE); /* set no parity */
788
789	SciSetDataBits(SCI_8_DATA_BITS); /* set 8 data bits */
790
791	SciEnableTransmitter(); /* enable the xmitter */
792
793	SciEnableReceiver(); /* enable the rcvr */
794
795	return RTEMS_SUCCESSFUL;
796	}
797
798
799	/****************************************************************************
800	* Func: SciPolledClose
801	* Desc: close routine for the device driver, same for both
802	* Inputs: major - device number
803	* minor - device number
804	* args - unused
805	* Outputs: success/fail
806	* Errors: none
807	* Scope: public termios API
808	****************************************************************************/
809
810	int SciPolledClose(
811	int major,
812	int minor,
813	void *arg
814	)
815	{
816	SciDisableAllInterrupts();
817
818	return RTEMS_SUCCESSFUL;
819	}
820
821
822	/****************************************************************************
823	* Func: SciPolledRead
824	* Desc: polling based read routine for the uart
825	* Inputs: minor - device number
826	* Outputs: error or the character read
827	* Errors: none
828	* Scope: public API
829	****************************************************************************/
830
831	int SciPolledRead(
832	int minor
833	)
834	{
835	if ( minor != SCI_MINOR ) /* check the type-punned dev num */
836	{
837	return -1; /* return error */
838	}
839
840	if ( SciCharAvailable() ) /* if a char is available */
841	{
842	return SciReadCharNoWait(); /* read the rx data register */
843	}
844
845	return -1; /* return error */
846	}
847
848
849	/****************************************************************************
850	* Func: SciPolledWrite
851	* Desc: writes out characters in polled mode, waiting for the uart
852	* check in console_open, but we only seem to use interrupt mode
853	* Inputs: minor - device number
854	* buf - points to the data
855	* len - how many bytes
856	* Outputs: error or number of bytes written
857	* Errors: none
858	* Scope: public termios API
859	****************************************************************************/
860
861	ssize_t SciPolledWrite(
862	int minor,
863	const char *buf,
864	size_t len
865	)
866	{
867	ssize_t written = 0;
868
869	if ( minor != SCI_MINOR ) /* check minor device num */
870	{
871	return -1;
872	}
873
874	if ( SciOpened == DRIVER_OPENED ) /* is the driver api open? */
875	{
876	return -1; /* toss the data */
877	}
878
879	/* send each byte in the string out the port */
880
881	while ( written < len )
882	{
883	SciWriteCharWait(buf++); / send a byte */
884
885	written++; /* increment counter */
886	}
887
888	return written; /* return count */
889	}
890
891
892	/*
893	*
894	* SECTION 4
895	* DEVICE DRIVER PUBLIC API ENTRY POINTS
896	*/
897
898	/****************************************************************************
899	* Func: SciInit
900	* Desc: Initialize the lasers device driver and hardware
901	* Inputs: major - the major device number which is assigned by rtems
902	* minor - the minor device number which is undefined at this point
903	* arg - ?????
904	* Outputs: RTEMS_SUCCESSFUL
905	* Errors: None.
906	* Scope: public API
907	****************************************************************************/
908
909	rtems_device_driver SciInitialize (
910	rtems_device_major_number major,
911	rtems_device_minor_number minor,
912	void * arg
913	)
914	{
915	/* rtems_status_code status; */
916
917	/printk("%s\r\n", __FUNCTION__); /
918
919	/* register the SCI device name for termios console i/o
920	* this is done over in console.c which doesn't seem exactly right
921	* but there were problems doing it here...
922	*/
923
924	/* status = rtems_io_register_name( "/dev/sci", major, 0 ); */
925
926	/* if (status != RTEMS_SUCCESSFUL) */
927	/* rtems_fatal_error_occurred(status); */
928
929	SciMajor = major; /* save the rtems major number */
930
931	SciOpened = DRIVER_CLOSED; /* initial state is closed */
932
933	/* if you have an interrupt handler, install it here */
934
935	SciInited = 1; /* set the inited flag */
936
937	return RTEMS_SUCCESSFUL;
938	}
939
940
941	/****************************************************************************
942	* Func: SciOpen
943	* Desc: device driver open routine
944	* you must open a device before you can anything else
945	* only one process can have the device opened at a time
946	* you could look at the task id to restrict access if you want
947	* Inputs: major - the major device number assigned by rtems
948	* minor - the minor device number assigned by us
949	* arg - ?????
950	* Outputs: see below
951	* Errors: none
952	* Scope: public API
953	****************************************************************************/
954
955	rtems_device_driver SciOpen (
956	rtems_device_major_number major,
957	rtems_device_minor_number minor,
958	void * arg
959	)
960	{
961	/printk("%s major=%d minor=%d\r\n", __FUNCTION__,major,minor); /
962
963	if (SciInited == 0) /* must be initialized first! */
964	{
965	return RTEMS_NOT_CONFIGURED;
966	}
967
968	if (minor != SCI_MINOR)
969	{
970	return RTEMS_INVALID_NAME; /* verify minor number */
971	}
972
973	if (SciOpened == DRIVER_OPENED)
974	{
975	return RTEMS_RESOURCE_IN_USE; /* already opened! */
976	}
977
978	SciOpened = DRIVER_OPENED; /* set the opened flag */
979
980	return RTEMS_SUCCESSFUL;
981	}
982
983
984	/****************************************************************************
985	* Func: SciClose
986	* Desc: device driver close routine
987	* the device must be opened before you can close it
988	* the device must be closed before someone (else) can open it
989	* Inputs: major - the major device number
990	* minor - the minor device number
991	* arg - ?????
992	* Outputs: see below
993	* Errors: none
994	* Scope: public API
995	****************************************************************************/
996
997	rtems_device_driver SciClose (
998	rtems_device_major_number major,
999	rtems_device_minor_number minor,
1000	void * arg
1001	)
1002	{
1003	/printk("%s major=%d minor=%d\r\n", __FUNCTION__,major,minor); /
1004
1005	if (minor != SCI_MINOR)
1006	{
1007	return RTEMS_INVALID_NAME; /* check the minor number */
1008	}
1009
1010	if (SciOpened != DRIVER_OPENED)
1011	{
1012	return RTEMS_INCORRECT_STATE; /* must be opened first */
1013	}
1014
1015	SciOpened = DRIVER_CLOSED; /* set the flag */
1016
1017	return RTEMS_SUCCESSFUL;
1018	}
1019
1020
1021	/****************************************************************************
1022	* Func: SciRead
1023	* Desc: device driver read routine
1024	* this function is not meaningful for the laser devices
1025	* Inputs: major - the major device number
1026	* minor - the minor device number
1027	* arg - read/write arguments
1028	* Outputs: see below
1029	* Errors: none
1030	* Scope: public API
1031	****************************************************************************/
1032
1033	rtems_device_driver SciRead (
1034	rtems_device_major_number major,
1035	rtems_device_minor_number minor,
1036	void *arg
1037	)
1038	{
1039	rtems_libio_rw_args_t rw_args; / ptr to argument struct */
1040	char *buffer;
1041
1042	rw_args = (rtems_libio_rw_args_t ) arg; / arguments to read() */
1043
1044	if (minor != SCI_MINOR)
1045	{
1046	return RTEMS_INVALID_NAME; /* check the minor number */
1047	}
1048
1049	if (SciOpened == DRIVER_CLOSED)
1050	{
1051	return RTEMS_INCORRECT_STATE; /* must be opened first */
1052	}
1053
1054	buffer = rw_args->buffer; /* points to user's buffer */
1055
1056	/* buffer = SciReadCharWait(); wait for a character /
1057
1058	/* if there isn't a character available, wait until one shows up */
1059	/* or the timeout period expires, which ever happens first */
1060
1061	if ( SciRcvBufCount == 0 ) /* no chars */
1062	{
1063	/* wait for someone to wake me up... */
1064	/rtems_task_wake_after(SciReadTimeout); /
1065	}
1066
1067	if ( SciRcvBufCount ) /* any characters locally? */
1068	{
1069	buffer = SciRcvBufGetChar(); / get the character */
1070
1071	rw_args->bytes_moved = 1; /* how many we actually read */
1072	}
1073
1074	return RTEMS_SUCCESSFUL;
1075	}
1076
1077
1078	/****************************************************************************
1079	* Func: SciWrite
1080	* Desc: device driver write routine
1081	* this function is not meaningful for the laser devices
1082	* Inputs: major - the major device number
1083	* minor - the minor device number
1084	* arg - read/write arguments
1085	* Outputs: see below
1086	* Errors: non3
1087	* Scope: public API
1088	****************************************************************************/
1089
1090	rtems_device_driver SciWrite (
1091	rtems_device_major_number major,
1092	rtems_device_minor_number minor,
1093	void * arg
1094	)
1095	{
1096	rtems_libio_rw_args_t rw_args; / ptr to argument struct */
1097	uint8_t *buffer;
1098	size_t length;
1099
1100	rw_args = (rtems_libio_rw_args_t *) arg;
1101
1102	if (minor != SCI_MINOR)
1103	{
1104	return RTEMS_INVALID_NAME; /* check the minor number */
1105	}
1106
1107	if (SciOpened == DRIVER_CLOSED)
1108	{
1109	return RTEMS_INCORRECT_STATE; /* must be opened first */
1110	}
1111
1112	buffer = (uint8_t)rw_args->buffer; / points to data */
1113
1114	length = rw_args->count; /* how many bytes */
1115
1116	while (length--)
1117	{
1118	SciWriteCharWait(buffer++); / send the bytes out */
1119	}
1120
1121	rw_args->bytes_moved = rw_args->count; /* how many we wrote */
1122
1123	return RTEMS_SUCCESSFUL;
1124	}
1125
1126
1127	/****************************************************************************
1128	* Func: SciControl
1129	* Desc: device driver control routine
1130	* see below for an example of how to use the ioctl interface
1131	* Inputs: major - the major device number
1132	* minor - the minor device number
1133	* arg - io control args
1134	* Outputs: see below
1135	* Errors: none
1136	* Scope: public API
1137	****************************************************************************/
1138
1139	rtems_device_driver SciControl (
1140	rtems_device_major_number major,
1141	rtems_device_minor_number minor,
1142	void * arg
1143	)
1144	{
1145	rtems_libio_ioctl_args_t args = arg; / rtems arg struct */
1146	uint16_t command; /* the cmd to execute */
1147
1148	/printk("%s major=%d minor=%d\r\n", __FUNCTION__,major,minor); /
1149
1150	/* do some sanity checking */
1151
1152	if (minor != SCI_MINOR)
1153	{
1154	return RTEMS_INVALID_NAME; /* check the minor number */
1155	}
1156
1157	if (SciOpened == DRIVER_CLOSED)
1158	{
1159	return RTEMS_INCORRECT_STATE; /* must be open first */
1160	}
1161
1162	if (args == 0)
1163	{
1164	return RTEMS_INVALID_ADDRESS; /* must have args */
1165	}
1166
1167	args->ioctl_return = -1; /* assume an error */
1168
1169	command = args->command; /* get the command */
1170
1171	if (command == SCI_SEND_BREAK) /* process the command */
1172	{
1173	SciSendBreak(); /* send break char */
1174	}
1175
1176	args->ioctl_return = 0; /* return status */
1177
1178	return RTEMS_SUCCESSFUL;
1179	}
1180
1181
1182	/*
1183	*
1184	* SECTION 5
1185	* HARDWARE LEVEL ROUTINES
1186	*/
1187
1188	/****************************************************************************
1189	* Func: SciSetBaud
1190	* Desc: setup the uart based on the termios modules requests
1191	* Inputs: baud rate
1192	* Outputs: none
1193	* Errors: none
1194	* Scope: private
1195	****************************************************************************/
1196
1197	static void SciSetBaud(uint32_t rate)
1198	{
1199	uint16_t value;
1200	uint16_t save_sccr1;
1201
1202	/* when you open the console you need to set the termio struct baud rate */
1203	/* it has a default value of 9600, when someone calls tcsetattr it reverts! */
1204
1205	SciBaud = rate; /* save the rate */
1206
1207	/* calculate the register value as a float and convert to an int */
1208	/* set baud rate - you must define the system clock constant */
1209	/* see mrm332.h for an example */
1210
1211	value = ( (uint16_t) ( SYS_CLOCK / rate / 32.0 + 0.5 ) & 0x1fff );
1212
1213	save_sccr1 = SCCR1; / save register */
1214
1215	/* also turns off the xmtr and rcvr */
1216
1217	SCCR1 &= SCI_DISABLE_INT_ALL; / disable interrupts */
1218
1219	SCCR0 = value; / write the register */
1220
1221	SCCR1 = save_sccr1; / restore register */
1222
1223	return;
1224	}
1225
1226
1227	/****************************************************************************
1228	* Func: SciSetParity
1229	* Desc: setup the uart based on the termios modules requests
1230	* Inputs: parity
1231	* Outputs: none
1232	* Errors: none
1233	* Scope: private
1234	****************************************************************************/
1235
1236	static void SciSetParity(uint16_t parity)
1237	{
1238	uint16_t value;
1239
1240	value = SCCR1; / get the register */
1241
1242	if (parity == SCI_PARITY_ODD)
1243	{
1244	value \|= SCI_PARITY_ENABLE; /* parity enabled */
1245	value \|= SCI_PARITY_ODD; /* parity odd */
1246	}
1247
1248	else if (parity == SCI_PARITY_EVEN)
1249	{
1250	value \|= SCI_PARITY_ENABLE; /* parity enabled */
1251	value &= ~SCI_PARITY_ODD; /* parity even */
1252	}
1253
1254	else if (parity == SCI_PARITY_NONE)
1255	{
1256	value &= ~SCI_PARITY_ENABLE; /* disabled, most common */
1257	}
1258
1259	/* else no changes */
1260
1261	SCCR1 = value; / write the register */
1262
1263	return;
1264	}
1265
1266
1267	/****************************************************************************
1268	* Func: SciSetDataBits
1269	* Desc: setup the uart based on the termios modules requests
1270	* Inputs: data bits
1271	* Outputs: none
1272	* Errors: none
1273	* Scope: private
1274	****************************************************************************/
1275
1276	static void SciSetDataBits(uint16_t bits)
1277	{
1278	uint16_t value;
1279
1280	value = SCCR1; / get the register */
1281
1282	/* note - the parity setting affects the number of data bits */
1283
1284	if (bits == SCI_9_DATA_BITS)
1285	{
1286	value \|= SCI_9_DATA_BITS; /* 9 data bits */
1287	}
1288
1289	else if (bits == SCI_8_DATA_BITS)
1290	{
1291	value &= SCI_8_DATA_BITS; /* 8 data bits */
1292	}
1293
1294	/* else no changes */
1295
1296	SCCR1 = value; / write the register */
1297
1298	return;
1299	}
1300
1301
1302	/****************************************************************************
1303	* Func: SciDisableAllInterrupts
1304	* Func: SciEnableTransmitInterrupts
1305	* Func: SciEnableReceiveInterrupts
1306	* Desc: handles generation of interrupts by the sci module
1307	* Inputs: none
1308	* Outputs: none
1309	* Errors: none
1310	* Scope: private
1311	****************************************************************************/
1312
1313	static void inline SciDisableAllInterrupts( void )
1314	{
1315	/* this also turns off the xmtr and rcvr */
1316
1317	*SCCR1 &= SCI_DISABLE_INT_ALL;
1318	}
1319
1320	static void inline SciEnableReceiveInterrupts( void )
1321	{
1322	*SCCR1 \|= SCI_ENABLE_INT_RX;
1323	}
1324
1325	static void inline SciDisableReceiveInterrupts( void )
1326	{
1327	*SCCR1 &= SCI_DISABLE_INT_RX;
1328	}
1329
1330	static void inline SciEnableTransmitInterrupts( void )
1331	{
1332	*SCCR1 \|= SCI_ENABLE_INT_TX;
1333	}
1334
1335	static void inline SciDisableTransmitInterrupts( void )
1336	{
1337	*SCCR1 &= SCI_DISABLE_INT_TX;
1338	}
1339
1340
1341	/****************************************************************************
1342	* Func: SciEnableTransmitter, SciDisableTransmitter
1343	* Func: SciEnableReceiver, SciDisableReceiver
1344	* Desc: turns the transmitter and receiver on and off
1345	* Inputs: none
1346	* Outputs: none
1347	* Errors: none
1348	* Scope: private
1349	****************************************************************************/
1350
1351	static void inline SciEnableTransmitter( void )
1352	{
1353	*SCCR1 \|= SCI_ENABLE_XMTR;
1354	}
1355
1356	static void inline SciDisableTransmitter( void )
1357	{
1358	*SCCR1 &= SCI_DISABLE_XMTR;
1359	}
1360
1361	static void inline SciEnableReceiver( void )
1362	{
1363	*SCCR1 \|= SCI_ENABLE_RCVR;
1364	}
1365
1366	static void inline SciDisableReceiver( void )
1367	{
1368	*SCCR1 &= SCI_DISABLE_RCVR;
1369	}
1370
1371
1372	/****************************************************************************
1373	* Func: SciWriteCharWait
1374	* Desc: wait for room in the fifo and then put a char in
1375	* Inputs: a byte to send
1376	* Outputs: none
1377	* Errors: none
1378	* Scope: public
1379	****************************************************************************/
1380
1381	void SciWriteCharWait(uint8_t c)
1382	{
1383	/* poll the fifo, waiting for room for another character */
1384
1385	while ( ( *SCSR & SCI_XMTR_AVAILABLE ) != SCI_XMTR_AVAILABLE )
1386	{
1387	/* Either we are writing to the fifo faster than
1388	* the uart can clock bytes out onto the cable,
1389	* or we are in flow control (actually no, we
1390	* are ignoring flow control from the other end).
1391	* In the first case, higher baud rates will help.
1392	*/
1393	/* relinquish processor while waiting */
1394	rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
1395	}
1396
1397	SCDR = c; / send the charcter */
1398
1399	SciBytesOut++; /* increment the counter */
1400
1401	return;
1402	}
1403
1404	/****************************************************************************
1405	* Func: SciWriteCharNoWait
1406	* Desc: if no room in the fifo throw the char on the floor
1407	* Inputs: a byte to send
1408	* Outputs: none
1409	* Errors: none
1410	* Scope: public
1411	****************************************************************************/
1412
1413	void SciWriteCharNoWait(uint8_t c)
1414	{
1415	if ( ( *SCSR & SCI_XMTR_AVAILABLE ) == 0 )
1416	{
1417	return; /* no room, throw it away */
1418	}
1419
1420	SCDR = c; / put the char in the fifo */
1421
1422	SciBytesOut++; /* increment the counter */
1423
1424	return;
1425	}
1426
1427
1428	/****************************************************************************
1429	* Func: SciReadCharWait
1430	* Desc: read a character, waiting for one to show up, if need be
1431	* Inputs: none
1432	* Outputs: a character
1433	* Errors: none
1434	* Scope: public
1435	****************************************************************************/
1436
1437	static uint8_t inline SciReadCharWait( void )
1438	{
1439	uint8_t ch;
1440
1441	while ( SciCharAvailable() == 0 ) /* anything there? */
1442	{
1443	/* relinquish processor while waiting */
1444	rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
1445	}
1446
1447	/* if you have rcv ints enabled, then the isr will probably */
1448	/* get the character before you will unless you turn off ints */
1449	/* ie polling and ints don't mix that well */
1450
1451	ch = SCDR; / get the charcter */
1452
1453	SciBytesIn++; /* increment the counter */
1454
1455	return ch; /* return the char */
1456	}
1457
1458	/****************************************************************************
1459	* Func: SciReadCharNoWait
1460	* Desc: try to get a char but dont wait for one
1461	* Inputs: none
1462	* Outputs: a character or -1 if none
1463	* Errors: none
1464	* Scope: public
1465	****************************************************************************/
1466
1467	static uint8_t inline SciReadCharNoWait( void )
1468	{
1469	uint8_t ch;
1470
1471	if ( SciCharAvailable() == 0 ) /* anything there? */
1472	return -1;
1473
1474	ch = SCDR; / get the character */
1475
1476	SciBytesIn++; /* increment the count */
1477
1478	return ch; /* return the char */
1479	}
1480
1481
1482	/****************************************************************************
1483	* Func: SciCharAvailable
1484	* Desc: is there a receive character in the data register
1485	* Inputs: none
1486	* Outputs: false if no char available, else true
1487	* Errors: none
1488	* Scope: public
1489	****************************************************************************/
1490
1491	uint8_t inline SciCharAvailable( void )
1492	{
1493	return ( SCSR & SCI_RCVR_READY ); / char in data register? */
1494	}
1495
1496
1497	/****************************************************************************
1498	* Func: SciSendBreak
1499	* Desc: send 1 or tow breaks (all zero bits)
1500	* Inputs: none
1501	* Outputs: none
1502	* Errors: none
1503	* Scope: public
1504	****************************************************************************/
1505
1506	void SciSendBreak( void )
1507	{
1508	/* From the Motorola QSM reference manual - */
1509
1510	/* "if SBK is toggled by writing it first to a one and then immediately */
1511	/* to a zero (in less than one serial frame interval), the transmitter */
1512	/* sends only one or two break frames before reverting to mark (idle) */
1513	/* or before commencing to send more data" */
1514
1515	SCCR1 \|= SCI_SEND_BREAK; / set the bit */
1516
1517	SCCR1 &= ~SCI_SEND_BREAK; / clear the bit */
1518
1519	return;
1520	}
1521
1522
1523	/*
1524	*
1525	* SECTION 6
1526	* TEST CODE
1527	*/
1528
1529	/****************************************************************************
1530	* Func: SciUnitTest
1531	* Desc: test the device driver
1532	* Inputs: nothing
1533	* Outputs: nothing
1534	* Scope: public
1535	****************************************************************************/
1536
1537	#if 0
1538	#define O_RDWR LIBIO_FLAGS_READ_WRITE /* dont like this but... */
1539
1540	void SciUnitTest()
1541	{
1542	uint8_t byte; /* a character */
1543	uint16_t fd; /* file descriptor for device */
1544	uint16_t result; /* result of ioctl */
1545
1546	fd = open("/dev/sci",O_RDWR); /* open the device */
1547
1548	printk("SCI open fd=%d\r\n",fd);
1549
1550	result = write(fd, "abcd\r\n", 6); /* send a string */
1551
1552	printk("SCI write result=%d\r\n",result);
1553
1554	result = read(fd, &byte, 1); /* read a byte */
1555
1556	printk("SCI read result=%d,byte=%x\r\n",result,byte);
1557
1558	return;
1559	}
1560	#endif
1561
1562
1563	/****************************************************************************
1564	* Func: SciPrintStats
1565	* Desc: print out some driver information
1566	* Inputs: nothing
1567	* Outputs: nothing
1568	* Scope: public
1569	****************************************************************************/
1570
1571	void SciPrintStats ( void )
1572	{
1573	printk("\r\n");
1574
1575	printk( "SYS_CLOCK is %2.6f Mhz\r\n\n", SYS_CLOCK / 1000000.0 );
1576
1577	printk( "Current baud rate is %d bps or %d cps\r\n\n", SciBaud, SciBaud / 10 );
1578
1579	printk( "SCI Uart chars in %8d\r\n", SciBytesIn );
1580	printk( "SCI Uart chars out %8d\r\n", SciBytesOut );
1581	printk( "SCI Uart framing errors %8d\r\n", SciErrorsFraming );
1582	printk( "SCI Uart parity errors %8d\r\n", SciErrorsParity );
1583	printk( "SCI Uart overrun errors %8d\r\n", SciErrorsOverrun );
1584	printk( "SCI Uart noise errors %8d\r\n", SciErrorsNoise );
1585
1586	return;
1587	}

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

Context Navigation

source: rtems/c/src/lib/libbsp/m68k/mrm332/console/sci.c @ 1c6926c1

Download in other formats: