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

    23

#include <stdio.h>

    24

#include <string.h>

    25

#include <stdlib.h>

    26

#include <stddef.h>		/* for NULL */

    27

#include <errno.h>

    28

    29

#include "config.h"

    30

    31

#ifdef RTCAN_SOCKET

    32

#include "rtdm/can.h"

    33

#define CAN_IFNAME     "rtcan%s"

    34

#else

    35

#include <unistd.h>

    36

#include <sys/socket.h>

    37

#include <sys/ioctl.h>

    38

#include "linux/can.h"

    39

#include "linux/can/raw.h"

    40

#include "net/if.h"

    41

#ifndef PF_CAN

    42

#define PF_CAN 29

    43

#endif

    44

#ifndef AF_CAN

    45

#define AF_CAN PF_CAN

    46

#endif

    47

//#include "af_can.h"

    48

#define CAN_IFNAME     "can%s"

    49

#endif

    50

    51

#include "can_driver.h"

    52

    53

/*********functions which permit to communicate with the board****************/

    54

UNS8

    55

canReceive_driver (CAN_HANDLE fd0, Message * m)

    56

{

    57

  int res;

    58

  struct can_frame frame;

    59

    61

  if (res < 0)

    62

    {

    64

      return 1;

    65

    }

    66

    67

  m->cob_id = frame.can_id & CAN_EFF_MASK;

    68

  m->len = frame.can_dlc;

    69

  if (frame.can_id & CAN_RTR_FLAG)

    70

    m->rtr = 1;

    71

  else

    72

    m->rtr = 0;

    73

  memcpy (m->data, frame.data, 8);

    74

    75

#if defined DEBUG_MSG_CONSOLE_ON

    76

  MSG("in : ");

    77

  print_message(m);

    78

#endif

    79

  return 0;

    80

}

    81

    82

    83

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

    84

UNS8

    85

canSend_driver (CAN_HANDLE fd0, Message const * m)

    86

{

    87

  int res;

    88

  struct can_frame frame;

    89

    90

  frame.can_id = m->cob_id;

    91

  if (frame.can_id >= 0x800)

    92

    frame.can_id |= CAN_EFF_FLAG;

    93

  frame.can_dlc = m->len;

    94

  if (m->rtr)

    95

    frame.can_id |= CAN_RTR_FLAG;

    96

  else

    97

    memcpy (frame.data, m->data, 8);

    98

    99

#if defined DEBUG_MSG_CONSOLE_ON

   100

  MSG("out : ");

   101

  print_message(m);

   102

#endif

   104

  if (res < 0)

   105

    {

   107

      return 1;

   108

    }

   109

   110

  return 0;

   111

}

   112

   113

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

   114

#ifdef RTCAN_SOCKET

   115

int

   116

TranslateBaudRate (const char *optarg)

   117

{

   118

  int baudrate;

   119

  int val, len;

   120

  char *pos = NULL;

   121

   122

  len = strlen (optarg);

   123

  if (!len)

   124

    return 0;

   125

   126

  switch ((int) optarg[len - 1])

   127

    {

   128

    case 'M':

   129

      baudrate = 1000000;

   130

      break;

   131

    case 'K':

   132

      baudrate = 1000;

   133

      break;

   134

    default:

   135

      baudrate = 1;

   136

      break;

   137

    }

   138

  if ((sscanf (optarg, "%i", &val)) == 1)

   139

    baudrate *= val;

   140

  else

   141

    baudrate = 0;;

   142

   143

  return baudrate;

   144

}

   145

#endif

   146

   147

UNS8 canChangeBaudRate_driver( CAN_HANDLE fd, char* baud)

   148

{

   149

	printf("canChangeBaudRate not yet supported by this driver\n");

   150

	return 0;

   151

}

   152

   153

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

   154

CAN_HANDLE

   155

canOpen_driver (s_BOARD * board)

   156

{

   157

  struct ifreq ifr;

   158

  struct sockaddr_can addr;

   159

  int err;

   160

  CAN_HANDLE fd0 = malloc (sizeof (int));

   161

#ifdef RTCAN_SOCKET

   162

  nanosecs_rel_t tx_timeout;

   163

  can_baudrate_t *baudrate;

   164

  can_mode_t *mode;

   165

#endif

   166

   167

  if(!fd0)

   168

    {

   169

      return NULL;

   170

    }

   171

   173

  if (*(int *) fd0 < 0)

   174

    {

   175

      fprintf (stderr, "Socket creation failed: %s\n",

   177

      goto error_ret;

   178

    }

   179

   180

  if (*board->busname >= '0' && *board->busname <= '9')

   181

    snprintf (ifr.ifr_name, IFNAMSIZ, CAN_IFNAME, board->busname);

   182

  else

   183

    strncpy (ifr.ifr_name, board->busname, IFNAMSIZ);

   185

  if (err)

   186

    {

   187

      fprintf (stderr, "Getting IF index for %s failed: %s\n",

   189

      goto error_close;

   190

    }

   191

   192

  {

   193

    int loopback = 1;

   195

               &loopback, sizeof(loopback));

   196

    if (err) {

   198

        goto error_close;

   199

    }

   200

  }

   201

   202

#ifndef RTCAN_SOCKET /*CAN_RAW_RECV_OWN_MSGS not supported in rtsocketcan*/

   203

  {

   204

    int recv_own_msgs = 0; /* 0 = disabled (default), 1 = enabled */

   206

               &recv_own_msgs, sizeof(recv_own_msgs));

   207

    if (err) {

   209

        goto error_close;

   210

    }

   211

  }

   212

#endif

   213

   214

  addr.can_family = AF_CAN;

   215

  addr.can_ifindex = ifr.ifr_ifindex;

   220

      goto error_close;

   221

    }

   222

   223

#ifdef RTCAN_SOCKET

   224

  tx_timeout = 10000000;    /* XXX Timeout is temporarily set to 10 ms */

   226

  if (err)

   227

    {

   228

      fprintf (stderr,

   229

          "Setting TX timeout %d failed: %s\n",

   231

      goto error_close;

   232

    }

   233

   234

  baudrate = (can_baudrate_t *) & ifr.ifr_ifru;

   235

  *baudrate = TranslateBaudRate (board->baudrate);

   236

  if (!*baudrate)

   237

    goto error_close;

   238

   240

  if (err)

   241

    {

   242

      fprintf (stderr,

   243

	       "Setting baudrate %d failed: %s\n",

   245

      goto error_close;

   246

    }

   247

   248

  mode = (can_mode_t *) & ifr.ifr_ifru;

   249

  *mode = CAN_MODE_START;

   251

  if (err)

   252

    {

   253

      fprintf (stderr, "Starting CAN device failed: %s\n",

   255

      goto error_close;

   256

    }

   257

#endif

   258

   259

  return fd0;

   260

   261

error_close:

   263

   264

error_ret:

   265

  free (fd0);

   266

  return NULL;

   267

}

   268

   269

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

   270

int

   271

canClose_driver (CAN_HANDLE fd0)

   272

{

   273

  if (fd0)

   274

    {

   277

      free (fd0);

   278

    }

   279

  return 0;

   280

}