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

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

    51

    52

int __init ec_gen_init_module(void);

    53

void __exit ec_gen_cleanup_module(void);

    54

    55

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

    56

    57

/** \cond */

    58

    59

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

    60

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

    61

MODULE_LICENSE("GPL");

    62

MODULE_VERSION(EC_MASTER_VERSION);

    63

    64

/** \endcond */

    65

    66

struct list_head generic_devices;

    67

    68

typedef struct {

    69

    struct list_head list;

    70

    struct net_device *netdev;

    71

    struct socket *socket;

    72

    ec_device_t *ecdev;

    73

} ec_gen_device_t;

    74

    75

int ec_gen_device_open(ec_gen_device_t *);

    76

int ec_gen_device_stop(ec_gen_device_t *);

    77

int ec_gen_device_start_xmit(ec_gen_device_t *, struct sk_buff *);

    78

void ec_gen_device_poll(ec_gen_device_t *);

    79

    80

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

    81

    82

static int ec_gen_netdev_open(struct net_device *dev)

    83

{

    84

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

    85

    return ec_gen_device_open(gendev);

    86

}

    87

    88

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

    89

    90

static int ec_gen_netdev_stop(struct net_device *dev)

    91

{

    92

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

    93

    return ec_gen_device_stop(gendev);

    94

}

    95

    96

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

    97

    98

static int ec_gen_netdev_start_xmit(

    99

        struct sk_buff *skb,

   100

        struct net_device *dev

   101

        )

   102

{

   103

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

   104

    return ec_gen_device_start_xmit(gendev, skb);

   105

}

   106

   107

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

   108

   109

void ec_gen_poll(struct net_device *dev)

   110

{

   111

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

   112

    ec_gen_device_poll(gendev);

   113

}

   114

   115

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

   116

   117

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

   118

static const struct net_device_ops ec_gen_netdev_ops = {

   119

    .ndo_open       = ec_gen_netdev_open,

   120

    .ndo_stop       = ec_gen_netdev_stop,

   121

    .ndo_start_xmit = ec_gen_netdev_start_xmit,

   122

};

   123

#endif

   124

   125

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

   126

   127

/** Init generic device.

   128

 */

   129

int ec_gen_device_init(

   130

        ec_gen_device_t *dev,

   131

        struct net_device *real_netdev

   132

        )

   133

{

   134

    ec_gen_device_t **priv;

   135

    char null = 0x00;

   136

   137

    dev->ecdev = NULL;

   138

    dev->socket = NULL;

   139

   140

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

   141

    if (!dev->netdev) {

   142

        return -ENOMEM;

   143

    }

   144

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

   145

   146

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

   147

    dev->netdev->netdev_ops = &ec_gen_netdev_ops;

   148

#else

   149

    dev->netdev->open = ec_gen_netdev_open;

   150

    dev->netdev->stop = ec_gen_netdev_stop;

   151

    dev->netdev->hard_start_xmit = ec_gen_netdev_start_xmit;

   152

#endif

   153

   154

    priv = netdev_priv(dev->netdev);

   155

    *priv = dev;

   156

   157

    return 0;

   158

}

   159

   160

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

   161

   162

/** Clear generic device.

   163

 */

   164

void ec_gen_device_clear(

   165

        ec_gen_device_t *dev

   166

        )

   167

{

   168

    if (dev->ecdev) {

   169

        ecdev_close(dev->ecdev);

   170

        ecdev_withdraw(dev->ecdev);

   171

    }

   172

    if (dev->socket) {

   173

        sock_release(dev->socket);

   174

    }

   175

    free_netdev(dev->netdev);

   176

}

   177

   178

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

   179

   180

/** Creates a network socket.

   181

 */

   182

int ec_gen_device_create_socket(

   183

        ec_gen_device_t *dev,

   184

        struct net_device *real_netdev

   185

        )

   186

{

   187

    int ret;

   188

    struct sockaddr_ll sa;

   189

   190

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

   191

    if (ret) {

   192

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

   193

        return ret;

   194

    }

   195

   196

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

   197

            real_netdev->ifindex, real_netdev->name);

   198

   199

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

   200

    sa.sll_family = AF_PACKET;

   201

    sa.sll_protocol = htons(ETH_P_ETHERCAT);

   202

    sa.sll_ifindex = real_netdev->ifindex;

   203

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

   204

    if (ret) {

   205

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

   206

        sock_release(dev->socket);

   207

        dev->socket = NULL;

   208

        return ret;

   209

    }

   210

   211

    return 0;

   212

}

   213

   214

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

   215

   216

/** Offer generic device to master.

   217

 */

   218

int ec_gen_device_offer(

   219

        ec_gen_device_t *dev,

   220

        struct net_device *real_netdev

   221

        )

   222

{

   223

    int ret = 0;

   224

   225

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

   226

    if (dev->ecdev) {

   227

        if (ec_gen_device_create_socket(dev, real_netdev)) {

   228

            ecdev_withdraw(dev->ecdev);

   229

            dev->ecdev = NULL;

   230

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

   231

            ecdev_withdraw(dev->ecdev);

   232

            dev->ecdev = NULL;

   233

        } else {

   234

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

   235

            ret = 1;

   236

        }

   237

    }

   238

   239

    return ret;

   240

}

   241

   242

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

   243

   244

/** Open the device.

   245

 */

   246

int ec_gen_device_open(

   247

        ec_gen_device_t *dev

   248

        )

   249

{

   250

    return 0;

   251

}

   252

   253

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

   254

   255

/** Stop the device.

   256

 */

   257

int ec_gen_device_stop(

   258

        ec_gen_device_t *dev

   259

        )

   260

{

   261

    return 0;

   262

}

   263

   264

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

   265

   266

int ec_gen_device_start_xmit(

   267

        ec_gen_device_t *dev,

   268

        struct sk_buff *skb

   269

        )

   270

{

   271

    struct msghdr msg;

   272

    struct kvec iov;

   273

    size_t len = skb->len;

   274

    int ret;

   275

   276

    iov.iov_base = skb->data;

   277

    iov.iov_len = len;

   278

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

   279

   280

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

   281

   282

    return ret == len ? NETDEV_TX_OK : NETDEV_TX_BUSY;

   283

}

   284

   285

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

   286

   287

/** Polls the device.

   288

 */

   289

void ec_gen_device_poll(

   290

        ec_gen_device_t *dev

   291

        )

   292

{

   293

    struct msghdr msg;

   294

    struct kvec iov;

   295

    char buf[2000]; // FIXME

   296

    int ret, budget = 10; // FIXME

   297

   298

    iov.iov_base = buf;

   299

    iov.iov_len = 2000;

   300

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

   301

   302

    do {

   303

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

   304

                MSG_DONTWAIT);

   305

        if (ret > 0) {

   306

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

   307

        } else if (ret < 0) {

   308

            break;

   309

        }

   310

        budget--;

   311

    } while (budget);

   312

}

   313

   314

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

   315

   316

/** Offer device.

   317

 */

   318

int offer_device(

   319

        struct net_device *netdev

   320

        )

   321

{

   322

    ec_gen_device_t *gendev;

   323

    int ret = 0;

   324

   325

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

   326

    if (!gendev) {

   327

        return -ENOMEM;

   328

    }

   329

   330

    ret = ec_gen_device_init(gendev, netdev);

   331

    if (ret) {

   332

        kfree(gendev);

   333

        return ret;

   334

    }

   335

   336

    if (ec_gen_device_offer(gendev, netdev)) {

   337

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

   338

    } else {

   339

        ec_gen_device_clear(gendev);

   340

        kfree(gendev);

   341

    }

   342

   343

    return ret;

   344

}

   345

   346

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

   347

   348

/** Clear devices.

   349

 */

   350

void clear_devices(void)

   351

{

   352

    ec_gen_device_t *gendev, *next;

   353

   354

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

   355

        list_del(&gendev->list);

   356

        ec_gen_device_clear(gendev);

   357

        kfree(gendev);

   358

    }

   359

}

   360

   361

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

   362

   363

/** Module initialization.

   364

 *

   365

 * Initializes \a master_count masters.

   366

 * \return 0 on success, else < 0

   367

 */

   368

int __init ec_gen_init_module(void)

   369

{

   370

    int ret = 0;

   371

    struct net_device *netdev;

   372

   373

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

   374

            EC_MASTER_VERSION);

   375

   376

    INIT_LIST_HEAD(&generic_devices);

   377

   378

    read_lock(&dev_base_lock);

   379

    for_each_netdev(&init_net, netdev) {

   380

        if (netdev->type != ARPHRD_ETHER)

   381

            continue;

   382

        ret = offer_device(netdev);

   383

        if (ret) {

   384

            read_unlock(&dev_base_lock);

   385

            goto out_err;

   386

        }

   387

    }

   388

    read_unlock(&dev_base_lock);

   389

    return ret;

   390

   391

out_err:

   392

    clear_devices();

   393

    return ret;

   394

}

   395

   396

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

   397

   398

/** Module cleanup.

   399

 *

   400

 * Clears all master instances.

   401

 */

   402

void __exit ec_gen_cleanup_module(void)

   403

{

   404

    clear_devices();

   405

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

   406

}

   407

   408

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

   409

   410

/** \cond */

   411

   412

module_init(ec_gen_init_module);

   413

module_exit(ec_gen_cleanup_module);

   414

   415

/** \endcond */

   416

   417

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