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

    43

#include "cdev.h"

    44

#include "master.h"

    45

#include "ioctl.h"

    46

    47

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

    48

    49

/** \cond */

    50

    51

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

    52

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

    53

ssize_t eccdev_read(struct file *, char __user *, size_t, loff_t *);

    54

ssize_t eccdev_write(struct file *, const char __user *, size_t, loff_t *);

    55

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

    56

    57

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

    58

    59

static struct file_operations eccdev_fops = {

    60

    .owner          = THIS_MODULE,

    61

    .open           = eccdev_open,

    62

    .release        = eccdev_release,

    63

    .unlocked_ioctl = eccdev_ioctl

    64

};

    65

    66

/** \endcond */

    67

    68

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

    69

    70

/** Constructor.

    71

 * 

    72

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

    73

 */

    74

int ec_cdev_init(

    75

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

    76

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

    77

		dev_t dev_num /**< Device number. */

    78

		)

    79

{

    80

    cdev->master = master;

    81

    82

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

    83

    cdev->cdev.owner = THIS_MODULE;

    84

    85

    if (cdev_add(&cdev->cdev,

    86

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

    87

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

    88

		return -1;

    89

    }

    90

    91

    return 0;

    92

}

    93

    94

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

    95

    96

/** Destructor.

    97

 */

    98

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

    99

{

   100

    cdev_del(&cdev->cdev);

   101

}

   102

   103

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

   104

 * File operations

   105

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

   106

   107

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

   108

{

   109

    ec_cdev_t *cdev = container_of(inode->i_cdev, ec_cdev_t, cdev);

   110

    ec_master_t *master = cdev->master;

   111

   112

    filp->private_data = cdev;

   113

    if (master->debug_level)

   114

        EC_DBG("File opened.\n");

   115

    return 0;

   116

}

   117

   118

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

   119

   120

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

   121

{

   122

    ec_cdev_t *cdev = (ec_cdev_t *) filp->private_data;

   123

    ec_master_t *master = cdev->master;

   124

   125

    if (master->debug_level)

   126

        EC_DBG("File closed.\n");

   127

    return 0;

   128

}

   129

   130

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

   131

   132

long eccdev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)

   133

{

   134

    ec_cdev_t *cdev = (ec_cdev_t *) filp->private_data;

   135

    ec_master_t *master = cdev->master;

   136

    long retval = 0;

   137

   138

    if (master->debug_level)

   139

        EC_DBG("ioctl(filp = %x, cmd = %u, arg = %u)\n",

   140

                (u32) filp, (u32) cmd, (u32) arg);

   141

   142

    // FIXME lock

   143

   144

    switch (cmd) {

   145

        case EC_IOCTL_SLAVE_COUNT:

   146

            retval = master->slave_count;

   147

            break;

   148

   149

        case EC_IOCTL_SLAVE:

   150

            {

   151

                ec_ioctl_slave_t data;

   152

                const ec_slave_t *slave;

   153

   154

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

   155

                    retval = -EFAULT;

   156

                    break;

   157

                }

   158

   159

                if (!(slave = ec_master_find_slave(

   160

                                master, 0, data.position))) {

   161

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

   162

                    retval = -EINVAL;

   163

                    break;

   164

                }

   165

   166

                data.vendor_id = slave->sii.vendor_id;

   167

                data.product_code = slave->sii.product_code;

   168

                data.revision_number = slave->sii.revision_number;

   169

                data.serial_number = slave->sii.serial_number;

   170

                data.alias = slave->sii.alias;

   171

                data.state = slave->current_state;

   172

   173

                data.sync_count = slave->sii.sync_count;

   174

   175

                if (slave->sii.name) {

   176

                    strncpy(data.name, slave->sii.name,

   177

                            EC_IOCTL_SLAVE_NAME_SIZE);

   178

                    data.name[EC_IOCTL_SLAVE_NAME_SIZE - 1] = 0;

   179

                } else {

   180

                    data.name[0] = 0;

   181

                }

   182

   183

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

   184

                    retval = -EFAULT;

   185

                    break;

   186

                }

   187

   188

                break;

   189

            }

   190

   191

        case EC_IOCTL_SYNC:

   192

            {

   193

                ec_ioctl_sync_t data;

   194

                const ec_slave_t *slave;

   195

                const ec_sync_t *sync;

   196

   197

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

   198

                    retval = -EFAULT;

   199

                    break;

   200

                }

   201

   202

                if (!(slave = ec_master_find_slave(

   203

                                master, 0, data.slave_position))) {

   204

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

   205

                    retval = -EINVAL;

   206

                    break;

   207

                }

   208

   209

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

   210

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

   211

                            data.sync_index, data.slave_position);

   212

                    retval = -EINVAL;

   213

                    break;

   214

                }

   215

   216

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

   217

   218

                data.physical_start_address = sync->physical_start_address;

   219

                data.default_size = sync->length;

   220

                data.control_register = sync->control_register;

   221

                data.enable = sync->enable;

   222

                data.assign_source = sync->assign_source;

   223

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

   224

   225

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

   226

                    retval = -EFAULT;

   227

                    break;

   228

                }

   229

                break;

   230

            }

   231

   232

        case EC_IOCTL_PDO:

   233

            {

   234

                ec_ioctl_pdo_t data;

   235

                const ec_slave_t *slave;

   236

                const ec_sync_t *sync;

   237

                const ec_pdo_t *pdo;

   238

   239

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

   240

                    retval = -EFAULT;

   241

                    break;

   242

                }

   243

   244

                if (!(slave = ec_master_find_slave(

   245

                                master, 0, data.slave_position))) {

   246

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

   247

                    retval = -EINVAL;

   248

                    break;

   249

                }

   250

   251

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

   252

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

   253

                            data.sync_index, data.slave_position);

   254

                    retval = -EINVAL;

   255

                    break;

   256

                }

   257

   258

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

   259

                if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   260

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

   261

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

   262

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

   263

                            data.pdo_pos, data.slave_position);

   264

                    retval = -EINVAL;

   265

                    break;

   266

                }

   267

   268

                data.dir = pdo->dir;

   269

                data.index = pdo->index;

   270

                data.entry_count = ec_pdo_entry_count(pdo);

   271

   272

                if (pdo->name) {

   273

                    strncpy(data.name, pdo->name, EC_IOCTL_PDO_NAME_SIZE);

   274

                    data.name[EC_IOCTL_PDO_NAME_SIZE - 1] = 0;

   275

                } else {

   276

                    data.name[0] = 0;

   277

                }

   278

   279

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

   280

                    retval = -EFAULT;

   281

                    break;

   282

                }

   283

                break;

   284

            }

   285

   286

        case EC_IOCTL_PDO_ENTRY:

   287

            {

   288

                ec_ioctl_pdo_entry_t data;

   289

                const ec_slave_t *slave;

   290

                const ec_sync_t *sync;

   291

                const ec_pdo_t *pdo;

   292

                const ec_pdo_entry_t *entry;

   293

   294

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

   295

                    retval = -EFAULT;

   296

                    break;

   297

                }

   298

   299

                if (!(slave = ec_master_find_slave(

   300

                                master, 0, data.slave_position))) {

   301

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

   302

                    retval = -EINVAL;

   303

                    break;

   304

                }

   305

   306

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

   307

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

   308

                            data.sync_index, data.slave_position);

   309

                    retval = -EINVAL;

   310

                    break;

   311

                }

   312

   313

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

   314

                if (!(pdo = ec_pdo_list_find_pdo_by_pos_const(

   315

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

   316

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

   317

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

   318

                            data.pdo_pos, data.slave_position);

   319

                    retval = -EINVAL;

   320

                    break;

   321

                }

   322

   323

                if (!(entry = ec_pdo_find_entry_by_pos_const(

   324

                                pdo, data.entry_pos))) {

   325

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

   326

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

   327

                            data.entry_pos, data.slave_position);

   328

                    retval = -EINVAL;

   329

                    break;

   330

                }

   331

   332

                data.index = entry->index;

   333

                data.subindex = entry->subindex;

   334

                data.bit_length = entry->bit_length;

   335

                if (entry->name) {

   336

                    strncpy(data.name, entry->name,

   337

                            EC_IOCTL_PDO_ENTRY_NAME_SIZE);

   338

                    data.name[EC_IOCTL_PDO_ENTRY_NAME_SIZE - 1] = 0;

   339

                } else {

   340

                    data.name[0] = 0;

   341

                }

   342

   343

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

   344

                    retval = -EFAULT;

   345

                    break;

   346

                }

   347

                break;

   348

            }

   349

   350

        default:

   351

            retval = -ENOIOCTLCMD;

   352

    }

   353

   354

    return retval;

   355

}

   356

   357

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