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

   104

/** Get master information.

   105

 */

   106

int ec_cdev_ioctl_master(

   107

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

   108

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

   109

        )

   110

{

   111

    ec_ioctl_master_t data;

   112

   113

    down(&master->master_sem);

   114

    data.slave_count = master->slave_count;

   115

    data.config_count = ec_master_config_count(master);

   116

    data.domain_count = ec_master_domain_count(master);

   117

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

   118

    up(&master->master_sem);

   119

   120

    down(&master->device_sem);

   121

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

   122

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

   123

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

   124

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

   125

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

   126

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

   127

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

   128

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

   129

    up(&master->device_sem);

   130

   131

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

   132

        return -EFAULT;

   133

   134

    return 0;

   135

}

   136

   137

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

   138

   139

/** Get slave information.

   140

 */

   141

int ec_cdev_ioctl_slave(

   142

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

   143

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

   144

        )

   145

{

   146

    ec_ioctl_slave_t data;

   147

    const ec_slave_t *slave;

   148

   149

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

   150

        return -EFAULT;

   151

    }

   152

   153

    down(&master->master_sem);

   154

   155

    if (!(slave = ec_master_find_slave_const(

   156

                    master, 0, data.position))) {

   157

        up(&master->master_sem);

   158

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

   159

        return -EINVAL;

   160

    }

   161

   162

    data.vendor_id = slave->sii.vendor_id;

   163

    data.product_code = slave->sii.product_code;

   164

    data.revision_number = slave->sii.revision_number;

   165

    data.serial_number = slave->sii.serial_number;

   166

    data.alias = slave->sii.alias;

   167

    data.rx_mailbox_offset = slave->sii.rx_mailbox_offset;

   168

    data.rx_mailbox_size = slave->sii.rx_mailbox_size;

   169

    data.tx_mailbox_offset = slave->sii.tx_mailbox_offset;

   170

    data.tx_mailbox_size = slave->sii.tx_mailbox_size;

   171

    data.mailbox_protocols = slave->sii.mailbox_protocols;

   172

    data.has_general_category = slave->sii.has_general;

   173

    data.coe_details = slave->sii.coe_details;

   174

    data.general_flags = slave->sii.general_flags;

   175

    data.current_on_ebus = slave->sii.current_on_ebus;

   176

    data.state = slave->current_state;

   177

    data.error_flag = slave->error_flag;

   178

   179

    data.sync_count = slave->sii.sync_count;

   180

    data.sdo_count = ec_slave_sdo_count(slave);

   181

    data.sii_nwords = slave->sii_nwords;

   182

   183

    if (slave->sii.name) {

   184

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

   185

                EC_IOCTL_STRING_SIZE);

   186

        data.name[EC_IOCTL_STRING_SIZE - 1] = 0;

   187

    } else {

   188

        data.name[0] = 0;

   189

    }

   190

   191

    up(&master->master_sem);

   192

   193

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

   194

        return -EFAULT;

   195

   196

    return 0;

   197

}

   198

   199

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

   200

   201

/** Get slave sync manager information.

   202

 */

   203

int ec_cdev_ioctl_slave_sync(

   204

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

   205

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

   206

        )

   207

{

   208

    ec_ioctl_slave_sync_t data;

   209

    const ec_slave_t *slave;

   210

    const ec_sync_t *sync;

   211

   212

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

   213

        return -EFAULT;

   214

    }

   215

   216

    down(&master->master_sem);

   217

   218

    if (!(slave = ec_master_find_slave_const(

   219

                    master, 0, data.slave_position))) {

   220

        up(&master->master_sem);

   221

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

   222

        return -EINVAL;

   223

    }

   224

   225

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

   226

        up(&master->master_sem);

   227

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

   228

                data.sync_index, data.slave_position);

   229

        return -EINVAL;

   230

    }

   231

   232

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

   233

   234

    data.physical_start_address = sync->physical_start_address;

   235

    data.default_size = sync->default_length;

   236

    data.control_register = sync->control_register;

   237

    data.enable = sync->enable;

   238

    data.assign_source = sync->assign_source;

   239

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

   240

   241

    up(&master->master_sem);

   242

   243

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

   244

        return -EFAULT;

   245

   246

    return 0;

   247

}

   248

   249

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

   250

   251

/** Get slave sync manager Pdo information.

   252

 */

   253

int ec_cdev_ioctl_slave_sync_pdo(

   254

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

   255

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

   256

        )

   257

{

   258

    ec_ioctl_slave_sync_pdo_t data;

   259

    const ec_slave_t *slave;

   260

    const ec_sync_t *sync;

   261

    const ec_pdo_t *pdo;

   262

   263

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

   264

        return -EFAULT;

   265

    }

   266

   267

    down(&master->master_sem);

   268

   269

    if (!(slave = ec_master_find_slave_const(

   270

                    master, 0, data.slave_position))) {

   271

        up(&master->master_sem);

   272

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

   273

        return -EINVAL;

   274

    }

   275

   276

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

   277

        up(&master->master_sem);

   278

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

   279

                data.sync_index, data.slave_position);

   280

        return -EINVAL;

   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

        up(&master->master_sem);

   287

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

   288

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

   289

                data.pdo_pos, data.slave_position);

   290

        return -EINVAL;

   291

    }

   292

   293

    data.index = pdo->index;

   294

    data.entry_count = ec_pdo_entry_count(pdo);

   295

   296

    if (pdo->name) {

   297

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

   298

        data.name[EC_IOCTL_STRING_SIZE - 1] = 0;

   299

    } else {

   300

        data.name[0] = 0;

   301

    }

   302

   303

    up(&master->master_sem);

   304

   305

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

   306

        return -EFAULT;

   307

   308

    return 0;

   309

}

   310

   311

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

   312

   313

/** Get slave sync manager Pdo entry information.

   314

 */

   315

int ec_cdev_ioctl_slave_sync_pdo_entry(

   316

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

   317

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

   318

        )

   319

{

   320

    ec_ioctl_slave_sync_pdo_entry_t data;

   321

    const ec_slave_t *slave;

   322

    const ec_sync_t *sync;

   323

    const ec_pdo_t *pdo;

   324

    const ec_pdo_entry_t *entry;

   325

   326

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

   327

        return -EFAULT;

   328

    }

   329

   330

    down(&master->master_sem);

   331

   332

    if (!(slave = ec_master_find_slave_const(

   333

                    master, 0, data.slave_position))) {

   334

        up(&master->master_sem);

   335

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

   336

        return -EINVAL;

   337

    }

   338

   339

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

   340

        up(&master->master_sem);

   341

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

   342

                data.sync_index, data.slave_position);

   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_ERR("Sync manager %u does not contain a Pdo with "

   351

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

   352

                data.pdo_pos, data.slave_position);

   353

        return -EINVAL;

   354

    }

   355

   356

    if (!(entry = ec_pdo_find_entry_by_pos_const(

   357

                    pdo, data.entry_pos))) {

   358

        up(&master->master_sem);

   359

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

   360

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

   361

                data.entry_pos, data.slave_position);

   362

        return -EINVAL;

   363

    }

   364

   365

    data.index = entry->index;

   366

    data.subindex = entry->subindex;

   367

    data.bit_length = entry->bit_length;

   368

    if (entry->name) {

   369

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

   370

        data.name[EC_IOCTL_STRING_SIZE - 1] = 0;

   371

    } else {

   372

        data.name[0] = 0;

   373

    }

   374

   375

    up(&master->master_sem);

   376

   377

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

   378

        return -EFAULT;

   379

   380

    return 0;

   381

}

   382

   383

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

   384

   385

/** Get domain information.

   386

 */

   387

int ec_cdev_ioctl_domain(

   388

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

   389

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

   390

        )

   391

{

   392

    ec_ioctl_domain_t data;

   393

    const ec_domain_t *domain;

   394

   395

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

   396

        return -EFAULT;

   397

    }

   398

   399

    down(&master->master_sem);

   400

   401

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

   402

        up(&master->master_sem);

   403

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

   404

        return -EINVAL;

   405

    }

   406

   407

    data.data_size = domain->data_size;

   408

    data.logical_base_address = domain->logical_base_address;

   409

    data.working_counter = domain->working_counter;

   410

    data.expected_working_counter = domain->expected_working_counter;

   411

    data.fmmu_count = ec_domain_fmmu_count(domain);

   412

   413

    up(&master->master_sem);

   414

   415

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

   416

        return -EFAULT;

   417

   418

    return 0;

   419

}

   420

   421

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

   422

   423

/** Get domain FMMU information.

   424

 */

   425

int ec_cdev_ioctl_domain_fmmu(

   426

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

   427

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

   428

        )

   429

{

   430

    ec_ioctl_domain_fmmu_t data;

   431

    const ec_domain_t *domain;

   432

    const ec_fmmu_config_t *fmmu;

   433

   434

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

   435

        return -EFAULT;

   436

    }

   437

   438

    down(&master->master_sem);

   439

   440

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

   441

        up(&master->master_sem);

   442

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

   443

        return -EINVAL;

   444

    }

   445

   446

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

   447

        up(&master->master_sem);

   448

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

   449

                data.domain_index, data.fmmu_index + 1);

   450

        return -EINVAL;

   451

    }

   452

   453

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

   454

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

   455

    data.sync_index = fmmu->sync_index;

   456

    data.dir = fmmu->dir;

   457

    data.logical_address = fmmu->logical_start_address;

   458

    data.data_size = fmmu->data_size;

   459

   460

    up(&master->master_sem);

   461

   462

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

   463

        return -EFAULT;

   464

   465

    return 0;

   466

}

   467

   468

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

   469

   470

/** Get domain data.

   471

 */

   472

int ec_cdev_ioctl_domain_data(

   473

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

   474

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

   475

        )

   476

{

   477

    ec_ioctl_domain_data_t data;

   478

    const ec_domain_t *domain;

   479

   480

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

   481

        return -EFAULT;

   482

    }

   483

   484

    down(&master->master_sem);

   485

   486

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

   487

        up(&master->master_sem);

   488

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

   489

        return -EINVAL;

   490

    }

   491

   492

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

   493

        up(&master->master_sem);

   494

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

   495

                data.data_size, domain->data_size);

   496

        return -EFAULT;

   497

    }

   498

   499

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

   500

                domain->data_size))

   501

        return -EFAULT;

   502