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

    56

typedef struct {

    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

    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

   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

   153

void canReceiveLoop(CAN_PORT port)

   154

{

   155

       Message m;

   156

   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

}

   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

   194

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

   195

   196

		EnterMutex();

   197

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

   198

		LeaveMutex();

   199

		return (CAN_PORT)&canports[i];

   200

	}else{

   201

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

   202

		return NULL;

   203

	}

   204

}

   205

   211

int canClose(CO_Data * d)

   212

{

   215

	EnterMutex();

   216

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

   217

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

   218

	d->canHandle = NULL;

   219

	LeaveMutex();

   220

   225

	WaitReceiveTaskEnd(&tmp->receiveTask);

   227

	return res;

   228

}

   229

   230

   237

UNS8 canChangeBaudRate(CAN_PORT port, char* baud)

   238

{

   239

   if(port){

   240

		UNS8 res;

   241

	        //LeaveMutex();

   242

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

   243

		//EnterMutex();

   244

		return res; // OK

   245

	}               

   246

	return 1; // NOT OK

   247

}

   248

   249

   250

#ifdef __KERNEL__

   251

EXPORT_SYMBOL (canOpen);

   252

EXPORT_SYMBOL (canClose);

   253

EXPORT_SYMBOL (canSend);

   254

#endif