drivers/unix/unix.c

   1 /*
   2 This file is part of CanFestival, a library implementing CanOpen Stack.
   3
   4 Copyright (C): Edouard TISSERANT and Francis DUPIN
   5
   6 See COPYING file for copyrights details.
   7
   8 This library is free software; you can redistribute it and/or
   9 modify it under the terms of the GNU Lesser General Public
  10 License as published by the Free Software Foundation; either
  11 version 2.1 of the License, or (at your option) any later version.
  12
  13 This library is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 Lesser General Public License for more details.
  17
  18 You should have received a copy of the GNU Lesser General Public
  19 License along with this library; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21 */
  22 #ifndef __KERNEL__
  23 #include <unistd.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #else
  27 #include <linux/module.h>
  28 #endif
  29
  30 #ifndef NOT_USE_DYNAMIC_LOADING
  31 #define DLL_CALL(funcname) (* funcname##_driver)
  32 #define FCT_PTR_INIT =NULL
  33
  34 #define DLSYM(name)\
  35         *(void **) (&name##_driver) = dlsym(handle, #name"_driver");\
  36         if ((error = dlerror()) != NULL)  {\
  37                 fprintf (stderr, "%s\n", error);\
  38                 UnLoadCanDriver(handle);\
  39                 return NULL;\
  40         }
  41
  42 #else /*NOT_USE_DYNAMIC_LOADING*/
  43
  44 /*Function call is direct*/
  45 #define DLL_CALL(funcname) funcname##_driver
  46
  47 #endif /*NOT_USE_DYNAMIC_LOADING*/
  48
  49 #include "data.h"
  50 #include "canfestival.h"
  51 #include "timers_driver.h"
  52
  53 #define MAX_NB_CAN_PORTS 16
  54
  55 /** CAN port structure */
  56 typedef struct {
  57   char used;  /**< flag indicating CAN port usage, will be used to abort Receiver task*/
  58   CAN_HANDLE fd; /**< CAN port file descriptor*/
  59   TASK_HANDLE receiveTask; /**< CAN Receiver task*/
  60   CO_Data* d; /**< CAN object data*/
  61 } CANPort;
  62
  63 #include "can_driver.h"
  64
  65 /*Declares the funtion pointers for dll binding or simple protos*/
  66 /*UNS8 DLL_CALL(canReceive)(CAN_HANDLE, Message *);
  67 UNS8 DLL_CALL(canSend)(CAN_HANDLE, Message *);
  68 CAN_HANDLE DLL_CALL(canOpen)(s_BOARD *);
  69 int DLL_CALL(canClose)(CAN_HANDLE);
  70 */
  71 CANPort canports[MAX_NB_CAN_PORTS] = {{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,}};
  72
  73 #ifndef NOT_USE_DYNAMIC_LOADING
  74
  75 /*UnLoads the dll*/
  76 UNS8 UnLoadCanDriver(LIB_HANDLE handle)
  77 {
  78         if(handle!=NULL)
  79         {
  80                 dlclose(handle);
  81
  82                 handle=NULL;
  83                 return 0;
  84         }
  85         return -1;
  86 }
  87
  88 /**
  89  * Loads the dll and get funcs ptr
  90  *
  91  * @param driver_name String containing driver's dynamic library name
  92  * @return Library handle
  93  */
  94 LIB_HANDLE LoadCanDriver(char* driver_name)
  95 {
  96         LIB_HANDLE handle = NULL;
  97         char *error;
  98
  99
 100         if(handle==NULL)
 101         {
 102                 handle = dlopen(driver_name, RTLD_LAZY);
 103         }
 104
 105         if (!handle) {
 106                 fprintf (stderr, "%s\n", dlerror());
 107                 return NULL;
 108         }
 109
 110         /*Get function ptr*/
 111         DLSYM(canReceive)
 112         DLSYM(canSend)
 113         DLSYM(canOpen)
 114         DLSYM(canChangeBaudRate)
 115         DLSYM(canClose)
 116
 117         return handle;
 118 }
 119
 120 #endif
 121
 122
 123
 124 /*Not needed -- canReceiveLoop calls _canReceive directly *//*
 125 UNS8 canReceive(CAN_PORT port, Message *m)
 126 {
 127         return DLL_CALL(canReceive)(port->fd, Message *m);
 128 }
 129 */
 130
 131 /**
 132  * CAN send routine
 133  * @param port CAN port
 134  * @param m CAN message
 135  * @return success or error
 136  */
 137 UNS8 canSend(CAN_PORT port, Message *m)
 138 {
 139         if(port){
 140                 UNS8 res;
 141                 //LeaveMutex();
 142                 res = DLL_CALL(canSend)(((CANPort*)port)->fd, m);
 143                 //EnterMutex();
 144                 return res; // OK
 145         }
 146         return 1; // NOT OK
 147 }
 148
 149 /**
 150  * CAN Receiver Task
 151  * @param port CAN port
 152  */
 153 void canReceiveLoop(CAN_PORT port)
 154 {
 155        Message m;
 156
 157        while (((CANPort*)port)->used) {
 158                if (DLL_CALL(canReceive)(((CANPort*)port)->fd, &m) != 0)
 159                        break;
 160
 161                EnterMutex();
 162                canDispatch(((CANPort*)port)->d, &m);
 163                LeaveMutex();
 164        }
 165 }
 166
 167 /**
 168  * CAN open routine
 169  * @param board device name and baudrate
 170  * @param d CAN object data
 171  * @return valid CAN_PORT pointer or NULL
 172  */
 173 CAN_PORT canOpen(s_BOARD *board, CO_Data * d)
 174 {
 175         int i;
 176         for(i=0; i < MAX_NB_CAN_PORTS; i++)
 177         {
 178                 if(!canports[i].used)
 179                 break;
 180         }
 181
 182 #ifndef NOT_USE_DYNAMIC_LOADING
 183         if (&DLL_CALL(canOpen)==NULL) {
 184                 fprintf(stderr,"CanOpen : Can Driver dll not loaded\n");
 185                 return NULL;
 186         }
 187 #endif
 188         CAN_HANDLE fd0 = DLL_CALL(canOpen)(board);
 189         if(fd0){
 190                 canports[i].used = 1;
 191                 canports[i].fd = fd0;
 192                 canports[i].d = d;
 193                 d->canHandle = (CAN_PORT)&canports[i];
 194                 CreateReceiveTask(&(canports[i]), &canports[i].receiveTask, &canReceiveLoop);
 195                 return (CAN_PORT)&canports[i];
 196         }else{
 197                 MSG("CanOpen : Cannot open board {busname='%s',baudrate='%s'}\n",board->busname, board->baudrate);
 198                 return NULL;
 199         }
 200 }
 201
 202 /**
 203  * CAN close routine
 204  * @param d CAN object data
 205  * @return success or error
 206  */
 207 int canClose(CO_Data * d)
 208 {
 209         UNS8 res;
 210
 211         ((CANPort*)d->canHandle)->used = 0;
 212         CANPort* tmp = (CANPort*)d->canHandle;
 213         d->canHandle = NULL;
 214
 215         // close CAN port
 216         res = DLL_CALL(canClose)(tmp->fd);
 217
 218         // kill receiver task
 219         WaitReceiveTaskEnd(&tmp->receiveTask);
 220
 221         return res;
 222 }
 223
 224
 225 /**
 226  * CAN change baudrate routine
 227  * @param port CAN port
 228  * @param baud baudrate
 229  * @return success or error
 230  */
 231 UNS8 canChangeBaudRate(CAN_PORT port, char* baud)
 232 {
 233    if(port){
 234                 UNS8 res;
 235                 //LeaveMutex();
 236                 res = DLL_CALL(canChangeBaudRate)(((CANPort*)port)->fd, baud);
 237                 //EnterMutex();
 238                 return res; // OK
 239         }
 240         return 1; // NOT OK
 241 }
 242
 243
 244 #ifdef __KERNEL__
 245 EXPORT_SYMBOL (canOpen);
 246 EXPORT_SYMBOL (canClose);
 247 EXPORT_SYMBOL (canSend);
 248 EXPORT_SYMBOL (canChangeBaudRate);
 249 #endif