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; version 2 of the License.

    12

 *

    13

 *  The IgH EtherCAT Master is distributed in the hope that it will be

    14

 *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    16

 *  GNU General Public License for more details.

    17

 *

    18

 *  You should have received a copy of the GNU General Public License

    19

 *  along 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

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

    23

    24

/**

    25

   \file

    26

   Ethernet-over-EtherCAT (EoE).

    27

*/

    28

    29

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

    30

    31

#include <linux/etherdevice.h>

    32

    33

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

    34

#include "globals.h"

    35

#include "master.h"

    36

#include "slave.h"

    37

#include "mailbox.h"

    38

#include "ethernet.h"

    39

    40

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

    41

    42

void ec_eoedev_init(struct net_device *);

    43

int ec_eoedev_open(struct net_device *);

    44

int ec_eoedev_stop(struct net_device *);

    45

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

    46

struct net_device_stats *ec_eoedev_stats(struct net_device *);

    47

void ec_eoedev_rx(struct net_device *, const uint8_t *, size_t);

    48

    49

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

    50

    51

/**

    52

   EoE constructor.

    53

*/

    54

    55

int ec_eoe_init(ec_eoe_t *eoe, ec_slave_t *slave)

    56

{

    58

    int result;

    59

    60

    eoe->slave = slave;

    61

    eoe->rx_state = EC_EOE_IDLE;

    62

    eoe->opened = 0;

    63

    eoe->skb = NULL;

    64

    INIT_LIST_HEAD(&eoe->tx_queue);

    65

    eoe->queued_frames = 0;

    66

    eoe->tx_queue_lock = SPIN_LOCK_UNLOCKED;

    67

    68

    if (!(eoe->dev =

    70

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

    71

        goto out_return;

    72

    }

    73

    74

    // set EoE object reference

    75

    priv = netdev_priv(eoe->dev);

    77

    78

    // connect the net_device to the kernel

    79

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

    80

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

    81

        goto out_free;

    82

    }

    83

    84

    return 0;

    85

    86

 out_free:

    87

    free_netdev(eoe->dev);

    88

    eoe->dev = NULL;

    89

 out_return:

    90

    return -1;

    91

}

    92

    93

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

    94

    95

/**

    96

   EoE destructor.

    97

*/

    98

    99

void ec_eoe_clear(ec_eoe_t *eoe)

   100

{

   101

    if (eoe->dev) {

   102

        unregister_netdev(eoe->dev);

   103

        free_netdev(eoe->dev);

   104

    }

   105

}

   106

   107

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

   108

   109

/**

   110

   Runs the EoE state machine.

   111

*/

   112

   113

void ec_eoe_run(ec_eoe_t *eoe)

   114

{

   115

    uint8_t *data;

   116

    ec_master_t *master;

   117

    size_t rec_size;

   118

    uint8_t fragment_number, frame_number, last_fragment, time_appended;

   119

    uint8_t fragment_offset, frame_type;

   120

   121

    if (!eoe->opened) return;

   122

   123

    master = eoe->slave->master;

   124

   125

    if (eoe->rx_state == EC_EOE_IDLE) {

   126

        ec_slave_mbox_prepare_check(eoe->slave);

   127

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

   128

        eoe->rx_state = EC_EOE_CHECKING;

   129

        return;

   130

    }

   131

   132

    if (eoe->rx_state == EC_EOE_CHECKING) {

   133

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

   134

            master->stats.eoe_errors++;

   135

            eoe->rx_state = EC_EOE_IDLE;

   136

            return;

   137

        }

   138

        if (!ec_slave_mbox_check(eoe->slave)) {

   139

            eoe->rx_state = EC_EOE_IDLE;

   140

            return;

   141

        }

   142

        ec_slave_mbox_prepare_fetch(eoe->slave);

   143

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

   144

        eoe->rx_state = EC_EOE_FETCHING;

   145

        return;

   146

    }

   147

   148

    if (eoe->rx_state == EC_EOE_FETCHING) {

   149

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

   150

            master->stats.eoe_errors++;

   151

            eoe->rx_state = EC_EOE_IDLE;

   152

            return;

   153

        }

   154

        if (!(data = ec_slave_mbox_fetch(eoe->slave, 0x02, &rec_size))) {

   155

            master->stats.eoe_errors++;

   156

            eoe->rx_state = EC_EOE_IDLE;

   157

            return;

   158

        }

   159

   160

        frame_type = EC_READ_U16(data) & 0x000F;

   161

   162

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

   163

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

   164

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

   165

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

   166

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

   167

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

   168

   169

#if 0

   170

            EC_DBG("EOE fragment req received, fragment: %i, offset: %i,"

   171

                   " frame %i%s%s, %i bytes\n", fragment_number,

   172

                   fragment_offset, frame_number,

   173

                   last_fragment ? ", last fragment" : "",

   174

                   time_appended ? ", + timestamp" : "",

   175

                   time_appended ? rec_size - 8 : rec_size - 4);

   176

   177

#if 0

   178

            EC_DBG("");

   179

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

   180

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

   181

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

   182

                    printk("\n");

   183

                    EC_DBG("");

   184

                }

   185

            }

   186

            printk("\n");

   187

#endif

   188

#endif

   189

   190

            ec_eoedev_rx(eoe->dev, data + 4,

   191

                         time_appended ? rec_size - 8 : rec_size - 4);

   192

        }

   193

        else {

   194

#if 1

   195

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

   196

#endif

   197

        }

   198

   199

        eoe->rx_state = EC_EOE_IDLE;

   200

        return;

   201

    }

   202

}

   203

   204

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

   205

   206

/**

   207

   Prints EoE object information.

   208

*/

   209

   210

void ec_eoe_print(const ec_eoe_t *eoe)

   211

{

   212

    EC_INFO("  EoE slave %i\n", eoe->slave->ring_position);

   213

    EC_INFO("    RX State %i\n", eoe->rx_state);

   214

    EC_INFO("    Assigned device: %s (%s)\n", eoe->dev->name,

   215

            eoe->opened ? "opened" : "closed");

   216

}

   217

   218

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

   219

   220

/**

   221

   Initializes a net_device structure for an EoE object.

   222

*/

   223

   224

void ec_eoedev_init(struct net_device *dev /**< pointer to the net_device */)

   225

{

   227

    unsigned int i;

   228

   229

    // initialize net_device

   230

    ether_setup(dev);

   231

    dev->open = ec_eoedev_open;

   232

    dev->stop = ec_eoedev_stop;

   233

    dev->hard_start_xmit = ec_eoedev_tx;

   234

    dev->get_stats = ec_eoedev_stats;

   235

   236

    for (i = 0; i < 6; i++) dev->dev_addr[i] = (i + 1) | (i + 1) << 4;

   237

   238

    // initialize private data

   239

    priv = netdev_priv(dev);

   241

}

   242

   243

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

   244

   245

/**

   246

   Opens the virtual network device.

   247

*/

   248

   249

int ec_eoedev_open(struct net_device *dev /**< EoE net_device */)

   250

{

   252

    eoe->opened = 1;

   253

    netif_start_queue(dev);

   254

    EC_INFO("%s (slave %i) opened.\n", dev->name, eoe->slave->ring_position);

   255

    return 0;

   256

}

   257

   258

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

   259

   260

/**

   261

   Stops the virtual network device.

   262

*/

   263

   264

int ec_eoedev_stop(struct net_device *dev /**< EoE net_device */)

   265

{

   267

    netif_stop_queue(dev);

   268

    eoe->opened = 0;

   269

    EC_INFO("%s (slave %i) stopped.\n", dev->name, eoe->slave->ring_position);

   270

    return 0;

   271

}

   272

   273

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

   274

   275

/**

   276

   Transmits data via the virtual network device.

   277

*/

   278

   279

int ec_eoedev_tx(struct sk_buff *skb, /**< transmit socket buffer */

   280

                 struct net_device *dev /**< EoE net_device */

   281

                )

   282

{

   284

   285

    spin_lock_bh(&eoe->tx_queue_lock);

   286

   287

#if 0

   288

    eoe->stats.tx_packets++;

   289

    dev_kfree_skb(skb);

   290

    EC_INFO("EoE device sent %i octets.\n", skb->len);

   291

#endif

   292

   293

    if (eoe->queued_frames == EC_EOE_TX_QUEUE_SIZE)

   294

        netif_stop_queue(dev);

   295

   296

    spin_unlock_bh(&eoe->tx_queue_lock);

   297

   298

    return 0;

   299

}

   300

   301

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

   302

   303

/**

   304

   Receives data from the bus and passes it to the network stack.

   305

*/

   306

   307

void ec_eoedev_rx(struct net_device *dev, /**< EoE net_device */

   308

                  const uint8_t *data, /**< pointer to the data */

   309

                  size_t size /**< size of the received data */

   310

                 )

   311

{

   313

   314

    // allocate socket buffer

   315

    if (!(eoe->skb = dev_alloc_skb(size + 2))) {

   316

        if (printk_ratelimit())

   317

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

   318

        eoe->stats.rx_dropped++;

   319

        return;

   320

    }

   321

   322

    // copy received data to socket buffer

   323

    memcpy(skb_put(eoe->skb, size), data, size);

   324

   325

    // set socket buffer fields

   326

    eoe->skb->dev = dev;

   327

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

   328

    eoe->skb->ip_summed = CHECKSUM_UNNECESSARY;

   329

   330

    // update statistics

   331

    eoe->stats.rx_packets++;

   332

    eoe->stats.rx_bytes += size;

   333

   334

    // pass socket buffer to network stack

   335

    netif_rx(eoe->skb);

   336

    eoe->skb = NULL;

   337

}

   338

   339

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

   340

   341

/**

   342

   Gets statistics about the virtual network device.

   343

*/

   344

   345

struct net_device_stats *ec_eoedev_stats(struct net_device *dev

   346

                                         /**< EoE net_device */)

   347

{

   349

    return &eoe->stats;

   350

}

   351

   352

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