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

    55

typedef struct {

    56

  char used;

    57

  CAN_HANDLE fd;

    58

  TASK_HANDLE receiveTask;

    59

  CO_Data* d;

    60

} CANPort;

    61

    62

#include "can_driver.h"

    63

    64

/*Declares the funtion pointers for dll binding or simple protos*/

    65

/*UNS8 DLL_CALL(canReceive)(CAN_HANDLE, Message *);

    66

UNS8 DLL_CALL(canSend)(CAN_HANDLE, Message *);

    67

CAN_HANDLE DLL_CALL(canOpen)(s_BOARD *);

    68

int DLL_CALL(canClose)(CAN_HANDLE);

    69

*/

    70

CANPort canports[MAX_NB_CAN_PORTS] = {{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,},{0,}};

    71

    72

#ifndef NOT_USE_DYNAMIC_LOADING

    73

    74

/*UnLoads the dll*/

    75

UNS8 UnLoadCanDriver(LIB_HANDLE handle)

    76

{

    77

	if(handle!=NULL)

    78

	{

    79

		dlclose(handle);

    80

    81

		handle=NULL;

    82

		return 0;

    83

	}

    84

	return -1;

    85

}

    86

    87

/*Loads the dll and get funcs ptr*/

    88

LIB_HANDLE LoadCanDriver(char* driver_name)

    89

{

    90

	LIB_HANDLE handle = NULL;

    91

	char *error;

    92

    93

    94

	if(handle==NULL)

    95

	{

    96

		handle = dlopen(driver_name, RTLD_LAZY);

    97

	}

    98

    99

	if (!handle) {

   100

		fprintf (stderr, "%s\n", dlerror());

   101

        	return NULL;

   102

	}

   103

   104

	/*Get function ptr*/

   105

	DLSYM(canReceive)

   106

	DLSYM(canSend)

   107

	DLSYM(canOpen)

   108

	DLSYM(canChangeBaudRate)

   109

	DLSYM(canClose)

   110

   111

	return handle;

   112

}

   113

   114

#endif

   115

   116

   117

   118

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

   119

UNS8 canReceive(CAN_PORT port, Message *m)

   120

{

   121

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

   122

}

   123

*/

   124

   125

UNS8 canSend(CAN_PORT port, Message *m)

   126

{

   127

	if(port){

   128

		UNS8 res;

   129

	        //LeaveMutex();

   130

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

   131

		//EnterMutex();

   132

		return res; // OK

   133

	}               

   134

	return 1; // NOT OK

   135

}

   136

   137

void canReceiveLoop(CAN_PORT port)

   138

{

   139

       Message m;

   140

   141

       while (1) {

   142

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

   143

                       break;

   144

   145

               EnterMutex();

   146

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

   147

               LeaveMutex();

   148

       }

   149

}

   150

CAN_PORT canOpen(s_BOARD *board, CO_Data * d)

   151

{

   152

	int i;

   153

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

   154

	{

   155

		if(!canports[i].used)

   156

		break;

   157

	}

   158

   159

#ifndef NOT_USE_DYNAMIC_LOADING

   160

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

   161

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

   162

        	return NULL;

   163

	}

   164

#endif	

   165

	CAN_HANDLE fd0 = DLL_CALL(canOpen)(board);

   166

	if(fd0){

   167

		canports[i].used = 1;

   168

		canports[i].fd = fd0;

   169

		canports[i].d = d;

   170

   171

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

   172

   173

		EnterMutex();

   174

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

   175

		LeaveMutex();

   176

		return (CAN_PORT)&canports[i];

   177

	}else{

   178

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

   179

		return NULL;

   180

	}

   181

}

   182

   183

int canClose(CO_Data * d)

   184

{

   185

	EnterMutex();

   186

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

   187

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

   188

	d->canHandle = NULL;

   189

	LeaveMutex();

   190

   191

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

   192

   193

	WaitReceiveTaskEnd(&tmp->receiveTask);

   194

	return res;

   195

}

   196

   197

   198

UNS8 canChangeBaudRate(CAN_PORT port, char* baud)

   199

{

   200

   if(port){

   201

		UNS8 res;

   202

	        //LeaveMutex();

   203

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

   204

		//EnterMutex();

   205

		return res; // OK

   206

	}               

   207

	return 1; // NOT OK

   208

}

   209

   210

   211

#ifdef __KERNEL__

   212

EXPORT_SYMBOL (canOpen);

   213

EXPORT_SYMBOL (canClose);

   214

EXPORT_SYMBOL (canSend);

   215

#endif