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

/** Context structure for an open RTDM file handle.

    50

 */

    51

typedef struct {

    52

    rtdm_user_info_t *user_info; /**< RTDM user data. */

    53

    ec_ioctl_context_t ioctl_ctx; /**< Context structure. */

    54

} ec_rtdm_context_t;

    55

    56

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

    57

    58

int ec_rtdm_open(struct rtdm_dev_context *, rtdm_user_info_t *, int);

    59

int ec_rtdm_close(struct rtdm_dev_context *, rtdm_user_info_t *);

    60

int ec_rtdm_ioctl(struct rtdm_dev_context *, rtdm_user_info_t *,

    61

        unsigned int, void __user *);

    62

    63

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

    64

    65

static struct rtdm_driver ec_rtdm_driver = {

    66

	.profile_info		=	RTDM_PROFILE_INFO(foo,

    67

							  RTDM_CLASS_EXPERIMENTAL,

    68

							  222,

    69

							  1),

    70

	.device_flags		=	RTDM_NAMED_DEVICE,

    71

	.device_count		=	1,

    72

	.context_size		=	sizeof(ec_rtdm_context_t).

    73

	.ops = {

    74

        .open      = ec_rtdm_open;

    75

        .close_nrt = ec_rtdm_close,

    76

        .ioctl_rt  = ec_rtdm_ioctl,

    77

        .ioctl_nrt = ec_rtdm_ioctl

    78

	},

    79

};

    80

    81

/** Initialize an RTDM device.

    82

 *

    83

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

    84

 */

    85

int ec_rtdm_dev_init(

    86

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

    87

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

    88

        )

    89

{

    90

    int ret;

    91

    92

    MODULE_VERSION

    93

    94

    rtdm_dev->master = master;

    95

    96

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

    97

    if (!rtdm_dev->dev) {

    98

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

    99

        return -ENOMEM;

   100

    }

   101

   102

    rtdm_dev->dev->label = kzalloc(RTDM_MAX_DEVNAME_LEN+1, GFP_KERNEL);

   103

    if (!rtdm_dev->dev->label) {

   104

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

   105

        return -ENOMEM;

   106

        kfree(rtdm_dev->dev);

   107

    }

   108

   109

   110

    rtdm_dev->dev->driver = &ec_rtdm_driver;

   111

    snprintf(rtdm_dev->dev->label, RTDM_MAX_DEVNAME_LEN,

   112

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

   113

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

   114

   115

   116

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

   117

            rtdm_dev->dev->driver_name);

   118

    ret = rtdm_dev_register(rtdm_dev->dev);

   119

    if (ret) {

   120

        EC_MASTER_ERR(master, "Initialization of RTDM interface failed"

   121

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

   122

        kfree(rtdm_dev->dev->label);

   123

        kfree(rtdm_dev->dev);

   124

    }

   125

   126

    return ret;

   127

}

   128

   129

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

   130

   131

/** Clear an RTDM device.

   132

 */

   133

void ec_rtdm_dev_clear(

   134

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

   135

        )

   136

{

   137

    int ret;

   138

   139

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

   140

            rtdm_dev->dev->label);

   141

    ret = rtdm_dev_unregister(rtdm_dev->dev, 1000 /* poll delay [ms] */);

   142

    if (ret < 0) {

   143

        EC_MASTER_WARN(rtdm_dev->master,

   144

                "Failed to unregister RTDM device (code %i).\n", ret);

   145

    }

   146

   147

    kfree(rtdm_dev->dev->label);

   148

    kfree(rtdm_dev->dev);

   149

}

   150

   151

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

   152

   153

/** Driver open.

   154

 *

   155

 * \return Always zero (success).

   156

 */

   157

int ec_rtdm_open(

   158

        struct rtdm_dev_context *context, /**< Context. */

   159

        rtdm_user_info_t *user_info, /**< User data. */

   160

        int oflags /**< Open flags. */

   161

        )

   162

{

   163

    ec_rtdm_context_t *ctx = (ec_rtdm_context_t *) context->dev_private;

   164

#if DEBUG

   165

    ec_rtdm_dev_t *rtdm_dev = (ec_rtdm_dev_t *) context->device->device_data;

   166

#endif

   167

   168

    ctx->user_info = user_info;

   169

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

   170

    ctx->ioctl_ctx.requested = 0;

   171

    ctx->ioctl_ctx.process_data = NULL;

   172

    ctx->ioctl_ctx.process_data_size = 0;

   173

   174

#if DEBUG

   175

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

   176

            context->device->device_name);

   177

#endif

   178

    return 0;

   179

}

   180

   181

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

   182

   183

/** Driver close.

   184

 *

   185

 * \return Always zero (success).

   186

 */

   187

int ec_rtdm_close(

   188

        struct rtdm_dev_context *context, /**< Context. */

   189

        rtdm_user_info_t *user_info /**< User data. */

   190

        )

   191

{

   192

    ec_rtdm_context_t *ctx = (ec_rtdm_context_t *) context->dev_private;

   193

    ec_rtdm_dev_t *rtdm_dev = (ec_rtdm_dev_t *) context->device->device_data;

   194

   195

    if (ctx->ioctl_ctx.requested) {

   196

        ecrt_release_master(rtdm_dev->master);

   197

	}

   198

   199

#if DEBUG

   200

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

   201

            context->device->device_name);

   202

#endif

   203

    return 0;

   204

}

   205

   206

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

   207

   208

/** Driver ioctl.

   209

 *

   210

 * \return ioctl() return code.

   211

 */

   212

int ec_rtdm_ioctl(

   213

        struct rtdm_dev_context *context, /**< Context. */

   214

        rtdm_user_info_t *user_info, /**< User data. */

   215

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

   216

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

   217

        )

   218

{

   219

    ec_rtdm_context_t *ctx = (ec_rtdm_context_t *) context->dev_private;

   220

    ec_rtdm_dev_t *rtdm_dev = (ec_rtdm_dev_t *) context->device->device_data;

   221

   222

#if DEBUG

   223

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

   224

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

   225

            context->device->device_name);

   226

#endif

   227

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

   228

}

   229

   230

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

   231

   232

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

   233

 *

   234

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

   235

 */

   236

int ec_rtdm_mmap(

   237

        ec_ioctl_context_t *ioctl_ctx, /**< Context. */

   238

        void **user_address /**< Userspace address. */

   239

        )

   240

{

   241

    ec_rtdm_context_t *ctx =

   242

        container_of(ioctl_ctx, ec_rtdm_context_t, ioctl_ctx);

   243

    int ret;

   244

   245

    ret = rtdm_mmap_to_user(ctx->user_info,

   246

            ioctl_ctx->process_data, ioctl_ctx->process_data_size,

   247

            PROT_READ | PROT_WRITE,

   248

            user_address,

   249

            NULL, NULL);

   250

    if (ret < 0) {

   251

        return ret;

   252

    }

   253

   254

    return 0;

   255

}

   256

   257

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