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

/** Constructor.

    64

 * 

    65

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

    66

 */

    67

int ec_device_init(

    68

        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

/** Destuctor.

   133

 */

   134

void ec_device_clear(

   135

        ec_device_t *device /**< EtherCAT device */

   136

        )

   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

/** Associate with net_device.

   151

 */

   152

void ec_device_attach(

   153

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

   154

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

   155

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

   156

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

   157

        )

   158

{

   159

    unsigned int i;

   160

    struct ethhdr *eth;

   161

   162

    ec_device_detach(device); // resets fields

   163

   164

    device->dev = net_dev;

   165

    device->poll = poll;

   166

    device->module = module;

   167

   168

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

   169

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

   170

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

   171

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

   172

    }

   173

}

   174

   175

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

   176

   177

/** Disconnect from net_device.

   178

 */

   179

void ec_device_detach(

   180

        ec_device_t *device /**< EtherCAT device */

   181

        )

   182

{

   183

    unsigned int i;

   184

   185

    device->dev = NULL;

   186

    device->poll = NULL;

   187

    device->module = NULL;

   188

    device->open = 0;

   189

    device->link_state = 0; // down

   190

    device->tx_count = 0;

   191

    device->rx_count = 0;

   192

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

   193

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

   194

}

   195

   196

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

   197

   198

/** Opens the EtherCAT device.

   199

 *

   200

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

   201

 */

   202

int ec_device_open(

   203

        ec_device_t *device /**< EtherCAT device */

   204

        )

   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

/** Stops the EtherCAT device.

   228

 *

   229

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

   230

 */

   231

int ec_device_close(

   232

        ec_device_t *device /**< EtherCAT device */

   233

        )

   234

{

   235

    if (!device->dev) {

   236

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

   237

        return -1;

   238

    }

   239

   240

    if (!device->open) {

   241

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

   242

        return 0;

   243

    }

   244

   245

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

   246

   247

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

   248

}

   249

   250

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

   251

   252

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

   253

 *

   254

 * \return pointer to the TX socket buffer

   255

 */

   256

uint8_t *ec_device_tx_data(

   257

        ec_device_t *device /**< EtherCAT device */

   258

        )

   259

{

   260

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

   261

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

   262

     * between. */

   263

    device->tx_ring_index++;

   264

    device->tx_ring_index %= EC_TX_RING_SIZE;

   265

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

   266

}

   267

   268

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

   269

   270

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

   271

 *

   272

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

   273

 * start_xmit() function of the assigned net_device.

   274

 */

   275

void ec_device_send(

   276

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

   277

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

   278

        )

   279

{

   280

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

   281

   282

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

   283

        return;

   284

   285

    // set the right length for the data

   286

    skb->len = ETH_HLEN + size;

   287

   288

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

   289

        EC_DBG("sending frame:\n");

   290

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

   291

    }

   292

   293

    // start sending

   294

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

   295

		device->tx_count++;

   296

#ifdef EC_DEBUG_IF

   297

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

   298

#endif

   299

#ifdef EC_DEBUG_RING

   300

		ec_device_debug_ring_append(

   301

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

   302

#endif

   303

	}

   304

}

   305

   306

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

   307

   308

#ifdef EC_DEBUG_RING

   309

/** Appends frame data to the debug ring.

   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

/** Outputs the debug ring.

   337

 */

   338

void ec_device_debug_ring_print(

   339

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

   340

        )

   341

{

   342

    int i;

   343

    unsigned int ring_index;

   344

    const ec_debug_frame_t *df;

   345

    struct timeval t0, diff;

   346

   347

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

   348

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

   349

        % EC_DEBUG_RING_SIZE;

   350

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

   351

   352

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

   353

   354

    // calculate index of the oldest frame in the ring

   355

    ring_index = (device->debug_frame_index + EC_DEBUG_RING_SIZE

   356

            - device->debug_frame_count) % EC_DEBUG_RING_SIZE;

   357

   358

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

   359

        df = &device->debug_frames[ring_index];

   360

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

   361

   362

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

   363

                i + 1 - device->debug_frame_count,

   364

                (unsigned int) diff.tv_sec,

   365

                (unsigned int) diff.tv_usec,

   366

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

   367

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

   368

   369

        ring_index++;

   370

        ring_index %= EC_DEBUG_RING_SIZE;

   371

    }

   372

}

   373

#endif

   374

   375

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

   376

   377

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

   378

 *

   379

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

   380

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

   381

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

   382

 */

   383

void ec_device_poll(

   384

        ec_device_t *device /**< EtherCAT device */

   385

        )

   386

{

   387

    device->cycles_poll = get_cycles();

   388

    device->jiffies_poll = jiffies;

   389

#ifdef EC_DEBUG_RING

   390

    do_gettimeofday(&device->timeval_poll);

   391

#endif

   392

    device->poll(device->dev);

   393

}

   394

   395

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

   396

 *  Device interface

   397

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

   398

   399

/** Withdraws an EtherCAT device from the master.

   400

 *

   401

 * The device is disconnected from the master and all device ressources

   402

 * are freed.

   403

 *

   404

 * \attention Before calling this function, the ecdev_stop() function has

   405

 *            to be called, to be sure that the master does not use the device

   406

 *            any more.

   407

 * \ingroup DeviceInterface

   408

 */

   409

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

   410

{

   411

    ec_master_t *master = device->master;

   412

    char str[20];

   413

   414

    ec_mac_print(device->dev->dev_addr, str);

   415

    EC_INFO("Master %u releasing main device %s.\n", master->index, str);

   416

   417

    down(&master->device_sem);

   418

    ec_device_detach(device);

   419

    up(&master->device_sem);

   420

}

   421

   422

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

   423

   425

 *

   426

 * \return 0 on success, else < 0

   427

 * \ingroup DeviceInterface

   428

 */

   429

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

   430

{

   431

    if (ec_device_open(device)) {

   432

        EC_ERR("Failed to open device!\n");

   433

        return -1;

   434

    }

   435

   438

        return -1;

   439

    }

   440

   441

    return 0;

   442

}

   443

   444

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

   445

   447

 *

   448

 * \return 0 on success, else < 0

   449

 * \ingroup DeviceInterface

   450

 */

   451

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

   452

{

   454

   455

    if (ec_device_close(device))

   456

        EC_WARN("Failed to close device!\n");

   457

}

   458

   459

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

   460

   461

/** Accepts a received frame.

   462

 *

   463

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

   464

 * and dispatch the received commands to the sending instances.

   465

 * 

   466

 * \ingroup DeviceInterface

   467

 */

   468

void ecdev_receive(

   469

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

   470

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

   471

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

   472

        )

   473

{

   474

    const void *ec_data = data + ETH_HLEN;

   475

    size_t ec_size = size - ETH_HLEN;

   476

    device->rx_count++;

   477

   478

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

   479

        EC_DBG("Received frame:\n");

   480

        ec_print_data(ec_data, ec_size);

   481

    }

   482

   483

#ifdef EC_DEBUG_IF

   484

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

   485

#endif

   486

#ifdef EC_DEBUG_RING

   487

    ec_device_debug_ring_append(device, RX, ec_data, ec_size);

   488

#endif