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

/**

    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

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

    53

    54

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

    55

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

    56

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

    57

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

    58

    59

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

    60

 * vm_operations_struct is usable.

    61

 */

    62

#define PAGE_FAULT_VERSION KERNEL_VERSION(2, 6, 23)

    63

    64

#if LINUX_VERSION_CODE >= PAGE_FAULT_VERSION

    65

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

    66

#else

    67

static struct page *eccdev_vma_nopage(

    68

        struct vm_area_struct *, unsigned long, int *);

    69

#endif

    70

    71

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

    72

    73

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

    74

 */

    75

static struct file_operations eccdev_fops = {

    76

    .owner          = THIS_MODULE,

    77

    .open           = eccdev_open,

    78

    .release        = eccdev_release,

    79

    .unlocked_ioctl = eccdev_ioctl,

    80

    .mmap           = eccdev_mmap

    81

};

    82

    83

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

    84

 */

    85

struct vm_operations_struct eccdev_vm_ops = {

    86

#if LINUX_VERSION_CODE >= PAGE_FAULT_VERSION

    87

    .fault = eccdev_vma_fault

    88

#else

    89

    .nopage = eccdev_vma_nopage

    90

#endif

    91

};

    92

    93

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

    94

    95

/** Private data structure for file handles.

    96

 */

    97

typedef struct {

    98

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

    99

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

   100

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

   101

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

   102

} ec_cdev_priv_t;

   103

   104

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

   105

   106

/** Constructor.

   107

 * 

   108

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

   109

 */

   110

int ec_cdev_init(

   111

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

   112

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

   113

        dev_t dev_num /**< Device number. */

   114

        )

   115

{

   116

    int ret;

   117

   118

    cdev->master = master;

   119

   120

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

   121

    cdev->cdev.owner = THIS_MODULE;

   122

   123

    ret = cdev_add(&cdev->cdev,

   124

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

   125

    if (ret) {

   126

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

   127

    }

   128

   129

    return ret;

   130

}

   131

   132

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

   133

   134

/** Destructor.

   135

 */

   136

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

   137

{

   138

    cdev_del(&cdev->cdev);

   139

}

   140

   141

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

   142

   143

/** Copies a string to an ioctl structure.

   144

 */

   145

void ec_cdev_strcpy(

   146

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

   147

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

   148

        )

   149

{

   150

    if (source) {

   151

        strncpy(target, source, EC_IOCTL_STRING_SIZE);

   152

        target[EC_IOCTL_STRING_SIZE - 1] = 0;

   153

    } else {

   154

        target[0] = 0;

   155

    }

   156

}

   157

   158

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

   159

   160

/** Get module information.

   161

 */

   162

int ec_cdev_ioctl_module(

   163

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

   164

        )

   165

{

   166

    ec_ioctl_module_t data;

   167

   168

    data.ioctl_version_magic = EC_IOCTL_VERSION_MAGIC;

   169

    data.master_count = ec_master_count();

   170

   171

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

   172

        return -EFAULT;

   173

   174

    return 0;

   175

}

   176

   177

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

   178

   179

/** Get master information.

   180

 */

   181

int ec_cdev_ioctl_master(

   182

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

   183

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

   184

        )

   185

{

   186

    ec_ioctl_master_t data;

   187

    unsigned int i;

   188

   189

    if (down_interruptible(&master->master_sem))

   190

        return -EINTR;

   191

    data.slave_count = master->slave_count;

   192

    data.config_count = ec_master_config_count(master);

   193

    data.domain_count = ec_master_domain_count(master);

   194

#ifdef EC_EOE

   195

    data.eoe_handler_count = ec_master_eoe_handler_count(master);

   196

#endif

   197

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

   198

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

   199

    data.scan_busy = master->scan_busy;

   200

    up(&master->master_sem);

   201

   202

    if (down_interruptible(&master->device_sem))

   203

        return -EINTR;

   204

   205

    if (master->main_device.dev) {

   206

        memcpy(data.devices[0].address,

   207

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

   208

    } else {

   209

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

   210

    }

   211

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

   212

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

   213

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

   214

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

   215

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

   216

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

   217

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

   218

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

   219

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

   220

            master->main_device.tx_frame_rates[i];

   221

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

   222

            master->main_device.rx_frame_rates[i];

   223

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

   224

            master->main_device.tx_byte_rates[i];

   225

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

   226

            master->main_device.rx_byte_rates[i];

   227

    }

   228

   229

    if (master->backup_device.dev) {

   230

        memcpy(data.devices[1].address,

   231

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

   232

    } else {

   233

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

   234

    }

   235

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

   236

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

   237

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

   238

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

   239

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

   240

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

   241

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

   242

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

   243

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

   244

            master->backup_device.tx_frame_rates[i];

   245

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

   246

            master->backup_device.rx_frame_rates[i];

   247

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

   248

            master->backup_device.tx_byte_rates[i];

   249

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

   250

            master->backup_device.rx_byte_rates[i];

   251

    }

   252

   253

    data.tx_count = master->device_stats.tx_count;

   254

    data.rx_count = master->device_stats.rx_count;

   255

    data.tx_bytes = master->device_stats.tx_bytes;

   256

    data.rx_bytes = master->device_stats.rx_bytes;

   257

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

   258

        data.tx_frame_rates[i] =

   259

            master->device_stats.tx_frame_rates[i];

   260

        data.rx_frame_rates[i] =

   261

            master->device_stats.rx_frame_rates[i];

   262

        data.tx_byte_rates[i] =

   263

            master->device_stats.tx_byte_rates[i];

   264

        data.rx_byte_rates[i] =

   265

            master->device_stats.rx_byte_rates[i];

   266

        data.loss_rates[i] =

   267

            master->device_stats.loss_rates[i];

   268

    }

   269

   270

    up(&master->device_sem);

   271

   272

    data.app_time = master->app_time;

   273

    data.ref_clock =

   274

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

   275

   276

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

   277

        return -EFAULT;

   278

   279

    return 0;

   280

}

   281

   282

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

   283

   284

/** Get slave information.

   285

 */

   286

int ec_cdev_ioctl_slave(

   287

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

   288

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

   289

        )

   290

{

   291

    ec_ioctl_slave_t data;

   292

    const ec_slave_t *slave;

   293

    int i;

   294

   295

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

   296

        return -EFAULT;

   297

    }

   298

   299

    if (down_interruptible(&master->master_sem))

   300

        return -EINTR;

   301

   302

    if (!(slave = ec_master_find_slave_const(

   303

                    master, 0, data.position))) {

   304

        up(&master->master_sem);

   305

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

   306

        return -EINVAL;

   307

    }

   308

   309

    data.vendor_id = slave->sii.vendor_id;

   310

    data.product_code = slave->sii.product_code;

   311

    data.revision_number = slave->sii.revision_number;

   312

    data.serial_number = slave->sii.serial_number;

   313

    data.alias = slave->effective_alias;

   314

    data.boot_rx_mailbox_offset = slave->sii.boot_rx_mailbox_offset;

   315

    data.boot_rx_mailbox_size = slave->sii.boot_rx_mailbox_size;

   316

    data.boot_tx_mailbox_offset = slave->sii.boot_tx_mailbox_offset;

   317

    data.boot_tx_mailbox_size = slave->sii.boot_tx_mailbox_size;

   318

    data.std_rx_mailbox_offset = slave->sii.std_rx_mailbox_offset;

   319

    data.std_rx_mailbox_size = slave->sii.std_rx_mailbox_size;

   320

    data.std_tx_mailbox_offset = slave->sii.std_tx_mailbox_offset;

   321

    data.std_tx_mailbox_size = slave->sii.std_tx_mailbox_size;

   322

    data.mailbox_protocols = slave->sii.mailbox_protocols;

   323

    data.has_general_category = slave->sii.has_general;

   324

    data.coe_details = slave->sii.coe_details;

   325

    data.general_flags = slave->sii.general_flags;

   326

    data.current_on_ebus = slave->sii.current_on_ebus;

   327

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

   328

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

   329

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

   330

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

   331

        data.ports[i].link.signal_detected =

   332

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

   333

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

   334

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

   335

            data.ports[i].next_slave =

   336

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

   337

        } else {

   338

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

   339

        }

   340

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

   341

    }

   342

    data.fmmu_bit = slave->base_fmmu_bit_operation;

   343

    data.dc_supported = slave->base_dc_supported;

   344

    data.dc_range = slave->base_dc_range;

   345

    data.has_dc_system_time = slave->has_dc_system_time;

   346

    data.transmission_delay = slave->transmission_delay;

   347

    data.al_state = slave->current_state;

   348

    data.error_flag = slave->error_flag;

   349

   350

    data.sync_count = slave->sii.sync_count;

   351

    data.sdo_count = ec_slave_sdo_count(slave);

   352

    data.sii_nwords = slave->sii_nwords;

   353

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

   354

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

   355

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

   356

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

   357

   358

    up(&master->master_sem);

   359

   360

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

   361

        return -EFAULT;

   362

   363

    return 0;

   364

}

   365

   366

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

   367

   368

/** Get slave sync manager information.

   369

 */

   370

int ec_cdev_ioctl_slave_sync(

   371

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

   372

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

   373

        )

   374

{

   375

    ec_ioctl_slave_sync_t data;

   376

    const ec_slave_t *slave;

   377

    const ec_sync_t *sync;

   378

   379

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

   380

        return -EFAULT;

   381

    }

   382

   383

    if (down_interruptible(&master->master_sem))

   384

        return -EINTR;

   385

   386

    if (!(slave = ec_master_find_slave_const(

   387

                    master, 0, data.slave_position))) {

   388

        up(&master->master_sem);

   389

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

   390

                data.slave_position);

   391

        return -EINVAL;

   392

    }

   393

   394

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

   395

        up(&master->master_sem);

   396

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

   397

                data.sync_index);

   398

        return -EINVAL;

   399

    }

   400

   401

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

   402

   403

    data.physical_start_address = sync->physical_start_address;

   404

    data.default_size = sync->default_length;

   405

    data.control_register = sync->control_register;

   406

    data.enable = sync->enable;

   407

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

   408

   409

    up(&master->master_sem);

   410

   411

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

   412

        return -EFAULT;

   413

   414

    return 0;

   415

}

   416

   417

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

   418

   419

/** Get slave sync manager PDO information.

   420

 */

   421

int ec_cdev_ioctl_slave_sync_pdo(

   422

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

   423

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

   424

        )

   425

{

   426

    ec_ioctl_slave_sync_pdo_t data;

   427

    const ec_slave_t *slave;

   428

    const ec_sync_t *sync;

   429

    const ec_pdo_t *pdo;

   430

   431

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

   432

        return -EFAULT;

   433

    }

   434

   435

    if (down_interruptible(&master->master_sem))

   436

        return -EINTR;

   437

   438

    if (!(slave = ec_master_find_slave_const(

   439

                    master, 0, data.slave_position))) {

   440

        up(&master->master_sem);

   441

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

   442

                data.slave_position);

   443

        return -EINVAL;

   444

    }

   445

   446

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

   447

        up(&master->master_sem);

   448

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

   449

                data.sync_index);

   450

        return -EINVAL;

   451

    }

   452

   453

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

   454

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   455

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

   456

        up(&master->master_sem);

   457

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

   458

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

   459

        return -EINVAL;

   460

    }

   461

   462

    data.index = pdo->index;

   463

    data.entry_count = ec_pdo_entry_count(pdo);

   464

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

   465

   466

    up(&master->master_sem);

   467

   468

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

   469

        return -EFAULT;

   470

   471

    return 0;

   472

}

   473

   474

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

   475

   476

/** Get slave sync manager PDO entry information.

   477

 */

   478

int ec_cdev_ioctl_slave_sync_pdo_entry(

   479

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

   480

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

   481

        )

   482

{

   483

    ec_ioctl_slave_sync_pdo_entry_t data;

   484

    const ec_slave_t *slave;

   485

    const ec_sync_t *sync;

   486

    const ec_pdo_t *pdo;

   487

    const ec_pdo_entry_t *entry;

   488

   489

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

   490

        return -EFAULT;

   491

    }