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

/** CAN port structure */

    56

typedef struct {

    57

  char used;  /**< flag indicating CAN port usage, will be used to abort Receiver task*/

    58

  CAN_HANDLE fd; /**< CAN port file descriptor*/

    59

  TASK_HANDLE receiveTask; /**< CAN Receiver task*/

    60

  CO_Data* d; /**< CAN object data*/

    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

    88

/**

    89

 * Loads the dll and get funcs ptr

    90

 *

    91

 * @param driver_name String containing driver's dynamic library name

    92

 * @return Library handle

    93

 */

    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

   131

/**

   132

 * CAN send routine

   133

 * @param port CAN port

   134

 * @param m CAN message

   135

 * @return success or error

   136

 */

   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

   149

/**

   150

 * CAN Receiver Task

   151

 * @param port CAN port

   152

 */

   153

void canReceiveLoop(CAN_PORT port)

   154

{

   155

       Message m;

   156

   157

       while (((CANPort*)port)->used) {

   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

}

   166

   167

/**

   168

 * CAN open routine

   169

 * @param board device name and baudrate

   170

 * @param d CAN object data

   171

 * @return valid CAN_PORT pointer or NULL

   172

 */

   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

   206

/**

   207

 * CAN close routine

   208

 * @param d CAN object data

   209

 * @return success or error

   210

 */

   211

int canClose(CO_Data * d)

   212

{

   213

	UNS8 res;

   214

   215

	EnterMutex();

   216

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

   217

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

   218

	d->canHandle = NULL;

   219

	LeaveMutex();

   220

   221

	// close CAN port

   222

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

   223

   224

	// kill receiver task

   225

	WaitReceiveTaskEnd(&tmp->receiveTask);

   226

   227

	return res;

   228

}

   229

   230

   231

/**

   232

 * CAN change baudrate routine

   233

 * @param port CAN port

   234

 * @param baud baudrate

   235

 * @return success or error

   236

 */

   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