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

#include <linux/vmalloc.h>

    36

#include <linux/mm.h>

    37

    38

#include "cdev.h"

    39

#include "master.h"

    40

#include "slave_config.h"

    41

#include "voe_handler.h"

    42

#include "ioctl.h"

    43

    44

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

    45

    46

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

    47

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

    48

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

    49

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

    50

    51

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

    52

 * vm_operations_struct is usable.

    53

 */

    54

#define PAGE_FAULT_VERSION KERNEL_VERSION(2, 6, 23)

    55

    56

#if LINUX_VERSION_CODE >= PAGE_FAULT_VERSION

    57

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

    58

#else

    59

static struct page *eccdev_vma_nopage(

    60

        struct vm_area_struct *, unsigned long, int *);

    61

#endif

    62

    63

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

    64

    65

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

    66

 */

    67

static struct file_operations eccdev_fops = {

    68

    .owner          = THIS_MODULE,

    69

    .open           = eccdev_open,

    70

    .release        = eccdev_release,

    71

    .unlocked_ioctl = eccdev_ioctl,

    72

    .mmap           = eccdev_mmap

    73

};

    74

    75

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

    76

 */

    77

struct vm_operations_struct eccdev_vm_ops = {

    78

#if LINUX_VERSION_CODE >= PAGE_FAULT_VERSION

    79

    .fault = eccdev_vma_fault

    80

#else

    81

    .nopage = eccdev_vma_nopage

    82

#endif

    83

};

    84

    85

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

    86

    87

/** Private data structure for file handles.

    88

 */

    89

typedef struct {

    90

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

    91

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

    92

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

    93

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

    94

} ec_cdev_priv_t;

    95

    96

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

    97

    98

/** Constructor.

    99

 * 

   100

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

   101

 */

   102

int ec_cdev_init(

   103

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

   104

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

   105

		dev_t dev_num /**< Device number. */

   106

		)

   107

{

   108

    int ret;

   109

   110

    cdev->master = master;

   111

   112

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

   113

    cdev->cdev.owner = THIS_MODULE;

   114

   115

    ret = cdev_add(&cdev->cdev,

   116

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

   117

    if (ret) {

   118

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

   119

    }

   120

   121

    return ret;

   122

}

   123

   124

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

   125

   126

/** Destructor.

   127

 */

   128

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

   129

{

   130

    cdev_del(&cdev->cdev);

   131

}

   132

   133

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

   134

   135

/** Copies a string to an ioctl structure.

   136

 */

   137

void ec_cdev_strcpy(

   138

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

   139

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

   140

        )

   141

{

   142

    if (source) {

   143

        strncpy(target, source, EC_IOCTL_STRING_SIZE);

   144

        target[EC_IOCTL_STRING_SIZE - 1] = 0;

   145

    } else {

   146

        target[0] = 0;

   147

    }

   148

}

   149

   150

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

   151

   152

/** Get master information.

   153

 */

   154

int ec_cdev_ioctl_master(

   155

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

   156

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

   157

        )

   158

{

   159

    ec_ioctl_master_t data;

   160

   161

    if (down_interruptible(&master->master_sem))

   162

        return -EINTR;

   163

    data.slave_count = master->slave_count;

   164

    data.config_count = ec_master_config_count(master);

   165

    data.domain_count = ec_master_domain_count(master);

   166

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

   167

    up(&master->master_sem);

   168

   169

    if (down_interruptible(&master->device_sem))

   170

        return -EINTR;

   171

    if (master->main_device.dev) {

   172

        memcpy(data.devices[0].address,

   173

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

   174

    } else {

   175

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

   176

    }

   177

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

   178

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

   179

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

   180

   181

    if (master->backup_device.dev) {

   182

        memcpy(data.devices[1].address,

   183

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

   184

    } else {

   185

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

   186

    }

   187

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

   188

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

   189

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

   190

    up(&master->device_sem);

   191

   192

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

   193

        return -EFAULT;

   194

   195

    return 0;

   196

}

   197

   198

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

   199

   200

/** Get slave information.

   201

 */

   202

int ec_cdev_ioctl_slave(

   203

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

   204

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

   205

        )

   206

{

   207

    ec_ioctl_slave_t data;

   208

    const ec_slave_t *slave;

   209

   210

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

   211

        return -EFAULT;

   212

    }

   213

   214

    if (down_interruptible(&master->master_sem))

   215

        return -EINTR;

   216

   217

    if (!(slave = ec_master_find_slave_const(

   218

                    master, 0, data.position))) {

   219

        up(&master->master_sem);

   220

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

   221

        return -EINVAL;

   222

    }

   223

   224

    data.vendor_id = slave->sii.vendor_id;

   225

    data.product_code = slave->sii.product_code;

   226

    data.revision_number = slave->sii.revision_number;

   227

    data.serial_number = slave->sii.serial_number;

   228

    data.alias = slave->sii.alias;

   229

    data.boot_rx_mailbox_offset = slave->sii.boot_rx_mailbox_offset;

   230

    data.boot_rx_mailbox_size = slave->sii.boot_rx_mailbox_size;

   231

    data.boot_tx_mailbox_offset = slave->sii.boot_tx_mailbox_offset;

   232

    data.boot_tx_mailbox_size = slave->sii.boot_tx_mailbox_size;

   233

    data.std_rx_mailbox_offset = slave->sii.std_rx_mailbox_offset;

   234

    data.std_rx_mailbox_size = slave->sii.std_rx_mailbox_size;

   235

    data.std_tx_mailbox_offset = slave->sii.std_tx_mailbox_offset;

   236

    data.std_tx_mailbox_size = slave->sii.std_tx_mailbox_size;

   237

    data.mailbox_protocols = slave->sii.mailbox_protocols;

   238

    data.has_general_category = slave->sii.has_general;

   239

    data.coe_details = slave->sii.coe_details;

   240

    data.general_flags = slave->sii.general_flags;

   241

    data.current_on_ebus = slave->sii.current_on_ebus;

   242

    data.al_state = slave->current_state;

   243

    data.error_flag = slave->error_flag;

   244

   245

    data.sync_count = slave->sii.sync_count;

   246

    data.sdo_count = ec_slave_sdo_count(slave);

   247

    data.sii_nwords = slave->sii_nwords;

   248

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

   249

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

   250

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

   251

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

   252

   253

    up(&master->master_sem);

   254

   255

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

   256

        return -EFAULT;

   257

   258

    return 0;

   259

}

   260

   261

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

   262

   263

/** Get slave sync manager information.

   264

 */

   265

int ec_cdev_ioctl_slave_sync(

   266

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

   267

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

   268

        )

   269

{

   270

    ec_ioctl_slave_sync_t data;

   271

    const ec_slave_t *slave;

   272

    const ec_sync_t *sync;

   273

   274

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

   275

        return -EFAULT;

   276

    }

   277

   278

    if (down_interruptible(&master->master_sem))

   279

        return -EINTR;

   280

   281

    if (!(slave = ec_master_find_slave_const(

   282

                    master, 0, data.slave_position))) {

   283

        up(&master->master_sem);

   284

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

   285

        return -EINVAL;

   286

    }

   287

   288

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

   289

        up(&master->master_sem);

   290

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

   291

                data.sync_index, data.slave_position);

   292

        return -EINVAL;

   293

    }

   294

   295

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

   296

   297

    data.physical_start_address = sync->physical_start_address;

   298

    data.default_size = sync->default_length;

   299

    data.control_register = sync->control_register;

   300

    data.enable = sync->enable;

   301

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

   302

   303

    up(&master->master_sem);

   304

   305

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

   306

        return -EFAULT;

   307

   308

    return 0;

   309

}

   310

   311

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

   312

   313

/** Get slave sync manager PDO information.

   314

 */

   315

int ec_cdev_ioctl_slave_sync_pdo(

   316

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

   317

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

   318

        )

   319

{

   320

    ec_ioctl_slave_sync_pdo_t data;

   321

    const ec_slave_t *slave;

   322

    const ec_sync_t *sync;

   323

    const ec_pdo_t *pdo;

   324

   325

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

   326

        return -EFAULT;

   327

    }

   328

   329

    if (down_interruptible(&master->master_sem))

   330

        return -EINTR;

   331

   332

    if (!(slave = ec_master_find_slave_const(

   333

                    master, 0, data.slave_position))) {

   334

        up(&master->master_sem);

   335

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

   336

        return -EINVAL;

   337

    }

   338

   339

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

   340

        up(&master->master_sem);

   341

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

   342

                data.sync_index, data.slave_position);

   343

        return -EINVAL;

   344

    }

   345

   346

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

   347

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   348

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

   349

        up(&master->master_sem);

   350

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

   351

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

   352

                data.pdo_pos, data.slave_position);

   353

        return -EINVAL;

   354

    }

   355

   356

    data.index = pdo->index;

   357

    data.entry_count = ec_pdo_entry_count(pdo);

   358

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

   359

   360

    up(&master->master_sem);

   361

   362

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

   363

        return -EFAULT;

   364

   365

    return 0;

   366

}

   367

   368

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

   369

   370

/** Get slave sync manager PDO entry information.

   371

 */

   372

int ec_cdev_ioctl_slave_sync_pdo_entry(

   373

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

   374

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

   375

        )

   376

{

   377

    ec_ioctl_slave_sync_pdo_entry_t data;

   378

    const ec_slave_t *slave;

   379

    const ec_sync_t *sync;

   380

    const ec_pdo_t *pdo;

   381

    const ec_pdo_entry_t *entry;

   382

   383

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

   384

        return -EFAULT;

   385

    }

   386

   387

    if (down_interruptible(&master->master_sem))

   388

        return -EINTR;

   389

   390

    if (!(slave = ec_master_find_slave_const(

   391

                    master, 0, data.slave_position))) {

   392

        up(&master->master_sem);

   393

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

   394

        return -EINVAL;

   395

    }

   396

   397

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

   398

        up(&master->master_sem);

   399

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

   400

                data.sync_index, data.slave_position);

   401

        return -EINVAL;

   402

    }

   403

   404

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

   405

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   406

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

   407

        up(&master->master_sem);

   408

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

   409

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

   410

                data.pdo_pos, data.slave_position);

   411

        return -EINVAL;

   412

    }

   413

   414

    if (!(entry = ec_pdo_find_entry_by_pos_const(

   415

                    pdo, data.entry_pos))) {

   416

        up(&master->master_sem);

   417

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

   418

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

   419

                data.entry_pos, data.slave_position);

   420

        return -EINVAL;

   421

    }

   422

   423

    data.index = entry->index;

   424

    data.subindex = entry->subindex;

   425

    data.bit_length = entry->bit_length;

   426

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

   427

   428

    up(&master->master_sem);

   429

   430

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

   431

        return -EFAULT;

   432

   433

    return 0;

   434

}

   435

   436

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

   437

   438

/** Get domain information.

   439

 */

   440

int ec_cdev_ioctl_domain(

   441

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

   442

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

   443

        )

   444

{

   445

    ec_ioctl_domain_t data;

   446

    const ec_domain_t *domain;

   447

   448

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

   449

        return -EFAULT;

   450

    }

   451

   452

    if (down_interruptible(&master->master_sem))

   453

        return -EINTR;

   454

   455

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

   456

        up(&master->master_sem);

   457

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

   458

        return -EINVAL;

   459

    }

   460

   461

    data.data_size = domain->data_size;

   462

    data.logical_base_address = domain->logical_base_address;

   463

    data.working_counter = domain->working_counter;

   464

    data.expected_working_counter = domain->expected_working_counter;

   465

    data.fmmu_count = ec_domain_fmmu_count(domain);

   466

   467

    up(&master->master_sem);

   468

   469

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

   470

        return -EFAULT;

   471

   472

    return 0;

   473

}

   474

   475

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

   476

   477

/** Get domain FMMU information.

   478

 */

   479

int ec_cdev_ioctl_domain_fmmu(

   480

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

   481

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

   482

        )

   483

{

   484

    ec_ioctl_domain_fmmu_t data;

   485

    const ec_domain_t *domain;

   486

    const ec_fmmu_config_t *fmmu;

   487

   488

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

   489

        return -EFAULT;

   490

    }

   491

   492

    if (down_interruptible(&master->master_sem))

   493

        return -EINTR;

   494

   495

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