CanFestival: /home/epimerde/documents/tc11/CanFestival-3/drivers/unix/unix.c Source File

00001 /*
+00002 This file is part of CanFestival, a library implementing CanOpen Stack. 
+00003 
+00004 Copyright (C): Edouard TISSERANT and Francis DUPIN
+00005 
+00006 See COPYING file for copyrights details.
+00007 
+00008 This library is free software; you can redistribute it and/or
+00009 modify it under the terms of the GNU Lesser General Public
+00010 License as published by the Free Software Foundation; either
+00011 version 2.1 of the License, or (at your option) any later version.
+00012 
+00013 This library is distributed in the hope that it will be useful,
+00014 but WITHOUT ANY WARRANTY; without even the implied warranty of
+00015 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+00016 Lesser General Public License for more details.
+00017 
+00018 You should have received a copy of the GNU Lesser General Public
+00019 License along with this library; if not, write to the Free Software
+00020 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+00021 */
+00022 #include <unistd.h>
+00023 #include <stdio.h>
+00024 #include <stdlib.h>
+00025 
+00026 #ifndef NOT_USE_DYNAMIC_LOADING
+00027 #define DLL_CALL(funcname) (* funcname##_driver)
+00028 #define FCT_PTR_INIT =NULL
+00029 
+00030 #define DLSYM(name)\
+00031         *(void **) (&name##_driver) = dlsym(handle, #name"_driver");\
+00032         if ((error = dlerror()) != NULL)  {\
+00033                 fprintf (stderr, "%s\n", error);\
+00034                 UnLoadCanDriver(handle);\
+00035                 return NULL;\
+00036         }
+00037 
+00038 #else /*NOT_USE_DYNAMIC_LOADING*/
+00039 
+00040 /*Function call is direct*/
+00041 #define DLL_CALL(funcname) funcname##_driver
+00042 
+00043 #endif /*NOT_USE_DYNAMIC_LOADING*/
+00044 
+00045 #include "data.h"
+00046 #include "canfestival.h"
+00047 #include "timers_driver.h"
+00048 
+00049 #define MAX_NB_CAN_PORTS 16
+00050 
+00051 typedef struct {
+00052   char used;
+00053   CAN_HANDLE fd;
+00054   TASK_HANDLE receiveTask;
+00055   CO_Data* d;
+00056 } CANPort;
+00057 
+00058 #include "can_driver.h"
+00059 
+00060 /*Declares the funtion pointers for dll binding or simple protos*/
+00061 /*UNS8 DLL_CALL(canReceive)(CAN_HANDLE, Message *);
+00062 UNS8 DLL_CALL(canSend)(CAN_HANDLE, Message *);
+00063 CAN_HANDLE DLL_CALL(canOpen)(s_BOARD *);
+00064 int DLL_CALL(canClose)(CAN_HANDLE);
+00065 */
+00066 CANPort canports[MAX_NB_CAN_PORTS] = {{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,}};
+00067 
+00068 #ifndef NOT_USE_DYNAMIC_LOADING
+00069 
+00070 /*UnLoads the dll*/
+00071 UNS8 UnLoadCanDriver(LIB_HANDLE handle)
+00072 {
+00073         if(handle!=NULL)
+00074         {
+00075                 dlclose(handle);
+00076 
+00077                 handle=NULL;
+00078                 return 0;
+00079         }
+00080         return -1;
+00081 }
+00082 
+00083 /*Loads the dll and get funcs ptr*/
+00084 LIB_HANDLE LoadCanDriver(char* driver_name)
+00085 {
+00086         LIB_HANDLE handle = NULL;
+00087         char *error;
+00088         
+00089 
+00090         if(handle==NULL)
+00091         {
+00092                 handle = dlopen(driver_name, RTLD_LAZY);
+00093         }
+00094 
+00095         if (!handle) {
+00096                 fprintf (stderr, "%s\n", dlerror());
+00097                 return NULL;
+00098         }
+00099  
+00100         /*Get function ptr*/
+00101         DLSYM(canReceive)
+00102         DLSYM(canSend)
+00103         DLSYM(canOpen)
+00104         DLSYM(canClose)
+00105 
+00106         return handle;
+00107 }
+00108 
+00109 #endif
+00110 
+00111 
+00112 
+00113 /*Not needed -- canReceiveLoop calls _canReceive directly *//*
+00114 UNS8 canReceive(CAN_PORT port, Message *m)
+00115 {
+00116         return DLL_CALL(canReceive)(port->fd, Message *m);
+00117 }
+00118 */
+00119 
+00120 UNS8 canSend(CAN_PORT port, Message *m)
+00121 {
+00122         if(port){
+00123                 UNS8 res;
+00124                 //LeaveMutex();
+00125                 res = DLL_CALL(canSend)(((CANPort*)port)->fd, m);
+00126                 //EnterMutex();
+00127                 return res;
+00128         }               
+00129         return -1;
+00130 }
+00131 
+00132 void canReceiveLoop(CAN_PORT port)
+00133 {
+00134        Message m;
+00135 
+00136        while (1) {
+00137                if (DLL_CALL(canReceive)(((CANPort*)port)->fd, &m) != 0)
+00138                        break;
+00139 
+00140                EnterMutex();
+00141                canDispatch(((CANPort*)port)->d, &m);
+00142                LeaveMutex();
+00143        }
+00144 }
+00145 CAN_PORT canOpen(s_BOARD *board, CO_Data * d)
+00146 {
+00147         int i;
+00148         for(i=0; i < MAX_NB_CAN_PORTS; i++)
+00149         {
+00150                 if(!canports[i].used)
+00151                 break;
+00152         }
+00153         
+00154 #ifndef NOT_USE_DYNAMIC_LOADING
+00155         if (&DLL_CALL(canOpen)==NULL) {
+00156                 fprintf(stderr,"CanOpen : Can Driver dll not loaded\n");
+00157                 return NULL;
+00158         }
+00159 #endif  
+00160         CAN_HANDLE fd0 = DLL_CALL(canOpen)(board);
+00161         if(fd0){
+00162                 canports[i].used = 1;
+00163                 canports[i].fd = fd0;
+00164                 canports[i].d = d;
+00165         
+00166                 CreateReceiveTask(&(canports[i]), &canports[i].receiveTask, &canReceiveLoop);
+00167                 
+00168                 EnterMutex();
+00169                 d->canHandle = (CAN_PORT)&canports[i];
+00170                 LeaveMutex();
+00171                 return (CAN_PORT)&canports[i];
+00172         }else{
+00173                 fprintf(stderr,"CanOpen : Cannot open board {busname='%s',baudrate='%s'}\n",board->busname, board->baudrate);
+00174                 return NULL;
+00175         }
+00176 }
+00177 
+00178 int canClose(CO_Data * d)
+00179 {
+00180         EnterMutex();
+00181         ((CANPort*)d->canHandle)->used = 0;
+00182         CANPort* tmp = (CANPort*)d->canHandle;
+00183         d->canHandle = NULL;
+00184         LeaveMutex();
+00185         
+00186         int res = DLL_CALL(canClose)(tmp->fd);
+00187         
+00188         WaitReceiveTaskEnd(tmp->receiveTask);
+00189         return res;
+00190 }
+