1

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

     2

 *

     3

 *  $Id$

     4

 *

     5

 *  Copyright (C) 2009-2010  Moehwald GmbH B. Benner

     6

 *                     2011  IgH Andreas Stewering-Bone

     7

 *                     2012  Florian Pose <fp@igh-essen.com>

     8

 *

     9

 *  This file is part of the IgH EtherCAT master.

    10

 *

    11

 *  The IgH EtherCAT master is free software; you can redistribute it and/or

    12

 *  modify it under the terms of the GNU General Public License as published

    13

 *  by the Free Software Foundation; version 2 of the License.

    14

 *

    15

 *  The IgH EtherCAT master is distributed in the hope that it will be useful,

    16

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    17

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General

    18

 *  Public License for more details.

    19

 *

    20

 *  You should have received a copy of the GNU General Public License along

    21

 *  with the IgH EtherCAT master. If not, see <http://www.gnu.org/licenses/>.

    22

 *

    23

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

    24

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

    25

 *  industrial property and similar rights of Beckhoff Automation GmbH.

    26

 *

    27

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

    28

    29

/** \file

    30

 * RTDM interface.

    31

 */

    32

    33

#include <linux/module.h>

    34

#include <linux/slab.h>

    35

#include <linux/mman.h>

    36

    37

#include <rtdm/driver.h>

    38

    39

#include "master.h"

    40

#include "ioctl.h"

    41

#include "rtdm.h"

    42

    43

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

    44

 */

    45

#define DEBUG 0

    46

    47

    48

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

    49

    50

int ec_rtdm_open(struct rtdm_fd *, int);

    51

void ec_rtdm_close(struct rtdm_fd *);

    52

int ec_rtdm_ioctl(struct rtdm_fd *,

    53

        unsigned int, void __user *);

    54

int ec_rtdm_mmap(struct rtdm_fd *fd, struct vm_area_struct *vma);

    55

    56

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

    57

    58

static struct rtdm_driver ec_rtdm_driver = {

    59

	.profile_info		=	RTDM_PROFILE_INFO(foo,

    60

							  RTDM_CLASS_EXPERIMENTAL,

    61

							  222,

    62

							  1),

    63

	.device_flags		=	RTDM_NAMED_DEVICE,

    64

	.device_count		=	1,

    65

	.context_size		=	sizeof(ec_ioctl_context_t),

    66

	.ops = {

    67

        .open      = ec_rtdm_open,

    68

        .close     = ec_rtdm_close,

    69

        .ioctl_rt  = ec_rtdm_ioctl,

    70

        .ioctl_nrt = ec_rtdm_ioctl,

    71

        .mmap      = ec_rtdm_mmap

    72

	},

    73

};

    74

    75

/** Initialize an RTDM device.

    76

 *

    77

 * \return Zero on success, otherwise a negative error code.

    78

 */

    79

int ec_rtdm_dev_init(

    80

        ec_rtdm_dev_t *rtdm_dev, /**< EtherCAT RTDM device. */

    81

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

    82

        )

    83

{

    84

    int ret;

    85

    char* devlabel;

    86

    87

    rtdm_dev->master = master;

    88

    89

    rtdm_dev->dev = kzalloc(sizeof(struct rtdm_device), GFP_KERNEL);

    90

    if (!rtdm_dev->dev) {

    91

        EC_MASTER_ERR(master, "Failed to reserve memory for RTDM device.\n");

    92

        return -ENOMEM;

    93

    }

    94

    95

    devlabel = kzalloc(RTDM_MAX_DEVNAME_LEN+1, GFP_KERNEL);

    96

    if (!devlabel) {

    97

        EC_MASTER_ERR(master, "Failed to reserve memory for RTDM device name.\n");

    98

        return -ENOMEM;

    99

        kfree(rtdm_dev->dev);

   100

    }

   101

    snprintf(devlabel, RTDM_MAX_DEVNAME_LEN,

   102

            "EtherCAT%u", master->index);

   103

   104

    rtdm_dev->dev->label = devlabel;

   105

    rtdm_dev->dev->driver = &ec_rtdm_driver;

   106

    rtdm_dev->dev->device_data = rtdm_dev; /* pointer to parent */

   107

   108

   109

    EC_MASTER_INFO(master, "Registering RTDM device %s.\n",

   110

            devlabel);

   111

    ret = rtdm_dev_register(rtdm_dev->dev);

   112

    if (ret) {

   113

        EC_MASTER_ERR(master, "Initialization of RTDM interface failed"

   114

                " (return value %i).\n", ret);

   115

        kfree(rtdm_dev->dev->label);

   116

        kfree(rtdm_dev->dev);

   117

    }

   118

   119

    return ret;

   120

}

   121

   122

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

   123

   124

/** Clear an RTDM device.

   125

 */

   126

void ec_rtdm_dev_clear(

   127

        ec_rtdm_dev_t *rtdm_dev /**< EtherCAT RTDM device. */

   128

        )

   129

{

   130

    EC_MASTER_INFO(rtdm_dev->master, "Unregistering RTDM device %s.\n",

   131

            rtdm_dev->dev->label);

   132

    rtdm_dev_unregister(rtdm_dev->dev);

   133

   134

    kfree(rtdm_dev->dev->label);

   135

    kfree(rtdm_dev->dev);

   136

}

   137

   138

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

   139

   140

/** Driver open.

   141

 *

   142

 * \return Always zero (success).

   143

 */

   144

int ec_rtdm_open(

   145

        struct rtdm_fd *fd, /**< User data. */

   146

        int oflags /**< Open flags. */

   147

        )

   148

{

   149

    ec_ioctl_context_t *ctx = (ec_ioctl_context_t *) rtdm_fd_to_private(fd);

   150

#if DEBUG

   151

    ec_rtdm_dev_t *rtdm_dev = (ec_rtdm_dev_t *) rtdm_fd_device(fd)->device_data;

   152

#endif

   153

   154

    ctx->writable = oflags & O_WRONLY || oflags & O_RDWR;

   155

    ctx->requested = 0;

   156

    ctx->process_data = NULL;

   157

    ctx->process_data_size = 0;

   158

   159

#if DEBUG

   160

    EC_MASTER_INFO(rtdm_dev->master, "RTDM device %s opened.\n",

   161

            context->device->device_name);

   162

#endif

   163

    return 0;

   164

}

   165

   166

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

   167

   168

/** Driver close.

   169

 *

   170

 * \return Always zero (success).

   171

 */

   172

void ec_rtdm_close(

   173

        struct rtdm_fd *fd /**< User data. */

   174

        )

   175

{

   176

    ec_ioctl_context_t *ctx = (ec_ioctl_context_t *) rtdm_fd_to_private(fd);

   177

    ec_rtdm_dev_t *rtdm_dev = (ec_rtdm_dev_t *) rtdm_fd_device(fd)->device_data;

   178

   179

    if (ctx->requested) {

   180

        ecrt_release_master(rtdm_dev->master);

   181

	}

   182

   183

#if DEBUG

   184

    EC_MASTER_INFO(rtdm_dev->master, "RTDM device %s closed.\n",

   185

            context->device->device_name);

   186

#endif

   187

}

   188

   189

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

   190

   191

/** Driver ioctl.

   192

 *

   193

 * \return ioctl() return code.

   194

 */

   195

int ec_rtdm_ioctl(

   196

        struct rtdm_fd *fd, /**< User data. */

   197

        unsigned int request, /**< Request. */

   198

        void __user *arg /**< Argument. */

   199

        )

   200

{

   201

    ec_ioctl_context_t *ctx = (ec_ioctl_context_t *) rtdm_fd_to_private(fd);

   202

    ec_rtdm_dev_t *rtdm_dev = (ec_rtdm_dev_t *) rtdm_fd_device(fd)->device_data;

   203

   204

#if DEBUG

   205

    EC_MASTER_INFO(rtdm_dev->master, "ioctl(request = %u, ctl = %02x)"

   206

            " on RTDM device %s.\n", request, _IOC_NR(request),

   207

            context->device->device_name);

   208

#endif

   209

    return ec_ioctl_rtdm(rtdm_dev->master, ctx, request, arg);

   210

}

   211

   212

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

   213

   214

/** Memory-map process data to user space.

   215

 *

   216

 */

   217

int ec_rtdm_mmap(struct rtdm_fd *fd, struct vm_area_struct *vma)

   218

{

   219

	size_t len;

   220

    ec_ioctl_context_t *ctx = (ec_ioctl_context_t *) rtdm_fd_to_private(fd);

   221

	len = vma->vm_end - vma->vm_start;

   222

	if (ctx->process_data_size != len)

   223

		return -EINVAL;

   224

	return rtdm_mmap_kmem(vma, (void *)ctx->process_data);

   225

}

   226

   227

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