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

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

    23

 *  the industrial property and similar rights of Beckhoff Automation GmbH.

    24

 *

    25

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

    26

    27

/**

    28

   \file

    29

   EtherCAT device methods.

    30

*/

    31

    32

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

    33

    34

#include <linux/module.h>

    35

#include <linux/skbuff.h>

    36

#include <linux/if_ether.h>

    37

#include <linux/netdevice.h>

    38

    39

#include "device.h"

    40

#include "master.h"

    41

    42

#ifdef EC_DEBUG_RING

    43

#define timersub(a, b, result) \

    44

    do { \

    45

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

    46

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

    47

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

    48

            --(result)->tv_sec; \

    49

            (result)->tv_usec += 1000000; \

    50

        } \

    51

    } while (0)

    52

#endif

    53

    54

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

    55

    56

/** Constructor.

    57

 * 

    58

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

    59

 */

    60

int ec_device_init(

    61

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

    62

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

    63

        )

    64

{

    65

    unsigned int i;

    66

    struct ethhdr *eth;

    67

#ifdef EC_DEBUG_IF

    68

    char ifname[10];

    69

    char mb = 'x';

    70

#endif

    71

#ifdef EC_DEBUG_RING

    72

    device->debug_frame_index = 0;

    73

    device->debug_frame_count = 0;

    74

#endif

    75

    76

    device->master = master;

    77

    device->tx_ring_index = 0;

    78

    79

#ifdef EC_DEBUG_IF

    80

    if (device == &master->main_device)

    81

        mb = 'm';

    82

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

    83

        mb = 'b';

    84

    85

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

    86

    87

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

    88

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

    89

        goto out_return;

    90

    }

    91

#endif

    92

    93

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

    94

        device->tx_skb[i] = NULL;

    95

    96

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

    97

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

    98

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

    99

            goto out_tx_ring;

   100

        }

   101

   102

        // add Ethernet-II-header

   103

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

   104

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

   105

        eth->h_proto = htons(0x88A4);

   106

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

   107

    }

   108

   109

    ec_device_detach(device); // resets remaining fields

   110

    return 0;

   111

   112

out_tx_ring:

   113

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

   114

        if (device->tx_skb[i])

   115

            dev_kfree_skb(device->tx_skb[i]);

   116

#ifdef EC_DEBUG_IF

   117

    ec_debug_clear(&device->dbg);

   118

out_return:

   119

#endif

   120

    return -1;

   121

}

   122

   123

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

   124

   125

/** Destuctor.

   126

 */

   127

void ec_device_clear(

   128

        ec_device_t *device /**< EtherCAT device */

   129

        )

   130

{

   131

    unsigned int i;

   132

   133

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

   134

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

   135

        dev_kfree_skb(device->tx_skb[i]);

   136

#ifdef EC_DEBUG_IF

   137

    ec_debug_clear(&device->dbg);

   138

#endif

   139

}

   140

   141

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

   142

   143

/** Associate with net_device.

   144

 */

   145

void ec_device_attach(

   146

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

   147

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

   148

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

   149

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

   150

        )

   151

{

   152

    unsigned int i;

   153

    struct ethhdr *eth;

   154

   155

    ec_device_detach(device); // resets fields

   156

   157

    device->dev = net_dev;

   158

    device->poll = poll;

   159

    device->module = module;

   160

   161

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

   162

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

   163

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

   164

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

   165

    }

   166

}

   167

   168

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

   169

   170

/** Disconnect from net_device.

   171

 */

   172

void ec_device_detach(

   173

        ec_device_t *device /**< EtherCAT device */

   174

        )

   175

{

   176

    unsigned int i;

   177

   178

    device->dev = NULL;

   179

    device->poll = NULL;

   180

    device->module = NULL;

   181

    device->open = 0;

   182

    device->link_state = 0; // down

   183

    device->tx_count = 0;

   184

    device->rx_count = 0;

   185

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

   186

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

   187

}

   188

   189

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

   190

   191

/** Opens the EtherCAT device.

   192

 *

   193

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

   194

 */

   195

int ec_device_open(

   196

        ec_device_t *device /**< EtherCAT device */

   197

        )

   198

{

   199

    if (!device->dev) {

   200

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

   201

        return -1;

   202

    }

   203

   204

    if (device->open) {

   205

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

   206

        return 0;

   207

    }

   208

   209

    device->link_state = 0;

   210

    device->tx_count = 0;

   211

    device->rx_count = 0;

   212

   213

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

   214

   215

    return device->open ? 0 : -1;

   216

}

   217

   218

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

   219

   220

/** Stops the EtherCAT device.

   221

 *

   222

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

   223

 */

   224

int ec_device_close(

   225

        ec_device_t *device /**< EtherCAT device */

   226

        )

   227

{

   228

    if (!device->dev) {

   229

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

   230

        return -1;

   231

    }

   232

   233

    if (!device->open) {

   234

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

   235

        return 0;

   236

    }

   237

   238

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

   239

   240

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

   241

}

   242

   243

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

   244

   245

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

   246

 *

   247

 * \return pointer to the TX socket buffer

   248

 */

   249

uint8_t *ec_device_tx_data(

   250

        ec_device_t *device /**< EtherCAT device */

   251

        )

   252

{

   253

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

   254

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

   255

     * between. */

   256

    device->tx_ring_index++;

   257

    device->tx_ring_index %= EC_TX_RING_SIZE;

   258

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

   259

}

   260

   261

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

   262

   263

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

   264

 *

   265

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

   266

 * start_xmit() function of the assigned net_device.

   267

 */

   268

void ec_device_send(

   269

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

   270

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

   271

        )

   272

{

   273

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

   274

   275

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

   276

        return;

   277

   278

    // set the right length for the data

   279

    skb->len = ETH_HLEN + size;

   280

   281

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

   282

        EC_DBG("sending frame:\n");

   283

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

   284

    }

   285

   286

    // start sending

   287

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

   288

		device->tx_count++;

   289

#ifdef EC_DEBUG_IF

   290

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

   291

#endif

   292

#ifdef EC_DEBUG_RING

   293

		ec_device_debug_ring_append(

   294

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

   295

#endif

   296

	}

   297

}

   298

   299

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

   300

   301

#ifdef EC_DEBUG_RING

   302

/** Appends frame data to the debug ring.

   303

 */

   304

void ec_device_debug_ring_append(

   305

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

   306

        ec_debug_frame_dir_t dir, /**< direction */

   307

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

   308

        size_t size /**< data size */

   309

        )

   310

{

   311

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

   312

   313

    df->dir = dir;

   314

    if (dir == TX)

   315

        do_gettimeofday(&df->t);

   316

    else

   317

        df->t = device->timeval_poll;

   318

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

   319

    df->data_size = size;

   320

   321

    device->debug_frame_index++;

   322

    device->debug_frame_index %= EC_DEBUG_RING_SIZE;

   323

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

   324

        device->debug_frame_count++;

   325

}

   326

   327

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

   328

   329

/** Outputs the debug ring.

   330

 */

   331

void ec_device_debug_ring_print(

   332

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

   333

        )

   334

{

   335

    int i;

   336

    unsigned int ring_index;

   337

    const ec_debug_frame_t *df;

   338

    struct timeval t0, diff;

   339

   340

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

   341

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

   342

        % EC_DEBUG_RING_SIZE;

   343

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

   344

   345

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

   346

   347

    // calculate index of the oldest frame in the ring

   348

    ring_index = (device->debug_frame_index + EC_DEBUG_RING_SIZE

   349

            - device->debug_frame_count) % EC_DEBUG_RING_SIZE;

   350

   351

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

   352

        df = &device->debug_frames[ring_index];

   353

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

   354

   355

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

   356

                i + 1 - device->debug_frame_count,

   357

                (unsigned int) diff.tv_sec,

   358

                (unsigned int) diff.tv_usec,

   359

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

   360

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

   361

   362

        ring_index++;

   363

        ring_index %= EC_DEBUG_RING_SIZE;

   364

    }

   365

}

   366

#endif

   367

   368

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

   369

   370

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

   371

 *

   372

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

   373

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

   374

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

   375

 */

   376

void ec_device_poll(

   377

        ec_device_t *device /**< EtherCAT device */

   378

        )

   379

{

   380

#ifdef EC_HAVE_CYCLES

   381

    device->cycles_poll = get_cycles();

   382

#endif

   383

    device->jiffies_poll = jiffies;

   384

#ifdef EC_DEBUG_RING

   385

    do_gettimeofday(&device->timeval_poll);

   386

#endif

   387

    device->poll(device->dev);

   388

}

   389

   390

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

   391

 *  Device interface

   392

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

   393

   394

/** Withdraws an EtherCAT device from the master.

   395

 *

   396

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

   397

 * are freed.

   398

 *

   399

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

   400

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

   401

 *            any more.

   402

 * \ingroup DeviceInterface

   403

 */

   404

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

   405

{

   406

    ec_master_t *master = device->master;

   407

    char str[20];

   408

   409

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

   410

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

   411

   412

    down(&master->device_sem);

   413

    ec_device_detach(device);

   414

    up(&master->device_sem);

   415

}

   416

   417

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

   418

   419

/** Opens the network device and makes the master enter IDLE phase.

   420

 *

   421

 * \return 0 on success, else < 0

   422

 * \ingroup DeviceInterface

   423

 */

   424

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

   425

{

   426

    if (ec_device_open(device)) {

   427

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

   428

        return -1;

   429

    }

   430

   431

    if (ec_master_enter_idle_phase(device->master)) {

   432

        EC_ERR("Failed to enter IDLE phase!\n");

   433

        return -1;

   434

    }

   435

   436

    return 0;

   437

}

   438

   439

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

   440

   441

/** Makes the master leave IDLE phase and closes the network device.

   442

 *

   443

 * \return 0 on success, else < 0

   444

 * \ingroup DeviceInterface

   445

 */

   446

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

   447

{

   448

    ec_master_leave_idle_phase(device->master);

   449

   450

    if (ec_device_close(device))

   451

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

   452

}

   453

   454

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

   455

   456

/** Accepts a received frame.

   457

 *

   458

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

   459

 * and dispatch the received commands to the sending instances.

   460

 * 

   461

 * \ingroup DeviceInterface

   462

 */

   463

void ecdev_receive(

   464

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

   465

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

   466

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

   467

        )

   468

{

   469

    const void *ec_data = data + ETH_HLEN;

   470

    size_t ec_size = size - ETH_HLEN;

   471

    device->rx_count++;

   472

   473

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

   474

        EC_DBG("Received frame:\n");

   475

        ec_print_data(ec_data, ec_size);

   476

    }

   477

   478

#ifdef EC_DEBUG_IF

   479

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

   480

#endif

   481

#ifdef EC_DEBUG_RING

   482

    ec_device_debug_ring_append(device, RX, ec_data, ec_size);

   483

#endif

   484

   485

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

   486

}

   487

   488

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