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

    28

#include "config.h"

    29

    30

#ifdef RTCAN_SOCKET

    31

#include "rtdm/rtcan.h"

    32

#define CAN_IFNAME     "rtcan%s"

    33

#define CAN_SOCKET     rt_dev_socket

    34

#define CAN_CLOSE      rt_dev_close

    35

#define CAN_RECV       rt_dev_recv

    36

#define CAN_SEND       rt_dev_send

    37

#define CAN_BIND       rt_dev_bind

    38

#define CAN_IOCTL      rt_dev_ioctl

    39

#else

    40

#include "af_can.h"

    41

#define CAN_IFNAME     "can%s"

    42

#define CAN_SOCKET     socket

    43

#define CAN_CLOSE      close

    44

#define CAN_RECV       recv

    45

#define CAN_SEND       send

    46

#define CAN_BIND       bind

    47

#define CAN_IOCTL      ioctl

    48

#endif

    49

    50

#include "can_driver.h"

    51

    52

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

    53

UNS8 canReceive_driver(CAN_HANDLE fd0, Message *m)

    54

{

    55

       int res;

    56

       struct can_frame frame;

    57

    58

       res = CAN_RECV(fd0, &frame, sizeof(frame), 0);

    59

       if (res < 0)

    60

               return 1;

    61

    62

       m->cob_id.w = frame.can_id & CAN_EFF_MASK;

    63

       m->len      = frame.can_dlc;

    64

       if (frame.can_id & CAN_RTR_FLAG)

    65

               m->rtr = 1;

    66

       else

    67

               m->rtr = 0;

    68

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

    69

    70

       return 0;

    71

}

    72

    73

    74

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

    75

UNS8 canSend_driver(CAN_HANDLE fd0, Message *m)

    76

{

    77

       int res;

    78

       struct can_frame frame;

    79

    80

       frame.can_id = m->cob_id.w;

    81

       if (frame.can_id >= 0x800)

    82

               frame.can_id |= CAN_EFF_FLAG;

    83

       frame.can_dlc = m->len;

    84

       if (m->rtr)

    85

               frame.can_id |= CAN_RTR_FLAG;

    86

       else

    87

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

    88

    89

       res = CAN_SEND(fd0, &frame, sizeof(frame), 0);

    90

       if (res < 0)

    91

               return 1;

    92

    93

       return 0;

    94

}

    95

    96

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

    97

CAN_HANDLE canOpen_driver(s_BOARD *board)

    98

{

    99

       CAN_HANDLE fd0;

   100

       struct ifreq ifr;

   101

       struct sockaddr_can addr;

   102

       int err;

   103

   104

       fd0 = CAN_SOCKET(PF_CAN, SOCK_RAW, 0);

   105

       if(fd0 < 0){

   106

               fprintf(stderr,"Socket creation failed.\n");

   107

               goto error_ret;

   108

       }

   109

   110

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

   111

       err = CAN_IOCTL(fd0, SIOCGIFINDEX, &ifr);

   112

       if (err) {

   113

               fprintf(stderr, "Unknown device: %s\n", ifr.ifr_name);

   114

               goto error_close;

   115

       }

   116

   117

       addr.can_family  = AF_CAN;

   118

       addr.can_ifindex = ifr.ifr_ifindex;

   119

       err = CAN_BIND(fd0, (struct sockaddr *)&addr,

   120

                             sizeof(addr));

   121

       if (err) {

   122

               fprintf(stderr, "Binding failed.\n");

   123

               goto error_close;

   124

       }

   125

   126

       return fd0;

   127

   128

 error_close:

   129

       CAN_CLOSE(fd0);

   130

   131

 error_ret:

   132

       return NULL;

   133

}

   134

   135

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

   136

int canClose_driver(CAN_HANDLE fd0)

   137

{

   138

       if (fd0) {

   139

               CAN_CLOSE(fd0);

   140

       }

   141

       return 0;

   142

}