1 /*

     2 This file is part of CanFestival, a library implementing CanOpen Stack.

     3 

     4 Copyright (C): Cosateq GmbH & Co.KG

     5                http://www.cosateq.com/

     6                http://www.scale-rt.com/

     7 

     8 See COPYING file for copyrights details.

     9 

    10 This library is free software; you can redistribute it and/or

    11 modify it under the terms of the GNU Lesser General Public

    12 License as published by the Free Software Foundation; either

    13 version 2.1 of the License, or (at your option) any later version.

    14 

    15 This library is distributed in the hope that it will be useful,

    16 but WITHOUT ANY WARRANTY; without even the implied warranty of

    17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    18 Lesser General Public License for more details.

    19 

    20 You should have received a copy of the GNU Lesser General Public

    21 License along with this library; if not, write to the Free Software

    22 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    23 */

    24 

    25 /*

    26 	COMEDI interface for CO-PCICAN card.

    27 */

    28 

    29 #include <linux/module.h>

    30 #include <linux/comedi.h>

    31 #include <linux/comedilib.h>

    32 

    33 #define NEED_PRINT_MESSAGE

    34 #include "can_driver.h"

    35 #include "def.h"

    36 #include "co_pcicanops.h"

    37 

    38 MODULE_LICENSE("GPL");

    39 

    40 /* at the moment not threadsafe :-( */

    41 static unsigned char selectedChannelRx = 0, selectedChannelTx = 0;

    42 

    43 static int rt_strcmp( const char *src, const char *dst )

    44 {

    45   int ret = 0;

    46 

    47   while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)

    48   {

    49     src++;

    50     dst++;

    51   }

    52 

    53   if( ret < 0 )

    54   {

    55     ret = -1 ;

    56   }

    57   else

    58   {

    59     if( ret > 0 )

    60       ret = 1 ;

    61   }

    62 

    63   return ret;

    64 }

    65 

    66 static int TranslateBaudRate( char* optarg )

    67 {

    68   /* values see documentation of CO-PCICAN */

    69   if( !rt_strcmp( optarg, "1M"    ) ) return 0;

    70   if( !rt_strcmp( optarg, "800K"  ) ) return 1;

    71   if( !rt_strcmp( optarg, "500K"  ) ) return 2;

    72   if( !rt_strcmp( optarg, "250K"  ) ) return 3;

    73   if( !rt_strcmp( optarg, "125K"  ) ) return 4;

    74   if( !rt_strcmp( optarg, "100K"  ) ) return 5;

    75   if( !rt_strcmp( optarg, "83.3K" ) ) return 6;

    76   if( !rt_strcmp( optarg, "10K"   ) ) return 7;

    77 

    78   return -1;

    79 }

    80 

    81 /*********CO-PCICAN specific functions to communicate with the board**********/

    82 typedef struct

    83 {

    84   char used;

    85   CAN_HANDLE fd;

    86   void* receiveTask;

    87   void* d;

    88 } CANPort; /* taken from drivers/unix.c */

    89 

    90 comedi_t* get_dev_of_port( CAN_PORT port )

    91 {

    92   CANPort *thisPort = (CANPort*)port;

    93   CAN_HANDLE thisHandle;

    94   comedi_t *dev;

    95 

    96   if( thisPort == NULL )

    97   {

    98     MSG("can_copcican_comedi: get_dev_of_port(): thisPort is NULL\n");

    99     return NULL;

   100   }

   101 

   102   thisHandle = thisPort->fd;

   103 

   104   if( thisHandle == NULL )

   105   {

   106     MSG("can_copcican_comedi: get_dev_of_port(): thisHandle is NULL\n");

   107     return NULL;

   108   }

   109 

   110   dev = (comedi_t*)thisHandle;

   111 

   112   /*MSG("can_copcican_comedi: get_dev_of_port(): handle is 0x%08x\n", (unsigned int)dev);*/

   113 

   114   return dev;

   115 }

   116 

   117 int co_pcican_enter_run_mode( comedi_t *dev )

   118 {

   119   unsigned int opcmd[15];

   120   unsigned int opcode = CMDQ_OPC_ENTER_RUN_MODE;

   121   comedi_insn insn;

   122 

   123   if( dev == NULL )

   124   {

   125     MSG("can_copcican_comedi: co_pcican_enter_run_mode(): dev is NULL\n");

   126     return 1;

   127   }

   128 

   129   memset( opcmd, 0x00, sizeof(opcmd) );

   130   opcmd[0] = 0;

   131 

   132   memset( &insn, 0x00, sizeof(insn) );

   133   insn.insn      = INSN_CONFIG;

   134   insn.n         = 1;

   135   insn.data      = (void*)opcmd;

   136   insn.subdev    = 0;

   137   insn.unused[0] = opcode; /* in use for CO-PCICAN */

   138 

   139   comedi_do_insn( dev, &insn );

   140 

   141   opcmd[0] = 2;

   142   insn.subdev    = 2;

   143   insn.unused[0] = opcode; /* in use for CO-PCICAN */

   144 

   145   return comedi_do_insn( dev, &insn );

   146 }

   147 

   148 int co_pcican_enter_config_mode( comedi_t *dev )

   149 {

   150   unsigned int opcmd[15];

   151   unsigned int opcode = CMDQ_OPC_ENTER_CONFIG_MODE;

   152   comedi_insn insn;

   153 

   154   if( dev == NULL )

   155   {

   156     MSG("can_copcican_comedi: co_pcican_enter_config_mode(): dev is NULL\n");

   157     return 1;

   158   }

   159 

   160   memset( opcmd, 0x00, sizeof(opcmd) );

   161   opcmd[0] = 0;

   162 

   163   memset( &insn, 0x00, sizeof(insn) );

   164   insn.insn      = INSN_CONFIG;

   165   insn.n         = 1;

   166   insn.data      = (void*)opcmd;

   167   insn.subdev    = 0;

   168   insn.unused[0] = opcode; /* in use for CO-PCICAN */

   169 

   170   comedi_do_insn( dev, &insn );

   171 

   172   opcmd[0] = 2;

   173   insn.subdev    = 2;

   174   insn.unused[0] = opcode; /* in use for CO-PCICAN */

   175 

   176   return comedi_do_insn( dev, &insn );

   177 }

   178 

   179 int co_pcican_select_channel( const unsigned char channel, const unsigned int direction )

   180 {

   181   if( channel >= NUM_CAN_CHANNELS )

   182   {

   183     MSG("can_copcican_comedi: co_pcican_select_channel(): invalid channel\n");

   184     return -1;

   185   }

   186 

   187   /* at the moment not threadsafe :-( */

   188   switch( direction )

   189   {

   190     case RX: selectedChannelRx = channel;

   191              break;

   192     case TX: selectedChannelTx = channel;

   193              break;

   194     default: return -1;

   195   }

   196 

   197   return 0;

   198 }

   199 

   200 int co_pcican_configure_selected_channel( comedi_t *dev, s_BOARD *board, const unsigned int direction )

   201 {

   202   unsigned int opcmd[15];

   203   unsigned int opcode = CMDQ_OPC_SET_CONFIG_CHANNEL;

   204   unsigned int selectedChannel;

   205   comedi_insn insn;

   206 

   207   if( dev == NULL )

   208   {

   209     MSG("can_copcican_comedi: co_pcican_configure_selected_channel(): dev is NULL\n");

   210     return -1;

   211   }

   212 

   213   if( board == NULL )

   214   {

   215     MSG("can_copcican_comedi: co_pcican_configure_selected_channel(): board is NULL\n");

   216     return -1;

   217   }

   218 

   219   if( board->baudrate == NULL )

   220   {

   221     MSG("can_copcican_comedi: co_pcican_configure_selected_channel(): baudrate is NULL\n");

   222     return -1;

   223   }

   224 

   225   switch( direction )

   226   {

   227     case RX: selectedChannel = selectedChannelRx;

   228              break;

   229     case TX: selectedChannel = selectedChannelTx;

   230              break;

   231     default: selectedChannel = 0xff;

   232   }

   233 

   234   if( selectedChannel >= NUM_CAN_CHANNELS )

   235   {

   236     MSG("can_copcican_comedi: co_pcican_configure_selected_channel(): invalid channel selected\n");

   237     return -1;

   238   }

   239 

   240   memset( opcmd, 0x00, sizeof(opcmd) );

   241   opcmd[0] = selectedChannel;

   242   opcmd[1] = TranslateBaudRate( board->baudrate );

   243 

   244   memset( &insn, 0x00, sizeof(insn) );

   245   insn.insn      = INSN_CONFIG;

   246   insn.n         = 1;

   247   insn.data      = (void*)opcmd;

   248 

   249   if( selectedChannel < 2 )

   250     insn.subdev    = 0;

   251   else

   252     insn.subdev    = 2;

   253 

   254   insn.unused[0] = opcode; /* in use for CO-PCICAN */

   255 

   256   return comedi_do_insn( dev, &insn );

   257 }

   258 

   259 /*********functions which permit to communicate with the board****************/

   260 UNS8 canReceive_driver( CAN_HANDLE fd0, Message *m )

   261 {

   262   MESSAGE_T canmsg;

   263   comedi_insn insn;

   264   UNS8 ret = 0;

   265   comedi_t *dev = (comedi_t*)fd0;

   266 

   267   if( dev == NULL )

   268   {

   269     MSG("can_copcican_comedi: canReceive_driver(): dev is NULL\n");

   270     return 1;

   271   }

   272 

   273   if( selectedChannelRx >= NUM_CAN_CHANNELS )

   274   {

   275     MSG("can_copcican_comedi: canReceive_driver(): invalid channel selected\n");

   276     return 1;

   277   }

   278 

   279   if( m == NULL )

   280   {

   281     MSG("can_copcican_comedi: canReceive_driver(): message is NULL\n");

   282     return 1;

   283   }

   284 

   285   memset( &canmsg, 0x00, sizeof(MESSAGE_T) );

   286 

   287   memset( &insn, 0x00, sizeof(insn) );

   288   insn.insn      = INSN_READ;

   289   insn.n         = 1;

   290   insn.data      = (void*)&canmsg;

   291 

   292   if( selectedChannelRx < 2 )

   293     insn.subdev    = comedi_find_subdevice_by_type(dev, COMEDI_SUBD_DI, 0);

   294   else

   295     insn.subdev    = comedi_find_subdevice_by_type(dev, COMEDI_SUBD_DI, 2);

   296 

   297   insn.unused[1] = selectedChannelRx; /* in use for CO-PCICAN */

   298   insn.unused[2] = sizeof(MESSAGE_T); /* in use for CO-PCICAN */

   299 

   300   comedi_do_insn( dev, &insn );

   301 

   302   if( canmsg.timestamp_lo == 0 )

   303   {

   304     memset( m, 0x00, sizeof(Message) );

   305 

   306     m->cob_id = 0xffff; /* set to invalid so nothing happens */

   307   }

   308   else

   309   {

   310     m->len = canmsg.size;

   311     m->cob_id = canmsg.id;

   312     m->rtr = canmsg.type & MSG_RTR;

   313 

   314     if( !m->rtr )

   315     {

   316       /* this is for safety */

   317       if( m->len > 8 )

   318         m->len = 8;

   319 

   320       memcpy( m->data, canmsg.data, m->len);

   321     }

   322   }

   323 

   324   return ret;

   325 }

   326 

   327 /***************************************************************************/

   328 UNS8 canSend_driver( CAN_HANDLE fd0, Message *m )

   329 {

   330   MESSAGE_T canmsg;

   331   comedi_insn insn;

   332   UNS8 ret = 0;

   333   comedi_t *dev = (comedi_t*)fd0;

   334 

   335   if( dev == NULL )

   336   {

   337     MSG("can_copcican_comedi: canSend_driver(): dev is NULL\n");

   338     return 1;

   339   }

   340 

   341   if( selectedChannelTx >= NUM_CAN_CHANNELS )

   342   {

   343     MSG("can_copcican_comedi: canSend_driver(): invalid channel selected\n");

   344     return 1;

   345   }

   346 

   347   if( m == NULL )

   348   {

   349     MSG("can_copcican_comedi: canSend_driver(): message is NULL\n");

   350     return 1;

   351   }

   352 

   353   memset( &canmsg, 0x00, sizeof(MESSAGE_T) );

   354   canmsg.size = m->len;

   355   canmsg.id = m->cob_id;

   356 

   357   if( canmsg.id >= 0x800 )

   358     canmsg.type |= MSG_EXT;

   359 

   360   if( m->rtr )

   361   {

   362     canmsg.type |= MSG_RTR;

   363   }

   364   else

   365   {

   366     /* this is for safety */

   367     if( canmsg.size > 8 )

   368       canmsg.size = 8;

   369 

   370     memcpy( canmsg.data, m->data, canmsg.size);

   371   }

   372 

   373   memset( &insn, 0x00, sizeof(insn) );

   374   insn.insn      = INSN_WRITE;

   375   insn.n         = 1;

   376   insn.data      = (void*)&canmsg;

   377 

   378   if( selectedChannelTx < 2 )

   379     insn.subdev    = comedi_find_subdevice_by_type(dev, COMEDI_SUBD_DO, 0);

   380   else

   381     insn.subdev    = comedi_find_subdevice_by_type(dev, COMEDI_SUBD_DO, 2);

   382 

   383   insn.unused[1] = selectedChannelTx; /* in use for CO-PCICAN */

   384   insn.unused[2] = sizeof(MESSAGE_T) - sizeof(unsigned long); /* in use for CO-PCICAN, no timestamp for tx */

   385 

   386   if( comedi_do_insn( dev, &insn ) < 0 )

   387     ret = 1;

   388 

   389   return ret;

   390 }

   391 

   392 /***************************************************************************/

   393 CAN_HANDLE canOpen_driver( s_BOARD *board )

   394 {

   395   comedi_t *dev;

   396 

   397   if( board == NULL )

   398   {

   399     MSG("can_copcican_comedi: canOpen_driver(): board is NULL\n");

   400     return NULL;

   401   }

   402 

   403   if( board->busname == NULL )

   404   {

   405     MSG("can_copcican_comedi: canOpen_driver(): busname is NULL\n");

   406     return NULL;

   407   }

   408 

   409   dev = comedi_open( board->busname );

   410 

   411   /*MSG("can_copcican_comedi: canOpen_driver(): handle is 0x%08x\n", (unsigned int)dev);*/

   412 

   413   return dev;

   414 }

   415 

   416 /***************************************************************************/

   417 int canClose_driver( CAN_HANDLE fd0 )

   418 {

   419   comedi_t *dev = (comedi_t*)fd0;

   420 

   421   if( dev == NULL )

   422   {

   423     MSG("can_copcican_comedi: canClose_driver(): dev is NULL\n");

   424     return 1;

   425   }

   426 

   427   comedi_close( dev );

   428 

   429   selectedChannelRx = 0;

   430   selectedChannelTx = 0;

   431 

   432   return 0;

   433 }

   434 

   435 /***************************************************************************/

   436 UNS8 canChangeBaudRate_driver( CAN_HANDLE fd0, char* baud )

   437 {

   438   s_BOARD board;

   439   UNS8 ret = 0;

   440   comedi_t *dev = (comedi_t*)fd0;

   441 

   442   if( dev == NULL )

   443   {

   444     MSG("can_copcican_comedi: canChangeBaudRate_driver(): dev is NULL\n");

   445     return 1;

   446   }

   447 

   448   if( baud == NULL )

   449   {

   450     MSG("can_copcican_comedi: canChangeBaudRate_driver(): baud is NULL\n");

   451     return 1;

   452   }

   453 

   454   memset( &board, 0x00, sizeof(s_BOARD) );

   455   board.baudrate = baud;

   456 

   457   if( co_pcican_configure_selected_channel( dev, &board, RX ) < 0 )

   458     ret = 1;

   459 

   460   if( co_pcican_configure_selected_channel( dev, &board, TX ) < 0 )

   461     ret = 1;

   462 

   463   return ret;

   464 }

   465 

   466 static int init(void)

   467 {

   468   printk("can_copcican_comedi for CanFestival loaded\n");

   469 

   470   return 0;

   471 }

   472 

   473 static void exit(void)

   474 {

   475   printk("can_copcican_comedi unloaded\n");

   476 }

   477 

   478 module_init(init);

   479 module_exit(exit);

   480 

   481 EXPORT_SYMBOL(get_dev_of_port);

   482 EXPORT_SYMBOL(co_pcican_enter_run_mode);

   483 EXPORT_SYMBOL(co_pcican_enter_config_mode);

   484 EXPORT_SYMBOL(co_pcican_select_channel);

   485 EXPORT_SYMBOL(co_pcican_configure_selected_channel);

   486 EXPORT_SYMBOL(canOpen_driver);

   487 EXPORT_SYMBOL(canClose_driver);

   488 EXPORT_SYMBOL(canSend_driver);

   489 EXPORT_SYMBOL(canReceive_driver);

   490 EXPORT_SYMBOL(canChangeBaudRate_driver);