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

    int ret;

    73

    unsigned int i;

    74

    struct ethhdr *eth;

    75

#ifdef EC_DEBUG_IF

    76

    char ifname[10];

    77

    char mb = 'x';

    78

#endif

    79

#ifdef EC_DEBUG_RING

    80

    device->debug_frame_index = 0;

    81

    device->debug_frame_count = 0;

    82

#endif

    83

    84

    device->master = master;

    85

    device->tx_ring_index = 0;

    86

    87

#ifdef EC_DEBUG_IF

    88

    if (device == &master->main_device)

    89

        mb = 'm';

    90

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

    91

        mb = 'b';

    92

    93

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

    94

    95

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

    96

    if (ret < 0) {

    97

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

    98

        goto out_return;

    99

    }

   100

#endif

   101

   102

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

   103

        device->tx_skb[i] = NULL;

   104

   105

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

   106

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

   107

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

   108

            ret = -ENOMEM;

   109

            goto out_tx_ring;

   110

        }

   111

   112

        // add Ethernet-II-header

   113

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

   114

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

   115

        eth->h_proto = htons(0x88A4);

   116

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

   117

    }

   118

   119

    ec_device_detach(device); // resets remaining fields

   120

    return 0;

   121

   122

out_tx_ring:

   123

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

   124

        if (device->tx_skb[i])

   125

            dev_kfree_skb(device->tx_skb[i]);

   126

#ifdef EC_DEBUG_IF

   127

    ec_debug_clear(&device->dbg);

   128

out_return:

   129

#endif

   130

    return ret;

   131

}

   132

   133

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

   134

   135

/** Destructor.

   136

 */

   137

void ec_device_clear(

   138

        ec_device_t *device /**< EtherCAT device */

   139

        )

   140

{

   141

    unsigned int i;

   142

   143

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

   144

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

   145

        dev_kfree_skb(device->tx_skb[i]);

   146

#ifdef EC_DEBUG_IF

   147

    ec_debug_clear(&device->dbg);

   148

#endif

   149

}

   150

   151

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

   152

   153

/** Associate with net_device.

   154

 */

   155

void ec_device_attach(

   156

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

   157

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

   158

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

   159

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

   160

        )

   161

{

   162

    unsigned int i;

   163

    struct ethhdr *eth;

   164

   165

    ec_device_detach(device); // resets fields

   166

   167

    device->dev = net_dev;

   168

    device->poll = poll;

   169

    device->module = module;

   170

   171

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

   172

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

   173

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

   174

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

   175

    }

   176

   177

#ifdef EC_DEBUG_IF

   178

    ec_debug_register(&device->dbg, net_dev);

   179

#endif

   180

}

   181

   182

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

   183

   184

/** Disconnect from net_device.

   185

 */

   186

void ec_device_detach(

   187

        ec_device_t *device /**< EtherCAT device */

   188

        )

   189

{

   190

    unsigned int i;

   191

   192

#ifdef EC_DEBUG_IF

   193

    ec_debug_unregister(&device->dbg);

   194

#endif

   195

   196

    device->dev = NULL;

   197

    device->poll = NULL;

   198

    device->module = NULL;

   199

    device->open = 0;

   200

    device->link_state = 0; // down

   201

    device->tx_count = 0;

   202

    device->rx_count = 0;

   203

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

   204

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

   205

}

   206

   207

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

   208

   209

/** Opens the EtherCAT device.

   210

 *

   211

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

   212

 */

   213

int ec_device_open(

   214

        ec_device_t *device /**< EtherCAT device */

   215

        )

   216

{

   217

    int ret;

   218

   219

    if (!device->dev) {

   220

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

   221

        return -ENODEV;

   222

    }

   223

   224

    if (device->open) {

   225

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

   226

        return 0;

   227

    }

   228

   229

    device->link_state = 0;

   230

    device->tx_count = 0;

   231

    device->rx_count = 0;

   232

   233

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

   234

    if (!ret)

   235

        device->open = 1;

   236

   237

    return ret;

   238

}

   239

   240

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

   241

   242

/** Stops the EtherCAT device.

   243

 *

   244

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

   245

 */

   246

int ec_device_close(

   247

        ec_device_t *device /**< EtherCAT device */

   248

        )

   249

{

   250

    int ret;

   251

   252

    if (!device->dev) {

   253

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

   254

        return -ENODEV;

   255

    }

   256

   257

    if (!device->open) {

   258

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

   259

        return 0;

   260

    }

   261

   262

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

   263

    if (!ret)

   264

        device->open = 0;

   265

   266

    return ret;

   267

}

   268

   269

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

   270

   271

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

   272

 *

   273

 * \return pointer to the TX socket buffer

   274

 */

   275

uint8_t *ec_device_tx_data(

   276

        ec_device_t *device /**< EtherCAT device */

   277

        )

   278

{

   279

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

   280

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

   281

     * between. */

   282

    device->tx_ring_index++;

   283

    device->tx_ring_index %= EC_TX_RING_SIZE;

   284

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

   285

}

   286

   287

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

   288

   289

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

   290

 *

   291

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

   292

 * start_xmit() function of the assigned net_device.

   293

 */

   294

void ec_device_send(

   295

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

   296

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

   297

        )

   298

{

   299

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

   300

   301

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

   302

        return;

   303

   304

    // set the right length for the data

   305

    skb->len = ETH_HLEN + size;

   306

   307

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

   308

        EC_DBG("sending frame:\n");

   309

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

   310

    }

   311

   312

    // start sending

   313

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

   314

		device->tx_count++;

   315

#ifdef EC_DEBUG_IF

   316

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

   317

#endif

   318

#ifdef EC_DEBUG_RING

   319

		ec_device_debug_ring_append(

   320

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

   321

#endif

   322

	}

   323

}

   324

   325

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

   326

   327

#ifdef EC_DEBUG_RING

   328

/** Appends frame data to the debug ring.

   329

 */

   330

void ec_device_debug_ring_append(

   331

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

   332

        ec_debug_frame_dir_t dir, /**< direction */

   333

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

   334

        size_t size /**< data size */

   335

        )

   336

{

   337

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

   338

   339

    df->dir = dir;

   340

    if (dir == TX)

   341

        do_gettimeofday(&df->t);

   342

    else

   343

        df->t = device->timeval_poll;

   344

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

   345

    df->data_size = size;

   346

   347

    device->debug_frame_index++;

   348

    device->debug_frame_index %= EC_DEBUG_RING_SIZE;

   349

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

   350

        device->debug_frame_count++;

   351

}

   352

   353

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

   354

   355

/** Outputs the debug ring.

   356

 */

   357

void ec_device_debug_ring_print(

   358

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

   359

        )

   360

{

   361

    int i;

   362

    unsigned int ring_index;

   363

    const ec_debug_frame_t *df;

   364

    struct timeval t0, diff;

   365

   366

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

   367

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

   368

        % EC_DEBUG_RING_SIZE;

   369

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

   370

   371

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

   372

   373

    // calculate index of the oldest frame in the ring

   374

    ring_index = (device->debug_frame_index + EC_DEBUG_RING_SIZE

   375

            - device->debug_frame_count) % EC_DEBUG_RING_SIZE;

   376

   377

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

   378

        df = &device->debug_frames[ring_index];

   379

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

   380

   381

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

   382

                i + 1 - device->debug_frame_count,

   383

                (unsigned int) diff.tv_sec,

   384

                (unsigned int) diff.tv_usec,

   385

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

   386

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

   387

   388

        ring_index++;

   389

        ring_index %= EC_DEBUG_RING_SIZE;

   390

    }

   391

}

   392

#endif

   393

   394

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

   395

   396

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

   397

 *

   398

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

   399

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

   400

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

   401

 */

   402

void ec_device_poll(

   403

        ec_device_t *device /**< EtherCAT device */

   404

        )

   405

{

   406

#ifdef EC_HAVE_CYCLES

   407

    device->cycles_poll = get_cycles();

   408

#endif

   409

    device->jiffies_poll = jiffies;

   410

#ifdef EC_DEBUG_RING

   411

    do_gettimeofday(&device->timeval_poll);

   412

#endif

   413

    device->poll(device->dev);

   414

}

   415

   416

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

   417

 *  Device interface

   418

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

   419

   420

/** Withdraws an EtherCAT device from the master.

   421

 *

   422

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

   423

 * are freed.

   424

 *

   425

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

   426

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

   427

 *            any more.

   428

 * \ingroup DeviceInterface

   429

 */

   430

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

   431

{

   432

    ec_master_t *master = device->master;

   433

    char str[20];

   434

   435

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

   436

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

   437

   438

    down(&master->device_sem);

   439

    ec_device_detach(device);

   440

    up(&master->device_sem);

   441

}

   442

   443

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

   444

   445

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

   446

 *

   447

 * \return 0 on success, else < 0

   448

 * \ingroup DeviceInterface

   449

 */

   450

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

   451

{

   452

    int ret;

   453

   454

    ret = ec_device_open(device);

   455

    if (ret) {

   456

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

   457

        return ret;

   458

    }

   459

   460

    ret = ec_master_enter_idle_phase(device->master);

   461

    if (ret) {

   462

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

   463

        return ret;

   464

    }

   465

   466

    return 0;

   467

}

   468

   469

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

   470

   471

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

   472

 *

   473

 * \return 0 on success, else < 0

   474

 * \ingroup DeviceInterface

   475

 */

   476

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

   477

{

   478

    ec_master_leave_idle_phase(device->master);

   479

   480

    if (ec_device_close(device))

   481

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

   482

}

   483

   484

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

   485

   486

/** Accepts a received frame.

   487

 *

   488

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