Add dual-license information.
[bertos.git] / drv / ser.c
1 /*!
2  * \file
3  * <!--
4  * Copyright 2003,2004 Develer S.r.l. (http://www.develer.com/)
5  * Copyright 2000 Bernardo Innocenti <bernie@codewiz.org>
6  * This file is part of DevLib - See devlib/README for information.
7  * -->
8  *
9  * \brief Buffered serial I/O driver
10  *
11  * The serial rx interrupt buffers incoming data in a software FIFO
12  * to decouple the higher level protocols from the line speed.
13  * Outgoing data is buffered as well for better performance.
14  * This driver is not optimized for best performance, but it
15  * has proved to be fast enough to handle transfer rates up to
16  * 38400bps on a 16MHz 80196.
17  *
18  * MODULE CONFIGURATION
19  *      \li \c CONFIG_SER_HWHANDSHAKE define this preprocessor symbol to enable
20  *      support for RTS/CTS handshake. Support is incomplete/untested
21  *      for 80196.
22  *  \li \c CONFIG_SER_TXTIMEOUT - Enable software serial transmission timeouts
23  *
24  *
25  * \version $Id$
26  * \author Bernardo Innocenti <bernie@develer.com>
27  */
28
29 /*
30  * $Log$
31  * Revision 1.4  2004/06/03 11:27:09  bernie
32  * Add dual-license information.
33  *
34  * Revision 1.3  2004/06/02 21:35:24  aleph
35  * Serial enhancements: interruptible receive handler and 8 bit serial status for AVR; remove volatile attribute to FIFOBuffer, useless for new fifobuf routens
36  *
37  * Revision 1.2  2004/05/23 18:21:53  bernie
38  * Trim CVS logs and cleanup header info.
39  *
40  */
41
42 #include <mware/formatwr.h>
43 #include <drv/kdebug.h>
44 #include "ser.h"
45 #include "ser_p.h"
46 #include "hw.h"
47
48 #ifdef CONFIG_KERNEL
49         #include <kern/proc.h>
50 #endif
51 #if defined(CONFIG_SER_TXTIMEOUT) || defined(CONFIG_SER_RXTIMEOUT)
52         #include <drv/timer.h>
53 #endif
54
55
56 /* Serial configuration parameters */
57 #define SER_CTSDELAY        70  /*!< CTS line retry interval (ms) */
58 #define SER_TXPOLLDELAY      2  /*!< Transmit buffer full retry interval (ms) */
59 #define SER_RXPOLLDELAY      2  /*!< Receive buffer empty retry interval (ms) */
60
61
62 struct Serial ser_handles[SER_CNT];
63
64
65 /*!
66  * Inserisce il carattere c nel buffer di trasmissione.
67  * Questa funzione mette il processo chiamante in attesa
68  * quando il buffer e' pieno.
69  *
70  * \return EOF in caso di errore o timeout, altrimenti
71  *         il carattere inviato.
72  */
73 int ser_putchar(int c, struct Serial *port)
74 {
75         if (fifo_isfull_locked(&port->txfifo))
76         {
77 #ifdef CONFIG_SER_TXTIMEOUT
78                 time_t start_time = timer_gettick();
79 #endif
80
81                 /* Attende finche' il buffer e' pieno... */
82                 do
83                 {
84 #ifdef CONFIG_KERN_SCHED
85                         /* Give up timeslice to other processes. */
86                         proc_switch();
87 #endif
88 #ifdef CONFIG_SER_TXTIMEOUT
89                         if (timer_gettick() - start_time >= port->txtimeout)
90                         {
91                                 port->status |= SERRF_TXTIMEOUT;
92                                 return EOF;
93                         }
94 #endif /* CONFIG_SER_TXTIMEOUT */
95                 }
96                 while (fifo_isfull_locked(&port->txfifo));
97         }
98
99         fifo_push(&port->txfifo, (unsigned char)c);
100
101         /* (re)trigger tx interrupt */
102         port->hw->table->enabletxirq(port->hw);
103
104         /* Avoid returning signed estended char */
105         return (int)((unsigned char)c);
106 }
107
108
109 /*!
110  * Preleva un carattere dal buffer di ricezione.
111  * Questa funzione mette il processo chiamante in attesa
112  * quando il buffer e' vuoto. L'attesa ha un timeout
113  * di ser_rxtimeout millisecondi.
114  *
115  * \return EOF in caso di errore o timeout, altrimenti
116  *         il carattere ricevuto.
117  */
118 int ser_getchar(struct Serial *port)
119 {
120         int result;
121
122         if (fifo_isempty_locked(&port->rxfifo))
123         {
124 #ifdef CONFIG_SER_RXTIMEOUT
125                 time_t start_time = timer_gettick();
126 #endif
127                 /* Wait while buffer is empty */
128                 do
129                 {
130 #ifdef CONFIG_KERN_SCHED
131                         /* Give up timeslice to other processes. */
132                         proc_switch();
133 #endif
134 #ifdef CONFIG_SER_RXTIMEOUT
135                         if (timer_gettick() - start_time >= port->rxtimeout)
136                         {
137                                 port->status |= SERRF_RXTIMEOUT;
138                                 return EOF;
139                         }
140 #endif /* CONFIG_SER_RXTIMEOUT */
141                 }
142                 while (fifo_isempty_locked(&port->rxfifo));
143         }
144
145         /*
146          * Get a byte from the FIFO (avoiding sign-extension),
147          * re-enable RTS, then return result.
148          */
149         result = (int)(unsigned char)fifo_pop(&port->rxfifo);
150         return port->status ? EOF : result;
151 }
152
153
154 /*!
155  * Preleva un carattere dal buffer di ricezione.
156  * Se il buffer e' vuoto, ser_getchar_nowait() ritorna
157  * immediatamente EOF.
158  */
159 int ser_getchar_nowait(struct Serial *port)
160 {
161         if (fifo_isempty_locked(&port->rxfifo))
162                 return EOF;
163
164         /* NOTE: the double cast prevents unwanted sign extension */
165         return (int)(unsigned char)fifo_pop(&port->rxfifo);
166 }
167
168
169 /*!
170  * Read a line long at most as size and puts it
171  * in buf.
172  * \return number of chars read or EOF in case
173  *         of error.
174  */
175 int ser_gets(struct Serial *port, char *buf, int size)
176 {
177         return ser_gets_echo(port, buf, size, false);
178 }
179
180
181 /*!
182  * Read a line long at most as size and puts it
183  * in buf, with optional echo.
184  * \return number of chars read or EOF in case
185  *         of error.
186  */
187 int ser_gets_echo(struct Serial *port, char *buf, int size, bool echo)
188 {
189         int i = 0;
190         int c;
191
192         for (;;)
193         {
194                 if ((c = ser_getchar(port)) == EOF)
195                         return -1;
196                 /* FIXME */
197                 if (c == '\r' || c == '\n' || i >= size-1)
198                 {
199                         buf[i] = '\0';
200                         if (echo)
201                                 ser_print(port, "\r\n");
202                         break;
203                 }
204                 buf[i++] = c;
205                 if (echo)
206                         ser_putchar(c, port);
207         }
208
209         return i;
210 }
211
212
213 /*!
214  * Read at most size bytes and puts them
215  * in buf.
216  * \return number of bytes read or EOF in case
217  *         of error.
218  */
219 int ser_read(struct Serial *port, char *buf, size_t size)
220 {
221         size_t i = 0;
222         int c;
223
224         while (i < size)
225         {
226                 if ((c = ser_getchar(port)) == EOF)
227                         return EOF;
228                 buf[i++] = c;
229         }
230
231         return i;
232 }
233
234
235 /*!
236  * Write a string to serial.
237  * \return 0 if OK, EOF in case of error.
238  */
239 int ser_print(struct Serial *port, const char *s)
240 {
241         while (*s)
242         {
243                 if (ser_putchar(*s++, port) == EOF)
244                         return EOF;
245         }
246         return 0;
247 }
248
249
250 /*!
251  * \brief Write a buffer to serial.
252  *
253  * \return 0 if OK, EOF in case of error.
254  */
255 int ser_write(struct Serial *port, const void *buf, size_t len)
256 {
257         while (len--)
258         {
259                 if (ser_putchar(*((const char *)buf)++, port) == EOF)
260                         return EOF;
261         }
262         return 0;
263 }
264
265
266 /*!
267  * Formatted write
268  */
269 int ser_printf(struct Serial *port, const char *format, ...)
270 {
271         va_list ap;
272         int len;
273
274         ser_setstatus(port, 0);
275         va_start(ap, format);
276         len = _formatted_write(format, (void (*)(char, void *))ser_putchar, port, ap);
277         va_end(ap);
278
279         return len;
280 }
281
282 #if defined(CONFIG_SER_RXTIMEOUT) || defined(CONFIG_SER_TXTIMEOUT)
283 void ser_settimeouts(struct Serial *port, time_t rxtimeout, time_t txtimeout)
284 {
285         port->rxtimeout = rxtimeout;
286         port->txtimeout = txtimeout;
287 }
288 #endif /* defined(CONFIG_SER_RXTIMEOUT) || defined(CONFIG_SER_TXTIMEOUT) */
289
290
291 void ser_setbaudrate(struct Serial *port, unsigned long rate)
292 {
293         port->hw->table->setbaudrate(port->hw, rate);
294 }
295
296
297 void ser_setparity(struct Serial *port, int parity)
298 {
299         port->hw->table->setparity(port->hw, parity);
300 }
301
302
303 /*!
304  * Flush both the RX and TX buffers.
305  */
306 void ser_purge(struct Serial *ser)
307 {
308         fifo_flush(&ser->rxfifo);
309         fifo_flush(&ser->txfifo);
310 }
311
312
313 /*!
314  * Initialize serial
315  */
316 struct Serial *ser_open(unsigned int unit)
317 {
318         struct Serial *port;
319
320         ASSERT(unit < countof(ser_handles));
321
322         port = &ser_handles[unit];
323
324         ASSERT(!port->is_open);
325
326         port->unit = unit;
327         port->is_open = true;
328
329         /* Initialize circular buffer */
330         fifo_init(&port->rxfifo, port->rxbuffer, sizeof(port->rxbuffer));
331         fifo_init(&port->txfifo, port->txbuffer, sizeof(port->txbuffer));
332
333         port->hw = ser_hw_getdesc(unit);
334         port->hw->table->init(port->hw, port);
335
336         /* Set default values */
337 #if defined(CONFIG_SER_RXTIMEOUT) || defined(CONFIG_SER_TXTIMEOUT)
338         ser_settimeouts(port, CONFIG_SER_RXTIMEOUT, CONFIG_SER_TXTIMEOUT);
339 #endif
340         ser_setbaudrate(port, CONFIG_SER_DEFBAUDRATE);
341
342         return port;
343 }
344
345
346 /*!
347  * Clean up serial port, disabling the associated hardware.
348  */
349 void ser_close(struct Serial *port)
350 {
351         ASSERT(port->is_open);
352
353         port->is_open = false;
354         port->hw->table->cleanup(port->hw);
355         port->hw = NULL;
356 }