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

    75

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

    76

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

    77

        goto out_return;

    78

    }

    80

    81

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

    82

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

    84

        goto out_debug;

    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

   102

 out_debug:

   103

    ec_debug_clear(&device->dbg);

   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);

   120

    ec_debug_clear(&device->dbg);

   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

   215

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

   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

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

   234

}

   235

   236

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

   237

 *  Device interface

   238

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

   239

   240

/**

   241

   Accepts a received frame.

   242

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

   243

   and dispatch the received commands to the sending instances.

   244

   \ingroup DeviceInterface

   245

*/

   246

   247

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

   248

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

   249

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

   250

                   )

   251

{

   252

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

   253

        EC_DBG("Received frame:\n");

   254

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

   255

                           data + ETH_HLEN, size - ETH_HLEN);

   256

    }

   257

   259

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

   261

   262

    ec_master_receive_datagrams(device->master,

   263

                                data + ETH_HLEN,

   264

                                size - ETH_HLEN);

   265

}

   266

   267

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

   268

   269

/**

   270

   Sets a new link state.

   271

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

   272

   will not try to send frames using this device.

   273

   \ingroup DeviceInterface

   274

*/

   275

   276

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

   277

                      uint8_t state /**< new link state */

   278

                      )

   279

{

   280

    if (unlikely(!device)) {

   281

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

   282

        return;

   283

    }

   284

   285

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

   286

        device->link_state = state;

   287

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

   288

    }

   289

}

   290

   291

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

   292

   293

/** \cond */

   294

   295

EXPORT_SYMBOL(ecdev_receive);

   296

EXPORT_SYMBOL(ecdev_link_state);

   297

   298

/** \endcond */

   299

   300

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