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

    if (!device->dev) {

   160

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

   161

        return -1;

   162

    }

   163

   164

    if (device->open) {

   165

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

   166

        return 0;

   167

    }

   168

   169

    device->link_state = 0;

   170

    device->tx_count = 0;

   171

    device->rx_count = 0;

   172

   173

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

   174

   175

    return device->open ? 0 : -1;

   176

}

   177

   178

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

   179

   180

/**

   181

   Stops the EtherCAT device.

   182

   \return 0 in case of success, else < 0

   183

*/

   184

   185

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

   186

{

   187

    if (!device->dev) {

   188

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

   189

        return -1;

   190

    }

   191

   192

    if (!device->open) {

   193

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

   194

        return 0;

   195

    }

   196

   197

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

   198

   199

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

   200

}

   201

   202

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

   203

   204

/**

   205

   Returns a pointer to the device's transmit memory.

   206

   \return pointer to the TX socket buffer

   207

*/

   208

   209

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

   210

{

   211

    return device->tx_skb->data + ETH_HLEN;

   212

}

   213

   214

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

   215

   216

/**

   217

   Sends the content of the transmit socket buffer.

   218

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

   219

   start_xmit() function of the assigned net_device.

   220

*/

   221

   222

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

   223

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

   224

                    )

   225

{

   226

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

   227

        return;

   228

   229

    // set the right length for the data

   230

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

   231

   232

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

   233

        EC_DBG("sending frame:\n");

   234

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

   235

    }

   236

   237

#ifdef EC_DBG_IF

   238

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

   239

#endif

   240

   241

    // start sending

   242

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

   243

    device->tx_count++;

   244

}

   245

   246

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

   247

   248

/**

   249

   Calls the poll function of the assigned net_device.

   250

   The master itself works without using interrupts. Therefore the processing

   251

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

   252

   done by the master calling the ISR "manually".

   253

*/

   254

   255

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

   256

{

   257

    device->cycles_poll = get_cycles();

   258

    device->jiffies_poll = jiffies;

   259

    device->poll(device->dev);

   260

}

   261

   262

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

   263

 *  Device interface

   264

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

   265

   266

/**

   267

   Accepts a received frame.

   268

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

   269

   and dispatch the received commands to the sending instances.

   270

   \ingroup DeviceInterface

   271

*/

   272

   273

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

   274

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

   275

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

   276

                   )

   277

{

   278

    device->rx_count++;

   279

   280

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

   281

        EC_DBG("Received frame:\n");

   282

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

   283

                           data + ETH_HLEN, size - ETH_HLEN);

   284

    }

   285

   286

#ifdef EC_DBG_IF

   287

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

   288

#endif

   289

   290

    ec_master_receive_datagrams(device->master,

   291

                                data + ETH_HLEN,

   292

                                size - ETH_HLEN);

   293

}

   294

   295

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

   296

   297

/**

   298

   Sets a new link state.

   299

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

   300

   will not try to send frames using this device.

   301

   \ingroup DeviceInterface

   302

*/

   303

   304

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

   305

                      uint8_t state /**< new link state */

   306

                      )

   307

{

   308

    if (unlikely(!device)) {

   309

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

   310

        return;

   311

    }

   312

   313

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

   314

        device->link_state = state;

   315

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

   316

    }

   317

}

   318

   319

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

   320

   321

/** \cond */

   322

   323

EXPORT_SYMBOL(ecdev_receive);

   324

EXPORT_SYMBOL(ecdev_link_state);

   325

   326

/** \endcond */

   327

   328

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