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

#include <linux/vmalloc.h>

    43

#include <linux/mm.h>

    44

    45

#include "cdev.h"

    46

#include "master.h"

    47

#include "slave_config.h"

    48

#include "ioctl.h"

    49

    50

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

    51

    52

/** \cond */

    53

    54

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

    55

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

    56

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

    57

int eccdev_mmap(struct file *, struct vm_area_struct *);

    58

    59

static struct page *eccdev_vma_nopage(

    60

        struct vm_area_struct *, unsigned long, int *);

    61

    62

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

    63

    64

static struct file_operations eccdev_fops = {

    65

    .owner          = THIS_MODULE,

    66

    .open           = eccdev_open,

    67

    .release        = eccdev_release,

    68

    .unlocked_ioctl = eccdev_ioctl,

    69

    .mmap           = eccdev_mmap

    70

};

    71

    72

struct vm_operations_struct eccdev_vm_ops = {

    73

    .nopage = eccdev_vma_nopage

    74

};

    75

    76

/** \endcond */

    77

    78

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

    79

    80

/** Private data structure for file handles.

    81

 */

    82

typedef struct {

    83

    ec_cdev_t *cdev;

    84

    unsigned int requested;

    85

    uint8_t *process_data;

    86

    size_t process_data_size;

    87

} ec_cdev_priv_t;

    88

    89

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

    90

    91

/** Constructor.

    92

 * 

    93

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

    94

 */

    95

int ec_cdev_init(

    96

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

    97

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

    98

		dev_t dev_num /**< Device number. */

    99

		)

   100

{

   101

    cdev->master = master;

   102

   103

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

   104

    cdev->cdev.owner = THIS_MODULE;

   105

   106

    if (cdev_add(&cdev->cdev,

   107

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

   108

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

   109

		return -1;

   110

    }

   111

   112

    return 0;

   113

}

   114

   115

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

   116

   117

/** Destructor.

   118

 */

   119

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

   120

{

   121

    cdev_del(&cdev->cdev);

   122

}

   123

   124

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

   125

   126

/** Copies a string to an ioctl structure.

   127

 */

   128

void ec_cdev_strcpy(

   129

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

   130

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

   131

        )

   132

{

   133

    if (source) {

   134

        strncpy(target, source, EC_IOCTL_STRING_SIZE);

   135

        target[EC_IOCTL_STRING_SIZE - 1] = 0;

   136

    } else {

   137

        target[0] = 0;

   138

    }

   139

}

   140

   141

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

   142

   143

/** Get master information.

   144

 */

   145

int ec_cdev_ioctl_master(

   146

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

   147

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

   148

        )

   149

{

   150

    ec_ioctl_master_t data;

   151

   152

    if (down_interruptible(&master->master_sem))

   153

        return -EINTR;

   154

    data.slave_count = master->slave_count;

   155

    data.config_count = ec_master_config_count(master);

   156

    data.domain_count = ec_master_domain_count(master);

   157

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

   158

    up(&master->master_sem);

   159

   160

    if (down_interruptible(&master->device_sem))

   161

        return -EINTR;

   162

    if (master->main_device.dev) {

   163

        memcpy(data.devices[0].address,

   164

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

   165

    } else {

   166

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

   167

    }

   168

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

   169

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

   170

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

   171

   172

    if (master->backup_device.dev) {

   173

        memcpy(data.devices[1].address,

   174

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

   175

    } else {

   176

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

   177

    }

   178

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

   179

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

   180

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

   181

    up(&master->device_sem);

   182

   183

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

   184

        return -EFAULT;

   185

   186

    return 0;

   187

}

   188

   189

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

   190

   191

/** Get slave information.

   192

 */

   193

int ec_cdev_ioctl_slave(

   194

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

   195

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

   196

        )

   197

{

   198

    ec_ioctl_slave_t data;

   199

    const ec_slave_t *slave;

   200

   201

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

   202

        return -EFAULT;

   203

    }

   204

   205

    if (down_interruptible(&master->master_sem))

   206

        return -EINTR;

   207

   208

    if (!(slave = ec_master_find_slave_const(

   209

                    master, 0, data.position))) {

   210

        up(&master->master_sem);

   211

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

   212

        return -EINVAL;

   213

    }

   214

   215

    data.vendor_id = slave->sii.vendor_id;

   216

    data.product_code = slave->sii.product_code;

   217

    data.revision_number = slave->sii.revision_number;

   218

    data.serial_number = slave->sii.serial_number;

   219

    data.alias = slave->sii.alias;

   220

    data.rx_mailbox_offset = slave->sii.rx_mailbox_offset;

   221

    data.rx_mailbox_size = slave->sii.rx_mailbox_size;

   222

    data.tx_mailbox_offset = slave->sii.tx_mailbox_offset;

   223

    data.tx_mailbox_size = slave->sii.tx_mailbox_size;

   224

    data.mailbox_protocols = slave->sii.mailbox_protocols;

   225

    data.has_general_category = slave->sii.has_general;

   226

    data.coe_details = slave->sii.coe_details;

   227

    data.general_flags = slave->sii.general_flags;

   228

    data.current_on_ebus = slave->sii.current_on_ebus;

   229

    data.al_state = slave->current_state;

   230

    data.error_flag = slave->error_flag;

   231

   232

    data.sync_count = slave->sii.sync_count;

   233

    data.sdo_count = ec_slave_sdo_count(slave);

   234

    data.sii_nwords = slave->sii_nwords;

   235

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

   236

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

   237

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

   238

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

   239

   240

    up(&master->master_sem);

   241

   242

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

   243

        return -EFAULT;

   244

   245

    return 0;

   246

}

   247

   248

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

   249

   250

/** Get slave sync manager information.

   251

 */

   252

int ec_cdev_ioctl_slave_sync(

   253

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

   254

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

   255

        )

   256

{

   257

    ec_ioctl_slave_sync_t data;

   258

    const ec_slave_t *slave;

   259

    const ec_sync_t *sync;

   260

   261

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

   262

        return -EFAULT;

   263

    }

   264

   265

    if (down_interruptible(&master->master_sem))

   266

        return -EINTR;

   267

   268

    if (!(slave = ec_master_find_slave_const(

   269

                    master, 0, data.slave_position))) {

   270

        up(&master->master_sem);

   271

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

   272

        return -EINVAL;

   273

    }

   274

   275

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

   276

        up(&master->master_sem);

   277

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

   278

                data.sync_index, data.slave_position);

   279

        return -EINVAL;

   280

    }

   281

   282

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

   283

   284

    data.physical_start_address = sync->physical_start_address;

   285

    data.default_size = sync->default_length;

   286

    data.control_register = sync->control_register;

   287

    data.enable = sync->enable;

   288

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

   289

   290

    up(&master->master_sem);

   291

   292

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

   293

        return -EFAULT;

   294

   295

    return 0;

   296

}

   297

   298

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

   299

   300

/** Get slave sync manager Pdo information.

   301

 */

   302

int ec_cdev_ioctl_slave_sync_pdo(

   303

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

   304

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

   305

        )

   306

{

   307

    ec_ioctl_slave_sync_pdo_t data;

   308

    const ec_slave_t *slave;

   309

    const ec_sync_t *sync;

   310

    const ec_pdo_t *pdo;

   311

   312

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

   313

        return -EFAULT;

   314

    }

   315

   316

    if (down_interruptible(&master->master_sem))

   317

        return -EINTR;

   318

   319

    if (!(slave = ec_master_find_slave_const(

   320

                    master, 0, data.slave_position))) {

   321

        up(&master->master_sem);

   322

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

   323

        return -EINVAL;

   324

    }

   325

   326

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

   327

        up(&master->master_sem);

   328

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

   329

                data.sync_index, data.slave_position);

   330

        return -EINVAL;

   331

    }

   332

   333

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

   334

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   335

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

   336

        up(&master->master_sem);

   337

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

   338

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

   339

                data.pdo_pos, data.slave_position);

   340

        return -EINVAL;

   341

    }

   342

   343

    data.index = pdo->index;

   344

    data.entry_count = ec_pdo_entry_count(pdo);

   345

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

   346

   347

    up(&master->master_sem);

   348

   349

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

   350

        return -EFAULT;

   351

   352

    return 0;

   353

}

   354

   355

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

   356

   357

/** Get slave sync manager Pdo entry information.

   358

 */

   359

int ec_cdev_ioctl_slave_sync_pdo_entry(

   360

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

   361

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

   362

        )

   363

{

   364

    ec_ioctl_slave_sync_pdo_entry_t data;

   365

    const ec_slave_t *slave;

   366

    const ec_sync_t *sync;

   367

    const ec_pdo_t *pdo;

   368

    const ec_pdo_entry_t *entry;

   369

   370

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

   371

        return -EFAULT;

   372

    }

   373

   374

    if (down_interruptible(&master->master_sem))

   375

        return -EINTR;

   376

   377

    if (!(slave = ec_master_find_slave_const(

   378

                    master, 0, data.slave_position))) {

   379

        up(&master->master_sem);

   380

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

   381

        return -EINVAL;

   382

    }

   383

   384

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

   385

        up(&master->master_sem);

   386

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

   387

                data.sync_index, data.slave_position);

   388

        return -EINVAL;

   389

    }

   390

   391

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

   392

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   393

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

   394

        up(&master->master_sem);

   395

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

   396

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

   397

                data.pdo_pos, data.slave_position);

   398

        return -EINVAL;

   399

    }

   400

   401

    if (!(entry = ec_pdo_find_entry_by_pos_const(

   402

                    pdo, data.entry_pos))) {

   403

        up(&master->master_sem);

   404

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

   405

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

   406

                data.entry_pos, data.slave_position);

   407

        return -EINVAL;

   408

    }

   409

   410

    data.index = entry->index;

   411

    data.subindex = entry->subindex;

   412

    data.bit_length = entry->bit_length;

   413

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

   414

   415

    up(&master->master_sem);

   416

   417

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

   418

        return -EFAULT;

   419

   420

    return 0;

   421

}

   422

   423

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

   424

   425

/** Get domain information.

   426

 */

   427

int ec_cdev_ioctl_domain(

   428

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

   429

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

   430

        )

   431

{

   432

    ec_ioctl_domain_t data;

   433

    const ec_domain_t *domain;

   434

   435

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

   436

        return -EFAULT;

   437

    }

   438

   439

    if (down_interruptible(&master->master_sem))

   440

        return -EINTR;

   441

   442

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

   443

        up(&master->master_sem);

   444

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

   445

        return -EINVAL;

   446

    }

   447

   448

    data.data_size = domain->data_size;

   449

    data.logical_base_address = domain->logical_base_address;

   450

    data.working_counter = domain->working_counter;

   451

    data.expected_working_counter = domain->expected_working_counter;

   452

    data.fmmu_count = ec_domain_fmmu_count(domain);

   453

   454

    up(&master->master_sem);

   455

   456

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

   457

        return -EFAULT;

   458

   459

    return 0;

   460

}

   461

   462

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

   463

   464

/** Get domain FMMU information.

   465

 */

   466

int ec_cdev_ioctl_domain_fmmu(

   467

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

   468

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

   469

        )

   470

{

   471

    ec_ioctl_domain_fmmu_t data;

   472

    const ec_domain_t *domain;

   473

    const ec_fmmu_config_t *fmmu;

   474

   475

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

   476

        return -EFAULT;

   477

    }

   478

   479

    if (down_interruptible(&master->master_sem))

   480

        return -EINTR;

   481

   482

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

   483

        up(&master->master_sem);

   484

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

   485

        return -EINVAL;

   486

    }

   487

   488

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

   489

        up(&master->master_sem);

   490

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

   491

                data.domain_index, data.fmmu_index + 1);

   492

        return -EINVAL;

   493

    }

   494

   495

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

   496

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

   497

    data.sync_index = fmmu->sync_index;

   498

    data.dir = fmmu->dir;

   499

    data.logical_address = fmmu->logical_start_address;

   500