1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2006-2012  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 "ethernet.h"

    46

#include "ioctl.h"

    47

    48

/** Set to 1 to enable device operations debugging.

    49

 */

    50

#define DEBUG 0

    51

    52

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

    53

    54

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

    55

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

    56

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

    57

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

    58

    59

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

    60

 * vm_operations_struct is usable.

    61

 */

    62

#define PAGE_FAULT_VERSION KERNEL_VERSION(2, 6, 23)

    63

    64

#if LINUX_VERSION_CODE >= PAGE_FAULT_VERSION

    65

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

    66

#else

    67

static struct page *eccdev_vma_nopage(

    68

        struct vm_area_struct *, unsigned long, int *);

    69

#endif

    70

    71

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

    72

    73

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

    74

 */

    75

static struct file_operations eccdev_fops = {

    76

    .owner          = THIS_MODULE,

    77

    .open           = eccdev_open,

    78

    .release        = eccdev_release,

    79

    .unlocked_ioctl = eccdev_ioctl,

    80

    .mmap           = eccdev_mmap

    81

};

    82

    83

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

    84

 */

    85

struct vm_operations_struct eccdev_vm_ops = {

    86

#if LINUX_VERSION_CODE >= PAGE_FAULT_VERSION

    87

    .fault = eccdev_vma_fault

    88

#else

    89

    .nopage = eccdev_vma_nopage

    90

#endif

    91

};

    92

    93

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

    94

    95

/** Private data structure for file handles.

    96

 */

    97

typedef struct {

    98

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

    99

    ec_ioctl_context_t ctx; /**< Context. */

   100

} ec_cdev_priv_t;

   101

   102

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

   103

   104

/** Constructor.

   105

 *

   106

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

   107

 */

   108

int ec_cdev_init(

   109

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

   110

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

   111

        dev_t dev_num /**< Device number. */

   112

        )

   113

{

   114

    int ret;

   115

   116

    cdev->master = master;

   117

   118

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

   119

    cdev->cdev.owner = THIS_MODULE;

   120

   121

    ret = cdev_add(&cdev->cdev,

   122

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

   123

    if (ret) {

   124

        EC_MASTER_ERR(master, "Failed to add character device!\n");

   125

    }

   126

   127

    return ret;

   128

}

   129

   130

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

   131

   132

/** Destructor.

   133

 */

   134

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

   135

{

   136

    cdev_del(&cdev->cdev);

   137

}

   138

   139

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

   140

 * File operations

   141

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

   142

   143

/** Called when the cdev is opened.

   144

 */

   145

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

   146

{

   147

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

   148

    ec_cdev_priv_t *priv;

   149

   150

    priv = kmalloc(sizeof(ec_cdev_priv_t), GFP_KERNEL);

   151

    if (!priv) {

   152

        EC_MASTER_ERR(cdev->master,

   153

                "Failed to allocate memory for private data structure.\n");

   154

        return -ENOMEM;

   155

    }

   156

   157

    priv->cdev = cdev;

   158

    priv->ctx.writable = (filp->f_mode & FMODE_WRITE) != 0;

   159

    priv->ctx.requested = 0;

   160

    priv->ctx.process_data = NULL;

   161

    priv->ctx.process_data_size = 0;

   162

   163

    filp->private_data = priv;

   164

   165

#if DEBUG

   166

    EC_MASTER_DBG(cdev->master, 0, "File opened.\n");

   167

#endif

   168

    return 0;

   169

}

   170

   171

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

   172

   173

/** Called when the cdev is closed.

   174

 */

   175

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

   176

{

   177

    ec_cdev_priv_t *priv = (ec_cdev_priv_t *) filp->private_data;

   178

    ec_master_t *master = priv->cdev->master;

   179

   180

    if (priv->ctx.requested) {

   181

        ecrt_release_master(master);

   182

    }

   183

   184

    if (priv->ctx.process_data) {

   185

        vfree(priv->ctx.process_data);

   186

    }

   187

   188

#if DEBUG

   189

    EC_MASTER_DBG(master, 0, "File closed.\n");

   190

#endif

   191

   192

    kfree(priv);

   193

    return 0;

   194

}

   195

   196

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

   197

   198

/** Called when an ioctl() command is issued.

   199

 */

   200

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

   201

{

   202

    ec_cdev_priv_t *priv = (ec_cdev_priv_t *) filp->private_data;

   203

   204

#if DEBUG

   205

    EC_MASTER_DBG(priv->cdev->master, 0,

   206

            "ioctl(filp = 0x%p, cmd = 0x%08x (0x%02x), arg = 0x%lx)\n",

   207

            filp, cmd, _IOC_NR(cmd), arg);

   208

#endif

   209

   210

    return ec_ioctl(priv->cdev->master, &priv->ctx, cmd, (void __user *) arg);

   211

}

   212

   213

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

   214

   215

/** Memory-map callback for the EtherCAT character device.

   216

 *

   217

 * The actual mapping will be done in the eccdev_vma_nopage() callback of the

   218

 * virtual memory area.

   219

 */

   220

int eccdev_mmap(

   221

        struct file *filp,

   222

        struct vm_area_struct *vma

   223

        )

   224

{

   225

    ec_cdev_priv_t *priv = (ec_cdev_priv_t *) filp->private_data;

   226

   227

    EC_MASTER_DBG(priv->cdev->master, 1, "mmap()\n");

   228

   229

    vma->vm_ops = &eccdev_vm_ops;

   230

    vma->vm_flags |= VM_RESERVED; /* Pages will not be swapped out */

   231

    vma->vm_private_data = priv;

   232

   233

    return 0;

   234

}

   235

   236

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

   237

   238

#if LINUX_VERSION_CODE >= PAGE_FAULT_VERSION

   239

   240

/** Page fault callback for a virtual memory area.

   241

 *

   242

 * Called at the first access on a virtual-memory area retrieved with

   243

 * ecdev_mmap().

   244

 */

   245

static int eccdev_vma_fault(

   246

        struct vm_area_struct *vma, /**< Virtual memory area. */

   247

        struct vm_fault *vmf /**< Fault data. */

   248

        )

   249

{

   250

    unsigned long offset = vmf->pgoff << PAGE_SHIFT;

   251

    ec_cdev_priv_t *priv = (ec_cdev_priv_t *) vma->vm_private_data;

   252

    struct page *page;

   253

   254

    if (offset >= priv->ctx.process_data_size)

   255

        return VM_FAULT_SIGBUS;

   256

   257

    page = vmalloc_to_page(priv->ctx.process_data + offset);

   258

    if (!page)

   259

        return VM_FAULT_SIGBUS;

   260

   261

    get_page(page);

   262

    vmf->page = page;

   263

   264

    EC_MASTER_DBG(priv->cdev->master, 1, "Vma fault, virtual_address = %p,"

   265

            " offset = %lu, page = %p\n", vmf->virtual_address, offset, page);

   266

   267

    return 0;

   268

}

   269

   270

#else

   271

   272

/** Nopage callback for a virtual memory area.

   273

 *

   274

 * Called at the first access on a virtual-memory area retrieved with

   275

 * ecdev_mmap().

   276

 */

   277

struct page *eccdev_vma_nopage(

   278

        struct vm_area_struct *vma, /**< Virtual memory area initialized by

   279

                                      the kernel. */

   280

        unsigned long address, /**< Requested virtual address. */

   281

        int *type /**< Type output parameter. */

   282

        )

   283

{

   284

    unsigned long offset;

   285

    struct page *page = NOPAGE_SIGBUS;

   286

    ec_cdev_priv_t *priv = (ec_cdev_priv_t *) vma->vm_private_data;

   287

    ec_master_t *master = priv->cdev->master;

   288

   289

    offset = (address - vma->vm_start) + (vma->vm_pgoff << PAGE_SHIFT);

   290

   291

    if (offset >= priv->ctx.process_data_size)

   292

        return NOPAGE_SIGBUS;

   293

   294

    page = vmalloc_to_page(priv->ctx.process_data + offset);

   295

   296

    EC_MASTER_DBG(master, 1, "Nopage fault vma, address = %#lx,"

   297

            " offset = %#lx, page = %p\n", address, offset, page);

   298

   299

    get_page(page);

   300

    if (type)

   301

        *type = VM_FAULT_MINOR;

   302

   303

    return page;

   304

}

   305

   306

#endif

   307

   308

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