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

#ifdef EC_DEBUG_RING

    50

#define timersub(a, b, result) \

    51

    do { \

    52

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

    53

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

    54

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

    55

            --(result)->tv_sec; \

    56

            (result)->tv_usec += 1000000; \

    57

        } \

    58

    } while (0)

    59

#endif

    60

    61

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

    62

    63

/**

    64

   Device constructor.

    65

   \return 0 in case of success, else < 0

    66

*/

    67

    68

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

    69

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

    70

        )

    71

{

    72

    unsigned int i;

    73

    struct ethhdr *eth;

    74

#ifdef EC_DEBUG_IF

    75

    char ifname[10];

    76

    char mb = 'x';

    77

#endif

    78

#ifdef EC_DEBUG_RING

    79

    device->debug_frame_index = 0;

    80

    device->debug_frame_count = 0;

    81

#endif

    82

    83

    device->master = master;

    84

    device->tx_ring_index = 0;

    85

    86

#ifdef EC_DEBUG_IF

    87

    if (device == &master->main_device)

    88

        mb = 'm';

    89

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

    90

        mb = 'b';

    91

    92

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

    93

    94

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

    95

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

    96

        goto out_return;

    97

    }

    98

#endif

    99

   100

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

   101

        device->tx_skb[i] = NULL;

   102

   103

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

   104

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

   105

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

   106

            goto out_tx_ring;

   107

        }

   108

   109

        // add Ethernet-II-header

   110

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

   111

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

   112

        eth->h_proto = htons(0x88A4);

   113

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

   114

    }

   115

   116

    ec_device_detach(device); // resets remaining fields

   117

    return 0;

   118

   119

out_tx_ring:

   120

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

   121

        if (device->tx_skb[i])

   122

            dev_kfree_skb(device->tx_skb[i]);

   123

#ifdef EC_DEBUG_IF

   124

    ec_debug_clear(&device->dbg);

   125

out_return:

   126

#endif

   127

    return -1;

   128

}

   129

   130

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

   131

   132

/**

   133

   EtherCAT device destuctor.

   134

*/

   135

   136

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

   137

{

   138

    unsigned int i;

   139

   140

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

   141

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

   142

        dev_kfree_skb(device->tx_skb[i]);

   143

#ifdef EC_DEBUG_IF

   144

    ec_debug_clear(&device->dbg);

   145

#endif

   146

}

   147

   148

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

   149

   150

/**

   151

   Associate with net_device.

   152

*/

   153

   154

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

   155

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

   156

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

   157

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

   158

        )

   159

{

   160

    unsigned int i;

   161

    struct ethhdr *eth;

   162

   163

    ec_device_detach(device); // resets fields

   164

   165

    device->dev = net_dev;

   166

    device->poll = poll;

   167

    device->module = module;

   168

   169

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

   170

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

   171

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

   172

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

   173

    }

   174

}

   175

   176

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

   177

   178

/**

   179

   Disconnect from net_device.

   180

*/

   181

   182

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

   183

{

   184

    unsigned int i;

   185

   186

    device->dev = NULL;

   187

    device->poll = NULL;

   188

    device->module = NULL;

   189

    device->open = 0;

   190

    device->link_state = 0; // down

   191

    device->tx_count = 0;

   192

    device->rx_count = 0;

   193

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

   194

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

   195

}

   196

   197

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

   198

   199

/**

   200

   Opens the EtherCAT device.

   201

   \return 0 in case of success, else < 0

   202

*/

   203

   204

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

   205

{

   206

    if (!device->dev) {

   207

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

   208

        return -1;

   209

    }

   210

   211

    if (device->open) {

   212

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

   213

        return 0;

   214

    }

   215

   216

    device->link_state = 0;

   217

    device->tx_count = 0;

   218

    device->rx_count = 0;

   219

   220

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

   221

   222

    return device->open ? 0 : -1;

   223

}

   224

   225

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

   226

   227

/**

   228

   Stops the EtherCAT device.

   229

   \return 0 in case of success, else < 0

   230

*/

   231

   232

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

   233

{

   234

    if (!device->dev) {

   235

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

   236

        return -1;

   237

    }

   238

   239

    if (!device->open) {

   240

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

   241

        return 0;

   242

    }

   243

   244

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

   245

   246

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

   247

}

   248

   249

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

   250

   251

/**

   252

   Returns a pointer to the device's transmit memory.

   253

   \return pointer to the TX socket buffer

   254

*/

   255

   256

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

   257

{

   258

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

   259

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

   260

     * between. */

   261

    device->tx_ring_index++;

   262

    device->tx_ring_index %= EC_TX_RING_SIZE;

   263

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

   264

}

   265

   266

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

   267

   268

/**

   269

   Sends the content of the transmit socket buffer.

   270

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

   271

   start_xmit() function of the assigned net_device.

   272

*/

   273

   274

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

   275

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

   276

                    )

   277

{

   278

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

   279

   280

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

   281

        return;

   282

   283

    // set the right length for the data

   284

    skb->len = ETH_HLEN + size;

   285

   286

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

   287

        EC_DBG("sending frame:\n");

   288

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

   289

    }

   290

   291

#ifdef EC_DEBUG_IF

   292

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

   293

#endif

   294

#ifdef EC_DEBUG_RING

   295

    ec_device_debug_ring_append(

   296

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

   297

#endif

   298

   299

    // start sending

   300

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

   301

    device->tx_count++;

   302

}

   303

   304

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

   305

   306

#ifdef EC_DEBUG_RING

   307

/**

   308

 * Appends frame data to the debug ring.

   309

 */

   310

   311

void ec_device_debug_ring_append(

   312

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

   313

        ec_debug_frame_dir_t dir, /**< direction */

   314

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

   315

        size_t size /**< data size */

   316

        )

   317

{

   318

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

   319

   320

    df->dir = dir;

   321

    if (dir == TX)

   322

        do_gettimeofday(&df->t);

   323

    else

   324

        df->t = device->timeval_poll;

   325

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

   326

    df->data_size = size;

   327

   328

    device->debug_frame_index++;

   329

    device->debug_frame_index %= EC_DEBUG_RING_SIZE;

   330

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

   331

        device->debug_frame_count++;

   332

}

   333

   334

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

   335

   336

/**

   337

 * Outputs the debug ring.

   338

 */

   339

   340

void ec_device_debug_ring_print(

   341

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

   342

        )

   343

{

   344

    int i;

   345

    unsigned int ring_index;

   346

    const ec_debug_frame_t *df;

   347

    struct timeval t0, diff;

   348

   349

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

   350

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

   351

        % EC_DEBUG_RING_SIZE;

   352

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

   353

   354

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

   355

   356

    // calculate index of the oldest frame in the ring

   357

    ring_index = (device->debug_frame_index + EC_DEBUG_RING_SIZE

   358

            - device->debug_frame_count) % EC_DEBUG_RING_SIZE;

   359

   360

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

   361

        df = &device->debug_frames[ring_index];

   362

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

   363

   364

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

   365

                i + 1 - device->debug_frame_count,

   366

                (unsigned int) diff.tv_sec,

   367

                (unsigned int) diff.tv_usec,

   368

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

   369

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

   370

   371

        ring_index++;

   372

        ring_index %= EC_DEBUG_RING_SIZE;

   373

    }

   374

}

   375

#endif

   376

   377

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

   378

   379

/**

   380

   Calls the poll function of the assigned net_device.

   381

   The master itself works without using interrupts. Therefore the processing

   382

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

   383

   done by the master calling the ISR "manually".

   384

*/

   385

   386

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

   387

{

   388

    device->cycles_poll = get_cycles();

   389

    device->jiffies_poll = jiffies;

   390

#ifdef EC_DEBUG_RING

   391

    do_gettimeofday(&device->timeval_poll);

   392

#endif

   393

    device->poll(device->dev);

   394

}

   395

   396

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

   397

 *  Device interface

   398

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

   399

   400

/**

   401

   Accepts a received frame.

   402

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

   403

   and dispatch the received commands to the sending instances.

   404

   \ingroup DeviceInterface

   405

*/

   406

   407

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

   408

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

   409

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

   410

                   )

   411

{

   412

    const void *ec_data = data + ETH_HLEN;

   413

    size_t ec_size = size - ETH_HLEN;

   414

    device->rx_count++;

   415

   416

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

   417

        EC_DBG("Received frame:\n");

   418

        ec_print_data(ec_data, ec_size);

   419

    }

   420

   421

#ifdef EC_DEBUG_IF

   422

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

   423

#endif

   424

#ifdef EC_DEBUG_RING

   425

    ec_device_debug_ring_append(device, RX, ec_data, ec_size);

   426

#endif

   427

   428

    ec_master_receive_datagrams(device->master, ec_data, ec_size);

   429

}

   430

   431

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

   432

   433

/**

   434

   Sets a new link state.

   435

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

   436

   will not try to send frames using this device.

   437

   \ingroup DeviceInterface

   438

*/

   439

   440

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

   441

        uint8_t state /**< new link state */

   442

        )

   443

{

   444

    if (unlikely(!device)) {

   445

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

   446

        return;

   447

    }

   448

   449

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

   450

        device->link_state = state;

   451

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

   452

    }

   453

}

   454

   455

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

   456

   457

/**

   458

   Reads the link state.

   459

   \ingroup DeviceInterface

   460

*/

   461

   462

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

   463

{

   464

    if (unlikely(!device)) {

   465

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

   466

        return 0;

   467

    }

   468

   469

    return device->link_state;

   470

}

   471

   472

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

   473

   474

/** \cond */

   475

   476

EXPORT_SYMBOL(ecdev_receive);

   477

EXPORT_SYMBOL(ecdev_get_link);

   478

EXPORT_SYMBOL(ecdev_set_link);

   479

   480

/** \endcond */

   481

   482

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