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

#include <linux/delay.h>

    29

#endif

    30

    31

#ifndef NOT_USE_DYNAMIC_LOADING

    32

#define DLL_CALL(funcname) (* funcname##_driver)

    33

#define FCT_PTR_INIT =NULL

    34

    35

#define DLSYM(name)\

    36

	*(void **) (&name##_driver) = dlsym(handle, #name"_driver");\

    37

	if ((error = dlerror()) != NULL)  {\

    38

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

    39

		UnLoadCanDriver(handle);\

    40

		return NULL;\

    41

	}

    42

    43

#else /*NOT_USE_DYNAMIC_LOADING*/

    44

    45

/*Function call is direct*/

    46

#define DLL_CALL(funcname) funcname##_driver

    47

    48

#endif /*NOT_USE_DYNAMIC_LOADING*/

    49

    50

#include "data.h"

    51

#include "canfestival.h"

    52

#include "timers_driver.h"

    53

    54

#define MAX_NB_CAN_PORTS 16

    55

    56

/** CAN port structure */

    57

typedef struct {

    58

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

    59

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

    60

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

    61

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

    62

} CANPort;

    63

    64

#include "can_driver.h"

    65

    66

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

    67

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

    68

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

    69

CAN_HANDLE DLL_CALL(canOpen)(s_BOARD *);

    70

int DLL_CALL(canClose)(CAN_HANDLE);

    71

*/

    72

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

    73

    74

#ifndef NOT_USE_DYNAMIC_LOADING

    75

    76

/*UnLoads the dll*/

    77

UNS8 UnLoadCanDriver(LIB_HANDLE handle)

    78

{

    79

	if(handle!=NULL)

    80

	{

    81

		dlclose(handle);

    82

    83

		handle=NULL;

    84

		return 0;

    85

	}

    86

	return -1;

    87

}

    88

    89

/**

    90

 * Loads the dll and get funcs ptr

    91

 *

    92

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

    93

 * @return Library handle

    94

 */

    95

LIB_HANDLE LoadCanDriver(const char* driver_name)

    96

{

    97

	LIB_HANDLE handle = NULL;

    98

	char *error;

    99

   100

   101

	if(handle==NULL)

   102

	{

   103

		handle = dlopen(driver_name, RTLD_LAZY);

   104

	}

   105

   106

	if (!handle) {

   107

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

   108

        	return NULL;

   109

	}

   110

   111

	/*Get function ptr*/

   112

	DLSYM(canReceive)

   113

	DLSYM(canSend)

   114

	DLSYM(canOpen)

   115

	DLSYM(canChangeBaudRate)

   116

	DLSYM(canClose)

   117

   118

	return handle;

   119

}

   120

   121

#endif

   122

   123

   124

   125

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

   126

UNS8 canReceive(CAN_PORT port, Message *m)

   127

{

   128

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

   129

}

   130

*/

   131

   132

/**

   133

 * CAN send routine

   134

 * @param port CAN port

   135

 * @param m CAN message

   136

 * @return success or error

   137

 */

   138

UNS8 canSend(CAN_PORT port, Message *m)

   139

{

   140

	if(port){

   141

		UNS8 res;

   142

	        //LeaveMutex();

   143

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

   144

		//EnterMutex();

   145

		return res; // OK

   146

	}

   147

	return 1; // NOT OK

   148

}

   149

   150

/**

   151

 * CAN Receiver Task

   152

 * @param port CAN port

   153

 */

   154

void canReceiveLoop(CAN_PORT port)

   155

{

   156

       Message m;

   157

   158

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

   159

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

   160

                       break;

   161

   162

               EnterMutex();

   163

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

   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

   172

       }

   173

}

   174

   175

/**

   176

 * CAN open routine

   177

 * @param board device name and baudrate

   178

 * @param d CAN object data

   179

 * @return valid CAN_PORT pointer or NULL

   180

 */

   181

CAN_PORT canOpen(s_BOARD *board, CO_Data * d)

   182

{

   183

	int i;

   184

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

   185

	{

   186

		if(!canports[i].used)

   187

		break;

   188

	}

   189

   190

#ifndef NOT_USE_DYNAMIC_LOADING

   191

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

   192

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

   193

        	return NULL;

   194

	}

   195

#endif

   196

	CAN_HANDLE fd0 = DLL_CALL(canOpen)(board);

   197

	if(fd0){

   198

		canports[i].used = 1;

   199

		canports[i].fd = fd0;

   200

		canports[i].d = d;

   201

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

   202

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

   203

		return (CAN_PORT)&canports[i];

   204

	}else{

   205

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

   206

		return NULL;

   207

	}

   208

}

   209

   210

/**

   211

 * CAN close routine

   212

 * @param d CAN object data

   213

 * @return success or error

   214

 */

   215

int canClose(CO_Data * d)

   216

{

   217

	UNS8 res;

   218

   219

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

   220

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

   221

   222

	// kill receiver task before port is closed and handle set to NULL

   223

	WaitReceiveTaskEnd(&tmp->receiveTask);

   224

   225

	// close CAN port

   226

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

   227

   228

	d->canHandle = NULL;

   229

   230

	return res;

   231

}

   232

   233

   234

/**

   235

 * CAN change baudrate routine

   236

 * @param port CAN port

   237

 * @param baud baudrate

   238

 * @return success or error

   239

 */

   240

UNS8 canChangeBaudRate(CAN_PORT port, char* baud)

   241

{

   242

   if(port){

   243

		UNS8 res;

   244

	        //LeaveMutex();

   245

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

   246

		//EnterMutex();

   247

		return res; // OK

   248

	}

   249

	return 1; // NOT OK

   250

}

   251

   252

   253

#ifdef __KERNEL__

   254

EXPORT_SYMBOL (canOpen);

   255

EXPORT_SYMBOL (canClose);

   256

EXPORT_SYMBOL (canSend);

   257

EXPORT_SYMBOL (canChangeBaudRate);

   258

#endif