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

    71

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

    72

    73

/** Copies a string to an ioctl structure.

    74

 */

    75

static void ec_ioctl_strcpy(

    76

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

    77

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

    78

        )

    79

{

    80

    if (source) {

    81

        strncpy(target, source, EC_IOCTL_STRING_SIZE);

    82

        target[EC_IOCTL_STRING_SIZE - 1] = 0;

    83

    } else {

    84

        target[0] = 0;

    85

    }

    86

}

    87

    88

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

    89

    90

/** Get module information.

    91

 *

    92

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

    93

 */

    94

static ATTRIBUTES int ec_ioctl_module(

    95

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

    96

        )

    97

{

    98

    ec_ioctl_module_t data;

    99

   100

    data.ioctl_version_magic = EC_IOCTL_VERSION_MAGIC;

   101

    data.master_count = ec_master_count();

   102

   104

        return -EFAULT;

   105

   106

    return 0;

   107

}

   108

   109

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

   110

   111

/** Get master information.

   112

 *

   113

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

   114

 */

   115

static ATTRIBUTES int ec_ioctl_master(

   116

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

   117

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

   118

        )

   119

{

   120

    ec_ioctl_master_t io;

   121

    unsigned int dev_idx, j;

   122

   123

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

   124

        return -EINTR;

   125

    }

   126

   127

    io.slave_count = master->slave_count;

   128

    io.config_count = ec_master_config_count(master);

   129

    io.domain_count = ec_master_domain_count(master);

   130

#ifdef EC_EOE

   131

    io.eoe_handler_count = ec_master_eoe_handler_count(master);

   132

#endif

   133

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

   134

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

   135

    io.scan_busy = master->scan_busy;

   136

   137

    up(&master->master_sem);

   138

   139

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

   140

        return -EINTR;

   141

    }

   142

   143

    for (dev_idx = EC_DEVICE_MAIN;

   144

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

   145

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

   146

   147

        if (device->dev) {

   148

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

   149

                    ETH_ALEN);

   150

        } else {

   151

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

   152

                    ETH_ALEN);

   153

        }

   154

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

   155

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

   156

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

   157

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

   158

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

   159

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

   160

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

   161

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

   162

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

   163

                device->tx_frame_rates[j];

   164

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

   165

                device->rx_frame_rates[j];

   166

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

   167

                device->tx_byte_rates[j];

   168

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

   169

                device->rx_byte_rates[j];

   170

        }

   171

    }

   172

    io.num_devices = ec_master_num_devices(master);

   173

   174

    io.tx_count = master->device_stats.tx_count;

   175

    io.rx_count = master->device_stats.rx_count;

   176

    io.tx_bytes = master->device_stats.tx_bytes;

   177

    io.rx_bytes = master->device_stats.rx_bytes;

   178

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

   179

        io.tx_frame_rates[j] =

   180

            master->device_stats.tx_frame_rates[j];

   181

        io.rx_frame_rates[j] =

   182

            master->device_stats.rx_frame_rates[j];

   183

        io.tx_byte_rates[j] =

   184

            master->device_stats.tx_byte_rates[j];

   185

        io.rx_byte_rates[j] =

   186

            master->device_stats.rx_byte_rates[j];

   187

        io.loss_rates[j] =

   188

            master->device_stats.loss_rates[j];

   189

    }

   190

   191

    up(&master->device_sem);

   192

   193

    io.app_time = master->app_time;

   194

    io.ref_clock =

   195

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

   196

   198

        return -EFAULT;

   199

    }

   200

   201

    return 0;

   202

}

   203

   204

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

   205

   206

/** Get slave information.

   207

 *

   208

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

   209

 */

   210

static ATTRIBUTES int ec_ioctl_slave(

   211

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

   212

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

   213

        )

   214

{

   215

    ec_ioctl_slave_t data;

   216

    const ec_slave_t *slave;

   217

    int i;

   218

   220

        return -EFAULT;

   221

    }

   222

   223

    if (down_interruptible(&master->master_sem))

   224

        return -EINTR;

   225

   226

    if (!(slave = ec_master_find_slave_const(

   227

                    master, 0, data.position))) {

   228

        up(&master->master_sem);

   229

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

   230

        return -EINVAL;

   231

    }

   232

   233

    data.device_index = slave->device_index;

   234

    data.vendor_id = slave->sii.vendor_id;

   235

    data.product_code = slave->sii.product_code;

   236

    data.revision_number = slave->sii.revision_number;

   237

    data.serial_number = slave->sii.serial_number;

   238

    data.alias = slave->effective_alias;

   239

    data.boot_rx_mailbox_offset = slave->sii.boot_rx_mailbox_offset;

   240

    data.boot_rx_mailbox_size = slave->sii.boot_rx_mailbox_size;

   241

    data.boot_tx_mailbox_offset = slave->sii.boot_tx_mailbox_offset;

   242

    data.boot_tx_mailbox_size = slave->sii.boot_tx_mailbox_size;

   243

    data.std_rx_mailbox_offset = slave->sii.std_rx_mailbox_offset;

   244

    data.std_rx_mailbox_size = slave->sii.std_rx_mailbox_size;

   245

    data.std_tx_mailbox_offset = slave->sii.std_tx_mailbox_offset;

   246

    data.std_tx_mailbox_size = slave->sii.std_tx_mailbox_size;

   247

    data.mailbox_protocols = slave->sii.mailbox_protocols;

   248

    data.has_general_category = slave->sii.has_general;

   249

    data.coe_details = slave->sii.coe_details;

   250

    data.general_flags = slave->sii.general_flags;

   251

    data.current_on_ebus = slave->sii.current_on_ebus;

   252

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

   253

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

   254

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

   255

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

   256

        data.ports[i].link.signal_detected =

   257

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

   258

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

   259

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

   260

            data.ports[i].next_slave =

   261

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

   262

        } else {

   263

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

   264

        }

   265

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

   266

    }

   267

    data.fmmu_bit = slave->base_fmmu_bit_operation;

   268

    data.dc_supported = slave->base_dc_supported;

   269

    data.dc_range = slave->base_dc_range;

   270

    data.has_dc_system_time = slave->has_dc_system_time;

   271

    data.transmission_delay = slave->transmission_delay;

   272

    data.al_state = slave->current_state;

   273

    data.error_flag = slave->error_flag;

   274

   275

    data.sync_count = slave->sii.sync_count;

   276

    data.sdo_count = ec_slave_sdo_count(slave);

   277

    data.sii_nwords = slave->sii_nwords;

   278

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

   279

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

   280

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

   281

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

   282

   283

    up(&master->master_sem);

   284

   286

        return -EFAULT;

   287

   288

    return 0;

   289

}

   290

   291

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

   292

   293

/** Get slave sync manager information.

   294

 *

   295

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

   296

 */

   297

static ATTRIBUTES int ec_ioctl_slave_sync(

   298

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

   299

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

   300

        )

   301

{

   302

    ec_ioctl_slave_sync_t data;

   303

    const ec_slave_t *slave;

   304

    const ec_sync_t *sync;

   305

   307

        return -EFAULT;

   308

    }

   309

   310

    if (down_interruptible(&master->master_sem))

   311

        return -EINTR;

   312

   313

    if (!(slave = ec_master_find_slave_const(

   314

                    master, 0, data.slave_position))) {

   315

        up(&master->master_sem);

   316

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

   317

                data.slave_position);

   318

        return -EINVAL;

   319

    }

   320

   321

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

   322

        up(&master->master_sem);

   323

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

   324

                data.sync_index);

   325

        return -EINVAL;

   326

    }

   327

   328

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

   329

   330

    data.physical_start_address = sync->physical_start_address;

   331

    data.default_size = sync->default_length;

   332

    data.control_register = sync->control_register;

   333

    data.enable = sync->enable;

   334

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

   335

   336

    up(&master->master_sem);

   337

   339

        return -EFAULT;

   340

   341

    return 0;

   342

}

   343

   344

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

   345

   346

/** Get slave sync manager PDO information.

   347

 *

   348

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

   349

 */

   350

static ATTRIBUTES int ec_ioctl_slave_sync_pdo(

   351

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

   352

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

   353

        )

   354

{

   355

    ec_ioctl_slave_sync_pdo_t data;

   356

    const ec_slave_t *slave;

   357

    const ec_sync_t *sync;

   358

    const ec_pdo_t *pdo;

   359

   361

        return -EFAULT;

   362

    }

   363

   364

    if (down_interruptible(&master->master_sem))

   365

        return -EINTR;

   366

   367

    if (!(slave = ec_master_find_slave_const(

   368

                    master, 0, data.slave_position))) {

   369

        up(&master->master_sem);

   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

        up(&master->master_sem);

   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

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   384

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

   385

        up(&master->master_sem);

   386

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

   387

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

   388

        return -EINVAL;

   389

    }

   390

   391

    data.index = pdo->index;

   392

    data.entry_count = ec_pdo_entry_count(pdo);

   393

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

   394

   395

    up(&master->master_sem);

   396

   398

        return -EFAULT;

   399

   400

    return 0;

   401

}

   402

   403

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

   404

   405

/** Get slave sync manager PDO entry information.

   406

 *

   407

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

   408

 */

   409

static ATTRIBUTES int ec_ioctl_slave_sync_pdo_entry(

   410

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

   411

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

   412

        )

   413

{

   414

    ec_ioctl_slave_sync_pdo_entry_t data;

   415

    const ec_slave_t *slave;

   416

    const ec_sync_t *sync;

   417

    const ec_pdo_t *pdo;

   418

    const ec_pdo_entry_t *entry;

   419

   421

        return -EFAULT;

   422

    }

   423

   424

    if (down_interruptible(&master->master_sem))

   425

        return -EINTR;

   426

   427

    if (!(slave = ec_master_find_slave_const(

   428

                    master, 0, data.slave_position))) {

   429

        up(&master->master_sem);

   430

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

   431

                data.slave_position);

   432

        return -EINVAL;

   433

    }

   434

   435

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

   436

        up(&master->master_sem);

   437

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

   438

                data.sync_index);

   439

        return -EINVAL;

   440

    }

   441

   442

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

   443

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   444

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

   445

        up(&master->master_sem);

   446

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

   447

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

   448

        return -EINVAL;

   449

    }

   450

   451

    if (!(entry = ec_pdo_find_entry_by_pos_const(

   452

                    pdo, data.entry_pos))) {

   453

        up(&master->master_sem);

   454

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

   455

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

   456

        return -EINVAL;

   457

    }

   458

   459

    data.index = entry->index;

   460

    data.subindex = entry->subindex;

   461

    data.bit_length = entry->bit_length;

   462

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

   463

   464

    up(&master->master_sem);

   465

   467

        return -EFAULT;

   468

   469

    return 0;

   470

}

   471

   472

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

   473

   474

/** Get domain information.

   475

 *

   476

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

   477

 */

   478

static ATTRIBUTES int ec_ioctl_domain(

   479

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

   480

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

   481

        )

   482

{

   483

    ec_ioctl_domain_t data;

   484

    const ec_domain_t *domain;

   485

    unsigned int dev_idx;

   486

   488

        return -EFAULT;

   489

    }

   490

   491

    if (down_interruptible(&master->master_sem))

   492

        return -EINTR;

   493

   494

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

   495

        up(&master->master_sem);

   496

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

   497

        return -EINVAL;

   498

    }

   499

   500

    data.data_size = domain->data_size;

   501

    data.logical_base_address = domain->logical_base_address;

   502

    for (dev_idx = EC_DEVICE_MAIN;

   503

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

   504

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

   505

    }

   506

    data.expected_working_counter = domain->expected_working_counter;

   507

    data.fmmu_count = ec_domain_fmmu_count(domain);

   508

   509

    up(&master->master_sem);

   510

   512

        return -EFAULT;

   513

   514

    return 0;

   515

}

   516