1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

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

    10

 *  and/or modify it under the terms of the GNU General Public License

    11

 *  as published by the Free Software Foundation; either version 2 of the

    12

 *  License, or (at your option) any later version.

    13

 *

    14

 *  The IgH EtherCAT Master is distributed in the hope that it will be

    15

 *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of

    16

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

 *  GNU General Public License for more details.

    18

 *

    19

 *  You should have received a copy of the GNU General Public License

    20

 *  along with the IgH EtherCAT Master; if not, write to the Free Software

    21

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    22

 *

    23

 *  The right to use EtherCAT Technology is granted and comes free of

    24

 *  charge under condition of compatibility of product made by

    25

 *  Licensee. People intending to distribute/sell products based on the

    26

 *  code, have to sign an agreement to guarantee that products using

    27

 *  software based on IgH EtherCAT master stay compatible with the actual

    28

 *  EtherCAT specification (which are released themselves as an open

    29

 *  standard) as the (only) precondition to have the right to use EtherCAT

    30

 *  Technology, IP and trade marks.

    31

 *

    32

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

    33

    34

/**

    35

   \file

    36

   EtherCAT master character device.

    37

*/

    38

    39

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

    40

    41

#include <linux/module.h>

    42

    43

#include "cdev.h"

    44

#include "master.h"

    45

#include "slave_config.h"

    46

#include "ioctl.h"

    47

    48

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

    49

    50

/** \cond */

    51

    52

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

    53

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

    54

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

    55

    56

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

    57

    58

static struct file_operations eccdev_fops = {

    59

    .owner          = THIS_MODULE,

    60

    .open           = eccdev_open,

    61

    .release        = eccdev_release,

    62

    .unlocked_ioctl = eccdev_ioctl

    63

};

    64

    65

/** \endcond */

    66

    67

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

    68

    69

/** Constructor.

    70

 * 

    71

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

    72

 */

    73

int ec_cdev_init(

    74

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

    75

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

    76

		dev_t dev_num /**< Device number. */

    77

		)

    78

{

    79

    cdev->master = master;

    80

    81

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

    82

    cdev->cdev.owner = THIS_MODULE;

    83

    84

    if (cdev_add(&cdev->cdev,

    85

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

    86

		EC_ERR("Failed to add character device!\n");

    87

		return -1;

    88

    }

    89

    90

    return 0;

    91

}

    92

    93

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

    94

    95

/** Destructor.

    96

 */

    97

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

    98

{

    99

    cdev_del(&cdev->cdev);

   100

}

   101

   102

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

   103

 * File operations

   104

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

   105

   106

int eccdev_open(struct inode *inode, struct file *filp)

   107

{

   108

    ec_cdev_t *cdev = container_of(inode->i_cdev, ec_cdev_t, cdev);

   109

    ec_master_t *master = cdev->master;

   110

   111

    filp->private_data = cdev;

   112

    if (master->debug_level)

   113

        EC_DBG("File opened.\n");

   114

    return 0;

   115

}

   116

   117

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

   118

   119

int eccdev_release(struct inode *inode, struct file *filp)

   120

{

   121

    ec_cdev_t *cdev = (ec_cdev_t *) filp->private_data;

   122

    ec_master_t *master = cdev->master;

   123

   124

    if (master->debug_level)

   125

        EC_DBG("File closed.\n");

   126

    return 0;

   127

}

   128

   129

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

   130

   131

long eccdev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)

   132

{

   133

    ec_cdev_t *cdev = (ec_cdev_t *) filp->private_data;

   134

    ec_master_t *master = cdev->master;

   135

    long retval = 0;

   136

   137

    if (master->debug_level)

   138

        EC_DBG("ioctl(filp = %x, cmd = %u (%u), arg = %x)\n",

   139

                (u32) filp, (u32) cmd, (u32) _IOC_NR(cmd), (u32) arg);

   140

   141

    // FIXME lock

   142

   143

    switch (cmd) {

   144

        case EC_IOCTL_MASTER:

   145

            {

   146

                ec_ioctl_master_t data;

   147

   148

                data.slave_count = master->slave_count;

   149

                data.config_count = ec_master_config_count(master);

   150

                data.domain_count = ec_master_domain_count(master);

   151

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

   152

   153

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

   154

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

   155

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

   156

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

   157

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

   158

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

   159

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

   160

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

   161

   162

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

   163

                    retval = -EFAULT;

   164

                break;

   165

            }

   166

   167

        case EC_IOCTL_SLAVE:

   168

            {

   169

                ec_ioctl_slave_t data;

   170

                const ec_slave_t *slave;

   171

   172

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

   173

                    retval = -EFAULT;

   174

                    break;

   175

                }

   176

   177

                if (!(slave = ec_master_find_slave(

   178

                                master, 0, data.position))) {

   179

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

   180

                    retval = -EINVAL;

   181

                    break;

   182

                }

   183

   184

                data.vendor_id = slave->sii.vendor_id;

   185

                data.product_code = slave->sii.product_code;

   186

                data.revision_number = slave->sii.revision_number;

   187

                data.serial_number = slave->sii.serial_number;

   188

                data.alias = slave->sii.alias;

   189

                data.rx_mailbox_offset = slave->sii.rx_mailbox_offset;

   190

                data.rx_mailbox_size = slave->sii.rx_mailbox_size;

   191

                data.tx_mailbox_offset = slave->sii.tx_mailbox_offset;

   192

                data.tx_mailbox_size = slave->sii.tx_mailbox_size;

   193

                data.mailbox_protocols = slave->sii.mailbox_protocols;

   194

                data.has_general_category = slave->sii.has_general;

   195

                data.coe_details = slave->sii.coe_details;

   196

                data.general_flags = slave->sii.general_flags;

   197

                data.current_on_ebus = slave->sii.current_on_ebus;

   198

                data.state = slave->current_state;

   199

                data.error_flag = slave->error_flag;

   200

   201

                data.sync_count = slave->sii.sync_count;

   202

                data.sdo_count = ec_slave_sdo_count(slave);

   203

                data.sii_nwords = slave->sii_nwords;

   204

   205

                if (slave->sii.name) {

   206

                    strncpy(data.name, slave->sii.name,

   207

                            EC_IOCTL_STRING_SIZE);

   208

                    data.name[EC_IOCTL_STRING_SIZE - 1] = 0;

   209

                } else {

   210

                    data.name[0] = 0;

   211

                }

   212

   213

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

   214

                    retval = -EFAULT;

   215

                break;

   216

            }

   217

   218

        case EC_IOCTL_SYNC:

   219

            {

   220

                ec_ioctl_sync_t data;

   221

                const ec_slave_t *slave;

   222

                const ec_sync_t *sync;

   223

   224

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

   225

                    retval = -EFAULT;

   226

                    break;

   227

                }

   228

   229

                if (!(slave = ec_master_find_slave(

   230

                                master, 0, data.slave_position))) {

   231

                    EC_ERR("Slave %u does not exist!\n", data.slave_position);

   232

                    retval = -EINVAL;

   233

                    break;

   234

                }

   235

   236

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

   237

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

   238

                            data.sync_index, data.slave_position);

   239

                    retval = -EINVAL;

   240

                    break;

   241

                }

   242

   243

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

   244

   245

                data.physical_start_address = sync->physical_start_address;

   246

                data.default_size = sync->length;

   247

                data.control_register = sync->control_register;

   248

                data.enable = sync->enable;

   249

                data.assign_source = sync->assign_source;

   250

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

   251

   252

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

   253

                    retval = -EFAULT;

   254

                break;

   255

            }

   256

   257

        case EC_IOCTL_PDO:

   258

            {

   259

                ec_ioctl_pdo_t data;

   260

                const ec_slave_t *slave;

   261

                const ec_sync_t *sync;

   262

                const ec_pdo_t *pdo;

   263

   264

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

   265

                    retval = -EFAULT;

   266

                    break;

   267

                }

   268

   269

                if (!(slave = ec_master_find_slave(

   270

                                master, 0, data.slave_position))) {

   271

                    EC_ERR("Slave %u does not exist!\n", data.slave_position);

   272

                    retval = -EINVAL;

   273

                    break;

   274

                }

   275

   276

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

   277

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

   278

                            data.sync_index, data.slave_position);

   279

                    retval = -EINVAL;

   280

                    break;

   281

                }

   282

   283

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

   284

                if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   285

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

   286

                    EC_ERR("Sync manager %u does not contain a Pdo with "

   287

                            "position %u in slave %u!\n", data.sync_index,

   288

                            data.pdo_pos, data.slave_position);

   289

                    retval = -EINVAL;

   290

                    break;

   291

                }

   292

   293

                data.dir = pdo->dir;

   294

                data.index = pdo->index;

   295

                data.entry_count = ec_pdo_entry_count(pdo);

   296

   297

                if (pdo->name) {

   298

                    strncpy(data.name, pdo->name, EC_IOCTL_STRING_SIZE);

   299

                    data.name[EC_IOCTL_STRING_SIZE - 1] = 0;

   300

                } else {

   301

                    data.name[0] = 0;

   302

                }

   303

   304

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

   305

                    retval = -EFAULT;

   306

                break;

   307

            }

   308

   309

        case EC_IOCTL_PDO_ENTRY:

   310

            {

   311

                ec_ioctl_pdo_entry_t data;

   312

                const ec_slave_t *slave;

   313

                const ec_sync_t *sync;

   314

                const ec_pdo_t *pdo;

   315

                const ec_pdo_entry_t *entry;

   316

   317

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

   318

                    retval = -EFAULT;

   319

                    break;

   320

                }

   321

   322

                if (!(slave = ec_master_find_slave(

   323

                                master, 0, data.slave_position))) {

   324

                    EC_ERR("Slave %u does not exist!\n", data.slave_position);

   325

                    retval = -EINVAL;

   326

                    break;

   327

                }

   328

   329

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

   330

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

   331

                            data.sync_index, data.slave_position);

   332

                    retval = -EINVAL;

   333

                    break;

   334

                }

   335

   336

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

   337

                if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   338

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

   339

                    EC_ERR("Sync manager %u does not contain a Pdo with "

   340

                            "position %u in slave %u!\n", data.sync_index,

   341

                            data.pdo_pos, data.slave_position);

   342

                    retval = -EINVAL;

   343

                    break;

   344

                }

   345

   346

                if (!(entry = ec_pdo_find_entry_by_pos_const(

   347

                                pdo, data.entry_pos))) {

   348

                    EC_ERR("Pdo 0x%04X does not contain an entry with "

   349

                            "position %u in slave %u!\n", data.pdo_pos,

   350

                            data.entry_pos, data.slave_position);

   351

                    retval = -EINVAL;

   352

                    break;

   353

                }

   354

   355

                data.index = entry->index;

   356

                data.subindex = entry->subindex;

   357

                data.bit_length = entry->bit_length;

   358

                if (entry->name) {

   359

                    strncpy(data.name, entry->name, EC_IOCTL_STRING_SIZE);

   360

                    data.name[EC_IOCTL_STRING_SIZE - 1] = 0;

   361

                } else {

   362

                    data.name[0] = 0;

   363

                }

   364

   365

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

   366

                    retval = -EFAULT;

   367

                break;

   368

            }

   369

   370

        case EC_IOCTL_DOMAIN:

   371

            {

   372

                ec_ioctl_domain_t data;

   373

                const ec_domain_t *domain;

   374

   375

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

   376

                    retval = -EFAULT;

   377

                    break;

   378

                }

   379

   380

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

   381

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

   382

                    retval = -EINVAL;

   383

                    break;

   384

                }

   385

   386

                data.data_size = domain->data_size;

   387

                data.logical_base_address = domain->logical_base_address;

   388

                data.working_counter = domain->working_counter;

   389

                data.expected_working_counter = domain->expected_working_counter;

   390

                data.fmmu_count = ec_domain_fmmu_count(domain);

   391

   392

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

   393

                    retval = -EFAULT;

   394

                break;

   395

            }

   396

   397

        case EC_IOCTL_DOMAIN_FMMU:

   398

            {

   399

                ec_ioctl_domain_fmmu_t data;

   400

                const ec_domain_t *domain;

   401

                const ec_fmmu_config_t *fmmu;

   402

   403

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

   404

                    retval = -EFAULT;

   405

                    break;

   406

                }

   407

   408

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

   409

                    EC_ERR("Domain %u does not exist!\n", data.domain_index);

   410

                    retval = -EINVAL;

   411

                    break;

   412

                }

   413

   414

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

   415

                    EC_ERR("Domain %u has less than %u fmmu configurations.\n",

   416

                            data.domain_index, data.fmmu_index + 1);

   417

                    retval = -EINVAL;

   418

                    break;

   419

                }

   420

   421

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

   422

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

   423

                data.fmmu_dir = fmmu->dir;

   424

                data.logical_address = fmmu->logical_start_address;

   425

                data.data_size = fmmu->data_size;

   426

   427

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

   428

                    retval = -EFAULT;

   429

                break;

   430

            }

   431

   432

        case EC_IOCTL_DATA:

   433

            {

   434

                ec_ioctl_data_t data;

   435

                const ec_domain_t *domain;

   436

   437

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

   438

                    retval = -EFAULT;

   439

                    break;

   440

                }

   441

   442

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

   443

                    EC_ERR("Domain %u does not exist!\n", data.domain_index);

   444

                    retval = -EINVAL;

   445

                    break;

   446

                }

   447

   448

                if (domain->data_size != data.data_size) {

   449

                    EC_ERR("Data size mismatch %u/%u!\n",

   450

                            data.data_size, domain->data_size);

   451

                    retval = -EFAULT;

   452

                    break;

   453

                }

   454

   455

                if (copy_to_user((void __user *) data.target, domain->data,

   456

                            domain->data_size))

   457

                    retval = -EFAULT;

   458

                break;

   459

            }

   460

   461

        case EC_IOCTL_SET_DEBUG:

   462

            if (!(filp->f_mode & FMODE_WRITE))

   463

                return -EPERM;

   464

            if (ec_master_debug_level(master, (unsigned int) arg))

   465

                retval = -EINVAL;

   466

            break;

   467

   468

        case EC_IOCTL_SLAVE_STATE:

   469

            {

   470

                ec_ioctl_slave_state_t data;

   471

                ec_slave_t *slave;

   472

   473

                if (!(filp->f_mode & FMODE_WRITE))

   474

                    return -EPERM;

   475

   476

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

   477

                    retval = -EFAULT;

   478

                    break;

   479

                }

   480

   481

                if (!(slave = ec_master_find_slave(

   482

                                master, 0, data.slave_position))) {

   483

                    EC_ERR("Slave %u does not exist!\n", data.slave_position);

   484

                    retval = -EINVAL;

   485

                    break;

   486

                }

   487

   488

                ec_slave_request_state(slave, data.requested_state);

   489

                break;

   490

            }

   491

   492

        case EC_IOCTL_SDO:

   493

            {

   494

                ec_ioctl_sdo_t data;

   495

                const ec_slave_t *slave;

   496

                const ec_sdo_t *sdo;

   497

   498

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

   499

                    retval = -EFAULT;

   500