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 ec_mutex_t 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 ec_mutex_t 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

    ec_mutex_init(&tty_sem);

   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

   196

    t->minor = minor;

   197

    t->tx_read_idx = 0;

   198

    t->tx_write_idx = 0;

   199

    t->wakeup = 0;

   200

    t->rx_read_idx = 0;

   201

    t->rx_write_idx = 0;

   202

    init_timer(&t->timer);

   203

    t->tty = NULL;

   204

    t->open_count = 0;

   205

    ec_mutex_init(&t->sem);

   206

    t->ops = *ops;

   207

    t->cb_data = cb_data;

   208

   209

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

   210

    if (IS_ERR(t->dev)) {

   211

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

   212

        return PTR_ERR(t->dev);

   213

    }

   214

   215

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

   216

    tty = tty_driver->ttys[minor];

   217

   218

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

   219

        cflag = tty->termios->c_cflag;

   220

    } else {

   221

        cflag = tty_driver->init_termios.c_cflag;

   222

    }

   223

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

   224

    if (ret) {

   225

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

   226

                cflag);

   227

        tty_unregister_device(tty_driver, t->minor);

   228

        return ret;

   229

    }

   230

   231

    t->timer.function = ec_tty_wakeup;

   232

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

   233

    t->timer.expires = jiffies + 10;

   234

    add_timer(&t->timer);

   235

    return 0;

   236

}

   237

   238

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

   239

   240

void ec_tty_clear(ec_tty_t *tty)

   241

{

   242

    del_timer_sync(&tty->timer);

   243

    tty_unregister_device(tty_driver, tty->minor);

   244

}

   245

   246

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

   247

   248

unsigned int ec_tty_tx_size(ec_tty_t *tty)

   249

{

   250

    unsigned int ret;

   251

   252

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

   253

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

   254

    } else {

   255

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

   256

    }

   257

   258

    return ret;

   259

}

   260

   261

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

   262

   263

unsigned int ec_tty_tx_space(ec_tty_t *tty)

   264

{

   265

    return EC_TTY_TX_BUFFER_SIZE - 1 - ec_tty_tx_size(tty);

   266

}

   267

   268

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

   269

   270

unsigned int ec_tty_rx_size(ec_tty_t *tty)

   271

{

   272

    unsigned int ret;

   273

   274

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

   275

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

   276

    } else {

   277

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

   278

    }

   279

   280

    return ret;

   281

}

   282

   283

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

   284

   285

unsigned int ec_tty_rx_space(ec_tty_t *tty)

   286

{

   287

    return EC_TTY_RX_BUFFER_SIZE - 1 - ec_tty_rx_size(tty);

   288

}

   289

   290

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

   291

   292

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

   293

{

   294

    struct serial_struct tmp;

   295

   296

    if (!data)

   297

        return -EFAULT;

   298

   299

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

   300

   301

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

   302

        return -EFAULT;

   303

    }

   304

    return 0;

   305

}

   306

   307

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

   308

   309

/** Timer function.

   310

 */

   311

void ec_tty_wakeup(unsigned long data)

   312

{

   313

    ec_tty_t *tty = (ec_tty_t *) data;

   314

    size_t to_recv;

   315

   316

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

   317

    if (tty->wakeup) {

   318

        if (tty->tty) {

   319

#if EC_TTY_DEBUG >= 1

   320

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

   321

#endif

   322

            tty_wakeup(tty->tty);

   323

        }

   324

        tty->wakeup = 0;

   325

    }

   326

   327

    /* Push received data into TTY core. */

   328

    to_recv = ec_tty_rx_size(tty);

   329

    if (to_recv && tty->tty) {

   330

        unsigned char *cbuf;

   331

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

   332

   333

        if (space < to_recv) {

   334

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

   335

                    to_recv, space);

   336

        }

   337

   338

        if (space < 0) {

   339

            to_recv = 0;

   340

        } else {

   341

            to_recv = space;

   342

        }

   343

   344

        if (to_recv) {

   345

            unsigned int i;

   346

   347

#if EC_TTY_DEBUG >= 1

   348

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

   349

#endif

   350

   351

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

   352

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

   353

                tty->rx_read_idx =

   354

                    (tty->rx_read_idx + 1) % EC_TTY_RX_BUFFER_SIZE;

   355

            }

   356

            tty_flip_buffer_push(tty->tty);

   357

        }

   358

    }

   359

   360

    tty->timer.expires += 1;

   361

    add_timer(&tty->timer);

   362

}

   363

   364

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

   365

 * Device callbacks

   366

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

   367

   368

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

   369

{

   370

    ec_tty_t *t;

   371

    int line = tty->index;

   372

   373

#if EC_TTY_DEBUG >= 1

   374

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

   375

            __func__, tty, file, line);

   376

#endif

   377

   378

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

   379

        tty->driver_data = NULL;

   380

        return -ENXIO;

   381

    }

   382

   383

    t = ttys[line];

   384

    if (!t) {

   385

        tty->driver_data = NULL;

   386

        return -ENXIO;

   387

    }

   388

   389

    if (!t->tty) {

   390

        t->tty = tty;

   391

        tty->driver_data = t;

   392

    }

   393

   394

    ec_mutex_lock(&t->sem);

   395

    t->open_count++;

   396

    ec_mutex_unlock(&t->sem);

   397

    return 0;

   398

}

   399

   400

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

   401

   402

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

   403

{

   404

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

   405

   406

#if EC_TTY_DEBUG >= 1

   407

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

   408

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

   409

#endif

   410

   411

    if (t) {

   412

        ec_mutex_lock(&t->sem);

   413

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

   414

            t->tty = NULL;

   415

        }

   416

        ec_mutex_unlock(&t->sem);

   417

    }

   418

}

   419

   420

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

   421

   422

static int ec_tty_write(

   423

        struct tty_struct *tty,

   424

        const unsigned char *buffer,

   425

        int count

   426

        )

   427

{

   428

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

   429

    unsigned int data_size, i;

   430

   431

#if EC_TTY_DEBUG >= 1

   432

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

   433

#endif

   434

   435

    if (count <= 0) {

   436

        return 0;

   437

    }

   438

   439

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

   440

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

   441

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

   442

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

   443

    }

   444

   445

#if EC_TTY_DEBUG >= 1

   446

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

   447

#endif

   448

    return data_size;

   449

}

   450

   451

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

   452

   453

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

   454

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

   455

#else

   456

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

   457

#endif

   458

{

   459

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

   460

   461

#if EC_TTY_DEBUG >= 1

   462

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

   463

#endif

   464

   465

    if (ec_tty_tx_space(t)) {

   466

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

   467

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

   468

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

   469

        return 1;

   470

#endif

   471

    } else {

   472

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

   473

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

   474

        return 0;

   475

#endif

   476

    }

   477

}

   478

   479

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

   480

   481

static int ec_tty_write_room(struct tty_struct *tty)

   482

{

   483

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

   484

    int ret = ec_tty_tx_space(t);

   485

   486

#if EC_TTY_DEBUG >= 2

   487

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

   488

#endif

   489

   490

    return ret;

   491

}

   492

   493

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