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 (!(device->tx_skb = dev_alloc_skb(ETH_FRAME_LEN))) {

    65

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

    66

        return -1;

    67

    }

    68

    69

    device->tx_skb->dev = net_dev;

    70

    71

    // add Ethernet-II-header

    72

    skb_reserve(device->tx_skb, ETH_HLEN);

    73

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

    74

    eth->h_proto = htons(0x88A4);

    75

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

    76

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

    77

    78

    return 0;

    79

}

    80

    81

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

    82

    83

/**

    84

   EtherCAT device destuctor.

    85

*/

    86

    87

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

    88

{

    89

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

    90

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

    91

}

    92

    93

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

    94

    95

/**

    96

   Opens the EtherCAT device.

    97

   \return 0 in case of success, else < 0

    98

*/

    99

   100

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

   101

{

   102

    unsigned int i;

   103

   104

    if (!device->dev) {

   105

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

   106

        return -1;

   107

    }

   108

   109

    if (device->open) {

   110

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

   111

        return 0;

   112

    }

   113

   114

    // device could have received frames before

   115

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

   116

   117

    device->link_state = 0;

   118

   119

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

   120

   121

    return device->open ? 0 : -1;

   122

}

   123

   124

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

   125

   126

/**

   127

   Stops the EtherCAT device.

   128

   \return 0 in case of success, else < 0

   129

*/

   130

   131

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

   132

{

   133

    if (!device->dev) {

   134

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

   135

        return -1;

   136

    }

   137

   138

    if (!device->open) {

   139

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

   140

        return 0;

   141

    }

   142

   143

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

   144

   145

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

   146

}

   147

   148

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

   149

   150

/**

   151

   Returns a pointer to the device's transmit memory.

   152

   \return pointer to the TX socket buffer

   153

*/

   154

   155

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

   156

{

   157

    return device->tx_skb->data + ETH_HLEN;

   158

}

   159

   160

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

   161

   162

/**

   163

   Sends the content of the transmit socket buffer.

   164

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

   165

   start_xmit() function of the assigned net_device.

   166

*/

   167

   168

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

   169

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

   170

                    )

   171

{

   172

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

   173

        return;

   174

   175

    // set the right length for the data

   176

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

   177

   178

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

   179

        EC_DBG("sending frame:\n");

   180

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

   181

    }

   182

   183

    // start sending

   184

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

   185

}

   186

   187

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

   188

   189

/**

   190

   Calls the interrupt service routine of the assigned net_device.

   191

   The master itself works without using interrupts. Therefore the processing

   192

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

   193

   done by the master calling the ISR "manually".

   194

*/

   195

   196

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

   197

{

   198

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

   199

}

   200

   201

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

   202

 *  Device interface

   203

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

   204

   205

/**

   206

   Accepts a received frame.

   207

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

   208

   and dispatch the received commands to the sending instances.

   209

   \ingroup DeviceInterface

   210

*/

   211

   212

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

   213

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

   214

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

   215

                   )

   216

{

   217

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

   218

        EC_DBG("Received frame:\n");

   219

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

   220

    }

   221

   222

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

   223

}

   224

   225

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

   226

   227

/**

   228

   Sets a new link state.

   229

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

   230

   will not try to send frames using this device.

   231

   \ingroup DeviceInterface

   232

*/

   233

   234

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

   235

                      uint8_t state /**< new link state */

   236

                      )

   237

{

   238

    if (unlikely(!device)) {

   239

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

   240

        return;

   241

    }

   242

   243

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

   244

        device->link_state = state;

   245

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

   246

    }

   247

}

   248

   249

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

   250

   251

/** \cond */

   252

   253

EXPORT_SYMBOL(ecdev_receive);

   254

EXPORT_SYMBOL(ecdev_link_state);

   255

   256

/** \endcond */

   257

   258

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