1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006  Florian Pose, Ingenieurgemeinschaft IgH

     6

 *

     7

 *  This file is part of the IgH EtherCAT Master.

     8

 *

     9

 *  The IgH EtherCAT Master is free software; you can redistribute it

    10

 *  and/or modify it under the terms of the GNU General Public License

    11

 *  as published by the Free Software Foundation; either version 2 of the

    12

 *  License, or (at your option) any later version.

    13

 *

    14

 *  The IgH EtherCAT Master is distributed in the hope that it will be

    15

 *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of

    16

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

 *  GNU General Public License for more details.

    18

 *

    19

 *  You should have received a copy of the GNU General Public License

    20

 *  along with the IgH EtherCAT Master; if not, write to the Free Software

    21

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    22

 *

    23

 *  The right to use EtherCAT Technology is granted and comes free of

    24

 *  charge under condition of compatibility of product made by

    25

 *  Licensee. People intending to distribute/sell products based on the

    26

 *  code, have to sign an agreement to guarantee that products using

    27

 *  software based on IgH EtherCAT master stay compatible with the actual

    28

 *  EtherCAT specification (which are released themselves as an open

    29

 *  standard) as the (only) precondition to have the right to use EtherCAT

    30

 *  Technology, IP and trade marks.

    31

 *

    32

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

    33

    34

/**

    35

   \file

    36

   EtherCAT device methods.

    37

*/

    38

    39

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

    40

    41

#include <linux/module.h>

    42

#include <linux/skbuff.h>

    43

#include <linux/if_ether.h>

    44

#include <linux/netdevice.h>

    45

    46

#include "device.h"

    47

#include "master.h"

    48

    49

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

    50

    51

/**

    52

   Device constructor.

    53

   \return 0 in case of success, else < 0

    54

*/

    55

    56

int ec_device_init(ec_device_t *device, /**< EtherCAT device */

    57

                   ec_master_t *master, /**< master owning the device */

    58

                   struct net_device *net_dev, /**< net_device structure */

    59

                   ec_pollfunc_t poll, /**< pointer to device's poll function */

    60

                   struct module *module /**< the device's module */

    61

                   )

    62

{

    63

    struct ethhdr *eth;

    64

    65

    device->master = master;

    66

    device->dev = net_dev;

    67

    device->poll = poll;

    68

    device->module = module;

    69

    70

    device->open = 0;

    71

    device->link_state = 0; // down

    72

    73

    device->tx_count = 0;

    74

    device->rx_count = 0;

    75

    76

#ifdef EC_DBG_IF

    77

    if (ec_debug_init(&device->dbg)) {

    78

        EC_ERR("Failed to init debug device!\n");

    79

        goto out_return;

    80

    }

    81

#endif

    82

    83

    if (!(device->tx_skb = dev_alloc_skb(ETH_FRAME_LEN))) {

    84

        EC_ERR("Error allocating device socket buffer!\n");

    85

#ifdef EC_DBG_IF

    86

        goto out_debug;

    87

#else

    88

        goto out_return;

    89

#endif

    90

    }

    91

    92

    device->tx_skb->dev = net_dev;

    93

    94

    // add Ethernet-II-header

    95

    skb_reserve(device->tx_skb, ETH_HLEN);

    96

    eth = (struct ethhdr *) skb_push(device->tx_skb, ETH_HLEN);

    97

    eth->h_proto = htons(0x88A4);

    98

    memcpy(eth->h_source, net_dev->dev_addr, net_dev->addr_len);

    99

    memset(eth->h_dest, 0xFF, net_dev->addr_len);

   100

   101

    return 0;

   102

   103

#ifdef EC_DBG_IF

   104

 out_debug:

   105

    ec_debug_clear(&device->dbg);

   106

#endif

   107

 out_return:

   108

    return -1;

   109

}

   110

   111

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

   112

   113

/**

   114

   EtherCAT device destuctor.

   115

*/

   116

   117

void ec_device_clear(ec_device_t *device /**< EtherCAT device */)

   118

{

   119

    if (device->open) ec_device_close(device);

   120

    if (device->tx_skb) dev_kfree_skb(device->tx_skb);

   121

#ifdef EC_DBG_IF

   122

    ec_debug_clear(&device->dbg);

   123

#endif

   124

}

   125

   126

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

   127

   128

/**

   129

   Opens the EtherCAT device.

   130

   \return 0 in case of success, else < 0

   131

*/

   132

   133

int ec_device_open(ec_device_t *device /**< EtherCAT device */)

   134

{

   135

    unsigned int i;

   136

   137

    if (!device->dev) {

   138

        EC_ERR("No net_device to open!\n");

   139

        return -1;

   140

    }

   141

   142

    if (device->open) {

   143

        EC_WARN("Device already opened!\n");

   144

        return 0;

   145

    }

   146

   147

    // device could have received frames before

   148

    for (i = 0; i < 4; i++) ec_device_poll(device);

   149

   150

    device->link_state = 0;

   151

    device->tx_count = 0;

   152

    device->rx_count = 0;

   153

   154

    if (device->dev->open(device->dev) == 0) device->open = 1;

   155

   156

    return device->open ? 0 : -1;

   157

}

   158

   159

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

   160

   161

/**

   162

   Stops the EtherCAT device.

   163

   \return 0 in case of success, else < 0

   164

*/

   165

   166

int ec_device_close(ec_device_t *device /**< EtherCAT device */)

   167

{

   168

    if (!device->dev) {

   169

        EC_ERR("No device to close!\n");

   170

        return -1;

   171

    }

   172

   173

    if (!device->open) {

   174

        EC_WARN("Device already closed!\n");

   175

        return 0;

   176

    }

   177

   178

    if (device->dev->stop(device->dev) == 0) device->open = 0;

   179

   180

    return !device->open ? 0 : -1;

   181

}

   182

   183

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

   184

   185

/**

   186

   Returns a pointer to the device's transmit memory.

   187

   \return pointer to the TX socket buffer

   188

*/

   189

   190

uint8_t *ec_device_tx_data(ec_device_t *device /**< EtherCAT device */)

   191

{

   192

    return device->tx_skb->data + ETH_HLEN;

   193

}

   194

   195

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

   196

   197

/**

   198

   Sends the content of the transmit socket buffer.

   199

   Cuts the socket buffer content to the (now known) size, and calls the

   200

   start_xmit() function of the assigned net_device.

   201

*/

   202

   203

void ec_device_send(ec_device_t *device, /**< EtherCAT device */

   204

                    size_t size /**< number of bytes to send */

   205

                    )

   206

{

   207

    if (unlikely(!device->link_state)) // Link down

   208

        return;

   209

   210

    // set the right length for the data

   211

    device->tx_skb->len = ETH_HLEN + size;

   212

   213

    if (unlikely(device->master->debug_level > 1)) {

   214

        EC_DBG("sending frame:\n");

   215

        ec_print_data(device->tx_skb->data + ETH_HLEN, size);

   216

    }

   217

   218

#ifdef EC_DBG_IF

   219

    ec_debug_send(&device->dbg, device->tx_skb->data, ETH_HLEN + size);

   220

#endif

   221

   222

    // start sending

   223

    device->dev->hard_start_xmit(device->tx_skb, device->dev);

   224

    device->tx_count++;

   225

}

   226

   227

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

   228

   229

/**

   230

   Calls the poll function of the assigned net_device.

   231

   The master itself works without using interrupts. Therefore the processing

   232

   of received data and status changes of the network device has to be

   233

   done by the master calling the ISR "manually".

   234

*/

   235

   236

void ec_device_poll(ec_device_t *device /**< EtherCAT device */)

   237

{

   238

    device->cycles_poll = get_cycles();

   239

    device->jiffies_poll = jiffies;

   240

    device->poll(device->dev);

   241

}

   242

   243

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

   244

 *  Device interface

   245

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

   246

   247

/**

   248

   Accepts a received frame.

   249

   Forwards the received data to the master. The master will analyze the frame

   250

   and dispatch the received commands to the sending instances.

   251

   \ingroup DeviceInterface

   252

*/

   253

   254

void ecdev_receive(ec_device_t *device, /**< EtherCAT device */

   255

                   const void *data, /**< pointer to received data */

   256

                   size_t size /**< number of bytes received */

   257

                   )

   258

{

   259

    device->rx_count++;

   260

   261

    if (unlikely(device->master->debug_level > 1)) {

   262

        EC_DBG("Received frame:\n");

   263

        ec_print_data_diff(device->tx_skb->data + ETH_HLEN,

   264

                           data + ETH_HLEN, size - ETH_HLEN);

   265

    }

   266

   267

#ifdef EC_DBG_IF

   268

    ec_debug_send(&device->dbg, data, size);

   269

#endif

   270

   271

    ec_master_receive_datagrams(device->master,

   272

                                data + ETH_HLEN,

   273

                                size - ETH_HLEN);

   274

}

   275

   276

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

   277

   278

/**

   279

   Sets a new link state.

   280

   If the device notifies the master about the link being down, the master

   281

   will not try to send frames using this device.

   282

   \ingroup DeviceInterface

   283

*/

   284

   285

void ecdev_link_state(ec_device_t *device, /**< EtherCAT device */

   286

                      uint8_t state /**< new link state */

   287

                      )

   288

{

   289

    if (unlikely(!device)) {

   290

        EC_WARN("ecdev_link_state: no device!\n");

   291

        return;

   292

    }

   293

   294

    if (likely(state != device->link_state)) {

   295

        device->link_state = state;

   296

        EC_INFO("Link state changed to %s.\n", (state ? "UP" : "DOWN"));

   297

    }

   298

}

   299

   300

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

   301

   302

/** \cond */

   303

   304

EXPORT_SYMBOL(ecdev_receive);

   305

EXPORT_SYMBOL(ecdev_link_state);

   306

   307

/** \endcond */

   308

   309

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