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/tty_flip.h>

    41

#include <linux/termios.h>

    42

#include <linux/timer.h>

    43

#include <linux/version.h>

    44

#include <linux/serial.h>

    45

#include <linux/uaccess.h>

    46

    47

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

    48

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

    49

    50

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

    51

    52

#define PFX "ec_tty: "

    53

    54

#define EC_TTY_MAX_DEVICES 10

    55

#define EC_TTY_TX_BUFFER_SIZE 100

    56

#define EC_TTY_RX_BUFFER_SIZE 100

    57

    58

#define EC_TTY_DEBUG 0

    59

    60

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

    61

    62

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

    63

unsigned int debug_level = 0;

    64

    65

static struct tty_driver *tty_driver = NULL;

    66

ec_tty_t *ttys[EC_TTY_MAX_DEVICES];

    67

struct semaphore tty_sem;

    68

    71

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

    72

    73

/** \cond */

    74

    75

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

    76

MODULE_DESCRIPTION("EtherCAT TTY driver module");

    77

MODULE_LICENSE("GPL");

    78

MODULE_VERSION(EC_MASTER_VERSION);

    79

    80

module_param_named(debug_level, debug_level, uint, S_IRUGO);

    81

MODULE_PARM_DESC(debug_level, "Debug level");

    82

    83

/** \endcond */

    84

    85

/** Standard termios for ec_tty devices.

    86

 *

    87

 * Simplest possible configuration, as you would expect.

    88

 */

    89

static struct ktermios ec_tty_std_termios = {

    90

    .c_iflag = 0,

    91

    .c_oflag = 0,

    92

    .c_cflag = B9600 | CS8 | CREAD,

    93

    .c_lflag = 0,

    94

    .c_cc = INIT_C_CC,

    95

};

    96

    97

struct ec_tty {

    98

    int minor;

    99

    struct device *dev;

   100

   101

    uint8_t tx_buffer[EC_TTY_TX_BUFFER_SIZE];

   102

    unsigned int tx_read_idx;

   103

    unsigned int tx_write_idx;

   104

    unsigned int wakeup;

   105

   106

    uint8_t rx_buffer[EC_TTY_RX_BUFFER_SIZE];

   107

    unsigned int rx_read_idx;

   108

    unsigned int rx_write_idx;

   109

   110

    struct timer_list timer;

   111

    struct tty_struct *tty;

   112

   113

    int (*cflag_cb)(void *, tcflag_t);

   114

    void *cb_data;

   115

};

   116

   117

static const struct tty_operations ec_tty_ops; // see below

   118

   119

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

   120

   121

/** Module initialization.

   122

 *

   123

 * \return 0 on success, else < 0

   124

 */

   125

int __init ec_tty_init_module(void)

   126

{

   127

    int i, ret = 0;

   128

   129

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

   130

   131

    init_MUTEX(&tty_sem);

   132

   133

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

   134

        ttys[i] = NULL;

   135

    }

   136

   137

    tty_driver = alloc_tty_driver(EC_TTY_MAX_DEVICES);

   138

    if (!tty_driver) {

   139

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

   140

        ret = -ENOMEM;

   141

        goto out_return;

   142

    }

   143

   144

    tty_driver->owner = THIS_MODULE;

   145

    tty_driver->driver_name = "EtherCAT TTY";

   146

    tty_driver->name = "ttyEC";

   147

    tty_driver->major = 0;

   148

    tty_driver->minor_start = 0;

   149

    tty_driver->type = TTY_DRIVER_TYPE_SERIAL;

   150

    tty_driver->subtype = SERIAL_TYPE_NORMAL;

   151

    tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;

   152

    tty_driver->init_termios = ec_tty_std_termios;

   153

    tty_set_operations(tty_driver, &ec_tty_ops);

   154

   155

    ret = tty_register_driver(tty_driver);

   156

    if (ret) {

   157

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

   158

        goto out_put;

   159

    }

   160

   161

    return ret;

   162

   163

out_put:

   164

    put_tty_driver(tty_driver);

   165

out_return:

   166

    return ret;

   167

}

   168

   169

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

   170

   171

/** Module cleanup.

   172

 *

   173

 * Clears all master instances.

   174

 */

   175

void __exit ec_tty_cleanup_module(void)

   176

{

   177

    tty_unregister_driver(tty_driver);

   178

    put_tty_driver(tty_driver);

   179

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

   180

}

   181

   185

   186

int ec_tty_init(ec_tty_t *tty, int minor,

   187

        int (*cflag_cb)(void *, tcflag_t), void *cb_data)

   188

{

   189

    tty->minor = minor;

   190

    tty->tx_read_idx = 0;

   191

    tty->tx_write_idx = 0;

   192

    tty->wakeup = 0;

   193

    tty->rx_read_idx = 0;

   194

    tty->rx_write_idx = 0;

   195

    init_timer(&tty->timer);

   196

    tty->tty = NULL;

   197

    tty->cflag_cb = cflag_cb;

   198

    tty->cb_data = cb_data;

   199

   200

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

   201

    if (IS_ERR(tty->dev)) {

   202

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

   203

        return PTR_ERR(tty->dev);

   204

    }

   205

   206

    tty->timer.function = ec_tty_wakeup;

   207

    tty->timer.data = (unsigned long) tty;

   208

    tty->timer.expires = jiffies + 10;

   209

    add_timer(&tty->timer);

   210

    return 0;

   211

}

   212

   213

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

   214

   215

void ec_tty_clear(ec_tty_t *tty)

   216

{

   217

    del_timer_sync(&tty->timer);

   218

    tty_unregister_device(tty_driver, tty->minor);

   219

}

   220

   221

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

   222

   267

int ec_tty_get_serial_info(ec_tty_t *tty, struct serial_struct *data)

   268

{

   269

    struct serial_struct tmp;

   270

   271

    if (!data)

   272

        return -EFAULT;

   273

   274

    memset(&tmp, 0, sizeof(tmp));

   275

   276

    if (copy_to_user(data, &tmp, sizeof(*data))) {

   277

        return -EFAULT;

   278

    }

   279

    return 0;

   280

}

   281

   339

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

   340

 * Device callbacks

   341

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

   342

   343

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

   344

{

   345

    ec_tty_t *t;

   346

    int line = tty->index, ret;

   347

   348

#if EC_TTY_DEBUG >= 1

   349

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

   350

#endif

   351

   352

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

   353

        return -ENXIO;

   354

    }

   355

   356

    t = ttys[line];

   357

    if (!t) {

   358

        return -ENXIO;

   359

    }

   360

   361

    if (t->tty) {

   362

        return -EBUSY;

   363

    }

   364

   365

    t->tty = tty;

   366

    tty->driver_data = t;

   367

   368

    // request initial settings

   369

    ret = t->cflag_cb(t->cb_data, t->tty->termios->c_cflag);

   370

    if (ret) {

   371

        printk(KERN_ERR PFX "Error: Device does not accept"

   372

                " initial configuration!\n");

   373

        return ret;

   374

    }

   375

   376

    return 0;

   377

}

   378

   379

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

   380

   381

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

   382

{

   383

    ec_tty_t *t = (ec_tty_t *) tty->driver_data;

   384

   385

#if EC_TTY_DEBUG >= 1

   386

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

   387

#endif

   388

   389

    if (t->tty == tty) {

   390

        t->tty = NULL;

   391

    }

   392

}

   393

   394

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

   395

   396

static int ec_tty_write(

   397

        struct tty_struct *tty,

   398

        const unsigned char *buffer,

   399

        int count

   400

        )

   401

{

   402

    ec_tty_t *t = (ec_tty_t *) tty->driver_data;

   403

    unsigned int data_size, i;

   404

   405

#if EC_TTY_DEBUG >= 1

   406

    printk(KERN_INFO PFX "%s(count=%i)\n", __func__, count);

   407

#endif

   408

   409

    if (count <= 0) {

   410

        return 0;

   411

    }

   412

   413

    data_size = min(ec_tty_tx_space(t), (unsigned int) count);

   414

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

   415

        t->tx_buffer[t->tx_write_idx] = buffer[i];

   416

        t->tx_write_idx = (t->tx_write_idx + 1) % EC_TTY_TX_BUFFER_SIZE;

   417

    }

   418

   419

#if EC_TTY_DEBUG >= 1

   420

    printk(KERN_INFO PFX "%s(): %u bytes written.\n", __func__, data_size);

   421

#endif

   422

    return data_size;

   423

}

   424

   425

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

   426

   427

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)

   428

static int ec_tty_put_char(struct tty_struct *tty, unsigned char ch)

   429

#else

   430

static void ec_tty_put_char(struct tty_struct *tty, unsigned char ch)

   431

#endif

   432

{

   433

    ec_tty_t *t = (ec_tty_t *) tty->driver_data;

   434

   435

#if EC_TTY_DEBUG >= 1

   436

    printk(KERN_INFO PFX "%s(): c=%02x.\n", __func__, (unsigned int) ch);

   437

#endif

   438

   439

    if (ec_tty_tx_space(t)) {

   440

        t->tx_buffer[t->tx_write_idx] = ch;

   441

        t->tx_write_idx = (t->tx_write_idx + 1) % EC_TTY_TX_BUFFER_SIZE;

   442

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)

   443

        return 1;

   444

#endif

   445

    } else {

   446

        printk(KERN_WARNING PFX "%s(): Dropped a byte!\n", __func__);

   447

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26)

   448

        return 0;

   449

#endif

   450

    }

   451

}

   452

   453

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

   454

   455

static int ec_tty_write_room(struct tty_struct *tty)

   456

{

   457

    ec_tty_t *t = (ec_tty_t *) tty->driver_data;

   458

    int ret = ec_tty_tx_space(t);

   459

   460

#if EC_TTY_DEBUG >= 2

   461

    printk(KERN_INFO PFX "%s() = %i.\n", __func__, ret);

   462

#endif

   463

   464

    return ret;

   465

}

   466

   467

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

   468

   469

static int ec_tty_chars_in_buffer(struct tty_struct *tty)

   470

{

   471

    ec_tty_t *t = (ec_tty_t *) tty->driver_data;

   472

    int ret;

   473

   474

#if EC_TTY_DEBUG >= 2

   475

    printk(KERN_INFO PFX "%s().\n", __func__);

   476

#endif

   477

   478

    ret = ec_tty_tx_size(t);

   479

   480

#if EC_TTY_DEBUG >= 2

   481

    printk(KERN_INFO PFX "%s() = %i.\n", __func__, ret);

   482

#endif

   483

   484

    return ret;

   485

}

   486

   487

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

   488

   489

static void ec_tty_flush_buffer(struct tty_struct *tty)

   490

{

   491

#if EC_TTY_DEBUG >= 2

   492

    printk(KERN_INFO PFX "%s().\n", __func__);

   493

#endif

   494