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 interface for debugging purposes.

    27

*/

    28

    29

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

    30

    31

#include <linux/etherdevice.h>

    32

    33

#include "globals.h"

    34

#include "debug.h"

    35

    36

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

    37

    38

// net_device functions

    39

int ec_dbgdev_open(struct net_device *);

    40

int ec_dbgdev_stop(struct net_device *);

    41

struct net_device_stats *ec_dbgdev_stats(struct net_device *);

    42

    43

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

    44

    45

/**

    46

   Debug constructor.

    47

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

    48

*/

    49

    50

int ec_debug_init(ec_debug_t *dbg /**< debug object */)

    51

{

    52

    int result;

    53

    54

    dbg->opened = 0;

    55

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

    56

    57

    if (!(dbg->dev =

    58

          alloc_netdev(sizeof(ec_debug_t *), "ec%d", ether_setup))) {

    59

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

    60

        goto out_return;

    61

    }

    62

    63

    // initialize net_device

    64

    dbg->dev->open = ec_dbgdev_open;

    65

    dbg->dev->stop = ec_dbgdev_stop;

    66

    dbg->dev->get_stats = ec_dbgdev_stats;

    67

    68

    // initialize private data

    69

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

    70

    71

    // connect the net_device to the kernel

    72

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

    73

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

    74

        goto out_free;

    75

    }

    76

    77

    return 0;

    78

    79

 out_free:

    80

    free_netdev(dbg->dev);

    81

    dbg->dev = NULL;

    82

 out_return:

    83

    return -1;

    84

}

    85

    86

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

    87

    88

/**

    89

   Debug destructor.

    90

   Unregisteres the net_device and frees allocated memory.

    91

*/

    92

    93

void ec_debug_clear(ec_debug_t *dbg /**< debug object */)

    94

{

    95

    if (dbg->dev) {

    96

        unregister_netdev(dbg->dev);

    97

        free_netdev(dbg->dev);

    98

    }

    99

}

   100

   101

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

   102

   103

/**

   104

   Sends frame data to the interface.

   105

*/

   106

   107

void ec_debug_send(ec_debug_t *dbg, /**< debug object */

   108

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

   109

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

   110

                   )

   111

{

   112

    struct sk_buff *skb;

   113

   114

    if (!dbg->opened) return;

   115

   116

    // allocate socket buffer

   117

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

   118

        dbg->stats.rx_dropped++;

   119

        return;

   120

    }

   121

   122

    // copy frame contents into socket buffer

   123

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

   124

   125

    // update device statistics

   126

    dbg->stats.rx_packets++;

   127

    dbg->stats.rx_bytes += size;

   128

   129

    // pass socket buffer to network stack

   130

    skb->dev = dbg->dev;

   131

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

   132

    skb->ip_summed = CHECKSUM_UNNECESSARY;

   133

    netif_rx(skb);

   134

}

   135

   136

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

   137

 *  NET_DEVICE functions

   138

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

   139

   140

/**

   141

   Opens the virtual network device.

   142

*/

   143

   144

int ec_dbgdev_open(struct net_device *dev /**< debug net_device */)

   145

{

   146

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

   147

    dbg->opened = 1;

   148

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

   149

    return 0;

   150

}

   151

   152

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

   153

   154

/**

   155

   Stops the virtual network device.

   156

*/

   157

   158

int ec_dbgdev_stop(struct net_device *dev /**< debug net_device */)

   159

{

   160

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

   161

    dbg->opened = 0;

   162

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

   163

    return 0;

   164

}

   165

   166

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

   167

   168

/**

   169

   Gets statistics about the virtual network device.

   170

*/

   171

   172

struct net_device_stats *ec_dbgdev_stats(struct net_device *dev

   173

                                         /**< debug net_device */)

   174

{

   175

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

   176

    return &dbg->stats;

   177

}

   178

   179

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