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 "voe_handler.h"

    49

#include "ioctl.h"

    50

    51

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

    52

    53

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

    54

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

    55

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

    56

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

    57

    58

/** This is the kernel version from which the .fault member of the

    59

 * vm_operations_struct is usable.

    60

 */

    61

#define PAGE_FAULT_VERSION KERNEL_VERSION(2, 6, 23)

    62

    63

#if LINUX_VERSION_CODE >= PAGE_FAULT_VERSION

    64

static int eccdev_vma_fault(struct vm_area_struct *, struct vm_fault *);

    65

#else

    66

static struct page *eccdev_vma_nopage(

    67

        struct vm_area_struct *, unsigned long, int *);

    68

#endif

    69

    70

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

    71

    72

/** File operation callbacks for the EtherCAT character device.

    73

 */

    74

static struct file_operations eccdev_fops = {

    75

    .owner          = THIS_MODULE,

    76

    .open           = eccdev_open,

    77

    .release        = eccdev_release,

    78

    .unlocked_ioctl = eccdev_ioctl,

    79

    .mmap           = eccdev_mmap

    80

};

    81

    82

/** Callbacks for a virtual memory area retrieved with ecdevc_mmap().

    83

 */

    84

struct vm_operations_struct eccdev_vm_ops = {

    85

#if LINUX_VERSION_CODE >= PAGE_FAULT_VERSION

    86

    .fault = eccdev_vma_fault

    87

#else

    88

    .nopage = eccdev_vma_nopage

    89

#endif

    90

};

    91

    92

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

    93

    94

/** Private data structure for file handles.

    95

 */

    96

typedef struct {

    97

    ec_cdev_t *cdev; /**< Character device. */

    98

    unsigned int requested; /**< Master wac requested via this file handle. */

    99

    uint8_t *process_data; /**< Total process data area. */

   100

    size_t process_data_size; /**< Size of the \a process_data. */

   101

} ec_cdev_priv_t;

   102

   103

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

   104

   105

/** Constructor.

   106

 * 

   107

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

   108

 */

   109

int ec_cdev_init(

   110

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

   111

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

   112

		dev_t dev_num /**< Device number. */

   113

		)

   114

{

   115

    cdev->master = master;

   116

   117

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

   118

    cdev->cdev.owner = THIS_MODULE;

   119

   120

    if (cdev_add(&cdev->cdev,

   121

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

   122

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

   123

		return -1;

   124

    }

   125

   126

    return 0;

   127

}

   128

   129

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

   130

   131

/** Destructor.

   132

 */

   133

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

   134

{

   135

    cdev_del(&cdev->cdev);

   136

}

   137

   138

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

   139

   140

/** Copies a string to an ioctl structure.

   141

 */

   142

void ec_cdev_strcpy(

   143

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

   144

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

   145

        )

   146

{

   147

    if (source) {

   148

        strncpy(target, source, EC_IOCTL_STRING_SIZE);

   149

        target[EC_IOCTL_STRING_SIZE - 1] = 0;

   150

    } else {

   151

        target[0] = 0;

   152

    }

   153

}

   154

   155

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

   156

   157

/** Get master information.

   158

 */

   159

int ec_cdev_ioctl_master(

   160

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

   161

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

   162

        )

   163

{

   164

    ec_ioctl_master_t data;

   165

   166

    if (down_interruptible(&master->master_sem))

   167

        return -EINTR;

   168

    data.slave_count = master->slave_count;

   169

    data.config_count = ec_master_config_count(master);

   170

    data.domain_count = ec_master_domain_count(master);

   171

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

   172

    up(&master->master_sem);

   173

   174

    if (down_interruptible(&master->device_sem))

   175

        return -EINTR;

   176

    if (master->main_device.dev) {

   177

        memcpy(data.devices[0].address,

   178

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

   179

    } else {

   180

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

   181

    }

   182

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

   183

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

   184

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

   185

   186

    if (master->backup_device.dev) {

   187

        memcpy(data.devices[1].address,

   188

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

   189

    } else {

   190

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

   191

    }

   192

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

   193

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

   194

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

   195

    up(&master->device_sem);

   196

   197

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

   198

        return -EFAULT;

   199

   200

    return 0;

   201

}

   202

   203

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

   204

   205

/** Get slave information.

   206

 */

   207

int ec_cdev_ioctl_slave(

   208

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

   209

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

   210

        )

   211

{

   212

    ec_ioctl_slave_t data;

   213

    const ec_slave_t *slave;

   214

   215

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

   216

        return -EFAULT;

   217

    }

   218

   219

    if (down_interruptible(&master->master_sem))

   220

        return -EINTR;

   221

   222

    if (!(slave = ec_master_find_slave_const(

   223

                    master, 0, data.position))) {

   224

        up(&master->master_sem);

   225

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

   226

        return -EINVAL;

   227

    }

   228

   229

    data.vendor_id = slave->sii.vendor_id;

   230

    data.product_code = slave->sii.product_code;

   231

    data.revision_number = slave->sii.revision_number;

   232

    data.serial_number = slave->sii.serial_number;

   233

    data.alias = slave->sii.alias;

   234

    data.rx_mailbox_offset = slave->sii.rx_mailbox_offset;

   235

    data.rx_mailbox_size = slave->sii.rx_mailbox_size;

   236

    data.tx_mailbox_offset = slave->sii.tx_mailbox_offset;

   237

    data.tx_mailbox_size = slave->sii.tx_mailbox_size;

   238

    data.mailbox_protocols = slave->sii.mailbox_protocols;

   239

    data.has_general_category = slave->sii.has_general;

   240

    data.coe_details = slave->sii.coe_details;

   241

    data.general_flags = slave->sii.general_flags;

   242

    data.current_on_ebus = slave->sii.current_on_ebus;

   243

    data.al_state = slave->current_state;

   244

    data.error_flag = slave->error_flag;

   245

   246

    data.sync_count = slave->sii.sync_count;

   247

    data.sdo_count = ec_slave_sdo_count(slave);

   248

    data.sii_nwords = slave->sii_nwords;

   249

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

   250

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

   251

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

   252

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

   253

   254

    up(&master->master_sem);

   255

   256

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

   257

        return -EFAULT;

   258

   259

    return 0;

   260

}

   261

   262

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

   263

   264

/** Get slave sync manager information.

   265

 */

   266

int ec_cdev_ioctl_slave_sync(

   267

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

   268

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

   269

        )

   270

{

   271

    ec_ioctl_slave_sync_t data;

   272

    const ec_slave_t *slave;

   273

    const ec_sync_t *sync;

   274

   275

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

   276

        return -EFAULT;

   277

    }

   278

   279

    if (down_interruptible(&master->master_sem))

   280

        return -EINTR;

   281

   282

    if (!(slave = ec_master_find_slave_const(

   283

                    master, 0, data.slave_position))) {

   284

        up(&master->master_sem);

   285

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

   286

        return -EINVAL;

   287

    }

   288

   289

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

   290

        up(&master->master_sem);

   291

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

   292

                data.sync_index, data.slave_position);

   293

        return -EINVAL;

   294

    }

   295

   296

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

   297

   298

    data.physical_start_address = sync->physical_start_address;

   299

    data.default_size = sync->default_length;

   300

    data.control_register = sync->control_register;

   301

    data.enable = sync->enable;

   302

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

   303

   304

    up(&master->master_sem);

   305

   306

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

   307

        return -EFAULT;

   308

   309

    return 0;

   310

}

   311

   312

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

   313

   314

/** Get slave sync manager Pdo information.

   315

 */

   316

int ec_cdev_ioctl_slave_sync_pdo(

   317

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

   318

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

   319

        )

   320

{

   321

    ec_ioctl_slave_sync_pdo_t data;

   322

    const ec_slave_t *slave;

   323

    const ec_sync_t *sync;

   324

    const ec_pdo_t *pdo;

   325

   326

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

   327

        return -EFAULT;

   328

    }

   329

   330

    if (down_interruptible(&master->master_sem))

   331

        return -EINTR;

   332

   333

    if (!(slave = ec_master_find_slave_const(

   334

                    master, 0, data.slave_position))) {

   335

        up(&master->master_sem);

   336

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

   337

        return -EINVAL;

   338

    }

   339

   340

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

   341

        up(&master->master_sem);

   342

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

   343

                data.sync_index, data.slave_position);

   344

        return -EINVAL;

   345

    }

   346

   347

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

   348

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   349

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

   350

        up(&master->master_sem);

   351

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

   352

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

   353

                data.pdo_pos, data.slave_position);

   354

        return -EINVAL;

   355

    }

   356

   357

    data.index = pdo->index;

   358

    data.entry_count = ec_pdo_entry_count(pdo);

   359

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

   360

   361

    up(&master->master_sem);

   362

   363

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

   364

        return -EFAULT;

   365

   366

    return 0;

   367

}

   368

   369

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

   370

   371

/** Get slave sync manager Pdo entry information.

   372

 */

   373

int ec_cdev_ioctl_slave_sync_pdo_entry(

   374

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

   375

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

   376

        )

   377

{

   378

    ec_ioctl_slave_sync_pdo_entry_t data;

   379

    const ec_slave_t *slave;

   380

    const ec_sync_t *sync;

   381

    const ec_pdo_t *pdo;

   382

    const ec_pdo_entry_t *entry;

   383

   384

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

   385

        return -EFAULT;

   386

    }

   387

   388

    if (down_interruptible(&master->master_sem))

   389

        return -EINTR;

   390

   391

    if (!(slave = ec_master_find_slave_const(

   392

                    master, 0, data.slave_position))) {

   393

        up(&master->master_sem);

   394

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

   395

        return -EINVAL;

   396

    }

   397

   398

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

   399

        up(&master->master_sem);

   400

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

   401

                data.sync_index, data.slave_position);

   402

        return -EINVAL;

   403

    }

   404

   405

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

   406

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   407

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

   408

        up(&master->master_sem);

   409

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

   410

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

   411

                data.pdo_pos, data.slave_position);

   412

        return -EINVAL;

   413

    }

   414

   415

    if (!(entry = ec_pdo_find_entry_by_pos_const(

   416

                    pdo, data.entry_pos))) {

   417

        up(&master->master_sem);

   418

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

   419

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

   420

                data.entry_pos, data.slave_position);

   421

        return -EINVAL;

   422

    }

   423

   424

    data.index = entry->index;

   425

    data.subindex = entry->subindex;

   426

    data.bit_length = entry->bit_length;

   427

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

   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 information.

   440

 */

   441

int ec_cdev_ioctl_domain(

   442

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

   443

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

   444

        )

   445

{

   446

    ec_ioctl_domain_t data;

   447

    const ec_domain_t *domain;

   448

   449

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

   450

        return -EFAULT;

   451

    }

   452

   453

    if (down_interruptible(&master->master_sem))

   454

        return -EINTR;

   455

   456

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

   457

        up(&master->master_sem);

   458

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

   459

        return -EINVAL;

   460

    }

   461

   462

    data.data_size = domain->data_size;

   463

    data.logical_base_address = domain->logical_base_address;

   464

    data.working_counter = domain->working_counter;

   465

    data.expected_working_counter = domain->expected_working_counter;

   466

    data.fmmu_count = ec_domain_fmmu_count(domain);

   467

   468

    up(&master->master_sem);

   469

   470

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

   471

        return -EFAULT;

   472

   473

    return 0;

   474

}

   475

   476

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

   477

   478

/** Get domain FMMU information.

   479

 */

   480

int ec_cdev_ioctl_domain_fmmu(

   481

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

   482

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

   483

        )

   484

{

   485

    ec_ioctl_domain_fmmu_t data;

   486

    const ec_domain_t *domain;

   487

    const ec_fmmu_config_t *fmmu;

   488

   489

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

   490

        return -EFAULT;

   491

    }

   492

   493

    if (down_interruptible(&master->master_sem))

   494

        return -EINTR;

   495

   496

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

   497

        up(&master->master_sem);

   498

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