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

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

    48

    49

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

    50

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

    51

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

    52

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

    53

    54

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

    55

 * vm_operations_struct is usable.

    56

 */

    57

#define PAGE_FAULT_VERSION KERNEL_VERSION(2, 6, 23)

    58

    59

#if LINUX_VERSION_CODE >= PAGE_FAULT_VERSION

    60

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

    61

#else

    62

static struct page *eccdev_vma_nopage(

    63

        struct vm_area_struct *, unsigned long, int *);

    64

#endif

    65

    66

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

    67

    68

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

    69

 */

    70

static struct file_operations eccdev_fops = {

    71

    .owner          = THIS_MODULE,

    72

    .open           = eccdev_open,

    73

    .release        = eccdev_release,

    74

    .unlocked_ioctl = eccdev_ioctl,

    75

    .mmap           = eccdev_mmap

    76

};

    77

    78

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

    79

 */

    80

struct vm_operations_struct eccdev_vm_ops = {

    81

#if LINUX_VERSION_CODE >= PAGE_FAULT_VERSION

    82

    .fault = eccdev_vma_fault

    83

#else

    84

    .nopage = eccdev_vma_nopage

    85

#endif

    86

};

    87

    88

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

    89

    90

/** Private data structure for file handles.

    91

 */

    92

typedef struct {

    93

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

    94

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

    95

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

    96

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

    97

} ec_cdev_priv_t;

    98

    99

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

   100

   101

/** Constructor.

   102

 * 

   103

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

   104

 */

   105

int ec_cdev_init(

   106

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

   107

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

   108

		dev_t dev_num /**< Device number. */

   109

		)

   110

{

   111

    int ret;

   112

   113

    cdev->master = master;

   114

   115

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

   116

    cdev->cdev.owner = THIS_MODULE;

   117

   118

    ret = cdev_add(&cdev->cdev,

   119

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

   120

    if (ret) {

   121

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

   122

    }

   123

   124

    return ret;

   125

}

   126

   127

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

   128

   129

/** Destructor.

   130

 */

   131

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

   132

{

   133

    cdev_del(&cdev->cdev);

   134

}

   135

   136

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

   137

   138

/** Copies a string to an ioctl structure.

   139

 */

   140

void ec_cdev_strcpy(

   141

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

   142

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

   143

        )

   144

{

   145

    if (source) {

   146

        strncpy(target, source, EC_IOCTL_STRING_SIZE);

   147

        target[EC_IOCTL_STRING_SIZE - 1] = 0;

   148

    } else {

   149

        target[0] = 0;

   150

    }

   151

}

   152

   153

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

   154

   155

/** Get master information.

   156

 */

   157

int ec_cdev_ioctl_master(

   158

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

   159

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

   160

        )

   161

{

   162

    ec_ioctl_master_t data;

   163

   164

    if (down_interruptible(&master->master_sem))

   165

        return -EINTR;

   166

    data.slave_count = master->slave_count;

   167

    data.config_count = ec_master_config_count(master);

   168

    data.domain_count = ec_master_domain_count(master);

   169

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

   170

    up(&master->master_sem);

   171

   172

    if (down_interruptible(&master->device_sem))

   173

        return -EINTR;

   174

    if (master->main_device.dev) {

   175

        memcpy(data.devices[0].address,

   176

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

   177

    } else {

   178

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

   179

    }

   180

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

   181

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

   182

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

   183

   184

    if (master->backup_device.dev) {

   185

        memcpy(data.devices[1].address,

   186

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

   187

    } else {

   188

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

   189

    }

   190

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

   191

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

   192

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

   193

    up(&master->device_sem);

   194

   195

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

   196

        return -EFAULT;

   197

   198

    return 0;

   199

}

   200

   201

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

   202

   203

/** Get slave information.

   204

 */

   205

int ec_cdev_ioctl_slave(

   206

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

   207

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

   208

        )

   209

{

   210

    ec_ioctl_slave_t data;

   211

    const ec_slave_t *slave;

   212

   213

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

   214

        return -EFAULT;

   215

    }

   216

   217

    if (down_interruptible(&master->master_sem))

   218

        return -EINTR;

   219

   220

    if (!(slave = ec_master_find_slave_const(

   221

                    master, 0, data.position))) {

   222

        up(&master->master_sem);

   223

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

   224

        return -EINVAL;

   225

    }

   226

   227

    data.vendor_id = slave->sii.vendor_id;

   228

    data.product_code = slave->sii.product_code;

   229

    data.revision_number = slave->sii.revision_number;

   230

    data.serial_number = slave->sii.serial_number;

   231

    data.alias = slave->sii.alias;

   232

    data.boot_rx_mailbox_offset = slave->sii.boot_rx_mailbox_offset;

   233

    data.boot_rx_mailbox_size = slave->sii.boot_rx_mailbox_size;

   234

    data.boot_tx_mailbox_offset = slave->sii.boot_tx_mailbox_offset;

   235

    data.boot_tx_mailbox_size = slave->sii.boot_tx_mailbox_size;

   236

    data.std_rx_mailbox_offset = slave->sii.std_rx_mailbox_offset;

   237

    data.std_rx_mailbox_size = slave->sii.std_rx_mailbox_size;

   238

    data.std_tx_mailbox_offset = slave->sii.std_tx_mailbox_offset;

   239

    data.std_tx_mailbox_size = slave->sii.std_tx_mailbox_size;

   240

    data.mailbox_protocols = slave->sii.mailbox_protocols;

   241

    data.has_general_category = slave->sii.has_general;

   242

    data.coe_details = slave->sii.coe_details;

   243

    data.general_flags = slave->sii.general_flags;

   244

    data.current_on_ebus = slave->sii.current_on_ebus;

   245

    data.al_state = slave->current_state;

   246

    data.error_flag = slave->error_flag;

   247

   248

    data.sync_count = slave->sii.sync_count;

   249

    data.sdo_count = ec_slave_sdo_count(slave);

   250

    data.sii_nwords = slave->sii_nwords;

   251

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

   252

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

   253

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

   254

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

   255

   256

    up(&master->master_sem);

   257

   258

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

   259

        return -EFAULT;

   260

   261

    return 0;

   262

}

   263

   264

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

   265

   266

/** Get slave sync manager information.

   267

 */

   268

int ec_cdev_ioctl_slave_sync(

   269

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

   270

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

   271

        )

   272

{

   273

    ec_ioctl_slave_sync_t data;

   274

    const ec_slave_t *slave;

   275

    const ec_sync_t *sync;

   276

   277

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

   278

        return -EFAULT;

   279

    }

   280

   281

    if (down_interruptible(&master->master_sem))

   282

        return -EINTR;

   283

   284

    if (!(slave = ec_master_find_slave_const(

   285

                    master, 0, data.slave_position))) {

   286

        up(&master->master_sem);

   287

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

   288

        return -EINVAL;

   289

    }

   290

   291

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

   292

        up(&master->master_sem);

   293

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

   294

                data.sync_index, data.slave_position);

   295

        return -EINVAL;

   296

    }

   297

   298

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

   299

   300

    data.physical_start_address = sync->physical_start_address;

   301

    data.default_size = sync->default_length;

   302

    data.control_register = sync->control_register;

   303

    data.enable = sync->enable;

   304

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

   305

   306

    up(&master->master_sem);

   307

   308

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

   309

        return -EFAULT;

   310

   311

    return 0;

   312

}

   313

   314

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

   315

   316

/** Get slave sync manager PDO information.

   317

 */

   318

int ec_cdev_ioctl_slave_sync_pdo(

   319

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

   320

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

   321

        )

   322

{

   323

    ec_ioctl_slave_sync_pdo_t data;

   324

    const ec_slave_t *slave;

   325

    const ec_sync_t *sync;

   326

    const ec_pdo_t *pdo;

   327

   328

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

   329

        return -EFAULT;

   330

    }

   331

   332

    if (down_interruptible(&master->master_sem))

   333

        return -EINTR;

   334

   335

    if (!(slave = ec_master_find_slave_const(

   336

                    master, 0, data.slave_position))) {

   337

        up(&master->master_sem);

   338

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

   339

        return -EINVAL;

   340

    }

   341

   342

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

   343

        up(&master->master_sem);

   344

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

   345

                data.sync_index, data.slave_position);

   346

        return -EINVAL;

   347

    }

   348

   349

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

   350

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   351

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

   352

        up(&master->master_sem);

   353

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

   354

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

   355

                data.pdo_pos, data.slave_position);

   356

        return -EINVAL;

   357

    }

   358

   359

    data.index = pdo->index;

   360

    data.entry_count = ec_pdo_entry_count(pdo);

   361

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

   362

   363

    up(&master->master_sem);

   364

   365

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

   366

        return -EFAULT;

   367

   368

    return 0;

   369

}

   370

   371

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

   372

   373

/** Get slave sync manager PDO entry information.

   374

 */

   375

int ec_cdev_ioctl_slave_sync_pdo_entry(

   376

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

   377

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

   378

        )

   379

{

   380

    ec_ioctl_slave_sync_pdo_entry_t data;

   381

    const ec_slave_t *slave;

   382

    const ec_sync_t *sync;

   383

    const ec_pdo_t *pdo;

   384

    const ec_pdo_entry_t *entry;

   385

   386

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

   387

        return -EFAULT;

   388

    }

   389

   390

    if (down_interruptible(&master->master_sem))

   391

        return -EINTR;

   392

   393

    if (!(slave = ec_master_find_slave_const(

   394

                    master, 0, data.slave_position))) {

   395

        up(&master->master_sem);

   396

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

   397

        return -EINVAL;

   398

    }

   399

   400

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

   401

        up(&master->master_sem);

   402

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

   403

                data.sync_index, data.slave_position);

   404

        return -EINVAL;

   405

    }

   406

   407

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

   408

    if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   409

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

   410

        up(&master->master_sem);

   411

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

   412

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

   413

                data.pdo_pos, data.slave_position);

   414

        return -EINVAL;

   415

    }

   416

   417

    if (!(entry = ec_pdo_find_entry_by_pos_const(

   418

                    pdo, data.entry_pos))) {

   419

        up(&master->master_sem);

   420

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

   421

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

   422

                data.entry_pos, data.slave_position);

   423

        return -EINVAL;

   424

    }

   425

   426

    data.index = entry->index;

   427

    data.subindex = entry->subindex;

   428

    data.bit_length = entry->bit_length;

   429

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

   430

   431

    up(&master->master_sem);

   432

   433

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

   434

        return -EFAULT;

   435

   436

    return 0;

   437

}

   438

   439

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

   440

   441

/** Get domain information.

   442

 */

   443

int ec_cdev_ioctl_domain(

   444

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

   445

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

   446

        )

   447

{

   448

    ec_ioctl_domain_t data;

   449

    const ec_domain_t *domain;

   450

   451

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

   452

        return -EFAULT;

   453

    }

   454

   455

    if (down_interruptible(&master->master_sem))

   456

        return -EINTR;

   457

   458

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

   459

        up(&master->master_sem);

   460

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

   461

        return -EINVAL;

   462

    }

   463

   464

    data.data_size = domain->data_size;

   465

    data.logical_base_address = domain->logical_base_address;

   466

    data.working_counter = domain->working_counter;

   467

    data.expected_working_counter = domain->expected_working_counter;

   468

    data.fmmu_count = ec_domain_fmmu_count(domain);

   469

   470

    up(&master->master_sem);

   471

   472

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

   473

        return -EFAULT;

   474

   475

    return 0;

   476

}

   477

   478

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

   479

   480

/** Get domain FMMU information.

   481

 */

   482

int ec_cdev_ioctl_domain_fmmu(

   483

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

   484

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

   485

        )

   486

{

   487

    ec_ioctl_domain_fmmu_t data;

   488

    const ec_domain_t *domain;

   489

    const ec_fmmu_config_t *fmmu;

   490

   491

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

   492

        return -EFAULT;

   493

    }

   494

   495

    if (down_interruptible(&master->master_sem))