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

/** \file

    31

 * EtherCAT tty driver module.

    32

 */

    33

    34

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

    35

    36

#include <linux/module.h>

    37

#include <linux/err.h>

    38

#include <linux/tty.h>

    39

#include <linux/tty_driver.h>

    40

#include <linux/termios.h>

    41

    42

#include "../master/globals.h"

    43

#include "../include/ectty.h"

    44

    45

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

    46

    47

#define PFX "ec_tty: "

    48

    49

#define EC_TTY_MAX_DEVICES 10

    50

    51

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

    52

    53

char *ec_master_version_str = EC_MASTER_VERSION; /**< Version string. */

    54

unsigned int debug_level = 0;

    55

    56

static struct tty_driver *tty_driver = NULL;

    57

ec_tty_t *ttys[EC_TTY_MAX_DEVICES];

    58

struct semaphore tty_sem;

    59

    60

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

    61

    62

/** \cond */

    63

    64

MODULE_AUTHOR("Florian Pose <fp@igh-essen.com>");

    65

MODULE_DESCRIPTION("EtherCAT TTY driver module");

    66

MODULE_LICENSE("GPL");

    67

MODULE_VERSION(EC_MASTER_VERSION);

    68

    69

module_param_named(debug_level, debug_level, uint, S_IRUGO);

    70

MODULE_PARM_DESC(debug_level, "Debug level");

    71

    72

/** \endcond */

    73

    74

static int ec_tty_open(struct tty_struct *, struct file *);

    75

static void ec_tty_close(struct tty_struct *, struct file *);

    76

static int ec_tty_write(struct tty_struct *, const unsigned char *, int);

    77

    78

static const struct tty_operations ec_tty_ops = {

    79

    .open = ec_tty_open,

    80

    .close = ec_tty_close,

    81

    .write = ec_tty_write,

    82

};

    83

    84

static struct ktermios ec_tty_std_termios = {

    85

    .c_iflag = ICRNL | IXON,

    86

    .c_oflag = OPOST | ONLCR,

    87

    .c_cflag = B38400 | CS8 | CREAD | HUPCL,

    88

    .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE | IEXTEN,

    89

    .c_cc = INIT_C_CC,

    90

};

    91

    92

struct ec_tty {

    93

    int minor;

    94

    struct device *dev;

    95

};

    96

    97

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

    98

    99

/** Module initialization.

   100

 *

   101

 * \return 0 on success, else < 0

   102

 */

   103

int __init ec_tty_init_module(void)

   104

{

   105

    int i, ret = 0;

   106

   107

    printk(KERN_INFO PFX "TTY driver %s\n", EC_MASTER_VERSION);

   108

   109

    init_MUTEX(&tty_sem);

   110

   111

    for (i = 0; i < EC_TTY_MAX_DEVICES; i++) {

   112

        ttys[i] = NULL;

   113

    }

   114

   115

    tty_driver = alloc_tty_driver(EC_TTY_MAX_DEVICES);

   116

    if (!tty_driver) {

   117

        printk(KERN_ERR PFX "Failed to allocate tty driver.\n");

   118

        ret = -ENOMEM;

   119

        goto out_return;

   120

    }

   121

   122

    tty_driver->owner = THIS_MODULE;

   123

    tty_driver->driver_name = "EtherCAT TTY";

   124

    tty_driver->name = "ttyEC";

   125

    tty_driver->major = 0;

   126

    tty_driver->minor_start = 0;

   127

    tty_driver->type = TTY_DRIVER_TYPE_SERIAL;

   128

    tty_driver->subtype = SERIAL_TYPE_NORMAL;

   129

    tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;

   130

    tty_driver->init_termios = ec_tty_std_termios;

   131

    tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;

   132

    tty_set_operations(tty_driver, &ec_tty_ops);

   133

   134

    ret = tty_register_driver(tty_driver);

   135

    if (ret) {

   136

        printk(KERN_ERR PFX "Failed to register tty driver.\n");

   137

        goto out_put;

   138

    }

   139

   140

    return ret;

   141

   142

out_put:

   143

    put_tty_driver(tty_driver);

   144

out_return:

   145

    return ret;

   146

}

   147

   148

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

   149

   150

/** Module cleanup.

   151

 *

   152

 * Clears all master instances.

   153

 */

   154

void __exit ec_tty_cleanup_module(void)

   155

{

   156

    tty_unregister_driver(tty_driver);

   157

    put_tty_driver(tty_driver);

   158

    printk(KERN_INFO PFX "Module unloading.\n");

   159

}

   160

   161

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

   162

   163

int ec_tty_init(ec_tty_t *tty, int minor)

   164

{

   165

    tty->minor = minor;

   166

   167

    tty->dev = tty_register_device(tty_driver, tty->minor, NULL);

   168

    if (IS_ERR(tty->dev)) {

   169

        printk(KERN_ERR PFX "Failed to register tty device.\n");

   170

        return PTR_ERR(tty->dev);

   171

    }

   172

   173

    return 0;

   174

}

   175

   176

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

   177

   178

void ec_tty_clear(ec_tty_t *tty)

   179

{

   180

    tty_unregister_device(tty_driver, tty->minor);

   181

}

   182

   183

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

   184

 * Device callbacks

   185

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

   186

   187

static int ec_tty_open(struct tty_struct *tty, struct file *file)

   188

{

   189

    ec_tty_t *t;

   190

    int line = tty->index;

   191

   192

    printk(KERN_INFO PFX "Opening line %i.\n", line);

   193

   194

	if (line < 0 || line >= EC_TTY_MAX_DEVICES) {

   195

		return -ENXIO;

   196

    }

   197

   198

    t = ttys[line];

   199

    if (!t) {

   200

        return -ENXIO;

   201

    }

   202

   203

    tty->driver_data = t;

   204

    return 0;

   205

}

   206

   207

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

   208

   209

static void ec_tty_close(struct tty_struct *tty, struct file *file)

   210

{

   211

    printk(KERN_INFO PFX "Closing line %i.\n", tty->index);

   212

}

   213

   214

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

   215

   216

static int ec_tty_write(

   217

        struct tty_struct *tty,

   218

        const unsigned char *buffer,

   219

        int count

   220

        )

   221

{

   222

    return -EIO;

   223

}

   224

   225

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

   226

 * Public functions and methods

   227

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

   228

   229

ec_tty_t *ectty_create(void)

   230

{

   231

    ec_tty_t *tty;

   232

    int minor, ret;

   233

   234

    if (down_interruptible(&tty_sem)) {

   235

        return ERR_PTR(-EINTR);

   236

    }

   237

   238

    for (minor = 0; minor < EC_TTY_MAX_DEVICES; minor++) {

   239

        if (!ttys[minor]) {

   240

            tty = kmalloc(sizeof(ec_tty_t), GFP_KERNEL);

   241

            if (!tty) {

   242

                up(&tty_sem);

   243

                printk(KERN_ERR PFX "Failed to allocate memory.\n");

   244

                return ERR_PTR(-ENOMEM);

   245

            }

   246

   247

            ret = ec_tty_init(tty, minor);

   248

            if (ret) {

   249

                up(&tty_sem);

   250

                kfree(tty);

   251

                return ERR_PTR(ret);

   252

            }

   253

   254

            ttys[minor] = tty;

   255

            up(&tty_sem);

   256

            return tty;

   257

        }

   258

    }

   259

   260

    up(&tty_sem);

   261

    printk(KERN_ERR PFX "No free interfaces avaliable.\n");

   262

    return ERR_PTR(-EBUSY);

   263

}

   264

   265

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

   266

   267

void ectty_free(ec_tty_t *tty)

   268

{

   269

    ec_tty_clear(tty);

   270

    ttys[tty->minor] = NULL;

   271

    kfree(tty);

   272

}

   273

   274

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

   275

   276

/** \cond */

   277

   278

module_init(ec_tty_init_module);

   279

module_exit(ec_tty_cleanup_module);

   280

   281

EXPORT_SYMBOL(ectty_create);

   282

EXPORT_SYMBOL(ectty_free);

   283

   284

/** \endcond */

   285

   286

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