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

    46

#include "device.h"

    47

#include "master.h"

    48

    49

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

    50

    51

/**

    52

   Device constructor.

    53

   \return 0 in case of success, else < 0

    54

*/

    55

    56

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

    57

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

    58

        )

    59

{

    60

    device->master = master;

    61

    62

#ifdef EC_DBG_IF

    63

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

    64

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

    65

        goto out_return;

    66

    }

    67

#endif

    68

    69

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

    70

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

    71

#ifdef EC_DBG_IF

    72

        goto out_debug;

    73

#else

    74

        goto out_return;

    75

#endif

    76

    }

    77

    78

    // add Ethernet-II-header

    79

    skb_reserve(device->tx_skb, ETH_HLEN);

    80

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

    81

    device->eth->h_proto = htons(0x88A4);

    82

    memset(device->eth->h_dest, 0xFF, ETH_ALEN);

    83

    84

    ec_device_detach(device); // resets remaining fields

    85

    return 0;

    86

    87

#ifdef EC_DBG_IF

    88

 out_debug:

    89

    ec_debug_clear(&device->dbg);

    90

#endif

    91

 out_return:

    92

    return -1;

    93

}

    94

    95

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

    96

    97

/**

    98

   EtherCAT device destuctor.

    99

*/

   100

   101

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

   102

{

   103

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

   104

    dev_kfree_skb(device->tx_skb);

   105

#ifdef EC_DBG_IF

   106

    ec_debug_clear(&device->dbg);

   107

#endif

   108

}

   109

   110

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

   111

   112

/**

   113

   Associate with net_device.

   114

*/

   115

   116

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

   117

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

   118

        ec_pollfunc_t poll, /**< pointer to device's poll function */

   119

        struct module *module /**< the device's module */

   120

        )

   121

{

   122

    ec_device_detach(device); // resets fields

   123

   124

    device->dev = net_dev;

   125

    device->poll = poll;

   126

    device->module = module;

   127

   128

    device->tx_skb->dev = net_dev;

   129

    memcpy(device->eth->h_source, net_dev->dev_addr, ETH_ALEN);

   130

}

   131

   132

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

   133

   134

/**

   135

   Disconnect from net_device.

   136

*/

   137

   138

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

   139

{

   140

    device->dev = NULL;

   141

    device->poll = NULL;

   142

    device->module = NULL;

   143

    device->open = 0;

   144

    device->link_state = 0; // down

   145

    device->tx_count = 0;

   146

    device->rx_count = 0;

   147

    device->tx_skb->dev = NULL;

   148

}

   149

   150

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

   151

   152

/**

   153

   Opens the EtherCAT device.

   154

   \return 0 in case of success, else < 0

   155

*/

   156

   157

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

   158

{

   159

    unsigned int i;

   160

   161

    if (!device->dev) {

   162

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

   163

        return -1;

   164

    }

   165

   166

    if (device->open) {

   167

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

   168

        return 0;

   169

    }

   170

   171

    // device could have received frames before

   172

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

   173

   174

    device->link_state = 0;

   175

    device->tx_count = 0;

   176

    device->rx_count = 0;

   177

   178

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

   179

   180

    return device->open ? 0 : -1;

   181

}

   182

   183

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

   184

   185

/**

   186

   Stops the EtherCAT device.

   187

   \return 0 in case of success, else < 0

   188

*/

   189

   190

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

   191

{

   192

    if (!device->dev) {

   193

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

   194

        return -1;

   195

    }

   196

   197

    if (!device->open) {

   198

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

   199

        return 0;

   200

    }

   201

   202

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

   203

   204

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

   205

}

   206

   207

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

   208

   209

/**

   210

   Returns a pointer to the device's transmit memory.

   211

   \return pointer to the TX socket buffer

   212

*/

   213

   214

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

   215

{

   216

    return device->tx_skb->data + ETH_HLEN;

   217

}

   218

   219

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

   220

   221

/**

   222

   Sends the content of the transmit socket buffer.

   223

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

   224

   start_xmit() function of the assigned net_device.

   225

*/

   226

   227

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

   228

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

   229

                    )

   230

{

   231

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

   232

        return;

   233

   234

    // set the right length for the data

   235

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

   236

   237

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

   238

        EC_DBG("sending frame:\n");

   239

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

   240

    }

   241

   242

#ifdef EC_DBG_IF

   243

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

   244

#endif

   245

   246

    // start sending

   247

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

   248

    device->tx_count++;

   249

}

   250

   251

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

   252

   253

/**

   254

   Calls the poll function of the assigned net_device.

   255

   The master itself works without using interrupts. Therefore the processing

   256

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

   257

   done by the master calling the ISR "manually".

   258

*/

   259

   260

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

   261

{

   262

    device->cycles_poll = get_cycles();

   263

    device->jiffies_poll = jiffies;

   264

    device->poll(device->dev);

   265

}

   266

   267

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

   268

 *  Device interface

   269

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

   270

   271

/**

   272

   Accepts a received frame.

   273

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

   274

   and dispatch the received commands to the sending instances.

   275

   \ingroup DeviceInterface

   276

*/

   277

   278

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

   279

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

   280

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

   281

                   )

   282

{

   283

    device->rx_count++;

   284

   285

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

   286

        EC_DBG("Received frame:\n");

   287

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

   288

                           data + ETH_HLEN, size - ETH_HLEN);

   289

    }

   290

   291

#ifdef EC_DBG_IF

   292

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

   293

#endif

   294

   295

    ec_master_receive_datagrams(device->master,

   296

                                data + ETH_HLEN,

   297

                                size - ETH_HLEN);

   298

}

   299

   300

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

   301

   302

/**

   303

   Sets a new link state.

   304

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

   305

   will not try to send frames using this device.

   306

   \ingroup DeviceInterface

   307

*/

   308

   309

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

   310

                      uint8_t state /**< new link state */

   311

                      )

   312

{

   313

    if (unlikely(!device)) {

   314

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

   315

        return;

   316

    }

   317

   318

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

   319

        device->link_state = state;

   320

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

   321

    }

   322

}

   323

   324

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

   325

   326

/** \cond */

   327

   328

EXPORT_SYMBOL(ecdev_receive);

   329

EXPORT_SYMBOL(ecdev_link_state);

   330

   331

/** \endcond */

   332

   333

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