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

    45

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

    46

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

    47

    48

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

    49

    50

#define PFX "ec_tty: "

    51

    52

#define EC_TTY_MAX_DEVICES 10

    53

#define EC_TTY_TX_BUFFER_SIZE 100

    54

#define EC_TTY_RX_BUFFER_SIZE 100

    55

    56

#define EC_TTY_DEBUG 0

    57

    58

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

    59

    60

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

    61

unsigned int debug_level = 0;

    62

    63

static struct tty_driver *tty_driver = NULL;

    64

ec_tty_t *ttys[EC_TTY_MAX_DEVICES];

    65

struct semaphore tty_sem;

    66

    67

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

    68

    69

/** \cond */

    70

    71

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

    72

MODULE_DESCRIPTION("EtherCAT TTY driver module");

    73

MODULE_LICENSE("GPL");

    74

MODULE_VERSION(EC_MASTER_VERSION);

    75

    76

module_param_named(debug_level, debug_level, uint, S_IRUGO);

    77

MODULE_PARM_DESC(debug_level, "Debug level");

    78

    79

/** \endcond */

    80

    81

static struct ktermios ec_tty_std_termios = {

    82

    .c_iflag = ICRNL | IXON,

    83

    .c_oflag = OPOST,

    84

    .c_cflag = B38400 | CS8 | CREAD | HUPCL,

    85

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

    86

    .c_cc = INIT_C_CC,

    87

};

    88

    89

struct ec_tty {

    90

    int minor;

    91

    struct device *dev;

    92

    93

    uint8_t tx_buffer[EC_TTY_TX_BUFFER_SIZE];

    94

    unsigned int tx_read_idx;

    95

    unsigned int tx_write_idx;

    96

    unsigned int wakeup;

    97

    98

    uint8_t rx_buffer[EC_TTY_RX_BUFFER_SIZE];

    99

    unsigned int rx_read_idx;

   100

    unsigned int rx_write_idx;

   101

   102

    struct timer_list timer;

   103

    struct tty_struct *tty;

   104

};

   105

   106

static const struct tty_operations ec_tty_ops; // see below

   107

   108

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

   109

   110

/** Module initialization.

   111

 *

   112

 * \return 0 on success, else < 0

   113

 */

   114

int __init ec_tty_init_module(void)

   115

{

   116

    int i, ret = 0;

   117

   118

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

   119

   120

    init_MUTEX(&tty_sem);

   121

   122

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

   123

        ttys[i] = NULL;

   124

    }

   125

   126

    tty_driver = alloc_tty_driver(EC_TTY_MAX_DEVICES);

   127

    if (!tty_driver) {

   128

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

   129

        ret = -ENOMEM;

   130

        goto out_return;

   131

    }

   132

   133

    tty_driver->owner = THIS_MODULE;

   134

    tty_driver->driver_name = "EtherCAT TTY";

   135

    tty_driver->name = "ttyEC";

   136

    tty_driver->major = 0;

   137

    tty_driver->minor_start = 0;

   138

    tty_driver->type = TTY_DRIVER_TYPE_SERIAL;

   139

    tty_driver->subtype = SERIAL_TYPE_NORMAL;

   140

    tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;

   141

    tty_driver->init_termios = ec_tty_std_termios;

   142

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

   143

    tty_set_operations(tty_driver, &ec_tty_ops);

   144

   145

    ret = tty_register_driver(tty_driver);

   146

    if (ret) {

   147

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

   148

        goto out_put;

   149

    }

   150

   151

    return ret;

   152

   153

out_put:

   154

    put_tty_driver(tty_driver);

   155

out_return:

   156

    return ret;

   157

}

   158

   159

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

   160

   161

/** Module cleanup.

   162

 *

   163

 * Clears all master instances.

   164

 */

   165

void __exit ec_tty_cleanup_module(void)

   166

{

   167

    tty_unregister_driver(tty_driver);

   168

    put_tty_driver(tty_driver);

   169

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

   170

}

   171

   172

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

   173

   174

unsigned int ec_tty_tx_size(ec_tty_t *tty)

   175

{

   176

    unsigned int ret;

   177

   178

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

   179

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

   180

    } else {

   181

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

   182

    }

   183

   184

    return ret;

   185

}

   186

   187

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

   188

   189

unsigned int ec_tty_tx_space(ec_tty_t *tty)

   190

{

   191

    return EC_TTY_TX_BUFFER_SIZE - 1 - ec_tty_tx_size(tty);

   192

}

   193

   194

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

   195

   196

unsigned int ec_tty_rx_size(ec_tty_t *tty)

   197

{

   198

    unsigned int ret;

   199

   200

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

   201

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

   202

    } else {

   203

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

   204

    }

   205

   206

    return ret;

   207

}

   208

   209

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

   210

   211

unsigned int ec_tty_rx_space(ec_tty_t *tty)

   212

{

   213

    return EC_TTY_RX_BUFFER_SIZE - 1 - ec_tty_rx_size(tty);

   214

}

   215

   216

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

   217

   218

void ec_tty_wakeup(unsigned long data)

   219

{

   220

    ec_tty_t *tty = (ec_tty_t *) data;

   221

    size_t to_recv;

   222

   223

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

   224

    if (tty->wakeup) {

   225

        if (tty->tty) {

   226

#if EC_TTY_DEBUG >= 1

   227

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

   228

#endif

   229

            tty_wakeup(tty->tty);

   230

        }

   231

        tty->wakeup = 0;

   232

    }

   233

   234

    /* Push received data into TTY core. */

   235

    to_recv = ec_tty_rx_size(tty);

   236

    if (to_recv && tty->tty) {

   237

        unsigned char *cbuf;

   238

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

   239

   240

		if (space < to_recv) {

   241

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

   242

                    to_recv, space);

   243

		}

   244

   245

        if (space < 0) {

   246

            to_recv = 0;

   247

        } else {

   248

            to_recv = space;

   249

        }

   250

   251

        if (to_recv) {

   252

            unsigned int i;

   253

   254

#if EC_TTY_DEBUG >= 1

   255

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

   256

#endif

   257

   258

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

   259

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

   260

                tty->rx_read_idx = (tty->rx_read_idx + 1) % EC_TTY_RX_BUFFER_SIZE;

   261

            }

   262

            tty_flip_buffer_push(tty->tty);

   263

        }

   264

	}

   265

   266

    tty->timer.expires += 1;

   267

    add_timer(&tty->timer);

   268

}

   269

   270

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

   271

   272

int ec_tty_init(ec_tty_t *tty, int minor)

   273

{

   274

    tty->minor = minor;

   275

    tty->tx_read_idx = 0;

   276

    tty->tx_write_idx = 0;

   277

    tty->wakeup = 0;

   278

    tty->rx_read_idx = 0;

   279

    tty->rx_write_idx = 0;

   280

    init_timer(&tty->timer);

   281

    tty->tty = NULL;

   282

   283

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

   284

    if (IS_ERR(tty->dev)) {

   285

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

   286

        return PTR_ERR(tty->dev);

   287

    }

   288

   289

    tty->timer.function = ec_tty_wakeup;

   290

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

   291

    tty->timer.expires = jiffies + 10;

   292

    add_timer(&tty->timer);

   293

    return 0;

   294

}

   295

   296

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

   297

   298

void ec_tty_clear(ec_tty_t *tty)

   299

{

   300

    del_timer_sync(&tty->timer);

   301

    tty_unregister_device(tty_driver, tty->minor);

   302

}

   303

   304

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

   305

 * Device callbacks

   306

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

   307

   308

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

   309

{

   310

    ec_tty_t *t;

   311

    int line = tty->index;

   312

   313

#if EC_TTY_DEBUG >= 1

   314

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

   315

#endif

   316

   317

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

   318

		return -ENXIO;

   319

    }

   320

   321

    t = ttys[line];

   322

    if (!t) {

   323

        return -ENXIO;

   324

    }

   325

   326

    if (t->tty) {

   327

        return -EBUSY;

   328

    }

   329

   330

    t->tty = tty;

   331

    tty->driver_data = t;

   332

    return 0;

   333

}

   334

   335

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

   336

   337

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

   338

{

   339

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

   340

   341

#if EC_TTY_DEBUG >= 1

   342

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

   343

#endif

   344

   345

    if (t->tty == tty) {

   346

        t->tty = NULL;

   347

    }

   348

}

   349

   350

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

   351

   352

static int ec_tty_write(

   353

        struct tty_struct *tty,

   354

        const unsigned char *buffer,

   355

        int count

   356

        )

   357

{

   358

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

   359

    unsigned int data_size, i;

   360

   361

#if EC_TTY_DEBUG >= 1

   362

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

   363

#endif

   364

   365

    if (count <= 0) {

   366

        return 0;

   367

    }

   368

   369

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

   370

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

   371

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

   372

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

   373

    }

   374

   375

#if EC_TTY_DEBUG >= 1

   376

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

   377

#endif

   378

    return data_size;

   379

}

   380

   381

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

   382

   383

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

   384

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

   385

#else

   386

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

   387

#endif

   388

{

   389

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

   390

   391

#if EC_TTY_DEBUG >= 1

   392

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

   393

#endif

   394

   395

    if (ec_tty_tx_space(t)) {

   396

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

   397

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

   398

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

   399

        return 1;

   400

#endif

   401

    } else {

   402

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

   403

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

   404

        return 0;

   405

#endif

   406

    }

   407

}

   408

   409

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

   410

   411

static int ec_tty_write_room(struct tty_struct *tty)

   412

{

   413

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

   414

    int ret = ec_tty_tx_space(t);

   415

   416

#if EC_TTY_DEBUG >= 2

   417

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

   418

#endif

   419

   420

    return ret;

   421

}

   422

   423

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

   424

   425

static int ec_tty_chars_in_buffer(struct tty_struct *tty)

   426

{

   427

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

   428

    int ret;

   429

   430

#if EC_TTY_DEBUG >= 2

   431

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

   432

#endif

   433

   434

    ret = ec_tty_tx_size(t);

   435

   436

#if EC_TTY_DEBUG >= 2

   437

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

   438

#endif

   439

   440

    return ret;

   441

}

   442

   443

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

   444

   445

static void ec_tty_flush_buffer(struct tty_struct *tty)

   446

{

   447

#if EC_TTY_DEBUG >= 2

   448

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

   449

#endif

   450

}

   451

   452

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

   453

   454

static int ec_tty_ioctl(struct tty_struct *tty, struct file *file,

   455

		    unsigned int cmd, unsigned long arg)

   456

{

   457

#if EC_TTY_DEBUG >= 2

   458

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

   459

#endif

   460

    return -ENOTTY;

   461

}

   462

   463

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

   464

   465

static void ec_tty_throttle(struct tty_struct *tty)

   466

{

   467

#if EC_TTY_DEBUG >= 2

   468

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

   469

#endif

   470

}

   471

   472

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

   473

   474

static void ec_tty_unthrottle(struct tty_struct *tty)

   475

{

   476

#if EC_TTY_DEBUG >= 2

   477

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

   478

#endif

   479

}

   480

   481

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

   482

   483

static void ec_tty_set_termios(struct tty_struct *tty,

   484

			   struct ktermios *old_termios)

   485

{

   486

#if EC_TTY_DEBUG >= 2

   487

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

   488

#endif

   489

}

   490

   491

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

   492

   493

static void ec_tty_stop(struct tty_struct *tty)

   494

{

   495

#if EC_TTY_DEBUG >= 2