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