|
2059
|
1 //========================================================================== |
|
|
2 // |
|
|
3 // loop_can.c |
|
|
4 // |
|
|
5 // Loopback CAN device driver |
|
|
6 // |
|
|
7 //========================================================================== |
|
|
8 //####ECOSGPLCOPYRIGHTBEGIN#### |
|
|
9 // ------------------------------------------- |
|
|
10 // This file is part of eCos, the Embedded Configurable Operating System. |
|
|
11 // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
|
|
12 // |
|
|
13 // eCos is free software; you can redistribute it and/or modify it under |
|
|
14 // the terms of the GNU General Public License as published by the Free |
|
|
15 // Software Foundation; either version 2 or (at your option) any later version. |
|
|
16 // |
|
|
17 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
|
|
18 // WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
|
19 // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
|
20 // for more details. |
|
|
21 // |
|
|
22 // You should have received a copy of the GNU General Public License along |
|
|
23 // with eCos; if not, write to the Free Software Foundation, Inc., |
|
|
24 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
|
|
25 // |
|
|
26 // As a special exception, if other files instantiate templates or use macros |
|
|
27 // or inline functions from this file, or you compile this file and link it |
|
|
28 // with other works to produce a work based on this file, this file does not |
|
|
29 // by itself cause the resulting work to be covered by the GNU General Public |
|
|
30 // License. However the source code for this file must still be made available |
|
|
31 // in accordance with section (3) of the GNU General Public License. |
|
|
32 // |
|
|
33 // This exception does not invalidate any other reasons why a work based on |
|
|
34 // this file might be covered by the GNU General Public License. |
|
|
35 // |
|
|
36 // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
|
|
37 // at http://sources.redhat.com/ecos/ecos-license/ |
|
|
38 // ------------------------------------------- |
|
|
39 //####ECOSGPLCOPYRIGHTEND#### |
|
|
40 //========================================================================== |
|
|
41 //#####DESCRIPTIONBEGIN#### |
|
|
42 // |
|
|
43 // Author(s): Uwe Kindler |
|
|
44 // Contributors: Uwe Kindler |
|
|
45 // Date: 2005-07-10 |
|
|
46 // Purpose: Loopback CAN device driver |
|
|
47 // Description: This device driver implements a pair of CAN lines that are |
|
|
48 // connected back-to-back. Data output to one will appear as |
|
|
49 // input on the other. This process in part driven by an alarm |
|
|
50 // object which provides a degree of separation between the two |
|
|
51 // channels. |
|
|
52 // |
|
|
53 //####DESCRIPTIONEND#### |
|
|
54 // |
|
|
55 //========================================================================== |
|
|
56 |
|
|
57 #include <pkgconf/hal.h> |
|
|
58 #include <pkgconf/io_can.h> |
|
|
59 #include <pkgconf/io_can_loop.h> |
|
|
60 #include <cyg/hal/hal_io.h> |
|
|
61 |
|
|
62 #include <cyg/io/io.h> |
|
|
63 #include <cyg/io/devtab.h> |
|
|
64 #include <cyg/io/can.h> |
|
|
65 #include <cyg/hal/hal_intr.h> |
|
|
66 #include <cyg/kernel/kapi.h> |
|
|
67 |
|
|
68 #ifdef CYGPKG_IO_CAN_LOOP |
|
|
69 |
|
|
70 //------------------------------------------------------------------------- |
|
|
71 |
|
|
72 extern void diag_printf(const char *fmt, ...); |
|
|
73 |
|
|
74 //------------------------------------------------------------------------- |
|
|
75 // Forward definitions |
|
|
76 |
|
|
77 static bool loop_can_init(struct cyg_devtab_entry *devtab_entry); |
|
|
78 static bool loop_can_putmsg(can_channel *priv, cyg_can_message *pmsg, void *pdata); |
|
|
79 static Cyg_ErrNo loop_can_lookup(struct cyg_devtab_entry **tab, |
|
|
80 struct cyg_devtab_entry *sub_tab, |
|
|
81 const char *name); |
|
|
82 static bool loop_can_getevent(can_channel *priv, cyg_can_event *pevent, void *pdata); |
|
|
83 static Cyg_ErrNo loop_can_set_config(can_channel *chan, cyg_uint32 key, |
|
|
84 const void *xbuf, cyg_uint32 *len); |
|
2377
|
85 static Cyg_ErrNo loop_can_get_config(can_channel *chan, cyg_uint32 key, |
|
|
86 const void* buf, cyg_uint32* len); |
|
2059
|
87 static void loop_can_start_xmit(can_channel *chan); |
|
|
88 static void loop_can_stop_xmit(can_channel *chan); |
|
|
89 |
|
|
90 static void alarm_handler(cyg_handle_t alarm, cyg_addrword_t data); |
|
|
91 |
|
|
92 |
|
|
93 //------------------------------------------------------------------------- |
|
|
94 // Alarm object for feeding data back into CAN channels |
|
|
95 |
|
|
96 static cyg_alarm alarm_obj; |
|
|
97 |
|
|
98 static cyg_handle_t alarm_handle; |
|
|
99 |
|
|
100 //------------------------------------------------------------------------- |
|
|
101 // Transfer FIFOs |
|
|
102 |
|
|
103 #define FIFO_SIZE 16 |
|
|
104 |
|
|
105 struct fifo |
|
|
106 { |
|
|
107 cyg_bool tx_enable; |
|
|
108 volatile int head; |
|
|
109 volatile int tail; |
|
|
110 volatile int num; |
|
|
111 volatile cyg_can_event buf[FIFO_SIZE+1]; |
|
|
112 }; |
|
|
113 |
|
|
114 static struct fifo fifo0 = { false, 0, 0, 0 }; // from CAN0 to CAN1 |
|
|
115 static struct fifo fifo1 = { false, 0, 0, 0 }; // from CAN1 to CAN0 |
|
|
116 |
|
|
117 //------------------------------------------------------------------------- |
|
|
118 |
|
|
119 #define BUFSIZE 128 |
|
|
120 |
|
|
121 //------------------------------------------------------------------------- |
|
|
122 // Info for each serial device controlled |
|
|
123 |
|
|
124 typedef struct loop_can_info { |
|
|
125 struct fifo *write_fifo; |
|
|
126 struct fifo *read_fifo; |
|
|
127 } loop_can_info; |
|
|
128 |
|
|
129 //------------------------------------------------------------------------- |
|
|
130 // Callback functions exported by this driver |
|
|
131 CAN_LOWLEVEL_FUNS(loop_can_lowlevel_funs, |
|
|
132 loop_can_putmsg, |
|
|
133 loop_can_getevent, |
|
2377
|
134 loop_can_get_config, |
|
2059
|
135 loop_can_set_config, |
|
|
136 loop_can_start_xmit, |
|
|
137 loop_can_stop_xmit |
|
|
138 ); |
|
|
139 |
|
|
140 //------------------------------------------------------------------------- |
|
|
141 // Hardware info for each serial line |
|
|
142 |
|
|
143 #ifdef CYGPKG_IO_CAN_LOOP_CAN0 |
|
|
144 static loop_can_info loop_can_info0 = { |
|
|
145 &fifo0, |
|
|
146 &fifo1 |
|
|
147 }; |
|
|
148 |
|
|
149 static cyg_can_message loop_can_txbuf0[CYGNUM_DEVS_CAN_LOOP_CAN0_QUEUESIZE_TX]; |
|
|
150 static cyg_can_event loop_can_rxbuf0[CYGNUM_DEVS_CAN_LOOP_CAN0_QUEUESIZE_RX]; |
|
|
151 #endif // CYGPKG_IO_SERIAL_LOOP_SERIAL0 |
|
|
152 |
|
|
153 #ifdef CYGPKG_IO_CAN_LOOP_CAN1 |
|
|
154 static loop_can_info loop_can_info1 = { |
|
|
155 &fifo1, |
|
|
156 &fifo0 |
|
|
157 }; |
|
|
158 |
|
|
159 static cyg_can_message loop_can_txbuf1[CYGNUM_DEVS_CAN_LOOP_CAN1_QUEUESIZE_TX]; |
|
|
160 static cyg_can_event loop_can_rxbuf1[CYGNUM_DEVS_CAN_LOOP_CAN1_QUEUESIZE_RX]; |
|
|
161 #endif // CYGPKG_IO_SERIAL_LOOP_SERIAL1 |
|
|
162 |
|
|
163 |
|
|
164 |
|
|
165 //------------------------------------------------------------------------- |
|
|
166 // Channel descriptions: |
|
|
167 // |
|
|
168 #ifdef CYGPKG_IO_CAN_LOOP_CAN0 |
|
|
169 CAN_CHANNEL_USING_INTERRUPTS(loop_can0_chan, |
|
|
170 loop_can_lowlevel_funs, |
|
|
171 loop_can_info0, |
|
|
172 CYG_CAN_BAUD_RATE(CYGNUM_DEVS_CAN_LOOP_CAN0_KBAUD), |
|
|
173 loop_can_txbuf0, CYGNUM_DEVS_CAN_LOOP_CAN0_QUEUESIZE_TX, |
|
|
174 loop_can_rxbuf0, CYGNUM_DEVS_CAN_LOOP_CAN0_QUEUESIZE_RX |
|
|
175 ); |
|
|
176 #endif // CYGPKG_IO_CAN_LOOP_CAN1 |
|
|
177 |
|
|
178 #ifdef CYGPKG_IO_CAN_LOOP_CAN1 |
|
|
179 CAN_CHANNEL_USING_INTERRUPTS(loop_can1_chan, |
|
|
180 loop_can_lowlevel_funs, |
|
|
181 loop_can_info1, |
|
|
182 CYG_CAN_BAUD_RATE(CYGNUM_DEVS_CAN_LOOP_CAN1_KBAUD), |
|
|
183 loop_can_txbuf1, CYGNUM_DEVS_CAN_LOOP_CAN1_QUEUESIZE_TX, |
|
|
184 loop_can_rxbuf1, CYGNUM_DEVS_CAN_LOOP_CAN1_QUEUESIZE_RX |
|
|
185 ); |
|
|
186 #endif // CYGPKG_IO_CAN_LOOP_CAN1 |
|
|
187 |
|
|
188 |
|
|
189 |
|
|
190 //------------------------------------------------------------------------- |
|
|
191 // And finally, the device table entries: |
|
|
192 // |
|
|
193 #ifdef CYGPKG_IO_CAN_LOOP_CAN0 |
|
|
194 DEVTAB_ENTRY(loop_can_io0, |
|
|
195 CYGDAT_DEVS_CAN_LOOP_CAN0_NAME, |
|
|
196 0, // Does not depend on a lower level interface |
|
|
197 &cyg_io_can_devio, |
|
|
198 loop_can_init, |
|
|
199 loop_can_lookup, // CAN driver may need initializing |
|
|
200 &loop_can0_chan |
|
|
201 ); |
|
|
202 #endif // CYGPKG_IO_CAN_LOOP_CAN0 |
|
|
203 |
|
|
204 #ifdef CYGPKG_IO_CAN_LOOP_CAN1 |
|
|
205 DEVTAB_ENTRY(loop_can_io1, |
|
|
206 CYGDAT_DEVS_CAN_LOOP_CAN1_NAME, |
|
|
207 0, // Does not depend on a lower level interface |
|
|
208 &cyg_io_can_devio, |
|
|
209 loop_can_init, |
|
|
210 loop_can_lookup, // CAN driver may need initializing |
|
|
211 &loop_can1_chan |
|
|
212 ); |
|
|
213 #endif // CYGPKG_IO_CAN_LOOP_CAN1 |
|
|
214 |
|
|
215 //------------------------------------------------------------------------- |
|
|
216 |
|
|
217 static bool |
|
|
218 loop_can_config_channel(can_channel *chan, cyg_can_info_t *new_config, bool init) |
|
|
219 { |
|
|
220 if (new_config != &chan->config) { |
|
|
221 chan->config = *new_config; |
|
|
222 } |
|
|
223 return true; |
|
|
224 } |
|
|
225 |
|
|
226 //------------------------------------------------------------------------- |
|
|
227 // Function to initialize the device. Called at bootstrap time. |
|
|
228 |
|
|
229 bool loop_can_init(struct cyg_devtab_entry *tab) |
|
|
230 { |
|
|
231 can_channel *chan = (can_channel *)tab->priv; |
|
|
232 |
|
|
233 (chan->callbacks->can_init)(chan); |
|
|
234 |
|
|
235 // Set up alarm for feeding data back into channels |
|
|
236 |
|
|
237 cyg_alarm_create( cyg_real_time_clock(), |
|
|
238 alarm_handler, |
|
|
239 0, |
|
|
240 &alarm_handle, |
|
|
241 &alarm_obj); |
|
|
242 |
|
|
243 cyg_alarm_initialize( alarm_handle, 1, 1 ); |
|
|
244 |
|
|
245 loop_can_config_channel(chan, &chan->config, true); |
|
|
246 |
|
|
247 return true; |
|
|
248 } |
|
|
249 |
|
|
250 //------------------------------------------------------------------------- |
|
|
251 // This routine is called when the device is "looked" up (i.e. attached) |
|
|
252 |
|
|
253 static Cyg_ErrNo |
|
|
254 loop_can_lookup(struct cyg_devtab_entry **tab, |
|
|
255 struct cyg_devtab_entry *sub_tab, |
|
|
256 const char *name) |
|
|
257 { |
|
|
258 can_channel *chan = (can_channel *)(*tab)->priv; |
|
|
259 (chan->callbacks->can_init)(chan); |
|
|
260 return ENOERR; |
|
|
261 } |
|
|
262 |
|
|
263 //------------------------------------------------------------------------- |
|
|
264 // Return 'true' if message is sent to device |
|
|
265 |
|
|
266 bool |
|
|
267 loop_can_putmsg(can_channel *chan, cyg_can_message *pmsg, void *pdata) |
|
|
268 { |
|
|
269 loop_can_info *loop_chan = (loop_can_info *)chan->dev_priv; |
|
|
270 |
|
|
271 struct fifo *fwr = loop_chan->write_fifo; |
|
2377
|
272 #ifdef CYGOPT_IO_CAN_TX_EVENT_SUPPORT |
|
2059
|
273 struct fifo *frd = loop_chan->read_fifo; |
|
2377
|
274 #endif |
|
2059
|
275 |
|
|
276 if( fwr->num == FIFO_SIZE ) |
|
|
277 { |
|
|
278 return false; |
|
|
279 } |
|
|
280 |
|
|
281 fwr->buf[fwr->tail].msg = *pmsg; |
|
|
282 fwr->buf[fwr->tail].flags = CYGNUM_CAN_EVENT_RX; |
|
|
283 fwr->num++; |
|
|
284 fwr->tail = (fwr->tail + 1) % FIFO_SIZE; |
|
|
285 |
|
|
286 #ifdef CYGOPT_IO_CAN_TX_EVENT_SUPPORT |
|
|
287 // |
|
|
288 // if TX events are supported we insert a TX event into read fifo |
|
|
289 // |
|
|
290 if( frd->num < FIFO_SIZE ) |
|
|
291 { |
|
|
292 frd->buf[frd->tail].msg = *pmsg; |
|
|
293 frd->buf[frd->tail].flags = CYGNUM_CAN_EVENT_TX; |
|
|
294 frd->num++; |
|
|
295 frd->tail = (frd->tail + 1) % FIFO_SIZE; |
|
|
296 } |
|
|
297 #endif |
|
|
298 |
|
|
299 return true; |
|
|
300 } |
|
|
301 |
|
|
302 //------------------------------------------------------------------------- |
|
|
303 |
|
|
304 bool loop_can_getevent(can_channel *chan, cyg_can_event *pevent, void *pdata) |
|
|
305 { |
|
|
306 loop_can_info *loop_chan = (loop_can_info *)chan->dev_priv; |
|
|
307 |
|
|
308 struct fifo *frd = loop_chan->read_fifo; |
|
|
309 |
|
|
310 while( frd->num == 0 ) |
|
|
311 { |
|
|
312 continue; |
|
|
313 } |
|
|
314 |
|
|
315 *pevent = frd->buf[frd->head]; |
|
|
316 |
|
|
317 |
|
|
318 #ifdef CYGOPT_IO_CAN_SUPPORT_TIMESTAMP |
|
|
319 // |
|
|
320 // if timestamps are supported then we store a actual timestamp into |
|
|
321 // CAN event |
|
|
322 // |
|
|
323 pevent->timestamp = cyg_current_time(); |
|
|
324 #endif // CYGOPT_IO_CAN_SUPPORT_TIMESTAMP |
|
|
325 |
|
|
326 frd->num--; |
|
|
327 frd->head = (frd->head + 1) % FIFO_SIZE; |
|
|
328 |
|
|
329 return true; |
|
|
330 } |
|
|
331 |
|
|
332 //------------------------------------------------------------------------- |
|
|
333 |
|
|
334 static Cyg_ErrNo |
|
|
335 loop_can_set_config(can_channel *chan, cyg_uint32 key, |
|
|
336 const void *xbuf, cyg_uint32 *len) |
|
|
337 { |
|
|
338 return ENOERR; |
|
|
339 } |
|
|
340 |
|
2377
|
341 //------------------------------------------------------------------------- |
|
|
342 // Query device configuration |
|
|
343 |
|
|
344 static Cyg_ErrNo |
|
|
345 loop_can_get_config(can_channel *chan, cyg_uint32 key, |
|
|
346 const void* buf, cyg_uint32* len) |
|
|
347 { |
|
|
348 return ENOERR; |
|
|
349 } |
|
|
350 |
|
2059
|
351 |
|
|
352 //------------------------------------------------------------------------- |
|
|
353 // Enable the transmitter on the device |
|
|
354 |
|
|
355 static void |
|
|
356 loop_can_start_xmit(can_channel *chan) |
|
|
357 { |
|
|
358 loop_can_info *loop_chan = (loop_can_info *)chan->dev_priv; |
|
|
359 |
|
|
360 loop_chan->write_fifo->tx_enable = true; |
|
|
361 |
|
|
362 (chan->callbacks->xmt_msg)(chan, 0); |
|
|
363 } |
|
|
364 |
|
|
365 //------------------------------------------------------------------------- |
|
|
366 // Disable the transmitter on the device |
|
|
367 |
|
|
368 static void |
|
|
369 loop_can_stop_xmit(can_channel *chan) |
|
|
370 { |
|
|
371 loop_can_info *loop_chan = (loop_can_info *)chan->dev_priv; |
|
|
372 |
|
|
373 loop_chan->write_fifo->tx_enable = false; |
|
|
374 } |
|
|
375 |
|
|
376 //------------------------------------------------------------------------- |
|
|
377 |
|
|
378 static void alarm_handler(cyg_handle_t alarm, cyg_addrword_t data) |
|
|
379 { |
|
|
380 can_channel *chan0 = &loop_can0_chan; |
|
|
381 can_channel *chan1 = &loop_can1_chan; |
|
|
382 |
|
|
383 |
|
|
384 while(fifo0.num ) |
|
|
385 { |
|
|
386 (chan1->callbacks->rcv_event)(chan1, 0); |
|
|
387 |
|
|
388 if(fifo0.tx_enable ) |
|
|
389 { |
|
|
390 (chan0->callbacks->xmt_msg)(chan0, 0); |
|
|
391 } |
|
|
392 } |
|
|
393 |
|
|
394 while(fifo1.num ) |
|
|
395 { |
|
|
396 (chan0->callbacks->rcv_event)(chan0, 0); |
|
|
397 |
|
|
398 if(fifo1.tx_enable ) |
|
|
399 { |
|
|
400 (chan1->callbacks->xmt_msg)(chan1, 0); |
|
|
401 } |
|
|
402 } // while( fifo1.num ) |
|
|
403 } |
|
|
404 |
|
|
405 |
|
|
406 #endif // CYGPKG_IO_CAN_LOOP |
|
|
407 |
|
|
408 //------------------------------------------------------------------------- |
|
|
409 // EOF loop_can.c |
