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 net_device *used_netdev;

    74

    struct socket *socket;

    75

    ec_device_t *ecdev;

    76

    uint8_t *rx_buf;

    77

} ec_gen_device_t;

    78

    79

typedef struct {

    80

    struct list_head list;

    81

    struct net_device *netdev;

    82

    char name[IFNAMSIZ];

    83

    int ifindex;

    84

    uint8_t dev_addr[ETH_ALEN];

    85

} ec_gen_interface_desc_t;

    86

    87

int ec_gen_device_open(ec_gen_device_t *);

    88

int ec_gen_device_stop(ec_gen_device_t *);

    89

int ec_gen_device_start_xmit(ec_gen_device_t *, struct sk_buff *);

    90

void ec_gen_device_poll(ec_gen_device_t *);

    91

    92

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

    93

    94

static int ec_gen_netdev_open(struct net_device *dev)

    95

{

    96

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

    97

    return ec_gen_device_open(gendev);

    98

}

    99

   100

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

   101

   102

static int ec_gen_netdev_stop(struct net_device *dev)

   103

{

   104

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

   105

    return ec_gen_device_stop(gendev);

   106

}

   107

   108

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

   109

   110

static int ec_gen_netdev_start_xmit(

   111

        struct sk_buff *skb,

   112

        struct net_device *dev

   113

        )

   114

{

   115

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

   116

    return ec_gen_device_start_xmit(gendev, skb);

   117

}

   118

   119

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

   120

   121

void ec_gen_poll(struct net_device *dev)

   122

{

   123

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

   124

    ec_gen_device_poll(gendev);

   125

}

   126

   127

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

   128

   129

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

   130

static const struct net_device_ops ec_gen_netdev_ops = {

   131

    .ndo_open       = ec_gen_netdev_open,

   132

    .ndo_stop       = ec_gen_netdev_stop,

   133

    .ndo_start_xmit = ec_gen_netdev_start_xmit,

   134

};

   135

#endif

   136

   137

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

   138

   139

/** Init generic device.

   140

 */

   141

int ec_gen_device_init(

   142

        ec_gen_device_t *dev

   143

        )

   144

{

   145

    ec_gen_device_t **priv;

   146

    char null = 0x00;

   147

   148

    dev->ecdev = NULL;

   149

    dev->socket = NULL;

   150

    dev->rx_buf = NULL;

   151

   152

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 17, 0)

   153

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

   154

            NET_NAME_UNKNOWN, ether_setup);

   155

#else

   156

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

   157

#endif

   158

    if (!dev->netdev) {

   159

        return -ENOMEM;

   160

    }

   161

   162

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

   163

    dev->netdev->netdev_ops = &ec_gen_netdev_ops;

   164

#else

   165

    dev->netdev->open = ec_gen_netdev_open;

   166

    dev->netdev->stop = ec_gen_netdev_stop;

   167

    dev->netdev->hard_start_xmit = ec_gen_netdev_start_xmit;

   168

#endif

   169

   170

    priv = netdev_priv(dev->netdev);

   171

    *priv = dev;

   172

   173

    return 0;

   174

}

   175

   176

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

   177

   178

/** Clear generic device.

   179

 */

   180

void ec_gen_device_clear(

   181

        ec_gen_device_t *dev

   182

        )

   183

{

   184

    if (dev->ecdev) {

   185

        ecdev_close(dev->ecdev);

   186

        ecdev_withdraw(dev->ecdev);

   187

    }

   188

    if (dev->socket) {

   189

        sock_release(dev->socket);

   190

    }

   191

    free_netdev(dev->netdev);

   192

   193

    if (dev->rx_buf) {

   194

        kfree(dev->rx_buf);

   195

    }

   196

}

   197

   198

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

   199

   200

/** Creates a network socket.

   201

 */

   202

int ec_gen_device_create_socket(

   203

        ec_gen_device_t *dev,

   204

        ec_gen_interface_desc_t *desc

   205

        )

   206

{

   207

    int ret;

   208

    struct sockaddr_ll sa;

   209

   210

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

   211

    if (!dev->rx_buf) {

   212

        return -ENOMEM;

   213

    }

   214

   215

#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)

   216

    ret = sock_create_kern(&init_net, PF_PACKET, SOCK_RAW,

   217

            htons(ETH_P_ETHERCAT), &dev->socket);

   218

#else

   219

    ret = sock_create_kern(PF_PACKET, SOCK_RAW, htons(ETH_P_ETHERCAT),

   220

            &dev->socket);

   221

#endif

   222

    if (ret) {

   223

        printk(KERN_ERR PFX "Failed to create socket (ret = %i).\n", ret);

   224

        return ret;

   225

    }

   226

   227

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

   228

            desc->ifindex, desc->name);

   229

   230

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

   231

    sa.sll_family = AF_PACKET;

   232

    sa.sll_protocol = htons(ETH_P_ETHERCAT);

   233

    sa.sll_ifindex = desc->ifindex;

   234

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

   235

    if (ret) {

   236

        printk(KERN_ERR PFX "Failed to bind() socket to interface"

   237

                " (ret = %i).\n", ret);

   238

        sock_release(dev->socket);

   239

        dev->socket = NULL;

   240

        return ret;

   241

    }

   242

   243

    return 0;

   244

}

   245

   246

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

   247

   248

/** Offer generic device to master.

   249

 */

   250

int ec_gen_device_offer(

   251

        ec_gen_device_t *dev,

   252

        ec_gen_interface_desc_t *desc

   253

        )

   254

{

   255

    int ret = 0;

   256

   257

    dev->used_netdev = desc->netdev;

   258

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

   259

   260

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

   261

    if (dev->ecdev) {

   262

        if (ec_gen_device_create_socket(dev, desc)) {

   263

            ecdev_withdraw(dev->ecdev);

   264

            dev->ecdev = NULL;

   265

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

   266

            ecdev_withdraw(dev->ecdev);

   267

            dev->ecdev = NULL;

   268

        } else {

   269

            ecdev_set_link(dev->ecdev, netif_carrier_ok(dev->used_netdev)); // FIXME

   270

            ret = 1;

   271

        }

   272

    }

   273

   274

    return ret;

   275

}

   276

   277

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

   278

   279

/** Open the device.

   280

 */

   281

int ec_gen_device_open(

   282

        ec_gen_device_t *dev

   283

        )

   284

{

   285

    return 0;

   286

}

   287

   288

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

   289

   290

/** Stop the device.

   291

 */

   292

int ec_gen_device_stop(

   293

        ec_gen_device_t *dev

   294

        )

   295

{

   296

    return 0;

   297

}

   298

   299

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

   300

   301

int ec_gen_device_start_xmit(

   302

        ec_gen_device_t *dev,

   303

        struct sk_buff *skb

   304

        )

   305

{

   306

    struct msghdr msg;

   307

    struct kvec iov;

   308

    size_t len = skb->len;

   309

    int ret;

   310

   311

    ecdev_set_link(dev->ecdev, netif_carrier_ok(dev->used_netdev));

   312

   313

    iov.iov_base = skb->data;

   314

    iov.iov_len = len;

   315

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

   316

   317

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

   318

   319

    return ret == len ? NETDEV_TX_OK : NETDEV_TX_BUSY;

   320

}

   321

   322

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

   323

   324

/** Polls the device.

   325

 */

   326

void ec_gen_device_poll(

   327

        ec_gen_device_t *dev

   328

        )

   329

{

   330

    struct msghdr msg;

   331

    struct kvec iov;

   332

    int ret, budget = 10; // FIXME

   333

   334

    ecdev_set_link(dev->ecdev, netif_carrier_ok(dev->used_netdev));

   335

   336

    do {

   337

        iov.iov_base = dev->rx_buf;

   338

        iov.iov_len = EC_GEN_RX_BUF_SIZE;

   339

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

   340

   341

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

   342

                MSG_DONTWAIT);

   343

        if (ret > 0) {

   344

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

   345

        } else if (ret < 0) {

   346

            break;

   347

        }

   348

        budget--;

   349

    } while (budget);

   350

}

   351

   352

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

   353

   354

/** Offer device.

   355

 */

   356

int offer_device(

   357

        ec_gen_interface_desc_t *desc

   358

        )

   359

{

   360

    ec_gen_device_t *gendev;

   361

    int ret = 0;

   362

   363

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

   364

    if (!gendev) {

   365

        return -ENOMEM;

   366

    }

   367

   368

    ret = ec_gen_device_init(gendev);

   369

    if (ret) {

   370

        kfree(gendev);

   371

        return ret;

   372

    }

   373

   374

    if (ec_gen_device_offer(gendev, desc)) {

   375

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

   376

    } else {

   377

        ec_gen_device_clear(gendev);

   378

        kfree(gendev);

   379

    }

   380

   381

    return ret;

   382

}

   383

   384

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

   385

   386

/** Clear devices.

   387

 */

   388

void clear_devices(void)

   389

{

   390

    ec_gen_device_t *gendev, *next;

   391

   392

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

   393

        list_del(&gendev->list);

   394

        ec_gen_device_clear(gendev);

   395

        kfree(gendev);

   396

    }

   397

}

   398

   399

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

   400

   401

/** Module initialization.

   402

 *

   403

 * Initializes \a master_count masters.

   404

 * \return 0 on success, else < 0

   405

 */

   406

int __init ec_gen_init_module(void)

   407

{

   408

    int ret = 0;

   409

    struct list_head descs;

   410

    struct net_device *netdev;

   411

    ec_gen_interface_desc_t *desc, *next;

   412

   413

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

   414

            EC_MASTER_VERSION);

   415

   416

    INIT_LIST_HEAD(&generic_devices);

   417

    INIT_LIST_HEAD(&descs);

   418

   419

    read_lock(&dev_base_lock);

   420

    for_each_netdev(&init_net, netdev) {

   421

        if (netdev->type != ARPHRD_ETHER)

   422

            continue;

   423

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

   424

        if (!desc) {

   425

            ret = -ENOMEM;

   426

            read_unlock(&dev_base_lock);

   427

            goto out_err;

   428

        }

   429

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

   430

        desc->netdev = netdev;

   431

        desc->ifindex = netdev->ifindex;

   432

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

   433

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

   434

    }

   435

    read_unlock(&dev_base_lock);

   436

   437

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

   438

        ret = offer_device(desc);

   439

        if (ret) {

   440

            goto out_err;

   441

        }

   442

        kfree(desc);

   443

    }

   444

    return ret;

   445

   446

out_err:

   447

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

   448

        list_del(&desc->list);

   449

        kfree(desc);

   450

    }

   451

    clear_devices();

   452

    return ret;

   453

}

   454

   455

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

   456

   457

/** Module cleanup.

   458

 *

   459

 * Clears all master instances.

   460

 */

   461

void __exit ec_gen_cleanup_module(void)

   462

{

   463

    clear_devices();

   464

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

   465

}

   466

   467

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

   468

   469

/** \cond */

   470

   471

module_init(ec_gen_init_module);

   472

module_exit(ec_gen_cleanup_module);

   473

   474

/** \endcond */

   475

   476

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