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

#include <linux/delay.h>

    46

    47

#include "device.h"

    48

#include "master.h"

    49

    50

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

    51

    52

/**

    53

   Device constructor.

    54

   \return 0 in case of success, else < 0

    55

*/

    56

    57

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

    58

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

    59

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

    60

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

    61

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

    62

                   )

    63

{

    64

    struct ethhdr *eth;

    65

    66

    device->master = master;

    67

    device->dev = net_dev;

    68

    device->poll = poll;

    69

    device->module = module;

    70

    71

    device->open = 0;

    72

    device->link_state = 0; // down

    73

    74

    device->tx_count = 0;

    75

    device->rx_count = 0;

    76

    77

#ifdef EC_DBG_IF

    78

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

    79

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

    80

        goto out_return;

    81

    }

    82

#endif

    83

    84

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

    85

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

    86

#ifdef EC_DBG_IF

    87

        goto out_debug;

    88

#else

    89

        goto out_return;

    90

#endif

    91

    }

    92

    93

    device->tx_skb->dev = net_dev;

    94

    95

    // add Ethernet-II-header

    96

    skb_reserve(device->tx_skb, ETH_HLEN);

    97

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

    98

    eth->h_proto = htons(0x88A4);

    99

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

   100

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

   101

   102

    return 0;

   103

   104

#ifdef EC_DBG_IF

   105

 out_debug:

   106

    ec_debug_clear(&device->dbg);

   107

#endif

   108

 out_return:

   109

    return -1;

   110

}

   111

   112

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

   113

   114

/**

   115

   EtherCAT device destuctor.

   116

*/

   117

   118

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

   119

{

   120

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

   121

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

   122

#ifdef EC_DBG_IF

   123

    ec_debug_clear(&device->dbg);

   124

#endif

   125

}

   126

   127

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

   128

   129

/**

   130

   Opens the EtherCAT device.

   131

   \return 0 in case of success, else < 0

   132

*/

   133

   134

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

   135

{

   136

    unsigned int i;

   137

   138

    if (!device->dev) {

   139

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

   140

        return -1;

   141

    }

   142

   143

    if (device->open) {

   144

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

   145

        return 0;

   146

    }

   147

   148

    // device could have received frames before

   149

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

   150

   151

    device->link_state = 0;

   152

    device->tx_count = 0;

   153

    device->rx_count = 0;

   154

   155

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

   156

   157

    return device->open ? 0 : -1;

   158

}

   159

   160

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

   161

   162

/**

   163

   Stops the EtherCAT device.

   164

   \return 0 in case of success, else < 0

   165

*/

   166

   167

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

   168

{

   169

    if (!device->dev) {

   170

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

   171

        return -1;

   172

    }

   173

   174

    if (!device->open) {

   175

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

   176

        return 0;

   177

    }

   178

   179

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

   180

   181

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

   182

}

   183

   184

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

   185

   186

/**

   187

   Returns a pointer to the device's transmit memory.

   188

   \return pointer to the TX socket buffer

   189

*/

   190

   191

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

   192

{

   193

    return device->tx_skb->data + ETH_HLEN;

   194

}

   195

   196

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

   197

   198

/**

   199

   Sends the content of the transmit socket buffer.

   200

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

   201

   start_xmit() function of the assigned net_device.

   202

*/

   203

   204

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

   205

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

   206

                    )

   207

{

   208

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

   209

        return;

   210

   211

    // set the right length for the data

   212

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

   213

   214

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

   215

        EC_DBG("sending frame:\n");

   216

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

   217

    }

   218

   219

#ifdef EC_DBG_IF

   220

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

   221

#endif

   222

   223

    // start sending

   224

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

   225

    device->tx_count++;

   226

}

   227

   228

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

   229

   230

/**

   231

   Calls the poll function of the assigned net_device.

   232

   The master itself works without using interrupts. Therefore the processing

   233

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

   234

   done by the master calling the ISR "manually".

   235

*/

   236

   237

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

   238

{

   239

    device->cycles_poll = get_cycles();

   240

    device->jiffies_poll = jiffies;

   241

    device->poll(device->dev);

   242

}

   243

   244

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

   245

 *  Device interface

   246

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

   247

   248

/**

   249

   Accepts a received frame.

   250

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

   251

   and dispatch the received commands to the sending instances.

   252

   \ingroup DeviceInterface

   253

*/

   254

   255

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

   256

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

   257

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

   258

                   )

   259

{

   260

    device->rx_count++;

   261

   262

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

   263

        EC_DBG("Received frame:\n");

   264

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

   265

                           data + ETH_HLEN, size - ETH_HLEN);

   266

    }

   267

   268

#ifdef EC_DBG_IF

   269

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

   270

#endif

   271

   272

    ec_master_receive_datagrams(device->master,

   273

                                data + ETH_HLEN,

   274

                                size - ETH_HLEN);

   275

}

   276

   277

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

   278

   279

/**

   280

   Sets a new link state.

   281

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

   282

   will not try to send frames using this device.

   283

   \ingroup DeviceInterface

   284

*/

   285

   286

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

   287

                      uint8_t state /**< new link state */

   288

                      )

   289

{

   290

    if (unlikely(!device)) {

   291

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

   292

        return;

   293

    }

   294

   295

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

   296

        device->link_state = state;

   297

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

   298

    }

   299

}

   300

   301

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

   302

   303

/** \cond */

   304

   305

EXPORT_SYMBOL(ecdev_receive);

   306

EXPORT_SYMBOL(ecdev_link_state);

   307

   308

/** \endcond */

   309

   310

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