1

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

     2

 *

     3

 *  $Id: cdev.c,v ebda087981e1 2011/09/15 13:58:58 fp $

     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

/**

    31

   \file

    32

   EtherCAT master character device.

    33

*/

    34

    35

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

    36

    37

#include <linux/module.h>

    38

#include <linux/vmalloc.h>

    39

#include <linux/mm.h>

    40

    41

#include "cdev.h"

    42

#include "master.h"

    43

#include "slave_config.h"

    44

#include "voe_handler.h"

    45

#include "ethernet.h"

    46

#include "ioctl.h"

    47

    48

/** Set to 1 to enable ioctl() command debugging.

    49

 */

    50

#define DEBUG_IOCTL 0

    51

    52

/** Set to 1 to enable ioctl() latency warnings.

    53

 *

    54

 * Requires CPU timestamp counter!

    55

 */

    56

#define DEBUG_LATENCY 0

    57

    58

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

    59

    60

static int eccdev_open(struct inode *, struct file *);

    61

static int eccdev_release(struct inode *, struct file *);

    62

static long eccdev_ioctl(struct file *, unsigned int, unsigned long);

    63

static int eccdev_mmap(struct file *, struct vm_area_struct *);

    64

    65

/** This is the kernel version from which the .fault member of the

    66

 * vm_operations_struct is usable.

    67

 */

    68

#define PAGE_FAULT_VERSION KERNEL_VERSION(2, 6, 23)

    69

    70

#if LINUX_VERSION_CODE >= PAGE_FAULT_VERSION

    71

static int eccdev_vma_fault(struct vm_area_struct *, struct vm_fault *);

    72

#else

    73

static struct page *eccdev_vma_nopage(

    74

        struct vm_area_struct *, unsigned long, int *);

    75

#endif

    76

    77

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

    78

    79

/** File operation callbacks for the EtherCAT character device.

    80

 */

    81

static struct file_operations eccdev_fops = {

    82

    .owner          = THIS_MODULE,

    83

    .open           = eccdev_open,

    84

    .release        = eccdev_release,

    85

    .unlocked_ioctl = eccdev_ioctl,

    86

    .mmap           = eccdev_mmap

    87

};

    88

    89

/** Callbacks for a virtual memory area retrieved with ecdevc_mmap().

    90

 */

    91

struct vm_operations_struct eccdev_vm_ops = {

    92

#if LINUX_VERSION_CODE >= PAGE_FAULT_VERSION

    93

    .fault = eccdev_vma_fault

    94

#else

    95

    .nopage = eccdev_vma_nopage

    96

#endif

    97

};

    98

    99

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

   100

   101

/** Private data structure for file handles.

   102

 */

   103

typedef struct {

   104

    ec_cdev_t *cdev; /**< Character device. */

   105

    unsigned int requested; /**< Master wac requested via this file handle. */

   106

    uint8_t *process_data; /**< Total process data area. */

   107

    size_t process_data_size; /**< Size of the \a process_data. */

   108

} ec_cdev_priv_t;

   109

   110

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

   111

   112

/** Constructor.

   113

 * 

   114

 * \return 0 in case of success, else < 0

   115

 */

   116

int ec_cdev_init(

   117

        ec_cdev_t *cdev, /**< EtherCAT master character device. */

   118

        ec_master_t *master, /**< Parent master. */

   119

        dev_t dev_num /**< Device number. */

   120

        )

   121

{

   122

    int ret;

   123

   124

    cdev->master = master;

   125

   126

    cdev_init(&cdev->cdev, &eccdev_fops);

   127

    cdev->cdev.owner = THIS_MODULE;

   128

   129

    ret = cdev_add(&cdev->cdev,

   130

            MKDEV(MAJOR(dev_num), master->index), 1);

   131

    if (ret) {

   132

        EC_MASTER_ERR(master, "Failed to add character device!\n");

   133

    }

   134

   135

    return ret;

   136

}

   137

   138

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

   139

   140

/** Destructor.

   141

 */

   142

void ec_cdev_clear(ec_cdev_t *cdev /**< EtherCAT XML device */)

   143

{

   144

    cdev_del(&cdev->cdev);

   145

}

   146

   147

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

   148

   149

/** Copies a string to an ioctl structure.

   150

 */

   151

void ec_cdev_strcpy(

   152

        char *target, /**< Target. */

   153

        const char *source /**< Source. */

   154

        )

   155

{

   156

    if (source) {

   157

        strncpy(target, source, EC_IOCTL_STRING_SIZE);

   158

        target[EC_IOCTL_STRING_SIZE - 1] = 0;

   159

    } else {

   160

        target[0] = 0;

   161

    }

   162

}

   163

   164

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

   165

   166

/** Get module information.

   167

 */

   168

int ec_cdev_ioctl_module(

   169

        unsigned long arg /**< Userspace address to store the results. */

   170

        )

   171

{

   172

    ec_ioctl_module_t data;

   173

   174

    data.ioctl_version_magic = EC_IOCTL_VERSION_MAGIC;

   175

    data.master_count = ec_master_count();

   176

   177

    if (copy_to_user((void __user *) arg, &data, sizeof(data)))

   178

        return -EFAULT;

   179

   180

    return 0;

   181

}

   182

   183

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

   184

   185

/** Get master information.

   186

 */

   187

int ec_cdev_ioctl_master(

   188

        ec_master_t *master, /**< EtherCAT master. */

   189

        unsigned long arg /**< Userspace address to store the results. */

   190

        )

   191

{

   192

    ec_ioctl_master_t data;

   193

    unsigned int i;

   194

   195

    if (ec_mutex_lock_interruptible(&master->master_mutex))

   196

        return -EINTR;

   197

    data.slave_count = master->slave_count;

   198

    data.config_count = ec_master_config_count(master);

   199

    data.domain_count = ec_master_domain_count(master);

   200

#ifdef EC_EOE

   201

    data.eoe_handler_count = ec_master_eoe_handler_count(master);

   202

#endif

   203

    data.phase = (uint8_t) master->phase;

   204

    data.active = (uint8_t) master->active;

   205

    data.scan_busy = master->scan_busy;

   206

    ec_mutex_unlock(&master->master_mutex);

   207

   208

    if (ec_mutex_lock_interruptible(&master->device_mutex))

   209

        return -EINTR;

   210

   211

    if (master->main_device.dev) {

   212

        memcpy(data.devices[0].address,

   213

                master->main_device.dev->dev_addr, ETH_ALEN);

   214

    } else {

   215

        memcpy(data.devices[0].address, master->main_mac, ETH_ALEN); 

   216

    }

   217

    data.devices[0].attached = master->main_device.dev ? 1 : 0;

   218

    data.devices[0].link_state = master->main_device.link_state ? 1 : 0;

   219

    data.devices[0].tx_count = master->main_device.tx_count;

   220

    data.devices[0].rx_count = master->main_device.rx_count;

   221

    data.devices[0].tx_bytes = master->main_device.tx_bytes;

   222

    data.devices[0].tx_errors = master->main_device.tx_errors;

   223

    for (i = 0; i < EC_RATE_COUNT; i++) {

   224

        data.devices[0].tx_frame_rates[i] =

   225

            master->main_device.tx_frame_rates[i];

   226

        data.devices[0].tx_byte_rates[i] =

   227

            master->main_device.tx_byte_rates[i];

   228

        data.devices[0].loss_rates[i] = master->main_device.loss_rates[i];

   229

    }

   230

   231

    if (master->backup_device.dev) {

   232

        memcpy(data.devices[1].address,

   233

                master->backup_device.dev->dev_addr, ETH_ALEN); 

   234

    } else {

   235

        memcpy(data.devices[1].address, master->backup_mac, ETH_ALEN); 

   236

    }

   237

    data.devices[1].attached = master->backup_device.dev ? 1 : 0;

   238

    data.devices[1].link_state = master->backup_device.link_state ? 1 : 0;

   239

    data.devices[1].tx_count = master->backup_device.tx_count;

   240

    data.devices[1].rx_count = master->backup_device.rx_count;

   241

    data.devices[1].tx_bytes = master->backup_device.tx_bytes;

   242

    data.devices[1].tx_errors = master->backup_device.tx_errors;

   243

    for (i = 0; i < EC_RATE_COUNT; i++) {

   244

        data.devices[1].tx_frame_rates[i] =

   245

            master->backup_device.tx_frame_rates[i];

   246

        data.devices[1].tx_byte_rates[i] =

   247

            master->backup_device.tx_byte_rates[i];

   248

        data.devices[1].loss_rates[i] = master->backup_device.loss_rates[i];

   249

    }

   250

   251

    ec_mutex_unlock(&master->device_mutex);

   252

   253

    data.app_time = master->app_time;

   254

    data.ref_clock =

   255

        master->dc_ref_clock ? master->dc_ref_clock->ring_position : 0xffff;

   256

   257

    if (copy_to_user((void __user *) arg, &data, sizeof(data)))

   258

        return -EFAULT;

   259

   260

    return 0;

   261

}

   262

   263

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

   264

   265

/** Get slave information.

   266

 */

   267

int ec_cdev_ioctl_slave(

   268

        ec_master_t *master, /**< EtherCAT master. */

   269

        unsigned long arg /**< Userspace address to store the results. */

   270

        )

   271

{

   272

    ec_ioctl_slave_t data;

   273

    const ec_slave_t *slave;

   274

    int i;

   275

   276

    if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   277

        return -EFAULT;

   278

    }

   279

   280

    if (ec_mutex_lock_interruptible(&master->master_mutex))

   281

        return -EINTR;

   282

   283

    if (!(slave = ec_master_find_slave_const(

   284

                    master, 0, data.position))) {

   285

        ec_mutex_unlock(&master->master_mutex);

   286

        EC_MASTER_ERR(master, "Slave %u does not exist!\n", data.position);

   287

        return -EINVAL;

   288

    }

   289

   290

    data.vendor_id = slave->sii.vendor_id;

   291

    data.product_code = slave->sii.product_code;

   292

    data.revision_number = slave->sii.revision_number;

   293

    data.serial_number = slave->sii.serial_number;

   294

    data.alias = slave->effective_alias;

   295

    data.boot_rx_mailbox_offset = slave->sii.boot_rx_mailbox_offset;

   296

    data.boot_rx_mailbox_size = slave->sii.boot_rx_mailbox_size;

   297

    data.boot_tx_mailbox_offset = slave->sii.boot_tx_mailbox_offset;

   298

    data.boot_tx_mailbox_size = slave->sii.boot_tx_mailbox_size;

   299

    data.std_rx_mailbox_offset = slave->sii.std_rx_mailbox_offset;

   300

    data.std_rx_mailbox_size = slave->sii.std_rx_mailbox_size;

   301

    data.std_tx_mailbox_offset = slave->sii.std_tx_mailbox_offset;

   302

    data.std_tx_mailbox_size = slave->sii.std_tx_mailbox_size;

   303

    data.mailbox_protocols = slave->sii.mailbox_protocols;

   304

    data.has_general_category = slave->sii.has_general;

   305

    data.coe_details = slave->sii.coe_details;

   306

    data.general_flags = slave->sii.general_flags;

   307

    data.current_on_ebus = slave->sii.current_on_ebus;

   308

    for (i = 0; i < EC_MAX_PORTS; i++) {

   309

        data.ports[i].desc = slave->ports[i].desc;

   310

        data.ports[i].link.link_up = slave->ports[i].link.link_up;

   311

        data.ports[i].link.loop_closed = slave->ports[i].link.loop_closed;

   312

        data.ports[i].link.signal_detected =

   313

            slave->ports[i].link.signal_detected;

   314

        data.ports[i].receive_time = slave->ports[i].receive_time;

   315

        if (slave->ports[i].next_slave) {

   316

            data.ports[i].next_slave =

   317

                slave->ports[i].next_slave->ring_position;

   318

        } else {

   319

            data.ports[i].next_slave = 0xffff;

   320

        }

   321

        data.ports[i].delay_to_next_dc = slave->ports[i].delay_to_next_dc;

   322

    }

   323

    data.fmmu_bit = slave->base_fmmu_bit_operation;

   324

    data.dc_supported = slave->base_dc_supported;

   325

    data.dc_range = slave->base_dc_range;

   326

    data.has_dc_system_time = slave->has_dc_system_time;

   327

    data.transmission_delay = slave->transmission_delay;

   328

    data.al_state = slave->current_state;

   329

    data.error_flag = slave->error_flag;

   330

   331

    data.sync_count = slave->sii.sync_count;

   332

    data.sdo_count = ec_slave_sdo_count(slave);

   333

    data.sii_nwords = slave->sii_nwords;

   334

    ec_cdev_strcpy(data.group, slave->sii.group);

   335

    ec_cdev_strcpy(data.image, slave->sii.image);

   336

    ec_cdev_strcpy(data.order, slave->sii.order);

   337

    ec_cdev_strcpy(data.name, slave->sii.name);

   338

   339

    ec_mutex_unlock(&master->master_mutex);

   340

   341

    if (copy_to_user((void __user *) arg, &data, sizeof(data)))

   342

        return -EFAULT;

   343

   344

    return 0;

   345

}

   346

   347

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

   348

   349

/** Get slave sync manager information.

   350

 */

   351

int ec_cdev_ioctl_slave_sync(

   352

        ec_master_t *master, /**< EtherCAT master. */

   353

        unsigned long arg /**< Userspace address to store the results. */

   354

        )

   355

{

   356

    ec_ioctl_slave_sync_t data;

   357

    const ec_slave_t *slave;

   358

    const ec_sync_t *sync;

   359

   360

    if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   361

        return -EFAULT;

   362

    }

   363

   364

    if (ec_mutex_lock_interruptible(&master->master_mutex))

   365

        return -EINTR;

   366

   367

    if (!(slave = ec_master_find_slave_const(

   368

                    master, 0, data.slave_position))) {

   369

        ec_mutex_unlock(&master->master_mutex);

   370

        EC_MASTER_ERR(master, "Slave %u does not exist!\n",

   371

                data.slave_position);

   372

        return -EINVAL;

   373

    }

   374

   375

    if (data.sync_index >= slave->sii.sync_count) {

   376

        ec_mutex_unlock(&master->master_mutex);

   377

        EC_SLAVE_ERR(slave, "Sync manager %u does not exist!\n",

   378

                data.sync_index);

   379

        return -EINVAL;

   380

    }

   381

   382

    sync = &slave->sii.syncs[data.sync_index];

   383

   384

    data.physical_start_address = sync->physical_start_address;

   385

    data.default_size = sync->default_length;

   386

    data.control_register = sync->control_register;

   387

    data.enable = sync->enable;

   388

    data.pdo_count = ec_pdo_list_count(&sync->pdos);

   389

   390

    ec_mutex_unlock(&master->master_mutex);

   391

   392

    if (copy_to_user((void __user *) arg, &data, sizeof(data)))

   393

        return -EFAULT;

   394

   395

    return 0;

   396

}

   397

   398

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

   399

   400

/** Get slave sync manager PDO information.

   401

 */

   402

int ec_cdev_ioctl_slave_sync_pdo(

   403

        ec_master_t *master, /**< EtherCAT master. */

   404

        unsigned long arg /**< Userspace address to store the results. */

   405

        )

   406

{

   407

    ec_ioctl_slave_sync_pdo_t data;

   408

    const ec_slave_t *slave;

   409

    const ec_sync_t *sync;

   410

    const ec_pdo_t *pdo;

   411

   412

    if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   413

        return -EFAULT;

   414

    }

   415

   416

    if (ec_mutex_lock_interruptible(&master->master_mutex))

   417

        return -EINTR;

   418

   419

    if (!(slave = ec_master_find_slave_const(

   420

                    master, 0, data.slave_position))) {

   421

        ec_mutex_unlock(&master->master_mutex);

   422

        EC_MASTER_ERR(master, "Slave %u does not exist!\n",

   423

                data.slave_position);

   424

        return -EINVAL;

   425

    }

   426

   427

    if (data.sync_index >= slave->sii.sync_count) {

   428

        ec_mutex_unlock(&master->master_mutex);

   429

        EC_SLAVE_ERR(slave, "Sync manager %u does not exist!\n",

   430

                data.sync_index);

   431

        return -EINVAL;

   432

    }

   433

   434

    sync = &slave->sii.syncs[data.sync_index];

   435

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   436

                    &sync->pdos, data.pdo_pos))) {

   437

        ec_mutex_unlock(&master->master_mutex);

   438

        EC_SLAVE_ERR(slave, "Sync manager %u does not contain a PDO with "

   439

                "position %u!\n", data.sync_index, data.pdo_pos);

   440

        return -EINVAL;

   441

    }

   442

   443

    data.index = pdo->index;

   444

    data.entry_count = ec_pdo_entry_count(pdo);

   445

    ec_cdev_strcpy(data.name, pdo->name);

   446

   447

    ec_mutex_unlock(&master->master_mutex);

   448

   449

    if (copy_to_user((void __user *) arg, &data, sizeof(data)))

   450

        return -EFAULT;

   451

   452

    return 0;

   453

}

   454

   455

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

   456

   457

/** Get slave sync manager PDO entry information.

   458

 */

   459

int ec_cdev_ioctl_slave_sync_pdo_entry(

   460

        ec_master_t *master, /**< EtherCAT master. */

   461

        unsigned long arg /**< Userspace address to store the results. */

   462

        )

   463

{

   464

    ec_ioctl_slave_sync_pdo_entry_t data;

   465

    const ec_slave_t *slave;

   466

    const ec_sync_t *sync;

   467

    const ec_pdo_t *pdo;

   468

    const ec_pdo_entry_t *entry;

   469

   470

    if (copy_from_user(&data, (void __user *) arg, sizeof(data))) {

   471

        return -EFAULT;

   472

    }

   473

   474

    if (ec_mutex_lock_interruptible(&master->master_mutex))

   475

        return -EINTR;

   476

   477

    if (!(slave = ec_master_find_slave_const(

   478

                    master, 0, data.slave_position))) {

   479

        ec_mutex_unlock(&master->master_mutex);

   480

        EC_MASTER_ERR(master, "Slave %u does not exist!\n",

   481

                data.slave_position);

   482

        return -EINVAL;

   483

    }

   484

   485

    if (data.sync_index >= slave->sii.sync_count) {

   486

        ec_mutex_unlock(&master->master_mutex);

   487

        EC_SLAVE_ERR(slave, "Sync manager %u does not exist!\n",

   488

                data.sync_index);

   489

        return -EINVAL;

   490

    }