1

/*

     2

This file is part of CanFestival, a library implementing CanOpen Stack.

     3

     4

Copyright (C): Edouard TISSERANT and Francis DUPIN

     5

Copyright (C) Win32 Port Leonid Tochinski

     6

     7

See COPYING file for copyrights details.

     8

     9

This library is free software; you can redistribute it and/or

    10

modify it under the terms of the GNU Lesser General Public

    11

License as published by the Free Software Foundation; either

    12

version 2.1 of the License, or (at your option) any later version.

    13

    14

This library is distributed in the hope that it will be useful,

    15

but WITHOUT ANY WARRANTY; without even the implied warranty of

    16

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    17

Lesser General Public License for more details.

    18

    19

You should have received a copy of the GNU Lesser General Public

    20

License along with this library; if not, write to the Free Software

    21

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    22

*/

    23

    24

/*

    25

 CAN driver interface.

    26

*/

    27

    28

#include <windows.h>

    29

    30

extern "C"

    31

   {

    32

#define DLL_CALL(funcname) (*_##funcname)

    33

#define FCT_PTR_INIT =NULL

    34

#include "canfestival.h"

    35

#include "timer.h"

    36

    37

#include "timers_driver.h"

    38

   };

    39

    40

typedef UNS8 (*CANRECEIVE_DRIVER_PROC)(void* inst, Message *m);

    41

typedef UNS8 (*CANSEND_DRIVER_PROC)(void* inst, const Message *m);

    42

typedef void* (*CANOPEN_DRIVER_PROC)(s_BOARD *board);

    43

typedef int (*CANCLOSE_DRIVER_PROC)(void* inst);

    44

    45

    46

class driver_procs

    47

   {

    48

   public:

    49

      driver_procs();

    50

      ~driver_procs();

    51

    52

      HMODULE load_canfestival_driver(LPCTSTR driver_name);

    53

      bool can_driver_valid() const;

    54

    55

   public:

    56

      // can driver

    57

      CANRECEIVE_DRIVER_PROC m_canReceive;

    58

      CANSEND_DRIVER_PROC m_canSend;

    59

      CANOPEN_DRIVER_PROC m_canOpen;

    60

      CANCLOSE_DRIVER_PROC m_canClose;

    61

    62

      // driver module habndle

    63

      HMODULE m_driver_handle;

    64

   };

    65

    66

driver_procs::driver_procs() : m_canReceive(0),

    67

      m_canSend(0),

    68

      m_canOpen(0),

    69

      m_canClose(0),

    70

      m_driver_handle(0)

    71

   {}

    72

    73

driver_procs::~driver_procs()

    74

   {

    75

   if (m_driver_handle)

    76

      ::FreeLibrary(m_driver_handle);

    77

   }

    78

    79

bool driver_procs::can_driver_valid() const

    80

   {

    81

   return ((m_canReceive != NULL) &&

    82

           (m_canSend != NULL) &&

    83

           (m_canOpen != NULL) &&

    84

           (m_canClose != NULL));

    85

   }

    86

    87

// GetProcAddress doesn't have an UNICODE version for NT

    88

#ifdef UNDER_CE

    89

  #define myTEXT(str) TEXT(str)

    90

#else

    91

  #define myTEXT(str) str

    92

#endif

    93

    94

HMODULE driver_procs::load_canfestival_driver(LPCTSTR driver_name)

    95

   {

    96

   if (can_driver_valid())

    97

      return m_driver_handle;

    98

   m_driver_handle = ::LoadLibrary(driver_name);

    99

   if (m_driver_handle == NULL)

   100

      return NULL;

   101

   102

   m_canReceive = (CANRECEIVE_DRIVER_PROC)::GetProcAddress(m_driver_handle, myTEXT("canReceive_driver"));

   103

   m_canSend = (CANSEND_DRIVER_PROC)::GetProcAddress(m_driver_handle, myTEXT("canSend_driver"));

   104

   m_canOpen = (CANOPEN_DRIVER_PROC)::GetProcAddress(m_driver_handle, myTEXT("canOpen_driver"));

   105

   m_canClose = (CANCLOSE_DRIVER_PROC)::GetProcAddress(m_driver_handle, myTEXT("canClose_driver"));

   106

   return can_driver_valid()?m_driver_handle:NULL;

   107

   }

   108

   109

struct driver_data

   110

   {

   111

   CO_Data * d;

   112

   HANDLE receive_thread;

   113

   void* inst;

   114

   volatile bool continue_receive_thread;

   115

   };

   116

   117

driver_procs s_driver_procs;

   118

   119

LIB_HANDLE LoadCanDriver(char* driver_name)

   120

   {

   121

		return s_driver_procs.load_canfestival_driver((LPCTSTR)driver_name);

   122

   }

   123

   124

UNS8 canReceive(CAN_PORT fd0, Message *m)

   125

   {

   126

   if (fd0 != NULL && s_driver_procs.m_canReceive != NULL)

   127

	   {

   128

		  driver_data* data = (driver_data*)fd0;

   129

		  return (*s_driver_procs.m_canReceive)(data->inst, m);

   130

	   }

   131

   return 1;

   132

   }

   133

   134

void* canReceiveLoop(CAN_PORT fd0)

   135

   {

   136

   driver_data* data = (driver_data*)fd0;

   137

   Message m;

   138

   while (data->continue_receive_thread)

   139

      {

   140

      if (!canReceive(fd0, &m))

   141

         {

   142

         EnterMutex();

   143

         canDispatch(data->d, &m);

   144

         LeaveMutex();

   145

         }

   146

      else

   147

         {

   148

		 break;

   149

         ::Sleep(1);

   150

         }

   151

      }

   152

   return 0;

   153

   }

   154

   155

/***************************************************************************/

   156

UNS8 canSend(CAN_PORT fd0, Message *m)

   157

   {

   158

   if (fd0 != NULL && s_driver_procs.m_canSend != NULL)

   159

      {

   160

      UNS8 res;

   161

      driver_data* data = (driver_data*)fd0;

   162

      LeaveMutex();

   163

      res = (*s_driver_procs.m_canSend)(data->inst, m);      

   164

      EnterMutex();

   165

      if (res)

   166

         return 0;

   167

      }

   168

   return 1;

   169

   }

   170

   171

/***************************************************************************/

   172

CAN_HANDLE canOpen(s_BOARD *board, CO_Data * d)

   173

   {

   174

   if (board != NULL && s_driver_procs.m_canOpen != NULL)

   175

      {

   176

      void* inst = (*s_driver_procs.m_canOpen)(board);

   177

      if (inst != NULL)

   178

         {

   179

         driver_data* data = new driver_data;

   180

         data->d = d;

   181

         data->inst = inst;

   182

         data->continue_receive_thread = true;

   183

         CreateReceiveTask(data, &data->receive_thread, &canReceiveLoop);

   184

	 EnterMutex();

   185

         d->canHandle = data;

   186

         LeaveMutex();

   187

         return data;

   188

         }

   189

      }

   190

   return NULL;

   191

   }

   192

   193

/***************************************************************************/

   194

int canClose(CO_Data * d)

   195

   {

   196

   if (s_driver_procs.m_canClose != NULL)

   197

      {

   198

		  driver_data* data;

   199

		  EnterMutex();

   200

		  if(d->canHandle != NULL){

   201

			data = (driver_data*)d->canHandle;

   202

			d->canHandle = NULL;

   203

			data->continue_receive_thread = false;}

   204

		  LeaveMutex();

   205

		  WaitReceiveTaskEnd(&data->receive_thread);

   206

		  (*s_driver_procs.m_canClose)(data->inst);

   207

		  delete data;

   208

		  return 0;

   209

      }

   210

   return 0;

   211

   }

   212

   213