1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006-2008  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 and/or

    10

 *  modify it under the terms of the GNU General Public License version 2, as

    11

 *  published by the Free Software Foundation.

    12

 *

    13

 *  The IgH EtherCAT Master 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 General

    16

 *  Public License for more details.

    17

 *

    18

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

    19

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

    20

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

    21

 *

    22

 *  ---

    23

 *

    24

 *  The license mentioned above concerns the source code only. Using the

    25

 *  EtherCAT technology and brand is only permitted in compliance with the

    26

 *  industrial property and similar rights of Beckhoff Automation GmbH.

    27

 *

    28

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

    29

    30

/**

    31

   \file

    32

   EtherCAT device methods.

    33

*/

    34

    35

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

    36

    37

#include <linux/module.h>

    38

#include <linux/skbuff.h>

    39

#include <linux/if_ether.h>

    40

#include <linux/netdevice.h>

    41

    42

#include "device.h"

    43

#include "master.h"

    44

    45

#ifdef EC_DEBUG_RING

    46

#define timersub(a, b, result) \

    47

    do { \

    48

        (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \

    49

        (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \

    50

        if ((result)->tv_usec < 0) { \

    51

            --(result)->tv_sec; \

    52

            (result)->tv_usec += 1000000; \

    53

        } \

    54

    } while (0)

    55

#endif

    56

    57

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

    58

    59

/** Constructor.

    60

 *

    61

 * \return 0 in case of success, else < 0

    62

 */

    63

int ec_device_init(

    64

        ec_device_t *device, /**< EtherCAT device */

    65

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

    66

        )

    67

{

    68

    int ret;

    69

    unsigned int i;

    70

    struct ethhdr *eth;

    71

#ifdef EC_DEBUG_IF

    72

    char ifname[10];

    73

    char mb = 'x';

    74

#endif

    75

#ifdef EC_DEBUG_RING

    76

    device->debug_frame_index = 0;

    77

    device->debug_frame_count = 0;

    78

#endif

    79

    80

    device->master = master;

    81

    device->tx_ring_index = 0;

    82

    83

#ifdef EC_DEBUG_IF

    84

    if (device == &master->main_device)

    85

        mb = 'm';

    86

    else if (device == &master->backup_device)

    87

        mb = 'b';

    88

    89

    sprintf(ifname, "ecdbg%c%u", mb, master->index);

    90

    91

    ret = ec_debug_init(&device->dbg, device, ifname);

    92

    if (ret < 0) {

    93

        EC_MASTER_ERR(master, "Failed to init debug device!\n");

    94

        goto out_return;

    95

    }

    96

#endif

    97

    98

    for (i = 0; i < EC_TX_RING_SIZE; i++)

    99

        device->tx_skb[i] = NULL;

   100

   101

    for (i = 0; i < EC_TX_RING_SIZE; i++) {

   102

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

   103

            EC_MASTER_ERR(master, "Error allocating device socket buffer!\n");

   104

            ret = -ENOMEM;

   105

            goto out_tx_ring;

   106

        }

   107

   108

        // add Ethernet-II-header

   109

        skb_reserve(device->tx_skb[i], ETH_HLEN);

   110

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

   111

        eth->h_proto = htons(0x88A4);

   112

        memset(eth->h_dest, 0xFF, ETH_ALEN);

   113

    }

   114

   115

    ec_device_detach(device); // resets remaining fields

   116

    return 0;

   117

   118

out_tx_ring:

   119

    for (i = 0; i < EC_TX_RING_SIZE; i++)

   120

        if (device->tx_skb[i])

   121

            dev_kfree_skb(device->tx_skb[i]);

   122

#ifdef EC_DEBUG_IF

   123

    ec_debug_clear(&device->dbg);

   124

out_return:

   125

#endif

   126

    return ret;

   127

}

   128

   129

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

   130

   131

/** Destructor.

   132

 */

   133

void ec_device_clear(

   134

        ec_device_t *device /**< EtherCAT device */

   135

        )

   136

{

   137

    unsigned int i;

   138

   139

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

   140

    for (i = 0; i < EC_TX_RING_SIZE; i++)

   141

        dev_kfree_skb(device->tx_skb[i]);

   142

#ifdef EC_DEBUG_IF

   143

    ec_debug_clear(&device->dbg);

   144

#endif

   145

}

   146

   147

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

   148

   149

/** Associate with net_device.

   150

 */

   151

void ec_device_attach(

   152

        ec_device_t *device, /**< EtherCAT device */

   153

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

   154

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

   155

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

   156

        )

   157

{

   158

    unsigned int i;

   159

    struct ethhdr *eth;

   160

   161

    ec_device_detach(device); // resets fields

   162

   163

    device->dev = net_dev;

   164

    device->poll = poll;

   165

    device->module = module;

   166

   167

    for (i = 0; i < EC_TX_RING_SIZE; i++) {

   168

        device->tx_skb[i]->dev = net_dev;

   169

        eth = (struct ethhdr *) (device->tx_skb[i]->data);

   170

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

   171

    }

   172

   173

#ifdef EC_DEBUG_IF

   174

    ec_debug_register(&device->dbg, net_dev);

   175

#endif

   176

}

   177

   178

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

   179

   180

/** Disconnect from net_device.

   181

 */

   182

void ec_device_detach(

   183

        ec_device_t *device /**< EtherCAT device */

   184

        )

   185

{

   186

    unsigned int i;

   187

   188

#ifdef EC_DEBUG_IF

   189

    ec_debug_unregister(&device->dbg);

   190

#endif

   191

   192

    device->dev = NULL;

   193

    device->poll = NULL;

   194

    device->module = NULL;

   195

    device->open = 0;

   196

    device->link_state = 0; // down

   197

   198

    ec_device_clear_stats(device);

   199

   200

    for (i = 0; i < EC_TX_RING_SIZE; i++)

   201

        device->tx_skb[i]->dev = NULL;

   202

}

   203

   204

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

   205

   206

/** Opens the EtherCAT device.

   207

 *

   208

 * \return 0 in case of success, else < 0

   209

 */

   210

int ec_device_open(

   211

        ec_device_t *device /**< EtherCAT device */

   212

        )

   213

{

   214

    int ret;

   215

   216

    if (!device->dev) {

   217

        EC_MASTER_ERR(device->master, "No net_device to open!\n");

   218

        return -ENODEV;

   219

    }

   220

   221

    if (device->open) {

   222

        EC_MASTER_WARN(device->master, "Device already opened!\n");

   223

        return 0;

   224

    }

   225

   226

    device->link_state = 0;

   227

   228

    ec_device_clear_stats(device);

   229

   230

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)

   231

    ret = device->dev->netdev_ops->ndo_open(device->dev);

   232

#else

   233

    ret = device->dev->open(device->dev);

   234

#endif

   235

    if (!ret)

   236

        device->open = 1;

   237

   238

    return ret;

   239

}

   240

   241

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

   242

   243

/** Stops the EtherCAT device.

   244

 *

   245

 * \return 0 in case of success, else < 0

   246

 */

   247

int ec_device_close(

   248

        ec_device_t *device /**< EtherCAT device */

   249

        )

   250

{

   251

    int ret;

   252

   253

    if (!device->dev) {

   254

        EC_MASTER_ERR(device->master, "No device to close!\n");

   255

        return -ENODEV;

   256

    }

   257

   258

    if (!device->open) {

   259

        EC_MASTER_WARN(device->master, "Device already closed!\n");

   260

        return 0;

   261

    }

   262

   263

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)

   264

    ret = device->dev->netdev_ops->ndo_stop(device->dev);

   265

#else

   266

    ret = device->dev->stop(device->dev);

   267

#endif

   268

    if (!ret)

   269

        device->open = 0;

   270

   271

    return ret;

   272

}

   273

   274

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

   275

   276

/** Returns a pointer to the device's transmit memory.

   277

 *

   278

 * \return pointer to the TX socket buffer

   279

 */

   280

uint8_t *ec_device_tx_data(

   281

        ec_device_t *device /**< EtherCAT device */

   282

        )

   283

{

   284

    /* cycle through socket buffers, because otherwise there is a race

   285

     * condition, if multiple frames are sent and the DMA is not scheduled in

   286

     * between. */

   287

    device->tx_ring_index++;

   288

    device->tx_ring_index %= EC_TX_RING_SIZE;

   289

    return device->tx_skb[device->tx_ring_index]->data + ETH_HLEN;

   290

}

   291

   292

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

   293

   294

/** Sends the content of the transmit socket buffer.

   295

 *

   296

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

   297

 * start_xmit() function of the assigned net_device.

   298

 */

   299

void ec_device_send(

   300

        ec_device_t *device, /**< EtherCAT device */

   301

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

   302

        )

   303

{

   304

    struct sk_buff *skb = device->tx_skb[device->tx_ring_index];

   305

   306

    // set the right length for the data

   307

    skb->len = ETH_HLEN + size;

   308

   309

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

   310

        EC_MASTER_DBG(device->master, 2, "Sending frame:\n");

   311

        ec_print_data(skb->data, ETH_HLEN + size);

   312

    }

   313

   314

    // start sending

   315

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)

   316

    if (device->dev->netdev_ops->ndo_start_xmit(skb, device->dev) ==

   317

            NETDEV_TX_OK)

   318

#else

   319

    if (device->dev->hard_start_xmit(skb, device->dev) == NETDEV_TX_OK)

   320

#endif

   321

    {

   322

        device->tx_count++;

   323

        device->master->device_stats.tx_count++;

   324

        device->tx_bytes += ETH_HLEN + size;

   325

        device->master->device_stats.tx_bytes += ETH_HLEN + size;

   326

#ifdef EC_DEBUG_IF

   327

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

   328

#endif

   329

#ifdef EC_DEBUG_RING

   330

        ec_device_debug_ring_append(

   331

                device, TX, skb->data + ETH_HLEN, size);

   332

#endif

   333

    } else {

   334

        device->tx_errors++;

   335

    }

   336

}

   337

   338

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

   339

   340

/** Clears the frame statistics.

   341

 */

   342

void ec_device_clear_stats(

   343

        ec_device_t *device /**< EtherCAT device */

   344

        )

   345

{

   346

    unsigned int i;

   347

   348

    // zero frame statistics

   349

    device->tx_count = 0;

   350

    device->last_tx_count = 0;

   351

    device->rx_count = 0;

   352

    device->last_rx_count = 0;

   353

    device->tx_bytes = 0;

   354

    device->last_tx_bytes = 0;

   355

    device->rx_bytes = 0;

   356

    device->last_rx_bytes = 0;

   357

    device->tx_errors = 0;

   358

   359

    for (i = 0; i < EC_RATE_COUNT; i++) {

   360

        device->tx_frame_rates[i] = 0;

   361

        device->rx_frame_rates[i] = 0;

   362

        device->tx_byte_rates[i] = 0;

   363

        device->rx_byte_rates[i] = 0;

   364

    }

   365

}

   366

   367

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

   368

   369

#ifdef EC_DEBUG_RING

   370

/** Appends frame data to the debug ring.

   371

 */

   372

void ec_device_debug_ring_append(

   373

        ec_device_t *device, /**< EtherCAT device */

   374

        ec_debug_frame_dir_t dir, /**< direction */

   375

        const void *data, /**< frame data */

   376

        size_t size /**< data size */

   377

        )

   378

{

   379

    ec_debug_frame_t *df = &device->debug_frames[device->debug_frame_index];

   380

   381

    df->dir = dir;

   382

    if (dir == TX)

   383

        do_gettimeofday(&df->t);

   384

    else

   385

        df->t = device->timeval_poll;

   386

    memcpy(df->data, data, size);

   387

    df->data_size = size;

   388

   389

    device->debug_frame_index++;

   390

    device->debug_frame_index %= EC_DEBUG_RING_SIZE;

   391

    if (unlikely(device->debug_frame_count < EC_DEBUG_RING_SIZE))

   392

        device->debug_frame_count++;

   393

}

   394

   395

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

   396

   397

/** Outputs the debug ring.

   398

 */

   399

void ec_device_debug_ring_print(

   400

        const ec_device_t *device /**< EtherCAT device */

   401

        )

   402

{

   403

    int i;

   404

    unsigned int ring_index;

   405

    const ec_debug_frame_t *df;

   406

    struct timeval t0, diff;

   407

   408

    // calculate index of the newest frame in the ring to get its time

   409

    ring_index = (device->debug_frame_index + EC_DEBUG_RING_SIZE - 1)

   410

        % EC_DEBUG_RING_SIZE;

   411

    t0 = device->debug_frames[ring_index].t;

   412

   413

    EC_MASTER_DBG(device->master, 1, "Debug ring %u:\n", ring_index);

   414

   415

    // calculate index of the oldest frame in the ring

   416

    ring_index = (device->debug_frame_index + EC_DEBUG_RING_SIZE

   417

            - device->debug_frame_count) % EC_DEBUG_RING_SIZE;

   418

   419

    for (i = 0; i < device->debug_frame_count; i++) {

   420

        df = &device->debug_frames[ring_index];

   421

        timersub(&t0, &df->t, &diff);

   422

   423

        EC_MASTER_DBG(device->master, 1, "Frame %u, dt=%u.%06u s, %s:\n",

   424

                i + 1 - device->debug_frame_count,

   425

                (unsigned int) diff.tv_sec,

   426

                (unsigned int) diff.tv_usec,

   427

                (df->dir == TX) ? "TX" : "RX");

   428

        ec_print_data(df->data, df->data_size);

   429

   430

        ring_index++;

   431

        ring_index %= EC_DEBUG_RING_SIZE;

   432

    }

   433

}

   434

#endif

   435

   436

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

   437

   438

/** Calls the poll function of the assigned net_device.

   439

 *

   440

 * The master itself works without using interrupts. Therefore the processing

   441

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

   442

 * done by the master calling the ISR "manually".

   443

 */

   444

void ec_device_poll(

   445

        ec_device_t *device /**< EtherCAT device */

   446

        )

   447

{

   448

#ifdef EC_HAVE_CYCLES

   449

    device->cycles_poll = get_cycles();

   450

#endif

   451

    device->jiffies_poll = jiffies;

   452

#ifdef EC_DEBUG_RING

   453

    do_gettimeofday(&device->timeval_poll);

   454

#endif

   455

    device->poll(device->dev);

   456

}

   457

   458

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

   459

   460

/** Update device statistics.

   461

 */

   462

void ec_device_update_stats(

   463

        ec_device_t *device /**< EtherCAT device */

   464

        )

   465

{

   466

    unsigned int i;

   467

   468

    s32 tx_frame_rate = (device->tx_count - device->last_tx_count) * 1000;

   469

    s32 rx_frame_rate = (device->rx_count - device->last_rx_count) * 1000;

   470

    s32 tx_byte_rate = (device->tx_bytes - device->last_tx_bytes);

   471

    s32 rx_byte_rate = (device->rx_bytes - device->last_rx_bytes);

   472

   473

    /* Low-pass filter:

   474

     *      Y_n = y_(n - 1) + T / tau * (x - y_(n - 1))   | T = 1

   475

     *   -> Y_n += (x - y_(n - 1)) / tau

   476

     */

   477

    for (i = 0; i < EC_RATE_COUNT; i++) {

   478

        s32 n = rate_intervals[i];

   479

        device->tx_frame_rates[i] +=

   480

            (tx_frame_rate - device->tx_frame_rates[i]) / n;

   481

        device->rx_frame_rates[i] +=

   482

            (rx_frame_rate - device->rx_frame_rates[i]) / n;

   483

        device->tx_byte_rates[i] +=

   484

            (tx_byte_rate - device->tx_byte_rates[i]) / n;

   485

        device->rx_byte_rates[i] +=

   486

            (rx_byte_rate - device->rx_byte_rates[i]) / n;