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

ssize_t eccdev_read(struct file *, char __user *, size_t, loff_t *);

    55

ssize_t eccdev_write(struct file *, const char __user *, size_t, loff_t *);

    56

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

    57

    58

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

    59

    60

static struct file_operations eccdev_fops = {

    61

    .owner          = THIS_MODULE,

    62

    .open           = eccdev_open,

    63

    .release        = eccdev_release,

    64

    .unlocked_ioctl = eccdev_ioctl

    65

};

    66

    67

/** \endcond */

    68

    69

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

    70

    71

/** Constructor.

    72

 * 

    73

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

    74

 */

    75

int ec_cdev_init(

    76

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

    77

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

    78

		dev_t dev_num /**< Device number. */

    79

		)

    80

{

    81

    cdev->master = master;

    82

    83

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

    84

    cdev->cdev.owner = THIS_MODULE;

    85

    86

    if (cdev_add(&cdev->cdev,

    87

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

    88

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

    89

		return -1;

    90

    }

    91

    92

    return 0;

    93

}

    94

    95

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

    96

    97

/** Destructor.

    98

 */

    99

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

   100

{

   101

    cdev_del(&cdev->cdev);

   102

}

   103

   104

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

   105

 * File operations

   106

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

   107

   108

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

   109

{

   110

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

   111

    ec_master_t *master = cdev->master;

   112

   113

    filp->private_data = cdev;

   114

    if (master->debug_level)

   115

        EC_DBG("File opened.\n");

   116

    return 0;

   117

}

   118

   119

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

   120

   121

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

   122

{

   123

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

   124

    ec_master_t *master = cdev->master;

   125

   126

    if (master->debug_level)

   127

        EC_DBG("File closed.\n");

   128

    return 0;

   129

}

   130

   131

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

   132

   133

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

   134

{

   135

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

   136

    ec_master_t *master = cdev->master;

   137

    long retval = 0;

   138

   139

    if (master->debug_level)

   140

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

   141

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

   142

   143

    // FIXME lock

   144

   145

    switch (cmd) {

   146

        case EC_IOCTL_SLAVE_COUNT:

   147

            retval = master->slave_count;

   148

            break;

   149

   150

        case EC_IOCTL_SLAVE:

   151

            {

   152

                ec_ioctl_slave_t data;

   153

                const ec_slave_t *slave;

   154

   155

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

   156

                    retval = -EFAULT;

   157

                    break;

   158

                }

   159

   160

                if (!(slave = ec_master_find_slave(

   161

                                master, 0, data.position))) {

   162

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

   163

                    retval = -EINVAL;

   164

                    break;

   165

                }

   166

   167

                data.vendor_id = slave->sii.vendor_id;

   168

                data.product_code = slave->sii.product_code;

   169

                data.revision_number = slave->sii.revision_number;

   170

                data.serial_number = slave->sii.serial_number;

   171

                data.alias = slave->sii.alias;

   172

                data.state = slave->current_state;

   173

   174

                data.sync_count = slave->sii.sync_count;

   175

   176

                if (slave->sii.name) {

   177

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

   178

                            EC_IOCTL_SLAVE_NAME_SIZE);

   179

                    data.name[EC_IOCTL_SLAVE_NAME_SIZE - 1] = 0;

   180

                } else {

   181

                    data.name[0] = 0;

   182

                }

   183

   184

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

   185

                    retval = -EFAULT;

   186

                    break;

   187

                }

   188

   189

                break;

   190

            }

   191

   192

        case EC_IOCTL_SYNC:

   193

            {

   194

                ec_ioctl_sync_t data;

   195

                const ec_slave_t *slave;

   196

                const ec_sync_t *sync;

   197

   198

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

   199

                    retval = -EFAULT;

   200

                    break;

   201

                }

   202

   203

                if (!(slave = ec_master_find_slave(

   204

                                master, 0, data.slave_position))) {

   205

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

   206

                    retval = -EINVAL;

   207

                    break;

   208

                }

   209

   210

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

   211

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

   212

                            data.sync_index, data.slave_position);

   213

                    retval = -EINVAL;

   214

                    break;

   215

                }

   216

   217

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

   218

   219

                data.physical_start_address = sync->physical_start_address;

   220

                data.default_size = sync->length;

   221

                data.control_register = sync->control_register;

   222

                data.enable = sync->enable;

   223

                data.assign_source = sync->assign_source;

   224

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

   225

   226

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

   227

                    retval = -EFAULT;

   228

                    break;

   229

                }

   230

                break;

   231

            }

   232

   233

        case EC_IOCTL_PDO:

   234

            {

   235

                ec_ioctl_pdo_t data;

   236

                const ec_slave_t *slave;

   237

                const ec_sync_t *sync;

   238

                const ec_pdo_t *pdo;

   239

   240

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

   241

                    retval = -EFAULT;

   242

                    break;

   243

                }

   244

   245

                if (!(slave = ec_master_find_slave(

   246

                                master, 0, data.slave_position))) {

   247

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

   248

                    retval = -EINVAL;

   249

                    break;

   250

                }

   251

   252

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

   253

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

   254

                            data.sync_index, data.slave_position);

   255

                    retval = -EINVAL;

   256

                    break;

   257

                }

   258

   259

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

   260

                if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   261

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

   262

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

   263

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

   264

                            data.pdo_pos, data.slave_position);

   265

                    retval = -EINVAL;

   266

                    break;

   267

                }

   268

   269

                data.dir = pdo->dir;

   270

                data.index = pdo->index;

   271

                data.entry_count = ec_pdo_entry_count(pdo);

   272

   273

                if (pdo->name) {

   274

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

   275

                    data.name[EC_IOCTL_PDO_NAME_SIZE - 1] = 0;

   276

                } else {

   277

                    data.name[0] = 0;

   278

                }

   279

   280

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

   281

                    retval = -EFAULT;

   282

                    break;

   283

                }

   284

                break;

   285

            }

   286

   287

        case EC_IOCTL_PDO_ENTRY:

   288

            {

   289

                ec_ioctl_pdo_entry_t data;

   290

                const ec_slave_t *slave;

   291

                const ec_sync_t *sync;

   292

                const ec_pdo_t *pdo;

   293

                const ec_pdo_entry_t *entry;

   294

   295

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

   296

                    retval = -EFAULT;

   297

                    break;

   298

                }

   299

   300

                if (!(slave = ec_master_find_slave(

   301

                                master, 0, data.slave_position))) {

   302

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

   303

                    retval = -EINVAL;

   304

                    break;

   305

                }

   306

   307

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

   308

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

   309

                            data.sync_index, data.slave_position);

   310

                    retval = -EINVAL;

   311

                    break;

   312

                }

   313

   314

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

   315

                if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   316

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

   317

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

   318

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

   319

                            data.pdo_pos, data.slave_position);

   320

                    retval = -EINVAL;

   321

                    break;

   322

                }

   323

   324

                if (!(entry = ec_pdo_find_entry_by_pos_const(

   325

                                pdo, data.entry_pos))) {

   326

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

   327

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

   328

                            data.entry_pos, data.slave_position);

   329

                    retval = -EINVAL;

   330

                    break;

   331

                }

   332

   333

                data.index = entry->index;

   334

                data.subindex = entry->subindex;

   335

                data.bit_length = entry->bit_length;

   336

                if (entry->name) {

   337

                    strncpy(data.name, entry->name,

   338

                            EC_IOCTL_PDO_ENTRY_NAME_SIZE);

   339

                    data.name[EC_IOCTL_PDO_ENTRY_NAME_SIZE - 1] = 0;

   340

                } else {

   341

                    data.name[0] = 0;

   342

                }

   343

   344

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

   345

                    retval = -EFAULT;

   346

                    break;

   347

                }

   348

                break;

   349

            }

   350

   351

        case EC_IOCTL_DOMAIN_COUNT:

   352

            retval = ec_master_domain_count(master);

   353

            break;

   354

   355

        case EC_IOCTL_DOMAIN:

   356

            {

   357

                ec_ioctl_domain_t data;

   358

                const ec_domain_t *domain;

   359

   360

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

   361

                    retval = -EFAULT;

   362

                    break;

   363

                }

   364

   365

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

   366

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

   367

                    retval = -EINVAL;

   368

                    break;

   369

                }

   370

   371

                data.data_size = domain->data_size;

   372

                data.logical_base_address = domain->logical_base_address;

   373

                data.working_counter = domain->working_counter;

   374

                data.expected_working_counter = domain->expected_working_counter;

   375

                data.fmmu_count = ec_domain_fmmu_count(domain);

   376

   377

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

   378

                    retval = -EFAULT;

   379

                    break;

   380

                }

   381

                break;

   382

            }

   383

   384

        case EC_IOCTL_DOMAIN_FMMU:

   385

            {

   386

                ec_ioctl_domain_fmmu_t data;

   387

                const ec_domain_t *domain;

   388

                const ec_fmmu_config_t *fmmu;

   389

   390

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

   391

                    retval = -EFAULT;

   392

                    break;

   393

                }

   394

   395

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

   396

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

   397

                    retval = -EINVAL;

   398

                    break;

   399

                }

   400

   401

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

   402

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

   403

                            data.domain_index, data.fmmu_index + 1);

   404

                    retval = -EINVAL;

   405

                    break;

   406

                }

   407

   408

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

   409

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

   410

                data.fmmu_dir = fmmu->dir;

   411

                data.logical_address = fmmu->logical_start_address;

   412

                data.data_size = fmmu->data_size;

   413

   414

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

   415

                    retval = -EFAULT;

   416

                    break;

   417

                }

   418

                break;

   419

            }

   420

   421

        case EC_IOCTL_DATA:

   422

            {

   423

                ec_ioctl_data_t data;

   424

                const ec_domain_t *domain;

   425

   426

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

   427

                    retval = -EFAULT;

   428

                    break;

   429

                }

   430

   431

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

   432

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

   433

                    retval = -EINVAL;

   434

                    break;

   435

                }

   436

   437

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

   438

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

   439

                            data.data_size, domain->data_size);

   440

                    retval = -EFAULT;

   441

                    break;

   442

                }

   443

   444

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

   445

                            domain->data_size)) {

   446

                    retval = -EFAULT;

   447

                    break;

   448

                }

   449

                break;

   450

            }

   451

   458

        default:

   459

            retval = -ENOIOCTLCMD;

   460

    }

   461

   462

    return retval;

   463

}

   464

   465

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