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

   EtherCAT device methods.

    27

*/

    28

    29

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

    30

    31

#include <linux/module.h>

    32

#include <linux/skbuff.h>

    33

#include <linux/if_ether.h>

    34

#include <linux/netdevice.h>

    35

#include <linux/delay.h>

    36

    37

#include "device.h"

    38

#include "master.h"

    39

    40

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

    41

    42

/**

    43

   Device constructor.

    44

   \return 0 in case of success, else < 0

    45

*/

    46

    47

int ec_device_init(ec_device_t *device, /**< EtherCAT device */

    48

                   ec_master_t *master, /**< master owning the device */

    49

                   struct net_device *net_dev, /**< net_device structure */

    50

                   ec_isr_t isr, /**< pointer to device's ISR */

    51

                   struct module *module /**< pointer to the owning module */

    52

                   )

    53

{

    54

    struct ethhdr *eth;

    55

    56

    device->master = master;

    57

    device->dev = net_dev;

    58

    device->isr = isr;

    59

    device->module = module;

    60

    61

    device->open = 0;

    62

    device->link_state = 0; // down

    63

    64

    if (ec_debug_init(&device->dbg)) {

    65

        EC_ERR("Failed to init debug device!\n");

    66

        goto out_return;

    67

    }

    68

    69

    if (!(device->tx_skb = dev_alloc_skb(ETH_FRAME_LEN))) {

    70

        EC_ERR("Error allocating device socket buffer!\n");

    71

        goto out_debug;

    72

    }

    73

    74

    device->tx_skb->dev = net_dev;

    75

    76

    // add Ethernet-II-header

    77

    skb_reserve(device->tx_skb, ETH_HLEN);

    78

    eth = (struct ethhdr *) skb_push(device->tx_skb, ETH_HLEN);

    79

    eth->h_proto = htons(0x88A4);

    80

    memcpy(eth->h_source, net_dev->dev_addr, net_dev->addr_len);

    81

    memset(eth->h_dest, 0xFF, net_dev->addr_len);

    82

    83

    return 0;

    84

    85

 out_debug:

    86

    ec_debug_clear(&device->dbg);

    87

 out_return:

    88

    return -1;

    89

}

    90

    91

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

    92

    93

/**

    94

   EtherCAT device destuctor.

    95

*/

    96

    97

void ec_device_clear(ec_device_t *device /**< EtherCAT device */)

    98

{

    99

    if (device->open) ec_device_close(device);

   100

    if (device->tx_skb) dev_kfree_skb(device->tx_skb);

   101

    ec_debug_clear(&device->dbg);

   102

}

   103

   104

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

   105

   106

/**

   107

   Opens the EtherCAT device.

   108

   \return 0 in case of success, else < 0

   109

*/

   110

   111

int ec_device_open(ec_device_t *device /**< EtherCAT device */)

   112

{

   113

    unsigned int i;

   114

   115

    if (!device->dev) {

   116

        EC_ERR("No net_device to open!\n");

   117

        return -1;

   118

    }

   119

   120

    if (device->open) {

   121

        EC_WARN("Device already opened!\n");

   122

        return 0;

   123

    }

   124

   125

    // device could have received frames before

   126

    for (i = 0; i < 4; i++) ec_device_call_isr(device);

   127

   128

    device->link_state = 0;

   129

   130

    if (device->dev->open(device->dev) == 0) device->open = 1;

   131

   132

    return device->open ? 0 : -1;

   133

}

   134

   135

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

   136

   137

/**

   138

   Stops the EtherCAT device.

   139

   \return 0 in case of success, else < 0

   140

*/

   141

   142

int ec_device_close(ec_device_t *device /**< EtherCAT device */)

   143

{

   144

    if (!device->dev) {

   145

        EC_ERR("No device to close!\n");

   146

        return -1;

   147

    }

   148

   149

    if (!device->open) {

   150

        EC_WARN("Device already closed!\n");

   151

        return 0;

   152

    }

   153

   154

    if (device->dev->stop(device->dev) == 0) device->open = 0;

   155

   156

    return !device->open ? 0 : -1;

   157

}

   158

   159

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

   160

   161

/**

   162

   Returns a pointer to the device's transmit memory.

   163

   \return pointer to the TX socket buffer

   164

*/

   165

   166

uint8_t *ec_device_tx_data(ec_device_t *device /**< EtherCAT device */)

   167

{

   168

    return device->tx_skb->data + ETH_HLEN;

   169

}

   170

   171

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

   172

   173

/**

   174

   Sends the content of the transmit socket buffer.

   175

   Cuts the socket buffer content to the (now known) size, and calls the

   176

   start_xmit() function of the assigned net_device.

   177

*/

   178

   179

void ec_device_send(ec_device_t *device, /**< EtherCAT device */

   180

                    size_t size /**< number of bytes to send */

   181

                    )

   182

{

   183

    if (unlikely(!device->link_state)) // Link down

   184

        return;

   185

   186

    // set the right length for the data

   187

    device->tx_skb->len = ETH_HLEN + size;

   188

   189

    if (unlikely(device->master->debug_level > 1)) {

   190

        EC_DBG("sending frame:\n");

   191

        ec_print_data(device->tx_skb->data + ETH_HLEN, size);

   192

    }

   193

   194

    ec_debug_send(&device->dbg, device->tx_skb->data, ETH_HLEN + size);

   195

   196

    // start sending

   197

    device->dev->hard_start_xmit(device->tx_skb, device->dev);

   198

}

   199

   200

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

   201

   202

/**

   203

   Calls the interrupt service routine of the assigned net_device.

   204

   The master itself works without using interrupts. Therefore the processing

   205

   of received data and status changes of the network device has to be

   206

   done by the master calling the ISR "manually".

   207

*/

   208

   209

void ec_device_call_isr(ec_device_t *device /**< EtherCAT device */)

   210

{

   211

    if (likely(device->isr)) device->isr(0, device->dev, NULL);

   212

}

   213

   214

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

   215

 *  Device interface

   216

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

   217

   218

/**

   219

   Accepts a received frame.

   220

   Forwards the received data to the master. The master will analyze the frame

   221

   and dispatch the received commands to the sending instances.

   222

   \ingroup DeviceInterface

   223

*/

   224

   225

void ecdev_receive(ec_device_t *device, /**< EtherCAT device */

   226

                   const void *data, /**< pointer to received data */

   227

                   size_t size /**< number of bytes received */

   228

                   )

   229

{

   230

    if (unlikely(device->master->debug_level > 1)) {

   231

        EC_DBG("Received frame:\n");

   232

        ec_print_data_diff(device->tx_skb->data + ETH_HLEN,

   233

                           data + ETH_HLEN, size - ETH_HLEN);

   234

    }

   235

   236

    ec_debug_send(&device->dbg, data, size);

   237

   238

    ec_master_receive(device->master, data + ETH_HLEN, size - ETH_HLEN);

   239

}

   240

   241

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

   242

   243

/**

   244

   Sets a new link state.

   245

   If the device notifies the master about the link being down, the master

   246

   will not try to send frames using this device.

   247

   \ingroup DeviceInterface

   248

*/

   249

   250

void ecdev_link_state(ec_device_t *device, /**< EtherCAT device */

   251

                      uint8_t state /**< new link state */

   252

                      )

   253

{

   254

    if (unlikely(!device)) {

   255

        EC_WARN("ecdev_link_state: no device!\n");

   256

        return;

   257

    }

   258

   259

    if (likely(state != device->link_state)) {

   260

        device->link_state = state;

   261

        EC_INFO("Link state changed to %s.\n", (state ? "UP" : "DOWN"));

   262

    }

   263

}

   264

   265

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

   266

   267

/** \cond */

   268

   269

EXPORT_SYMBOL(ecdev_receive);

   270

EXPORT_SYMBOL(ecdev_link_state);

   271

   272

/** \endcond */

   273

   274

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