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

    76

    device->master = master;

    77

    device->dev = NULL;

    78

    device->poll = NULL;

    79

    device->module = NULL;

    80

    device->open = 0;

    81

    device->link_state = 0;

    82

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

    83

        device->tx_skb[i] = NULL;

    84

    }

    85

    device->tx_ring_index = 0;

    86

#ifdef EC_HAVE_CYCLES

    87

    device->cycles_poll = 0;

    88

#endif

    89

#ifdef EC_DEBUG_RING

    90

    device->timeval_poll.tv_sec = 0;

    91

    device->timeval_poll.tv_usec = 0;

    92

#endif

    93

    device->jiffies_poll = 0;

    94

    95

    ec_device_clear_stats(device);

    96

    97

#ifdef EC_DEBUG_RING

    98

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

    99

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

   100

        df->dir = TX;

   101

        df->t.tv_sec = 0;

   102

        df->t.tv_usec = 0;

   103

        memset(df->data, 0, EC_MAX_DATA_SIZE);

   104

        df->data_size = 0;

   105

    }

   106

#endif

   107

#ifdef EC_DEBUG_RING

   108

    device->debug_frame_index = 0;

   109

    device->debug_frame_count = 0;

   110

#endif

   111

   112

#ifdef EC_DEBUG_IF

   113

    if (device == &master->devices[EC_DEVICE_MAIN]) {

   114

        mb = 'm';

   115

    }

   116

    else {

   117

        mb = 'b';

   118

    }

   119

   120

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

   121

   122

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

   123

    if (ret < 0) {

   124

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

   125

        goto out_return;

   126

    }

   127

#endif

   128

   129

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

   130

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

   131

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

   132

            ret = -ENOMEM;

   133

            goto out_tx_ring;

   134

        }

   135

   136

        // add Ethernet-II-header

   137

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

   138

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

   139

        eth->h_proto = htons(0x88A4);

   140

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

   141

    }

   142

   143

    return 0;

   144

   145

out_tx_ring:

   146

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

   147

        if (device->tx_skb[i]) {

   148

            dev_kfree_skb(device->tx_skb[i]);

   149

        }

   150

    }

   151

#ifdef EC_DEBUG_IF

   152

    ec_debug_clear(&device->dbg);

   153

out_return:

   154

#endif

   155

    return ret;

   156

}

   157

   158

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

   159

   160

/** Destructor.

   161

 */

   162

void ec_device_clear(

   163

        ec_device_t *device /**< EtherCAT device */

   164

        )

   165

{

   166

    unsigned int i;

   167

   168

    if (device->open) {

   169

        ec_device_close(device);

   170

    }

   171

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

   172

        dev_kfree_skb(device->tx_skb[i]);

   173

#ifdef EC_DEBUG_IF

   174

    ec_debug_clear(&device->dbg);

   175

#endif

   176

}

   177

   178

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

   179

   180

/** Associate with net_device.

   181

 */

   182

void ec_device_attach(

   183

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

   184

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

   185

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

   186

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

   187

        )

   188

{

   189

    unsigned int i;

   190

    struct ethhdr *eth;

   191

   192

    ec_device_detach(device); // resets fields

   193

   194

    device->dev = net_dev;

   195

    device->poll = poll;

   196

    device->module = module;

   197

   198

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

   199

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

   200

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

   201

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

   202

    }

   203

   204

#ifdef EC_DEBUG_IF

   205

    ec_debug_register(&device->dbg, net_dev);

   206

#endif

   207

}

   208

   209

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

   210

   211

/** Disconnect from net_device.

   212

 */

   213

void ec_device_detach(

   214

        ec_device_t *device /**< EtherCAT device */

   215

        )

   216

{

   217

    unsigned int i;

   218

   219

#ifdef EC_DEBUG_IF

   220

    ec_debug_unregister(&device->dbg);

   221

#endif

   222

   223

    device->dev = NULL;

   224

    device->poll = NULL;

   225

    device->module = NULL;

   226

    device->open = 0;

   227

    device->link_state = 0; // down

   228

   229

    ec_device_clear_stats(device);

   230

   231

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

   232

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

   233

    }

   234

}

   235

   236

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

   237

   238

/** Opens the EtherCAT device.

   239

 *

   240

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

   241

 */

   242

int ec_device_open(

   243

        ec_device_t *device /**< EtherCAT device */

   244

        )

   245

{

   246

    int ret;

   247

   248

    if (!device->dev) {

   249

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

   250

        return -ENODEV;

   251

    }

   252

   253

    if (device->open) {

   254

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

   255

        return 0;

   256

    }

   257

   258

    device->link_state = 0;

   259

   260

    ec_device_clear_stats(device);

   261

   262

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

   263

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

   264

#else

   265

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

   266

#endif

   267

    if (!ret)

   268

        device->open = 1;

   269

   270

    return ret;

   271

}

   272

   273

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

   274

   275

/** Stops the EtherCAT device.

   276

 *

   277

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

   278

 */

   279

int ec_device_close(

   280

        ec_device_t *device /**< EtherCAT device */

   281

        )

   282

{

   283

    int ret;

   284

   285

    if (!device->dev) {

   286

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

   287

        return -ENODEV;

   288

    }

   289

   290

    if (!device->open) {

   291

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

   292

        return 0;

   293

    }

   294

   295

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

   296

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

   297

#else

   298

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

   299

#endif

   300

    if (!ret)

   301

        device->open = 0;

   302

   303

    return ret;

   304

}

   305

   306

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

   307

   308

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

   309

 *

   310

 * \return pointer to the TX socket buffer

   311

 */

   312

uint8_t *ec_device_tx_data(

   313

        ec_device_t *device /**< EtherCAT device */

   314

        )

   315

{

   316

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

   317

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

   318

     * between. */

   319

    device->tx_ring_index++;

   320

    device->tx_ring_index %= EC_TX_RING_SIZE;

   321

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

   322

}

   323

   324

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

   325

   326

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

   327

 *

   328

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

   329

 * start_xmit() function of the assigned net_device.

   330

 */

   331

void ec_device_send(

   332

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

   333

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

   334

        )

   335

{

   336

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

   337

   338

    // set the right length for the data

   339

    skb->len = ETH_HLEN + size;

   340

   341

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

   342

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

   343

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

   344

    }

   345

   346

    // start sending

   347

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

   348

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

   349

            NETDEV_TX_OK)

   350

#else

   351

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

   352

#endif

   353

    {

   354

        device->tx_count++;

   355

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

   356

        device->tx_bytes += ETH_HLEN + size;

   357

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

   358

#ifdef EC_DEBUG_IF

   359

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

   360

#endif

   361

#ifdef EC_DEBUG_RING

   362

        ec_device_debug_ring_append(

   363

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

   364

#endif

   365

    } else {

   366

        device->tx_errors++;

   367

    }

   368

}

   369

   370

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

   371

   372

/** Clears the frame statistics.

   373

 */

   374

void ec_device_clear_stats(

   375

        ec_device_t *device /**< EtherCAT device */

   376

        )

   377

{

   378

    unsigned int i;

   379

   380

    // zero frame statistics

   381

    device->tx_count = 0;

   382

    device->last_tx_count = 0;

   383

    device->rx_count = 0;

   384

    device->last_rx_count = 0;

   385

    device->tx_bytes = 0;

   386

    device->last_tx_bytes = 0;

   387

    device->rx_bytes = 0;

   388

    device->last_rx_bytes = 0;

   389

    device->tx_errors = 0;

   390

   391

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

   392

        device->tx_frame_rates[i] = 0;

   393

        device->rx_frame_rates[i] = 0;

   394

        device->tx_byte_rates[i] = 0;

   395

        device->rx_byte_rates[i] = 0;

   396

    }

   397

}

   398

   399

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

   400

   401

#ifdef EC_DEBUG_RING

   402

/** Appends frame data to the debug ring.

   403

 */

   404

void ec_device_debug_ring_append(

   405

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

   406

        ec_debug_frame_dir_t dir, /**< direction */

   407

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

   408

        size_t size /**< data size */

   409

        )

   410

{

   411

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

   412

   413

    df->dir = dir;

   414

    if (dir == TX) {

   415

        do_gettimeofday(&df->t);

   416

    }

   417

    else {

   418

        df->t = device->timeval_poll;

   419

    }

   420

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

   421

    df->data_size = size;

   422

   423

    device->debug_frame_index++;

   424

    device->debug_frame_index %= EC_DEBUG_RING_SIZE;

   425

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

   426

        device->debug_frame_count++;

   427

}

   428

   429

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

   430

   431

/** Outputs the debug ring.

   432

 */

   433

void ec_device_debug_ring_print(

   434

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

   435

        )

   436

{

   437

    int i;

   438

    unsigned int ring_index;

   439

    const ec_debug_frame_t *df;

   440

    struct timeval t0, diff;

   441

   442

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

   443

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

   444

        % EC_DEBUG_RING_SIZE;

   445

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

   446

   447

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

   448

   449

    // calculate index of the oldest frame in the ring

   450

    ring_index = (device->debug_frame_index + EC_DEBUG_RING_SIZE

   451

            - device->debug_frame_count) % EC_DEBUG_RING_SIZE;

   452

   453

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

   454

        df = &device->debug_frames[ring_index];

   455

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

   456

   457

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

   458

                i + 1 - device->debug_frame_count,

   459

                (unsigned int) diff.tv_sec,

   460

                (unsigned int) diff.tv_usec,

   461

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

   462

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

   463

   464

        ring_index++;

   465

        ring_index %= EC_DEBUG_RING_SIZE;

   466

    }

   467

}

   468

#endif

   469

   470

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

   471

   472

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

   473

 *

   474

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

   475

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

   476

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

   477

 */

   478

void ec_device_poll(

   479

        ec_device_t *device /**< EtherCAT device */

   480

        )

   481

{

   482

#ifdef EC_HAVE_CYCLES

   483

    device->cycles_poll = get_cycles();

   484

#endif

   485

    device->jiffies_poll = jiffies;

   486

#ifdef EC_DEBUG_RING