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 32

    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

    69

void ec_tty_wakeup(unsigned long);

    70

    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

    unsigned int open_count;

   113

    struct semaphore sem;

   114

   115

    ec_tty_operations_t ops;

   116

    void *cb_data;

   117

};

   118

   119

static const struct tty_operations ec_tty_ops; // see below

   120

   121

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

   122

   123

/** Module initialization.

   124

 *

   125

 * \return 0 on success, else < 0

   126

 */

   127

int __init ec_tty_init_module(void)

   128

{

   129

    int i, ret = 0;

   130

   131

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

   132

   133

    sema_init(&tty_sem, 1);

   134

   135

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

   136

        ttys[i] = NULL;

   137

    }

   138

   139

    tty_driver = alloc_tty_driver(EC_TTY_MAX_DEVICES);

   140

    if (!tty_driver) {

   141

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

   142

        ret = -ENOMEM;

   143

        goto out_return;

   144

    }

   145

   146

    tty_driver->owner = THIS_MODULE;

   147

    tty_driver->driver_name = "EtherCAT TTY";

   148

    tty_driver->name = "ttyEC";

   149

    tty_driver->major = 0;

   150

    tty_driver->minor_start = 0;

   151

    tty_driver->type = TTY_DRIVER_TYPE_SERIAL;

   152

    tty_driver->subtype = SERIAL_TYPE_NORMAL;

   153

    tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;

   154

    tty_driver->init_termios = ec_tty_std_termios;

   155

    tty_set_operations(tty_driver, &ec_tty_ops);

   156

   157

    ret = tty_register_driver(tty_driver);

   158

    if (ret) {

   159

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

   160

        goto out_put;

   161

    }

   162

   163

    return ret;

   164

   165

out_put:

   166

    put_tty_driver(tty_driver);

   167

out_return:

   168

    return ret;

   169

}

   170

   171

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

   172

   173

/** Module cleanup.

   174

 *

   175

 * Clears all master instances.

   176

 */

   177

void __exit ec_tty_cleanup_module(void)

   178

{

   179

    tty_unregister_driver(tty_driver);

   180

    put_tty_driver(tty_driver);

   181

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

   182

}

   183

   184

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

   185

 * ec_tty_t methods.

   186

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

   187

   188

int ec_tty_init(ec_tty_t *t, int minor,

   189

        const ec_tty_operations_t *ops, void *cb_data)

   190

{

   191

    int ret;

   192

    tcflag_t cflag;

   193

    struct tty_struct *tty;

   194

   195

    t->minor = minor;

   196

    t->tx_read_idx = 0;

   197

    t->tx_write_idx = 0;

   198

    t->wakeup = 0;

   199

    t->rx_read_idx = 0;

   200

    t->rx_write_idx = 0;

   201

    init_timer(&t->timer);

   202

    t->tty = NULL;

   203

    t->open_count = 0;

   204

    sema_init(&t->sem, 1);

   205

    t->ops = *ops;

   206

    t->cb_data = cb_data;

   207

   208

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

   209

    if (IS_ERR(t->dev)) {

   210

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

   211

        return PTR_ERR(t->dev);

   212

    }

   213

   214

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

   215

    tty = tty_driver->ttys[minor];

   216

   217

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

   218

        cflag = tty->termios->c_cflag;

   219

    } else {

   220

        cflag = tty_driver->init_termios.c_cflag;

   221

    }

   222

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

   223

    if (ret) {

   224

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

   225

                cflag);

   226

        tty_unregister_device(tty_driver, t->minor);

   227

        return ret;

   228

    }

   229

   230

    t->timer.function = ec_tty_wakeup;

   231

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

   232

    t->timer.expires = jiffies + 10;

   233

    add_timer(&t->timer);

   234

    return 0;

   235

}

   236

   237

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

   238

   239

void ec_tty_clear(ec_tty_t *tty)

   240

{

   241

    del_timer_sync(&tty->timer);

   242

    tty_unregister_device(tty_driver, tty->minor);

   243

}

   244

   245

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

   246

   247

unsigned int ec_tty_tx_size(ec_tty_t *tty)

   248

{

   249

    unsigned int ret;

   250

   251

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

   252

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

   253

    } else {

   254

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

   255

    }

   256

   257

    return ret;

   258

}

   259

   260

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

   261

   262

unsigned int ec_tty_tx_space(ec_tty_t *tty)

   263

{

   264

    return EC_TTY_TX_BUFFER_SIZE - 1 - ec_tty_tx_size(tty);

   265

}

   266

   267

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

   268

   269

unsigned int ec_tty_rx_size(ec_tty_t *tty)

   270

{

   271

    unsigned int ret;

   272

   273

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

   274

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

   275

    } else {

   276

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

   277

    }

   278

   279

    return ret;

   280

}

   281

   282

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

   283

   284

unsigned int ec_tty_rx_space(ec_tty_t *tty)

   285

{

   286

    return EC_TTY_RX_BUFFER_SIZE - 1 - ec_tty_rx_size(tty);

   287

}

   288

   289

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

   290

   291

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

   292

{

   293

    struct serial_struct tmp;

   294

   295

    if (!data)

   296

        return -EFAULT;

   297

   298

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

   299

   300

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

   301

        return -EFAULT;

   302

    }

   303

    return 0;

   304

}

   305

   306

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

   307

   308

/** Timer function.

   309

 */

   310

void ec_tty_wakeup(unsigned long data)

   311

{

   312

    ec_tty_t *tty = (ec_tty_t *) data;

   313

    size_t to_recv;

   314

   315

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

   316

    if (tty->wakeup) {

   317

        if (tty->tty) {

   318

#if EC_TTY_DEBUG >= 1

   319

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

   320

#endif

   321

            tty_wakeup(tty->tty);

   322

        }

   323

        tty->wakeup = 0;

   324

    }

   325

   326

    /* Push received data into TTY core. */

   327

    to_recv = ec_tty_rx_size(tty);

   328

    if (to_recv && tty->tty) {

   329

        unsigned char *cbuf;

   330

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

   331

   332

        if (space < to_recv) {

   333

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

   334

                    to_recv, space);

   335

        }

   336

   337

        if (space < 0) {

   338

            to_recv = 0;

   339

        } else {

   340

            to_recv = space;

   341

        }

   342

   343

        if (to_recv) {

   344

            unsigned int i;

   345

   346

#if EC_TTY_DEBUG >= 1

   347

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

   348

#endif

   349

   350

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

   351

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

   352

                tty->rx_read_idx =

   353

                    (tty->rx_read_idx + 1) % EC_TTY_RX_BUFFER_SIZE;

   354

            }

   355

            tty_flip_buffer_push(tty->tty);

   356

        }

   357

    }

   358

   359

    tty->timer.expires += 1;

   360

    add_timer(&tty->timer);

   361

}

   362

   363

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

   364

 * Device callbacks

   365

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

   366

   367

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

   368

{

   369

    ec_tty_t *t;

   370

    int line = tty->index;

   371

   372

#if EC_TTY_DEBUG >= 1

   373

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

   374

            __func__, tty, file, line);

   375

#endif

   376

   377

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

   378

        tty->driver_data = NULL;

   379

        return -ENXIO;

   380

    }

   381

   382

    t = ttys[line];

   383

    if (!t) {

   384

        tty->driver_data = NULL;

   385

        return -ENXIO;

   386

    }

   387

   388

    if (!t->tty) {

   389

        t->tty = tty;

   390

        tty->driver_data = t;

   391

    }

   392

   393

    down(&t->sem);

   394

    t->open_count++;

   395

    up(&t->sem);

   396

    return 0;

   397

}

   398

   399

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

   400

   401

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

   402

{

   403

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

   404

   405

#if EC_TTY_DEBUG >= 1

   406

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

   407

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

   408

#endif

   409

   410

    if (t) {

   411

        down(&t->sem);

   412

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

   413

            t->tty = NULL;

   414

        }

   415

        up(&t->sem);

   416

    }

   417

}

   418

   419

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

   420

   421

static int ec_tty_write(

   422

        struct tty_struct *tty,

   423

        const unsigned char *buffer,

   424

        int count

   425

        )

   426

{

   427

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

   428

    unsigned int data_size, i;

   429

   430

#if EC_TTY_DEBUG >= 1

   431

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

   432

#endif

   433

   434

    if (count <= 0) {

   435

        return 0;

   436

    }

   437

   438

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

   439

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

   440

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

   441

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

   442

    }

   443

   444

#if EC_TTY_DEBUG >= 1

   445

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

   446

#endif

   447

    return data_size;

   448

}

   449

   450

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

   451

   452

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

   453

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

   454

#else

   455

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

   456

#endif

   457

{

   458

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

   459

   460

#if EC_TTY_DEBUG >= 1

   461

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

   462

#endif

   463

   464

    if (ec_tty_tx_space(t)) {

   465

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

   466

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

   467

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

   468

        return 1;

   469

#endif

   470

    } else {

   471

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

   472

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

   473

        return 0;

   474

#endif

   475

    }

   476

}

   477

   478

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

   479

   480

static int ec_tty_write_room(struct tty_struct *tty)

   481

{

   482

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

   483

    int ret = ec_tty_tx_space(t);

   484

   485

#if EC_TTY_DEBUG >= 2

   486

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

   487

#endif

   488

   489

    return ret;

   490

}

   491

   492

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

   493

   494