drivers/tty/n_r3964.c

   1 // SPDX-License-Identifier: GPL-1.0+
   2 /* r3964 linediscipline for linux
   3  *
   4  * -----------------------------------------------------------
   5  * Copyright by
   6  * Philips Automation Projects
   7  * Kassel (Germany)
   8  * -----------------------------------------------------------
   9  * Author:
  10  * L. Haag
  11  *
  12  * $Log: n_r3964.c,v $
  13  * Revision 1.10  2001/03/18 13:02:24  dwmw2
  14  * Fix timer usage, use spinlocks properly.
  15  *
  16  * Revision 1.9  2001/03/18 12:52:14  dwmw2
  17  * Merge changes in 2.4.2
  18  *
  19  * Revision 1.8  2000/03/23 14:14:54  dwmw2
  20  * Fix race in sleeping in r3964_read()
  21  *
  22  * Revision 1.7  1999/28/08 11:41:50  dwmw2
  23  * Port to 2.3 kernel
  24  *
  25  * Revision 1.6  1998/09/30 00:40:40  dwmw2
  26  * Fixed compilation on 2.0.x kernels
  27  * Updated to newly registered tty-ldisc number 9
  28  *
  29  * Revision 1.5  1998/09/04 21:57:36  dwmw2
  30  * Signal handling bug fixes, port to 2.1.x.
  31  *
  32  * Revision 1.4  1998/04/02 20:26:59  lhaag
  33  * select, blocking, ...
  34  *
  35  * Revision 1.3  1998/02/12 18:58:43  root
  36  * fixed some memory leaks
  37  * calculation of checksum characters
  38  *
  39  * Revision 1.2  1998/02/07 13:03:34  root
  40  * ioctl read_telegram
  41  *
  42  * Revision 1.1  1998/02/06 19:21:03  root
  43  * Initial revision
  44  *
  45  *
  46  */
  47
  48 #include <linux/module.h>
  49 #include <linux/kernel.h>
  50 #include <linux/sched.h>
  51 #include <linux/types.h>
  52 #include <linux/fcntl.h>
  53 #include <linux/interrupt.h>
  54 #include <linux/ptrace.h>
  55 #include <linux/ioport.h>
  56 #include <linux/in.h>
  57 #include <linux/slab.h>
  58 #include <linux/tty.h>
  59 #include <linux/errno.h>
  60 #include <linux/string.h>       /* used in new tty drivers */
  61 #include <linux/signal.h>       /* used in new tty drivers */
  62 #include <linux/ioctl.h>
  63 #include <linux/n_r3964.h>
  64 #include <linux/poll.h>
  65 #include <linux/init.h>
  66 #include <linux/uaccess.h>
  67
  68 /*#define DEBUG_QUEUE*/
  69
  70 /* Log successful handshake and protocol operations  */
  71 /*#define DEBUG_PROTO_S*/
  72
  73 /* Log handshake and protocol errors: */
  74 /*#define DEBUG_PROTO_E*/
  75
  76 /* Log Linediscipline operations (open, close, read, write...): */
  77 /*#define DEBUG_LDISC*/
  78
  79 /* Log module and memory operations (init, cleanup; kmalloc, kfree): */
  80 /*#define DEBUG_MODUL*/
  81
  82 /* Macro helpers for debug output: */
  83 #define TRACE(format, args...) printk("r3964: " format "\n" , ## args)
  84
  85 #ifdef DEBUG_MODUL
  86 #define TRACE_M(format, args...) printk("r3964: " format "\n" , ## args)
  87 #else
  88 #define TRACE_M(fmt, arg...) do {} while (0)
  89 #endif
  90 #ifdef DEBUG_PROTO_S
  91 #define TRACE_PS(format, args...) printk("r3964: " format "\n" , ## args)
  92 #else
  93 #define TRACE_PS(fmt, arg...) do {} while (0)
  94 #endif
  95 #ifdef DEBUG_PROTO_E
  96 #define TRACE_PE(format, args...) printk("r3964: " format "\n" , ## args)
  97 #else
  98 #define TRACE_PE(fmt, arg...) do {} while (0)
  99 #endif
 100 #ifdef DEBUG_LDISC
 101 #define TRACE_L(format, args...) printk("r3964: " format "\n" , ## args)
 102 #else
 103 #define TRACE_L(fmt, arg...) do {} while (0)
 104 #endif
 105 #ifdef DEBUG_QUEUE
 106 #define TRACE_Q(format, args...) printk("r3964: " format "\n" , ## args)
 107 #else
 108 #define TRACE_Q(fmt, arg...) do {} while (0)
 109 #endif
 110 static void add_tx_queue(struct r3964_info *, struct r3964_block_header *);
 111 static void remove_from_tx_queue(struct r3964_info *pInfo, int error_code);
 112 static void put_char(struct r3964_info *pInfo, unsigned char ch);
 113 static void trigger_transmit(struct r3964_info *pInfo);
 114 static void retry_transmit(struct r3964_info *pInfo);
 115 static void transmit_block(struct r3964_info *pInfo);
 116 static void receive_char(struct r3964_info *pInfo, const unsigned char c);
 117 static void receive_error(struct r3964_info *pInfo, const char flag);
 118 static void on_timeout(struct timer_list *t);
 119 static int enable_signals(struct r3964_info *pInfo, struct pid *pid, int arg);
 120 static int read_telegram(struct r3964_info *pInfo, struct pid *pid,
 121                 unsigned char __user * buf);
 122 static void add_msg(struct r3964_client_info *pClient, int msg_id, int arg,
 123                 int error_code, struct r3964_block_header *pBlock);
 124 static struct r3964_message *remove_msg(struct r3964_info *pInfo,
 125                 struct r3964_client_info *pClient);
 126 static void remove_client_block(struct r3964_info *pInfo,
 127                 struct r3964_client_info *pClient);
 128
 129 static int r3964_open(struct tty_struct *tty);
 130 static void r3964_close(struct tty_struct *tty);
 131 static ssize_t r3964_read(struct tty_struct *tty, struct file *file,
 132                 void *cookie, unsigned char *buf, size_t nr);
 133 static ssize_t r3964_write(struct tty_struct *tty, struct file *file,
 134                 const unsigned char *buf, size_t nr);
 135 static int r3964_ioctl(struct tty_struct *tty, struct file *file,
 136                 unsigned int cmd, unsigned long arg);
 137 #ifdef CONFIG_COMPAT
 138 static int r3964_compat_ioctl(struct tty_struct *tty, struct file *file,
 139                 unsigned int cmd, unsigned long arg);
 140 #endif
 141 static void r3964_set_termios(struct tty_struct *tty, struct ktermios *old);
 142 static __poll_t r3964_poll(struct tty_struct *tty, struct file *file,
 143                 struct poll_table_struct *wait);
 144 static void r3964_receive_buf(struct tty_struct *tty, const unsigned char *cp,
 145                 char *fp, int count);
 146
 147 static struct tty_ldisc_ops tty_ldisc_N_R3964 = {
 148         .owner = THIS_MODULE,
 149         .name = "R3964",
 150         .open = r3964_open,
 151         .close = r3964_close,
 152         .read = r3964_read,
 153         .write = r3964_write,
 154         .ioctl = r3964_ioctl,
 155 #ifdef CONFIG_COMPAT
 156         .compat_ioctl = r3964_compat_ioctl,
 157 #endif
 158         .set_termios = r3964_set_termios,
 159         .poll = r3964_poll,
 160         .receive_buf = r3964_receive_buf,
 161 };
 162
 163 static void dump_block(const unsigned char *block, unsigned int length)
 164 {
 165         unsigned int i, j;
 166         char linebuf[16 * 3 + 1];
 167
 168         for (i = 0; i < length; i += 16) {
 169                 for (j = 0; (j < 16) && (j + i < length); j++) {
 170                         sprintf(linebuf + 3 * j, "%02x ", block[i + j]);
 171                 }
 172                 linebuf[3 * j] = '\0';
 173                 TRACE_PS("%s", linebuf);
 174         }
 175 }
 176
 177 /*************************************************************
 178  * Driver initialisation
 179  *************************************************************/
 180
 181 /*************************************************************
 182  * Module support routines
 183  *************************************************************/
 184
 185 static void __exit r3964_exit(void)
 186 {
 187         int status;
 188
 189         TRACE_M("cleanup_module()");
 190
 191         status = tty_unregister_ldisc(N_R3964);
 192
 193         if (status != 0) {
 194                 printk(KERN_ERR "r3964: error unregistering linediscipline: "
 195                                 "%d\n", status);
 196         } else {
 197                 TRACE_L("linediscipline successfully unregistered");
 198         }
 199 }
 200
 201 static int __init r3964_init(void)
 202 {
 203         int status;
 204
 205         printk("r3964: Philips r3964 Driver $Revision: 1.10 $\n");
 206
 207         /*
 208          * Register the tty line discipline
 209          */
 210
 211         status = tty_register_ldisc(N_R3964, &tty_ldisc_N_R3964);
 212         if (status == 0) {
 213                 TRACE_L("line discipline %d registered", N_R3964);
 214                 TRACE_L("flags=%x num=%x", tty_ldisc_N_R3964.flags,
 215                         tty_ldisc_N_R3964.num);
 216                 TRACE_L("open=%p", tty_ldisc_N_R3964.open);
 217                 TRACE_L("tty_ldisc_N_R3964 = %p", &tty_ldisc_N_R3964);
 218         } else {
 219                 printk(KERN_ERR "r3964: error registering line discipline: "
 220                                 "%d\n", status);
 221         }
 222         return status;
 223 }
 224
 225 module_init(r3964_init);
 226 module_exit(r3964_exit);
 227
 228 /*************************************************************
 229  * Protocol implementation routines
 230  *************************************************************/
 231
 232 static void add_tx_queue(struct r3964_info *pInfo,
 233                          struct r3964_block_header *pHeader)
 234 {
 235         unsigned long flags;
 236
 237         spin_lock_irqsave(&pInfo->lock, flags);
 238
 239         pHeader->next = NULL;
 240
 241         if (pInfo->tx_last == NULL) {
 242                 pInfo->tx_first = pInfo->tx_last = pHeader;
 243         } else {
 244                 pInfo->tx_last->next = pHeader;
 245                 pInfo->tx_last = pHeader;
 246         }
 247
 248         spin_unlock_irqrestore(&pInfo->lock, flags);
 249
 250         TRACE_Q("add_tx_queue %p, length %d, tx_first = %p",
 251                 pHeader, pHeader->length, pInfo->tx_first);
 252 }
 253
 254 static void remove_from_tx_queue(struct r3964_info *pInfo, int error_code)
 255 {
 256         struct r3964_block_header *pHeader;
 257         unsigned long flags;
 258 #ifdef DEBUG_QUEUE
 259         struct r3964_block_header *pDump;
 260 #endif
 261
 262         pHeader = pInfo->tx_first;
 263
 264         if (pHeader == NULL)
 265                 return;
 266
 267 #ifdef DEBUG_QUEUE
 268         printk("r3964: remove_from_tx_queue: %p, length %u - ",
 269                 pHeader, pHeader->length);
 270         for (pDump = pHeader; pDump; pDump = pDump->next)
 271                 printk("%p ", pDump);
 272         printk("\n");
 273 #endif
 274
 275         if (pHeader->owner) {
 276                 if (error_code) {
 277                         add_msg(pHeader->owner, R3964_MSG_ACK, 0,
 278                                 error_code, NULL);
 279                 } else {
 280                         add_msg(pHeader->owner, R3964_MSG_ACK, pHeader->length,
 281                                 error_code, NULL);
 282                 }
 283                 wake_up_interruptible(&pInfo->tty->read_wait);
 284         }
 285
 286         spin_lock_irqsave(&pInfo->lock, flags);
 287
 288         pInfo->tx_first = pHeader->next;
 289         if (pInfo->tx_first == NULL) {
 290                 pInfo->tx_last = NULL;
 291         }
 292
 293         spin_unlock_irqrestore(&pInfo->lock, flags);
 294
 295         kfree(pHeader);
 296         TRACE_M("remove_from_tx_queue - kfree %p", pHeader);
 297
 298         TRACE_Q("remove_from_tx_queue: tx_first = %p, tx_last = %p",
 299                 pInfo->tx_first, pInfo->tx_last);
 300 }
 301
 302 static void add_rx_queue(struct r3964_info *pInfo,
 303                          struct r3964_block_header *pHeader)
 304 {
 305         unsigned long flags;
 306
 307         spin_lock_irqsave(&pInfo->lock, flags);
 308
 309         pHeader->next = NULL;
 310
 311         if (pInfo->rx_last == NULL) {
 312                 pInfo->rx_first = pInfo->rx_last = pHeader;
 313         } else {
 314                 pInfo->rx_last->next = pHeader;
 315                 pInfo->rx_last = pHeader;
 316         }
 317         pInfo->blocks_in_rx_queue++;
 318
 319         spin_unlock_irqrestore(&pInfo->lock, flags);
 320
 321         TRACE_Q("add_rx_queue: %p, length = %d, rx_first = %p, count = %d",
 322                 pHeader, pHeader->length,
 323                 pInfo->rx_first, pInfo->blocks_in_rx_queue);
 324 }
 325
 326 static void remove_from_rx_queue(struct r3964_info *pInfo,
 327                                  struct r3964_block_header *pHeader)
 328 {
 329         unsigned long flags;
 330         struct r3964_block_header *pFind;
 331
 332         if (pHeader == NULL)
 333                 return;
 334
 335         TRACE_Q("remove_from_rx_queue: rx_first = %p, rx_last = %p, count = %d",
 336                 pInfo->rx_first, pInfo->rx_last, pInfo->blocks_in_rx_queue);
 337         TRACE_Q("remove_from_rx_queue: %p, length %u",
 338                 pHeader, pHeader->length);
 339
 340         spin_lock_irqsave(&pInfo->lock, flags);
 341
 342         if (pInfo->rx_first == pHeader) {
 343                 /* Remove the first block in the linked list: */
 344                 pInfo->rx_first = pHeader->next;
 345
 346                 if (pInfo->rx_first == NULL) {
 347                         pInfo->rx_last = NULL;
 348                 }
 349                 pInfo->blocks_in_rx_queue--;
 350         } else {
 351                 /* Find block to remove: */
 352                 for (pFind = pInfo->rx_first; pFind; pFind = pFind->next) {
 353                         if (pFind->next == pHeader) {
 354                                 /* Got it. */
 355                                 pFind->next = pHeader->next;
 356                                 pInfo->blocks_in_rx_queue--;
 357                                 if (pFind->next == NULL) {
 358                                         /* Oh, removed the last one! */
 359                                         pInfo->rx_last = pFind;
 360                                 }
 361                                 break;
 362                         }
 363                 }
 364         }
 365
 366         spin_unlock_irqrestore(&pInfo->lock, flags);
 367
 368         kfree(pHeader);
 369         TRACE_M("remove_from_rx_queue - kfree %p", pHeader);
 370
 371         TRACE_Q("remove_from_rx_queue: rx_first = %p, rx_last = %p, count = %d",
 372                 pInfo->rx_first, pInfo->rx_last, pInfo->blocks_in_rx_queue);
 373 }
 374
 375 static void put_char(struct r3964_info *pInfo, unsigned char ch)
 376 {
 377         struct tty_struct *tty = pInfo->tty;
 378         /* FIXME: put_char should not be called from an IRQ */
 379         tty_put_char(tty, ch);
 380         pInfo->bcc ^= ch;
 381 }
 382
 383 static void flush(struct r3964_info *pInfo)
 384 {
 385         struct tty_struct *tty = pInfo->tty;
 386
 387         if (tty == NULL || tty->ops->flush_chars == NULL)
 388                 return;
 389         tty->ops->flush_chars(tty);
 390 }
 391
 392 static void trigger_transmit(struct r3964_info *pInfo)
 393 {
 394         unsigned long flags;
 395
 396         spin_lock_irqsave(&pInfo->lock, flags);
 397
 398         if ((pInfo->state == R3964_IDLE) && (pInfo->tx_first != NULL)) {
 399                 pInfo->state = R3964_TX_REQUEST;
 400                 pInfo->nRetry = 0;
 401                 pInfo->flags &= ~R3964_ERROR;
 402                 mod_timer(&pInfo->tmr, jiffies + R3964_TO_QVZ);
 403
 404                 spin_unlock_irqrestore(&pInfo->lock, flags);
 405
 406                 TRACE_PS("trigger_transmit - sent STX");
 407
 408                 put_char(pInfo, STX);
 409                 flush(pInfo);
 410
 411                 pInfo->bcc = 0;
 412         } else {
 413                 spin_unlock_irqrestore(&pInfo->lock, flags);
 414         }
 415 }
 416
 417 static void retry_transmit(struct r3964_info *pInfo)
 418 {
 419         if (pInfo->nRetry < R3964_MAX_RETRIES) {
 420                 TRACE_PE("transmission failed. Retry #%d", pInfo->nRetry);
 421                 pInfo->bcc = 0;
 422                 put_char(pInfo, STX);
 423                 flush(pInfo);
 424                 pInfo->state = R3964_TX_REQUEST;
 425                 pInfo->nRetry++;
 426                 mod_timer(&pInfo->tmr, jiffies + R3964_TO_QVZ);
 427         } else {
 428                 TRACE_PE("transmission failed after %d retries",
 429                          R3964_MAX_RETRIES);
 430
 431                 remove_from_tx_queue(pInfo, R3964_TX_FAIL);
 432
 433                 put_char(pInfo, NAK);
 434                 flush(pInfo);
 435                 pInfo->state = R3964_IDLE;
 436
 437                 trigger_transmit(pInfo);
 438         }
 439 }
 440
 441 static void transmit_block(struct r3964_info *pInfo)
 442 {
 443         struct tty_struct *tty = pInfo->tty;
 444         struct r3964_block_header *pBlock = pInfo->tx_first;
 445         int room = 0;
 446
 447         if (tty == NULL || pBlock == NULL) {
 448                 return;
 449         }
 450
 451         room = tty_write_room(tty);
 452
 453         TRACE_PS("transmit_block %p, room %d, length %d",
 454                  pBlock, room, pBlock->length);
 455
 456         while (pInfo->tx_position < pBlock->length) {
 457                 if (room < 2)
 458                         break;
 459
 460                 if (pBlock->data[pInfo->tx_position] == DLE) {
 461                         /* send additional DLE char: */
 462                         put_char(pInfo, DLE);
 463                 }
 464                 put_char(pInfo, pBlock->data[pInfo->tx_position++]);
 465
 466                 room--;
 467         }
 468
 469         if ((pInfo->tx_position == pBlock->length) && (room >= 3)) {
 470                 put_char(pInfo, DLE);
 471                 put_char(pInfo, ETX);
 472                 if (pInfo->flags & R3964_BCC) {
 473                         put_char(pInfo, pInfo->bcc);
 474                 }
 475                 pInfo->state = R3964_WAIT_FOR_TX_ACK;
 476                 mod_timer(&pInfo->tmr, jiffies + R3964_TO_QVZ);
 477         }
 478         flush(pInfo);
 479 }
 480
 481 static void on_receive_block(struct r3964_info *pInfo)
 482 {
 483         unsigned int length;
 484         struct r3964_client_info *pClient;
 485         struct r3964_block_header *pBlock;
 486
 487         length = pInfo->rx_position;
 488
 489         /* compare byte checksum characters: */
 490         if (pInfo->flags & R3964_BCC) {
 491                 if (pInfo->bcc != pInfo->last_rx) {
 492                         TRACE_PE("checksum error - got %x but expected %x",
 493                                  pInfo->last_rx, pInfo->bcc);
 494                         pInfo->flags |= R3964_CHECKSUM;
 495                 }
 496         }
 497
 498         /* check for errors (parity, overrun,...): */
 499         if (pInfo->flags & R3964_ERROR) {
 500                 TRACE_PE("on_receive_block - transmission failed error %x",
 501                          pInfo->flags & R3964_ERROR);
 502
 503                 put_char(pInfo, NAK);
 504                 flush(pInfo);
 505                 if (pInfo->nRetry < R3964_MAX_RETRIES) {
 506                         pInfo->state = R3964_WAIT_FOR_RX_REPEAT;
 507                         pInfo->nRetry++;
 508                         mod_timer(&pInfo->tmr, jiffies + R3964_TO_RX_PANIC);
 509                 } else {
 510                         TRACE_PE("on_receive_block - failed after max retries");
 511                         pInfo->state = R3964_IDLE;
 512                 }
 513                 return;
 514         }
 515
 516         /* received block; submit DLE: */
 517         put_char(pInfo, DLE);
 518         flush(pInfo);
 519         del_timer_sync(&pInfo->tmr);
 520         TRACE_PS(" rx success: got %d chars", length);
 521
 522         /* prepare struct r3964_block_header: */
 523         pBlock = kmalloc(length + sizeof(struct r3964_block_header),
 524                         GFP_KERNEL);
 525         TRACE_M("on_receive_block - kmalloc %p", pBlock);
 526
 527         if (pBlock == NULL)
 528                 return;
 529
 530         pBlock->length = length;
 531         pBlock->data = ((unsigned char *)pBlock) +
 532                         sizeof(struct r3964_block_header);
 533         pBlock->locks = 0;
 534         pBlock->next = NULL;
 535         pBlock->owner = NULL;
 536
 537         memcpy(pBlock->data, pInfo->rx_buf, length);
 538
 539         /* queue block into rx_queue: */
 540         add_rx_queue(pInfo, pBlock);
 541
 542         /* notify attached client processes: */
 543         for (pClient = pInfo->firstClient; pClient; pClient = pClient->next) {
 544                 if (pClient->sig_flags & R3964_SIG_DATA) {
 545                         add_msg(pClient, R3964_MSG_DATA, length, R3964_OK,
 546                                 pBlock);
 547                 }
 548         }
 549         wake_up_interruptible(&pInfo->tty->read_wait);
 550
 551         pInfo->state = R3964_IDLE;
 552
 553         trigger_transmit(pInfo);
 554 }
 555
 556 static void receive_char(struct r3964_info *pInfo, const unsigned char c)
 557 {
 558         switch (pInfo->state) {
 559         case R3964_TX_REQUEST:
 560                 if (c == DLE) {
 561                         TRACE_PS("TX_REQUEST - got DLE");
 562
 563                         pInfo->state = R3964_TRANSMITTING;
 564                         pInfo->tx_position = 0;
 565
 566                         transmit_block(pInfo);
 567                 } else if (c == STX) {
 568                         if (pInfo->nRetry == 0) {
 569                                 TRACE_PE("TX_REQUEST - init conflict");
 570                                 if (pInfo->priority == R3964_SLAVE) {
 571                                         goto start_receiving;
 572                                 }
 573                         } else {
 574                                 TRACE_PE("TX_REQUEST - secondary init "
 575                                         "conflict!? Switching to SLAVE mode "
 576                                         "for next rx.");
 577                                 goto start_receiving;
 578                         }
 579                 } else {
 580                         TRACE_PE("TX_REQUEST - char != DLE: %x", c);
 581                         retry_transmit(pInfo);
 582                 }
 583                 break;
 584         case R3964_TRANSMITTING:
 585                 if (c == NAK) {
 586                         TRACE_PE("TRANSMITTING - got NAK");
 587                         retry_transmit(pInfo);
 588                 } else {
 589                         TRACE_PE("TRANSMITTING - got invalid char");
 590
 591                         pInfo->state = R3964_WAIT_ZVZ_BEFORE_TX_RETRY;
 592                         mod_timer(&pInfo->tmr, jiffies + R3964_TO_ZVZ);
 593                 }
 594                 break;
 595         case R3964_WAIT_FOR_TX_ACK:
 596                 if (c == DLE) {
 597                         TRACE_PS("WAIT_FOR_TX_ACK - got DLE");
 598                         remove_from_tx_queue(pInfo, R3964_OK);
 599
 600                         pInfo->state = R3964_IDLE;
 601                         trigger_transmit(pInfo);
 602                 } else {
 603                         retry_transmit(pInfo);
 604                 }
 605                 break;
 606         case R3964_WAIT_FOR_RX_REPEAT:
 607         case R3964_IDLE:
 608                 if (c == STX) {
 609                         /* Prevent rx_queue from overflow: */
 610                         if (pInfo->blocks_in_rx_queue >=
 611                             R3964_MAX_BLOCKS_IN_RX_QUEUE) {
 612                                 TRACE_PE("IDLE - got STX but no space in "
 613                                                 "rx_queue!");
 614                                 pInfo->state = R3964_WAIT_FOR_RX_BUF;
 615                                 mod_timer(&pInfo->tmr,
 616                                           jiffies + R3964_TO_NO_BUF);
 617                                 break;
 618                         }
 619 start_receiving:
 620                         /* Ok, start receiving: */
 621                         TRACE_PS("IDLE - got STX");
 622                         pInfo->rx_position = 0;
 623                         pInfo->last_rx = 0;
 624                         pInfo->flags &= ~R3964_ERROR;
 625                         pInfo->state = R3964_RECEIVING;
 626                         mod_timer(&pInfo->tmr, jiffies + R3964_TO_ZVZ);
 627                         pInfo->nRetry = 0;
 628                         put_char(pInfo, DLE);
 629                         flush(pInfo);
 630                         pInfo->bcc = 0;
 631                 }
 632                 break;
 633         case R3964_RECEIVING:
 634                 if (pInfo->rx_position < RX_BUF_SIZE) {
 635                         pInfo->bcc ^= c;
 636
 637                         if (c == DLE) {
 638                                 if (pInfo->last_rx == DLE) {
 639                                         pInfo->last_rx = 0;
 640                                         goto char_to_buf;
 641                                 }
 642                                 pInfo->last_rx = DLE;
 643                                 break;
 644                         } else if ((c == ETX) && (pInfo->last_rx == DLE)) {
 645                                 if (pInfo->flags & R3964_BCC) {
 646                                         pInfo->state = R3964_WAIT_FOR_BCC;
 647                                         mod_timer(&pInfo->tmr,
 648                                                   jiffies + R3964_TO_ZVZ);
 649                                 } else {
 650                                         on_receive_block(pInfo);
 651                                 }
 652                         } else {
 653                                 pInfo->last_rx = c;
 654 char_to_buf:
 655                                 pInfo->rx_buf[pInfo->rx_position++] = c;
 656                                 mod_timer(&pInfo->tmr, jiffies + R3964_TO_ZVZ);
 657                         }
 658                 }
 659                 /* else: overflow-msg? BUF_SIZE>MTU; should not happen? */
 660                 break;
 661         case R3964_WAIT_FOR_BCC:
 662                 pInfo->last_rx = c;
 663                 on_receive_block(pInfo);
 664                 break;
 665         }
 666 }
 667
 668 static void receive_error(struct r3964_info *pInfo, const char flag)
 669 {
 670         switch (flag) {
 671         case TTY_NORMAL:
 672                 break;
 673         case TTY_BREAK:
 674                 TRACE_PE("received break");
 675                 pInfo->flags |= R3964_BREAK;
 676                 break;
 677         case TTY_PARITY:
 678                 TRACE_PE("parity error");
 679                 pInfo->flags |= R3964_PARITY;
 680                 break;
 681         case TTY_FRAME:
 682                 TRACE_PE("frame error");
 683                 pInfo->flags |= R3964_FRAME;
 684                 break;
 685         case TTY_OVERRUN:
 686                 TRACE_PE("frame overrun");
 687                 pInfo->flags |= R3964_OVERRUN;
 688                 break;
 689         default:
 690                 TRACE_PE("receive_error - unknown flag %d", flag);
 691                 pInfo->flags |= R3964_UNKNOWN;
 692                 break;
 693         }
 694 }
 695
 696 static void on_timeout(struct timer_list *t)
 697 {
 698         struct r3964_info *pInfo = from_timer(pInfo, t, tmr);
 699
 700         switch (pInfo->state) {
 701         case R3964_TX_REQUEST:
 702                 TRACE_PE("TX_REQUEST - timeout");
 703                 retry_transmit(pInfo);
 704                 break;
 705         case R3964_WAIT_ZVZ_BEFORE_TX_RETRY:
 706                 put_char(pInfo, NAK);
 707                 flush(pInfo);
 708                 retry_transmit(pInfo);
 709                 break;
 710         case R3964_WAIT_FOR_TX_ACK:
 711                 TRACE_PE("WAIT_FOR_TX_ACK - timeout");
 712                 retry_transmit(pInfo);
 713                 break;
 714         case R3964_WAIT_FOR_RX_BUF:
 715                 TRACE_PE("WAIT_FOR_RX_BUF - timeout");
 716                 put_char(pInfo, NAK);
 717                 flush(pInfo);
 718                 pInfo->state = R3964_IDLE;
 719                 break;
 720         case R3964_RECEIVING:
 721                 TRACE_PE("RECEIVING - timeout after %d chars",
 722                          pInfo->rx_position);
 723                 put_char(pInfo, NAK);
 724                 flush(pInfo);
 725                 pInfo->state = R3964_IDLE;
 726                 break;
 727         case R3964_WAIT_FOR_RX_REPEAT:
 728                 TRACE_PE("WAIT_FOR_RX_REPEAT - timeout");
 729                 pInfo->state = R3964_IDLE;
 730                 break;
 731         case R3964_WAIT_FOR_BCC:
 732                 TRACE_PE("WAIT_FOR_BCC - timeout");
 733                 put_char(pInfo, NAK);
 734                 flush(pInfo);
 735                 pInfo->state = R3964_IDLE;
 736                 break;
 737         }
 738 }
 739
 740 static struct r3964_client_info *findClient(struct r3964_info *pInfo,
 741                 struct pid *pid)
 742 {
 743         struct r3964_client_info *pClient;
 744
 745         for (pClient = pInfo->firstClient; pClient; pClient = pClient->next) {
 746                 if (pClient->pid == pid) {
 747                         return pClient;
 748                 }
 749         }
 750         return NULL;
 751 }
 752
 753 static int enable_signals(struct r3964_info *pInfo, struct pid *pid, int arg)
 754 {
 755         struct r3964_client_info *pClient;
 756         struct r3964_client_info **ppClient;
 757         struct r3964_message *pMsg;
 758
 759         if ((arg & R3964_SIG_ALL) == 0) {
 760                 /* Remove client from client list */
 761                 for (ppClient = &pInfo->firstClient; *ppClient;
 762                      ppClient = &(*ppClient)->next) {
 763                         pClient = *ppClient;
 764
 765                         if (pClient->pid == pid) {
 766                                 TRACE_PS("removing client %d from client list",
 767                                          pid_nr(pid));
 768                                 *ppClient = pClient->next;
 769                                 while (pClient->msg_count) {
 770                                         pMsg = remove_msg(pInfo, pClient);
 771                                         if (pMsg) {
 772                                                 kfree(pMsg);
 773                                                 TRACE_M("enable_signals - msg "
 774                                                         "kfree %p", pMsg);
 775                                         }
 776                                 }
 777                                 put_pid(pClient->pid);
 778                                 kfree(pClient);
 779                                 TRACE_M("enable_signals - kfree %p", pClient);
 780                                 return 0;
 781                         }
 782                 }
 783                 return -EINVAL;
 784         } else {
 785                 pClient = findClient(pInfo, pid);
 786                 if (pClient) {
 787                         /* update signal options */
 788                         pClient->sig_flags = arg;
 789                 } else {
 790                         /* add client to client list */
 791                         pClient = kmalloc(sizeof(struct r3964_client_info),
 792                                         GFP_KERNEL);
 793                         TRACE_M("enable_signals - kmalloc %p", pClient);
 794                         if (pClient == NULL)
 795                                 return -ENOMEM;
 796
 797                         TRACE_PS("add client %d to client list", pid_nr(pid));
 798                         spin_lock_init(&pClient->lock);
 799                         pClient->sig_flags = arg;
 800                         pClient->pid = get_pid(pid);
 801                         pClient->next = pInfo->firstClient;
 802                         pClient->first_msg = NULL;
 803                         pClient->last_msg = NULL;
 804                         pClient->next_block_to_read = NULL;
 805                         pClient->msg_count = 0;
 806                         pInfo->firstClient = pClient;
 807                 }
 808         }
 809
 810         return 0;
 811 }
 812
 813 static int read_telegram(struct r3964_info *pInfo, struct pid *pid,
 814                          unsigned char __user * buf)
 815 {
 816         struct r3964_client_info *pClient;
 817         struct r3964_block_header *block;
 818
 819         if (!buf) {
 820                 return -EINVAL;
 821         }
 822
 823         pClient = findClient(pInfo, pid);
 824         if (pClient == NULL) {
 825                 return -EINVAL;
 826         }
 827
 828         block = pClient->next_block_to_read;
 829         if (!block) {
 830                 return 0;
 831         } else {
 832                 if (copy_to_user(buf, block->data, block->length))
 833                         return -EFAULT;
 834
 835                 remove_client_block(pInfo, pClient);
 836                 return block->length;
 837         }
 838
 839         return -EINVAL;
 840 }
 841
 842 static void add_msg(struct r3964_client_info *pClient, int msg_id, int arg,
 843                 int error_code, struct r3964_block_header *pBlock)
 844 {
 845         struct r3964_message *pMsg;
 846         unsigned long flags;
 847
 848         if (pClient->msg_count < R3964_MAX_MSG_COUNT - 1) {
 849 queue_the_message:
 850
 851                 pMsg = kmalloc(sizeof(struct r3964_message),
 852                                 error_code ? GFP_ATOMIC : GFP_KERNEL);
 853                 TRACE_M("add_msg - kmalloc %p", pMsg);
 854                 if (pMsg == NULL) {
 855                         return;
 856                 }
 857
 858                 spin_lock_irqsave(&pClient->lock, flags);
 859
 860                 pMsg->msg_id = msg_id;
 861                 pMsg->arg = arg;
 862                 pMsg->error_code = error_code;
 863                 pMsg->block = pBlock;
 864                 pMsg->next = NULL;
 865
 866                 if (pClient->last_msg == NULL) {
 867                         pClient->first_msg = pClient->last_msg = pMsg;
 868                 } else {
 869                         pClient->last_msg->next = pMsg;
 870                         pClient->last_msg = pMsg;
 871                 }
 872
 873                 pClient->msg_count++;
 874
 875                 if (pBlock != NULL) {
 876                         pBlock->locks++;
 877                 }
 878                 spin_unlock_irqrestore(&pClient->lock, flags);
 879         } else {
 880                 if ((pClient->last_msg->msg_id == R3964_MSG_ACK)
 881                     && (pClient->last_msg->error_code == R3964_OVERFLOW)) {
 882                         pClient->last_msg->arg++;
 883                         TRACE_PE("add_msg - inc prev OVERFLOW-msg");
 884                 } else {
 885                         msg_id = R3964_MSG_ACK;
 886                         arg = 0;
 887                         error_code = R3964_OVERFLOW;
 888                         pBlock = NULL;
 889                         TRACE_PE("add_msg - queue OVERFLOW-msg");
 890                         goto queue_the_message;
 891                 }
 892         }
 893         /* Send SIGIO signal to client process: */
 894         if (pClient->sig_flags & R3964_USE_SIGIO) {
 895                 kill_pid(pClient->pid, SIGIO, 1);
 896         }
 897 }
 898
 899 static struct r3964_message *remove_msg(struct r3964_info *pInfo,
 900                                         struct r3964_client_info *pClient)
 901 {
 902         struct r3964_message *pMsg = NULL;
 903         unsigned long flags;
 904
 905         if (pClient->first_msg) {
 906                 spin_lock_irqsave(&pClient->lock, flags);
 907
 908                 pMsg = pClient->first_msg;
 909                 pClient->first_msg = pMsg->next;
 910                 if (pClient->first_msg == NULL) {
 911                         pClient->last_msg = NULL;
 912                 }
 913
 914                 pClient->msg_count--;
 915                 if (pMsg->block) {
 916                         remove_client_block(pInfo, pClient);
 917                         pClient->next_block_to_read = pMsg->block;
 918                 }
 919                 spin_unlock_irqrestore(&pClient->lock, flags);
 920         }
 921         return pMsg;
 922 }
 923
 924 static void remove_client_block(struct r3964_info *pInfo,
 925                                 struct r3964_client_info *pClient)
 926 {
 927         struct r3964_block_header *block;
 928
 929         TRACE_PS("remove_client_block PID %d", pid_nr(pClient->pid));
 930
 931         block = pClient->next_block_to_read;
 932         if (block) {
 933                 block->locks--;
 934                 if (block->locks == 0) {
 935                         remove_from_rx_queue(pInfo, block);
 936                 }
 937         }
 938         pClient->next_block_to_read = NULL;
 939 }
 940
 941 /*************************************************************
 942  * Line discipline routines
 943  *************************************************************/
 944
 945 static int r3964_open(struct tty_struct *tty)
 946 {
 947         struct r3964_info *pInfo;
 948
 949         TRACE_L("open");
 950         TRACE_L("tty=%p, PID=%d, disc_data=%p",
 951                 tty, current->pid, tty->disc_data);
 952
 953         pInfo = kmalloc(sizeof(struct r3964_info), GFP_KERNEL);
 954         TRACE_M("r3964_open - info kmalloc %p", pInfo);
 955
 956         if (!pInfo) {
 957                 printk(KERN_ERR "r3964: failed to alloc info structure\n");
 958                 return -ENOMEM;
 959         }
 960
 961         pInfo->rx_buf = kmalloc(RX_BUF_SIZE, GFP_KERNEL);
 962         TRACE_M("r3964_open - rx_buf kmalloc %p", pInfo->rx_buf);
 963
 964         if (!pInfo->rx_buf) {
 965                 printk(KERN_ERR "r3964: failed to alloc receive buffer\n");
 966                 kfree(pInfo);
 967                 TRACE_M("r3964_open - info kfree %p", pInfo);
 968                 return -ENOMEM;
 969         }
 970
 971         pInfo->tx_buf = kmalloc(TX_BUF_SIZE, GFP_KERNEL);
 972         TRACE_M("r3964_open - tx_buf kmalloc %p", pInfo->tx_buf);
 973
 974         if (!pInfo->tx_buf) {
 975                 printk(KERN_ERR "r3964: failed to alloc transmit buffer\n");
 976                 kfree(pInfo->rx_buf);
 977                 TRACE_M("r3964_open - rx_buf kfree %p", pInfo->rx_buf);
 978                 kfree(pInfo);
 979                 TRACE_M("r3964_open - info kfree %p", pInfo);
 980                 return -ENOMEM;
 981         }
 982
 983         spin_lock_init(&pInfo->lock);
 984         mutex_init(&pInfo->read_lock);
 985         pInfo->tty = tty;
 986         pInfo->priority = R3964_MASTER;
 987         pInfo->rx_first = pInfo->rx_last = NULL;
 988         pInfo->tx_first = pInfo->tx_last = NULL;
 989         pInfo->rx_position = 0;
 990         pInfo->tx_position = 0;
 991         pInfo->last_rx = 0;
 992         pInfo->blocks_in_rx_queue = 0;
 993         pInfo->firstClient = NULL;
 994         pInfo->state = R3964_IDLE;
 995         pInfo->flags = R3964_DEBUG;
 996         pInfo->nRetry = 0;
 997
 998         tty->disc_data = pInfo;
 999         tty->receive_room = 65536;
1000
1001         timer_setup(&pInfo->tmr, on_timeout, 0);
1002
1003         return 0;
1004 }
1005
1006 static void r3964_close(struct tty_struct *tty)
1007 {
1008         struct r3964_info *pInfo = tty->disc_data;
1009         struct r3964_client_info *pClient, *pNext;
1010         struct r3964_message *pMsg;
1011         struct r3964_block_header *pHeader, *pNextHeader;
1012         unsigned long flags;
1013
1014         TRACE_L("close");
1015
1016         /*
1017          * Make sure that our task queue isn't activated.  If it
1018          * is, take it out of the linked list.
1019          */
1020         del_timer_sync(&pInfo->tmr);
1021
1022         /* Remove client-structs and message queues: */
1023         pClient = pInfo->firstClient;
1024         while (pClient) {
1025                 pNext = pClient->next;
1026                 while (pClient->msg_count) {
1027                         pMsg = remove_msg(pInfo, pClient);
1028                         if (pMsg) {
1029                                 kfree(pMsg);
1030                                 TRACE_M("r3964_close - msg kfree %p", pMsg);
1031                         }
1032                 }
1033                 put_pid(pClient->pid);
1034                 kfree(pClient);
1035                 TRACE_M("r3964_close - client kfree %p", pClient);
1036                 pClient = pNext;
1037         }
1038         /* Remove jobs from tx_queue: */
1039         spin_lock_irqsave(&pInfo->lock, flags);
1040         pHeader = pInfo->tx_first;
1041         pInfo->tx_first = pInfo->tx_last = NULL;
1042         spin_unlock_irqrestore(&pInfo->lock, flags);
1043
1044         while (pHeader) {
1045                 pNextHeader = pHeader->next;
1046                 kfree(pHeader);
1047                 pHeader = pNextHeader;
1048         }
1049
1050         /* Free buffers: */
1051         kfree(pInfo->rx_buf);
1052         TRACE_M("r3964_close - rx_buf kfree %p", pInfo->rx_buf);
1053         kfree(pInfo->tx_buf);
1054         TRACE_M("r3964_close - tx_buf kfree %p", pInfo->tx_buf);
1055         kfree(pInfo);
1056         TRACE_M("r3964_close - info kfree %p", pInfo);
1057 }
1058
1059 static ssize_t r3964_read(struct tty_struct *tty, struct file *file,
1060                           unsigned char *kbuf, size_t nr,
1061                           void **cookie, unsigned long offset)
1062 {
1063         struct r3964_info *pInfo = tty->disc_data;
1064         struct r3964_client_info *pClient;
1065         struct r3964_message *pMsg;
1066         struct r3964_client_message theMsg;
1067         int ret;
1068
1069         TRACE_L("read()");
1070
1071         /*
1072          *      Internal serialization of reads.
1073          */
1074         if (file->f_flags & O_NONBLOCK) {
1075                 if (!mutex_trylock(&pInfo->read_lock))
1076                         return -EAGAIN;
1077         } else {
1078                 if (mutex_lock_interruptible(&pInfo->read_lock))
1079                         return -ERESTARTSYS;
1080         }
1081
1082         pClient = findClient(pInfo, task_pid(current));
1083         if (pClient) {
1084                 pMsg = remove_msg(pInfo, pClient);
1085                 if (pMsg == NULL) {
1086                         /* no messages available. */
1087                         if (tty_io_nonblock(tty, file)) {
1088                                 ret = -EAGAIN;
1089                                 goto unlock;
1090                         }
1091                         /* block until there is a message: */
1092                         wait_event_interruptible(tty->read_wait,
1093                                         (pMsg = remove_msg(pInfo, pClient)));
1094                 }
1095
1096                 /* If we still haven't got a message, we must have been signalled */
1097
1098                 if (!pMsg) {
1099                         ret = -EINTR;
1100                         goto unlock;
1101                 }
1102
1103                 /* deliver msg to client process: */
1104                 theMsg.msg_id = pMsg->msg_id;
1105                 theMsg.arg = pMsg->arg;
1106                 theMsg.error_code = pMsg->error_code;
1107                 ret = sizeof(struct r3964_client_message);
1108
1109                 kfree(pMsg);
1110                 TRACE_M("r3964_read - msg kfree %p", pMsg);
1111
1112                 memcpy(kbuf, &theMsg, ret);
1113
1114                 TRACE_PS("read - return %d", ret);
1115                 goto unlock;
1116         }
1117         ret = -EPERM;
1118 unlock:
1119         mutex_unlock(&pInfo->read_lock);
1120         return ret;
1121 }
1122
1123 static ssize_t r3964_write(struct tty_struct *tty, struct file *file,
1124                            const unsigned char *data, size_t count)
1125 {
1126         struct r3964_info *pInfo = tty->disc_data;
1127         struct r3964_block_header *pHeader;
1128         struct r3964_client_info *pClient;
1129         unsigned char *new_data;
1130
1131         TRACE_L("write request, %d characters", count);
1132 /*
1133  * Verify the pointers
1134  */
1135
1136         if (!pInfo)
1137                 return -EIO;
1138
1139 /*
1140  * Ensure that the caller does not wish to send too much.
1141  */
1142         if (count > R3964_MTU) {
1143                 if (pInfo->flags & R3964_DEBUG) {
1144                         TRACE_L(KERN_WARNING "r3964_write: truncating user "
1145                                 "packet from %u to mtu %d", count, R3964_MTU);
1146                 }
1147                 count = R3964_MTU;
1148         }
1149 /*
1150  * Allocate a buffer for the data and copy it from the buffer with header prepended
1151  */
1152         new_data = kmalloc(count + sizeof(struct r3964_block_header),
1153                         GFP_KERNEL);
1154         TRACE_M("r3964_write - kmalloc %p", new_data);
1155         if (new_data == NULL) {
1156                 if (pInfo->flags & R3964_DEBUG) {
1157                         printk(KERN_ERR "r3964_write: no memory\n");
1158                 }
1159                 return -ENOSPC;
1160         }
1161
1162         pHeader = (struct r3964_block_header *)new_data;
1163         pHeader->data = new_data + sizeof(struct r3964_block_header);
1164         pHeader->length = count;
1165         pHeader->locks = 0;
1166         pHeader->owner = NULL;
1167
1168         pClient = findClient(pInfo, task_pid(current));
1169         if (pClient) {
1170                 pHeader->owner = pClient;
1171         }
1172
1173         memcpy(pHeader->data, data, count);     /* We already verified this */
1174
1175         if (pInfo->flags & R3964_DEBUG) {
1176                 dump_block(pHeader->data, count);
1177         }
1178
1179 /*
1180  * Add buffer to transmit-queue:
1181  */
1182         add_tx_queue(pInfo, pHeader);
1183         trigger_transmit(pInfo);
1184
1185         return 0;
1186 }
1187
1188 static int r3964_ioctl(struct tty_struct *tty, struct file *file,
1189                 unsigned int cmd, unsigned long arg)
1190 {
1191         struct r3964_info *pInfo = tty->disc_data;
1192         if (pInfo == NULL)
1193                 return -EINVAL;
1194         switch (cmd) {
1195         case R3964_ENABLE_SIGNALS:
1196                 return enable_signals(pInfo, task_pid(current), arg);
1197         case R3964_SETPRIORITY:
1198                 if (arg < R3964_MASTER || arg > R3964_SLAVE)
1199                         return -EINVAL;
1200                 pInfo->priority = arg & 0xff;
1201                 return 0;
1202         case R3964_USE_BCC:
1203                 if (arg)
1204                         pInfo->flags |= R3964_BCC;
1205                 else
1206                         pInfo->flags &= ~R3964_BCC;
1207                 return 0;
1208         case R3964_READ_TELEGRAM:
1209                 return read_telegram(pInfo, task_pid(current),
1210                                 (unsigned char __user *)arg);
1211         default:
1212                 return -ENOIOCTLCMD;
1213         }
1214 }
1215
1216 #ifdef CONFIG_COMPAT
1217 static int r3964_compat_ioctl(struct tty_struct *tty, struct file *file,
1218                 unsigned int cmd, unsigned long arg)
1219 {
1220         switch (cmd) {
1221         case R3964_ENABLE_SIGNALS:
1222         case R3964_SETPRIORITY:
1223         case R3964_USE_BCC:
1224                 return r3964_ioctl(tty, file, cmd, arg);
1225         default:
1226                 return -ENOIOCTLCMD;
1227         }
1228 }
1229 #endif
1230
1231 static void r3964_set_termios(struct tty_struct *tty, struct ktermios *old)
1232 {
1233         TRACE_L("set_termios");
1234 }
1235
1236 /* Called without the kernel lock held - fine */
1237 static __poll_t r3964_poll(struct tty_struct *tty, struct file *file,
1238                         struct poll_table_struct *wait)
1239 {
1240         struct r3964_info *pInfo = tty->disc_data;
1241         struct r3964_client_info *pClient;
1242         struct r3964_message *pMsg = NULL;
1243         unsigned long flags;
1244         __poll_t result = EPOLLOUT;
1245
1246         TRACE_L("POLL");
1247
1248         pClient = findClient(pInfo, task_pid(current));
1249         if (pClient) {
1250                 poll_wait(file, &tty->read_wait, wait);
1251                 spin_lock_irqsave(&pInfo->lock, flags);
1252                 pMsg = pClient->first_msg;
1253                 spin_unlock_irqrestore(&pInfo->lock, flags);
1254                 if (pMsg)
1255                         result |= EPOLLIN | EPOLLRDNORM;
1256         } else {
1257                 result = -EINVAL;
1258         }
1259         return result;
1260 }
1261
1262 static void r3964_receive_buf(struct tty_struct *tty, const unsigned char *cp,
1263                         char *fp, int count)
1264 {
1265         struct r3964_info *pInfo = tty->disc_data;
1266         const unsigned char *p;
1267         char *f, flags = TTY_NORMAL;
1268         int i;
1269
1270         for (i = count, p = cp, f = fp; i; i--, p++) {
1271                 if (f)
1272                         flags = *f++;
1273                 if (flags == TTY_NORMAL) {
1274                         receive_char(pInfo, *p);
1275                 } else {
1276                         receive_error(pInfo, flags);
1277                 }
1278
1279         }
1280 }
1281
1282 MODULE_LICENSE("GPL");
1283 MODULE_ALIAS_LDISC(N_R3964);