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

    unsigned int i;

   124

    uint8_t fragment_number;

   125

    uint8_t complete_size;

   126

    uint8_t frame_number;

   127

    uint8_t last_fragment;

   128

   129

    master = eoe->slave->master;

   130

   131

    if (eoe->rx_state == EC_EOE_IDLE) {

   132

        ec_slave_mbox_prepare_check(eoe->slave);

   133

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

   134

        eoe->rx_state = EC_EOE_CHECKING;

   135

        return;

   136

    }

   137

   138

    if (eoe->rx_state == EC_EOE_CHECKING) {

   139

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

   140

            master->stats.eoe_errors++;

   141

            eoe->rx_state = EC_EOE_IDLE;

   142

            return;

   143

        }

   144

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

   145

            eoe->rx_state = EC_EOE_IDLE;

   146

            return;

   147

        }

   148

        ec_slave_mbox_prepare_fetch(eoe->slave);

   149

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

   150

        eoe->rx_state = EC_EOE_FETCHING;

   151

        return;

   152

    }

   153

   154

    if (eoe->rx_state == EC_EOE_FETCHING) {

   155

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

   156

            master->stats.eoe_errors++;

   157

            eoe->rx_state = EC_EOE_IDLE;

   158

            return;

   159

        }

   160

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

   161

            master->stats.eoe_errors++;

   162

            eoe->rx_state = EC_EOE_IDLE;

   163

            return;

   164

        }

   165

   166

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

   167

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

   168

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

   169

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

   170

   171

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

   172

               " frame %i%s\n",

   173

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

   174

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

   175

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

   176

        EC_DBG("");

   177

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

   178

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

   179

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

   180

                printk("\n");

   181

                EC_DBG("");

   182

            }

   183

        }

   184

        printk("\n");

   185

   186

        eoe->rx_state = EC_EOE_IDLE;

   187

        return;

   188

    }

   189

}

   190

   191

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

   192

   193

/**

   194

   Prints EoE object information.

   195

*/

   196

   197

void ec_eoe_print(const ec_eoe_t *eoe)

   198

{

   199

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

   200

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

   201

}

   202

   203

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

   204

   205

/**

   206

   Initializes a net_device structure for an EoE object.

   207

*/

   208

   209

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

   210

{

   211

    ec_eoedev_priv_t *priv;

   212

   213

    // initialize net_device

   214

    ether_setup(dev);

   215

    dev->open = ec_eoedev_open;

   216

    dev->stop = ec_eoedev_stop;

   217

    dev->hard_start_xmit = ec_eoedev_tx;

   218

    dev->get_stats = ec_eoedev_stats;

   219

   220

    // initialize private data

   221

    priv = netdev_priv(dev);

   222

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

   223

}

   224

   225

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

   226

   227

/**

   228

   Opens the virtual network device.

   229

*/

   230

   231

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

   232

{

   233

    ec_eoedev_priv_t *priv = netdev_priv(dev);

   234

    netif_start_queue(dev);

   235

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

   236

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

   237

    return 0;

   238

}

   239

   240

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

   241

   242

/**

   243

   Stops the virtual network device.

   244

*/

   245

   246

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

   247

{

   248

    ec_eoedev_priv_t *priv = netdev_priv(dev);

   249

    netif_stop_queue(dev);

   250

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

   251

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

   252

    return 0;

   253

}

   254

   255

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

   256

   257

/**

   258

   Transmits data via the virtual network device.

   259

*/

   260

   261

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

   262

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

   263

                 )

   264

{

   265

    ec_eoedev_priv_t *priv = netdev_priv(dev);

   266

    priv->stats.tx_packets++;

   267

    dev_kfree_skb(skb);

   268

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

   269

    return 0;

   270

}

   271

   272

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

   273

   274

/**

   275

   Gets statistics about the virtual network device.

   276

*/

   277

   278

struct net_device_stats *ec_eoedev_stats(struct net_device *dev

   279

                                         /**< EoE net_device */)

   280

{

   281

    ec_eoedev_priv_t *priv = netdev_priv(dev);

   282

    return &priv->stats;

   283

}

   284

   285

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