drivers/s390/net/ctctty.c

   1 /*
   2  * $Id: ctctty.c,v 1.17 2004/03/31 17:06:34 ptiedem Exp $
   3  *
   4  * CTC / ESCON network driver, tty interface.
   5  *
   6  * Copyright (C) 2001 IBM Deutschland Entwicklung GmbH, IBM Corporation
   7  * Author(s): Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2, or (at your option)
  12  * any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  */
  24
  25 #include <linux/config.h>
  26 #include <linux/module.h>
  27 #include <linux/tty.h>
  28 #include <linux/serial_reg.h>
  29 #include <linux/interrupt.h>
  30 #include <asm/uaccess.h>
  31 #include <linux/devfs_fs_kernel.h>
  32 #include "ctctty.h"
  33
  34 #define CTC_TTY_MAJOR       43
  35 #define CTC_TTY_MAX_DEVICES 64
  36
  37 #define CTC_ASYNC_MAGIC          0x49344C01 /* for paranoia-checking        */
  38 #define CTC_ASYNC_INITIALIZED    0x80000000 /* port was initialized         */
  39 #define CTC_ASYNC_NORMAL_ACTIVE  0x20000000 /* Normal device active         */
  40 #define CTC_ASYNC_CLOSING        0x08000000 /* Serial port is closing       */
  41 #define CTC_ASYNC_CTS_FLOW       0x04000000 /* Do CTS flow control          */
  42 #define CTC_ASYNC_CHECK_CD       0x02000000 /* i.e., CLOCAL                 */
  43 #define CTC_ASYNC_HUP_NOTIFY         0x0001 /* Notify tty on hangups/closes */
  44 #define CTC_ASYNC_NETDEV_OPEN        0x0002 /* Underlying netdev is open    */
  45 #define CTC_ASYNC_TX_LINESTAT        0x0004 /* Must send line status        */
  46 #define CTC_ASYNC_SPLIT_TERMIOS      0x0008 /* Sep. termios for dialin/out  */
  47 #define CTC_TTY_XMIT_SIZE              1024 /* Default bufsize for write    */
  48 #define CTC_SERIAL_XMIT_MAX            4000 /* Maximum bufsize for write    */
  49
  50 /* Private data (similar to async_struct in <linux/serial.h>) */
  51 typedef struct {
  52   int                   magic;
  53   int                   flags;           /* defined in tty.h               */
  54   int                   mcr;             /* Modem control register         */
  55   int                   msr;             /* Modem status register          */
  56   int                   lsr;             /* Line status register           */
  57   int                   line;
  58   int                   count;           /* # of fd on device              */
  59   int                   blocked_open;    /* # of blocked opens             */
  60   struct net_device     *netdev;
  61   struct sk_buff_head   tx_queue;        /* transmit queue                 */
  62   struct sk_buff_head   rx_queue;        /* receive queue                  */
  63   struct tty_struct     *tty;            /* Pointer to corresponding tty   */
  64   wait_queue_head_t     open_wait;
  65   wait_queue_head_t     close_wait;
  66   struct semaphore      write_sem;
  67   struct tasklet_struct tasklet;
  68   struct timer_list     stoptimer;
  69 } ctc_tty_info;
  70
  71 /* Description of one CTC-tty */
  72 typedef struct {
  73   struct tty_driver  *ctc_tty_device;              /* tty-device             */
  74   ctc_tty_info       info[CTC_TTY_MAX_DEVICES];    /* Private data           */
  75 } ctc_tty_driver;
  76
  77 static ctc_tty_driver *driver;
  78
  79 /* Leave this unchanged unless you know what you do! */
  80 #define MODEM_PARANOIA_CHECK
  81 #define MODEM_DO_RESTART
  82
  83 #define CTC_TTY_NAME "ctctty"
  84
  85 static __u32 ctc_tty_magic = CTC_ASYNC_MAGIC;
  86 static int ctc_tty_shuttingdown = 0;
  87
  88 static spinlock_t ctc_tty_lock;
  89
  90 /* ctc_tty_try_read() is called from within ctc_tty_rcv_skb()
  91  * to stuff incoming data directly into a tty's flip-buffer. If the
  92  * flip buffer is full, the packet gets queued up.
  93  *
  94  * Return:
  95  *  1 = Success
  96  *  0 = Failure, data has to be buffered and later processed by
  97  *      ctc_tty_readmodem().
  98  */
  99 static int
 100 ctc_tty_try_read(ctc_tty_info * info, struct sk_buff *skb)
 101 {
 102         int c;
 103         int len;
 104         struct tty_struct *tty;
 105
 106         if ((tty = info->tty)) {
 107                 if (info->mcr & UART_MCR_RTS) {
 108                         c = TTY_FLIPBUF_SIZE - tty->flip.count;
 109                         len = skb->len;
 110                         if (c >= len) {
 111                                 memcpy(tty->flip.char_buf_ptr, skb->data, len);
 112                                 memset(tty->flip.flag_buf_ptr, 0, len);
 113                                 tty->flip.count += len;
 114                                 tty->flip.char_buf_ptr += len;
 115                                 tty->flip.flag_buf_ptr += len;
 116                                 tty_flip_buffer_push(tty);
 117                                 kfree_skb(skb);
 118                                 return 1;
 119                         }
 120                 }
 121         }
 122         return 0;
 123 }
 124
 125 /* ctc_tty_readmodem() is called periodically from within timer-interrupt.
 126  * It tries getting received data from the receive queue an stuff it into
 127  * the tty's flip-buffer.
 128  */
 129 static int
 130 ctc_tty_readmodem(ctc_tty_info *info)
 131 {
 132         int ret = 1;
 133         struct tty_struct *tty;
 134
 135         if ((tty = info->tty)) {
 136                 if (info->mcr & UART_MCR_RTS) {
 137                         int c = TTY_FLIPBUF_SIZE - tty->flip.count;
 138                         struct sk_buff *skb;
 139
 140                         if ((c > 0) && (skb = skb_dequeue(&info->rx_queue))) {
 141                                 int len = skb->len;
 142                                 if (len > c)
 143                                         len = c;
 144                                 memcpy(tty->flip.char_buf_ptr, skb->data, len);
 145                                 skb_pull(skb, len);
 146                                 memset(tty->flip.flag_buf_ptr, 0, len);
 147                                 tty->flip.count += len;
 148                                 tty->flip.char_buf_ptr += len;
 149                                 tty->flip.flag_buf_ptr += len;
 150                                 tty_flip_buffer_push(tty);
 151                                 if (skb->len > 0)
 152                                         skb_queue_head(&info->rx_queue, skb);
 153                                 else {
 154                                         kfree_skb(skb);
 155                                         ret = skb_queue_len(&info->rx_queue);
 156                                 }
 157                         }
 158                 }
 159         }
 160         return ret;
 161 }
 162
 163 void
 164 ctc_tty_setcarrier(struct net_device *netdev, int on)
 165 {
 166         int i;
 167
 168         if ((!driver) || ctc_tty_shuttingdown)
 169                 return;
 170         for (i = 0; i < CTC_TTY_MAX_DEVICES; i++)
 171                 if (driver->info[i].netdev == netdev) {
 172                         ctc_tty_info *info = &driver->info[i];
 173                         if (on)
 174                                 info->msr |= UART_MSR_DCD;
 175                         else
 176                                 info->msr &= ~UART_MSR_DCD;
 177                         if ((info->flags & CTC_ASYNC_CHECK_CD) && (!on))
 178                                 tty_hangup(info->tty);
 179                 }
 180 }
 181
 182 void
 183 ctc_tty_netif_rx(struct sk_buff *skb)
 184 {
 185         int i;
 186         ctc_tty_info *info = NULL;
 187
 188         if (!skb)
 189                 return;
 190         if ((!skb->dev) || (!driver) || ctc_tty_shuttingdown) {
 191                 dev_kfree_skb(skb);
 192                 return;
 193         }
 194         for (i = 0; i < CTC_TTY_MAX_DEVICES; i++)
 195                 if (driver->info[i].netdev == skb->dev) {
 196                         info = &driver->info[i];
 197                         break;
 198                 }
 199         if (!info) {
 200                 dev_kfree_skb(skb);
 201                 return;
 202         }
 203         if (skb->len < 6) {
 204                 dev_kfree_skb(skb);
 205                 return;
 206         }
 207         if (memcmp(skb->data, &ctc_tty_magic, sizeof(__u32))) {
 208                 dev_kfree_skb(skb);
 209                 return;
 210         }
 211         skb_pull(skb, sizeof(__u32));
 212
 213         i = *((int *)skb->data);
 214         skb_pull(skb, sizeof(info->mcr));
 215         if (i & UART_MCR_RTS) {
 216                 info->msr |= UART_MSR_CTS;
 217                 if (info->flags & CTC_ASYNC_CTS_FLOW)
 218                         info->tty->hw_stopped = 0;
 219         } else {
 220                 info->msr &= ~UART_MSR_CTS;
 221                 if (info->flags & CTC_ASYNC_CTS_FLOW)
 222                         info->tty->hw_stopped = 1;
 223         }
 224         if (i & UART_MCR_DTR)
 225                 info->msr |= UART_MSR_DSR;
 226         else
 227                 info->msr &= ~UART_MSR_DSR;
 228         if (skb->len <= 0) {
 229                 kfree_skb(skb);
 230                 return;
 231         }
 232         /* Try to deliver directly via tty-flip-buf if queue is empty */
 233         if (skb_queue_empty(&info->rx_queue))
 234                 if (ctc_tty_try_read(info, skb))
 235                         return;
 236         /* Direct deliver failed or queue wasn't empty.
 237          * Queue up for later dequeueing via timer-irq.
 238          */
 239         skb_queue_tail(&info->rx_queue, skb);
 240         /* Schedule dequeuing */
 241         tasklet_schedule(&info->tasklet);
 242 }
 243
 244 static int
 245 ctc_tty_tint(ctc_tty_info * info)
 246 {
 247         struct sk_buff *skb = skb_dequeue(&info->tx_queue);
 248         int stopped = (info->tty->hw_stopped || info->tty->stopped);
 249         int wake = 1;
 250         int rc;
 251
 252         if (!info->netdev) {
 253                 if (skb)
 254                         kfree_skb(skb);
 255                 return 0;
 256         }
 257         if (info->flags & CTC_ASYNC_TX_LINESTAT) {
 258                 int skb_res = info->netdev->hard_header_len +
 259                         sizeof(info->mcr) + sizeof(__u32);
 260                 /* If we must update line status,
 261                  * create an empty dummy skb and insert it.
 262                  */
 263                 if (skb)
 264                         skb_queue_head(&info->tx_queue, skb);
 265
 266                 skb = dev_alloc_skb(skb_res);
 267                 if (!skb) {
 268                         printk(KERN_WARNING
 269                                "ctc_tty: Out of memory in %s%d tint\n",
 270                                CTC_TTY_NAME, info->line);
 271                         return 1;
 272                 }
 273                 skb_reserve(skb, skb_res);
 274                 stopped = 0;
 275                 wake = 0;
 276         }
 277         if (!skb)
 278                 return 0;
 279         if (stopped) {
 280                 skb_queue_head(&info->tx_queue, skb);
 281                 return 1;
 282         }
 283 #if 0
 284         if (skb->len > 0)
 285                 printk(KERN_DEBUG "tint: %d %02x\n", skb->len, *(skb->data));
 286         else
 287                 printk(KERN_DEBUG "tint: %d STAT\n", skb->len);
 288 #endif
 289         memcpy(skb_push(skb, sizeof(info->mcr)), &info->mcr, sizeof(info->mcr));
 290         memcpy(skb_push(skb, sizeof(__u32)), &ctc_tty_magic, sizeof(__u32));
 291         rc = info->netdev->hard_start_xmit(skb, info->netdev);
 292         if (rc) {
 293                 skb_pull(skb, sizeof(info->mcr) + sizeof(__u32));
 294                 if (skb->len > 0)
 295                         skb_queue_head(&info->tx_queue, skb);
 296                 else
 297                         kfree_skb(skb);
 298         } else {
 299                 struct tty_struct *tty = info->tty;
 300
 301                 info->flags &= ~CTC_ASYNC_TX_LINESTAT;
 302                 if (tty) {
 303                         if (wake && (tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
 304                             tty->ldisc.write_wakeup)
 305                                 (tty->ldisc.write_wakeup)(tty);
 306                         wake_up_interruptible(&tty->write_wait);
 307                 }
 308         }
 309         return (skb_queue_empty(&info->tx_queue) ? 0 : 1);
 310 }
 311
 312 /************************************************************
 313  *
 314  * Modem-functions
 315  *
 316  * mostly "stolen" from original Linux-serial.c and friends.
 317  *
 318  ************************************************************/
 319
 320 static inline int
 321 ctc_tty_paranoia_check(ctc_tty_info * info, char *name, const char *routine)
 322 {
 323 #ifdef MODEM_PARANOIA_CHECK
 324         if (!info) {
 325                 printk(KERN_WARNING "ctc_tty: null info_struct for %s in %s\n",
 326                        name, routine);
 327                 return 1;
 328         }
 329         if (info->magic != CTC_ASYNC_MAGIC) {
 330                 printk(KERN_WARNING "ctc_tty: bad magic for info struct %s in %s\n",
 331                        name, routine);
 332                 return 1;
 333         }
 334 #endif
 335         return 0;
 336 }
 337
 338 static void
 339 ctc_tty_inject(ctc_tty_info *info, char c)
 340 {
 341         int skb_res;
 342         struct sk_buff *skb;
 343
 344         if (ctc_tty_shuttingdown)
 345                 return;
 346         skb_res = info->netdev->hard_header_len + sizeof(info->mcr) +
 347                 sizeof(__u32) + 1;
 348         skb = dev_alloc_skb(skb_res);
 349         if (!skb) {
 350                 printk(KERN_WARNING
 351                        "ctc_tty: Out of memory in %s%d tx_inject\n",
 352                        CTC_TTY_NAME, info->line);
 353                 return;
 354         }
 355         skb_reserve(skb, skb_res);
 356         *(skb_put(skb, 1)) = c;
 357         skb_queue_head(&info->tx_queue, skb);
 358         tasklet_schedule(&info->tasklet);
 359 }
 360
 361 static void
 362 ctc_tty_transmit_status(ctc_tty_info *info)
 363 {
 364         if (ctc_tty_shuttingdown)
 365                 return;
 366         info->flags |= CTC_ASYNC_TX_LINESTAT;
 367         tasklet_schedule(&info->tasklet);
 368 }
 369
 370 static void
 371 ctc_tty_change_speed(ctc_tty_info * info)
 372 {
 373         unsigned int cflag;
 374         unsigned int quot;
 375         int i;
 376
 377         if (!info->tty || !info->tty->termios)
 378                 return;
 379         cflag = info->tty->termios->c_cflag;
 380
 381         quot = i = cflag & CBAUD;
 382         if (i & CBAUDEX) {
 383                 i &= ~CBAUDEX;
 384                 if (i < 1 || i > 2)
 385                         info->tty->termios->c_cflag &= ~CBAUDEX;
 386                 else
 387                         i += 15;
 388         }
 389         if (quot) {
 390                 info->mcr |= UART_MCR_DTR;
 391                 info->mcr |= UART_MCR_RTS;
 392                 ctc_tty_transmit_status(info);
 393         } else {
 394                 info->mcr &= ~UART_MCR_DTR;
 395                 info->mcr &= ~UART_MCR_RTS;
 396                 ctc_tty_transmit_status(info);
 397                 return;
 398         }
 399
 400         /* CTS flow control flag and modem status interrupts */
 401         if (cflag & CRTSCTS) {
 402                 info->flags |= CTC_ASYNC_CTS_FLOW;
 403         } else
 404                 info->flags &= ~CTC_ASYNC_CTS_FLOW;
 405         if (cflag & CLOCAL)
 406                 info->flags &= ~CTC_ASYNC_CHECK_CD;
 407         else {
 408                 info->flags |= CTC_ASYNC_CHECK_CD;
 409         }
 410 }
 411
 412 static int
 413 ctc_tty_startup(ctc_tty_info * info)
 414 {
 415         if (info->flags & CTC_ASYNC_INITIALIZED)
 416                 return 0;
 417 #ifdef CTC_DEBUG_MODEM_OPEN
 418         printk(KERN_DEBUG "starting up %s%d ...\n", CTC_TTY_NAME, info->line);
 419 #endif
 420         /*
 421          * Now, initialize the UART
 422          */
 423         info->mcr = UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2;
 424         if (info->tty)
 425                 clear_bit(TTY_IO_ERROR, &info->tty->flags);
 426         /*
 427          * and set the speed of the serial port
 428          */
 429         ctc_tty_change_speed(info);
 430
 431         info->flags |= CTC_ASYNC_INITIALIZED;
 432         if (!(info->flags & CTC_ASYNC_NETDEV_OPEN))
 433                 info->netdev->open(info->netdev);
 434         info->flags |= CTC_ASYNC_NETDEV_OPEN;
 435         return 0;
 436 }
 437
 438 static void
 439 ctc_tty_stopdev(unsigned long data)
 440 {
 441         ctc_tty_info *info = (ctc_tty_info *)data;
 442
 443         if ((!info) || (!info->netdev) ||
 444             (info->flags & CTC_ASYNC_INITIALIZED))
 445                 return;
 446         info->netdev->stop(info->netdev);
 447         info->flags &= ~CTC_ASYNC_NETDEV_OPEN;
 448 }
 449
 450 /*
 451  * This routine will shutdown a serial port; interrupts are disabled, and
 452  * DTR is dropped if the hangup on close termio flag is on.
 453  */
 454 static void
 455 ctc_tty_shutdown(ctc_tty_info * info)
 456 {
 457         if (!(info->flags & CTC_ASYNC_INITIALIZED))
 458                 return;
 459 #ifdef CTC_DEBUG_MODEM_OPEN
 460         printk(KERN_DEBUG "Shutting down %s%d ....\n", CTC_TTY_NAME, info->line);
 461 #endif
 462         info->msr &= ~UART_MSR_RI;
 463         if (!info->tty || (info->tty->termios->c_cflag & HUPCL))
 464                 info->mcr &= ~(UART_MCR_DTR | UART_MCR_RTS);
 465         if (info->tty)
 466                 set_bit(TTY_IO_ERROR, &info->tty->flags);
 467         mod_timer(&info->stoptimer, jiffies + (10 * HZ));
 468         skb_queue_purge(&info->tx_queue);
 469         skb_queue_purge(&info->rx_queue);
 470         info->flags &= ~CTC_ASYNC_INITIALIZED;
 471 }
 472
 473 /* ctc_tty_write() is the main send-routine. It is called from the upper
 474  * levels within the kernel to perform sending data. Depending on the
 475  * online-flag it either directs output to the at-command-interpreter or
 476  * to the lower level. Additional tasks done here:
 477  *  - If online, check for escape-sequence (+++)
 478  *  - If sending audio-data, call ctc_tty_DLEdown() to parse DLE-codes.
 479  *  - If receiving audio-data, call ctc_tty_end_vrx() to abort if needed.
 480  *  - If dialing, abort dial.
 481  */
 482 static int
 483 ctc_tty_write(struct tty_struct *tty, int from_user, const u_char * buf, int count)
 484 {
 485         int c;
 486         int total = 0;
 487         ctc_tty_info *info = (ctc_tty_info *) tty->driver_data;
 488
 489         if (ctc_tty_shuttingdown)
 490                 return 0;
 491         if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_write"))
 492                 return 0;
 493         if (!tty)
 494                 return 0;
 495         if (!info->netdev)
 496                 return -ENODEV;
 497         if (from_user)
 498                 down(&info->write_sem);
 499         while (1) {
 500                 struct sk_buff *skb;
 501                 int skb_res;
 502
 503                 c = (count < CTC_TTY_XMIT_SIZE) ? count : CTC_TTY_XMIT_SIZE;
 504                 if (c <= 0)
 505                         break;
 506
 507                 skb_res = info->netdev->hard_header_len + sizeof(info->mcr) +
 508                         + sizeof(__u32);
 509                 skb = dev_alloc_skb(skb_res + c);
 510                 if (!skb) {
 511                         printk(KERN_WARNING
 512                                "ctc_tty: Out of memory in %s%d write\n",
 513                                CTC_TTY_NAME, info->line);
 514                         break;
 515                 }
 516                 skb_reserve(skb, skb_res);
 517                 if (from_user)
 518                         copy_from_user(skb_put(skb, c), buf, c);
 519                 else
 520                         memcpy(skb_put(skb, c), buf, c);
 521                 skb_queue_tail(&info->tx_queue, skb);
 522                 buf += c;
 523                 total += c;
 524                 count -= c;
 525         }
 526         if (skb_queue_len(&info->tx_queue)) {
 527                 info->lsr &= ~UART_LSR_TEMT;
 528                 tasklet_schedule(&info->tasklet);
 529         }
 530         if (from_user)
 531                 up(&info->write_sem);
 532         return total;
 533 }
 534
 535 static int
 536 ctc_tty_write_room(struct tty_struct *tty)
 537 {
 538         ctc_tty_info *info = (ctc_tty_info *) tty->driver_data;
 539
 540         if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_write_room"))
 541                 return 0;
 542         return CTC_TTY_XMIT_SIZE;
 543 }
 544
 545 static int
 546 ctc_tty_chars_in_buffer(struct tty_struct *tty)
 547 {
 548         ctc_tty_info *info = (ctc_tty_info *) tty->driver_data;
 549
 550         if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_chars_in_buffer"))
 551                 return 0;
 552         return 0;
 553 }
 554
 555 static void
 556 ctc_tty_flush_buffer(struct tty_struct *tty)
 557 {
 558         ctc_tty_info *info;
 559         unsigned long flags;
 560
 561         if (!tty)
 562                 return;
 563         spin_lock_irqsave(&ctc_tty_lock, flags);
 564         info = (ctc_tty_info *) tty->driver_data;
 565         if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_flush_buffer")) {
 566                 spin_unlock_irqrestore(&ctc_tty_lock, flags);
 567                 return;
 568         }
 569         skb_queue_purge(&info->tx_queue);
 570         info->lsr |= UART_LSR_TEMT;
 571         spin_unlock_irqrestore(&ctc_tty_lock, flags);
 572         wake_up_interruptible(&tty->write_wait);
 573         if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
 574             tty->ldisc.write_wakeup)
 575                 (tty->ldisc.write_wakeup) (tty);
 576 }
 577
 578 static void
 579 ctc_tty_flush_chars(struct tty_struct *tty)
 580 {
 581         ctc_tty_info *info = (ctc_tty_info *) tty->driver_data;
 582
 583         if (ctc_tty_shuttingdown)
 584                 return;
 585         if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_flush_chars"))
 586                 return;
 587         if (tty->stopped || tty->hw_stopped || (!skb_queue_len(&info->tx_queue)))
 588                 return;
 589         tasklet_schedule(&info->tasklet);
 590 }
 591
 592 /*
 593  * ------------------------------------------------------------
 594  * ctc_tty_throttle()
 595  *
 596  * This routine is called by the upper-layer tty layer to signal that
 597  * incoming characters should be throttled.
 598  * ------------------------------------------------------------
 599  */
 600 static void
 601 ctc_tty_throttle(struct tty_struct *tty)
 602 {
 603         ctc_tty_info *info = (ctc_tty_info *) tty->driver_data;
 604
 605         if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_throttle"))
 606                 return;
 607         info->mcr &= ~UART_MCR_RTS;
 608         if (I_IXOFF(tty))
 609                 ctc_tty_inject(info, STOP_CHAR(tty));
 610         ctc_tty_transmit_status(info);
 611 }
 612
 613 static void
 614 ctc_tty_unthrottle(struct tty_struct *tty)
 615 {
 616         ctc_tty_info *info = (ctc_tty_info *) tty->driver_data;
 617
 618         if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_unthrottle"))
 619                 return;
 620         info->mcr |= UART_MCR_RTS;
 621         if (I_IXOFF(tty))
 622                 ctc_tty_inject(info, START_CHAR(tty));
 623         ctc_tty_transmit_status(info);
 624 }
 625
 626 /*
 627  * ------------------------------------------------------------
 628  * ctc_tty_ioctl() and friends
 629  * ------------------------------------------------------------
 630  */
 631
 632 /*
 633  * ctc_tty_get_lsr_info - get line status register info
 634  *
 635  * Purpose: Let user call ioctl() to get info when the UART physically
 636  *          is emptied.  On bus types like RS485, the transmitter must
 637  *          release the bus after transmitting. This must be done when
 638  *          the transmit shift register is empty, not be done when the
 639  *          transmit holding register is empty.  This functionality
 640  *          allows RS485 driver to be written in user space.
 641  */
 642 static int
 643 ctc_tty_get_lsr_info(ctc_tty_info * info, uint * value)
 644 {
 645         u_char status;
 646         uint result;
 647         ulong flags;
 648
 649         spin_lock_irqsave(&ctc_tty_lock, flags);
 650         status = info->lsr;
 651         spin_unlock_irqrestore(&ctc_tty_lock, flags);
 652         result = ((status & UART_LSR_TEMT) ? TIOCSER_TEMT : 0);
 653         put_user(result, (uint *) value);
 654         return 0;
 655 }
 656
 657
 658 static int ctc_tty_tiocmget(struct tty_struct *tty, struct file *file)
 659 {
 660         ctc_tty_info *info = (ctc_tty_info *) tty->driver_data;
 661         u_char control,
 662          status;
 663         uint result;
 664         ulong flags;
 665
 666         if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_ioctl"))
 667                 return -ENODEV;
 668         if (tty->flags & (1 << TTY_IO_ERROR))
 669                 return -EIO;
 670
 671         control = info->mcr;
 672         spin_lock_irqsave(&ctc_tty_lock, flags);
 673         status = info->msr;
 674         spin_unlock_irqrestore(&ctc_tty_lock, flags);
 675         result = ((control & UART_MCR_RTS) ? TIOCM_RTS : 0)
 676             | ((control & UART_MCR_DTR) ? TIOCM_DTR : 0)
 677             | ((status & UART_MSR_DCD) ? TIOCM_CAR : 0)
 678             | ((status & UART_MSR_RI) ? TIOCM_RNG : 0)
 679             | ((status & UART_MSR_DSR) ? TIOCM_DSR : 0)
 680             | ((status & UART_MSR_CTS) ? TIOCM_CTS : 0);
 681         return result;
 682 }
 683
 684 static int
 685 ctc_tty_tiocmset(struct tty_struct *tty, struct file *file,
 686                  unsigned int set, unsigned int clear)
 687 {
 688         ctc_tty_info *info = (ctc_tty_info *) tty->driver_data;
 689
 690         if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_ioctl"))
 691                 return -ENODEV;
 692         if (tty->flags & (1 << TTY_IO_ERROR))
 693                 return -EIO;
 694
 695         if (set & TIOCM_RTS)
 696                 info->mcr |= UART_MCR_RTS;
 697         if (set & TIOCM_DTR)
 698                 info->mcr |= UART_MCR_DTR;
 699
 700         if (clear & TIOCM_RTS)
 701                 info->mcr &= ~UART_MCR_RTS;
 702         if (clear & TIOCM_DTR)
 703                 info->mcr &= ~UART_MCR_DTR;
 704
 705         if ((set | clear) & (TIOCM_RTS|TIOCM_DTR))
 706                 ctc_tty_transmit_status(info);
 707         return 0;
 708 }
 709
 710 static int
 711 ctc_tty_ioctl(struct tty_struct *tty, struct file *file,
 712                uint cmd, ulong arg)
 713 {
 714         ctc_tty_info *info = (ctc_tty_info *) tty->driver_data;
 715         int error;
 716         int retval;
 717
 718         if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_ioctl"))
 719                 return -ENODEV;
 720         if (tty->flags & (1 << TTY_IO_ERROR))
 721                 return -EIO;
 722         switch (cmd) {
 723                 case TCSBRK:   /* SVID version: non-zero arg --> no break */
 724 #ifdef CTC_DEBUG_MODEM_IOCTL
 725                         printk(KERN_DEBUG "%s%d ioctl TCSBRK\n", CTC_TTY_NAME, info->line);
 726 #endif
 727                         retval = tty_check_change(tty);
 728                         if (retval)
 729                                 return retval;
 730                         tty_wait_until_sent(tty, 0);
 731                         return 0;
 732                 case TCSBRKP:  /* support for POSIX tcsendbreak() */
 733 #ifdef CTC_DEBUG_MODEM_IOCTL
 734                         printk(KERN_DEBUG "%s%d ioctl TCSBRKP\n", CTC_TTY_NAME, info->line);
 735 #endif
 736                         retval = tty_check_change(tty);
 737                         if (retval)
 738                                 return retval;
 739                         tty_wait_until_sent(tty, 0);
 740                         return 0;
 741                 case TIOCGSOFTCAR:
 742 #ifdef CTC_DEBUG_MODEM_IOCTL
 743                         printk(KERN_DEBUG "%s%d ioctl TIOCGSOFTCAR\n", CTC_TTY_NAME,
 744                                info->line);
 745 #endif
 746                         error = put_user(C_CLOCAL(tty) ? 1 : 0, (ulong *) arg);
 747                         return error;
 748                 case TIOCSSOFTCAR:
 749 #ifdef CTC_DEBUG_MODEM_IOCTL
 750                         printk(KERN_DEBUG "%s%d ioctl TIOCSSOFTCAR\n", CTC_TTY_NAME,
 751                                info->line);
 752 #endif
 753                         error = get_user(arg, (ulong *) arg);
 754                         if (error)
 755                                 return error;
 756                         tty->termios->c_cflag =
 757                             ((tty->termios->c_cflag & ~CLOCAL) |
 758                              (arg ? CLOCAL : 0));
 759                         return 0;
 760                 case TIOCSERGETLSR:     /* Get line status register */
 761 #ifdef CTC_DEBUG_MODEM_IOCTL
 762                         printk(KERN_DEBUG "%s%d ioctl TIOCSERGETLSR\n", CTC_TTY_NAME,
 763                                info->line);
 764 #endif
 765                         error = verify_area(VERIFY_WRITE, (void *) arg, sizeof(uint));
 766                         if (error)
 767                                 return error;
 768                         else
 769                                 return ctc_tty_get_lsr_info(info, (uint *) arg);
 770                 default:
 771 #ifdef CTC_DEBUG_MODEM_IOCTL
 772                         printk(KERN_DEBUG "UNKNOWN ioctl 0x%08x on %s%d\n", cmd,
 773                                CTC_TTY_NAME, info->line);
 774 #endif
 775                         return -ENOIOCTLCMD;
 776         }
 777         return 0;
 778 }
 779
 780 static void
 781 ctc_tty_set_termios(struct tty_struct *tty, struct termios *old_termios)
 782 {
 783         ctc_tty_info *info = (ctc_tty_info *) tty->driver_data;
 784         unsigned int cflag = tty->termios->c_cflag;
 785
 786         ctc_tty_change_speed(info);
 787
 788         /* Handle transition to B0 */
 789         if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD)) {
 790                 info->mcr &= ~(UART_MCR_DTR|UART_MCR_RTS);
 791                 ctc_tty_transmit_status(info);
 792         }
 793
 794         /* Handle transition from B0 to other */
 795         if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
 796                 info->mcr |= UART_MCR_DTR;
 797                 if (!(tty->termios->c_cflag & CRTSCTS) ||
 798                     !test_bit(TTY_THROTTLED, &tty->flags)) {
 799                         info->mcr |= UART_MCR_RTS;
 800                 }
 801                 ctc_tty_transmit_status(info);
 802         }
 803
 804         /* Handle turning off CRTSCTS */
 805         if ((old_termios->c_cflag & CRTSCTS) &&
 806             !(tty->termios->c_cflag & CRTSCTS))
 807                 tty->hw_stopped = 0;
 808 }
 809
 810 /*
 811  * ------------------------------------------------------------
 812  * ctc_tty_open() and friends
 813  * ------------------------------------------------------------
 814  */
 815 static int
 816 ctc_tty_block_til_ready(struct tty_struct *tty, struct file *filp, ctc_tty_info *info)
 817 {
 818         DECLARE_WAITQUEUE(wait, NULL);
 819         int do_clocal = 0;
 820         unsigned long flags;
 821         int retval;
 822
 823         /*
 824          * If the device is in the middle of being closed, then block
 825          * until it's done, and then try again.
 826          */
 827         if (tty_hung_up_p(filp) ||
 828             (info->flags & CTC_ASYNC_CLOSING)) {
 829                 if (info->flags & CTC_ASYNC_CLOSING)
 830                         wait_event(info->close_wait,
 831                                    !(info->flags & CTC_ASYNC_CLOSING));
 832 #ifdef MODEM_DO_RESTART
 833                 if (info->flags & CTC_ASYNC_HUP_NOTIFY)
 834                         return -EAGAIN;
 835                 else
 836                         return -ERESTARTSYS;
 837 #else
 838                 return -EAGAIN;
 839 #endif
 840         }
 841         /*
 842          * If non-blocking mode is set, then make the check up front
 843          * and then exit.
 844          */
 845         if ((filp->f_flags & O_NONBLOCK) ||
 846             (tty->flags & (1 << TTY_IO_ERROR))) {
 847                 info->flags |= CTC_ASYNC_NORMAL_ACTIVE;
 848                 return 0;
 849         }
 850         if (tty->termios->c_cflag & CLOCAL)
 851                 do_clocal = 1;
 852         /*
 853          * Block waiting for the carrier detect and the line to become
 854          * free (i.e., not in use by the callout).  While we are in
 855          * this loop, info->count is dropped by one, so that
 856          * ctc_tty_close() knows when to free things.  We restore it upon
 857          * exit, either normal or abnormal.
 858          */
 859         retval = 0;
 860         add_wait_queue(&info->open_wait, &wait);
 861 #ifdef CTC_DEBUG_MODEM_OPEN
 862         printk(KERN_DEBUG "ctc_tty_block_til_ready before block: %s%d, count = %d\n",
 863                CTC_TTY_NAME, info->line, info->count);
 864 #endif
 865         spin_lock_irqsave(&ctc_tty_lock, flags);
 866         if (!(tty_hung_up_p(filp)))
 867                 info->count--;
 868         spin_unlock_irqrestore(&ctc_tty_lock, flags);
 869         info->blocked_open++;
 870         while (1) {
 871                 set_current_state(TASK_INTERRUPTIBLE);
 872                 if (tty_hung_up_p(filp) ||
 873                     !(info->flags & CTC_ASYNC_INITIALIZED)) {
 874 #ifdef MODEM_DO_RESTART
 875                         if (info->flags & CTC_ASYNC_HUP_NOTIFY)
 876                                 retval = -EAGAIN;
 877                         else
 878                                 retval = -ERESTARTSYS;
 879 #else
 880                         retval = -EAGAIN;
 881 #endif
 882                         break;
 883                 }
 884                 if (!(info->flags & CTC_ASYNC_CLOSING) &&
 885                     (do_clocal || (info->msr & UART_MSR_DCD))) {
 886                         break;
 887                 }
 888                 if (signal_pending(current)) {
 889                         retval = -ERESTARTSYS;
 890                         break;
 891                 }
 892 #ifdef CTC_DEBUG_MODEM_OPEN
 893                 printk(KERN_DEBUG "ctc_tty_block_til_ready blocking: %s%d, count = %d\n",
 894                        CTC_TTY_NAME, info->line, info->count);
 895 #endif
 896                 schedule();
 897         }
 898         current->state = TASK_RUNNING;
 899         remove_wait_queue(&info->open_wait, &wait);
 900         if (!tty_hung_up_p(filp))
 901                 info->count++;
 902         info->blocked_open--;
 903 #ifdef CTC_DEBUG_MODEM_OPEN
 904         printk(KERN_DEBUG "ctc_tty_block_til_ready after blocking: %s%d, count = %d\n",
 905                CTC_TTY_NAME, info->line, info->count);
 906 #endif
 907         if (retval)
 908                 return retval;
 909         info->flags |= CTC_ASYNC_NORMAL_ACTIVE;
 910         return 0;
 911 }
 912
 913 /*
 914  * This routine is called whenever a serial port is opened.  It
 915  * enables interrupts for a serial port, linking in its async structure into
 916  * the IRQ chain.   It also performs the serial-specific
 917  * initialization for the tty structure.
 918  */
 919 static int
 920 ctc_tty_open(struct tty_struct *tty, struct file *filp)
 921 {
 922         ctc_tty_info *info;
 923         unsigned long saveflags;
 924         int retval,
 925          line;
 926
 927         line = tty->index;
 928         if (line < 0 || line > CTC_TTY_MAX_DEVICES)
 929                 return -ENODEV;
 930         info = &driver->info[line];
 931         if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_open"))
 932                 return -ENODEV;
 933         if (!info->netdev)
 934                 return -ENODEV;
 935 #ifdef CTC_DEBUG_MODEM_OPEN
 936         printk(KERN_DEBUG "ctc_tty_open %s, count = %d\n", tty->name,
 937                info->count);
 938 #endif
 939         spin_lock_irqsave(&ctc_tty_lock, saveflags);
 940         info->count++;
 941         tty->driver_data = info;
 942         info->tty = tty;
 943         spin_unlock_irqrestore(&ctc_tty_lock, saveflags);
 944         /*
 945          * Start up serial port
 946          */
 947         retval = ctc_tty_startup(info);
 948         if (retval) {
 949 #ifdef CTC_DEBUG_MODEM_OPEN
 950                 printk(KERN_DEBUG "ctc_tty_open return after startup\n");
 951 #endif
 952                 return retval;
 953         }
 954         retval = ctc_tty_block_til_ready(tty, filp, info);
 955         if (retval) {
 956 #ifdef CTC_DEBUG_MODEM_OPEN
 957                 printk(KERN_DEBUG "ctc_tty_open return after ctc_tty_block_til_ready \n");
 958 #endif
 959                 return retval;
 960         }
 961 #ifdef CTC_DEBUG_MODEM_OPEN
 962         printk(KERN_DEBUG "ctc_tty_open %s successful...\n", tty->name);
 963 #endif
 964         return 0;
 965 }
 966
 967 static void
 968 ctc_tty_close(struct tty_struct *tty, struct file *filp)
 969 {
 970         ctc_tty_info *info = (ctc_tty_info *) tty->driver_data;
 971         ulong flags;
 972         ulong timeout;
 973
 974         if (!info || ctc_tty_paranoia_check(info, tty->name, "ctc_tty_close"))
 975                 return;
 976         spin_lock_irqsave(&ctc_tty_lock, flags);
 977         if (tty_hung_up_p(filp)) {
 978                 spin_unlock_irqrestore(&ctc_tty_lock, flags);
 979 #ifdef CTC_DEBUG_MODEM_OPEN
 980                 printk(KERN_DEBUG "ctc_tty_close return after tty_hung_up_p\n");
 981 #endif
 982                 return;
 983         }
 984         if ((tty->count == 1) && (info->count != 1)) {
 985                 /*
 986                  * Uh, oh.  tty->count is 1, which means that the tty
 987                  * structure will be freed.  Info->count should always
 988                  * be one in these conditions.  If it's greater than
 989                  * one, we've got real problems, since it means the
 990                  * serial port won't be shutdown.
 991                  */
 992                 printk(KERN_ERR "ctc_tty_close: bad port count; tty->count is 1, "
 993                        "info->count is %d\n", info->count);
 994                 info->count = 1;
 995         }
 996         if (--info->count < 0) {
 997                 printk(KERN_ERR "ctc_tty_close: bad port count for %s%d: %d\n",
 998                        CTC_TTY_NAME, info->line, info->count);
 999                 info->count = 0;
1000         }
1001         if (info->count) {
1002                 local_irq_restore(flags);
1003 #ifdef CTC_DEBUG_MODEM_OPEN
1004                 printk(KERN_DEBUG "ctc_tty_close after info->count != 0\n");
1005 #endif
1006                 return;
1007         }
1008         info->flags |= CTC_ASYNC_CLOSING;
1009         tty->closing = 1;
1010         /*
1011          * At this point we stop accepting input.  To do this, we
1012          * disable the receive line status interrupts, and tell the
1013          * interrupt driver to stop checking the data ready bit in the
1014          * line status register.
1015          */
1016         if (info->flags & CTC_ASYNC_INITIALIZED) {
1017                 tty_wait_until_sent(tty, 30*HZ); /* 30 seconds timeout */
1018                 /*
1019                  * Before we drop DTR, make sure the UART transmitter
1020                  * has completely drained; this is especially
1021                  * important if there is a transmit FIFO!
1022                  */
1023                 timeout = jiffies + HZ;
1024                 while (!(info->lsr & UART_LSR_TEMT)) {
1025                         set_current_state(TASK_INTERRUPTIBLE);
1026                         spin_unlock_irqrestore(&ctc_tty_lock, flags);
1027                         schedule_timeout(HZ/2);
1028                         spin_lock_irqsave(&ctc_tty_lock, flags);
1029                         if (time_after(jiffies,timeout))
1030                                 break;
1031                 }
1032         }
1033         ctc_tty_shutdown(info);
1034         if (tty->driver->flush_buffer)
1035                 tty->driver->flush_buffer(tty);
1036         if (tty->ldisc.flush_buffer)
1037                 tty->ldisc.flush_buffer(tty);
1038         info->tty = 0;
1039         tty->closing = 0;
1040         if (info->blocked_open) {
1041                 set_current_state(TASK_INTERRUPTIBLE);
1042                 schedule_timeout(HZ/2);
1043                 wake_up_interruptible(&info->open_wait);
1044         }
1045         info->flags &= ~(CTC_ASYNC_NORMAL_ACTIVE | CTC_ASYNC_CLOSING);
1046         wake_up_interruptible(&info->close_wait);
1047         spin_unlock_irqrestore(&ctc_tty_lock, flags);
1048 #ifdef CTC_DEBUG_MODEM_OPEN
1049         printk(KERN_DEBUG "ctc_tty_close normal exit\n");
1050 #endif
1051 }
1052
1053 /*
1054  * ctc_tty_hangup() --- called by tty_hangup() when a hangup is signaled.
1055  */
1056 static void
1057 ctc_tty_hangup(struct tty_struct *tty)
1058 {
1059         ctc_tty_info *info = (ctc_tty_info *)tty->driver_data;
1060         unsigned long saveflags;
1061
1062         if (ctc_tty_paranoia_check(info, tty->name, "ctc_tty_hangup"))
1063                 return;
1064         ctc_tty_shutdown(info);
1065         info->count = 0;
1066         info->flags &= ~CTC_ASYNC_NORMAL_ACTIVE;
1067         spin_lock_irqsave(&ctc_tty_lock, saveflags);
1068         info->tty = 0;
1069         spin_unlock_irqrestore(&ctc_tty_lock, saveflags);
1070         wake_up_interruptible(&info->open_wait);
1071 }
1072
1073
1074 /*
1075  * For all online tty's, try sending data to
1076  * the lower levels.
1077  */
1078 static void
1079 ctc_tty_task(unsigned long arg)
1080 {
1081         ctc_tty_info *info = (void *)arg;
1082         unsigned long saveflags;
1083         int again;
1084
1085         spin_lock_irqsave(&ctc_tty_lock, saveflags);
1086         if ((!ctc_tty_shuttingdown) && info) {
1087                 again = ctc_tty_tint(info);
1088                 if (!again)
1089                         info->lsr |= UART_LSR_TEMT;
1090                 again |= ctc_tty_readmodem(info);
1091                 if (again) {
1092                         tasklet_schedule(&info->tasklet);
1093                 }
1094         }
1095         spin_unlock_irqrestore(&ctc_tty_lock, saveflags);
1096 }
1097
1098 static struct tty_operations ctc_ops = {
1099         .open = ctc_tty_open,
1100         .close = ctc_tty_close,
1101         .write = ctc_tty_write,
1102         .flush_chars = ctc_tty_flush_chars,
1103         .write_room = ctc_tty_write_room,
1104         .chars_in_buffer = ctc_tty_chars_in_buffer,
1105         .flush_buffer = ctc_tty_flush_buffer,
1106         .ioctl = ctc_tty_ioctl,
1107         .throttle = ctc_tty_throttle,
1108         .unthrottle = ctc_tty_unthrottle,
1109         .set_termios = ctc_tty_set_termios,
1110         .hangup = ctc_tty_hangup,
1111         .tiocmget = ctc_tty_tiocmget,
1112         .tiocmset = ctc_tty_tiocmset,
1113 };
1114
1115 int
1116 ctc_tty_init(void)
1117 {
1118         int i;
1119         ctc_tty_info *info;
1120         struct tty_driver *device;
1121
1122         driver = kmalloc(sizeof(ctc_tty_driver), GFP_KERNEL);
1123         if (driver == NULL) {
1124                 printk(KERN_WARNING "Out of memory in ctc_tty_modem_init\n");
1125                 return -ENOMEM;
1126         }
1127         memset(driver, 0, sizeof(ctc_tty_driver));
1128         device = alloc_tty_driver(CTC_TTY_MAX_DEVICES);
1129         if (!device) {
1130                 kfree(driver);
1131                 printk(KERN_WARNING "Out of memory in ctc_tty_modem_init\n");
1132                 return -ENOMEM;
1133         }
1134
1135         device->devfs_name = "ctc/" CTC_TTY_NAME;
1136         device->name = CTC_TTY_NAME;
1137         device->major = CTC_TTY_MAJOR;
1138         device->minor_start = 0;
1139         device->type = TTY_DRIVER_TYPE_SERIAL;
1140         device->subtype = SERIAL_TYPE_NORMAL;
1141         device->init_termios = tty_std_termios;
1142         device->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1143         device->flags = TTY_DRIVER_REAL_RAW;
1144         device->driver_name = "ctc_tty",
1145         tty_set_operations(device, &ctc_ops);
1146         if (tty_register_driver(device)) {
1147                 printk(KERN_WARNING "ctc_tty: Couldn't register serial-device\n");
1148                 put_tty_driver(device);
1149                 kfree(driver);
1150                 return -1;
1151         }
1152         driver->ctc_tty_device = device;
1153         for (i = 0; i < CTC_TTY_MAX_DEVICES; i++) {
1154                 info = &driver->info[i];
1155                 init_MUTEX(&info->write_sem);
1156                 tasklet_init(&info->tasklet, ctc_tty_task,
1157                                 (unsigned long) info);
1158                 info->magic = CTC_ASYNC_MAGIC;
1159                 info->line = i;
1160                 info->tty = 0;
1161                 info->count = 0;
1162                 info->blocked_open = 0;
1163                 init_waitqueue_head(&info->open_wait);
1164                 init_waitqueue_head(&info->close_wait);
1165                 skb_queue_head_init(&info->tx_queue);
1166                 skb_queue_head_init(&info->rx_queue);
1167                 init_timer(&info->stoptimer);
1168                 info->stoptimer.function = ctc_tty_stopdev;
1169                 info->stoptimer.data = (unsigned long)info;
1170                 info->mcr = UART_MCR_RTS;
1171         }
1172         return 0;
1173 }
1174
1175 int
1176 ctc_tty_register_netdev(struct net_device *dev) {
1177         int ttynum;
1178         char *err;
1179         char *p;
1180
1181         if ((!dev) || (!dev->name)) {
1182                 printk(KERN_WARNING
1183                        "ctc_tty_register_netdev called "
1184                        "with NULL dev or NULL dev-name\n");
1185                 return -1;
1186         }
1187         for (p = dev->name; p && ((*p < '0') || (*p > '9')); p++);
1188         ttynum = simple_strtoul(p, &err, 0);
1189         if ((ttynum < 0) || (ttynum >= CTC_TTY_MAX_DEVICES) ||
1190             (err && *err)) {
1191                 printk(KERN_WARNING
1192                        "ctc_tty_register_netdev called "
1193                        "with number in name '%s'\n", dev->name);
1194                 return -1;
1195         }
1196         if (driver->info[ttynum].netdev) {
1197                 printk(KERN_WARNING
1198                        "ctc_tty_register_netdev called "
1199                        "for already registered device '%s'\n",
1200                        dev->name);
1201                 return -1;
1202         }
1203         driver->info[ttynum].netdev = dev;
1204         return 0;
1205 }
1206
1207 void
1208 ctc_tty_unregister_netdev(struct net_device *dev) {
1209         int i;
1210         unsigned long saveflags;
1211         ctc_tty_info *info = NULL;
1212
1213         spin_lock_irqsave(&ctc_tty_lock, saveflags);
1214         for (i = 0; i < CTC_TTY_MAX_DEVICES; i++)
1215                 if (driver->info[i].netdev == dev) {
1216                         info = &driver->info[i];
1217                         break;
1218                 }
1219         if (info) {
1220                 info->netdev = NULL;
1221                 skb_queue_purge(&info->tx_queue);
1222                 skb_queue_purge(&info->rx_queue);
1223         }
1224         spin_unlock_irqrestore(&ctc_tty_lock, saveflags);
1225 }
1226
1227 void
1228 ctc_tty_cleanup(void) {
1229         unsigned long saveflags;
1230
1231         spin_lock_irqsave(&ctc_tty_lock, saveflags);
1232         ctc_tty_shuttingdown = 1;
1233         spin_unlock_irqrestore(&ctc_tty_lock, saveflags);
1234         tty_unregister_driver(driver->ctc_tty_device);
1235         put_tty_driver(driver->ctc_tty_device);
1236         kfree(driver);
1237         driver = NULL;
1238 }