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

 *  ---

    23

 *

    24

 *  The license mentioned above concerns the source code only. Using the

    25

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

    26

 *  industrial property and similar rights of Beckhoff Automation GmbH.

    27

 *

    28

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

    29

    30

/**

    31

   \file

    32

   EtherCAT master character device.

    33

*/

    34

    35

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

    36

    37

#include <linux/module.h>

    38

#include <linux/vmalloc.h>

    39

#include <linux/mm.h>

    40

    41

#include "cdev.h"

    42

#include "master.h"

    43

#include "slave_config.h"

    44

#include "voe_handler.h"

    45

#include "ioctl.h"

    46

    47

#define DEBUG_IOCTL 0

    48

    49

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

    50

    51

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

    52

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

    53

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

    54

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

    55

    56

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

    57

 * vm_operations_struct is usable.

    58

 */

    59

#define PAGE_FAULT_VERSION KERNEL_VERSION(2, 6, 23)

    60

    61

#if LINUX_VERSION_CODE >= PAGE_FAULT_VERSION

    62

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

    63

#else

    64

static struct page *eccdev_vma_nopage(

    65

        struct vm_area_struct *, unsigned long, int *);

    66

#endif

    67

    68

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

    69

    70

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

    71

 */

    72

static struct file_operations eccdev_fops = {

    73

    .owner          = THIS_MODULE,

    74

    .open           = eccdev_open,

    75

    .release        = eccdev_release,

    76

    .unlocked_ioctl = eccdev_ioctl,

    77

    .mmap           = eccdev_mmap

    78

};

    79

    80

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

    81

 */

    82

struct vm_operations_struct eccdev_vm_ops = {

    83

#if LINUX_VERSION_CODE >= PAGE_FAULT_VERSION

    84

    .fault = eccdev_vma_fault

    85

#else

    86

    .nopage = eccdev_vma_nopage

    87

#endif

    88

};

    89

    90

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

    91

    92

/** Private data structure for file handles.

    93

 */

    94

typedef struct {

    95

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

    96

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

    97

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

    98

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

    99

} ec_cdev_priv_t;

   100

   101

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

   102

   103

/** Constructor.

   104

 * 

   105

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

   106

 */

   107

int ec_cdev_init(

   108

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

   109

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

   110

		dev_t dev_num /**< Device number. */

   111

		)

   112

{

   113

    int ret;

   114

   115

    cdev->master = master;

   116

   117

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

   118

    cdev->cdev.owner = THIS_MODULE;

   119

   120

    ret = cdev_add(&cdev->cdev,

   121

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

   122

    if (ret) {

   123

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

   124

    }

   125

   126

    return ret;

   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

   177

    if (master->main_device.dev) {

   178

        memcpy(data.devices[0].address,

   179

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

   180

    } else {

   181

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

   182

    }

   183

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

   184

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

   185

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

   186

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

   187

   188

    if (master->backup_device.dev) {

   189

        memcpy(data.devices[1].address,

   190

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

   191

    } else {

   192

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

   193

    }

   194

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

   195

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

   196

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

   197

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

   198

   199

    up(&master->device_sem);

   200

   201

    data.app_time = master->app_time;

   202

    data.ref_clock = EC_READ_U16(master->sync_datagram.address);

   203

    if (data.ref_clock < 0xffff) {

   204

        // ref_clock address is station_address, output ring position

   205

        data.ref_clock--;

   206

    }

   207

   208

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

   209

        return -EFAULT;

   210

   211

    return 0;

   212

}

   213

   214

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

   215

   216

/** Get slave information.

   217

 */

   218

int ec_cdev_ioctl_slave(

   219

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

   220

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

   221

        )

   222

{

   223

    ec_ioctl_slave_t data;

   224

    const ec_slave_t *slave;

   225

    int i;

   226

   227

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

   228

        return -EFAULT;

   229

    }

   230

   231

    if (down_interruptible(&master->master_sem))

   232

        return -EINTR;

   233

   234

    if (!(slave = ec_master_find_slave_const(

   235

                    master, 0, data.position))) {

   236

        up(&master->master_sem);

   237

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

   238

        return -EINVAL;

   239

    }

   240

   241

    data.vendor_id = slave->sii.vendor_id;

   242

    data.product_code = slave->sii.product_code;

   243

    data.revision_number = slave->sii.revision_number;

   244

    data.serial_number = slave->sii.serial_number;

   245

    data.alias = slave->sii.alias;

   246

    data.boot_rx_mailbox_offset = slave->sii.boot_rx_mailbox_offset;

   247

    data.boot_rx_mailbox_size = slave->sii.boot_rx_mailbox_size;

   248

    data.boot_tx_mailbox_offset = slave->sii.boot_tx_mailbox_offset;

   249

    data.boot_tx_mailbox_size = slave->sii.boot_tx_mailbox_size;

   250

    data.std_rx_mailbox_offset = slave->sii.std_rx_mailbox_offset;

   251

    data.std_rx_mailbox_size = slave->sii.std_rx_mailbox_size;

   252

    data.std_tx_mailbox_offset = slave->sii.std_tx_mailbox_offset;

   253

    data.std_tx_mailbox_size = slave->sii.std_tx_mailbox_size;

   254

    data.mailbox_protocols = slave->sii.mailbox_protocols;

   255

    data.has_general_category = slave->sii.has_general;

   256

    data.coe_details = slave->sii.coe_details;

   257

    data.general_flags = slave->sii.general_flags;

   258

    data.current_on_ebus = slave->sii.current_on_ebus;

   259

    for (i = 0; i < EC_MAX_PORTS; i++) {

   265

    }

   266

    data.fmmu_bit = slave->base_fmmu_bit_operation;

   267

    data.dc_supported = slave->base_dc_supported;

   268

    data.dc_range = slave->base_dc_range;

   269

    data.has_dc_system_time = slave->has_dc_system_time;

   270

    data.al_state = slave->current_state;

   271

    data.error_flag = slave->error_flag;

   272

   273

    data.sync_count = slave->sii.sync_count;

   274

    data.sdo_count = ec_slave_sdo_count(slave);

   275

    data.sii_nwords = slave->sii_nwords;

   276

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

   277

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

   278

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

   279

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

   280

   281

    up(&master->master_sem);

   282

   283

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

   284

        return -EFAULT;

   285

   286

    return 0;

   287

}

   288

   289

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

   290

   291

/** Get slave sync manager information.

   292

 */

   293

int ec_cdev_ioctl_slave_sync(

   294

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

   295

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

   296

        )

   297

{

   298

    ec_ioctl_slave_sync_t data;

   299

    const ec_slave_t *slave;

   300

    const ec_sync_t *sync;

   301

   302

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

   303

        return -EFAULT;

   304

    }

   305

   306

    if (down_interruptible(&master->master_sem))

   307

        return -EINTR;

   308

   309

    if (!(slave = ec_master_find_slave_const(

   310

                    master, 0, data.slave_position))) {

   311

        up(&master->master_sem);

   312

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

   313

        return -EINVAL;

   314

    }

   315

   316

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

   317

        up(&master->master_sem);

   318

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

   319

                data.sync_index, data.slave_position);

   320

        return -EINVAL;

   321

    }

   322

   323

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

   324

   325

    data.physical_start_address = sync->physical_start_address;

   326

    data.default_size = sync->default_length;

   327

    data.control_register = sync->control_register;

   328

    data.enable = sync->enable;

   329

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

   330

   331

    up(&master->master_sem);

   332

   333

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

   334

        return -EFAULT;

   335

   336

    return 0;

   337

}

   338

   339

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

   340

   341

/** Get slave sync manager PDO information.

   342

 */

   343

int ec_cdev_ioctl_slave_sync_pdo(

   344

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

   345

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

   346

        )

   347

{

   348

    ec_ioctl_slave_sync_pdo_t data;

   349

    const ec_slave_t *slave;

   350

    const ec_sync_t *sync;

   351

    const ec_pdo_t *pdo;

   352

   353

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

   354

        return -EFAULT;

   355

    }

   356

   357

    if (down_interruptible(&master->master_sem))

   358

        return -EINTR;

   359

   360

    if (!(slave = ec_master_find_slave_const(

   361

                    master, 0, data.slave_position))) {

   362

        up(&master->master_sem);

   363

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

   364

        return -EINVAL;

   365

    }

   366

   367

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

   368

        up(&master->master_sem);

   369

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

   370

                data.sync_index, data.slave_position);

   371

        return -EINVAL;

   372

    }

   373

   374

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

   375

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   376

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

   377

        up(&master->master_sem);

   378

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

   379

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

   380

                data.pdo_pos, data.slave_position);

   381

        return -EINVAL;

   382

    }

   383

   384

    data.index = pdo->index;

   385

    data.entry_count = ec_pdo_entry_count(pdo);

   386

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

   387

   388

    up(&master->master_sem);

   389

   390

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

   391

        return -EFAULT;

   392

   393

    return 0;

   394

}

   395

   396

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

   397

   398

/** Get slave sync manager PDO entry information.

   399

 */

   400

int ec_cdev_ioctl_slave_sync_pdo_entry(

   401

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

   402

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

   403

        )

   404

{

   405

    ec_ioctl_slave_sync_pdo_entry_t data;

   406

    const ec_slave_t *slave;

   407

    const ec_sync_t *sync;

   408

    const ec_pdo_t *pdo;

   409

    const ec_pdo_entry_t *entry;

   410

   411

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

   412

        return -EFAULT;

   413

    }

   414

   415

    if (down_interruptible(&master->master_sem))

   416

        return -EINTR;

   417

   418

    if (!(slave = ec_master_find_slave_const(

   419

                    master, 0, data.slave_position))) {

   420

        up(&master->master_sem);

   421

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

   422

        return -EINVAL;

   423

    }

   424

   425

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

   426

        up(&master->master_sem);

   427

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

   428

                data.sync_index, data.slave_position);

   429

        return -EINVAL;

   430

    }

   431

   432

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

   433

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   434

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

   435

        up(&master->master_sem);

   436

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

   437

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

   438

                data.pdo_pos, data.slave_position);

   439

        return -EINVAL;

   440

    }

   441

   442

    if (!(entry = ec_pdo_find_entry_by_pos_const(

   443

                    pdo, data.entry_pos))) {

   444

        up(&master->master_sem);

   445

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

   446

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

   447

                data.entry_pos, data.slave_position);

   448

        return -EINVAL;

   449

    }

   450

   451

    data.index = entry->index;

   452

    data.subindex = entry->subindex;

   453

    data.bit_length = entry->bit_length;

   454

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

   455

   456

    up(&master->master_sem);

   457

   458

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

   459

        return -EFAULT;

   460

   461

    return 0;

   462

}

   463

   464

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

   465

   466

/** Get domain information.

   467

 */

   468

int ec_cdev_ioctl_domain(

   469

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

   470

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

   471

        )

   472

{

   473

    ec_ioctl_domain_t data;

   474

    const ec_domain_t *domain;

   475

   476

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

   477

        return -EFAULT;

   478

    }

   479

   480

    if (down_interruptible(&master->master_sem))

   481

        return -EINTR;

   482

   483

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

   484

        up(&master->master_sem);

   485

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

   486

        return -EINVAL;

   487

    }

   488

   489

    data.data_size = domain->data_size;

   490

    data.logical_base_address = domain->logical_base_address;

   491

    data.working_counter = domain->working_counter;

   492

    data.expected_working_counter = domain->expected_working_counter;

   493

    data.fmmu_count = ec_domain_fmmu_count(domain);

   494