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

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

/**

    84

 * Loads the dll and get funcs ptr

    85

 *

    86

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

    87

 * @return Library handle

    88

 */

    89

LIB_HANDLE LoadCanDriver(const char* driver_name)

    90

{

    91

	LIB_HANDLE handle = NULL;

    92

	char *error;

    93

    94

    95

	if(handle==NULL)

    96

	{

    97

		handle = dlopen(driver_name, RTLD_LAZY);

    98

	}

    99

   100

	if (!handle) {

   101

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

   102

        	return NULL;

   103

	}

   104

   105

	/*Get function ptr*/

   106

	DLSYM(canReceive)

   107

	DLSYM(canSend)

   108

	DLSYM(canOpen)

   109

	DLSYM(canChangeBaudRate)

   110

	DLSYM(canClose)

   111

   112

	return handle;

   113

}

   114

   115

#endif

   116

   117

/**

   118

 * CAN send routine

   119

 * @param port CAN port

   120

 * @param m CAN message

   121

 * @return success or error

   122

 */

   123

UNS8 canSend(CAN_PORT port, Message *m)

   124

{

   125

	if(port){

   126

		UNS8 res;

   127

	        //LeaveMutex();

   128

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

   129

		//EnterMutex();

   130

		return res; // OK

   131

	}

   132

	return 1; // NOT OK

   133

}

   134

   135

/**

   136

 * CAN Receiver Task

   137

 * @param port CAN port

   138

 */

   139

void canReceiveLoop(CAN_PORT port)

   140

{

   141

       Message m;

   142

   143

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

   144

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

   145

                       break;

   146

   147

               EnterMutex();

   148

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

   149

               LeaveMutex();

   150

       }

   151

}

   152

   153

/**

   154

 * CAN open routine

   155

 * @param board device name and baudrate

   156

 * @param d CAN object data

   157

 * @return valid CAN_PORT pointer or NULL

   158

 */

   159

CAN_PORT canOpen(s_BOARD *board, CO_Data * d)

   160

{

   161

	int i;

   162

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

   163

	{

   164

		if(!canports[i].used)

   165

		break;

   166

	}

   167

   168

#ifndef NOT_USE_DYNAMIC_LOADING

   169

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

   170

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

   171

        	return NULL;

   172

	}

   173

#endif

   174

	CAN_HANDLE fd0 = DLL_CALL(canOpen)(board);

   175

	if(fd0){

   176

		canports[i].used = 1;

   177

		canports[i].fd = fd0;

   178

		canports[i].d = d;

   179

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

   180

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

   181

		return (CAN_PORT)&canports[i];

   182

	}else{

   183

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

   184

		return NULL;

   185

	}

   186

}

   187

   188

/**

   189

 * CAN close routine

   190

 * @param d CAN object data

   191

 * @return success or error

   192

 */

   193

int canClose(CO_Data * d)

   194

{

   195

	int res = 0;

   196

   197

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

   198

    if(port){

   199

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

   200

   201

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

   202

   203

        WaitReceiveTaskEnd(&port->receiveTask);

   204

   205

        d->canHandle = NULL;

   206

    }

   207

   208

	return res;

   209

}

   210

   211

   212

/**

   213

 * CAN change baudrate routine

   214

 * @param port CAN port

   215

 * @param baud baudrate

   216

 * @return success or error

   217

 */

   218

UNS8 canChangeBaudRate(CAN_PORT port, char* baud)

   219

{

   220

   if(port){

   221

		UNS8 res;

   222

	    //LeaveMutex();

   223

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

   224

		//EnterMutex();

   225

		return res; // OK

   226

	}

   227

	return 1; // NOT OK

   228

}

   229

   230

   231

#ifdef __KERNEL__

   232

EXPORT_SYMBOL (canOpen);

   233

EXPORT_SYMBOL (canClose);

   234

EXPORT_SYMBOL (canSend);

   235

EXPORT_SYMBOL (canChangeBaudRate);

   236

#endif