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

/** Private data structure for file handles.

    70

 */

    71

typedef struct {

    72

    ec_cdev_t *cdev;

    73

    unsigned int requested;

    74

} ec_cdev_priv_t;

    75

    76

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

    77

    78

/** Constructor.

    79

 * 

    80

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

    81

 */

    82

int ec_cdev_init(

    83

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

    84

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

    85

		dev_t dev_num /**< Device number. */

    86

		)

    87

{

    88

    cdev->master = master;

    89

    90

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

    91

    cdev->cdev.owner = THIS_MODULE;

    92

    93

    if (cdev_add(&cdev->cdev,

    94

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

    95

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

    96

		return -1;

    97

    }

    98

    99

    return 0;

   100

}

   101

   102

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

   103

   104

/** Destructor.

   105

 */

   106

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

   107

{

   108

    cdev_del(&cdev->cdev);

   109

}

   110

   111

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

   112

   113

/** Copies a string to an ioctl structure.

   114

 */

   115

void ec_cdev_strcpy(

   116

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

   117

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

   118

        )

   119

{

   120

    if (source) {

   121

        strncpy(target, source, EC_IOCTL_STRING_SIZE);

   122

        target[EC_IOCTL_STRING_SIZE - 1] = 0;

   123

    } else {

   124

        target[0] = 0;

   125

    }

   126

}

   127

   128

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

   129

   130

/** Get master information.

   131

 */

   132

int ec_cdev_ioctl_master(

   133

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

   134

        unsigned long arg /**< Userspace address to store the results. */

   135

        )

   136

{

   137

    ec_ioctl_master_t data;

   138

   139

    if (down_interruptible(&master->master_sem))

   140

        return -EINTR;

   141

    data.slave_count = master->slave_count;

   142

    data.config_count = ec_master_config_count(master);

   143

    data.domain_count = ec_master_domain_count(master);

   144

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

   145

    up(&master->master_sem);

   146

   147

    if (down_interruptible(&master->device_sem))

   148

        return -EINTR;

   149

    if (master->main_device.dev) {

   150

        memcpy(data.devices[0].address,

   151

                master->main_device.dev->dev_addr, ETH_ALEN);

   152

    } else {

   153

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

   154

    }

   155

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

   156

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

   157

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

   158

   159

    if (master->backup_device.dev) {

   160

        memcpy(data.devices[1].address,

   161

                master->backup_device.dev->dev_addr, ETH_ALEN); 

   162

    } else {

   163

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

   164

    }

   165

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

   166

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

   167

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

   168

    up(&master->device_sem);

   169

   170

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

   171

        return -EFAULT;

   172

   173

    return 0;

   174

}

   175

   176

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

   177

   178

/** Get slave information.

   179

 */

   180

int ec_cdev_ioctl_slave(

   181

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

   182

        unsigned long arg /**< Userspace address to store the results. */

   183

        )

   184

{

   185

    ec_ioctl_slave_t data;

   186

    const ec_slave_t *slave;

   187

   188

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

   189

        return -EFAULT;

   190

    }

   191

   192

    if (down_interruptible(&master->master_sem))

   193

        return -EINTR;

   194

   195

    if (!(slave = ec_master_find_slave_const(

   196

                    master, 0, data.position))) {

   197

        up(&master->master_sem);

   198

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

   199

        return -EINVAL;

   200

    }

   201

   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->sii.alias;

   207

    data.rx_mailbox_offset = slave->sii.rx_mailbox_offset;

   208

    data.rx_mailbox_size = slave->sii.rx_mailbox_size;

   209

    data.tx_mailbox_offset = slave->sii.tx_mailbox_offset;

   210

    data.tx_mailbox_size = slave->sii.tx_mailbox_size;

   211

    data.mailbox_protocols = slave->sii.mailbox_protocols;

   212

    data.has_general_category = slave->sii.has_general;

   213

    data.coe_details = slave->sii.coe_details;

   214

    data.general_flags = slave->sii.general_flags;

   215

    data.current_on_ebus = slave->sii.current_on_ebus;

   216

    data.al_state = slave->current_state;

   217

    data.error_flag = slave->error_flag;

   218

   219

    data.sync_count = slave->sii.sync_count;

   220

    data.sdo_count = ec_slave_sdo_count(slave);

   221

    data.sii_nwords = slave->sii_nwords;

   222

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

   223

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

   224

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

   225

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

   226

   227

    up(&master->master_sem);

   228

   229

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

   230

        return -EFAULT;

   231

   232

    return 0;

   233

}

   234

   235

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

   236

   237

/** Get slave sync manager information.

   238

 */

   239

int ec_cdev_ioctl_slave_sync(

   240

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

   241

        unsigned long arg /**< Userspace address to store the results. */

   242

        )

   243

{

   244

    ec_ioctl_slave_sync_t data;

   245

    const ec_slave_t *slave;

   246

    const ec_sync_t *sync;

   247

   248

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

   249

        return -EFAULT;

   250

    }

   251

   252

    if (down_interruptible(&master->master_sem))

   253

        return -EINTR;

   254

   255

    if (!(slave = ec_master_find_slave_const(

   256

                    master, 0, data.slave_position))) {

   257

        up(&master->master_sem);

   258

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

   259

        return -EINVAL;

   260

    }

   261

   262

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

   263

        up(&master->master_sem);

   264

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

   265

                data.sync_index, data.slave_position);

   266

        return -EINVAL;

   267

    }

   268

   269

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

   270

   271

    data.physical_start_address = sync->physical_start_address;

   272

    data.default_size = sync->default_length;

   273

    data.control_register = sync->control_register;

   274

    data.enable = sync->enable;

   275

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

   276

   277

    up(&master->master_sem);

   278

   279

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

   280

        return -EFAULT;

   281

   282

    return 0;

   283

}

   284

   285

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

   286

   287

/** Get slave sync manager Pdo information.

   288

 */

   289

int ec_cdev_ioctl_slave_sync_pdo(

   290

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

   291

        unsigned long arg /**< Userspace address to store the results. */

   292

        )

   293

{

   294

    ec_ioctl_slave_sync_pdo_t data;

   295

    const ec_slave_t *slave;

   296

    const ec_sync_t *sync;

   297

    const ec_pdo_t *pdo;

   298

   299

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

   300

        return -EFAULT;

   301

    }

   302

   303

    if (down_interruptible(&master->master_sem))

   304

        return -EINTR;

   305

   306

    if (!(slave = ec_master_find_slave_const(

   307

                    master, 0, data.slave_position))) {

   308

        up(&master->master_sem);

   309

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

   310

        return -EINVAL;

   311

    }

   312

   313

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

   314

        up(&master->master_sem);

   315

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

   316

                data.sync_index, data.slave_position);

   317

        return -EINVAL;

   318

    }

   319

   320

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

   321

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   322

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

   323

        up(&master->master_sem);

   324

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

   325

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

   326

                data.pdo_pos, data.slave_position);

   327

        return -EINVAL;

   328

    }

   329

   330

    data.index = pdo->index;

   331

    data.entry_count = ec_pdo_entry_count(pdo);

   332

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

   333

   334

    up(&master->master_sem);

   335

   336

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

   337

        return -EFAULT;

   338

   339

    return 0;

   340

}

   341

   342

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

   343

   344

/** Get slave sync manager Pdo entry information.

   345

 */

   346

int ec_cdev_ioctl_slave_sync_pdo_entry(

   347

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

   348

        unsigned long arg /**< Userspace address to store the results. */

   349

        )

   350

{

   351

    ec_ioctl_slave_sync_pdo_entry_t data;

   352

    const ec_slave_t *slave;

   353

    const ec_sync_t *sync;

   354

    const ec_pdo_t *pdo;

   355

    const ec_pdo_entry_t *entry;

   356

   357

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

   358

        return -EFAULT;

   359

    }

   360

   361

    if (down_interruptible(&master->master_sem))

   362

        return -EINTR;

   363

   364

    if (!(slave = ec_master_find_slave_const(

   365

                    master, 0, data.slave_position))) {

   366

        up(&master->master_sem);

   367

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

   368

        return -EINVAL;

   369

    }

   370

   371

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

   372

        up(&master->master_sem);

   373

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

   374

                data.sync_index, data.slave_position);

   375

        return -EINVAL;

   376

    }

   377

   378

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

   379

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   380

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

   381

        up(&master->master_sem);

   382

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

   383

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

   384

                data.pdo_pos, data.slave_position);

   385

        return -EINVAL;

   386

    }

   387

   388

    if (!(entry = ec_pdo_find_entry_by_pos_const(

   389

                    pdo, data.entry_pos))) {

   390

        up(&master->master_sem);

   391

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

   392

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

   393

                data.entry_pos, data.slave_position);

   394

        return -EINVAL;

   395

    }

   396

   397

    data.index = entry->index;

   398

    data.subindex = entry->subindex;

   399

    data.bit_length = entry->bit_length;

   400

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

   401

   402

    up(&master->master_sem);

   403

   404

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

   405

        return -EFAULT;

   406

   407

    return 0;

   408

}

   409

   410

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

   411

   412

/** Get domain information.

   413

 */

   414

int ec_cdev_ioctl_domain(

   415

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

   416

        unsigned long arg /**< Userspace address to store the results. */

   417

        )

   418

{

   419

    ec_ioctl_domain_t data;

   420

    const ec_domain_t *domain;

   421

   422

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

   423

        return -EFAULT;

   424

    }

   425

   426

    if (down_interruptible(&master->master_sem))

   427

        return -EINTR;

   428

   429

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

   430

        up(&master->master_sem);

   431

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

   432

        return -EINVAL;

   433

    }

   434

   435

    data.data_size = domain->data_size;

   436

    data.logical_base_address = domain->logical_base_address;

   437

    data.working_counter = domain->working_counter;

   438

    data.expected_working_counter = domain->expected_working_counter;

   439

    data.fmmu_count = ec_domain_fmmu_count(domain);

   440

   441

    up(&master->master_sem);

   442

   443

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

   444

        return -EFAULT;

   445

   446

    return 0;

   447

}

   448

   449

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

   450

   451

/** Get domain FMMU information.

   452

 */

   453

int ec_cdev_ioctl_domain_fmmu(

   454

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

   455

        unsigned long arg /**< Userspace address to store the results. */

   456

        )

   457

{

   458

    ec_ioctl_domain_fmmu_t data;

   459

    const ec_domain_t *domain;

   460

    const ec_fmmu_config_t *fmmu;

   461

   462

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

   463

        return -EFAULT;

   464

    }

   465

   466

    if (down_interruptible(&master->master_sem))

   467

        return -EINTR;

   468

   469

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

   470

        up(&master->master_sem);

   471

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

   472

        return -EINVAL;

   473

    }

   474

   475

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

   476

        up(&master->master_sem);

   477

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

   478

                data.domain_index, data.fmmu_index + 1);

   479

        return -EINVAL;

   480

    }

   481

   482

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

   483

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

   484

    data.sync_index = fmmu->sync_index;

   485

    data.dir = fmmu->dir;

   486

    data.logical_address = fmmu->logical_start_address;

   487

    data.data_size = fmmu->data_size;

   488

   489

    up(&master->master_sem);

   490

   491

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

   492

        return -EFAULT;

   493

   494

    return 0;

   495

}

   496

   497

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

   498

   499

/** Get domain data.

   500

 */