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

   Ethernet-over-EtherCAT (EoE).

    37

*/

    38

    39

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

    40

    41

#include <linux/etherdevice.h>

    42

    43

#include "../include/ecrt.h"

    44

#include "globals.h"

    45

#include "master.h"

    46

#include "slave.h"

    47

#include "mailbox.h"

    48

#include "ethernet.h"

    49

    50

/**

    51

   Defines the debug level of EoE processing

    52

    53

   0 = No debug messages.

    54

   1 = Output actions.

    55

   2 = Output actions and frame data.

    56

*/

    57

    58

#define EOE_DEBUG_LEVEL 0

    59

    60

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

    61

    62

void ec_eoe_flush(ec_eoe_t *);

    63

    64

// state functions

    65

void ec_eoe_state_rx_start(ec_eoe_t *);

    66

void ec_eoe_state_rx_check(ec_eoe_t *);

    67

void ec_eoe_state_rx_fetch(ec_eoe_t *);

    68

void ec_eoe_state_tx_start(ec_eoe_t *);

    69

void ec_eoe_state_tx_sent(ec_eoe_t *);

    70

    71

// net_device functions

    72

int ec_eoedev_open(struct net_device *);

    73

int ec_eoedev_stop(struct net_device *);

    74

int ec_eoedev_tx(struct sk_buff *, struct net_device *);

    75

struct net_device_stats *ec_eoedev_stats(struct net_device *);

    76

    77

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

    78

    79

/**

    80

   EoE constructor.

    81

   Initializes the EoE handler, creates a net_device and registeres it.

    82

*/

    83

    84

int ec_eoe_init(ec_eoe_t *eoe /**< EoE handler */)

    85

{

    86

    ec_eoe_t **priv;

    87

    int result, i;

    88

    89

    eoe->slave = NULL;

    90

    ec_command_init(&eoe->command);

    91

    eoe->state = ec_eoe_state_rx_start;

    92

    eoe->opened = 0;

    93

    eoe->rx_skb = NULL;

    94

    eoe->rx_expected_fragment = 0;

    95

    INIT_LIST_HEAD(&eoe->tx_queue);

    96

    eoe->tx_frame = NULL;

    97

    eoe->tx_queue_active = 0;

    98

    eoe->tx_queued_frames = 0;

    99

    eoe->tx_queue_lock = SPIN_LOCK_UNLOCKED;

   100

    eoe->tx_frame_number = 0xFF;

   101

    memset(&eoe->stats, 0, sizeof(struct net_device_stats));

   102

   103

    if (!(eoe->dev =

   104

          alloc_netdev(sizeof(ec_eoe_t *), "eoe%d", ether_setup))) {

   105

        EC_ERR("Unable to allocate net_device for EoE handler!\n");

   106

        goto out_return;

   107

    }

   108

   109

    // initialize net_device

   110

    eoe->dev->open = ec_eoedev_open;

   111

    eoe->dev->stop = ec_eoedev_stop;

   112

    eoe->dev->hard_start_xmit = ec_eoedev_tx;

   113

    eoe->dev->get_stats = ec_eoedev_stats;

   114

   115

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

   116

        eoe->dev->dev_addr[i] = i | (i << 4);

   117

   118

    // initialize private data

   119

    priv = netdev_priv(eoe->dev);

   120

    *priv = eoe;

   121

   122

    // Usually setting the MTU appropriately makes the upper layers

   123

    // do the frame fragmenting. In some cases this doesn't work

   124

    // so the MTU is left on the Ethernet standard value and fragmenting

   125

    // is done "manually".

   126

#if 0

   127

    eoe->dev->mtu = slave->sii_rx_mailbox_size - ETH_HLEN - 10;

   128

#endif

   129

   130

    // connect the net_device to the kernel

   131

    if ((result = register_netdev(eoe->dev))) {

   132

        EC_ERR("Unable to register net_device: error %i\n", result);

   133

        goto out_free;

   134

    }

   135

   136

    // make the last address octet unique

   137

    eoe->dev->dev_addr[ETH_ALEN - 1] = (uint8_t) eoe->dev->ifindex;

   138

   139

    return 0;

   140

   141

 out_free:

   142

    free_netdev(eoe->dev);

   143

    eoe->dev = NULL;

   144

 out_return:

   145

    return -1;

   146

}

   147

   148

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

   149

   150

/**

   151

   EoE destructor.

   152

   Unregisteres the net_device and frees allocated memory.

   153

*/

   154

   155

void ec_eoe_clear(ec_eoe_t *eoe /**< EoE handler */)

   156

{

   157

    if (eoe->dev) {

   158

        unregister_netdev(eoe->dev);

   159

        free_netdev(eoe->dev);

   160

    }

   161

   162

    // empty transmit queue

   163

    ec_eoe_flush(eoe);

   164

   165

    if (eoe->tx_frame) {

   166

        dev_kfree_skb(eoe->tx_frame->skb);

   167

        kfree(eoe->tx_frame);

   168

    }

   169

   170

    if (eoe->rx_skb) dev_kfree_skb(eoe->rx_skb);

   171

   172

    ec_command_clear(&eoe->command);

   173

}

   174

   175

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

   176

   177

/**

   178

   Empties the transmit queue.

   179

*/

   180

   181

void ec_eoe_flush(ec_eoe_t *eoe /**< EoE handler */)

   182

{

   183

    ec_eoe_frame_t *frame, *next;

   184

   185

    spin_lock_bh(&eoe->tx_queue_lock);

   186

   187

    list_for_each_entry_safe(frame, next, &eoe->tx_queue, queue) {

   188

        list_del(&frame->queue);

   189

        dev_kfree_skb(frame->skb);

   190

        kfree(frame);

   191

    }

   192

    eoe->tx_queued_frames = 0;

   193

   194

    spin_unlock_bh(&eoe->tx_queue_lock);

   195

}

   196

   197

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

   198

   199

/**

   200

   Sends a frame or the next fragment.

   201

*/

   202

   203

int ec_eoe_send(ec_eoe_t *eoe /**< EoE handler */)

   204

{

   205

    size_t remaining_size, current_size, complete_offset;

   206

    unsigned int last_fragment;

   207

    uint8_t *data;

   208

#if EOE_DEBUG_LEVEL > 1

   209

    unsigned int i;

   210

#endif

   211

   212

    remaining_size = eoe->tx_frame->skb->len - eoe->tx_offset;

   213

   214

    if (remaining_size <= eoe->slave->sii_tx_mailbox_size - 10) {

   215

        current_size = remaining_size;

   216

        last_fragment = 1;

   217

    }

   218

    else {

   219

        current_size = ((eoe->slave->sii_tx_mailbox_size - 10) / 32) * 32;

   220

        last_fragment = 0;

   221

    }

   222

   223

    if (eoe->tx_fragment_number) {

   224

        complete_offset = eoe->tx_offset / 32;

   225

    }

   226

    else {

   227

        complete_offset = remaining_size / 32 + 1;

   228

    }

   229

   230

#if EOE_DEBUG_LEVEL > 0

   231

    EC_DBG("EoE TX sending %sfragment %i with %i octets (%i)."

   232

           " %i frames queued.\n", last_fragment ? "last " : "",

   233

           eoe->tx_fragment_number, current_size, complete_offset,

   234

           eoe->tx_queued_frames);

   235

#endif

   236

   237

#if EOE_DEBUG_LEVEL > 1

   238

    EC_DBG("");

   239

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

   240

        printk("%02X ", frame->skb->data[eoe->tx_offset + i]);

   241

        if ((i + 1) % 16 == 0) {

   242

            printk("\n");

   243

            EC_DBG("");

   244

        }

   245

    }

   246

    printk("\n");

   247

#endif

   248

   249

    if (!(data = ec_slave_mbox_prepare_send(eoe->slave, &eoe->command,

   250

                                            0x02, current_size + 4)))

   251

        return -1;

   252

   253

    EC_WRITE_U8 (data,     0x00); // eoe fragment req.

   254

    EC_WRITE_U8 (data + 1, last_fragment);

   255

    EC_WRITE_U16(data + 2, ((eoe->tx_fragment_number & 0x3F) |

   256

                            (complete_offset & 0x3F) << 6 |

   257

                            (eoe->tx_frame_number & 0x0F) << 12));

   258

   259

    memcpy(data + 4, eoe->tx_frame->skb->data + eoe->tx_offset, current_size);

   260

    ec_master_queue_command(eoe->slave->master, &eoe->command);

   261

   262

    eoe->tx_offset += current_size;

   263

    eoe->tx_fragment_number++;

   264

    return 0;

   265

}

   266

   267

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

   268

   269

/**

   270

   Runs the EoE state machine.

   271

*/

   272

   273

void ec_eoe_run(ec_eoe_t *eoe /**< EoE handler */)

   274

{

   275

    if (!eoe->opened) return;

   276

   277

    // call state function

   278

    eoe->state(eoe);

   279

}

   280

   281

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

   282

   283

/**

   284

   Returns the state of the device.

   285

   \return 1 if the device is "up", 0 if it is "down"

   286

*/

   287

   288

unsigned int ec_eoe_active(const ec_eoe_t *eoe /**< EoE handler */)

   289

{

   290

    return eoe->slave && eoe->opened;

   291

}

   292

   293

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

   294

   295

/**

   296

   Prints EoE handler information.

   297

*/

   298

   299

void ec_eoe_print(const ec_eoe_t *eoe /**< EoE handler */)

   300

{

   301

    EC_INFO("  EoE handler %s\n", eoe->dev->name);

   302

    EC_INFO("    State: %s\n", eoe->opened ? "opened" : "closed");

   303

    if (eoe->slave)

   304

        EC_INFO("    Coupled to slave %i.\n", eoe->slave->ring_position);

   305

    else

   306

        EC_INFO("    Not coupled.\n");

   307

}

   308

   309

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

   310

 *  STATE PROCESSING FUNCTIONS

   311

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

   312

   313

/**

   314

   State: RX_START.

   315

   Starts a new receiving sequence by queueing a command that checks the

   316

   slave's mailbox for a new EoE command.

   317

*/

   318

   319

void ec_eoe_state_rx_start(ec_eoe_t *eoe /**< EoE handler */)

   320

{

   321

    if (!eoe->slave->online || !eoe->slave->master->device->link_state)

   322

        return;

   323

   324

    ec_slave_mbox_prepare_check(eoe->slave, &eoe->command);

   325

    ec_master_queue_command(eoe->slave->master, &eoe->command);

   326

    eoe->state = ec_eoe_state_rx_check;

   327

}

   328

   329

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

   330

   331

/**

   332

   State: RX_CHECK.

   333

   Processes the checking command sent in RX_START and issues a receive

   334

   command, if new data is available.

   335

*/

   336

   337

void ec_eoe_state_rx_check(ec_eoe_t *eoe /**< EoE handler */)

   338

{

   339

    if (eoe->command.state != EC_CMD_RECEIVED) {

   340

        eoe->stats.rx_errors++;

   341

        eoe->state = ec_eoe_state_tx_start;

   342

        return;

   343

    }

   344

   345

    if (!ec_slave_mbox_check(&eoe->command)) {

   346

        eoe->state = ec_eoe_state_tx_start;

   347

        return;

   348

    }

   349

   350

    ec_slave_mbox_prepare_fetch(eoe->slave, &eoe->command);

   351

    ec_master_queue_command(eoe->slave->master, &eoe->command);

   352

    eoe->state = ec_eoe_state_rx_fetch;

   353

}

   354

   355

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

   356

   357

/**

   358

   State: RX_FETCH.

   359

   Checks if the requested data of RX_CHECK was received and processes the

   360

   EoE command.

   361

*/

   362

   363

void ec_eoe_state_rx_fetch(ec_eoe_t *eoe /**< EoE handler */)

   364

{

   365

    size_t rec_size, data_size;

   366

    uint8_t *data, frame_type, last_fragment, time_appended;

   367

    uint8_t frame_number, fragment_offset, fragment_number;

   368

    off_t offset;

   369

   370

    if (eoe->command.state != EC_CMD_RECEIVED) {

   371

        eoe->stats.rx_errors++;

   372

        eoe->state = ec_eoe_state_tx_start;

   373

        return;

   374

    }

   375

   376

    if (!(data = ec_slave_mbox_fetch(eoe->slave, &eoe->command,

   377

                                     0x02, &rec_size))) {

   378

        eoe->stats.rx_errors++;

   379

        eoe->state = ec_eoe_state_tx_start;

   380

        return;

   381

    }

   382

   383

    frame_type = EC_READ_U16(data) & 0x000F;

   384

   385

    if (frame_type == 0x00) { // EoE Fragment Request

   386

        last_fragment = (EC_READ_U16(data) >> 8) & 0x0001;

   387

        time_appended = (EC_READ_U16(data) >> 9) & 0x0001;

   388

        fragment_number = EC_READ_U16(data + 2) & 0x003F;

   389

        fragment_offset = (EC_READ_U16(data + 2) >> 6) & 0x003F;

   390

        frame_number = (EC_READ_U16(data + 2) >> 12) & 0x000F;

   391

   392

#if EOE_DEBUG_LEVEL > 0

   393

        EC_DBG("EoE RX fragment %i, offset %i, frame %i%s%s,"

   394

               " %i octets\n", fragment_number, fragment_offset,

   395

               frame_number,

   396

               last_fragment ? ", last fragment" : "",

   397

               time_appended ? ", + timestamp" : "",

   398

               time_appended ? rec_size - 8 : rec_size - 4);

   399

#endif

   400

   401

#if EOE_DEBUG_LEVEL > 1

   402

        EC_DBG("");

   403

        for (i = 0; i < rec_size - 4; i++) {

   404

            printk("%02X ", data[i + 4]);

   405

            if ((i + 1) % 16 == 0) {

   406

                printk("\n");

   407

                EC_DBG("");

   408

            }

   409

        }

   410

        printk("\n");

   411

#endif

   412

   413

        data_size = time_appended ? rec_size - 8 : rec_size - 4;

   414

   415

        if (!fragment_number) {

   416

            if (eoe->rx_skb) {

   417

                EC_WARN("EoE RX freeing old socket buffer...\n");

   418

                dev_kfree_skb(eoe->rx_skb);

   419

            }

   420

   421

            // new socket buffer

   422

            if (!(eoe->rx_skb = dev_alloc_skb(fragment_offset * 32))) {

   423

                if (printk_ratelimit())

   424

                    EC_WARN("EoE RX low on mem. frame dropped.\n");

   425

                eoe->stats.rx_dropped++;

   426

                eoe->state = ec_eoe_state_tx_start;

   427

                return;

   428

            }

   429

   430

            eoe->rx_skb_offset = 0;

   431

            eoe->rx_skb_size = fragment_offset * 32;

   432

            eoe->rx_expected_fragment = 0;

   433

        }

   434

        else {

   435

            if (!eoe->rx_skb) {

   436

                eoe->stats.rx_dropped++;

   437

                eoe->state = ec_eoe_state_tx_start;

   438

                return;

   439

            }

   440

   441

            offset = fragment_offset * 32;

   442

            if (offset != eoe->rx_skb_offset ||

   443

                offset + data_size > eoe->rx_skb_size ||

   444

                fragment_number != eoe->rx_expected_fragment) {

   445

                eoe->stats.rx_errors++;

   446

                eoe->state = ec_eoe_state_tx_start;

   447

                dev_kfree_skb(eoe->rx_skb);

   448

                eoe->rx_skb = NULL;

   449

                return;

   450

            }

   451

        }

   452

   453

        // copy fragment into socket buffer

   454

        memcpy(skb_put(eoe->rx_skb, data_size), data + 4, data_size);

   455

        eoe->rx_skb_offset += data_size;

   456

   457

        if (last_fragment) {

   458

            // update statistics

   459

            eoe->stats.rx_packets++;

   460

            eoe->stats.rx_bytes += eoe->rx_skb->len;

   461

   462

#if EOE_DEBUG_LEVEL > 0

   463

            EC_DBG("EoE RX frame completed with %u octets.\n",

   464

                   eoe->rx_skb->len);

   465

#endif

   466

   467

            // pass socket buffer to network stack

   468

            eoe->rx_skb->dev = eoe->dev;

   469

            eoe->rx_skb->protocol = eth_type_trans(eoe->rx_skb, eoe->dev);

   470

            eoe->rx_skb->ip_summed = CHECKSUM_UNNECESSARY;

   471

            if (netif_rx(eoe->rx_skb)) {

   472

                EC_WARN("EoE RX netif_rx failed.\n");

   473

            }

   474

            eoe->rx_skb = NULL;

   475

   476

            eoe->state = ec_eoe_state_tx_start;

   477

        }

   478

        else {

   479

            eoe->rx_expected_fragment++;

   480

#if EOE_DEBUG_LEVEL > 0

   481

            EC_DBG("EoE RX expecting fragment %i\n",

   482

                   eoe->rx_expected_fragment);

   483

#endif

   484

            eoe->state = ec_eoe_state_rx_start;

   485

        }

   486

    }

   487

    else {

   488

#if EOE_DEBUG_LEVEL > 0

   489

        EC_DBG("other frame received.\n");

   490

#endif

   491

        eoe->stats.rx_dropped++;