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.boot_rx_mailbox_offset = slave->sii.boot_rx_mailbox_offset;

   192

    data.boot_rx_mailbox_size = slave->sii.boot_rx_mailbox_size;

   193

    data.boot_tx_mailbox_offset = slave->sii.boot_tx_mailbox_offset;

   194

    data.boot_tx_mailbox_size = slave->sii.boot_tx_mailbox_size;

   195

    data.std_rx_mailbox_offset = slave->sii.std_rx_mailbox_offset;

   196

    data.std_rx_mailbox_size = slave->sii.std_rx_mailbox_size;

   197

    data.std_tx_mailbox_offset = slave->sii.std_tx_mailbox_offset;

   198

    data.std_tx_mailbox_size = slave->sii.std_tx_mailbox_size;

   199

    data.mailbox_protocols = slave->sii.mailbox_protocols;

   200

    data.has_general_category = slave->sii.has_general;

   201

    data.coe_details = slave->sii.coe_details;

   202

    data.general_flags = slave->sii.general_flags;

   203

    data.current_on_ebus = slave->sii.current_on_ebus;

   204

    data.al_state = slave->current_state;

   205

    data.error_flag = slave->error_flag;

   206

   207

    data.sync_count = slave->sii.sync_count;

   208

    data.sdo_count = ec_slave_sdo_count(slave);

   209

    data.sii_nwords = slave->sii_nwords;

   210

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

   211

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

   212

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

   213

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

   214

   215

    up(&master->master_sem);

   216

   217

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

   218

        return -EFAULT;

   219

   220

    return 0;

   221

}

   222

   223

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

   224

   225

/** Get slave sync manager information.

   226

 */

   227

int ec_cdev_ioctl_slave_sync(

   228

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

   229

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

   230

        )

   231

{

   232

    ec_ioctl_slave_sync_t data;

   233

    const ec_slave_t *slave;

   234

    const ec_sync_t *sync;

   235

   236

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

   237

        return -EFAULT;

   238

    }

   239

   240

    if (down_interruptible(&master->master_sem))

   241

        return -EINTR;

   242

   243

    if (!(slave = ec_master_find_slave_const(

   244

                    master, 0, data.slave_position))) {

   245

        up(&master->master_sem);

   246

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

   247

        return -EINVAL;

   248

    }

   249

   250

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

   251

        up(&master->master_sem);

   252

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

   253

                data.sync_index, data.slave_position);

   254

        return -EINVAL;

   255

    }

   256

   257

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

   258

   259

    data.physical_start_address = sync->physical_start_address;

   260

    data.default_size = sync->default_length;

   261

    data.control_register = sync->control_register;

   262

    data.enable = sync->enable;

   263

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

   264

   265

    up(&master->master_sem);

   266

   267

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

   268

        return -EFAULT;

   269

   270

    return 0;

   271

}

   272

   273

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

   274

   275

/** Get slave sync manager PDO information.

   276

 */

   277

int ec_cdev_ioctl_slave_sync_pdo(

   278

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

   279

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

   280

        )

   281

{

   282

    ec_ioctl_slave_sync_pdo_t data;

   283

    const ec_slave_t *slave;

   284

    const ec_sync_t *sync;

   285

    const ec_pdo_t *pdo;

   286

   287

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

   288

        return -EFAULT;

   289

    }

   290

   291

    if (down_interruptible(&master->master_sem))

   292

        return -EINTR;

   293

   294

    if (!(slave = ec_master_find_slave_const(

   295

                    master, 0, data.slave_position))) {

   296

        up(&master->master_sem);

   297

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

   298

        return -EINVAL;

   299

    }

   300

   301

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

   302

        up(&master->master_sem);

   303

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

   304

                data.sync_index, data.slave_position);

   305

        return -EINVAL;

   306

    }

   307

   308

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

   309

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   310

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

   311

        up(&master->master_sem);

   312

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

   313

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

   314

                data.pdo_pos, data.slave_position);

   315

        return -EINVAL;

   316

    }

   317

   318

    data.index = pdo->index;

   319

    data.entry_count = ec_pdo_entry_count(pdo);

   320

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

   321

   322

    up(&master->master_sem);

   323

   324

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

   325

        return -EFAULT;

   326

   327

    return 0;

   328

}

   329

   330

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

   331

   332

/** Get slave sync manager PDO entry information.

   333

 */

   334

int ec_cdev_ioctl_slave_sync_pdo_entry(

   335

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

   336

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

   337

        )

   338

{

   339

    ec_ioctl_slave_sync_pdo_entry_t data;

   340

    const ec_slave_t *slave;

   341

    const ec_sync_t *sync;

   342

    const ec_pdo_t *pdo;

   343

    const ec_pdo_entry_t *entry;

   344

   345

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

   346

        return -EFAULT;

   347

    }

   348

   349

    if (down_interruptible(&master->master_sem))

   350

        return -EINTR;

   351

   352

    if (!(slave = ec_master_find_slave_const(

   353

                    master, 0, data.slave_position))) {

   354

        up(&master->master_sem);

   355

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

   356

        return -EINVAL;

   357

    }

   358

   359

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

   360

        up(&master->master_sem);

   361

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

   362

                data.sync_index, data.slave_position);

   363

        return -EINVAL;

   364

    }

   365

   366

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

   367

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   368

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

   369

        up(&master->master_sem);

   370

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

   371

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

   372

                data.pdo_pos, data.slave_position);

   373

        return -EINVAL;

   374

    }

   375

   376

    if (!(entry = ec_pdo_find_entry_by_pos_const(

   377

                    pdo, data.entry_pos))) {

   378

        up(&master->master_sem);

   379

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

   380

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

   381

                data.entry_pos, data.slave_position);

   382

        return -EINVAL;

   383

    }

   384

   385

    data.index = entry->index;

   386

    data.subindex = entry->subindex;

   387

    data.bit_length = entry->bit_length;

   388

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

   389

   390

    up(&master->master_sem);

   391

   392

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

   393

        return -EFAULT;

   394

   395

    return 0;

   396

}

   397

   398

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

   399

   400

/** Get domain information.

   401

 */

   402

int ec_cdev_ioctl_domain(

   403

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

   404

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

   405

        )

   406

{

   407

    ec_ioctl_domain_t data;

   408

    const ec_domain_t *domain;

   409

   410

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

   411

        return -EFAULT;

   412

    }

   413

   414

    if (down_interruptible(&master->master_sem))

   415

        return -EINTR;

   416

   417

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

   418

        up(&master->master_sem);

   419

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

   420

        return -EINVAL;

   421

    }

   422

   423

    data.data_size = domain->data_size;

   424

    data.logical_base_address = domain->logical_base_address;

   425

    data.working_counter = domain->working_counter;

   426

    data.expected_working_counter = domain->expected_working_counter;

   427

    data.fmmu_count = ec_domain_fmmu_count(domain);

   428

   429

    up(&master->master_sem);

   430

   431

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

   432

        return -EFAULT;

   433

   434

    return 0;

   435

}

   436

   437

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

   438

   439

/** Get domain FMMU information.

   440

 */

   441

int ec_cdev_ioctl_domain_fmmu(

   442

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

   443

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

   444

        )

   445

{

   446

    ec_ioctl_domain_fmmu_t data;

   447

    const ec_domain_t *domain;

   448

    const ec_fmmu_config_t *fmmu;

   449

   450

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

   451

        return -EFAULT;

   452

    }

   453

   454

    if (down_interruptible(&master->master_sem))

   455

        return -EINTR;

   456

   457

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

   458

        up(&master->master_sem);

   459

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

   460

        return -EINVAL;

   461

    }

   462

   463

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

   464

        up(&master->master_sem);

   465

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

   466

                data.domain_index, data.fmmu_index + 1);

   467

        return -EINVAL;

   468

    }

   469

   470

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

   471

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

   472

    data.sync_index = fmmu->sync_index;

   473

    data.dir = fmmu->dir;

   474

    data.logical_address = fmmu->logical_start_address;

   475

    data.data_size = fmmu->data_size;

   476

   477

    up(&master->master_sem);

   478

   479

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

   480

        return -EFAULT;

   481

   482

    return 0;

   483

}

   484

   485

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

   486

   487

/** Get domain data.

   488

 */

   489

int ec_cdev_ioctl_domain_data(

   490

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

   491

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

   492

        )

   493

{

   494

    ec_ioctl_domain_data_t data;

   495

    const ec_domain_t *domain;

   496

   497

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

   498