uart: fix return value of send functions
[aversive.git] / modules / comm / uart / uart.c
1 /*  
2  *  Copyright Droids Corporation, Microb Technology, Eirbot (2005)
3  * 
4  *  This program is free software; you can redistribute it and/or modify
5  *  it under the terms of the GNU General Public License as published by
6  *  the Free Software Foundation; either version 2 of the License, or
7  *  (at your option) any later version.
8  *
9  *  This program is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  *  GNU General Public License for more details.
13  *
14  *  You should have received a copy of the GNU General Public License
15  *  along with this program; if not, write to the Free Software
16  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17  *
18  *  Revision : $Id: uart.c,v 1.33.4.7 2009-01-23 23:08:42 zer0 Exp $
19  *
20  */
21
22 /* Olivier MATZ, Droids-corp 2004 - 2009 */
23
24 #include <aversive.h>
25 #include <aversive/list.h>
26
27 #include <uart.h>
28 #include <uart_defs.h>
29 #include <uart_private.h>
30
31 struct cirbuf g_tx_fifo[UART_HW_NUM];
32 struct cirbuf g_rx_fifo[UART_HW_NUM];
33
34 /* global vars are initialized to 0 (NULL) */
35 event *rx_event[UART_HW_NUM];
36 event *tx_event[UART_HW_NUM];
37
38 const struct regs uart_regs[UART_HW_NUM] = {
39 #ifdef UDR0
40         {
41                 .udr = &UDR0,
42                 .ucsra = &UCSR0A,
43                 .ucsrb = &UCSR0B,
44                 .ucsrc = &UCSR0C,
45                 .ubrrl = &UBRR0L,
46                 .ubrrh = &UBRR0H,
47         },
48 #endif
49 #ifdef UDR1
50         {
51                 .udr = &UDR1,
52                 .ucsra = &UCSR1A,
53                 .ucsrb = &UCSR1B,
54                 .ucsrc = &UCSR1C,
55                 .ubrrl = &UBRR1L,
56                 .ubrrh = &UBRR1H,
57         },
58 #endif
59 #ifdef UDR2
60         {
61                 .udr = &UDR2,
62                 .ucsra = &UCSR2A,
63                 .ucsrb = &UCSR2B,
64                 .ucsrc = &UCSR2C,
65                 .ubrrl = &UBRR2L,
66                 .ubrrh = &UBRR2H,
67         },
68 #endif
69 #ifdef UDR3
70         {
71                 .udr = &UDR3,
72                 .ucsra = &UCSR3A,
73                 .ucsrb = &UCSR3B,
74                 .ucsrc = &UCSR3C,
75                 .ubrrl = &UBRR3L,
76                 .ubrrh = &UBRR3H,
77         },
78 #endif
79 };
80
81 /**
82  * This is the interruption function which occurs when the entire
83  * frame in the transmit shift register has been shifted out and 
84  * there is no new data in the transmit buffer.
85  */
86 #ifdef UART0_COMPILE
87 #ifndef SIG_UART0_DATA
88 #if defined(USART_UDRE_vect)
89 #define SIG_UART0_DATA USART_UDRE_vect
90 #elif defined(USART0_UDRE_vect)
91 #define SIG_UART0_DATA USART0_UDRE_vect
92 #elif defined(SIG_USART0_DATA)
93 #define SIG_UART0_DATA SIG_USART0_DATA
94 #endif
95 #endif
96 SIGNAL(SIG_UART0_DATA)
97 {
98         uart_send_next_char(0);
99 }
100 #endif
101 #ifdef UART1_COMPILE
102 #ifndef SIG_UART1_DATA
103 #if defined(USART1_UDRE_vect)
104 #define SIG_UART1_DATA USART1_UDRE_vect
105 #elif defined(SIG_USART1_DATA)
106 #define SIG_UART1_DATA SIG_USART1_DATA
107 #endif
108 #endif
109 SIGNAL(SIG_UART1_DATA)
110 {
111         uart_send_next_char(1);
112 }
113 #endif
114 #ifdef UART2_COMPILE
115 #ifndef SIG_UART2_DATA
116 #if defined(USART2_UDRE_vect)
117 #define SIG_UART2_DATA USART2_UDRE_vect
118 #elif defined(SIG_USART2_DATA)
119 #define SIG_UART2_DATA SIG_USART2_DATA
120 #endif
121 #endif
122 SIGNAL(SIG_UART2_DATA)
123 {
124         uart_send_next_char(2);
125 }
126 #endif
127 #ifdef UART3_COMPILE
128 #ifndef SIG_UART3_DATA
129 #if defined(USART3_UDRE_vect)
130 #define SIG_UART3_DATA USART3_UDRE_vect
131 #elif defined(SIG_USART3_DATA)
132 #define SIG_UART3_DATA SIG_USART3_DATA
133 #endif
134 #endif
135 SIGNAL(SIG_UART3_DATA)
136 {
137         uart_send_next_char(3);
138 }
139 #endif
140
141 static void uart_recv_next_char(uint8_t num);
142
143 /**
144  * This is the interruption function which occurs when there is
145  * a new unread data in the reception buffer.
146  */
147 #ifdef UART0_COMPILE
148 #ifndef SIG_UART0_RECV
149 #if defined(USART_RX_vect)
150 #define SIG_UART0_RECV USART_RX_vect
151 #elif defined(USART0_RX_vect)
152 #define SIG_UART0_RECV USART0_RX_vect
153 #elif defined(SIG_USART0_RECV)
154 #define SIG_UART0_RECV SIG_USART0_RECV
155 #endif
156 #endif
157 SIGNAL(SIG_UART0_RECV)
158 {
159         uart_recv_next_char(0);
160 }
161 #endif
162 #ifdef UART1_COMPILE
163 #ifndef SIG_UART1_RECV
164 #if defined(USART1_RX_vect)
165 #define SIG_UART1_RECV USART1_RX_vect
166 #elif defined(SIG_USART1_RECV)
167 #define SIG_UART1_RECV SIG_USART1_RECV
168 #endif
169 #endif
170 SIGNAL(SIG_UART1_RECV)
171 {
172         uart_recv_next_char(1);
173 }
174 #endif
175 #ifdef UART2_COMPILE
176 #ifndef SIG_UART2_RECV
177 #if defined(USART2_RX_vect)
178 #define SIG_UART2_RECV USART2_RX_vect
179 #elif defined(SIG_USART2_RECV)
180 #define SIG_UART2_RECV SIG_USART2_RECV
181 #endif
182 #endif
183 SIGNAL(SIG_UART2_RECV)
184 {
185         uart_recv_next_char(2);
186 }
187 #endif
188 #ifdef UART3_COMPILE
189 #ifndef SIG_UART3_RECV
190 #if defined(USART3_RX_vect)
191 #define SIG_UART3_RECV USART3_RX_vect
192 #elif defined(SIG_USART3_RECV)
193 #define SIG_UART3_RECV SIG_USART3_RECV
194 #endif
195 #endif
196 SIGNAL(SIG_UART3_RECV)
197 {
198         uart_recv_next_char(3);
199 }
200 #endif
201
202
203 /** 
204  * transmit next character of fifo if any, and call the event function.
205  * This function is executed with intr locked.
206  */
207 void uart_send_next_char(uint8_t num)
208 {
209 #ifdef CONFIG_MODULE_UART_9BITS
210         if (uart_getconf_nbits(num) == 9) {
211                 int elt = 0;
212
213                 /* for 9 bits, it uses 2 places in the fifo */
214                 if (CIRBUF_GET_LEN(&g_tx_fifo[num]) < 2) {
215                         cbi(*uart_regs[num].ucsrb, UDRIE);
216                         return;
217                 }
218
219                 cirbuf_get_buf_tail(&g_tx_fifo[num], (char *)&elt, 2);
220                 cirbuf_del_buf_tail(&g_tx_fifo[num], 2);
221
222                 uart_set_udr_9bits(num, elt);
223                 sbi(*uart_regs[num].ucsrb, UDRIE);
224         }
225         else /* 5, 6, 7 or 8 bits */
226 #endif /* CONFIG_MODULE_UART_9BITS */
227         { 
228                 char elt = 0;
229
230                 if (CIRBUF_IS_EMPTY(&g_tx_fifo[num])) {
231                         cbi(*uart_regs[num].ucsrb, UDRIE);
232                         return;
233                 }
234
235                 elt = cirbuf_get_tail(&g_tx_fifo[num]);
236                 cirbuf_del_tail(&g_tx_fifo[num]);
237                 uart_set_udr(num, elt);
238                 sbi(*uart_regs[num].ucsrb, UDRIE);
239         }
240 }
241
242 /**
243  * UART RX Interrupt
244  */
245 static void uart_recv_next_char(uint8_t num)
246 {
247 #ifdef CONFIG_MODULE_UART_9BITS
248         if (uart_getconf_nbits() == 9) {
249                 int elt = 0;
250
251                 elt = uart_get_udr_9bits(num);
252                 if (CIRBUF_GET_FREELEN(&g_rx_fifo[num]) >= 2) {
253                         cirbuf_add_buf_head(&g_rx_fifo[num], (char *)&elt, 2);
254                 }
255
256                 if (rx_event[num])
257                         ((event_9bits *)rx_event[num])(elt);
258         }
259         else 
260 #endif /* CONFIG_MODULE_UART_9BITS */
261         {
262                 char elt = 0;
263
264                 elt = uart_get_udr(num);
265                 if (!CIRBUF_IS_FULL(&g_rx_fifo[num])) {
266                         cirbuf_add_head(&g_rx_fifo[num], elt);
267                 }
268
269                 if (rx_event[num])
270                         rx_event[num](elt);
271         }
272 }
273
274 /* init all uarts */
275 void uart_init(void)
276 {
277 #if (defined UDR0) && (defined UART0_COMPILE)
278         uart_setconf(0, NULL);
279 #endif
280
281 #if (defined UDR1) && (defined UART1_COMPILE)
282         uart_setconf(1, NULL);
283 #endif
284
285 #if (defined UDR2) && (defined UART2_COMPILE)
286         uart_setconf(2, NULL);
287 #endif
288
289 #if (defined UDR3) && (defined UART3_COMPILE)
290         uart_setconf(3, NULL);
291 #endif
292 }