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

#ifdef EC_DEBUG_IF

    61

    char ifname[10];

    62

    char mb = 'x';

    63

#endif

    64

    65

    device->master = master;

    66

    67

#ifdef EC_DEBUG_IF

    68

    if (device == &master->main_device)

    69

        mb = 'm';

    70

    else if (device == &master->backup_device)

    71

        mb = 'b';

    72

    73

    sprintf(ifname, "ecdbg%c%u", mb, master->index);

    74

    75

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

    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_DEBUG_IF

    84

        goto out_debug;

    85

#else

    86

        goto out_return;

    87

#endif

    88

    }

    89

    90

    // add Ethernet-II-header

    91

    skb_reserve(device->tx_skb, ETH_HLEN);

    92

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

    93

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

    94

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

    95

    96

    ec_device_detach(device); // resets remaining fields

    97

    return 0;

    98

    99

#ifdef EC_DEBUG_IF

   100

 out_debug:

   101

    ec_debug_clear(&device->dbg);

   102

#endif

   103

 out_return:

   104

    return -1;

   105

}

   106

   107

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

   108

   109

/**

   110

   EtherCAT device destuctor.

   111

*/

   112

   113

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

   114

{

   115

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

   116

    dev_kfree_skb(device->tx_skb);

   117

#ifdef EC_DEBUG_IF

   118

    ec_debug_clear(&device->dbg);

   119

#endif

   120

}

   121

   122

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

   123

   124

/**

   125

   Associate with net_device.

   126

*/

   127

   128

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

   129

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

   130

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

   131

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

   132

        )

   133

{

   134

    ec_device_detach(device); // resets fields

   135

   136

    device->dev = net_dev;

   137

    device->poll = poll;

   138

    device->module = module;

   139

   140

    device->tx_skb->dev = net_dev;

   141

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

   142

}

   143

   144

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

   145

   146

/**

   147

   Disconnect from net_device.

   148

*/

   149

   150

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

   151

{

   152

    device->dev = NULL;

   153

    device->poll = NULL;

   154

    device->module = NULL;

   155

    device->open = 0;

   156

    device->link_state = 0; // down

   157

    device->tx_count = 0;

   158

    device->rx_count = 0;

   159

    device->tx_skb->dev = NULL;

   160

}

   161

   162

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

   163

   164

/**

   165

   Opens the EtherCAT device.

   166

   \return 0 in case of success, else < 0

   167

*/

   168

   169

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

   170

{

   171

    if (!device->dev) {

   172

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

   173

        return -1;

   174

    }

   175

   176

    if (device->open) {

   177

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

   178

        return 0;

   179

    }

   180

   181

    device->link_state = 0;

   182

    device->tx_count = 0;

   183

    device->rx_count = 0;

   184

   185

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

   186

   187

    return device->open ? 0 : -1;

   188

}

   189

   190

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

   191

   192

/**

   193

   Stops the EtherCAT device.

   194

   \return 0 in case of success, else < 0

   195

*/

   196

   197

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

   198

{

   199

    if (!device->dev) {

   200

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

   201

        return -1;

   202

    }

   203

   204

    if (!device->open) {

   205

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

   206

        return 0;

   207

    }

   208

   209

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

   210

   211

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

   212

}

   213

   214

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

   215

   216

/**

   217

   Returns a pointer to the device's transmit memory.

   218

   \return pointer to the TX socket buffer

   219

*/

   220

   221

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

   222

{

   223

    return device->tx_skb->data + ETH_HLEN;

   224

}

   225

   226

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

   227

   228

/**

   229

   Sends the content of the transmit socket buffer.

   230

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

   231

   start_xmit() function of the assigned net_device.

   232

*/

   233

   234

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

   235

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

   236

                    )

   237

{

   238

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

   239

        return;

   240

   241

    // set the right length for the data

   242

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

   243

   244

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

   245

        EC_DBG("sending frame:\n");

   246

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

   247

    }

   248

   249

#ifdef EC_DEBUG_IF

   250

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

   251

#endif

   252

   253

    // start sending

   254

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

   255

    device->tx_count++;

   256

}

   257

   258

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

   259

   260

/**

   261

   Calls the poll function of the assigned net_device.

   262

   The master itself works without using interrupts. Therefore the processing

   263

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

   264

   done by the master calling the ISR "manually".

   265

*/

   266

   267

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

   268

{

   269

    device->cycles_poll = get_cycles();

   270

    device->jiffies_poll = jiffies;

   271

    device->poll(device->dev);

   272

}

   273

   274

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

   275

 *  Device interface

   276

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

   277

   278

/**

   279

   Accepts a received frame.

   280

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

   281

   and dispatch the received commands to the sending instances.

   282

   \ingroup DeviceInterface

   283

*/

   284

   285

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

   286

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

   287

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

   288

                   )

   289

{

   290

    device->rx_count++;

   291

   292

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

   293

        EC_DBG("Received frame:\n");

   294

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

   295

                           data + ETH_HLEN, size - ETH_HLEN);

   296

    }

   297

   298

#ifdef EC_DEBUG_IF

   299

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

   300

#endif

   301

   302

    ec_master_receive_datagrams(device->master,

   303

                                data + ETH_HLEN,

   304

                                size - ETH_HLEN);

   305

}

   306

   307

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

   308

   309

/**

   310

   Sets a new link state.

   311

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

   312

   will not try to send frames using this device.

   313

   \ingroup DeviceInterface

   314

*/

   315

   316

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

   317

        uint8_t state /**< new link state */

   318

        )

   319

{

   320

    if (unlikely(!device)) {

   321

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

   322

        return;

   323

    }

   324

   325

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

   326

        device->link_state = state;

   327

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

   328

    }

   329

}

   330

   331

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

   332

   333

/**

   334

   Reads the link state.

   335

   \ingroup DeviceInterface

   336

*/

   337

   338

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

   339

{

   340

    if (unlikely(!device)) {

   341

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

   342

        return 0;

   343

    }

   344

   345

    return device->link_state;

   346

}

   347

   348

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

   349

   350

/** \cond */

   351

   352

EXPORT_SYMBOL(ecdev_receive);

   353

EXPORT_SYMBOL(ecdev_get_link);

   354

EXPORT_SYMBOL(ecdev_set_link);

   355

   356

/** \endcond */

   357

   358

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