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

/** List of intervals for frame statistics [s].

    58

 */

    59

static const unsigned int rate_intervals[] = {

    60

    1, 10, 60

    61

};

    62

    63

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

    64

    65

/** Constructor.

    66

 * 

    67

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

    68

 */

    69

int ec_device_init(

    70

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

    71

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

    72

        )

    73

{

    74

    int ret;

    75

    unsigned int i;

    76

    struct ethhdr *eth;

    77

#ifdef EC_DEBUG_IF

    78

    char ifname[10];

    79

    char mb = 'x';

    80

#endif

    81

#ifdef EC_DEBUG_RING

    82

    device->debug_frame_index = 0;

    83

    device->debug_frame_count = 0;

    84

#endif

    85

    86

    device->master = master;

    87

    device->tx_ring_index = 0;

    88

    89

#ifdef EC_DEBUG_IF

    90

    if (device == &master->main_device)

    91

        mb = 'm';

    92

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

    93

        mb = 'b';

    94

    95

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

    96

    97

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

    98

    if (ret < 0) {

    99

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

   100

        goto out_return;

   101

    }

   102

#endif

   103

   104

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

   105

        device->tx_skb[i] = NULL;

   106

   107

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

   108

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

   109

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

   110

            ret = -ENOMEM;

   111

            goto out_tx_ring;

   112

        }

   113

   114

        // add Ethernet-II-header

   115

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

   116

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

   117

        eth->h_proto = htons(0x88A4);

   118

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

   119

    }

   120

   121

    ec_device_detach(device); // resets remaining fields

   122

    return 0;

   123

   124

out_tx_ring:

   125

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

   126

        if (device->tx_skb[i])

   127

            dev_kfree_skb(device->tx_skb[i]);

   128

#ifdef EC_DEBUG_IF

   129

    ec_debug_clear(&device->dbg);

   130

out_return:

   131

#endif

   132

    return ret;

   133

}

   134

   135

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

   136

   137

/** Destructor.

   138

 */

   139

void ec_device_clear(

   140

        ec_device_t *device /**< EtherCAT device */

   141

        )

   142

{

   143

    unsigned int i;

   144

   145

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

   146

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

   147

        dev_kfree_skb(device->tx_skb[i]);

   148

#ifdef EC_DEBUG_IF

   149

    ec_debug_clear(&device->dbg);

   150

#endif

   151

}

   152

   153

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

   154

   155

/** Associate with net_device.

   156

 */

   157

void ec_device_attach(

   158

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

   159

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

   160

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

   161

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

   162

        )

   163

{

   164

    unsigned int i;

   165

    struct ethhdr *eth;

   166

   167

    ec_device_detach(device); // resets fields

   168

   169

    device->dev = net_dev;

   170

    device->poll = poll;

   171

    device->module = module;

   172

   173

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

   174

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

   175

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

   176

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

   177

    }

   178

   179

#ifdef EC_DEBUG_IF

   180

    ec_debug_register(&device->dbg, net_dev);

   181

#endif

   182

}

   183

   184

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

   185

   186

/** Disconnect from net_device.

   187

 */

   188

void ec_device_detach(

   189

        ec_device_t *device /**< EtherCAT device */

   190

        )

   191

{

   192

    unsigned int i;

   193

   194

#ifdef EC_DEBUG_IF

   195

    ec_debug_unregister(&device->dbg);

   196

#endif

   197

   198

    device->dev = NULL;

   199

    device->poll = NULL;

   200

    device->module = NULL;

   201

    device->open = 0;

   202

    device->link_state = 0; // down

   203

   204

    ec_device_clear_stats(device);

   205

   206

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

   207

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

   208

}

   209

   210

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

   211

   212

/** Opens the EtherCAT device.

   213

 *

   214

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

   215

 */

   216

int ec_device_open(

   217

        ec_device_t *device /**< EtherCAT device */

   218

        )

   219

{

   220

    int ret;

   221

   222

    if (!device->dev) {

   223

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

   224

        return -ENODEV;

   225

    }

   226

   227

    if (device->open) {

   228

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

   229

        return 0;

   230

    }

   231

   232

    device->link_state = 0;

   233

   234

    ec_device_clear_stats(device);

   235

   236

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

   237

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

   238

#else

   239

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

   240

#endif

   241

    if (!ret)

   242

        device->open = 1;

   243

   244

    return ret;

   245

}

   246

   247

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

   248

   249

/** Stops the EtherCAT device.

   250

 *

   251

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

   252

 */

   253

int ec_device_close(

   254

        ec_device_t *device /**< EtherCAT device */

   255

        )

   256

{

   257

    int ret;

   258

   259

    if (!device->dev) {

   260

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

   261

        return -ENODEV;

   262

    }

   263

   264

    if (!device->open) {

   265

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

   266

        return 0;

   267

    }

   268

   269

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

   270

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

   271

#else

   272

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

   273

#endif

   274

    if (!ret)

   275

        device->open = 0;

   276

   277

    return ret;

   278

}

   279

   280

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

   281

   282

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

   283

 *

   284

 * \return pointer to the TX socket buffer

   285

 */

   286

uint8_t *ec_device_tx_data(

   287

        ec_device_t *device /**< EtherCAT device */

   288

        )

   289

{

   290

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

   291

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

   292

     * between. */

   293

    device->tx_ring_index++;

   294

    device->tx_ring_index %= EC_TX_RING_SIZE;

   295

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

   296

}

   297

   298

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

   299

   300

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

   301

 *

   302

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

   303

 * start_xmit() function of the assigned net_device.

   304

 */

   305

void ec_device_send(

   306

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

   307

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

   308

        )

   309

{

   310

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

   311

   312

    // frame statistics

   313

    if (unlikely(jiffies - device->stats_jiffies >= HZ)) {

   314

        unsigned int i;

   315

        u32 tx_frame_rate =

   316

            (u32) (device->tx_count - device->last_tx_count) * 1000;

   317

        u32 tx_byte_rate =

   318

            (device->tx_bytes - device->last_tx_bytes) * 1000;

   319

        u64 loss = device->tx_count - device->rx_count;

   320

        s32 loss_rate = (s32) (loss - device->last_loss) * 1000;

   321

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

   322

            unsigned int n = rate_intervals[i];

   323

            device->tx_frame_rates[i] =

   324

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

   325

            device->tx_byte_rates[i] =

   326

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

   327

            device->loss_rates[i] =

   328

                (device->loss_rates[i] * (n - 1) + loss_rate) / n;

   329

        }

   330

        device->last_tx_count = device->tx_count;

   331

        device->last_tx_bytes = device->tx_bytes;

   332

        device->last_loss = loss;

   333

        device->stats_jiffies = jiffies;

   334

    }

   335

   336

    // set the right length for the data

   337

    skb->len = ETH_HLEN + size;

   338

   339

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

   340

        EC_DBG("Sending frame:\n");

   341

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

   342

    }

   343

   344

    // start sending

   345

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

   346

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

   347

            NETDEV_TX_OK)

   348

#else

   349

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

   350

#endif

   351

    {

   352

        device->tx_count++;

   353

        device->tx_bytes += ETH_HLEN + size;

   354

#ifdef EC_DEBUG_IF

   355

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

   356

#endif

   357

#ifdef EC_DEBUG_RING

   358

        ec_device_debug_ring_append(

   359

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

   360

#endif

   361

    } else {

   362

        device->tx_errors++;

   363

    }

   364

}

   365

   366

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

   367

   368

/** Clears the frame statistics.

   369

 */

   370

void ec_device_clear_stats(

   371

        ec_device_t *device /**< EtherCAT device */

   372

        )

   373

{

   374

    unsigned int i;

   375

   376

    // zero frame statistics

   377

    device->tx_count = 0;

   378

    device->rx_count = 0;

   379

    device->tx_errors = 0;

   380

    device->tx_bytes = 0;

   381

    device->last_tx_count = 0;

   382

    device->last_tx_bytes = 0;

   383

    device->last_loss = 0;

   384

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

   385

        device->tx_frame_rates[i] = 0;

   386

        device->tx_byte_rates[i] = 0;

   387

        device->loss_rates[i] = 0;

   388

    }

   389

}

   390

   391

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

   392

   393

#ifdef EC_DEBUG_RING

   394

/** Appends frame data to the debug ring.

   395

 */

   396

void ec_device_debug_ring_append(

   397

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

   398

        ec_debug_frame_dir_t dir, /**< direction */

   399

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

   400

        size_t size /**< data size */

   401

        )

   402

{

   403

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

   404

   405

    df->dir = dir;

   406

    if (dir == TX)

   407

        do_gettimeofday(&df->t);

   408

    else

   409

        df->t = device->timeval_poll;

   410

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

   411

    df->data_size = size;

   412

   413

    device->debug_frame_index++;

   414

    device->debug_frame_index %= EC_DEBUG_RING_SIZE;

   415

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

   416

        device->debug_frame_count++;

   417

}

   418

   419

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

   420

   421

/** Outputs the debug ring.

   422

 */

   423

void ec_device_debug_ring_print(

   424

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

   425

        )

   426

{

   427

    int i;

   428

    unsigned int ring_index;

   429

    const ec_debug_frame_t *df;

   430

    struct timeval t0, diff;

   431

   432

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

   433

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

   434

        % EC_DEBUG_RING_SIZE;

   435

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

   436

   437

    EC_DBG("Debug ring %u:\n", ring_index);

   438

   439

    // calculate index of the oldest frame in the ring

   440

    ring_index = (device->debug_frame_index + EC_DEBUG_RING_SIZE

   441

            - device->debug_frame_count) % EC_DEBUG_RING_SIZE;

   442

   443

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

   444

        df = &device->debug_frames[ring_index];

   445

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

   446

   447

        EC_DBG("Frame %u, dt=%u.%06u s, %s:\n",

   448

                i + 1 - device->debug_frame_count,

   449

                (unsigned int) diff.tv_sec,

   450

                (unsigned int) diff.tv_usec,

   451

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

   452

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

   453

   454

        ring_index++;

   455

        ring_index %= EC_DEBUG_RING_SIZE;

   456

    }

   457

}

   458

#endif

   459

   460

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

   461

   462

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

   463

 *

   464

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

   465

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

   466

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

   467

 */

   468

void ec_device_poll(

   469

        ec_device_t *device /**< EtherCAT device */

   470

        )

   471

{

   472

#ifdef EC_HAVE_CYCLES

   473

    device->cycles_poll = get_cycles();

   474

#endif

   475

    device->jiffies_poll = jiffies;

   476

#ifdef EC_DEBUG_RING

   477

    do_gettimeofday(&device->timeval_poll);

   478

#endif

   479

    device->poll(device->dev);

   480

}

   481

   482

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

   483

 *  Device interface

   484

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

   485

   486

/** Withdraws an EtherCAT device from the master.