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 "../include/ecrt.h"

    32

#include "globals.h"

    33

#include "master.h"

    34

#include "slave.h"

    35

#include "mailbox.h"

    36

#include "ethernet.h"

    37

    38

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

    39

    40

/**

    41

   Contains the private data of an EoE net_device.

    42

*/

    43

    44

typedef struct

    45

{

    46

    struct net_device_stats stats; /**< device statistics */

    47

    ec_eoe_t *eoe; /**< pointer to parent eoe object */

    48

}

    49

ec_eoedev_priv_t;

    50

    51

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

    52

    53

void ec_eoedev_init(struct net_device *);

    54

int ec_eoedev_open(struct net_device *);

    55

int ec_eoedev_stop(struct net_device *);

    56

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

    57

struct net_device_stats *ec_eoedev_stats(struct net_device *);

    58

    59

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

    60

    61

/**

    62

   EoE constructor.

    63

*/

    64

    65

int ec_eoe_init(ec_eoe_t *eoe, ec_slave_t *slave)

    66

{

    67

    ec_eoedev_priv_t *priv;

    68

    int result;

    69

    70

    eoe->slave = slave;

    71

    eoe->rx_state = EC_EOE_IDLE;

    72

    73

    if (!(eoe->dev =

    74

          alloc_netdev(sizeof(ec_eoedev_priv_t), "eoe%d", ec_eoedev_init))) {

    75

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

    76

        goto out_return;

    77

    }

    78

    79

    // set EoE object reference

    80

    priv = netdev_priv(eoe->dev);

    81

    priv->eoe = eoe;

    82

    83

    // connect the net_device to the kernel

    84

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

    85

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

    86

        goto out_free;

    87

    }

    88

    89

    return 0;

    90

    91

 out_free:

    92

    free_netdev(eoe->dev);

    93

    eoe->dev = NULL;

    94

 out_return:

    95

    return -1;

    96

}

    97

    98

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

    99

   100

/**

   101

   EoE destructor.

   102

*/

   103

   104

void ec_eoe_clear(ec_eoe_t *eoe)

   105

{

   106

    if (eoe->dev) {

   107

        unregister_netdev(eoe->dev);

   108

        free_netdev(eoe->dev);

   109

    }

   110

}

   111

   112

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

   113

   114

/**

   115

   Runs the EoE state machine.

   116

*/

   117

   118

void ec_eoe_run(ec_eoe_t *eoe)

   119

{

   120

    uint8_t *data;

   121

    ec_master_t *master;

   122

    size_t rec_size;

   123

#if 0

   124

    unsigned int i;

   125

    uint8_t fragment_number;

   126

    uint8_t complete_size;

   127

    uint8_t frame_number;

   128

    uint8_t last_fragment;

   129

#endif

   130

   131

    master = eoe->slave->master;

   132

   133

    if (eoe->rx_state == EC_EOE_IDLE) {

   134

        ec_slave_mbox_prepare_check(eoe->slave);

   135

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

   136

        eoe->rx_state = EC_EOE_CHECKING;

   137

        return;

   138

    }

   139

   140

    if (eoe->rx_state == EC_EOE_CHECKING) {

   141

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

   142

            master->stats.eoe_errors++;

   143

            eoe->rx_state = EC_EOE_IDLE;

   144

            return;

   145

        }

   146

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

   147

            eoe->rx_state = EC_EOE_IDLE;

   148

            return;

   149

        }

   150

        ec_slave_mbox_prepare_fetch(eoe->slave);

   151

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

   152

        eoe->rx_state = EC_EOE_FETCHING;

   153

        return;

   154

    }

   155

   156

    if (eoe->rx_state == EC_EOE_FETCHING) {

   157

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

   158

            master->stats.eoe_errors++;

   159

            eoe->rx_state = EC_EOE_IDLE;

   160

            return;

   161

        }

   162

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

   163

            master->stats.eoe_errors++;

   164

            eoe->rx_state = EC_EOE_IDLE;

   165

            return;

   166

        }

   167

   168

#if 0

   169

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

   170

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

   171

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

   172

        last_fragment = (EC_READ_U16(data + 2) >> 15) & 0x0001;

   173

   174

        EC_DBG("EOE %s received, fragment: %i, complete size: %i (0x%02X),"

   175

               " frame %i%s\n",

   176

               fragment_number ? "fragment" : "initiate", fragment_number,

   177

               (complete_size - 31) / 32, complete_size, frame_number,

   178

               last_fragment ? ", last fragment" : "");

   179

        EC_DBG("");

   180

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

   181

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

   182

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

   183

                printk("\n");

   184

                EC_DBG("");

   185

            }

   186

        }

   187

        printk("\n");

   188

#endif

   189

   190

        eoe->rx_state = EC_EOE_IDLE;

   191

        return;

   192

    }

   193

}

   194

   195

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

   196

   197

/**

   198

   Prints EoE object information.

   199

*/

   200

   201

void ec_eoe_print(const ec_eoe_t *eoe)

   202

{

   203

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

   204

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

   205

}

   206

   207

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

   208

   209

/**

   210

   Initializes a net_device structure for an EoE object.

   211

*/

   212

   213

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

   214

{

   215

    ec_eoedev_priv_t *priv;

   216

   217

    // initialize net_device

   218

    ether_setup(dev);

   219

    dev->open = ec_eoedev_open;

   220

    dev->stop = ec_eoedev_stop;

   221

    dev->hard_start_xmit = ec_eoedev_tx;

   222

    dev->get_stats = ec_eoedev_stats;

   223

   224

    // initialize private data

   225

    priv = netdev_priv(dev);

   226

    memset(priv, 0, sizeof(ec_eoedev_priv_t));

   227

}

   228

   229

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

   230

   231

/**

   232

   Opens the virtual network device.

   233

*/

   234

   235

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

   236

{

   237

    ec_eoedev_priv_t *priv = netdev_priv(dev);

   238

    netif_start_queue(dev);

   239

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

   240

            priv->eoe->slave->ring_position);

   241

    return 0;

   242

}

   243

   244

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

   245

   246

/**

   247

   Stops the virtual network device.

   248

*/

   249

   250

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

   251

{

   252

    ec_eoedev_priv_t *priv = netdev_priv(dev);

   253

    netif_stop_queue(dev);

   254

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

   255

            priv->eoe->slave->ring_position);

   256

    return 0;

   257

}

   258

   259

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

   260

   261

/**

   262

   Transmits data via the virtual network device.

   263

*/

   264

   265

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

   266

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

   267

                 )

   268

{

   269

    ec_eoedev_priv_t *priv = netdev_priv(dev);

   270

    priv->stats.tx_packets++;

   271

    dev_kfree_skb(skb);

   272

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

   273

    return 0;

   274

}

   275

   276

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

   277

   278

/**

   279

   Gets statistics about the virtual network device.

   280

*/

   281

   282

struct net_device_stats *ec_eoedev_stats(struct net_device *dev

   283

                                         /**< EoE net_device */)

   284

{

   285

    ec_eoedev_priv_t *priv = netdev_priv(dev);

   286

    return &priv->stats;

   287

}

   288

   289

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