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(canChangeBaudRate)

   105

	DLSYM(canClose)

   106

   107

	return handle;

   108

}

   109

   110

#endif

   111

   112

   113

   114

/*Not needed -- canReceiveLoop calls _canReceive directly *//*

   115

UNS8 canReceive(CAN_PORT port, Message *m)

   116

{

   117

	return DLL_CALL(canReceive)(port->fd, Message *m);

   118

}

   119

*/

   120

   121

UNS8 canSend(CAN_PORT port, Message *m)

   122

{

   123

	if(port){

   124

		UNS8 res;

   125

	        //LeaveMutex();

   126

		res = DLL_CALL(canSend)(((CANPort*)port)->fd, m);

   127

		//EnterMutex();

   128

		return res; // OK

   129

	}               

   130

	return 1; // NOT OK

   131

}

   132

   133

void canReceiveLoop(CAN_PORT port)

   134

{

   135

       Message m;

   136

   137

       while (1) {

   138

               if (DLL_CALL(canReceive)(((CANPort*)port)->fd, &m) != 0)

   139

                       break;

   140

   141

               EnterMutex();

   142

               canDispatch(((CANPort*)port)->d, &m);

   143

               LeaveMutex();

   144

       }

   145

}

   146

CAN_PORT canOpen(s_BOARD *board, CO_Data * d)

   147

{

   148

	int i;

   149

	for(i=0; i < MAX_NB_CAN_PORTS; i++)

   150

	{

   151

		if(!canports[i].used)

   152

		break;

   153

	}

   154

   155

#ifndef NOT_USE_DYNAMIC_LOADING

   156

	if (&DLL_CALL(canOpen)==NULL) {

   157

        	fprintf(stderr,"CanOpen : Can Driver dll not loaded\n");

   158

        	return NULL;

   159

	}

   160

#endif	

   161

	CAN_HANDLE fd0 = DLL_CALL(canOpen)(board);

   162

	if(fd0){

   163

		canports[i].used = 1;

   164

		canports[i].fd = fd0;

   165

		canports[i].d = d;

   166

   167

		CreateReceiveTask(&(canports[i]), &canports[i].receiveTask, &canReceiveLoop);

   168

   169

		EnterMutex();

   170

		d->canHandle = (CAN_PORT)&canports[i];

   171

		LeaveMutex();

   172

		return (CAN_PORT)&canports[i];

   173

	}else{

   174

        	fprintf(stderr,"CanOpen : Cannot open board {busname='%s',baudrate='%s'}\n",board->busname, board->baudrate);

   175

		return NULL;

   176

	}

   177

}

   178

   179

int canClose(CO_Data * d)

   180

{

   181

	EnterMutex();

   182

	((CANPort*)d->canHandle)->used = 0;

   183

	CANPort* tmp = (CANPort*)d->canHandle;

   184

	d->canHandle = NULL;

   185

	LeaveMutex();

   186

   187

	int res = DLL_CALL(canClose)(tmp->fd);

   188

   189

	WaitReceiveTaskEnd(tmp->receiveTask);

   190

	return res;

   191

}

   192

   193

   194

UNS8 canChangeBaudRate(CAN_PORT port, char* baud)

   195

{

   196

   if(port){

   197

		UNS8 res;

   198

	        //LeaveMutex();

   199

		res = DLL_CALL(canChangeBaudRate)(((CANPort*)port)->fd, baud);

   200

		//EnterMutex();

   201

		return res; // OK

   202

	}               

   203

	return 1; // NOT OK

   204

}