1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006-2008  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 and/or

    10

 *  modify it under the terms of the GNU General Public License version 2, as

    11

 *  published by the Free Software Foundation.

    12

 *

    13

 *  The IgH EtherCAT Master is distributed in the hope that it will be useful,

    14

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

    16

 *  Public License for more details.

    17

 *

    18

 *  You should have received a copy of the GNU General Public License along

    19

 *  with the IgH EtherCAT Master; if not, write to the Free Software

    20

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    21

 *

    22

 *  ---

    23

 *

    24

 *  The license mentioned above concerns the source code only. Using the

    25

 *  EtherCAT technology and brand is only permitted in compliance with the

    26

 *  industrial property and similar rights of Beckhoff Automation GmbH.

    27

 *

    28

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

    29

    30

/** \file

    31

 * EtherCAT generic Ethernet device module.

    32

 */

    33

    34

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

    35

    36

#include <linux/module.h>

    37

#include <linux/device.h>

    38

#include <linux/err.h>

    39

#include <linux/version.h>

    40

#include <linux/if_arp.h> /* ARPHRD_ETHER */

    41

#include <linux/etherdevice.h>

    42

    43

#include "../globals.h"

    44

#include "ecdev.h"

    45

    46

#define PFX "ec_generic: "

    47

    48

#define ETH_P_ETHERCAT 0x88A4

    49

    50

#define EC_GEN_RX_BUF_SIZE 1600

    51

    52

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

    53

    54

int __init ec_gen_init_module(void);

    55

void __exit ec_gen_cleanup_module(void);

    56

    57

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

    58

    59

/** \cond */

    60

    61

MODULE_AUTHOR("Florian Pose <fp@igh-essen.com>");

    62

MODULE_DESCRIPTION("EtherCAT master generic Ethernet device module");

    63

MODULE_LICENSE("GPL");

    64

MODULE_VERSION(EC_MASTER_VERSION);

    65

    66

/** \endcond */

    67

    68

struct list_head generic_devices;

    69

    70

typedef struct {

    71

    struct list_head list;

    72

    struct net_device *netdev;

    73

    struct socket *socket;

    74

    ec_device_t *ecdev;

    75

    uint8_t *rx_buf;

    76

} ec_gen_device_t;

    77

    78

typedef struct {

    79

    struct list_head list;

    80

    char name[IFNAMSIZ];

    81

    int ifindex;

    82

    uint8_t dev_addr[ETH_ALEN];

    83

} ec_gen_interface_desc_t;

    84

    85

int ec_gen_device_open(ec_gen_device_t *);

    86

int ec_gen_device_stop(ec_gen_device_t *);

    87

int ec_gen_device_start_xmit(ec_gen_device_t *, struct sk_buff *);

    88

void ec_gen_device_poll(ec_gen_device_t *);

    89

    90

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

    91

    92

static int ec_gen_netdev_open(struct net_device *dev)

    93

{

    94

    ec_gen_device_t *gendev = *((ec_gen_device_t **) netdev_priv(dev));

    95

    return ec_gen_device_open(gendev);

    96

}

    97

    98

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

    99

   100

static int ec_gen_netdev_stop(struct net_device *dev)

   101

{

   102

    ec_gen_device_t *gendev = *((ec_gen_device_t **) netdev_priv(dev));

   103

    return ec_gen_device_stop(gendev);

   104

}

   105

   106

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

   107

   108

static int ec_gen_netdev_start_xmit(

   109

        struct sk_buff *skb,

   110

        struct net_device *dev

   111

        )

   112

{

   113

    ec_gen_device_t *gendev = *((ec_gen_device_t **) netdev_priv(dev));

   114

    return ec_gen_device_start_xmit(gendev, skb);

   115

}

   116

   117

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

   118

   119

void ec_gen_poll(struct net_device *dev)

   120

{

   121

    ec_gen_device_t *gendev = *((ec_gen_device_t **) netdev_priv(dev));

   122

    ec_gen_device_poll(gendev);

   123

}

   124

   125

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

   126

   127

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)

   128

static const struct net_device_ops ec_gen_netdev_ops = {

   129

    .ndo_open       = ec_gen_netdev_open,

   130

    .ndo_stop       = ec_gen_netdev_stop,

   131

    .ndo_start_xmit = ec_gen_netdev_start_xmit,

   132

};

   133

#endif

   134

   135

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

   136

   137

/** Init generic device.

   138

 */

   139

int ec_gen_device_init(

   140

        ec_gen_device_t *dev

   141

        )

   142

{

   143

    ec_gen_device_t **priv;

   144

    char null = 0x00;

   145

   146

    dev->ecdev = NULL;

   147

    dev->socket = NULL;

   148

    dev->rx_buf = NULL;

   149

   150

    dev->netdev = alloc_netdev(sizeof(ec_gen_device_t *), &null, ether_setup);

   151

    if (!dev->netdev) {

   152

        return -ENOMEM;

   153

    }

   154

   155

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)

   156

    dev->netdev->netdev_ops = &ec_gen_netdev_ops;

   157

#else

   158

    dev->netdev->open = ec_gen_netdev_open;

   159

    dev->netdev->stop = ec_gen_netdev_stop;

   160

    dev->netdev->hard_start_xmit = ec_gen_netdev_start_xmit;

   161

#endif

   162

   163

    priv = netdev_priv(dev->netdev);

   164

    *priv = dev;

   165

   166

    return 0;

   167

}

   168

   169

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

   170

   171

/** Clear generic device.

   172

 */

   173

void ec_gen_device_clear(

   174

        ec_gen_device_t *dev

   175

        )

   176

{

   177

    if (dev->ecdev) {

   178

        ecdev_close(dev->ecdev);

   179

        ecdev_withdraw(dev->ecdev);

   180

    }

   181

    if (dev->socket) {

   182

        sock_release(dev->socket);

   183

    }

   184

    free_netdev(dev->netdev);

   185

   186

    if (dev->rx_buf) {

   187

        kfree(dev->rx_buf);

   188

    }

   189

}

   190

   191

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

   192

   193

/** Creates a network socket.

   194

 */

   195

int ec_gen_device_create_socket(

   196

        ec_gen_device_t *dev,

   197

        ec_gen_interface_desc_t *desc

   198

        )

   199

{

   200

    int ret;

   201

    struct sockaddr_ll sa;

   202

   203

    dev->rx_buf = kmalloc(EC_GEN_RX_BUF_SIZE, GFP_KERNEL);

   204

    if (!dev->rx_buf) {

   205

        return -ENOMEM;

   206

    }

   207

   208

    ret = sock_create_kern(PF_PACKET, SOCK_RAW, htons(ETH_P_ETHERCAT), &dev->socket);

   209

    if (ret) {

   210

        printk(KERN_ERR PFX "Failed to create socket.\n");

   211

        return ret;

   212

    }

   213

   214

    printk(KERN_ERR PFX "Binding socket to interface %i (%s).\n",

   215

            desc->ifindex, desc->name);

   216

   217

    memset(&sa, 0x00, sizeof(sa));

   218

    sa.sll_family = AF_PACKET;

   219

    sa.sll_protocol = htons(ETH_P_ETHERCAT);

   220

    sa.sll_ifindex = desc->ifindex;

   221

    ret = kernel_bind(dev->socket, (struct sockaddr *) &sa, sizeof(sa));

   222

    if (ret) {

   223

        printk(KERN_ERR PFX "Failed to bind() socket to interface.\n");

   224

        sock_release(dev->socket);

   225

        dev->socket = NULL;

   226

        return ret;

   227

    }

   228

   229

    return 0;

   230

}

   231

   232

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

   233

   234

/** Offer generic device to master.

   235

 */

   236

int ec_gen_device_offer(

   237

        ec_gen_device_t *dev,

   238

        ec_gen_interface_desc_t *desc

   239

        )

   240

{

   241

    int ret = 0;

   242

   243

    memcpy(dev->netdev->dev_addr, desc->dev_addr, ETH_ALEN);

   244

   245

    dev->ecdev = ecdev_offer(dev->netdev, ec_gen_poll, THIS_MODULE);

   246

    if (dev->ecdev) {

   247

        if (ec_gen_device_create_socket(dev, desc)) {

   248

            ecdev_withdraw(dev->ecdev);

   249

            dev->ecdev = NULL;

   250

        } else if (ecdev_open(dev->ecdev)) {

   251

            ecdev_withdraw(dev->ecdev);

   252

            dev->ecdev = NULL;

   253

        } else {

   254

            ecdev_set_link(dev->ecdev, 1); // FIXME

   255

            ret = 1;

   256

        }

   257

    }

   258

   259

    return ret;

   260

}

   261

   262

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

   263

   264

/** Open the device.

   265

 */

   266

int ec_gen_device_open(

   267

        ec_gen_device_t *dev

   268

        )

   269

{

   270

    return 0;

   271

}

   272

   273

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

   274

   275

/** Stop the device.

   276

 */

   277

int ec_gen_device_stop(

   278

        ec_gen_device_t *dev

   279

        )

   280

{

   281

    return 0;

   282

}

   283

   284

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

   285

   286

int ec_gen_device_start_xmit(

   287

        ec_gen_device_t *dev,

   288

        struct sk_buff *skb

   289

        )

   290

{

   291

    struct msghdr msg;

   292

    struct kvec iov;

   293

    size_t len = skb->len;

   294

    int ret;

   295

   296

    iov.iov_base = skb->data;

   297

    iov.iov_len = len;

   298

    memset(&msg, 0, sizeof(msg));

   299

   300

    ret = kernel_sendmsg(dev->socket, &msg, &iov, 1, len);

   301

   302

    return ret == len ? NETDEV_TX_OK : NETDEV_TX_BUSY;

   303

}

   304

   305

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

   306

   307

/** Polls the device.

   308

 */

   309

void ec_gen_device_poll(

   310

        ec_gen_device_t *dev

   311

        )

   312

{

   313

    struct msghdr msg;

   314

    struct kvec iov;

   315

    int ret, budget = 10; // FIXME

   316

   317

    do {

   318

        iov.iov_base = dev->rx_buf;

   319

        iov.iov_len = EC_GEN_RX_BUF_SIZE;

   320

        memset(&msg, 0, sizeof(msg));

   321

   322

        ret = kernel_recvmsg(dev->socket, &msg, &iov, 1, iov.iov_len,

   323

                MSG_DONTWAIT);

   324

        if (ret > 0) {

   325

            ecdev_receive(dev->ecdev, dev->rx_buf, ret);

   326

        } else if (ret < 0) {

   327

            break;

   328

        }

   329

        budget--;

   330

    } while (budget);

   331

}

   332

   333

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

   334

   335

/** Offer device.

   336

 */

   337

int offer_device(

   338

        ec_gen_interface_desc_t *desc

   339

        )

   340

{

   341

    ec_gen_device_t *gendev;

   342

    int ret = 0;

   343

   344

    gendev = kmalloc(sizeof(ec_gen_device_t), GFP_KERNEL);

   345

    if (!gendev) {

   346

        return -ENOMEM;

   347

    }

   348

   349

    ret = ec_gen_device_init(gendev);

   350

    if (ret) {

   351

        kfree(gendev);

   352

        return ret;

   353

    }

   354

   355

    if (ec_gen_device_offer(gendev, desc)) {

   356

        list_add_tail(&gendev->list, &generic_devices);

   357

    } else {

   358

        ec_gen_device_clear(gendev);

   359

        kfree(gendev);

   360

    }

   361

   362

    return ret;

   363

}

   364

   365

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

   366

   367

/** Clear devices.

   368

 */

   369

void clear_devices(void)

   370

{

   371

    ec_gen_device_t *gendev, *next;

   372

   373

    list_for_each_entry_safe(gendev, next, &generic_devices, list) {

   374

        list_del(&gendev->list);

   375

        ec_gen_device_clear(gendev);

   376

        kfree(gendev);

   377

    }

   378

}

   379

   380

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

   381

   382

/** Module initialization.

   383

 *

   384

 * Initializes \a master_count masters.

   385

 * \return 0 on success, else < 0

   386

 */

   387

int __init ec_gen_init_module(void)

   388

{

   389

    int ret = 0;

   390

    struct list_head descs;

   391

    struct net_device *netdev;

   392

    ec_gen_interface_desc_t *desc, *next;

   393

   394

    printk(KERN_INFO PFX "EtherCAT master generic Ethernet device module %s\n",

   395

            EC_MASTER_VERSION);

   396

   397

    INIT_LIST_HEAD(&generic_devices);

   398

    INIT_LIST_HEAD(&descs);

   399

   400

    read_lock(&dev_base_lock);

   401

    for_each_netdev(&init_net, netdev) {

   402

        if (netdev->type != ARPHRD_ETHER)

   403

            continue;

   404

        desc = kmalloc(sizeof(ec_gen_interface_desc_t), GFP_KERNEL);

   405

        if (!desc) {

   406

            ret = -ENOMEM;

   407

            read_unlock(&dev_base_lock);

   408

            goto out_err;

   409

        }

   410

        strncpy(desc->name, netdev->name, IFNAMSIZ);

   411

        desc->ifindex = netdev->ifindex;

   412

        memcpy(desc->dev_addr, netdev->dev_addr, ETH_ALEN);

   413

        list_add_tail(&desc->list, &descs);

   414

    }

   415

    read_unlock(&dev_base_lock);

   416

   417

    list_for_each_entry_safe(desc, next, &descs, list) {

   418

        ret = offer_device(desc);

   419

        if (ret) {

   420

            goto out_err;

   421

        }

   422

        kfree(desc);

   423

    }

   424

    return ret;

   425

   426

out_err:

   427

    list_for_each_entry_safe(desc, next, &descs, list) {

   428

        list_del(&desc->list);

   429

        kfree(desc);

   430

    }

   431

    clear_devices();

   432

    return ret;

   433

}

   434

   435

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

   436

   437

/** Module cleanup.

   438

 *

   439

 * Clears all master instances.

   440

 */

   441

void __exit ec_gen_cleanup_module(void)

   442

{

   443

    clear_devices();

   444

    printk(KERN_INFO PFX "Unloading.\n");

   445

}

   446

   447

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

   448

   449

/** \cond */

   450

   451

module_init(ec_gen_init_module);

   452

module_exit(ec_gen_cleanup_module);

   453

   454

/** \endcond */

   455

   456

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