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

    39

#include "master.h"

    40

#include "slave_config.h"

    41

#include "voe_handler.h"

    42

#include "ethernet.h"

    43

#include "ioctl.h"

    44

    45

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

    46

 *

    47

 * Requires CPU timestamp counter!

    48

 */

    49

#define DEBUG_LATENCY 0

    50

    51

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

    52

    53

/** Copies a string to an ioctl structure.

    54

 */

    55

static void ec_ioctl_strcpy(

    56

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

    57

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

    58

        )

    59

{

    60

    if (source) {

    61

        strncpy(target, source, EC_IOCTL_STRING_SIZE);

    62

        target[EC_IOCTL_STRING_SIZE - 1] = 0;

    63

    } else {

    64

        target[0] = 0;

    65

    }

    66

}

    67

    68

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

    69

    70

/** Get module information.

    71

 */

    72

static int ec_ioctl_module(

    73

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

    74

        )

    75

{

    76

    ec_ioctl_module_t data;

    77

    78

    data.ioctl_version_magic = EC_IOCTL_VERSION_MAGIC;

    79

    data.master_count = ec_master_count();

    80

    81

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

    82

        return -EFAULT;

    83

    84

    return 0;

    85

}

    86

    87

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

    88

    89

/** Get master information.

    90

 */

    91

static int ec_ioctl_master(

    92

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

    93

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

    94

        )

    95

{

    96

    ec_ioctl_master_t data;

    97

    unsigned int i, j;

    98

    99

    if (down_interruptible(&master->master_sem))

   100

        return -EINTR;

   101

   102

    data.slave_count = master->slave_count;

   103

    data.config_count = ec_master_config_count(master);

   104

    data.domain_count = ec_master_domain_count(master);

   105

#ifdef EC_EOE

   106

    data.eoe_handler_count = ec_master_eoe_handler_count(master);

   107

#endif

   108

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

   109

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

   110

    data.scan_busy = master->scan_busy;

   111

   112

    up(&master->master_sem);

   113

   114

    if (down_interruptible(&master->device_sem))

   115

        return -EINTR;

   116

   117

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

   118

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

   119

   120

        if (device->dev) {

   121

            memcpy(data.devices[i].address,

   122

                    device->dev->dev_addr, ETH_ALEN);

   123

        } else {

   124

            memcpy(data.devices[i].address, master->macs[i], ETH_ALEN);

   125

        }

   126

        data.devices[i].attached = device->dev ? 1 : 0;

   127

        data.devices[i].link_state = device->link_state ? 1 : 0;

   128

        data.devices[i].tx_count = device->tx_count;

   129

        data.devices[i].rx_count = device->rx_count;

   130

        data.devices[i].tx_bytes = device->tx_bytes;

   131

        data.devices[i].rx_bytes = device->rx_bytes;

   132

        data.devices[i].tx_errors = device->tx_errors;

   133

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

   134

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

   135

                device->tx_frame_rates[j];

   136

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

   137

                device->rx_frame_rates[j];

   138

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

   139

                device->tx_byte_rates[j];

   140

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

   141

                device->rx_byte_rates[j];

   142

        }

   143

    }

   144

   145

    data.tx_count = master->device_stats.tx_count;

   146

    data.rx_count = master->device_stats.rx_count;

   147

    data.tx_bytes = master->device_stats.tx_bytes;

   148

    data.rx_bytes = master->device_stats.rx_bytes;

   149

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

   150

        data.tx_frame_rates[i] =

   151

            master->device_stats.tx_frame_rates[i];

   152

        data.rx_frame_rates[i] =

   153

            master->device_stats.rx_frame_rates[i];

   154

        data.tx_byte_rates[i] =

   155

            master->device_stats.tx_byte_rates[i];

   156

        data.rx_byte_rates[i] =

   157

            master->device_stats.rx_byte_rates[i];

   158

        data.loss_rates[i] =

   159

            master->device_stats.loss_rates[i];

   160

    }

   161

   162

    up(&master->device_sem);

   163

   164

    data.app_time = master->app_time;

   165

    data.ref_clock =

   166

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

   167

   168

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

   169

        return -EFAULT;

   170

   171

    return 0;

   172

}

   173

   174

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

   175

   176

/** Get slave information.

   177

 */

   178

static int ec_ioctl_slave(

   179

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

   180

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

   181

        )

   182

{

   183

    ec_ioctl_slave_t data;

   184

    const ec_slave_t *slave;

   185

    int i;

   186

   187

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

   188

        return -EFAULT;

   189

    }

   190

   191

    if (down_interruptible(&master->master_sem))

   192

        return -EINTR;

   193

   194

    if (!(slave = ec_master_find_slave_const(

   195

                    master, 0, data.position))) {

   196

        up(&master->master_sem);

   197

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

   198

        return -EINVAL;

   199

    }

   200

   201

    data.device_index = slave->device_index;

   202

    data.vendor_id = slave->sii.vendor_id;

   203

    data.product_code = slave->sii.product_code;

   204

    data.revision_number = slave->sii.revision_number;

   205

    data.serial_number = slave->sii.serial_number;

   206

    data.alias = slave->effective_alias;

   207

    data.boot_rx_mailbox_offset = slave->sii.boot_rx_mailbox_offset;

   208

    data.boot_rx_mailbox_size = slave->sii.boot_rx_mailbox_size;

   209

    data.boot_tx_mailbox_offset = slave->sii.boot_tx_mailbox_offset;

   210

    data.boot_tx_mailbox_size = slave->sii.boot_tx_mailbox_size;

   211

    data.std_rx_mailbox_offset = slave->sii.std_rx_mailbox_offset;

   212

    data.std_rx_mailbox_size = slave->sii.std_rx_mailbox_size;

   213

    data.std_tx_mailbox_offset = slave->sii.std_tx_mailbox_offset;

   214

    data.std_tx_mailbox_size = slave->sii.std_tx_mailbox_size;

   215

    data.mailbox_protocols = slave->sii.mailbox_protocols;

   216

    data.has_general_category = slave->sii.has_general;

   217

    data.coe_details = slave->sii.coe_details;

   218

    data.general_flags = slave->sii.general_flags;

   219

    data.current_on_ebus = slave->sii.current_on_ebus;

   220

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

   221

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

   222

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

   223

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

   224

        data.ports[i].link.signal_detected =

   225

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

   226

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

   227

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

   228

            data.ports[i].next_slave =

   229

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

   230

        } else {

   231

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

   232

        }

   233

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

   234

    }

   235

    data.fmmu_bit = slave->base_fmmu_bit_operation;

   236

    data.dc_supported = slave->base_dc_supported;

   237

    data.dc_range = slave->base_dc_range;

   238

    data.has_dc_system_time = slave->has_dc_system_time;

   239

    data.transmission_delay = slave->transmission_delay;

   240

    data.al_state = slave->current_state;

   241

    data.error_flag = slave->error_flag;

   242

   243

    data.sync_count = slave->sii.sync_count;

   244

    data.sdo_count = ec_slave_sdo_count(slave);

   245

    data.sii_nwords = slave->sii_nwords;

   246

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

   247

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

   248

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

   249

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

   250

   251

    up(&master->master_sem);

   252

   253

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

   254

        return -EFAULT;

   255

   256

    return 0;

   257

}

   258

   259

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

   260

   261

/** Get slave sync manager information.

   262

 */

   263

static int ec_ioctl_slave_sync(

   264

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

   265

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

   266

        )

   267

{

   268

    ec_ioctl_slave_sync_t data;

   269

    const ec_slave_t *slave;

   270

    const ec_sync_t *sync;

   271

   272

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

   273

        return -EFAULT;

   274

    }

   275

   276

    if (down_interruptible(&master->master_sem))

   277

        return -EINTR;

   278

   279

    if (!(slave = ec_master_find_slave_const(

   280

                    master, 0, data.slave_position))) {

   281

        up(&master->master_sem);

   282

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

   283

                data.slave_position);

   284

        return -EINVAL;

   285

    }

   286

   287

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

   288

        up(&master->master_sem);

   289

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

   290

                data.sync_index);

   291

        return -EINVAL;

   292

    }

   293

   294

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

   295

   296

    data.physical_start_address = sync->physical_start_address;

   297

    data.default_size = sync->default_length;

   298

    data.control_register = sync->control_register;

   299

    data.enable = sync->enable;

   300

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

   301

   302

    up(&master->master_sem);

   303

   304

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

   305

        return -EFAULT;

   306

   307

    return 0;

   308

}

   309

   310

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

   311

   312

/** Get slave sync manager PDO information.

   313

 */

   314

static int ec_ioctl_slave_sync_pdo(

   315

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

   316

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

   317

        )

   318

{

   319

    ec_ioctl_slave_sync_pdo_t data;

   320

    const ec_slave_t *slave;

   321

    const ec_sync_t *sync;

   322

    const ec_pdo_t *pdo;

   323

   324

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

   325

        return -EFAULT;

   326

    }

   327

   328

    if (down_interruptible(&master->master_sem))

   329

        return -EINTR;

   330

   331

    if (!(slave = ec_master_find_slave_const(

   332

                    master, 0, data.slave_position))) {

   333

        up(&master->master_sem);

   334

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

   335

                data.slave_position);

   336

        return -EINVAL;

   337

    }

   338

   339

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

   340

        up(&master->master_sem);

   341

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

   342

                data.sync_index);

   343

        return -EINVAL;

   344

    }

   345

   346

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

   347

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   348

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

   349

        up(&master->master_sem);

   350

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

   351

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

   352

        return -EINVAL;

   353

    }

   354

   355

    data.index = pdo->index;

   356

    data.entry_count = ec_pdo_entry_count(pdo);

   357

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

   358

   359

    up(&master->master_sem);

   360

   361

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

   362

        return -EFAULT;

   363

   364

    return 0;

   365

}

   366

   367

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

   368

   369

/** Get slave sync manager PDO entry information.

   370

 */

   371

static int ec_ioctl_slave_sync_pdo_entry(

   372

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

   373

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

   374

        )

   375

{

   376

    ec_ioctl_slave_sync_pdo_entry_t data;

   377

    const ec_slave_t *slave;

   378

    const ec_sync_t *sync;

   379

    const ec_pdo_t *pdo;

   380

    const ec_pdo_entry_t *entry;

   381

   382

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

   383

        return -EFAULT;

   384

    }

   385

   386

    if (down_interruptible(&master->master_sem))

   387

        return -EINTR;

   388

   389

    if (!(slave = ec_master_find_slave_const(

   390

                    master, 0, data.slave_position))) {

   391

        up(&master->master_sem);

   392

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

   393

                data.slave_position);

   394

        return -EINVAL;

   395

    }

   396

   397

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

   398

        up(&master->master_sem);

   399

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

   400

                data.sync_index);

   401

        return -EINVAL;

   402

    }

   403

   404

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

   405

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   406

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

   407

        up(&master->master_sem);

   408

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

   409

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

   410

        return -EINVAL;

   411

    }

   412

   413

    if (!(entry = ec_pdo_find_entry_by_pos_const(

   414

                    pdo, data.entry_pos))) {

   415

        up(&master->master_sem);

   416

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

   417

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

   418

        return -EINVAL;

   419

    }

   420

   421

    data.index = entry->index;

   422

    data.subindex = entry->subindex;

   423

    data.bit_length = entry->bit_length;

   424

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

   425

   426

    up(&master->master_sem);

   427

   428

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

   429

        return -EFAULT;

   430

   431

    return 0;

   432

}

   433

   434

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

   435

   436

/** Get domain information.

   437

 */

   438

static int ec_ioctl_domain(

   439

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

   440

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

   441

        )

   442

{

   443

    ec_ioctl_domain_t data;

   444

    const ec_domain_t *domain;

   445

    unsigned int dev_idx;

   446

   447

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

   448

        return -EFAULT;

   449

    }

   450

   451

    if (down_interruptible(&master->master_sem))

   452

        return -EINTR;

   453

   454

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

   455

        up(&master->master_sem);

   456

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

   457

        return -EINVAL;

   458

    }

   459

   460

    data.data_size = domain->data_size;

   461

    data.logical_base_address = domain->logical_base_address;

   462

    for (dev_idx = 0; dev_idx < EC_NUM_DEVICES; dev_idx++) {

   463

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

   464

    }

   465

    data.expected_working_counter = domain->expected_working_counter;

   466

    data.fmmu_count = ec_domain_fmmu_count(domain);

   467

   468

    up(&master->master_sem);

   469

   470

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

   471

        return -EFAULT;

   472

   473

    return 0;

   474

}

   475

   476

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

   477

   478

/** Get domain FMMU information.

   479

 */

   480

static int ec_ioctl_domain_fmmu(

   481

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

   482

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

   483

        )

   484

{

   485

    ec_ioctl_domain_fmmu_t data;

   486

    const ec_domain_t *domain;

   487

    const ec_fmmu_config_t *fmmu;

   488

   489

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

   490

        return -EFAULT;

   491

    }

   492

   493

    if (down_interruptible(&master->master_sem))

   494

        return -EINTR;

   495

   496

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

   497

        up(&master->master_sem);

   498

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

   499

                data.domain_index);

   500

        return -EINVAL;

   501

    }

   502

   503

    if (!(fmmu = ec_domain_find_fmmu(domain, data.fmmu_index))) {

   504

        up(&master->master_sem);

   505

        EC_MASTER_ERR(master, "Domain %u has less than %u"

   506

                " fmmu configurations.\n",

   507

                data.domain_index, data.fmmu_index + 1);

   508

        return -EINVAL;

   509

    }

   510

   511

    data.slave_config_alias = fmmu->sc->alias;

   512

    data.slave_config_position = fmmu->sc->position;

   513

    data.sync_index = fmmu->sync_index;

   514

    data.dir = fmmu->dir;

   515

    data.logical_address = fmmu->logical_start_address;

   516

    data.data_size = fmmu->data_size;

   517

   518

    up(&master->master_sem);

   519

   520

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

   521

        return -EFAULT;

   522

   523

    return 0;

   524

}

   525

   526

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

   527

   528

/** Get domain data.

   529

 */