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 #include <unistd.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25
  26 #ifndef NOT_USE_DYNAMIC_LOADING
  27 #define DLL_CALL(funcname) (* funcname##_driver)
  28 #define FCT_PTR_INIT =NULL
  29
  30 #define DLSYM(name)\
  31         *(void **) (&name##_driver) = dlsym(handle, #name"_driver");\
  32         if ((error = dlerror()) != NULL)  {\
  33                 fprintf (stderr, "%s\n", error);\
  34                 UnLoadCanDriver(handle);\
  35                 return NULL;\
  36         }
  37
  38 #else /*NOT_USE_DYNAMIC_LOADING*/
  39
  40 /*Function call is direct*/
  41 #define DLL_CALL(funcname) funcname##_driver
  42
  43 #endif /*NOT_USE_DYNAMIC_LOADING*/
  44
  45 #include "data.h"
  46 #include "canfestival.h"
  47 #include "timers_driver.h"
  48
  49 #define MAX_NB_CAN_PORTS 16
  50
  51 typedef struct {
  52   char used;
  53   CAN_HANDLE fd;
  54   TASK_HANDLE receiveTask;
  55   CO_Data* d;
  56 } CANPort;
  57
  58 #include "can_driver.h"
  59
  60 /*Declares the funtion pointers for dll binding or simple protos*/
  61 /*UNS8 DLL_CALL(canReceive)(CAN_HANDLE, Message *);
  62 UNS8 DLL_CALL(canSend)(CAN_HANDLE, Message *);
  63 CAN_HANDLE DLL_CALL(canOpen)(s_BOARD *);
  64 int DLL_CALL(canClose)(CAN_HANDLE);
  65 */
  66 CANPort canports[MAX_NB_CAN_PORTS] = {{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,}};
  67
  68 #ifndef NOT_USE_DYNAMIC_LOADING
  69
  70 /*UnLoads the dll*/
  71 UNS8 UnLoadCanDriver(LIB_HANDLE handle)
  72 {
  73         if(handle!=NULL)
  74         {
  75                 dlclose(handle);
  76
  77                 handle=NULL;
  78                 return 0;
  79         }
  80         return -1;
  81 }
  82
  83 /*Loads the dll and get funcs ptr*/
  84 LIB_HANDLE LoadCanDriver(char* driver_name)
  85 {
  86         LIB_HANDLE handle = NULL;
  87         char *error;
  88
  89
  90         if(handle==NULL)
  91         {
  92                 handle = dlopen(driver_name, RTLD_LAZY);
  93         }
  94
  95         if (!handle) {
  96                 fprintf (stderr, "%s\n", dlerror());
  97                 return NULL;
  98         }
  99
 100         /*Get function ptr*/
 101         DLSYM(canReceive)
 102         DLSYM(canSend)
 103         DLSYM(canOpen)
 104         DLSYM(canClose)
 105
 106         return handle;
 107 }
 108
 109 #endif
 110
 111
 112
 113 /*Not needed -- canReceiveLoop calls _canReceive directly *//*
 114 UNS8 canReceive(CAN_PORT port, Message *m)
 115 {
 116         return DLL_CALL(canReceive)(port->fd, Message *m);
 117 }
 118 */
 119
 120 UNS8 canSend(CAN_PORT port, Message *m)
 121 {
 122         if(port){
 123                 UNS8 res;
 124                 //LeaveMutex();
 125                 res = DLL_CALL(canSend)(((CANPort*)port)->fd, m);
 126                 //EnterMutex();
 127                 return res; // OK
 128         }
 129         return 1; // NOT OK
 130 }
 131
 132 void canReceiveLoop(CAN_PORT port)
 133 {
 134        Message m;
 135
 136        while (1) {
 137                if (DLL_CALL(canReceive)(((CANPort*)port)->fd, &m) != 0)
 138                        break;
 139
 140                EnterMutex();
 141                canDispatch(((CANPort*)port)->d, &m);
 142                LeaveMutex();
 143        }
 144 }
 145 CAN_PORT canOpen(s_BOARD *board, CO_Data * d)
 146 {
 147         int i;
 148         for(i=0; i < MAX_NB_CAN_PORTS; i++)
 149         {
 150                 if(!canports[i].used)
 151                 break;
 152         }
 153
 154 #ifndef NOT_USE_DYNAMIC_LOADING
 155         if (&DLL_CALL(canOpen)==NULL) {
 156                 fprintf(stderr,"CanOpen : Can Driver dll not loaded\n");
 157                 return NULL;
 158         }
 159 #endif
 160         CAN_HANDLE fd0 = DLL_CALL(canOpen)(board);
 161         if(fd0){
 162                 canports[i].used = 1;
 163                 canports[i].fd = fd0;
 164                 canports[i].d = d;
 165
 166                 CreateReceiveTask(&(canports[i]), &canports[i].receiveTask, &canReceiveLoop);
 167
 168                 EnterMutex();
 169                 d->canHandle = (CAN_PORT)&canports[i];
 170                 LeaveMutex();
 171                 return (CAN_PORT)&canports[i];
 172         }else{
 173                 fprintf(stderr,"CanOpen : Cannot open board {busname='%s',baudrate='%s'}\n",board->busname, board->baudrate);
 174                 return NULL;
 175         }
 176 }
 177
 178 int canClose(CO_Data * d)
 179 {
 180         EnterMutex();
 181         ((CANPort*)d->canHandle)->used = 0;
 182         CANPort* tmp = (CANPort*)d->canHandle;
 183         d->canHandle = NULL;
 184         LeaveMutex();
 185
 186         int res = DLL_CALL(canClose)(tmp->fd);
 187
 188         WaitReceiveTaskEnd(tmp->receiveTask);
 189         return res;
 190 }