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

#ifdef EC_DBG_IF

    75

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

    76

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

    77

        goto out_return;

    78

    }

    79

#endif

    80

    81

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

    82

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

    83

#ifdef EC_DBG_IF

    84

        goto out_debug;

    85

#else

    86

        goto out_return;

    87

#endif

    88

    }

    89

    90

    device->tx_skb->dev = net_dev;

    91

    92

    // add Ethernet-II-header

    93

    skb_reserve(device->tx_skb, ETH_HLEN);

    94

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

    95

    eth->h_proto = htons(0x88A4);

    96

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

    97

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

    98

    99

    return 0;

   100

   101

#ifdef EC_DBG_IF

   102

 out_debug:

   103

    ec_debug_clear(&device->dbg);

   104

#endif

   105

 out_return:

   106

    return -1;

   107

}

   108

   109

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

   110

   111

/**

   112

   EtherCAT device destuctor.

   113

*/

   114

   115

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

   116

{

   117

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

   118

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

   119

#ifdef EC_DBG_IF

   120

    ec_debug_clear(&device->dbg);

   121

#endif

   122

}

   123

   124

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

   125

   126

/**

   127

   Opens the EtherCAT device.

   128

   \return 0 in case of success, else < 0

   129

*/

   130

   131

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

   132

{

   133

    unsigned int i;

   134

   135

    if (!device->dev) {

   136

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

   137

        return -1;

   138

    }

   139

   140

    if (device->open) {

   141

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

   142

        return 0;

   143

    }

   144

   145

    // device could have received frames before

   146

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

   147

   148

    device->link_state = 0;

   149

   150

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

   151

   152

    return device->open ? 0 : -1;

   153

}

   154

   155

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

   156

   157

/**

   158

   Stops the EtherCAT device.

   159

   \return 0 in case of success, else < 0

   160

*/

   161

   162

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

   163

{

   164

    if (!device->dev) {

   165

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

   166

        return -1;

   167

    }

   168

   169

    if (!device->open) {

   170

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

   171

        return 0;

   172

    }

   173

   174

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

   175

   176

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

   177

}

   178

   179

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

   180

   181

/**

   182

   Returns a pointer to the device's transmit memory.

   183

   \return pointer to the TX socket buffer

   184

*/

   185

   186

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

   187

{

   188

    return device->tx_skb->data + ETH_HLEN;

   189

}

   190

   191

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

   192

   193

/**

   194

   Sends the content of the transmit socket buffer.

   195

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

   196

   start_xmit() function of the assigned net_device.

   197

*/

   198

   199

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

   200

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

   201

                    )

   202

{

   203

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

   204

        return;

   205

   206

    // set the right length for the data

   207

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

   208

   209

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

   210

        EC_DBG("sending frame:\n");

   211

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

   212

    }

   213

   214

#ifdef EC_DBG_IF

   215

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

   216

#endif

   217

   218

    // start sending

   219

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

   220

}

   221

   222

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

   223

   224

/**

   225

   Calls the interrupt service routine of the assigned net_device.

   226

   The master itself works without using interrupts. Therefore the processing

   227

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

   228

   done by the master calling the ISR "manually".

   229

*/

   230

   231

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

   232

{

   233

    device->cycles_isr = get_cycles();

   234

    device->jiffies_isr = jiffies;

   235

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

   236

}

   237

   238

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

   239

 *  Device interface

   240

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

   241

   242

/**

   243

   Accepts a received frame.

   244

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

   245

   and dispatch the received commands to the sending instances.

   246

   \ingroup DeviceInterface

   247

*/

   248

   249

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

   250

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

   251

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

   252

                   )

   253

{

   254

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

   255

        EC_DBG("Received frame:\n");

   256

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

   257

                           data + ETH_HLEN, size - ETH_HLEN);

   258

    }

   259

   260

#ifdef EC_DBG_IF

   261

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

   262

#endif

   263

   264

    ec_master_receive_datagrams(device->master,

   265

                                data + ETH_HLEN,

   266

                                size - ETH_HLEN);

   267

}

   268

   269

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

   270

   271

/**

   272

   Sets a new link state.

   273

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

   274

   will not try to send frames using this device.

   275

   \ingroup DeviceInterface

   276

*/

   277

   278

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

   279

                      uint8_t state /**< new link state */

   280

                      )

   281

{

   282

    if (unlikely(!device)) {

   283

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

   284

        return;

   285

    }

   286

   287

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

   288

        device->link_state = state;

   289

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

   290

    }

   291

}

   292

   293

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

   294

   295

/** \cond */

   296

   297

EXPORT_SYMBOL(ecdev_receive);

   298

EXPORT_SYMBOL(ecdev_link_state);

   299

   300

/** \endcond */

   301

   302

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