1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

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

 *  Using the EtherCAT technology and brand is permitted in compliance with

    23

 *  the industrial property and similar rights of Beckhoff Automation GmbH.

    24

 *

    25

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

    26

    27

/**

    28

   \file

    29

   EtherCAT master character device.

    30

*/

    31

    32

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

    33

    34

#include <linux/module.h>

    35

    36

#include "cdev.h"

    37

#include "master.h"

    38

#include "slave_config.h"

    39

#include "ioctl.h"

    40

    41

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

    42

    43

/** \cond */

    44

    45

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

    46

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

    47

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

    48

    49

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

    50

    51

static struct file_operations eccdev_fops = {

    52

    .owner          = THIS_MODULE,

    53

    .open           = eccdev_open,

    54

    .release        = eccdev_release,

    55

    .unlocked_ioctl = eccdev_ioctl

    56

};

    57

    58

/** \endcond */

    59

    60

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

    61

    62

/** Constructor.

    63

 * 

    64

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

    65

 */

    66

int ec_cdev_init(

    67

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

    68

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

    69

		dev_t dev_num /**< Device number. */

    70

		)

    71

{

    72

    cdev->master = master;

    73

    74

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

    75

    cdev->cdev.owner = THIS_MODULE;

    76

    77

    if (cdev_add(&cdev->cdev,

    78

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

    79

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

    80

		return -1;

    81

    }

    82

    83

    return 0;

    84

}

    85

    86

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

    87

    88

/** Destructor.

    89

 */

    90

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

    91

{

    92

    cdev_del(&cdev->cdev);

    93

}

    94

    95

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

    96

    97

/** Copies a string to an ioctl structure.

    98

 */

    99

void ec_cdev_strcpy(

   100

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

   101

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

   102

        )

   103

{

   104

    if (source) {

   105

        strncpy(target, source, EC_IOCTL_STRING_SIZE);

   106

        target[EC_IOCTL_STRING_SIZE - 1] = 0;

   107

    } else {

   108

        target[0] = 0;

   109

    }

   110

}

   111

   112

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

   113

   114

/** Get master information.

   115

 */

   116

int ec_cdev_ioctl_master(

   117

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

   118

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

   119

        )

   120

{

   121

    ec_ioctl_master_t data;

   122

   123

    if (down_interruptible(&master->master_sem))

   124

        return -EINTR;

   125

    data.slave_count = master->slave_count;

   126

    data.config_count = ec_master_config_count(master);

   127

    data.domain_count = ec_master_domain_count(master);

   128

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

   129

    up(&master->master_sem);

   130

   131

    if (down_interruptible(&master->device_sem))

   132

        return -EINTR;

   133

    if (master->main_device.dev) {

   134

        memcpy(data.devices[0].address,

   135

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

   136

    } else {

   137

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

   138

    }

   139

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

   140

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

   141

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

   142

   143

    if (master->backup_device.dev) {

   144

        memcpy(data.devices[1].address,

   145

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

   146

    } else {

   147

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

   148

    }

   149

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

   150

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

   151

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

   152

    up(&master->device_sem);

   153

   154

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

   155

        return -EFAULT;

   156

   157

    return 0;

   158

}

   159

   160

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

   161

   162

/** Get slave information.

   163

 */

   164

int ec_cdev_ioctl_slave(

   165

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

   166

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

   167

        )

   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

        return -EFAULT;

   174

    }

   175

   176

    if (down_interruptible(&master->master_sem))

   177

        return -EINTR;

   178

   179

    if (!(slave = ec_master_find_slave_const(

   180

                    master, 0, data.position))) {

   181

        up(&master->master_sem);

   182

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

   183

        return -EINVAL;

   184

    }

   185

   186

    data.vendor_id = slave->sii.vendor_id;

   187

    data.product_code = slave->sii.product_code;

   188

    data.revision_number = slave->sii.revision_number;

   189

    data.serial_number = slave->sii.serial_number;

   190

    data.alias = slave->sii.alias;

   191

    data.rx_mailbox_offset = slave->sii.rx_mailbox_offset;

   192

    data.rx_mailbox_size = slave->sii.rx_mailbox_size;

   193

    data.tx_mailbox_offset = slave->sii.tx_mailbox_offset;

   194

    data.tx_mailbox_size = slave->sii.tx_mailbox_size;

   195

    data.mailbox_protocols = slave->sii.mailbox_protocols;

   196

    data.has_general_category = slave->sii.has_general;

   197

    data.coe_details = slave->sii.coe_details;

   198

    data.general_flags = slave->sii.general_flags;

   199

    data.current_on_ebus = slave->sii.current_on_ebus;

   200

    data.al_state = slave->current_state;

   201

    data.error_flag = slave->error_flag;

   202

   203

    data.sync_count = slave->sii.sync_count;

   204

    data.sdo_count = ec_slave_sdo_count(slave);

   205

    data.sii_nwords = slave->sii_nwords;

   206

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

   207

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

   208

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

   209

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

   210

   211

    up(&master->master_sem);

   212

   213

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

   214

        return -EFAULT;

   215

   216

    return 0;

   217

}

   218

   219

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

   220

   221

/** Get slave sync manager information.

   222

 */

   223

int ec_cdev_ioctl_slave_sync(

   224

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

   225

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

   226

        )

   227

{

   228

    ec_ioctl_slave_sync_t data;

   229

    const ec_slave_t *slave;

   230

    const ec_sync_t *sync;

   231

   232

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

   233

        return -EFAULT;

   234

    }

   235

   236

    if (down_interruptible(&master->master_sem))

   237

        return -EINTR;

   238

   239

    if (!(slave = ec_master_find_slave_const(

   240

                    master, 0, data.slave_position))) {

   241

        up(&master->master_sem);

   242

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

   243

        return -EINVAL;

   244

    }

   245

   246

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

   247

        up(&master->master_sem);

   248

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

   249

                data.sync_index, data.slave_position);

   250

        return -EINVAL;

   251

    }

   252

   253

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

   254

   255

    data.physical_start_address = sync->physical_start_address;

   256

    data.default_size = sync->default_length;

   257

    data.control_register = sync->control_register;

   258

    data.enable = sync->enable;

   259

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

   260

   261

    up(&master->master_sem);

   262

   263

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

   264

        return -EFAULT;

   265

   266

    return 0;

   267

}

   268

   269

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

   270

   272

 */

   273

int ec_cdev_ioctl_slave_sync_pdo(

   274

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

   275

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

   276

        )

   277

{

   278

    ec_ioctl_slave_sync_pdo_t data;

   279

    const ec_slave_t *slave;

   280

    const ec_sync_t *sync;

   281

    const ec_pdo_t *pdo;

   282

   283

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

   284

        return -EFAULT;

   285

    }

   286

   287

    if (down_interruptible(&master->master_sem))

   288

        return -EINTR;

   289

   290

    if (!(slave = ec_master_find_slave_const(

   291

                    master, 0, data.slave_position))) {

   292

        up(&master->master_sem);

   293

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

   294

        return -EINVAL;

   295

    }

   296

   297

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

   298

        up(&master->master_sem);

   299

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

   300

                data.sync_index, data.slave_position);

   301

        return -EINVAL;

   302

    }

   303

   304

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

   305

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   306

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

   307

        up(&master->master_sem);

   309

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

   310

                data.pdo_pos, data.slave_position);

   311

        return -EINVAL;

   312

    }

   313

   314

    data.index = pdo->index;

   315

    data.entry_count = ec_pdo_entry_count(pdo);

   316

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

   317

   318

    up(&master->master_sem);

   319

   320

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

   321

        return -EFAULT;

   322

   323

    return 0;

   324

}

   325

   326

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

   327

   329

 */

   330

int ec_cdev_ioctl_slave_sync_pdo_entry(

   331

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

   332

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

   333

        )

   334

{

   335

    ec_ioctl_slave_sync_pdo_entry_t data;

   336

    const ec_slave_t *slave;

   337

    const ec_sync_t *sync;

   338

    const ec_pdo_t *pdo;

   339

    const ec_pdo_entry_t *entry;

   340

   341

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

   342

        return -EFAULT;

   343

    }

   344

   345

    if (down_interruptible(&master->master_sem))

   346

        return -EINTR;

   347

   348

    if (!(slave = ec_master_find_slave_const(

   349

                    master, 0, data.slave_position))) {

   350

        up(&master->master_sem);

   351

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

   352

        return -EINVAL;

   353

    }

   354

   355

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

   356

        up(&master->master_sem);

   357

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

   358

                data.sync_index, data.slave_position);

   359

        return -EINVAL;

   360

    }

   361

   362

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

   363

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   364

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

   365

        up(&master->master_sem);

   367

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

   368

                data.pdo_pos, data.slave_position);

   369

        return -EINVAL;

   370

    }

   371

   372

    if (!(entry = ec_pdo_find_entry_by_pos_const(

   373

                    pdo, data.entry_pos))) {

   374

        up(&master->master_sem);

   376

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

   377

                data.entry_pos, data.slave_position);

   378

        return -EINVAL;

   379

    }

   380

   381

    data.index = entry->index;

   382

    data.subindex = entry->subindex;

   383

    data.bit_length = entry->bit_length;

   384

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

   385

   386

    up(&master->master_sem);

   387

   388

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

   389

        return -EFAULT;

   390

   391

    return 0;

   392

}

   393

   394

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

   395

   396

/** Get domain information.

   397

 */

   398

int ec_cdev_ioctl_domain(

   399

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

   400

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

   401

        )

   402

{

   403

    ec_ioctl_domain_t data;

   404

    const ec_domain_t *domain;

   405

   406

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

   407

        return -EFAULT;

   408

    }

   409

   410

    if (down_interruptible(&master->master_sem))

   411

        return -EINTR;

   412

   413

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

   414

        up(&master->master_sem);

   415

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

   416

        return -EINVAL;

   417

    }

   418

   419

    data.data_size = domain->data_size;

   420

    data.logical_base_address = domain->logical_base_address;

   421

    data.working_counter = domain->working_counter;

   422

    data.expected_working_counter = domain->expected_working_counter;

   423

    data.fmmu_count = ec_domain_fmmu_count(domain);

   424

   425

    up(&master->master_sem);

   426

   427

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

   428

        return -EFAULT;

   429

   430

    return 0;

   431

}

   432

   433

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

   434

   435

/** Get domain FMMU information.

   436

 */

   437

int ec_cdev_ioctl_domain_fmmu(

   438

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

   439

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

   440

        )

   441

{

   442

    ec_ioctl_domain_fmmu_t data;

   443

    const ec_domain_t *domain;

   444

    const ec_fmmu_config_t *fmmu;

   445

   446

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

   447

        return -EFAULT;

   448

    }

   449

   450

    if (down_interruptible(&master->master_sem))

   451

        return -EINTR;

   452

   453

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

   454

        up(&master->master_sem);

   455

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

   456

        return -EINVAL;

   457

    }

   458

   459

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

   460

        up(&master->master_sem);

   461

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

   462

                data.domain_index, data.fmmu_index + 1);

   463

        return -EINVAL;

   464

    }

   465

   466

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

   467

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

   468

    data.sync_index = fmmu->sync_index;

   469

    data.dir = fmmu->dir;

   470

    data.logical_address = fmmu->logical_start_address;

   471

    data.data_size = fmmu->data_size;

   472

   473

    up(&master->master_sem);

   474

   475

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

   476

        return -EFAULT;

   477

   478

    return 0;

   479

}

   480

   481

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

   482

   483

/** Get domain data.

   484

 */

   485

int ec_cdev_ioctl_domain_data(

   486

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

   487

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

   488

        )

   489

{

   490

    ec_ioctl_domain_data_t data;

   491

    const ec_domain_t *domain;

   492

   493

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

   494

        return -EFAULT;

   495

    }

   496

   497

    if (down_interruptible(&master->master_sem))