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

#include <unistd.h>

    23

#include <stdio.h>

    24

#include <stdlib.h>

    25

    26

#ifndef NOT_USE_DYNAMIC_LOADING

    27

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

    28

#define FCT_PTR_INIT =NULL

    29

    30

#ifdef WIN32

    31

#define DLSYM(name)\

    32

    *(void **) (&_##name) = GetProcAddress(handle, TEXT(#name"_driver"));\

    33

	if (name##_driver == NULL)  {\

    34

		fprintf (stderr, "Error loading symbol %s\n",#name"_driver");\

    35

		UnLoadCanDriver(handle);\

    36

		return NULL;\

    37

	}

    38

    39

#else

    40

#define DLSYM(name)\

    41

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

    42

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

    43

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

    44

		UnLoadCanDriver(handle);\

    45

		return NULL;\

    46

	}

    47

#endif

    48

    49

#else /*NOT_USE_DYNAMIC_LOADING*/

    50

    51

/*Function call is direct*/

    52

#define DLL_CALL(funcname) funcname##_driver

    53

    54

#endif /*NOT_USE_DYNAMIC_LOADING*/

    55

    56

#include "data.h"

    57

#include "canfestival.h"

    58

#include "timers_driver.h"

    59

    60

#define MAX_NB_CAN_PORTS 16

    61

    62

typedef struct {

    63

  char used;

    64

  CAN_HANDLE fd;

    65

  TASK_HANDLE receiveTask;

    66

  CO_Data* d;

    67

} CANPort;

    68

    69

#include "can_driver.h"

    70

    71

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

    72

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

    73

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

    74

CAN_HANDLE DLL_CALL(canOpen)(s_BOARD *);

    75

int DLL_CALL(canClose)(CAN_HANDLE);

    76

*/

    77

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

    78

    79

#ifndef NOT_USE_DYNAMIC_LOADING

    80

    81

/*UnLoads the dll*/

    82

UNS8 UnLoadCanDriver(LIB_HANDLE handle)

    83

{

    84

	if(handle!=NULL)

    85

	{

    86

#ifdef WIN32

    87

	        FreeLibrary(handle);    

    88

#else

    89

		dlclose(handle);

    90

#endif

    91

		handle=NULL;

    92

		return 0;

    93

	}

    94

	return -1;

    95

}

    96

    97

/*Loads the dll and get funcs ptr*/

    98

LIB_HANDLE LoadCanDriver(char* driver_name)

    99

{

   100

	LIB_HANDLE handle = NULL;

   101

	char *error;

   102

   103

#ifdef WIN32

   104

   105

	if(handle==NULL)

   106

	{

   107

		handle = LoadLibrary(driver_name);

   108

	}

   109

   110

	if (handle == NULL) {

   111

        	fprintf(stderr,"Error loading Can Driver dll \n");

   112

        	return -1;

   113

	}

   114

   115

#else

   116

	if(handle==NULL)

   117

	{

   118

		handle = dlopen(driver_name, RTLD_LAZY);

   119

	}

   120

   121

	if (!handle) {

   122

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

   123

        	return NULL;

   124

	}

   125

#endif

   126

   127

	/*Get function ptr*/

   128

	DLSYM(canReceive)

   129

	DLSYM(canSend)

   130

	DLSYM(canOpen)

   131

	DLSYM(canClose)

   132

   133

	return 0;

   134

}

   135

   136

#endif

   137

   138

   139

   140

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

   141

UNS8 canReceive(CAN_PORT port, Message *m)

   142

{

   143

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

   144

}

   145

*/

   146

   147

UNS8 canSend(CAN_PORT port, Message *m)

   148

{

   157

}

   158

   159

void canReceiveLoop(CAN_PORT port)

   160

{

   161

       Message m;

   162

   163

       while (1) {

   164

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

   165

                       break;

   166

   167

               EnterMutex();

   168

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

   169

               LeaveMutex();

   170

       }

   171

}

   172

CAN_PORT canOpen(s_BOARD *board, CO_Data * d)

   173

{

   174

	int i;

   175

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

   176

	{

   177

		if(!canports[i].used)

   178

		break;

   179

	}

   180

   181

#ifndef NOT_USE_DYNAMIC_LOADING

   182

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

   183

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

   184

        	return NULL;

   185

	}

   186

#endif	

   187

	CAN_HANDLE fd0 = DLL_CALL(canOpen)(board);

   188

   189

	canports[i].used = 1;

   190

	canports[i].fd = fd0;

   191

	canports[i].d = d;

   192

   193

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

   198

	return (CAN_PORT)&canports[i];

   199

}

   200

   212

	return res;

   213

}