Pull bugzilla-6316 into release branch
[linux-2.6] / drivers / net / wan / x25_asy.c
1 /*
2  *      Things to sort out:
3  *
4  *      o       tbusy handling
5  *      o       allow users to set the parameters
6  *      o       sync/async switching ?
7  *
8  *      Note: This does _not_ implement CCITT X.25 asynchronous framing
9  *      recommendations. Its primarily for testing purposes. If you wanted
10  *      to do CCITT then in theory all you need is to nick the HDLC async
11  *      checksum routines from ppp.c
12  *      Changes:
13  *
14  *      2000-10-29      Henner Eisen    lapb_data_indication() return status.
15  */
16
17 #include <linux/module.h>
18
19 #include <asm/system.h>
20 #include <asm/uaccess.h>
21 #include <linux/bitops.h>
22 #include <linux/string.h>
23 #include <linux/mm.h>
24 #include <linux/interrupt.h>
25 #include <linux/in.h>
26 #include <linux/tty.h>
27 #include <linux/errno.h>
28 #include <linux/netdevice.h>
29 #include <linux/etherdevice.h>
30 #include <linux/skbuff.h>
31 #include <linux/if_arp.h>
32 #include <linux/x25.h>
33 #include <linux/lapb.h>
34 #include <linux/init.h>
35 #include "x25_asy.h"
36
37 #include <net/x25device.h>
38
39 static struct net_device **x25_asy_devs;
40 static int x25_asy_maxdev = SL_NRUNIT;
41
42 module_param(x25_asy_maxdev, int, 0);
43 MODULE_LICENSE("GPL");
44
45 static int x25_asy_esc(unsigned char *p, unsigned char *d, int len);
46 static void x25_asy_unesc(struct x25_asy *sl, unsigned char c);
47 static void x25_asy_setup(struct net_device *dev);
48
49 /* Find a free X.25 channel, and link in this `tty' line. */
50 static struct x25_asy *x25_asy_alloc(void)
51 {
52         struct net_device *dev = NULL;
53         struct x25_asy *sl;
54         int i;
55
56         if (x25_asy_devs == NULL)
57                 return NULL;    /* Master array missing ! */
58
59         for (i = 0; i < x25_asy_maxdev; i++) {
60                 dev = x25_asy_devs[i];
61
62                 /* Not allocated ? */
63                 if (dev == NULL)
64                         break;
65
66                 sl = dev->priv;
67                 /* Not in use ? */
68                 if (!test_and_set_bit(SLF_INUSE, &sl->flags))
69                         return sl;
70         }
71
72
73         /* Sorry, too many, all slots in use */
74         if (i >= x25_asy_maxdev)
75                 return NULL;
76
77         /* If no channels are available, allocate one */
78         if (!dev) {
79                 char name[IFNAMSIZ];
80                 sprintf(name, "x25asy%d", i);
81
82                 dev = alloc_netdev(sizeof(struct x25_asy),
83                                    name, x25_asy_setup);
84                 if (!dev)
85                         return NULL;
86
87                 /* Initialize channel control data */
88                 sl = dev->priv;
89                 dev->base_addr    = i;
90
91                 /* register device so that it can be ifconfig'ed       */
92                 if (register_netdev(dev) == 0) {
93                         /* (Re-)Set the INUSE bit.   Very Important! */
94                         set_bit(SLF_INUSE, &sl->flags);
95                         x25_asy_devs[i] = dev;
96                         return sl;
97                 } else {
98                         printk("x25_asy_alloc() - register_netdev() failure.\n");
99                         free_netdev(dev);
100                 }
101         }
102         return NULL;
103 }
104
105
106 /* Free an X.25 channel. */
107 static void x25_asy_free(struct x25_asy *sl)
108 {
109         /* Free all X.25 frame buffers. */
110         kfree(sl->rbuff);
111         sl->rbuff = NULL;
112         kfree(sl->xbuff);
113         sl->xbuff = NULL;
114
115         if (!test_and_clear_bit(SLF_INUSE, &sl->flags)) {
116                 printk("%s: x25_asy_free for already free unit.\n", sl->dev->name);
117         }
118 }
119
120 static int x25_asy_change_mtu(struct net_device *dev, int newmtu)
121 {
122         struct x25_asy *sl = dev->priv;
123         unsigned char *xbuff, *rbuff;
124         int len = 2* newmtu;
125
126         xbuff = kmalloc(len + 4, GFP_ATOMIC);
127         rbuff = kmalloc(len + 4, GFP_ATOMIC);
128
129         if (xbuff == NULL || rbuff == NULL)  
130         {
131                 printk("%s: unable to grow X.25 buffers, MTU change cancelled.\n",
132                        dev->name);
133                 kfree(xbuff);
134                 kfree(rbuff);
135                 return -ENOMEM;
136         }
137
138         spin_lock_bh(&sl->lock);
139         xbuff    = xchg(&sl->xbuff, xbuff);
140         if (sl->xleft)  {
141                 if (sl->xleft <= len)  {
142                         memcpy(sl->xbuff, sl->xhead, sl->xleft);
143                 } else  {
144                         sl->xleft = 0;
145                         sl->stats.tx_dropped++;
146                 }
147         }
148         sl->xhead = sl->xbuff;
149
150         rbuff    = xchg(&sl->rbuff, rbuff);
151         if (sl->rcount)  {
152                 if (sl->rcount <= len) {
153                         memcpy(sl->rbuff, rbuff, sl->rcount);
154                 } else  {
155                         sl->rcount = 0;
156                         sl->stats.rx_over_errors++;
157                         set_bit(SLF_ERROR, &sl->flags);
158                 }
159         }
160
161         dev->mtu    = newmtu;
162         sl->buffsize = len;
163
164         spin_unlock_bh(&sl->lock);
165
166         kfree(xbuff);
167         kfree(rbuff);
168         return 0;
169 }
170
171
172 /* Set the "sending" flag.  This must be atomic, hence the ASM. */
173
174 static inline void x25_asy_lock(struct x25_asy *sl)
175 {
176         netif_stop_queue(sl->dev);
177 }
178
179
180 /* Clear the "sending" flag.  This must be atomic, hence the ASM. */
181
182 static inline void x25_asy_unlock(struct x25_asy *sl)
183 {
184         netif_wake_queue(sl->dev);
185 }
186
187 /* Send one completely decapsulated IP datagram to the IP layer. */
188
189 static void x25_asy_bump(struct x25_asy *sl)
190 {
191         struct sk_buff *skb;
192         int count;
193         int err;
194
195         count = sl->rcount;
196         sl->stats.rx_bytes+=count;
197         
198         skb = dev_alloc_skb(count+1);
199         if (skb == NULL)  
200         {
201                 printk("%s: memory squeeze, dropping packet.\n", sl->dev->name);
202                 sl->stats.rx_dropped++;
203                 return;
204         }
205         skb_push(skb,1);        /* LAPB internal control */
206         memcpy(skb_put(skb,count), sl->rbuff, count);
207         skb->protocol = x25_type_trans(skb, sl->dev);
208         if((err=lapb_data_received(skb->dev, skb))!=LAPB_OK)
209         {
210                 kfree_skb(skb);
211                 printk(KERN_DEBUG "x25_asy: data received err - %d\n",err);
212         }
213         else
214         {
215                 netif_rx(skb);
216                 sl->dev->last_rx = jiffies;
217                 sl->stats.rx_packets++;
218         }
219 }
220
221 /* Encapsulate one IP datagram and stuff into a TTY queue. */
222 static void x25_asy_encaps(struct x25_asy *sl, unsigned char *icp, int len)
223 {
224         unsigned char *p;
225         int actual, count, mtu = sl->dev->mtu;
226
227         if (len > mtu) 
228         {               /* Sigh, shouldn't occur BUT ... */
229                 len = mtu;
230                 printk ("%s: truncating oversized transmit packet!\n", sl->dev->name);
231                 sl->stats.tx_dropped++;
232                 x25_asy_unlock(sl);
233                 return;
234         }
235
236         p = icp;
237         count = x25_asy_esc(p, (unsigned char *) sl->xbuff, len);
238
239         /* Order of next two lines is *very* important.
240          * When we are sending a little amount of data,
241          * the transfer may be completed inside driver.write()
242          * routine, because it's running with interrupts enabled.
243          * In this case we *never* got WRITE_WAKEUP event,
244          * if we did not request it before write operation.
245          *       14 Oct 1994  Dmitry Gorodchanin.
246          */
247         sl->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
248         actual = sl->tty->driver->write(sl->tty, sl->xbuff, count);
249         sl->xleft = count - actual;
250         sl->xhead = sl->xbuff + actual;
251         /* VSV */
252         clear_bit(SLF_OUTWAIT, &sl->flags);     /* reset outfill flag */
253 }
254
255 /*
256  * Called by the driver when there's room for more data.  If we have
257  * more packets to send, we send them here.
258  */
259 static void x25_asy_write_wakeup(struct tty_struct *tty)
260 {
261         int actual;
262         struct x25_asy *sl = (struct x25_asy *) tty->disc_data;
263
264         /* First make sure we're connected. */
265         if (!sl || sl->magic != X25_ASY_MAGIC || !netif_running(sl->dev))
266                 return;
267
268         if (sl->xleft <= 0)  
269         {
270                 /* Now serial buffer is almost free & we can start
271                  * transmission of another packet */
272                 sl->stats.tx_packets++;
273                 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
274                 x25_asy_unlock(sl);
275                 return;
276         }
277
278         actual = tty->driver->write(tty, sl->xhead, sl->xleft);
279         sl->xleft -= actual;
280         sl->xhead += actual;
281 }
282
283 static void x25_asy_timeout(struct net_device *dev)
284 {
285         struct x25_asy *sl = (struct x25_asy*)(dev->priv);
286
287         spin_lock(&sl->lock);
288         if (netif_queue_stopped(dev)) {
289                 /* May be we must check transmitter timeout here ?
290                  *      14 Oct 1994 Dmitry Gorodchanin.
291                  */
292                 printk(KERN_WARNING "%s: transmit timed out, %s?\n", dev->name,
293                        (sl->tty->driver->chars_in_buffer(sl->tty) || sl->xleft) ?
294                        "bad line quality" : "driver error");
295                 sl->xleft = 0;
296                 sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
297                 x25_asy_unlock(sl);
298         }
299         spin_unlock(&sl->lock);
300 }
301
302 /* Encapsulate an IP datagram and kick it into a TTY queue. */
303
304 static int x25_asy_xmit(struct sk_buff *skb, struct net_device *dev)
305 {
306         struct x25_asy *sl = (struct x25_asy*)(dev->priv);
307         int err;
308
309         if (!netif_running(sl->dev)) {
310                 printk("%s: xmit call when iface is down\n", dev->name);
311                 kfree_skb(skb);
312                 return 0;
313         }
314         
315         switch(skb->data[0])
316         {
317                 case 0x00:break;
318                 case 0x01: /* Connection request .. do nothing */
319                         if((err=lapb_connect_request(dev))!=LAPB_OK)
320                                 printk(KERN_ERR "x25_asy: lapb_connect_request error - %d\n", err);
321                         kfree_skb(skb);
322                         return 0;
323                 case 0x02: /* Disconnect request .. do nothing - hang up ?? */
324                         if((err=lapb_disconnect_request(dev))!=LAPB_OK)
325                                 printk(KERN_ERR "x25_asy: lapb_disconnect_request error - %d\n", err);
326                 default:
327                         kfree_skb(skb);
328                         return  0;
329         }
330         skb_pull(skb,1);        /* Remove control byte */
331         /*
332          * If we are busy already- too bad.  We ought to be able
333          * to queue things at this point, to allow for a little
334          * frame buffer.  Oh well...
335          * -----------------------------------------------------
336          * I hate queues in X.25 driver. May be it's efficient,
337          * but for me latency is more important. ;)
338          * So, no queues !
339          *        14 Oct 1994  Dmitry Gorodchanin.
340          */
341         
342         if((err=lapb_data_request(dev,skb))!=LAPB_OK)
343         {
344                 printk(KERN_ERR "lapbeth: lapb_data_request error - %d\n", err);
345                 kfree_skb(skb);
346                 return 0;
347         }
348         return 0;
349 }
350
351
352 /*
353  *      LAPB interface boilerplate
354  */
355
356 /*
357  *      Called when I frame data arrives. We did the work above - throw it
358  *      at the net layer.
359  */
360   
361 static int x25_asy_data_indication(struct net_device *dev, struct sk_buff *skb)
362 {
363         skb->dev->last_rx = jiffies;
364         return netif_rx(skb);
365 }
366
367 /*
368  *      Data has emerged from the LAPB protocol machine. We don't handle
369  *      busy cases too well. Its tricky to see how to do this nicely -
370  *      perhaps lapb should allow us to bounce this ?
371  */
372  
373 static void x25_asy_data_transmit(struct net_device *dev, struct sk_buff *skb)
374 {
375         struct x25_asy *sl=dev->priv;
376         
377         spin_lock(&sl->lock);
378         if (netif_queue_stopped(sl->dev) || sl->tty == NULL)
379         {
380                 spin_unlock(&sl->lock);
381                 printk(KERN_ERR "x25_asy: tbusy drop\n");
382                 kfree_skb(skb);
383                 return;
384         }
385         /* We were not busy, so we are now... :-) */
386         if (skb != NULL) 
387         {
388                 x25_asy_lock(sl);
389                 sl->stats.tx_bytes+=skb->len;
390                 x25_asy_encaps(sl, skb->data, skb->len);
391                 dev_kfree_skb(skb);
392         }
393         spin_unlock(&sl->lock);
394 }
395
396 /*
397  *      LAPB connection establish/down information.
398  */
399  
400 static void x25_asy_connected(struct net_device *dev, int reason)
401 {
402         struct x25_asy *sl = dev->priv;
403         struct sk_buff *skb;
404         unsigned char *ptr;
405
406         if ((skb = dev_alloc_skb(1)) == NULL) {
407                 printk(KERN_ERR "lapbeth: out of memory\n");
408                 return;
409         }
410
411         ptr  = skb_put(skb, 1);
412         *ptr = 0x01;
413
414         skb->protocol = x25_type_trans(skb, sl->dev);
415         netif_rx(skb);
416         sl->dev->last_rx = jiffies;
417 }
418
419 static void x25_asy_disconnected(struct net_device *dev, int reason)
420 {
421         struct x25_asy *sl = dev->priv;
422         struct sk_buff *skb;
423         unsigned char *ptr;
424
425         if ((skb = dev_alloc_skb(1)) == NULL) {
426                 printk(KERN_ERR "x25_asy: out of memory\n");
427                 return;
428         }
429
430         ptr  = skb_put(skb, 1);
431         *ptr = 0x02;
432
433         skb->protocol = x25_type_trans(skb, sl->dev);
434         netif_rx(skb);
435         sl->dev->last_rx = jiffies;
436 }
437
438 static struct lapb_register_struct x25_asy_callbacks = {
439         .connect_confirmation = x25_asy_connected,
440         .connect_indication = x25_asy_connected,
441         .disconnect_confirmation = x25_asy_disconnected,
442         .disconnect_indication = x25_asy_disconnected,
443         .data_indication = x25_asy_data_indication,
444         .data_transmit = x25_asy_data_transmit,
445
446 };
447
448
449 /* Open the low-level part of the X.25 channel. Easy! */
450 static int x25_asy_open(struct net_device *dev)
451 {
452         struct x25_asy *sl = (struct x25_asy*)(dev->priv);
453         unsigned long len;
454         int err;
455
456         if (sl->tty == NULL)
457                 return -ENODEV;
458
459         /*
460          * Allocate the X.25 frame buffers:
461          *
462          * rbuff        Receive buffer.
463          * xbuff        Transmit buffer.
464          */
465
466         len = dev->mtu * 2;
467
468         sl->rbuff = kmalloc(len + 4, GFP_KERNEL);
469         if (sl->rbuff == NULL)   {
470                 goto norbuff;
471         }
472         sl->xbuff = kmalloc(len + 4, GFP_KERNEL);
473         if (sl->xbuff == NULL)   {
474                 goto noxbuff;
475         }
476
477         sl->buffsize = len;
478         sl->rcount   = 0;
479         sl->xleft    = 0;
480         sl->flags   &= (1 << SLF_INUSE);      /* Clear ESCAPE & ERROR flags */
481
482         netif_start_queue(dev);
483                         
484         /*
485          *      Now attach LAPB
486          */
487         if((err=lapb_register(dev, &x25_asy_callbacks))==LAPB_OK)
488                 return 0;
489
490         /* Cleanup */
491         kfree(sl->xbuff);
492 noxbuff:
493         kfree(sl->rbuff);
494 norbuff:
495         return -ENOMEM;
496 }
497
498
499 /* Close the low-level part of the X.25 channel. Easy! */
500 static int x25_asy_close(struct net_device *dev)
501 {
502         struct x25_asy *sl = (struct x25_asy*)(dev->priv);
503         int err;
504
505         spin_lock(&sl->lock);
506         if (sl->tty) 
507                 sl->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
508
509         netif_stop_queue(dev);
510         sl->rcount = 0;
511         sl->xleft  = 0;
512         if((err=lapb_unregister(dev))!=LAPB_OK)
513                 printk(KERN_ERR "x25_asy_close: lapb_unregister error -%d\n",err);
514         spin_unlock(&sl->lock);
515         return 0;
516 }
517
518 /*
519  * Handle the 'receiver data ready' interrupt.
520  * This function is called by the 'tty_io' module in the kernel when
521  * a block of X.25 data has been received, which can now be decapsulated
522  * and sent on to some IP layer for further processing.
523  */
524  
525 static void x25_asy_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
526 {
527         struct x25_asy *sl = (struct x25_asy *) tty->disc_data;
528
529         if (!sl || sl->magic != X25_ASY_MAGIC || !netif_running(sl->dev))
530                 return;
531
532
533         /* Read the characters out of the buffer */
534         while (count--) {
535                 if (fp && *fp++) {
536                         if (!test_and_set_bit(SLF_ERROR, &sl->flags))  {
537                                 sl->stats.rx_errors++;
538                         }
539                         cp++;
540                         continue;
541                 }
542                 x25_asy_unesc(sl, *cp++);
543         }
544 }
545
546 /*
547  * Open the high-level part of the X.25 channel.
548  * This function is called by the TTY module when the
549  * X.25 line discipline is called for.  Because we are
550  * sure the tty line exists, we only have to link it to
551  * a free X.25 channel...
552  */
553
554 static int x25_asy_open_tty(struct tty_struct *tty)
555 {
556         struct x25_asy *sl = (struct x25_asy *) tty->disc_data;
557         int err;
558
559         /* First make sure we're not already connected. */
560         if (sl && sl->magic == X25_ASY_MAGIC) {
561                 return -EEXIST;
562         }
563
564         /* OK.  Find a free X.25 channel to use. */
565         if ((sl = x25_asy_alloc()) == NULL) {
566                 return -ENFILE;
567         }
568
569         sl->tty = tty;
570         tty->disc_data = sl;
571         tty->receive_room = 65536;
572         if (tty->driver->flush_buffer)  {
573                 tty->driver->flush_buffer(tty);
574         }
575         if (tty->ldisc.flush_buffer)  {
576                 tty->ldisc.flush_buffer(tty);
577         }
578
579         /* Restore default settings */
580         sl->dev->type = ARPHRD_X25;
581         
582         /* Perform the low-level X.25 async init */
583         if ((err = x25_asy_open(sl->dev)))
584                 return err;
585
586         /* Done.  We have linked the TTY line to a channel. */
587         return sl->dev->base_addr;
588 }
589
590
591 /*
592  * Close down an X.25 channel.
593  * This means flushing out any pending queues, and then restoring the
594  * TTY line discipline to what it was before it got hooked to X.25
595  * (which usually is TTY again).
596  */
597 static void x25_asy_close_tty(struct tty_struct *tty)
598 {
599         struct x25_asy *sl = (struct x25_asy *) tty->disc_data;
600
601         /* First make sure we're connected. */
602         if (!sl || sl->magic != X25_ASY_MAGIC)
603                 return;
604
605         if (sl->dev->flags & IFF_UP)
606         {
607                 (void) dev_close(sl->dev);
608         }
609
610         tty->disc_data = NULL;
611         sl->tty = NULL;
612         x25_asy_free(sl);
613 }
614
615
616 static struct net_device_stats *x25_asy_get_stats(struct net_device *dev)
617 {
618         struct x25_asy *sl = (struct x25_asy*)(dev->priv);
619
620         return &sl->stats;
621 }
622
623
624  /************************************************************************
625   *                     STANDARD X.25 ENCAPSULATION                      *
626   ************************************************************************/
627
628 int x25_asy_esc(unsigned char *s, unsigned char *d, int len)
629 {
630         unsigned char *ptr = d;
631         unsigned char c;
632
633         /*
634          * Send an initial END character to flush out any
635          * data that may have accumulated in the receiver
636          * due to line noise.
637          */
638
639         *ptr++ = X25_END;       /* Send 10111110 bit seq */
640
641         /*
642          * For each byte in the packet, send the appropriate
643          * character sequence, according to the X.25 protocol.
644          */
645
646         while (len-- > 0) 
647         {
648                 switch(c = *s++) 
649                 {
650                         case X25_END:
651                                 *ptr++ = X25_ESC;
652                                 *ptr++ = X25_ESCAPE(X25_END);
653                                 break;
654                         case X25_ESC:
655                                 *ptr++ = X25_ESC;
656                                 *ptr++ = X25_ESCAPE(X25_ESC);
657                                 break;
658                          default:
659                                 *ptr++ = c;
660                                 break;
661                 }
662         }
663         *ptr++ = X25_END;
664         return (ptr - d);
665 }
666
667 static void x25_asy_unesc(struct x25_asy *sl, unsigned char s)
668 {
669
670         switch(s) 
671         {
672                 case X25_END:
673                         if (!test_and_clear_bit(SLF_ERROR, &sl->flags) && (sl->rcount > 2))  
674                         {
675                                 x25_asy_bump(sl);
676                         }
677                         clear_bit(SLF_ESCAPE, &sl->flags);
678                         sl->rcount = 0;
679                         return;
680
681                 case X25_ESC:
682                         set_bit(SLF_ESCAPE, &sl->flags);
683                         return;
684                         
685                 case X25_ESCAPE(X25_ESC):
686                 case X25_ESCAPE(X25_END):
687                         if (test_and_clear_bit(SLF_ESCAPE, &sl->flags))
688                                 s = X25_UNESCAPE(s);
689                         break;
690         }
691         if (!test_bit(SLF_ERROR, &sl->flags))  
692         {
693                 if (sl->rcount < sl->buffsize)  
694                 {
695                         sl->rbuff[sl->rcount++] = s;
696                         return;
697                 }
698                 sl->stats.rx_over_errors++;
699                 set_bit(SLF_ERROR, &sl->flags);
700         }
701 }
702
703
704 /* Perform I/O control on an active X.25 channel. */
705 static int x25_asy_ioctl(struct tty_struct *tty, struct file *file,
706                          unsigned int cmd,  unsigned long arg)
707 {
708         struct x25_asy *sl = (struct x25_asy *) tty->disc_data;
709
710         /* First make sure we're connected. */
711         if (!sl || sl->magic != X25_ASY_MAGIC)
712                 return -EINVAL;
713
714         switch(cmd) {
715         case SIOCGIFNAME:
716                 if (copy_to_user((void __user *)arg, sl->dev->name,
717                                         strlen(sl->dev->name) + 1))
718                         return -EFAULT;
719                 return 0;
720         case SIOCSIFHWADDR:
721                 return -EINVAL;
722         /* Allow stty to read, but not set, the serial port */
723         case TCGETS:
724         case TCGETA:
725                 return n_tty_ioctl(tty, file, cmd, arg);
726         default:
727                 return -ENOIOCTLCMD;
728         }
729 }
730
731 static int x25_asy_open_dev(struct net_device *dev)
732 {
733         struct x25_asy *sl = (struct x25_asy*)(dev->priv);
734         if(sl->tty==NULL)
735                 return -ENODEV;
736         return 0;
737 }
738
739 /* Initialise the X.25 driver.  Called by the device init code */
740 static void x25_asy_setup(struct net_device *dev)
741 {
742         struct x25_asy *sl = dev->priv;
743
744         sl->magic  = X25_ASY_MAGIC;
745         sl->dev    = dev;
746         spin_lock_init(&sl->lock);
747         set_bit(SLF_INUSE, &sl->flags);
748
749         /*
750          *      Finish setting up the DEVICE info. 
751          */
752          
753         dev->mtu                = SL_MTU;
754         dev->hard_start_xmit    = x25_asy_xmit;
755         dev->tx_timeout         = x25_asy_timeout;
756         dev->watchdog_timeo     = HZ*20;
757         dev->open               = x25_asy_open_dev;
758         dev->stop               = x25_asy_close;
759         dev->get_stats          = x25_asy_get_stats;
760         dev->change_mtu         = x25_asy_change_mtu;
761         dev->hard_header_len    = 0;
762         dev->addr_len           = 0;
763         dev->type               = ARPHRD_X25;
764         dev->tx_queue_len       = 10;
765
766         /* New-style flags. */
767         dev->flags              = IFF_NOARP;
768 }
769
770 static struct tty_ldisc x25_ldisc = {
771         .owner          = THIS_MODULE,
772         .magic          = TTY_LDISC_MAGIC,
773         .name           = "X.25",
774         .open           = x25_asy_open_tty,
775         .close          = x25_asy_close_tty,
776         .ioctl          = x25_asy_ioctl,
777         .receive_buf    = x25_asy_receive_buf,
778         .write_wakeup   = x25_asy_write_wakeup,
779 };
780
781 static int __init init_x25_asy(void)
782 {
783         if (x25_asy_maxdev < 4)
784                 x25_asy_maxdev = 4; /* Sanity */
785
786         printk(KERN_INFO "X.25 async: version 0.00 ALPHA "
787                         "(dynamic channels, max=%d).\n", x25_asy_maxdev );
788
789         x25_asy_devs = kmalloc(sizeof(struct net_device *)*x25_asy_maxdev, 
790                                GFP_KERNEL);
791         if (!x25_asy_devs) {
792                 printk(KERN_WARNING "X25 async: Can't allocate x25_asy_ctrls[] "
793                                 "array! Uaargh! (-> No X.25 available)\n");
794                 return -ENOMEM;
795         }
796         memset(x25_asy_devs, 0, sizeof(struct net_device *)*x25_asy_maxdev); 
797
798         return tty_register_ldisc(N_X25, &x25_ldisc);
799 }
800
801
802 static void __exit exit_x25_asy(void)
803 {
804         struct net_device *dev;
805         int i;
806
807         for (i = 0; i < x25_asy_maxdev; i++) {
808                 dev = x25_asy_devs[i];
809                 if (dev) {
810                         struct x25_asy *sl = dev->priv;
811
812                         spin_lock_bh(&sl->lock);
813                         if (sl->tty) 
814                                 tty_hangup(sl->tty);
815
816                         spin_unlock_bh(&sl->lock);
817                         /*
818                          * VSV = if dev->start==0, then device
819                          * unregistered while close proc.
820                          */
821                         unregister_netdev(dev);
822                         free_netdev(dev);
823                 }
824         }
825
826         kfree(x25_asy_devs);
827         tty_unregister_ldisc(N_X25);
828 }
829
830 module_init(init_x25_asy);
831 module_exit(exit_x25_asy);