1

/*

     2

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

     3

     4

Copyright (C): Cosateq GmbH & Co.KG

     5

               http://www.cosateq.com/

     6

               http://www.scale-rt.com/

     7

     8

See COPYING file for copyrights details.

     9

    10

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

    11

modify it under the terms of the GNU Lesser General Public

    12

License as published by the Free Software Foundation; either

    13

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

    14

    15

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

    16

but WITHOUT ANY WARRANTY; without even the implied warranty of

    17

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    18

Lesser General Public License for more details.

    19

    20

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

    21

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

    22

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

    23

*/

    24

    25

/*

    26

	CAN driver interface for CO-PCICAN card.

    27

*/

    28

    29

#include <stdio.h>

    30

#include <unistd.h>

    31

#include <fcntl.h>

    32

    33

#define NEED_PRINT_MESSAGE

    34

#include "can_driver.h"

    35

#include "def.h"

    36

#include "co_pcicanops.h"

    37

    38

/* at the moment not threadsafe :-( */

    39

static unsigned char selectedChannelRx = 0, selectedChannelTx = 0;

    40

    41

static int TranslateBaudRate( char* optarg )

    42

{

    43

  /* values see documentation of CO-PCICAN */

    44

  if( !strcmp( optarg, "1M"    ) ) return 0;

    45

  if( !strcmp( optarg, "800K"  ) ) return 1;

    46

  if( !strcmp( optarg, "500K"  ) ) return 2;

    47

  if( !strcmp( optarg, "250K"  ) ) return 3;

    48

  if( !strcmp( optarg, "125K"  ) ) return 4;

    49

  if( !strcmp( optarg, "100K"  ) ) return 5;

    50

  if( !strcmp( optarg, "83.3K" ) ) return 6;

    51

  if( !strcmp( optarg, "10K"   ) ) return 7;

    52

    53

  return -1;

    54

}

    55

    56

/*********CO-PCICAN specific functions to communicate with the board**********/

    57

typedef struct

    58

{

    59

  char used;

    60

  CAN_HANDLE fd;

    61

  void* receiveTask;

    62

  void* d;

    63

} CANPort; /* taken from drivers/unix.c */

    64

    65

int get_fd_of_port( CAN_PORT port )

    66

{

    67

  CANPort *thisPort = (CANPort*)port;

    68

  CAN_HANDLE thisHandle;

    69

  int *pfd;

    70

    71

  if( thisPort == NULL )

    72

  {

    73

    MSG("can_copcican_linux: get_fd_of_port(): thisPort is NULL\n");

    74

    return -1;

    75

  }

    76

    77

  thisHandle = thisPort->fd;

    78

    79

  if( thisHandle == NULL )

    80

  {

    81

    MSG("can_copcican_linux: get_fd_of_port(): thisHandle is NULL\n");

    82

    return -1;

    83

  }

    84

    85

  pfd = (int*)thisHandle;

    86

    87

  /*MSG("can_copcican_linux: get_fd_of_port(): handle is %d\n", *pfd);*/

    88

    89

  return *pfd;

    90

}

    91

    92

int co_pcican_enter_run_mode( const int fd )

    93

{

    94

  co_pcican_config_t board_config;

    95

    96

  if( fd < 0 )

    97

  {

    98

    MSG("can_copcican_linux: co_pcican_enter_run_mode(): invalid file descriptor\n");

    99

    return -1;

   100

  }

   101

   102

  memset( &board_config, 0x00, sizeof(co_pcican_config_t) );

   103

  board_config.opcode = CMDQ_OPC_ENTER_RUN_MODE;

   104

   105

  return ioctl( fd, CAN_CONFIG, &board_config );

   106

}

   107

   108

int co_pcican_enter_config_mode( const int fd )

   109

{

   110

  co_pcican_config_t board_config;

   111

   112

  if( fd < 0 )

   113

  {

   114

    MSG("can_copcican_linux: co_pcican_enter_config_mode(): invalid file descriptor\n");

   115

    return -1;

   116

  }

   117

   118

  memset( &board_config, 0x00, sizeof(co_pcican_config_t) );

   119

  board_config.opcode = CMDQ_OPC_ENTER_CONFIG_MODE;

   120

   121

  return ioctl( fd, CAN_CONFIG, &board_config );

   122

}

   123

   124

int co_pcican_select_channel( const unsigned char channel, const unsigned int direction )

   125

{

   126

  if( channel >= NUM_CAN_CHANNELS )

   127

  {

   128

    MSG("can_copcican_linux: co_pcican_select_channel(): invalid channel\n");

   129

    return -1;

   130

  }

   131

   132

  /* at the moment not threadsafe :-( */

   133

  switch( direction )

   134

  {

   135

    case RX: selectedChannelRx = channel;

   136

             break;

   137

    case TX: selectedChannelTx = channel;

   138

             break;

   139

    default: return -1;

   140

  }

   141

   142

  return 0;

   143

}

   144

   145

int co_pcican_configure_selected_channel( const int fd, s_BOARD *board, const unsigned int direction )

   146

{

   147

  co_pcican_config_t board_config;

   148

  unsigned int selectedChannel;

   149

   150

  if( fd < 0 )

   151

  {

   152

    MSG("can_copcican_linux: co_pcican_configure_selected_channel(): invalid file descriptor\n");

   153

    return -1;

   154

  }

   155

   156

  if( board == NULL )

   157

  {

   158

    MSG("can_copcican_linux: co_pcican_configure_selected_channel(): board is NULL\n");

   159

    return -1;

   160

  }

   161

   162

  if( board->baudrate == NULL )

   163

  {

   164

    MSG("can_copcican_linux: co_pcican_configure_selected_channel(): baudrate is NULL\n");

   165

    return -1;

   166

  }

   167

   168

  switch( direction )

   169

  {

   170

    case RX: selectedChannel = selectedChannelRx;

   171

             break;

   172

    case TX: selectedChannel = selectedChannelTx;

   173

             break;

   174

    default: selectedChannel = 0xff;

   175

  }

   176

   177

  if( selectedChannel >= NUM_CAN_CHANNELS )

   178

  {

   179

    MSG("can_copcican_linux: co_pcican_configure_selected_channel(): invalid channel selected\n");

   180

    return -1;

   181

  }

   182

   183

  memset( &board_config, 0x00, sizeof(co_pcican_config_t) );

   184

  board_config.opcode   = CMDQ_OPC_SET_CONFIG_CHANNEL;

   185

  board_config.param[0] = selectedChannel;

   186

  board_config.param[1] = TranslateBaudRate( board->baudrate );

   187

   188

  return ioctl( fd, CAN_CONFIG, &board_config );

   189

}

   190

   191

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

   192

UNS8 canReceive_driver( CAN_HANDLE fd0, Message *m )

   193

{

   194

  co_pcican_message_t canmsg;

   195

  UNS8 ret = 0;

   196

  int *pfd = (int*)fd0;

   197

   198

  if( pfd == NULL )

   199

  {

   200

    MSG("can_copcican_linux: canReceive_driver(): file descriptor is NULL\n");

   201

    return 1;

   202

  }

   203

   204

  if( *pfd < 0 )

   205

  {

   206

    MSG("can_copcican_linux: canReceive_driver(): invalid file descriptor\n");

   207

    return 1;

   208

  }

   209

   210

  if( selectedChannelRx >= NUM_CAN_CHANNELS )

   211

  {

   212

    MSG("can_copcican_linux: canReceive_driver(): invalid channel selected\n");

   213

    return 1;

   214

  }

   215

   216

  if( m == NULL )

   217

  {

   218

    MSG("can_copcican_linux: canReceive_driver(): message is NULL\n");

   219

    return 1;

   220

  }

   221

   222

  memset( &canmsg, 0x00, sizeof(co_pcican_message_t) );

   223

  canmsg.channelnum = selectedChannelRx;

   224

   225

  ioctl( *pfd, CAN_READ, &canmsg );

   226

   227

  if( canmsg.timestamp_lo == 0 )

   228

  {

   229

    memset( m, 0x00, sizeof(Message) );

   230

   231

    m->cob_id = 0xffff; /* set to invalid so nothing happens */

   232

  }

   233

  else

   234

  {

   235

    m->len = canmsg.size;

   236

    m->cob_id = canmsg.id;

   237

    m->rtr = canmsg.type & MSG_RTR;

   238

   239

    if( !m->rtr )

   240

    {

   241

      /* this is for safety */

   242

      if( m->len > 8 )

   243

        m->len = 8;

   244

   245

      memcpy( m->data, canmsg.data, m->len);

   246

    }

   247

  }

   248

   249

  return ret;

   250

}

   251

   252

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

   253

UNS8 canSend_driver( CAN_HANDLE fd0, Message *m )

   254

{

   255

  co_pcican_message_t canmsg;

   256

  UNS8 ret = 0;

   257

  int *pfd = (int*)fd0;

   258

   259

  if( pfd == NULL )

   260

  {

   261

    MSG("can_copcican_linux: canSend_driver(): file descriptor is NULL\n");

   262

    return 1;

   263

  }

   264

   265

  if( *pfd < 0 )

   266

  {

   267

    MSG("can_copcican_linux: canSend_driver(): invalid file descriptor\n");

   268

    return 1;

   269

  }

   270

   271

  if( selectedChannelTx >= NUM_CAN_CHANNELS )

   272

  {

   273

    MSG("can_copcican_linux: canSend_driver(): invalid channel selected\n");

   274

    return 1;

   275

  }

   276

   277

  if( m == NULL )

   278

  {

   279

    MSG("can_copcican_linux: canSend_driver(): message is NULL\n");

   280

    return 1;

   281

  }

   282

   283

  memset( &canmsg, 0x00, sizeof(co_pcican_message_t) );

   284

  canmsg.channelnum = selectedChannelTx;

   285

  canmsg.size = m->len;

   286

  canmsg.id = m->cob_id;

   287

   288

  if( canmsg.id >= 0x800 )

   289

    canmsg.type |= MSG_EXT;

   290

   291

  if( m->rtr )

   292

  {

   293

    canmsg.type |= MSG_RTR;

   294

  }

   295

  else

   296

  {

   297

    /* this is for safety */

   298

    if( canmsg.size > 8 )

   299

      canmsg.size = 8;

   300

   301

    memcpy( canmsg.data, m->data, canmsg.size);

   302

  }

   303

   304

  if( ioctl( *pfd, CAN_WRITE, &canmsg ) < 0 )

   305

    ret = 1;

   306

   307

  return ret;

   308

}

   309

   310

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

   311

CAN_HANDLE canOpen_driver( s_BOARD *board )

   312

{

   313

  int *pfd;

   314

   315

  if( board == NULL )

   316

  {

   317

    MSG("can_copcican_linux: canOpen_driver(): board is NULL\n");

   318

    return NULL;

   319

  }

   320

   321

  if( board->busname == NULL )

   322

  {

   323

    MSG("can_copcican_linux: canOpen_driver(): busname is NULL\n");

   324

    return NULL;

   325

  }

   326

   327

  /* create dynamically to avoid global variable */

   328

  pfd = (int*)malloc( sizeof(int) );

   329

   330

  if( pfd == NULL )

   331

  {

   332

    MSG("can_copcican_linux: canOpen_driver(): file descriptor is NULL\n");

   333

    return NULL;

   334

  }

   335

   336

  *pfd = open( board->busname, O_RDWR, 0 );

   337

   338

  if( *pfd < 0 )

   339

  {

   340

    MSG("can_copcican_linux: canOpen_driver(): invalid file descriptor\n");

   341

   342

    /* clear resources if open failed */

   343

    free( pfd );

   344

    pfd = NULL;

   345

  }

   346

   347

  /*MSG("can_copcican_linux: canOpen_driver(): handle is %d\n", *pfd);*/

   348

   349

  return (CAN_HANDLE)pfd;

   350

}

   351

   352

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

   353

int canClose_driver( CAN_HANDLE fd0 )

   354

{

   355

  int *pfd = (int*)fd0;

   356

   357

  if( pfd == NULL )

   358

  {

   359

    MSG("can_copcican_linux: canClose_driver(): file descriptor is NULL\n");

   360

    return -1;

   361

  }

   362

   363

  if( *pfd < 0 )

   364

  {

   365

    MSG("can_copcican_linux: canClose_driver(): invalid file descriptor\n");

   366

    return -1;

   367

  }

   368

   369

  close( *pfd );

   370

  free( pfd );

   371

  pfd = NULL;

   372

   373

  selectedChannelRx = 0;

   374

  selectedChannelTx = 0;

   375

   376

  return 0;

   377

}

   378

   379

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

   380

UNS8 canChangeBaudRate_driver( CAN_HANDLE fd0, char* baud )

   381

{

   382

  s_BOARD board;

   383

  UNS8 ret = 0;

   384

  int *pfd = (int*)fd0;

   385

   386

  if( pfd == NULL )

   387

  {

   388

    MSG("can_copcican_linux: canChangeBaudRate_driver(): file descriptor is NULL\n");

   389

    return 1;

   390

  }

   391

   392

  if( *pfd < 0 )

   393

  {

   394

    MSG("can_copcican_linux: canChangeBaudRate_driver(): invalid file descriptor\n");

   395

    return 1;

   396

  }

   397

   398

  if( baud == NULL )

   399

  {

   400

    MSG("can_copcican_linux: canChangeBaudRate_driver(): baud is NULL\n");

   401

    return 1;

   402

  }

   403

   404

  memset( &board, 0x00, sizeof(s_BOARD) );

   405

  board.baudrate = baud;

   406

   407

  if( co_pcican_configure_selected_channel( *pfd, &board, RX ) < 0 )

   408

    ret = 1;

   409

   410

  if( co_pcican_configure_selected_channel( *pfd, &board, TX ) < 0 )

   411

    ret = 1;

   412

   413

  return ret;

   414

}

   415