1 /******************************************************************************
3 Cl2.C - PCAN and VCAN cards hardware access library
5 (C) Copyright 1997 Unicontrols a.s.
9 FIRMA : CVUT FEL, Dept. of Measurement
16 12.12.2000, J.B., cl2_receive_data - time stamp for even number of bytes corr.
17 26.8.1998 - cl2_buf_size - corrected, new function return code CL2_BAD_PARAM
18 cl2_clr_async_buffer - corrected
20 ===============================================================================
24 ******************************************************************************/
26 /* Constnt used by CL2 functions */
27 #define CL2_TMP_RF 0x0800
28 #define CL2_TMP_EX 0x0400
29 #define CL2_TMP_EX2 0x0004
30 #define CL2_TMP_EXHIGH 0x80000000L
34 #include "../include/canmsg.h"
35 #include "../include/can_sysdep.h"
36 #include "../include/unican_types.h"
37 #include "../include/unican_cl2.h"
38 #include "linux/delay.h"
41 /*******************************************************************************
42 * cl2_init_card - initialize card to default parameters
45 * Command installs card. The data in sCAN_CARD structure pointed
46 * by *card are initialized to their predefined default values.
47 * Command must be called before any operation with sCAN_CARD
51 * CL2_OK - command completed succesfuly
54 eCL2_RESULT cl2_init_card
56 sCAN_CARD *card, /* Pointer to card structure */
57 void *baseAddress, /* Card base address pointer */
58 U16 intNumber /* Card interrupt number */
63 card->intNumber = intNumber;
64 card->baseAddressPtr = (U8*)baseAddress;
65 card->rxBufBase = card->baseAddressPtr + CL2_RX_BUFFER_DEFAULT;
66 card->asyncTxBufBase = card->baseAddressPtr + CL2_ASYNC_BUFFER_DEFAULT;
67 card->syncTxBufBase = card->baseAddressPtr + CL2_SYNC_BUFFER_DEFAULT;
68 card->rxBufPtr = card->rxBufBase;
69 card->asyncTxBufPtr = card->asyncTxBufBase;
70 card->syncTxBufPtr = card->syncTxBufBase;
71 card->commandRegister = card->baseAddressPtr+CL2_COMMAND_REGISTER;
72 card->dataPtr = card->baseAddressPtr + CL2_DATA_BUFFER;
73 card->rxBufSize = CL2_RX_BUFFER_SIZE;
74 card->syncTxBufSize = CL2_TX_SYNC_BUFFER_SIZE;
75 card->asyncTxBufSize = CL2_TX_ASYNC_BUFFER_SIZE;
77 for ( i = 0; i < 10; i++ ) card->rtrSub[i] = 0xFFFFFFFFL;
82 /*******************************************************************************
83 * cl2_test_card - test card
86 * Test whether the card is installed in system and working properly
87 * or not. If this function fails (return value is CL2_HW_FAILURE)
88 * check if the card is present and card base address.
91 * CL2_OK - card is present and working properly
92 * CL2_HW_FAILURE - card not found or card error
95 eCL2_RESULT cl2_test_card
97 sCAN_CARD *card /* Pointer to card structure */
100 BOOLEAN1 isAA = FALSE, is55 = FALSE;
102 U16 volatile tmpWord;
104 /* timeout for card testing - 1000 read cycles */
105 for ( i = 0; i < 10000; i++ )
107 if ( isAA && is55 ) return CL2_OK;
108 tmpWord = unican_readw(card->baseAddressPtr);
109 /*printk("cl2_test_card: %08lx %04x\n", (long)card->baseAddressPtr, tmpWord);*/
111 if ( (tmpWord & 0x00FF) == 0x00AA ) isAA = TRUE;
112 if ( (tmpWord & 0x00FF) == 0x0055 ) is55 = TRUE;
115 return CL2_HW_FAILURE;
116 } /* cl2_test_card */
119 /*******************************************************************************
120 * cl2_reset_card - reset card
123 * Card pointed by *card gets hardware reset. This command resets
124 * card processor, card settings are restored to their default
128 * CL2_OK - command completed successfuly
131 eCL2_RESULT cl2_reset_card
133 sCAN_CARD *card /* Pointer to card structure */
136 unican_writew(0x0000, card->baseAddressPtr + CL2_RESET_REGISTER);
138 } /* cl2_reset_card */
141 /*******************************************************************************
142 * cl2_get_version - read card version
145 * Fucntion reads a value from card version register.
148 * CL2_OK - command completed successfuly
151 eCL2_RESULT cl2_get_version
153 sCAN_CARD *card, /* Pointer to card structure */
154 U16 *version /* returns card version */
157 *version = unican_readw(card->baseAddressPtr + CL2_VERSION_REGISTER);
159 } /* cl2_get_version */
162 /*******************************************************************************
163 * cl2_gen_interrupt - request for interrupt
166 * CAN card is requested to generate interrupt if there is any reason
167 * to do it. The condition for interrupt generation is defined by
168 * cl2_int_mode command.
171 * CL2_OK - command completed successfuly
174 eCL2_RESULT cl2_gen_interrupt
176 sCAN_CARD *card /* Pointer to card structure */
179 unican_writew(0x0000, card->baseAddressPtr + CL2_GEN_INT_REGISTER);
181 } /* cl2_gen_interrupt */
184 /*******************************************************************************
185 * cl2_start_it - start inhibit time
188 * Command starts interrupt inhibit time. If there is any reason for
189 * interrupt geneation, the card generates interrupt after end of
190 * specified time interval. Time interval is set by cl2_set_iit command.
193 * CL2_OK - command completed successfuly
196 eCL2_RESULT cl2_start_it
198 sCAN_CARD *card /* Pointer to card structure */
201 unican_writew(0x0000, card->baseAddressPtr + CL2_START_IT_REGISTER);
206 /*******************************************************************************
207 * cl2_clear_interrupt - clear interrupt
208 * """""""""""""""""""
210 * Comand clears interrupt (IRQ) generated by a card.
213 * CL2_OK - command completed successfuly
216 eCL2_RESULT cl2_clear_interrupt
218 sCAN_CARD *card /* Pointer to card structure */
221 unican_writew(0x0000, card->baseAddressPtr + CL2_CLEAR_INT_REGISTER);
223 } /* cl2_clear_interrupt */
226 /*******************************************************************************
227 * cl2_int_mode - set interrupt mode
230 * Command controls, which event will generate interrupt. Constants
231 * CL2_INT_XXXX are used for setting of interrupt mode.
234 * CL2_OK - command completed successfuly
235 * CL2_BAD_PARAM - bad command parameter
236 * CL2_COMMAND_BUSY - previous command not completed
239 eCL2_RESULT cl2_int_mode
241 sCAN_CARD *card, /* Pointer to card structure */
242 U16 mode /* Interrupt mode */
245 if ( mode > INT_MODE_ALL ) return CL2_BAD_PARAM;
246 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
247 return CL2_COMMAND_BUSY;
248 unican_writew(mode, card->dataPtr);
249 unican_writew(((U16)cmCL2_INT_MODE + CL2_COMMAND_VALID), card->commandRegister);
254 /*******************************************************************************
255 * cl2_iit_mode - inhibit interrupt time mode
258 * Command enables/disables inhibit interupt time mode.
261 * CL2_OK - command completed successfuly
262 * CL2_COMMAND_BUSY - previous command not completed
265 eCL2_RESULT cl2_iit_mode
267 sCAN_CARD *card, /* Pointer to card structure */
268 BOOLEAN1 onoff /* IIT mode - TRUE=on, FALSE=off */
271 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID ) return
273 unican_writew((U16)onoff, card->dataPtr);
274 unican_writew(((U16)cmCL2_IIT_MODE + CL2_COMMAND_VALID), card->commandRegister);
279 /*******************************************************************************
280 * cl2_sync_mode - sync mode
283 * Command enables/disables transmission of SYNC frames.
286 * CL2_OK - command completed successfuly
287 * CL2_COMMAND_BUSY - previous command not completed
290 eCL2_RESULT cl2_sync_mode
292 sCAN_CARD *card, /* Pointer to card structure */
293 BOOLEAN1 onoff /* Sync mode - TRUE=on, FALSE=off */
296 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
297 return CL2_COMMAND_BUSY;
298 unican_writew((U16)onoff, card->dataPtr);
299 unican_writew(((U16)cmCL2_SYNC_MODE + CL2_COMMAND_VALID), card->commandRegister);
301 } /* cl2_sync_mode */
304 /*******************************************************************************
305 * cl2_rtr_mode - rtr mode
308 * Command enables/disables automatic transmission of RTR frames
311 * CL2_OK - command completed successfuly
312 * CL2_COMMAND_BUSY - previous command not completed
315 eCL2_RESULT cl2_rtr_mode
317 sCAN_CARD *card, /* Pointer to card structure */
318 BOOLEAN1 onoff /* RTR mode - TRUE=on, FALSE=off */
321 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
322 return CL2_COMMAND_BUSY;
323 unican_writew((U16)onoff, card->dataPtr);
324 unican_writew(((U16)cmCL2_RTR_MODE + CL2_COMMAND_VALID), card->commandRegister);
329 /*******************************************************************************
330 * cl2_buf_size - size of synchronous queue
333 * Command sets the size of synchronous send buffer. The size is
334 * in numbers of messages. Default buffer size is 32 messages.
335 * The sum of synchronous_buffer_size and asynchronous_buffer_size
336 * is constant and equal to 64. So, if the size od synchronous
337 * buffer increases, the size of asynchronous buffer decreases and
339 * NOTE: 1 message = 16 bytes
342 * CL2_OK - command completed successfully
343 * CL2_COMMAND_BUSY - previous command not completed
344 * CL2_BAD_PARAM - bad command parameter (bufSize>64)
347 eCL2_RESULT cl2_buf_size
349 sCAN_CARD *card, /* Pointer to card structure */
350 U16 bufSize /* Size of synchronous buffer */
353 if ( bufSize > 64 ) return CL2_BAD_PARAM;
354 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
355 return CL2_COMMAND_BUSY;
356 unican_writew(bufSize, card->dataPtr);
357 unican_writew(((U16)cmCL2_BUF_SIZE + CL2_COMMAND_VALID), card->commandRegister);
358 card->syncTxBufSize = bufSize;
359 card->asyncTxBufSize = 64 - bufSize;
360 card->syncTxBufPtr = card->syncTxBufBase;
361 card->asyncTxBufPtr = card->asyncTxBufBase = card->syncTxBufBase+bufSize*16;
366 /*******************************************************************************
367 * cl2_set_iit - set value of inhibit interrupt time
370 * Command sets value of inhibit interrupt time. If inhibit
371 * interrupt time mode is enabled and started, generation of
372 * interrupt (IRQ) is disabled during this time period.
373 * Inhibit interrupt time can be set from 100 us to 6.5535 s
376 * CL2_OK - command completed successfuly
377 * CL2_COMMAND_BUSY - previous command not completed
380 eCL2_RESULT cl2_set_iit
382 sCAN_CARD *card, /* Pointer to card structure */
383 U16 iit /* time period in x100 us */
386 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
387 return CL2_COMMAND_BUSY;
388 unican_writew(iit, card->dataPtr);
389 unican_writew(((U16)cmCL2_SET_IIT + CL2_COMMAND_VALID), card->commandRegister);
394 /*******************************************************************************
395 * cl2_start_firmware - start firmware
398 * Command starts card firmware
401 * CL2_OK - command completed successfuly
402 * CL2_COMMAND_BUSY - previous command not completed
405 eCL2_RESULT cl2_start_firmware
407 sCAN_CARD *card /* Pointer to card structure */
410 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
411 return CL2_COMMAND_BUSY;
412 unican_writew((U16)cmCL2_START_FIRMWARE + CL2_COMMAND_VALID, card->commandRegister);
414 } /* cl2_start_firmware */
417 /*******************************************************************************
418 * cl2_set_rec_mode - set receive mode
421 * Command sets card receive mode. This enable reception of standard
422 * or extended frames according to CAN 2.0A and 2.0B specifications.
423 * If value of mode is TRUE, card receives extended frames, if mode
424 * is FALSE, card receives standard massage format (default).
427 * CL2_OK - command completed successfuly
428 * CL2_COMMAND_BUSY - previous command not completed
431 eCL2_RESULT cl2_set_rec_mode
433 sCAN_CARD *card, /* Pointer to card structure */
434 BOOLEAN1 mode /* Mode - TRUE=ext, FALSE=std */
437 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
438 return CL2_COMMAND_BUSY;
439 unican_writew((U16)mode, card->dataPtr);
440 unican_writew((U16)cmCL2_SET_REC_MODE + CL2_COMMAND_VALID, card->commandRegister);
442 } /* cl2_set_rec_mode */
445 /*******************************************************************************
446 * cl2_clr_rx_buffer - clear RX buffer
449 * Command clears receive (rx) buffer. All messages stored in
450 * rx buffer will be lost.
453 * CL2_OK - command completed successfuly
454 * CL2_COMMAND_BUSY - previous command not completed
457 eCL2_RESULT cl2_clr_rx_buffer
459 sCAN_CARD *card /* Pointer to card structure */
462 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
463 return CL2_COMMAND_BUSY;
464 card->rxBufPtr = card->rxBufBase;
465 unican_writew((U16)cmCL2_CLR_RX_BUFFER + CL2_COMMAND_VALID, card->commandRegister);
467 } /* cl2_clr_rx_buffer */
470 /*******************************************************************************
471 * cl2_clr_sync_buffer - clear synchronous buffer
472 * """""""""""""""""""
474 * Command clears synchronous send buffer. All messages stored
475 * in synchronous buffer will be lost.
478 * CL2_OK - command completed successfuly
479 * CL2_COMMAND_BUSY - previous command not completed
482 eCL2_RESULT cl2_clr_sync_buffer
484 sCAN_CARD *card /* Pointer to card structure */
487 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
488 return CL2_COMMAND_BUSY;
489 card->syncTxBufPtr = card->syncTxBufBase;
490 unican_writew((U16)cmCL2_CLR_SYNC_BUFFER + CL2_COMMAND_VALID, card->commandRegister);
492 } /* cl2_clr_sync_buffer */
495 /*******************************************************************************
496 * cl2_clr_async_buffer - clear asynchronous buffer
497 * """"""""""""""""""""
499 * Command clears asynchronnous send buffer. All messages stored
500 * in async buffer will be lost.
503 * CL2_OK - command completed successfuly
504 * CL2_COMMAND_BUSY - previous command not completed
507 eCL2_RESULT cl2_clr_async_buffer
509 sCAN_CARD *card /* Pointer to card structure */
512 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
513 return CL2_COMMAND_BUSY;
514 card->asyncTxBufPtr = card->syncTxBufBase + card->syncTxBufSize*16;
515 unican_writew((U16)cmCL2_CLR_ASYNC_BUFFER + CL2_COMMAND_VALID, card->commandRegister);
517 } /* cl2_clr_async_buffer */
520 /*******************************************************************************
521 * cl2_send_time_sync - send time synchronization
524 * Command forces the card to start the High Resolution Synchronization
525 * Protocol according to the CANopen Communication profile. The SYNC
526 * mode has to be enabled (cl2_sync_mode) otherwise this command has
530 * CL2_OK - command completed successfuly
531 * CL2_COMMAND_BUSY - previous command not completed
534 eCL2_RESULT cl2_send_time_sync
536 sCAN_CARD *card /* Pointer to card structure */
539 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
540 return CL2_COMMAND_BUSY;
541 unican_writew((U16)cmCL2_SEND_TIME_SYNC + CL2_COMMAND_VALID, card->commandRegister);
543 } /* cl2_send_time_sync */
546 /*******************************************************************************
547 * cl2_set_time_cobid - set time COB-ID
550 * Command sets the COB-ID for high resolution synchronization
551 * frame. The synchronization can be then made by means of
552 * cl2_send_time_sync command.
555 * CL2_OK - command completed successfuly
556 * CL2_COMMAND_BUSY - previous command not completed
559 eCL2_RESULT cl2_set_time_cobid
561 sCAN_CARD *card, /* Pointer to card structure */
562 U32 COBID /* HRS frame COB-ID */
566 U16 *ptr = (U16 *)card->dataPtr;
568 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
569 return CL2_COMMAND_BUSY;
571 if ( COBID & CL2_TMP_EXHIGH ) /* standard or extended format? */
574 cobidL = (U16)(COBID & 0x0000FFFFL);
575 cobidH = (U16)((COBID & 0xFFFF0000L)>>16);
576 cobidH = ((cobidH >> 8) & 0x00FF) | (((cobidH << 8) & 0xFF00));
578 cobidL = ((cobidL >> 8) & 0x00FF) | (((cobidL << 8) & 0xFF00));
585 cobidH = (U16)(COBID & 0x0000FFFFL);
586 cobidH = ((cobidH >> 8) & 0x00FF) | (((cobidH << 8) & 0xFF00));
592 unican_writew((U16)cmCL2_SET_TIME_COBID + CL2_COMMAND_VALID, card->commandRegister);
594 } /* cl2_set_time_cobid */
597 /*******************************************************************************
598 * cl2_set_receive_limit - set limit for receive signaling
599 * """""""""""""""""""""
601 * Command is used to set the receive limit signalized by bit
602 * RL (in CL2.H CL2_X_DATA_IN_RBUF) of the Status Register.
603 * This bit is set when more then the limit number of frames
604 * was received since the last interrupt was generated (in interrupt
605 * mode) or since the Status Register was last time read.
609 * CL2_COMMAND_BUSY - previous command not completed
610 * CL2_BAD_PARAM - bad command parameter
612 eCL2_RESULT cl2_set_receive_limit
614 sCAN_CARD *card, /* pointer to card structure */
615 U16 limit /* limit of messages in receive buffer */
618 if ( limit > 127 ) return CL2_BAD_PARAM;
619 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
620 return CL2_COMMAND_BUSY;
621 unican_writew(limit, card->dataPtr);
622 unican_writew((U16)cmCL2_SET_RECEIVE_LIMIT + CL2_COMMAND_VALID, card->commandRegister);
624 } /* cl2_set_receive_limit */
627 /*******************************************************************************
628 * cl2_download_rtr_list - download rtr list
629 * """""""""""""""""""""
631 * Command downloads a list of up to 64 RTR frames. These frames are
632 * periodically transmitted by the card. The parameters, how often
633 * frames are send and in which SYNC period is defined by period and
634 * subperiod in sRTR_FRAME structure.
637 * CL2_OK - command completed successfuly
638 * CL2_COMMAND_BUSY - previous command not completed
639 * CL2_BAD_PARAM - bad command parameter
642 eCL2_RESULT cl2_download_rtr_list
644 sCAN_CARD *card, /* Pointer to card structure */
645 sRTR_LIST *rtrList /* RTR list */
648 U16 *ptrTmp = (U16*)card->dataPtr;
649 sRTR_FRAME *ptrRTR = rtrList->data;
652 U16 cobidH, cobidL, i;
654 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID ) return
656 if ( rtrList->nb > 64 ) return CL2_BAD_PARAM;
658 *ptrTmp++ = (U16)rtrList->nb;
659 for ( i = 0; i < rtrList->nb; i++ )
661 if ( ptrRTR->period < ptrRTR->subperiod ) return CL2_BAD_PARAM;
662 if ( ptrRTR->subperiod == 0 ) ptrRTR->subperiod = 1;
663 tmpU16 = (ptrRTR->period & 0x00FF) + ((ptrRTR->subperiod & 0x00FF)<<8);
665 COBID = ptrRTR->cob_id;
667 if ( COBID & CL2_TMP_EXHIGH ) /* standard or extended format? */
670 cobidL = (U16)(COBID & 0x0000FFFFL);
671 cobidH = (U16)((COBID & 0xFFFF0000L)>>16);
672 cobidH = ((cobidH >> 8) & 0x00FF) | (((cobidH << 8) & 0xFF00));
674 cobidL = ((cobidL >> 8) & 0x00FF) | (((cobidL << 8) & 0xFF00));
680 cobidH = (U16)(COBID & 0x0000FFFFL);
681 cobidH = ((cobidH >> 8) & 0x00FF) | (((cobidH << 8) & 0xFF00));
686 *ptrTmp++ = 0x0000; /* rezerva */
690 unican_writew((U16)cmCL2_DOWNLOAD_RTR_LIST + CL2_COMMAND_VALID, card->commandRegister);
692 } /* cl2_download_rtrlist */
695 /*******************************************************************************
696 * cl2_subscribe_rtr - subscribe RTR frame
699 * Command subscribes RTR frame. Incoming RTR frames which were
700 * subscribed are accepted, while other are ignored. Up to 10
701 * RTR frames can be subscribed.
704 * CL2_OK - command completed successfuly
705 * CL2_COMMAND_BUSY - previous command not completed
706 * CL2_BAD_PARAM - bad command parameter
709 eCL2_RESULT cl2_subscribe_rtr
711 sCAN_CARD *card, /* Pointer to card structure */
712 sCAN_MESSAGE *canMessage, /* RTR frame */
713 U16 RTRnumber /* number of RTR */
716 U16 *ptrU16 = (U16*)card->dataPtr;
720 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
721 return CL2_COMMAND_BUSY;
722 if ( RTRnumber > 9 ) return CL2_BAD_PARAM;
724 card->rtrSub[RTRnumber] = canMessage->COB_ID;
727 COBID = canMessage->COB_ID;
729 if ( COBID & CL2_TMP_EXHIGH ) /* standard or extended format? */
732 cobidL = (U16)(COBID & 0x0000FFFFL);
733 cobidH = (U16)((COBID & 0xFFFF0000L)>>16);
734 cobidH = ((cobidH >> 8) & 0x00FF) | (((cobidH << 8) & 0xFF00));
736 cobidL = ((cobidL >> 8) & 0x00FF) | (((cobidL << 8) & 0xFF00));
738 *ptrU16 = (U16)CL2_EXT_FRAME;
743 cobidH = (U16)(COBID & 0x0000FFFFL);
744 cobidH = ((cobidH >> 8) & 0x00FF) | (((cobidH << 8) & 0xFF00));
750 unican_writew((U16)cmCL2_SUBSCRIBE_RTR + CL2_COMMAND_VALID, card->commandRegister);
752 } /* cl2_subscribe_rtr */
755 /*******************************************************************************
756 * cl2_desubscribe_rtr - desubscribe rtr frame
757 * """""""""""""""""""
759 * Command desubscribes RTR frame. Card will not accept RTR frames
760 * with this identifier.
763 * CL2_OK - command completed successfuly
764 * CL2_COMMAND_BUSY - previous command not completed
765 * CL2_BAD_PARAM - bad command parameter
768 eCL2_RESULT cl2_desubscribe_rtr
770 sCAN_CARD *card, /* Pointer to card structure */
771 sCAN_MESSAGE *canMessage /* RTR frame */
776 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
777 return CL2_COMMAND_BUSY;
779 for ( i = 0; i < 10; i++ )
781 if ( card->rtrSub[i] == canMessage->COB_ID )
783 card->rtrSub[i] = 0xFFFFFFFFL;
788 if ( i >= 10 ) return CL2_BAD_PARAM;
790 unican_writew(i, card->dataPtr);
791 unican_writew((U16)cmCL2_DESUBSCRIBE_RTR + CL2_COMMAND_VALID, card->commandRegister);
793 } /* cl2_desubscribe_rtr */
797 /*******************************************************************************
798 * cl2_set_sync_cobid - set COB-ID
801 * Command sets COB-ID of SYNC frame. In active SYNC mode, the SYNC
802 * frame with this COB-ID is periodically sent with period defined
803 * by cl2_set_sync_period command.
806 * CL2_OK - command completed successfuly
807 * CL2_COMMAND_BUSY - previous command not completed
810 eCL2_RESULT cl2_set_sync_cobid
812 sCAN_CARD *card, /* Pointer to card structure */
813 U32 COBID /* COB-ID */
817 U16 *ptr = (U16 *)card->dataPtr;
819 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
820 return CL2_COMMAND_BUSY;
822 if ( COBID & CL2_TMP_EXHIGH ) /* standard or extended format? */
825 cobidL = (U16)(COBID & 0x0000FFFFL);
826 cobidH = (U16)((COBID & 0xFFFF0000L)>>16);
827 cobidH = ((cobidH >> 8) & 0x00FF) | (((cobidH << 8) & 0xFF00));
829 cobidL = ((cobidL >> 8) & 0x00FF) | (((cobidL << 8) & 0xFF00));
836 cobidH = (U16)(COBID & 0x0000FFFFL);
837 cobidH = ((cobidH >> 8) & 0x00FF) | (((cobidH << 8) & 0xFF00));
843 unican_writew(((U16)cmCL2_SET_COBID + CL2_COMMAND_VALID), card->commandRegister);
845 } /* cl2_set_sync_cobid */
848 /*******************************************************************************
849 * cl2_set_sync_period - set SYNC period
850 * """""""""""""""""""
852 * Coomand sets the SYNC frame send period in active SYNC mode in
853 * x100 us. The period range is from 0 to 0xFFFF (SYNC period can
854 * be set from 100us to 6.5535s).
857 * CL2_OK - command completed successfuly
858 * CL2_COMMAND_BUSY - previous command not completed
861 eCL2_RESULT cl2_set_sync_period
863 sCAN_CARD *card, /* Pointer to card structure */
864 U16 period /* period in x100 us */
867 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
868 return CL2_COMMAND_BUSY;
869 unican_writew((U16)period, card->dataPtr);
870 unican_writew((U16)cmCL2_SET_SYNC_PERIOD + CL2_COMMAND_VALID, card->commandRegister);
872 } /* cl2_set_sync_period */
875 /*******************************************************************************
876 * cl2_set_sync_window - set SYNC window
877 * """""""""""""""""""
879 * Command sets the SYNC window length. Only during this time period
880 * after SYNC frame was send or receive the frames from the synchronous
881 * send buffer can be sent.
884 * CL2_OK - command completed successfuly
885 * CL2_COMMAND_BUSY - previous command not completed
888 eCL2_RESULT cl2_set_sync_window
890 sCAN_CARD *card, /* Pointer to card structure */
891 U16 window /* period in x100 us */
894 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
895 return CL2_COMMAND_BUSY;
896 unican_writew((U16)window, card->dataPtr);
897 unican_writew((U16)cmCL2_SET_SYNC_WINDOW + CL2_COMMAND_VALID, card->commandRegister);
899 } /* cl2_set_sync_window */
902 /*******************************************************************************
903 * cl2_set_bitrate - set CAN bit-rate
906 * Command switches the bus bit-rate. There are some predefined
907 * constants CL2_BITRATE_XXXX.
910 * CL2_OK - command completed successfuly
911 * CL2_COMMAND_BUSY - previous command not completed
914 eCL2_RESULT cl2_set_bitrate
916 sCAN_CARD *card, /* Pointer to card structure */
917 U16 bitrate /* CAN bitrate */
920 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
921 return CL2_COMMAND_BUSY;
922 unican_writew(bitrate, card->dataPtr);
923 unican_writew((U16)cmCL2_SET_BITRATE + CL2_COMMAND_VALID, card->commandRegister);
925 } /* cl2_set_bitrate */
928 /*******************************************************************************
929 * cl2_bus_reset - resets CAN controller
932 * Command resets CAN controller
935 * CL2_OK - command completed successfuly
936 * CL2_COMMAND_BUSY - previously command not completed
939 eCL2_RESULT cl2_bus_reset
944 if ( unican_readw(card->commandRegister) & CL2_COMMAND_VALID )
945 return CL2_COMMAND_BUSY;
946 unican_writew((U16)cmCL2_BUS_RESET + CL2_COMMAND_VALID, card->commandRegister);
948 } /* cl2_bus_reset */
951 /*******************************************************************************
952 * cl2_send_sync - sends synchronous frame
955 * Command stores massage in synchronous send buffer.
958 * CL2_OK - command completed successfuly
959 * CL2_HW_QUEUE_FULL - synchronous send buffer is full
960 * CL2_BAD_PARAM - bad command parameter
961 * CL2_HW_FAILURE - error in HW configuration
964 eCL2_RESULT cl2_send_sync
966 sCAN_CARD *card, /* pointer to card */
967 sCAN_MESSAGE *message /* massage to be sent */
972 U16 *ptrU16 = (U16*)card->syncTxBufPtr;
977 if ( card->syncTxBufSize==0 ) return CL2_HW_FAILURE;
978 if ( message->dataLength > 8 ) return CL2_BAD_PARAM;
979 if ( *ptrU16 & CL2_FRAME_VALID ) return CL2_HW_QUEUE_FULL;
981 cobid = message->COB_ID;
982 if ( (message->dataType & CL2_EXT_FRAME) || (cobid & CL2_TMP_EXHIGH) )
985 cobidL = (U16)(cobid & 0x0000FFFFL);
986 cobidH = (U16)((cobid & 0xFFFF0000L)>>16);
992 cobidH = (U16)(cobid & 0x0000FFFFL);
995 tmpU16 = (cobidH & 0x00FF) + (cobidL & 0xFF00);
998 tmpU16 = (((U16)message->dataLength) << 12) + (cobidL & 0x00FF);
999 if ( !(message->dataType & CL2_REMOTE_FRAME) ) tmpU16 |= CL2_TMP_RF;
1000 if ( (message->dataType & CL2_EXT_FRAME) ||
1001 (message->COB_ID & CL2_TMP_EXHIGH) )
1002 tmpU16 |= CL2_TMP_EX;
1005 for ( i = 0; i < message->dataLength; )
1007 tmpU16 = (U16)message->data[i]; i++;
1008 if ( i == message->dataLength )
1011 tmpU16 |= ((message->timeStamp & 0x00FF)<<8);
1016 tmpU16 |= ((U16)message->data[i]<<8); i++;
1022 tmpU16 = (message->timeStamp>>8) & 0x00FF;
1027 *ptrU16 = message->timeStamp;
1030 tmpU16 = (((U16)cobidH) & 0xFF00) | CL2_MESSAGE_VALID;
1031 unican_writew(tmpU16, card->syncTxBufPtr);
1033 if ( (card->syncTxBufBase + card->syncTxBufSize*16) <=
1034 (card->syncTxBufPtr += 16) )
1036 card->syncTxBufPtr = card->syncTxBufBase;
1039 } /* cl2_send_sync */
1042 /*******************************************************************************
1043 * cl2_send_async - sends asynchronous frame
1046 * Command stores message in asynchronous send buffer.
1049 * CL2_OK - command completed successfuly
1050 * CL2_HW_QUEUE_FULL - asynchronous buffer full
1051 * CL2_HW_FAILURE - error in HW configuration
1052 * CL2_BAD_PARAM - bad command parameter
1055 eCL2_RESULT cl2_send_async
1057 sCAN_CARD *card, /* pointer to card */
1058 sCAN_MESSAGE *message /* message to be sent */
1063 U16 *ptrU16 = (U16*)card->asyncTxBufPtr;
1068 if ( card->asyncTxBufSize==0 ) return CL2_HW_FAILURE;
1069 if ( message->dataLength > 8 ) return CL2_BAD_PARAM;
1070 if ( *ptrU16 & CL2_FRAME_VALID ) return CL2_HW_QUEUE_FULL;
1072 cobid = message->COB_ID;
1073 if ( (message->dataType & CL2_EXT_FRAME) || (cobid & CL2_TMP_EXHIGH) )
1076 cobidL = (U16)(cobid & 0x0000FFFFL);
1077 cobidH = (U16)((cobid & 0xFFFF0000L)>>16);
1083 cobidH = (U16)(cobid & 0x0000FFFFL);
1086 tmpU16 = (cobidH & 0x00FF ) + (cobidL & 0xFF00);
1089 tmpU16 = (((U16)message->dataLength) << 12) + (cobidL & 0x00FF);
1090 if ( !(message->dataType & CL2_REMOTE_FRAME) ) tmpU16 |= CL2_TMP_RF;
1091 if ( (message->dataType & CL2_EXT_FRAME) ||
1092 (message->COB_ID & CL2_TMP_EXHIGH ) )
1093 tmpU16 |= CL2_TMP_EX;
1096 for ( i = 0; i < message->dataLength; )
1098 tmpU16 = (U16)message->data[i]; i++;
1099 if ( i == message->dataLength )
1102 tmpU16 |= ((message->timeStamp & 0x00FF)<<8);
1107 tmpU16 |= ((U16)message->data[i]<<8); i++;
1113 tmpU16 = (message->timeStamp>>8) & 0x00FF;
1118 *ptrU16 = message->timeStamp;
1121 tmpU16 = (((U16)cobidH) & 0xFF00) | CL2_MESSAGE_VALID;
1122 unican_writew(tmpU16, card->asyncTxBufPtr);
1124 if ( (card->asyncTxBufBase + card->asyncTxBufSize*16) <=
1125 (card->asyncTxBufPtr += 16) )
1127 card->asyncTxBufPtr = card->asyncTxBufBase;
1130 } /* cl2_send_async */
1133 /*******************************************************************************
1134 * cl2_get_status - reads card status
1137 * Command reads card status register. If data in status register
1138 * are valid (status valid flag is set), the value of status is read
1139 * and stored in status and sCAN_CARD structure.
1142 * CL2_OK - command completed successfuly
1143 * CL2_NO_REQUEST - status is not valid
1146 eCL2_RESULT cl2_get_status
1148 sCAN_CARD *card, /* pointer to card */
1149 U16 *status /* card status word */
1154 ptr = (U16*)(card->baseAddressPtr + CL2_STATUS_REGISTER);
1156 if ( (*status & CL2_STATUS_VALID_FLAG) )
1158 *ptr = *status & ~CL2_STATUS_VALID_FLAG;
1159 card->status = *status;
1162 return CL2_NO_REQUEST;
1163 } /* cl2_get_status */
1166 /*******************************************************************************
1167 * cl2_get_error - reads card error
1170 * Command reads card error register. If data in error register
1171 * are valid (error register valid flag is set), the value of error
1172 * register is read and stored in error and sCAN_CARD structure.
1175 * Cl2_OK - command completed successfuly
1178 eCL2_RESULT cl2_get_error
1180 sCAN_CARD *card, /* pointer to card */
1181 U16 *error /* card error word */
1186 ptr = (U16*)(card->baseAddressPtr + CL2_ERROR_REGISTER);
1188 card->error |= *error;
1191 } /* cl2_get_error */
1194 /*******************************************************************************
1195 * cl2_receive_data - reads received frame
1198 * Command reads new messages received by a card.
1201 * CL2_OK - command commpleted successfuly
1202 * CL2_NO_REQUEST - there is no new message
1205 eCL2_RESULT cl2_receive_data
1207 sCAN_CARD *card, /* Pointer to card structure */
1208 sCAN_MESSAGE *canMessage /* Message */
1211 U16 *ptrU16 = (U16*)card->rxBufPtr;
1216 if ( !(tmpU16 & CL2_MESSAGE_VALID) ) return CL2_NO_REQUEST;
1217 canMessage->COB_ID = ((U32)(tmpU16 & 0xFF00 )) << 16;
1219 canMessage->COB_ID |= ((U32)( tmpU16 & 0x00FF )) << 16;
1220 canMessage->COB_ID |= (U32)( tmpU16 & 0xFF00 );
1222 canMessage->COB_ID |= (U32)( tmpU16 & 0x00FF );
1223 canMessage->dataType = (U8)(( tmpU16 & 0xFF00 ) >> 8);
1225 if ( canMessage->dataType & CL2_EXT_FRAME )
1227 canMessage->COB_ID >>= 3;
1228 /* canMessage->COB_ID |= CL2_TMP_EXHIGH; */
1232 canMessage->COB_ID >>= 21;
1234 canMessage->dataLength = (U8)( (tmpU16 >> 12) & 0x000F );
1235 /* if ( !(tmpU16 & CL2_TMP_RF) ) canMessage->dataType |= CL2_REMOTE_FRAME; */
1236 for ( i = 0; i < canMessage->dataLength; )
1239 canMessage->data[i++] = (U8)( tmpU16 );
1240 canMessage->data[i++] = (U8)( tmpU16 >> 8 );
1242 if ( canMessage->dataLength & 0x01 )
1244 canMessage->timeStamp = ( (*ptrU16 & 0x00FF) | (tmpU16 & 0xFF00) );
1248 canMessage->timeStamp = *ptrU16 << 8 | *ptrU16 >> 8;
1250 unican_writew(0x0000, card->rxBufPtr);
1252 /* increment rx-buffer pointer */
1253 if ( (card->rxBufBase + card->rxBufSize*16 ) <= (card->rxBufPtr += 16) )
1255 card->rxBufPtr = card->rxBufBase;
1259 } /* cl2_receive_data */
1262 /* **************************************************************** *
1264 * **************************************************************** */