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; either version 2 of the

    12

 *  License, or (at your option) any later version.

    13

 *

    14

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

    15

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

    16

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

 *  GNU General Public License for more details.

    18

 *

    19

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

    20

 *  along with the IgH EtherCAT Master; if not, write to the Free Software

    21

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    22

 *

    23

 *  The right to use EtherCAT Technology is granted and comes free of

    24

 *  charge under condition of compatibility of product made by

    25

 *  Licensee. People intending to distribute/sell products based on the

    26

 *  code, have to sign an agreement to guarantee that products using

    27

 *  software based on IgH EtherCAT master stay compatible with the actual

    28

 *  EtherCAT specification (which are released themselves as an open

    29

 *  standard) as the (only) precondition to have the right to use EtherCAT

    30

 *  Technology, IP and trade marks.

    31

 *

    32

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

    33

    34

/**

    35

   \file

    36

   EtherCAT device methods.

    37

*/

    38

    39

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

    40

    41

#include <linux/module.h>

    42

#include <linux/skbuff.h>

    43

#include <linux/if_ether.h>

    44

#include <linux/netdevice.h>

    45

#include <linux/delay.h>

    46

    47

#include "device.h"

    48

#include "master.h"

    49

    50

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

    51

    52

/**

    53

   Device constructor.

    54

   \return 0 in case of success, else < 0

    55

*/

    56

    57

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

    58

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

    59

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

    60

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

    61

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

    62

                   )

    63

{

    64

    struct ethhdr *eth;

    65

    66

    device->master = master;

    67

    device->dev = net_dev;

    68

    device->isr = isr;

    69

    device->module = module;

    70

    71

    device->open = 0;

    72

    device->link_state = 0; // down

    73

    74

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

    75

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

    76

        goto out_return;

    77

    }

    78

    79

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

    80

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

    81

        goto out_debug;

    82

    }

    83

    84

    device->tx_skb->dev = net_dev;

    85

    86

    // add Ethernet-II-header

    87

    skb_reserve(device->tx_skb, ETH_HLEN);

    88

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

    89

    eth->h_proto = htons(0x88A4);

    90

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

    91

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

    92

    93

    return 0;

    94

    95

 out_debug:

    96

    ec_debug_clear(&device->dbg);

    97

 out_return:

    98

    return -1;

    99

}

   100

   101

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

   102

   103

/**

   104

   EtherCAT device destuctor.

   105

*/

   106

   107

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

   108

{

   109

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

   110

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

   111

    ec_debug_clear(&device->dbg);

   112

}

   113

   114

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

   115

   116

/**

   117

   Opens the EtherCAT device.

   118

   \return 0 in case of success, else < 0

   119

*/

   120

   121

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

   122

{

   123

    unsigned int i;

   124

   125

    if (!device->dev) {

   126

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

   127

        return -1;

   128

    }

   129

   130

    if (device->open) {

   131

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

   132

        return 0;

   133

    }

   134

   135

    // device could have received frames before

   136

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

   137

   138

    device->link_state = 0;

   139

   140

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

   141

   142

    return device->open ? 0 : -1;

   143

}

   144

   145

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

   146

   147

/**

   148

   Stops the EtherCAT device.

   149

   \return 0 in case of success, else < 0

   150

*/

   151

   152

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

   153

{

   154

    if (!device->dev) {

   155

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

   156

        return -1;

   157

    }

   158

   159

    if (!device->open) {

   160

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

   161

        return 0;

   162

    }

   163

   164

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

   165

   166

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

   167

}

   168

   169

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

   170

   171

/**

   172

   Returns a pointer to the device's transmit memory.

   173

   \return pointer to the TX socket buffer

   174

*/

   175

   176

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

   177

{

   178

    return device->tx_skb->data + ETH_HLEN;

   179

}

   180

   181

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

   182

   183

/**

   184

   Sends the content of the transmit socket buffer.

   185

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

   186

   start_xmit() function of the assigned net_device.

   187

*/

   188

   189

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

   190

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

   191

                    )

   192

{

   193

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

   194

        return;

   195

   196

    // set the right length for the data

   197

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

   198

   199

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

   200

        EC_DBG("sending frame:\n");

   201

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

   202

    }

   203

   204

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

   205

   206

    // start sending

   207

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

   208

}

   209

   210

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

   211

   212

/**

   213

   Calls the interrupt service routine of the assigned net_device.

   214

   The master itself works without using interrupts. Therefore the processing

   215

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

   216

   done by the master calling the ISR "manually".

   217

*/

   218

   219

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

   220

{

   221

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

   222

}

   223

   224

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

   225

 *  Device interface

   226

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

   227

   228

/**

   229

   Accepts a received frame.

   230

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

   231

   and dispatch the received commands to the sending instances.

   232

   \ingroup DeviceInterface

   233

*/

   234

   235

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

   236

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

   237

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

   238

                   )

   239

{

   240

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

   241

        EC_DBG("Received frame:\n");

   242

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

   243

                           data + ETH_HLEN, size - ETH_HLEN);

   244

    }

   245

   246

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

   247

   248

    ec_master_receive_datagrams(device->master,

   249

                                data + ETH_HLEN,

   250

                                size - ETH_HLEN);

   251

}

   252

   253

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

   254

   255

/**

   256

   Sets a new link state.

   257

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

   258

   will not try to send frames using this device.

   259

   \ingroup DeviceInterface

   260

*/

   261

   262

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

   263

                      uint8_t state /**< new link state */

   264

                      )

   265

{

   266

    if (unlikely(!device)) {

   267

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

   268

        return;

   269

    }

   270

   271

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

   272

        device->link_state = state;

   273

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

   274

    }

   275

}

   276

   277

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

   278

   279

/** \cond */

   280

   281

EXPORT_SYMBOL(ecdev_receive);

   282

EXPORT_SYMBOL(ecdev_link_state);

   283

   284

/** \endcond */

   285

   286

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