Mercurial Mercurial > canfestival / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
drivers/unix/unix.c
changeset 629 b9274b595650
parent 480 d0d76932ad74
child 644 11b21e9a92f6
equal deleted inserted replaced
628:9e496a2aadca 629:b9274b595650 
     1 /*
 
     1 /*
 
     2 This file is part of CanFestival, a library implementing CanOpen Stack. 
     2 This file is part of CanFestival, a library implementing CanOpen Stack.
 
     3 
     3 
     4 Copyright (C): Edouard TISSERANT and Francis DUPIN
 
     4 Copyright (C): Edouard TISSERANT and Francis DUPIN
 
     5 
     5 
     6 See COPYING file for copyrights details.
 
     6 See COPYING file for copyrights details.
 
     7 
     7 
    24 #include <stdio.h>
 
    24 #include <stdio.h>
 
    25 #include <stdlib.h>
 
    25 #include <stdlib.h>
 
    26 #else
 
    26 #else
 
    27 #include <linux/module.h>
 
    27 #include <linux/module.h>
 
    28 #endif
 
    28 #endif
 
       
    29 #include <linux/delay.h>
 
    29 
    30 
    30 #ifndef NOT_USE_DYNAMIC_LOADING
 
    31 #ifndef NOT_USE_DYNAMIC_LOADING
 
    31 #define DLL_CALL(funcname) (* funcname##_driver)
 
    32 #define DLL_CALL(funcname) (* funcname##_driver)
 
    32 #define FCT_PTR_INIT =NULL
 
    33 #define FCT_PTR_INIT =NULL
 
    33 
    34 
    93  */
 
    94  */
 
    94 LIB_HANDLE LoadCanDriver(const char* driver_name)
 
    95 LIB_HANDLE LoadCanDriver(const char* driver_name)
 
    95 {
 
    96 {
 
    96 	LIB_HANDLE handle = NULL;
 
    97 	LIB_HANDLE handle = NULL;
 
    97 	char *error;
 
    98 	char *error;
 
    98 	
    99 
    99 
   100 
   100 	if(handle==NULL)
 
   101 	if(handle==NULL)
 
   101 	{
 
   102 	{
 
   102 		handle = dlopen(driver_name, RTLD_LAZY);
 
   103 		handle = dlopen(driver_name, RTLD_LAZY);
 
   103 	}
 
   104 	}
 
   104 
   105 
   105 	if (!handle) {
 
   106 	if (!handle) {
 
   106 		fprintf (stderr, "%s\n", dlerror());
 
   107 		fprintf (stderr, "%s\n", dlerror());
 
   107         	return NULL;
 
   108         	return NULL;
 
   108 	}
 
   109 	}
 
   109  
   110 
   110 	/*Get function ptr*/
 
   111 	/*Get function ptr*/
 
   111 	DLSYM(canReceive)
 
   112 	DLSYM(canReceive)
 
   112 	DLSYM(canSend)
 
   113 	DLSYM(canSend)
 
   113 	DLSYM(canOpen)
 
   114 	DLSYM(canOpen)
 
   114 	DLSYM(canChangeBaudRate)
 
   115 	DLSYM(canChangeBaudRate)
 
   140 		UNS8 res;
 
   141 		UNS8 res;
 
   141 	        //LeaveMutex();
 
   142 	        //LeaveMutex();
 
   142 		res = DLL_CALL(canSend)(((CANPort*)port)->fd, m);
 
   143 		res = DLL_CALL(canSend)(((CANPort*)port)->fd, m);
 
   143 		//EnterMutex();
 
   144 		//EnterMutex();
 
   144 		return res; // OK
 
   145 		return res; // OK
 
   145 	}               
   146 	}
 
   146 	return 1; // NOT OK
 
   147 	return 1; // NOT OK
 
   147 }
 
   148 }
 
   148 
   149 
   149 /**
 
   150 /**
 
   150  * CAN Receiver Task
 
   151  * CAN Receiver Task
 
   159                        break;
 
   160                        break;
 
   160 
   161 
   161                EnterMutex();
 
   162                EnterMutex();
 
   162                canDispatch(((CANPort*)port)->d, &m);
 
   163                canDispatch(((CANPort*)port)->d, &m);
 
   163                LeaveMutex();
 
   164                LeaveMutex();
 
       
   165 
       
   166 #ifdef __KERNEL__
 
       
   167 #ifdef USE_XENO
 
       
   168                /* periodic task for Xenomai kernel realtime */
 
       
   169                rt_task_wait_period(NULL);
 
       
   170 #endif
 
       
   171 #endif
 
   164        }
 
   172        }
 
   165 }
 
   173 }
 
   166 
   174 
   167 /**
 
   175 /**
 
   168  * CAN open routine
 
   176  * CAN open routine
 
   176 	for(i=0; i < MAX_NB_CAN_PORTS; i++)
 
   184 	for(i=0; i < MAX_NB_CAN_PORTS; i++)
 
   177 	{
 
   185 	{
 
   178 		if(!canports[i].used)
 
   186 		if(!canports[i].used)
 
   179 		break;
 
   187 		break;
 
   180 	}
 
   188 	}
 
   181 	
   189 
   182 #ifndef NOT_USE_DYNAMIC_LOADING
 
   190 #ifndef NOT_USE_DYNAMIC_LOADING
 
   183 	if (&DLL_CALL(canOpen)==NULL) {
 
   191 	if (&DLL_CALL(canOpen)==NULL) {
 
   184         	fprintf(stderr,"CanOpen : Can Driver dll not loaded\n");
 
   192         	fprintf(stderr,"CanOpen : Can Driver dll not loaded\n");
 
   185         	return NULL;
 
   193         	return NULL;
 
   186 	}
 
   194 	}
 
   187 #endif	
   195 #endif
 
   188 	CAN_HANDLE fd0 = DLL_CALL(canOpen)(board);
 
   196 	CAN_HANDLE fd0 = DLL_CALL(canOpen)(board);
 
   189 	if(fd0){
 
   197 	if(fd0){
 
   190 		canports[i].used = 1;
 
   198 		canports[i].used = 1;
 
   191 		canports[i].fd = fd0;
 
   199 		canports[i].fd = fd0;
 
   192 		canports[i].d = d;
 
   200 		canports[i].d = d;
 
   193 		d->canHandle = (CAN_PORT)&canports[i];		
   201 		d->canHandle = (CAN_PORT)&canports[i];
 
   194 		CreateReceiveTask(&(canports[i]), &canports[i].receiveTask, &canReceiveLoop);
 
   202 		CreateReceiveTask(&(canports[i]), &canports[i].receiveTask, &canReceiveLoop);
 
   195 		return (CAN_PORT)&canports[i];
 
   203 		return (CAN_PORT)&canports[i];
 
   196 	}else{
 
   204 	}else{
 
   197         	MSG("CanOpen : Cannot open board {busname='%s',baudrate='%s'}\n",board->busname, board->baudrate);
 
   205         	MSG("CanOpen : Cannot open board {busname='%s',baudrate='%s'}\n",board->busname, board->baudrate);
 
   198 		return NULL;
 
   206 		return NULL;
 
   205  * @return success or error
 
   213  * @return success or error
 
   206  */
 
   214  */
 
   207 int canClose(CO_Data * d)
 
   215 int canClose(CO_Data * d)
 
   208 {
 
   216 {
 
   209 	UNS8 res;
 
   217 	UNS8 res;
 
   210 	
   218 
   211 	((CANPort*)d->canHandle)->used = 0;
 
   219 	((CANPort*)d->canHandle)->used = 0;
 
   212 	CANPort* tmp = (CANPort*)d->canHandle;
 
   220 	CANPort* tmp = (CANPort*)d->canHandle;
 
   213 	d->canHandle = NULL;
 
   221 
   214 	
   222 	// kill receiver task before port is closed and handle set to NULL
 
       
   223 	WaitReceiveTaskEnd(&tmp->receiveTask);
 
       
   224 
   215 	// close CAN port
 
   225 	// close CAN port
 
   216 	res = DLL_CALL(canClose)(tmp->fd);
 
   226 	res = DLL_CALL(canClose)(tmp->fd);
 
   217 
   227 
   218 	// kill receiver task
 
   228 	d->canHandle = NULL;
 
   219 	WaitReceiveTaskEnd(&tmp->receiveTask);
 
   229 
   220 	
       
   221 	return res;
 
   230 	return res;
 
   222 }
 
   231 }
 
   223 
   232 
   224 
   233 
   225 /**
 
   234 /**
 
   234 		UNS8 res;
 
   243 		UNS8 res;
 
   235 	        //LeaveMutex();
 
   244 	        //LeaveMutex();
 
   236 		res = DLL_CALL(canChangeBaudRate)(((CANPort*)port)->fd, baud);
 
   245 		res = DLL_CALL(canChangeBaudRate)(((CANPort*)port)->fd, baud);
 
   237 		//EnterMutex();
 
   246 		//EnterMutex();
 
   238 		return res; // OK
 
   247 		return res; // OK
 
   239 	}               
   248 	}
 
   240 	return 1; // NOT OK
 
   249 	return 1; // NOT OK
 
   241 }
 
   250 }
 
   242 
   251 
   243 
   252 
   244 #ifdef __KERNEL__
 
   253 #ifdef __KERNEL__
canfestival