1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006-2008  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 and/or

    10

 *  modify it under the terms of the GNU General Public License version 2, as

    11

 *  published by the Free Software Foundation.

    12

 *

    13

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

    14

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

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

    16

 *  Public License for more details.

    17

 *

    18

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

    19

 *  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

 *  The license mentioned above concerns the source code only. Using the

    25

 *  EtherCAT technology and brand is only permitted in compliance with the

    26

 *  industrial property and similar rights of Beckhoff Automation GmbH.

    27

 *

    28

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

    29

    30

/**

    31

   \file

    32

   Ethernet interface for debugging purposes.

    33

*/

    34

    35

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

    36

    37

#include <linux/netdevice.h>

    38

#include <linux/etherdevice.h>

    39

    40

#include "globals.h"

    41

#include "debug.h"

    42

    43

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

    44

    45

// net_device functions

    46

int ec_dbgdev_open(struct net_device *);

    47

int ec_dbgdev_stop(struct net_device *);

    48

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

    49

struct net_device_stats *ec_dbgdev_stats(struct net_device *);

    50

    51

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

    52

    53

/** Debug interface constructor.

    54

 *

    55

 * Initializes the debug object, creates a net_device and registeres it.

    56

 *

    57

 * \retval  0 Success.

    58

 * \retval <0 Error code.

    59

 */

    60

int ec_debug_init(

    61

        ec_debug_t *dbg, /**< debug object */

    62

        const char *name /**< interface name */

    63

        )

    64

{

    65

    dbg->registered = 0;

    66

    dbg->opened = 0;

    67

    68

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

    69

    70

    if (!(dbg->dev =

    71

          alloc_netdev(sizeof(ec_debug_t *), name, ether_setup))) {

    72

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

    73

        return -ENODEV;

    74

    }

    75

    76

    // initialize net_device

    77

    dbg->dev->open = ec_dbgdev_open;

    78

    dbg->dev->stop = ec_dbgdev_stop;

    79

    dbg->dev->hard_start_xmit = ec_dbgdev_tx;

    80

    dbg->dev->get_stats = ec_dbgdev_stats;

    81

    82

    // initialize private data

    83

    *((ec_debug_t **) netdev_priv(dbg->dev)) = dbg;

    84

    85

    return 0;

    86

}

    87

    88

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

    89

    90

/** Debug interface destructor.

    91

 *

    92

 * Unregisters the net_device and frees allocated memory.

    93

 */

    94

void ec_debug_clear(

    95

        ec_debug_t *dbg /**< debug object */

    96

        )

    97

{

    98

    ec_debug_unregister(dbg);

    99

    free_netdev(dbg->dev);

   100

}

   101

   102

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

   103

   104

/** Register debug interface.

   105

 */

   106

void ec_debug_register(

   107

        ec_debug_t *dbg, /**< debug object */

   108

        const struct net_device *net_dev /**< 'Real' Ethernet device. */

   109

        )

   110

{

   111

    int result;

   112

   113

    ec_debug_unregister(dbg);

   114

   115

    // use the Ethernet address of the physical device for the debug device

   116

    memcpy(dbg->dev->dev_addr, net_dev->dev_addr, ETH_ALEN);

   117

   118

    // connect the net_device to the kernel

   119

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

   120

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

   121

    } else {

   122

        dbg->registered = 1;

   123

    }

   124

}

   125

   126

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

   127

   128

/** Unregister debug interface.

   129

 */

   130

void ec_debug_unregister(

   131

        ec_debug_t *dbg /**< debug object */

   132

        )

   133

{

   134

    if (dbg->registered) {

   135

        dbg->opened = 0;

   136

        dbg->registered = 0;

   137

        unregister_netdev(dbg->dev);

   138

    }

   139

}

   140

   141

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

   142

   143

/** Sends frame data to the interface.

   144

 */

   145

void ec_debug_send(

   146

        ec_debug_t *dbg, /**< debug object */

   147

        const uint8_t *data, /**< frame data */

   148

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

   149

        )

   150

{

   151

    struct sk_buff *skb;

   152

   153

    if (!dbg->opened)

   154

        return;

   155

   156

    // allocate socket buffer

   157

    if (!(skb = dev_alloc_skb(size))) {

   158

        dbg->stats.rx_dropped++;

   159

        return;

   160

    }

   161

   162

    // copy frame contents into socket buffer

   163

    memcpy(skb_put(skb, size), data, size);

   164

   165

    // update device statistics

   166

    dbg->stats.rx_packets++;

   167

    dbg->stats.rx_bytes += size;

   168

   169

    // pass socket buffer to network stack

   170

    skb->dev = dbg->dev;

   171

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

   172

    skb->ip_summed = CHECKSUM_UNNECESSARY;

   173

    netif_rx(skb);

   174

}

   175

   176

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

   177

 *  NET_DEVICE functions

   178

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

   179

   180

/** Opens the virtual network device.

   181

 */

   182

int ec_dbgdev_open(

   183

        struct net_device *dev /**< debug net_device */

   184

        )

   185

{

   186

    ec_debug_t *dbg = *((ec_debug_t **) netdev_priv(dev));

   187

    dbg->opened = 1;

   188

    EC_INFO("Debug interface %s opened.\n", dev->name);

   189

    return 0;

   190

}

   191

   192

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

   193

   194

/** Stops the virtual network device.

   195

 */

   196

int ec_dbgdev_stop(

   197

        struct net_device *dev /**< debug net_device */

   198

        )

   199

{

   200

    ec_debug_t *dbg = *((ec_debug_t **) netdev_priv(dev));

   201

    dbg->opened = 0;

   202

    EC_INFO("Debug interface %s stopped.\n", dev->name);

   203

    return 0;

   204

}

   205

   206

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

   207

   208

/** Transmits data via the virtual network device.

   209

 */

   210

int ec_dbgdev_tx(

   211

        struct sk_buff *skb, /**< transmit socket buffer */

   212

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

   213

        )

   214

{

   215

    ec_debug_t *dbg = *((ec_debug_t **) netdev_priv(dev));

   216

   217

    dev_kfree_skb(skb);

   218

    dbg->stats.tx_dropped++;

   219

    return 0;

   220

}

   221

   222

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

   223

   224

/** Gets statistics about the virtual network device.

   225

 */

   226

struct net_device_stats *ec_dbgdev_stats(

   227

        struct net_device *dev /**< debug net_device */

   228

        )

   229

{

   230

    ec_debug_t *dbg = *((ec_debug_t **) netdev_priv(dev));

   231

    return &dbg->stats;

   232

}

   233

   234

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