1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006-2012  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

    40

#include "master.h"

    41

#include "slave_config.h"

    42

#include "voe_handler.h"

    43

#include "ethernet.h"

    44

#include "ioctl.h"

    45

    46

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

    47

 *

    48

 * Requires CPU timestamp counter!

    49

 */

    50

#define DEBUG_LATENCY 0

    51

    52

/** Optional compiler attributes fo ioctl() functions.

    53

 */

    54

#if 0

    55

#define ATTRIBUTES __attribute__ ((__noinline__))

    56

#else

    57

#define ATTRIBUTES

    58

#endif

    59

    60

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

    61

    62

/** Copies a string to an ioctl structure.

    63

 */

    64

static void ec_ioctl_strcpy(

    65

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

    66

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

    67

        )

    68

{

    69

    if (source) {

    70

        strncpy(target, source, EC_IOCTL_STRING_SIZE);

    71

        target[EC_IOCTL_STRING_SIZE - 1] = 0;

    72

    } else {

    73

        target[0] = 0;

    74

    }

    75

}

    76

    77

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

    78

    79

/** Get module information.

    80

 *

    81

 * \return Zero on success, otherwise a negative error code.

    82

 */

    83

static ATTRIBUTES int ec_ioctl_module(

    84

        void *arg /**< Userspace address to store the results. */

    85

        )

    86

{

    87

    ec_ioctl_module_t data;

    88

    89

    data.ioctl_version_magic = EC_IOCTL_VERSION_MAGIC;

    90

    data.master_count = ec_master_count();

    91

    92

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

    93

        return -EFAULT;

    94

    95

    return 0;

    96

}

    97

    98

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

    99

   100

/** Get master information.

   101

 *

   102

 * \return Zero on success, otherwise a negative error code.

   103

 */

   104

static ATTRIBUTES int ec_ioctl_master(

   105

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

   106

        void *arg /**< Userspace address to store the results. */

   107

        )

   108

{

   109

    ec_ioctl_master_t io;

   110

    unsigned int dev_idx, j;

   111

   112

    if (down_interruptible(&master->master_sem)) {

   113

        return -EINTR;

   114

    }

   115

   116

    io.slave_count = master->slave_count;

   117

    io.config_count = ec_master_config_count(master);

   118

    io.domain_count = ec_master_domain_count(master);

   119

#ifdef EC_EOE

   120

    io.eoe_handler_count = ec_master_eoe_handler_count(master);

   121

#endif

   122

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

   123

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

   124

    io.scan_busy = master->scan_busy;

   125

   126

    up(&master->master_sem);

   127

   128

    if (down_interruptible(&master->device_sem)) {

   129

        return -EINTR;

   130

    }

   131

   132

    for (dev_idx = EC_DEVICE_MAIN;

   133

            dev_idx < ec_master_num_devices(master); dev_idx++) {

   134

        ec_device_t *device = &master->devices[dev_idx];

   135

   136

        if (device->dev) {

   137

            memcpy(io.devices[dev_idx].address, device->dev->dev_addr,

   138

                    ETH_ALEN);

   139

        } else {

   140

            memcpy(io.devices[dev_idx].address, master->macs[dev_idx],

   141

                    ETH_ALEN);

   142

        }

   143

        io.devices[dev_idx].attached = device->dev ? 1 : 0;

   144

        io.devices[dev_idx].link_state = device->link_state ? 1 : 0;

   145

        io.devices[dev_idx].tx_count = device->tx_count;

   146

        io.devices[dev_idx].rx_count = device->rx_count;

   147

        io.devices[dev_idx].tx_bytes = device->tx_bytes;

   148

        io.devices[dev_idx].rx_bytes = device->rx_bytes;

   149

        io.devices[dev_idx].tx_errors = device->tx_errors;

   150

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

   151

            io.devices[dev_idx].tx_frame_rates[j] =

   152

                device->tx_frame_rates[j];

   153

            io.devices[dev_idx].rx_frame_rates[j] =

   154

                device->rx_frame_rates[j];

   155

            io.devices[dev_idx].tx_byte_rates[j] =

   156

                device->tx_byte_rates[j];

   157

            io.devices[dev_idx].rx_byte_rates[j] =

   158

                device->rx_byte_rates[j];

   159

        }

   160

    }

   161

    io.num_devices = ec_master_num_devices(master);

   162

   163

    io.tx_count = master->device_stats.tx_count;

   164

    io.rx_count = master->device_stats.rx_count;

   165

    io.tx_bytes = master->device_stats.tx_bytes;

   166

    io.rx_bytes = master->device_stats.rx_bytes;

   167

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

   168

        io.tx_frame_rates[j] =

   169

            master->device_stats.tx_frame_rates[j];

   170

        io.rx_frame_rates[j] =

   171

            master->device_stats.rx_frame_rates[j];

   172

        io.tx_byte_rates[j] =

   173

            master->device_stats.tx_byte_rates[j];

   174

        io.rx_byte_rates[j] =

   175

            master->device_stats.rx_byte_rates[j];

   176

        io.loss_rates[j] =

   177

            master->device_stats.loss_rates[j];

   178

    }

   179

   180

    up(&master->device_sem);

   181

   182

    io.app_time = master->app_time;

   183

    io.ref_clock =

   184

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

   185

   186

    if (copy_to_user((void __user *) arg, &io, sizeof(io))) {

   187

        return -EFAULT;

   188

    }

   189

   190

    return 0;

   191

}

   192

   193

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

   194

   195

/** Get slave information.

   196

 *

   197

 * \return Zero on success, otherwise a negative error code.

   198

 */

   199

static ATTRIBUTES int ec_ioctl_slave(

   200

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

   201

        void *arg /**< Userspace address to store the results. */

   202

        )

   203

{

   204

    ec_ioctl_slave_t data;

   205

    const ec_slave_t *slave;

   206

    int i;

   207

   208

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

   209

        return -EFAULT;

   210

    }

   211

   212

    if (down_interruptible(&master->master_sem))

   213

        return -EINTR;

   214

   215

    if (!(slave = ec_master_find_slave_const(

   216

                    master, 0, data.position))) {

   217

        up(&master->master_sem);

   218

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

   219

        return -EINVAL;

   220

    }

   221

   222

    data.device_index = slave->device_index;

   223

    data.vendor_id = slave->sii.vendor_id;

   224

    data.product_code = slave->sii.product_code;

   225

    data.revision_number = slave->sii.revision_number;

   226

    data.serial_number = slave->sii.serial_number;

   227

    data.alias = slave->effective_alias;

   228

    data.boot_rx_mailbox_offset = slave->sii.boot_rx_mailbox_offset;

   229

    data.boot_rx_mailbox_size = slave->sii.boot_rx_mailbox_size;

   230

    data.boot_tx_mailbox_offset = slave->sii.boot_tx_mailbox_offset;

   231

    data.boot_tx_mailbox_size = slave->sii.boot_tx_mailbox_size;

   232

    data.std_rx_mailbox_offset = slave->sii.std_rx_mailbox_offset;

   233

    data.std_rx_mailbox_size = slave->sii.std_rx_mailbox_size;

   234

    data.std_tx_mailbox_offset = slave->sii.std_tx_mailbox_offset;

   235

    data.std_tx_mailbox_size = slave->sii.std_tx_mailbox_size;

   236

    data.mailbox_protocols = slave->sii.mailbox_protocols;

   237

    data.has_general_category = slave->sii.has_general;

   238

    data.coe_details = slave->sii.coe_details;

   239

    data.general_flags = slave->sii.general_flags;

   240

    data.current_on_ebus = slave->sii.current_on_ebus;

   241

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

   242

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

   243

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

   244

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

   245

        data.ports[i].link.signal_detected =

   246

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

   247

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

   248

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

   249

            data.ports[i].next_slave =

   250

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

   251

        } else {

   252

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

   253

        }

   254

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

   255

    }

   256

    data.fmmu_bit = slave->base_fmmu_bit_operation;

   257

    data.dc_supported = slave->base_dc_supported;

   258

    data.dc_range = slave->base_dc_range;

   259

    data.has_dc_system_time = slave->has_dc_system_time;

   260

    data.transmission_delay = slave->transmission_delay;

   261

    data.al_state = slave->current_state;

   262

    data.error_flag = slave->error_flag;

   263

   264

    data.sync_count = slave->sii.sync_count;

   265

    data.sdo_count = ec_slave_sdo_count(slave);

   266

    data.sii_nwords = slave->sii_nwords;

   267

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

   268

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

   269

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

   270

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

   271

   272

    up(&master->master_sem);

   273

   274

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

   275

        return -EFAULT;

   276

   277

    return 0;

   278

}

   279

   280

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

   281

   282

/** Get slave sync manager information.

   283

 *

   284

 * \return Zero on success, otherwise a negative error code.

   285

 */

   286

static ATTRIBUTES int ec_ioctl_slave_sync(

   287

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

   288

        void *arg /**< Userspace address to store the results. */

   289

        )

   290

{

   291

    ec_ioctl_slave_sync_t data;

   292

    const ec_slave_t *slave;

   293

    const ec_sync_t *sync;

   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.slave_position))) {

   304

        up(&master->master_sem);

   305

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

   306

                data.slave_position);

   307

        return -EINVAL;

   308

    }

   309

   310

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

   311

        up(&master->master_sem);

   312

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

   313

                data.sync_index);

   314

        return -EINVAL;

   315

    }

   316

   317

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

   318

   319

    data.physical_start_address = sync->physical_start_address;

   320

    data.default_size = sync->default_length;

   321

    data.control_register = sync->control_register;

   322

    data.enable = sync->enable;

   323

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

   324

   325

    up(&master->master_sem);

   326

   327

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

   328

        return -EFAULT;

   329

   330

    return 0;

   331

}

   332

   333

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

   334

   335

/** Get slave sync manager PDO information.

   336

 *

   337

 * \return Zero on success, otherwise a negative error code.

   338

 */

   339

static ATTRIBUTES int ec_ioctl_slave_sync_pdo(

   340

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

   341

        void *arg /**< Userspace address to store the results. */

   342

        )

   343

{

   344

    ec_ioctl_slave_sync_pdo_t data;

   345

    const ec_slave_t *slave;

   346

    const ec_sync_t *sync;

   347

    const ec_pdo_t *pdo;

   348

   349

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

   350

        return -EFAULT;

   351

    }

   352

   353

    if (down_interruptible(&master->master_sem))

   354

        return -EINTR;

   355

   356

    if (!(slave = ec_master_find_slave_const(

   357

                    master, 0, data.slave_position))) {

   358

        up(&master->master_sem);

   359

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

   360

                data.slave_position);

   361

        return -EINVAL;

   362

    }

   363

   364

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

   365

        up(&master->master_sem);

   366

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

   367

                data.sync_index);

   368

        return -EINVAL;

   369

    }

   370

   371

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

   372

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   373

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

   374

        up(&master->master_sem);

   375

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

   376

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

   377

        return -EINVAL;

   378

    }

   379

   380

    data.index = pdo->index;

   381

    data.entry_count = ec_pdo_entry_count(pdo);

   382

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

   383

   384

    up(&master->master_sem);

   385

   386

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

   387

        return -EFAULT;

   388

   389

    return 0;

   390

}

   391

   392

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

   393

   394

/** Get slave sync manager PDO entry information.

   395

 *

   396

 * \return Zero on success, otherwise a negative error code.

   397

 */

   398

static ATTRIBUTES int ec_ioctl_slave_sync_pdo_entry(

   399

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

   400

        void *arg /**< Userspace address to store the results. */

   401

        )

   402

{

   403

    ec_ioctl_slave_sync_pdo_entry_t data;

   404

    const ec_slave_t *slave;

   405

    const ec_sync_t *sync;

   406

    const ec_pdo_t *pdo;

   407

    const ec_pdo_entry_t *entry;

   408

   409

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

   410

        return -EFAULT;

   411

    }

   412

   413

    if (down_interruptible(&master->master_sem))

   414

        return -EINTR;

   415

   416

    if (!(slave = ec_master_find_slave_const(

   417

                    master, 0, data.slave_position))) {

   418

        up(&master->master_sem);

   419

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

   420

                data.slave_position);

   421

        return -EINVAL;

   422

    }

   423

   424

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

   425

        up(&master->master_sem);

   426

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

   427

                data.sync_index);

   428

        return -EINVAL;

   429

    }

   430

   431

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

   432

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   433

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

   434

        up(&master->master_sem);

   435

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

   436

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

   437

        return -EINVAL;

   438

    }

   439

   440

    if (!(entry = ec_pdo_find_entry_by_pos_const(

   441

                    pdo, data.entry_pos))) {

   442

        up(&master->master_sem);

   443

        EC_SLAVE_ERR(slave, "PDO 0x%04X does not contain an entry with "

   444

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

   445

        return -EINVAL;

   446

    }

   447

   448

    data.index = entry->index;

   449

    data.subindex = entry->subindex;

   450

    data.bit_length = entry->bit_length;

   451

    ec_ioctl_strcpy(data.name, entry->name);

   452

   453

    up(&master->master_sem);

   454

   455

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

   456

        return -EFAULT;

   457

   458

    return 0;

   459

}

   460

   461

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

   462

   463

/** Get domain information.

   464

 *

   465

 * \return Zero on success, otherwise a negative error code.

   466

 */

   467

static ATTRIBUTES int ec_ioctl_domain(

   468

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

   469

        void *arg /**< Userspace address to store the results. */

   470

        )

   471

{

   472

    ec_ioctl_domain_t data;

   473

    const ec_domain_t *domain;

   474

    unsigned int dev_idx;

   475

   476

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

   477

        return -EFAULT;

   478

    }

   479

   480

    if (down_interruptible(&master->master_sem))

   481

        return -EINTR;

   482

   483

    if (!(domain = ec_master_find_domain_const(master, data.index))) {

   484

        up(&master->master_sem);

   485

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

   486

        return -EINVAL;

   487

    }

   488

   489

    data.data_size = domain->data_size;

   490

    data.logical_base_address = domain->logical_base_address;

   491

    for (dev_idx = EC_DEVICE_MAIN;

   492

            dev_idx < ec_master_num_devices(domain->master); dev_idx++) {

   493

        data.working_counter[dev_idx] = domain->working_counter[dev_idx];

   494

    }

   495

    data.expected_working_counter = domain->expected_working_counter;

   496

    data.fmmu_count = ec_domain_fmmu_count(domain);

   497

   498

    up(&master->master_sem);

   499

   500

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

   501

        return -EFAULT;

   502

   503

    return 0;

   504

}

   505

   506

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

   507

   508

/** Get domain FMMU information.

   509

 *

   510

 * \return Zero on success, otherwise a negative error code.

   511

 */

   512

static ATTRIBUTES int ec_ioctl_domain_fmmu(

   513

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

   514

        void *arg /**< Userspace address to store the results. */

   515

        )

   516

{

   517

    ec_ioctl_domain_fmmu_t data;

   518

    const ec_domain_t *domain;

   519

    const ec_fmmu_config_t *fmmu;

   520

   521

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

   522

        return -EFAULT;

   523

    }

   524

   525

    if (down_interruptible(&master->master_sem))

   526

        return -EINTR;

   527

   528

    if (!(domain = ec_master_find_domain_const(master, data.domain_index))) {

   529

        up(&master->master_sem);

   530

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