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

    int ret;

    66

    unsigned int i;

    67

    struct ethhdr *eth;

    68

#ifdef EC_DEBUG_IF

    69

    char ifname[10];

    70

    char mb = 'x';

    71

#endif

    72

#ifdef EC_DEBUG_RING

    73

    device->debug_frame_index = 0;

    74

    device->debug_frame_count = 0;

    75

#endif

    76

    77

    device->master = master;

    78

    device->tx_ring_index = 0;

    79

    80

#ifdef EC_DEBUG_IF

    81

    if (device == &master->main_device)

    82

        mb = 'm';

    83

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

    84

        mb = 'b';

    85

    86

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

    87

    88

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

    89

    if (ret < 0) {

    90

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

    91

        goto out_return;

    92

    }

    93

#endif

    94

    95

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

    96

        device->tx_skb[i] = NULL;

    97

    98

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

    99

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

   100

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

   101

            ret = -ENOMEM;

   102

            goto out_tx_ring;

   103

        }

   104

   105

        // add Ethernet-II-header

   106

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

   107

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

   108

        eth->h_proto = htons(0x88A4);

   109

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

   110

    }

   111

   112

    ec_device_detach(device); // resets remaining fields

   113

    return 0;

   114

   115

out_tx_ring:

   116

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

   117

        if (device->tx_skb[i])

   118

            dev_kfree_skb(device->tx_skb[i]);

   119

#ifdef EC_DEBUG_IF

   120

    ec_debug_clear(&device->dbg);

   121

out_return:

   122

#endif

   123

    return ret;

   124

}

   125

   126

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

   127

   128

/** Destructor.

   129

 */

   130

void ec_device_clear(

   131

        ec_device_t *device /**< EtherCAT device */

   132

        )

   133

{

   134

    unsigned int i;

   135

   136

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

   137

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

   138

        dev_kfree_skb(device->tx_skb[i]);

   139

#ifdef EC_DEBUG_IF

   140

    ec_debug_clear(&device->dbg);

   141

#endif

   142

}

   143

   144

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

   145

   146

/** Associate with net_device.

   147

 */

   148

void ec_device_attach(

   149

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

   150

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

   151

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

   152

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

   153

        )

   154

{

   155

    unsigned int i;

   156

    struct ethhdr *eth;

   157

   158

    ec_device_detach(device); // resets fields

   159

   160

    device->dev = net_dev;

   161

    device->poll = poll;

   162

    device->module = module;

   163

   164

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

   165

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

   166

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

   167

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

   168

    }

   169

   170

#ifdef EC_DEBUG_IF

   171

    ec_debug_register(&device->dbg, net_dev);

   172

#endif

   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

#ifdef EC_DEBUG_IF

   186

    ec_debug_unregister(&device->dbg);

   187

#endif

   188

   189

    device->dev = NULL;

   190

    device->poll = NULL;

   191

    device->module = NULL;

   192

    device->open = 0;

   193

    device->link_state = 0; // down

   194

    device->tx_count = 0;

   195

    device->rx_count = 0;

   196

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

   197

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

   198

}

   199

   200

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

   201

   202

/** Opens the EtherCAT device.

   203

 *

   204

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

   205

 */

   206

int ec_device_open(

   207

        ec_device_t *device /**< EtherCAT device */

   208

        )

   209

{

   210

    int ret;

   211

   212

    if (!device->dev) {

   213

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

   214

        return -ENODEV;

   215

    }

   216

   217

    if (device->open) {

   218

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

   219

        return 0;

   220

    }

   221

   222

    device->link_state = 0;

   223

    device->tx_count = 0;

   224

    device->rx_count = 0;

   225

   226

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

   227

    if (!ret)

   228

        device->open = 1;

   229

   230

    return ret;

   231

}

   232

   233

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

   234

   235

/** Stops the EtherCAT device.

   236

 *

   237

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

   238

 */

   239

int ec_device_close(

   240

        ec_device_t *device /**< EtherCAT device */

   241

        )

   242

{

   243

    int ret;

   244

   245

    if (!device->dev) {

   246

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

   247

        return -ENODEV;

   248

    }

   249

   250

    if (!device->open) {

   251

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

   252

        return 0;

   253

    }

   254

   255

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

   256

    if (!ret)

   257

        device->open = 0;

   258

   259

    return ret;

   260

}

   261

   262

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

   263

   264

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

   265

 *

   266

 * \return pointer to the TX socket buffer

   267

 */

   268

uint8_t *ec_device_tx_data(

   269

        ec_device_t *device /**< EtherCAT device */

   270

        )

   271

{

   272

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

   273

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

   274

     * between. */

   275

    device->tx_ring_index++;

   276

    device->tx_ring_index %= EC_TX_RING_SIZE;

   277

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

   278

}

   279

   280

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

   281

   282

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

   283

 *

   284

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

   285

 * start_xmit() function of the assigned net_device.

   286

 */

   287

void ec_device_send(

   288

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

   289

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

   290

        )

   291

{

   292

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

   293

   294

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

   295

        return;

   296

   297

    // set the right length for the data

   298

    skb->len = ETH_HLEN + size;

   299

   300

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

   301

        EC_DBG("sending frame:\n");

   302

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

   303

    }

   304

   305

    // start sending

   306

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

   307

		device->tx_count++;

   308

#ifdef EC_DEBUG_IF

   309

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

   310

#endif

   311

#ifdef EC_DEBUG_RING

   312

		ec_device_debug_ring_append(

   313

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

   314

#endif

   315

	}

   316

}

   317

   318

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

   319

   320

#ifdef EC_DEBUG_RING

   321

/** Appends frame data to the debug ring.

   322

 */

   323

void ec_device_debug_ring_append(

   324

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

   325

        ec_debug_frame_dir_t dir, /**< direction */

   326

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

   327

        size_t size /**< data size */

   328

        )

   329

{

   330

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

   331

   332

    df->dir = dir;

   333

    if (dir == TX)

   334

        do_gettimeofday(&df->t);

   335

    else

   336

        df->t = device->timeval_poll;

   337

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

   338

    df->data_size = size;

   339

   340

    device->debug_frame_index++;

   341

    device->debug_frame_index %= EC_DEBUG_RING_SIZE;

   342

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

   343

        device->debug_frame_count++;

   344

}

   345

   346

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

   347

   348

/** Outputs the debug ring.

   349

 */

   350

void ec_device_debug_ring_print(

   351

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

   352

        )

   353

{

   354

    int i;

   355

    unsigned int ring_index;

   356

    const ec_debug_frame_t *df;

   357

    struct timeval t0, diff;

   358

   359

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

   360

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

   361

        % EC_DEBUG_RING_SIZE;

   362

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

   363

   364

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

   365

   366

    // calculate index of the oldest frame in the ring

   367

    ring_index = (device->debug_frame_index + EC_DEBUG_RING_SIZE

   368

            - device->debug_frame_count) % EC_DEBUG_RING_SIZE;

   369

   370

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

   371

        df = &device->debug_frames[ring_index];

   372

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

   373

   374

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

   375

                i + 1 - device->debug_frame_count,

   376

                (unsigned int) diff.tv_sec,

   377

                (unsigned int) diff.tv_usec,

   378

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

   379

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

   380

   381

        ring_index++;

   382

        ring_index %= EC_DEBUG_RING_SIZE;

   383

    }

   384

}

   385

#endif

   386

   387

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

   388

   389

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

   390

 *

   391

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

   392

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

   393

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

   394

 */

   395

void ec_device_poll(

   396

        ec_device_t *device /**< EtherCAT device */

   397

        )

   398

{

   399

#ifdef EC_HAVE_CYCLES

   400

    device->cycles_poll = get_cycles();

   401

#endif

   402

    device->jiffies_poll = jiffies;

   403

#ifdef EC_DEBUG_RING

   404

    do_gettimeofday(&device->timeval_poll);

   405

#endif

   406

    device->poll(device->dev);

   407

}

   408

   409

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

   410

 *  Device interface

   411

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

   412

   413

/** Withdraws an EtherCAT device from the master.

   414

 *

   415

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

   416

 * are freed.

   417

 *

   418

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

   419

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

   420

 *            any more.

   421

 * \ingroup DeviceInterface

   422

 */

   423

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

   424

{

   425

    ec_master_t *master = device->master;

   426

    char str[20];

   427

   428

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

   429

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

   430

   431

    down(&master->device_sem);

   432

    ec_device_detach(device);

   433

    up(&master->device_sem);

   434

}

   435

   436

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

   437

   438

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

   439

 *

   440

 * \return 0 on success, else < 0

   441

 * \ingroup DeviceInterface

   442

 */

   443

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

   444

{

   445

    int ret;

   446

   447

    ret = ec_device_open(device);

   448

    if (ret) {

   449

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

   450

        return ret;

   451

    }

   452

   453

    ret = ec_master_enter_idle_phase(device->master);

   454

    if (ret) {

   455

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

   456

        return ret;

   457

    }

   458

   459

    return 0;

   460

}

   461

   462

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

   463

   464

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

   465

 *

   466

 * \return 0 on success, else < 0

   467

 * \ingroup DeviceInterface

   468

 */

   469

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

   470

{

   471

    ec_master_leave_idle_phase(device->master);

   472

   473

    if (ec_device_close(device))

   474

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

   475

}

   476

   477

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

   478

   479

/** Accepts a received frame.

   480

 *

   481

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

   482

 * and dispatch the received commands to the sending instances.

   483

 * 

   484

 * \ingroup DeviceInterface

   485

 */

   486

void ecdev_receive(

   487

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

   488

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