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

#include <linux/slab.h>

    47

    48

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

    49

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

    50

    51

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

    52

    53

#define PFX "ec_tty: "

    54

    55

#define EC_TTY_MAX_DEVICES 32

    56

#define EC_TTY_TX_BUFFER_SIZE 100

    57

#define EC_TTY_RX_BUFFER_SIZE 100

    58

    59

#define EC_TTY_DEBUG 0

    60

    61

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

    62

    63

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

    64

unsigned int debug_level = 0;

    65

    66

static struct tty_driver *tty_driver = NULL;

    67

ec_tty_t *ttys[EC_TTY_MAX_DEVICES];

    68

struct semaphore tty_sem;

    69

    70

void ec_tty_wakeup(unsigned long);

    71

    72

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

    73

    74

/** \cond */

    75

    76

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

    77

MODULE_DESCRIPTION("EtherCAT TTY driver module");

    78

MODULE_LICENSE("GPL");

    79

MODULE_VERSION(EC_MASTER_VERSION);

    80

    81

module_param_named(debug_level, debug_level, uint, S_IRUGO);

    82

MODULE_PARM_DESC(debug_level, "Debug level");

    83

    84

/** \endcond */

    85

    86

/** Standard termios for ec_tty devices.

    87

 *

    88

 * Simplest possible configuration, as you would expect.

    89

 */

    90

static struct ktermios ec_tty_std_termios = {

    91

    .c_iflag = 0,

    92

    .c_oflag = 0,

    93

    .c_cflag = B9600 | CS8 | CREAD,

    94

    .c_lflag = 0,

    95

    .c_cc = INIT_C_CC,

    96

};

    97

    98

struct ec_tty {

    99

    int minor;

   100

    struct device *dev;

   101

   102

    uint8_t tx_buffer[EC_TTY_TX_BUFFER_SIZE];

   103

    unsigned int tx_read_idx;

   104

    unsigned int tx_write_idx;

   105

    unsigned int wakeup;

   106

   107

    uint8_t rx_buffer[EC_TTY_RX_BUFFER_SIZE];

   108

    unsigned int rx_read_idx;

   109

    unsigned int rx_write_idx;

   110

   111

    struct timer_list timer;

   112

    struct tty_struct *tty;

   113

    unsigned int open_count;

   114

    struct semaphore sem;

   115

   116

    ec_tty_operations_t ops;

   117

    void *cb_data;

   118

};

   119

   120

static const struct tty_operations ec_tty_ops; // see below

   121

   122

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

   123

   124

/** Module initialization.

   125

 *

   126

 * \return 0 on success, else < 0

   127

 */

   128

int __init ec_tty_init_module(void)

   129

{

   130

    int i, ret = 0;

   131

   132

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

   133

   134

    sema_init(&tty_sem, 1);

   135

   136

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

   137

        ttys[i] = NULL;

   138

    }

   139

   140

    tty_driver = alloc_tty_driver(EC_TTY_MAX_DEVICES);

   141

    if (!tty_driver) {

   142

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

   143

        ret = -ENOMEM;

   144

        goto out_return;

   145

    }

   146

   147

    tty_driver->owner = THIS_MODULE;

   148

    tty_driver->driver_name = "EtherCAT TTY";

   149

    tty_driver->name = "ttyEC";

   150

    tty_driver->major = 0;

   151

    tty_driver->minor_start = 0;

   152

    tty_driver->type = TTY_DRIVER_TYPE_SERIAL;

   153

    tty_driver->subtype = SERIAL_TYPE_NORMAL;

   154

    tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;

   155

    tty_driver->init_termios = ec_tty_std_termios;

   156

    tty_set_operations(tty_driver, &ec_tty_ops);

   157

   158

    ret = tty_register_driver(tty_driver);

   159

    if (ret) {

   160

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

   161

        goto out_put;

   162

    }

   163

   164

    return ret;

   165

   166

out_put:

   167

    put_tty_driver(tty_driver);

   168

out_return:

   169

    return ret;

   170

}

   171

   172

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

   173

   174

/** Module cleanup.

   175

 *

   176

 * Clears all master instances.

   177

 */

   178

void __exit ec_tty_cleanup_module(void)

   179

{

   180

    tty_unregister_driver(tty_driver);

   181

    put_tty_driver(tty_driver);

   182

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

   183

}

   184

   185

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

   186

 * ec_tty_t methods.

   187

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

   188

   189

int ec_tty_init(ec_tty_t *t, int minor,

   190

        const ec_tty_operations_t *ops, void *cb_data)

   191

{

   192

    int ret;

   193

    tcflag_t cflag;

   194

    struct tty_struct *tty;

   195

    struct ktermios *termios;

   196

   197

    t->minor = minor;

   198

    t->tx_read_idx = 0;

   199

    t->tx_write_idx = 0;

   200

    t->wakeup = 0;

   201

    t->rx_read_idx = 0;

   202

    t->rx_write_idx = 0;

   203

    init_timer(&t->timer);

   204

    t->tty = NULL;

   205

    t->open_count = 0;

   206

    sema_init(&t->sem, 1);

   207

    t->ops = *ops;

   208

    t->cb_data = cb_data;

   209

   210

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

   211

    if (IS_ERR(t->dev)) {

   212

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

   213

        return PTR_ERR(t->dev);

   214

    }

   215

   216

    // Tell the device-specific implementation about the initial cflags

   217

    tty = tty_driver->ttys[minor];

   218

   219

    termios =

   220

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 0)

   221

        &tty->termios

   222

#else

   223

        tty->termios

   224

#endif

   225

        ;

   226

   227

    if (tty && termios) { // already opened before

   228

        cflag = termios->c_cflag;

   229

    } else {

   230

        cflag = tty_driver->init_termios.c_cflag;

   231

    }

   232

    ret = t->ops.cflag_changed(t->cb_data, cflag);

   233

    if (ret) {

   234

        printk(KERN_ERR PFX "ERROR: Initial cflag 0x%x not accepted.\n",

   235

                cflag);

   236

        tty_unregister_device(tty_driver, t->minor);

   237

        return ret;

   238

    }

   239

   240

    t->timer.function = ec_tty_wakeup;

   241

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

   242

    t->timer.expires = jiffies + 10;

   243

    add_timer(&t->timer);

   244

    return 0;

   245

}

   246

   247

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

   248

   249

void ec_tty_clear(ec_tty_t *tty)

   250

{

   251

    del_timer_sync(&tty->timer);

   252

    tty_unregister_device(tty_driver, tty->minor);

   253

}

   254

   255

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

   256

   257

unsigned int ec_tty_tx_size(ec_tty_t *tty)

   258

{

   259

    unsigned int ret;

   260

   261

    if (tty->tx_write_idx >= tty->tx_read_idx) {

   262

        ret = tty->tx_write_idx - tty->tx_read_idx;

   263

    } else {

   264

        ret = EC_TTY_TX_BUFFER_SIZE + tty->tx_write_idx - tty->tx_read_idx;

   265

    }

   266

   267

    return ret;

   268

}

   269

   270

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

   271

   272

unsigned int ec_tty_tx_space(ec_tty_t *tty)

   273

{

   274

    return EC_TTY_TX_BUFFER_SIZE - 1 - ec_tty_tx_size(tty);

   275

}

   276

   277

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

   278

   279

unsigned int ec_tty_rx_size(ec_tty_t *tty)

   280

{

   281

    unsigned int ret;

   282

   283

    if (tty->rx_write_idx >= tty->rx_read_idx) {

   284

        ret = tty->rx_write_idx - tty->rx_read_idx;

   285

    } else {

   286

        ret = EC_TTY_RX_BUFFER_SIZE + tty->rx_write_idx - tty->rx_read_idx;

   287

    }

   288

   289

    return ret;

   290

}

   291

   292

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

   293

   294

unsigned int ec_tty_rx_space(ec_tty_t *tty)

   295

{

   296

    return EC_TTY_RX_BUFFER_SIZE - 1 - ec_tty_rx_size(tty);

   297

}

   298

   299

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

   300

   301

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

   302

{

   303

    struct serial_struct tmp;

   304

   305

    if (!data)

   306

        return -EFAULT;

   307

   308

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

   309

   310

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

   311

        return -EFAULT;

   312

    }

   313

    return 0;

   314

}

   315

   316

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

   317

   318

/** Timer function.

   319

 */

   320

void ec_tty_wakeup(unsigned long data)

   321

{

   322

    ec_tty_t *tty = (ec_tty_t *) data;

   323

    size_t to_recv;

   324

   325

    /* Wake up any process waiting to send data */

   326

    if (tty->wakeup) {

   327

        if (tty->tty) {

   328

#if EC_TTY_DEBUG >= 1

   329

            printk(KERN_INFO PFX "Waking up.\n");

   330

#endif

   331

            tty_wakeup(tty->tty);

   332

        }

   333

        tty->wakeup = 0;

   334

    }

   335

   336

    /* Push received data into TTY core. */

   337

    to_recv = ec_tty_rx_size(tty);

   338

    if (to_recv && tty->tty) {

   339

        unsigned char *cbuf;

   340

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 9, 0)

   341

        int space = tty_prepare_flip_string(tty->tty->port, &cbuf, to_recv);

   342

#else

   343

        int space = tty_prepare_flip_string(tty->tty, &cbuf, to_recv);

   344

#endif

   345

   346

        if (space < to_recv) {

   347

            printk(KERN_WARNING PFX "Insufficient space to_recv=%d space=%d\n",

   348

                    to_recv, space);

   349

        }

   350

   351

        if (space < 0) {

   352

            to_recv = 0;

   353

        } else {

   354

            to_recv = space;

   355

        }

   356

   357

        if (to_recv) {

   358

            unsigned int i;

   359

   360

#if EC_TTY_DEBUG >= 1

   361

            printk(KERN_INFO PFX "Pushing %u bytes to TTY core.\n", to_recv);

   362

#endif

   363

   364

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

   365

                cbuf[i] = tty->rx_buffer[tty->rx_read_idx];

   366

                tty->rx_read_idx =

   367

                    (tty->rx_read_idx + 1) % EC_TTY_RX_BUFFER_SIZE;

   368

            }

   369

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 9, 0)

   370

            tty_flip_buffer_push(tty->tty->port);

   371

#else

   372

            tty_flip_buffer_push(tty->tty);

   373

#endif

   374

        }

   375

    }

   376

   377

    tty->timer.expires += 1;

   378

    add_timer(&tty->timer);

   379

}

   380

   381

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

   382

 * Device callbacks

   383

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

   384

   385

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

   386

{

   387

    ec_tty_t *t;

   388

    int line = tty->index;

   389

   390

#if EC_TTY_DEBUG >= 1

   391

    printk(KERN_INFO PFX "%s(tty=%p, file=%p): Opening line %i.\n",

   392

            __func__, tty, file, line);

   393

#endif

   394

   395

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

   396

        tty->driver_data = NULL;

   397

        return -ENXIO;

   398

    }

   399

   400

    t = ttys[line];

   401

    if (!t) {

   402

        tty->driver_data = NULL;

   403

        return -ENXIO;

   404

    }

   405

   406

    if (!t->tty) {

   407

        t->tty = tty;

   408

        tty->driver_data = t;

   409

    }

   410

   411

    down(&t->sem);

   412

    t->open_count++;

   413

    up(&t->sem);

   414

    return 0;

   415

}

   416

   417

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

   418

   419

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

   420

{

   421

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

   422

   423

#if EC_TTY_DEBUG >= 1

   424

    printk(KERN_INFO PFX "%s(tty=%p, file=%p): Closing line %i.\n",

   425

            __func__, tty, file, tty->index);

   426

#endif

   427

   428

    if (t) {

   429

        down(&t->sem);

   430

        if (--t->open_count == 0) {

   431

            t->tty = NULL;

   432

        }

   433

        up(&t->sem);

   434

    }

   435

}

   436

   437

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

   438

   439

static int ec_tty_write(

   440

        struct tty_struct *tty,

   441

        const unsigned char *buffer,

   442

        int count

   443

        )

   444

{

   445

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

   446

    unsigned int data_size, i;

   447

   448

#if EC_TTY_DEBUG >= 1

   449

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

   450

#endif

   451

   452

    if (count <= 0) {

   453

        return 0;

   454

    }

   455

   456

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

   457

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

   458

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

   459

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

   460

    }

   461

   462

#if EC_TTY_DEBUG >= 1

   463

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

   464

#endif

   465

    return data_size;

   466

}

   467

   468

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

   469

   470

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

   471

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

   472

#else

   473

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

   474

#endif

   475

{

   476

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

   477

   478

#if EC_TTY_DEBUG >= 1

   479

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

   480

#endif

   481

   482

    if (ec_tty_tx_space(t)) {

   483

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

   484

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

   485

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

   486

        return 1;

   487

#endif

   488

    } else {

   489

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

   490

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

   491

        return 0;

   492

#endif