Linux-2.6.12-rc2
[linux-2.6.git] / drivers / net / hamradio / mkiss.c
1 /*
2  *      MKISS Driver
3  *
4  *      This module:
5  *              This module is free software; you can redistribute it and/or
6  *              modify it under the terms of the GNU General Public License
7  *              as published by the Free Software Foundation; either version
8  *              2 of the License, or (at your option) any later version.
9  *
10  *              This module implements the AX.25 protocol for kernel-based
11  *              devices like TTYs. It interfaces between a raw TTY, and the
12  *              kernel's AX.25 protocol layers, just like slip.c.
13  *              AX.25 needs to be separated from slip.c while slip.c is no
14  *              longer a static kernel device since it is a module.
15  *              This method clears the way to implement other kiss protocols
16  *              like mkiss smack g8bpq ..... so far only mkiss is implemented.
17  *
18  * Hans Alblas <hans@esrac.ele.tue.nl>
19  *
20  *      History
21  *      Jonathan (G4KLX)        Fixed to match Linux networking changes - 2.1.15.
22  *      Matthias (DG2FEF)       Added support for FlexNet CRC (on special request)
23  *                              Fixed bug in ax25_close(): dev_lock_wait() was
24  *                              called twice, causing a deadlock.
25  *      Jeroen (PE1RXQ)         Removed old MKISS_MAGIC stuff and calls to
26  *                              MOD_*_USE_COUNT
27  *                              Remove cli() and fix rtnl lock usage.
28  */
29
30 #include <linux/config.h>
31 #include <linux/module.h>
32 #include <asm/system.h>
33 #include <linux/bitops.h>
34 #include <asm/uaccess.h>
35 #include <linux/string.h>
36 #include <linux/mm.h>
37 #include <linux/interrupt.h>
38 #include <linux/in.h>
39 #include <linux/inet.h>
40 #include <linux/tty.h>
41 #include <linux/errno.h>
42 #include <linux/netdevice.h>
43 #include <linux/major.h>
44 #include <linux/init.h>
45 #include <linux/rtnetlink.h>
46 #include <linux/etherdevice.h>
47 #include <linux/skbuff.h>
48 #include <linux/if_arp.h>
49
50 #include <net/ax25.h>
51
52 #include "mkiss.h"
53
54 #ifdef CONFIG_INET
55 #include <linux/ip.h>
56 #include <linux/tcp.h>
57 #endif
58
59 static char banner[] __initdata = KERN_INFO "mkiss: AX.25 Multikiss, Hans Albas PE1AYX\n";
60
61 typedef struct ax25_ctrl {
62         struct ax_disp ctrl;    /*                              */
63         struct net_device  dev; /* the device                   */
64 } ax25_ctrl_t;
65
66 static ax25_ctrl_t **ax25_ctrls;
67
68 int ax25_maxdev = AX25_MAXDEV;          /* Can be overridden with insmod! */
69
70 static struct tty_ldisc ax_ldisc;
71
72 static int ax25_init(struct net_device *);
73 static int kiss_esc(unsigned char *, unsigned char *, int);
74 static int kiss_esc_crc(unsigned char *, unsigned char *, unsigned short, int);
75 static void kiss_unesc(struct ax_disp *, unsigned char);
76
77 /*---------------------------------------------------------------------------*/
78
79 static const unsigned short Crc_flex_table[] = {
80   0x0f87, 0x1e0e, 0x2c95, 0x3d1c, 0x49a3, 0x582a, 0x6ab1, 0x7b38,
81   0x83cf, 0x9246, 0xa0dd, 0xb154, 0xc5eb, 0xd462, 0xe6f9, 0xf770,
82   0x1f06, 0x0e8f, 0x3c14, 0x2d9d, 0x5922, 0x48ab, 0x7a30, 0x6bb9,
83   0x934e, 0x82c7, 0xb05c, 0xa1d5, 0xd56a, 0xc4e3, 0xf678, 0xe7f1,
84   0x2e85, 0x3f0c, 0x0d97, 0x1c1e, 0x68a1, 0x7928, 0x4bb3, 0x5a3a,
85   0xa2cd, 0xb344, 0x81df, 0x9056, 0xe4e9, 0xf560, 0xc7fb, 0xd672,
86   0x3e04, 0x2f8d, 0x1d16, 0x0c9f, 0x7820, 0x69a9, 0x5b32, 0x4abb,
87   0xb24c, 0xa3c5, 0x915e, 0x80d7, 0xf468, 0xe5e1, 0xd77a, 0xc6f3,
88   0x4d83, 0x5c0a, 0x6e91, 0x7f18, 0x0ba7, 0x1a2e, 0x28b5, 0x393c,
89   0xc1cb, 0xd042, 0xe2d9, 0xf350, 0x87ef, 0x9666, 0xa4fd, 0xb574,
90   0x5d02, 0x4c8b, 0x7e10, 0x6f99, 0x1b26, 0x0aaf, 0x3834, 0x29bd,
91   0xd14a, 0xc0c3, 0xf258, 0xe3d1, 0x976e, 0x86e7, 0xb47c, 0xa5f5,
92   0x6c81, 0x7d08, 0x4f93, 0x5e1a, 0x2aa5, 0x3b2c, 0x09b7, 0x183e,
93   0xe0c9, 0xf140, 0xc3db, 0xd252, 0xa6ed, 0xb764, 0x85ff, 0x9476,
94   0x7c00, 0x6d89, 0x5f12, 0x4e9b, 0x3a24, 0x2bad, 0x1936, 0x08bf,
95   0xf048, 0xe1c1, 0xd35a, 0xc2d3, 0xb66c, 0xa7e5, 0x957e, 0x84f7,
96   0x8b8f, 0x9a06, 0xa89d, 0xb914, 0xcdab, 0xdc22, 0xeeb9, 0xff30,
97   0x07c7, 0x164e, 0x24d5, 0x355c, 0x41e3, 0x506a, 0x62f1, 0x7378,
98   0x9b0e, 0x8a87, 0xb81c, 0xa995, 0xdd2a, 0xcca3, 0xfe38, 0xefb1,
99   0x1746, 0x06cf, 0x3454, 0x25dd, 0x5162, 0x40eb, 0x7270, 0x63f9,
100   0xaa8d, 0xbb04, 0x899f, 0x9816, 0xeca9, 0xfd20, 0xcfbb, 0xde32,
101   0x26c5, 0x374c, 0x05d7, 0x145e, 0x60e1, 0x7168, 0x43f3, 0x527a,
102   0xba0c, 0xab85, 0x991e, 0x8897, 0xfc28, 0xeda1, 0xdf3a, 0xceb3,
103   0x3644, 0x27cd, 0x1556, 0x04df, 0x7060, 0x61e9, 0x5372, 0x42fb,
104   0xc98b, 0xd802, 0xea99, 0xfb10, 0x8faf, 0x9e26, 0xacbd, 0xbd34,
105   0x45c3, 0x544a, 0x66d1, 0x7758, 0x03e7, 0x126e, 0x20f5, 0x317c,
106   0xd90a, 0xc883, 0xfa18, 0xeb91, 0x9f2e, 0x8ea7, 0xbc3c, 0xadb5,
107   0x5542, 0x44cb, 0x7650, 0x67d9, 0x1366, 0x02ef, 0x3074, 0x21fd,
108   0xe889, 0xf900, 0xcb9b, 0xda12, 0xaead, 0xbf24, 0x8dbf, 0x9c36,
109   0x64c1, 0x7548, 0x47d3, 0x565a, 0x22e5, 0x336c, 0x01f7, 0x107e,
110   0xf808, 0xe981, 0xdb1a, 0xca93, 0xbe2c, 0xafa5, 0x9d3e, 0x8cb7,
111   0x7440, 0x65c9, 0x5752, 0x46db, 0x3264, 0x23ed, 0x1176, 0x00ff
112 };
113
114 /*---------------------------------------------------------------------------*/
115
116 static unsigned short calc_crc_flex(unsigned char *cp, int size)
117 {
118     unsigned short crc = 0xffff;
119     
120     while (size--)
121         crc = (crc << 8) ^ Crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
122
123     return crc;
124 }
125
126 /*---------------------------------------------------------------------------*/
127
128 static int check_crc_flex(unsigned char *cp, int size)
129 {
130   unsigned short crc = 0xffff;
131
132   if (size < 3)
133       return -1;
134
135   while (size--)
136       crc = (crc << 8) ^ Crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
137
138   if ((crc & 0xffff) != 0x7070) 
139       return -1;
140
141   return 0;
142 }
143
144 /*---------------------------------------------------------------------------*/
145
146 /* Find a free channel, and link in this `tty' line. */
147 static inline struct ax_disp *ax_alloc(void)
148 {
149         ax25_ctrl_t *axp=NULL;
150         int i;
151
152         for (i = 0; i < ax25_maxdev; i++) {
153                 axp = ax25_ctrls[i];
154
155                 /* Not allocated ? */
156                 if (axp == NULL)
157                         break;
158
159                 /* Not in use ? */
160                 if (!test_and_set_bit(AXF_INUSE, &axp->ctrl.flags))
161                         break;
162         }
163
164         /* Sorry, too many, all slots in use */
165         if (i >= ax25_maxdev)
166                 return NULL;
167
168         /* If no channels are available, allocate one */
169         if (axp == NULL && (ax25_ctrls[i] = kmalloc(sizeof(ax25_ctrl_t), GFP_KERNEL)) != NULL) {
170                 axp = ax25_ctrls[i];
171         }
172         memset(axp, 0, sizeof(ax25_ctrl_t));
173
174         /* Initialize channel control data */
175         set_bit(AXF_INUSE, &axp->ctrl.flags);
176         sprintf(axp->dev.name, "ax%d", i++);
177         axp->ctrl.tty      = NULL;
178         axp->dev.base_addr = i;
179         axp->dev.priv      = (void *)&axp->ctrl;
180         axp->dev.next      = NULL;
181         axp->dev.init      = ax25_init;
182
183         if (axp != NULL) {
184                 /*
185                  * register device so that it can be ifconfig'ed
186                  * ax25_init() will be called as a side-effect
187                  * SIDE-EFFECT WARNING: ax25_init() CLEARS axp->ctrl !
188                  */
189                 if (register_netdev(&axp->dev) == 0) {
190                         /* (Re-)Set the INUSE bit.   Very Important! */
191                         set_bit(AXF_INUSE, &axp->ctrl.flags);
192                         axp->ctrl.dev = &axp->dev;
193                         axp->dev.priv = (void *) &axp->ctrl;
194
195                         return &axp->ctrl;
196                 } else {
197                         clear_bit(AXF_INUSE,&axp->ctrl.flags);
198                         printk(KERN_ERR "mkiss: ax_alloc() - register_netdev() failure.\n");
199                 }
200         }
201
202         return NULL;
203 }
204
205 /* Free an AX25 channel. */
206 static inline void ax_free(struct ax_disp *ax)
207 {
208         /* Free all AX25 frame buffers. */
209         if (ax->rbuff)
210                 kfree(ax->rbuff);
211         ax->rbuff = NULL;
212         if (ax->xbuff)
213                 kfree(ax->xbuff);
214         ax->xbuff = NULL;
215         if (!test_and_clear_bit(AXF_INUSE, &ax->flags))
216                 printk(KERN_ERR "mkiss: %s: ax_free for already free unit.\n", ax->dev->name);
217 }
218
219 static void ax_changedmtu(struct ax_disp *ax)
220 {
221         struct net_device *dev = ax->dev;
222         unsigned char *xbuff, *rbuff, *oxbuff, *orbuff;
223         int len;
224
225         len = dev->mtu * 2;
226
227         /*
228          * allow for arrival of larger UDP packets, even if we say not to
229          * also fixes a bug in which SunOS sends 512-byte packets even with
230          * an MSS of 128
231          */
232         if (len < 576 * 2)
233                 len = 576 * 2;
234
235         xbuff = kmalloc(len + 4, GFP_ATOMIC);
236         rbuff = kmalloc(len + 4, GFP_ATOMIC);
237
238         if (xbuff == NULL || rbuff == NULL)  {
239                 printk(KERN_ERR "mkiss: %s: unable to grow ax25 buffers, MTU change cancelled.\n",
240                        ax->dev->name);
241                 dev->mtu = ax->mtu;
242                 if (xbuff != NULL)
243                         kfree(xbuff);
244                 if (rbuff != NULL)
245                         kfree(rbuff);
246                 return;
247         }
248
249         spin_lock_bh(&ax->buflock);
250
251         oxbuff    = ax->xbuff;
252         ax->xbuff = xbuff;
253         orbuff    = ax->rbuff;
254         ax->rbuff = rbuff;
255
256         if (ax->xleft) {
257                 if (ax->xleft <= len) {
258                         memcpy(ax->xbuff, ax->xhead, ax->xleft);
259                 } else  {
260                         ax->xleft = 0;
261                         ax->tx_dropped++;
262                 }
263         }
264
265         ax->xhead = ax->xbuff;
266
267         if (ax->rcount) {
268                 if (ax->rcount <= len) {
269                         memcpy(ax->rbuff, orbuff, ax->rcount);
270                 } else  {
271                         ax->rcount = 0;
272                         ax->rx_over_errors++;
273                         set_bit(AXF_ERROR, &ax->flags);
274                 }
275         }
276
277         ax->mtu      = dev->mtu + 73;
278         ax->buffsize = len;
279
280         spin_unlock_bh(&ax->buflock);
281
282         if (oxbuff != NULL)
283                 kfree(oxbuff);
284         if (orbuff != NULL)
285                 kfree(orbuff);
286 }
287
288
289 /* Set the "sending" flag.  This must be atomic. */
290 static inline void ax_lock(struct ax_disp *ax)
291 {
292         netif_stop_queue(ax->dev);
293 }
294
295
296 /* Clear the "sending" flag.  This must be atomic. */
297 static inline void ax_unlock(struct ax_disp *ax)
298 {
299         netif_start_queue(ax->dev);
300 }
301
302 /* Send one completely decapsulated AX.25 packet to the AX.25 layer. */
303 static void ax_bump(struct ax_disp *ax)
304 {
305         struct sk_buff *skb;
306         int count;
307
308         spin_lock_bh(&ax->buflock);
309         if (ax->rbuff[0] > 0x0f) {
310                 if (ax->rbuff[0] & 0x20) {
311                         ax->crcmode = CRC_MODE_FLEX;
312                         if (check_crc_flex(ax->rbuff, ax->rcount) < 0) {
313                                 ax->rx_errors++;
314                                 return;
315                         }
316                         ax->rcount -= 2;
317                         /* dl9sau bugfix: the trailling two bytes flexnet crc
318                          * will not be passed to the kernel. thus we have
319                          * to correct the kissparm signature, because it
320                          * indicates a crc but there's none
321                          */
322                         *ax->rbuff &= ~0x20;
323                 }
324         }
325         spin_unlock_bh(&ax->buflock);
326
327         count = ax->rcount;
328
329         if ((skb = dev_alloc_skb(count)) == NULL) {
330                 printk(KERN_ERR "mkiss: %s: memory squeeze, dropping packet.\n", ax->dev->name);
331                 ax->rx_dropped++;
332                 return;
333         }
334
335         skb->dev      = ax->dev;
336         spin_lock_bh(&ax->buflock);
337         memcpy(skb_put(skb,count), ax->rbuff, count);
338         spin_unlock_bh(&ax->buflock);
339         skb->mac.raw  = skb->data;
340         skb->protocol = htons(ETH_P_AX25);
341         netif_rx(skb);
342         ax->dev->last_rx = jiffies;
343         ax->rx_packets++;
344         ax->rx_bytes+=count;
345 }
346
347 /* Encapsulate one AX.25 packet and stuff into a TTY queue. */
348 static void ax_encaps(struct ax_disp *ax, unsigned char *icp, int len)
349 {
350         unsigned char *p;
351         int actual, count;
352
353         if (ax->mtu != ax->dev->mtu + 73)       /* Someone has been ifconfigging */
354                 ax_changedmtu(ax);
355
356         if (len > ax->mtu) {            /* Sigh, shouldn't occur BUT ... */
357                 len = ax->mtu;
358                 printk(KERN_ERR "mkiss: %s: truncating oversized transmit packet!\n", ax->dev->name);
359                 ax->tx_dropped++;
360                 ax_unlock(ax);
361                 return;
362         }
363
364         p = icp;
365
366         spin_lock_bh(&ax->buflock);
367         switch (ax->crcmode) {
368                  unsigned short crc;
369
370         case CRC_MODE_FLEX:
371                  *p |= 0x20;
372                  crc = calc_crc_flex(p, len);
373                  count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
374                  break;
375
376         default:
377                  count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
378                  break;
379         }
380         
381         ax->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
382         actual = ax->tty->driver->write(ax->tty, ax->xbuff, count);
383         ax->tx_packets++;
384         ax->tx_bytes+=actual;
385         ax->dev->trans_start = jiffies;
386         ax->xleft = count - actual;
387         ax->xhead = ax->xbuff + actual;
388
389         spin_unlock_bh(&ax->buflock);
390 }
391
392 /*
393  * Called by the driver when there's room for more data.  If we have
394  * more packets to send, we send them here.
395  */
396 static void ax25_write_wakeup(struct tty_struct *tty)
397 {
398         int actual;
399         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
400
401         /* First make sure we're connected. */
402         if (ax == NULL || ax->magic != AX25_MAGIC || !netif_running(ax->dev))
403                 return;
404         if (ax->xleft <= 0)  {
405                 /* Now serial buffer is almost free & we can start
406                  * transmission of another packet
407                  */
408                 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
409
410                 netif_wake_queue(ax->dev);
411                 return;
412         }
413
414         actual = tty->driver->write(tty, ax->xhead, ax->xleft);
415         ax->xleft -= actual;
416         ax->xhead += actual;
417 }
418
419 /* Encapsulate an AX.25 packet and kick it into a TTY queue. */
420 static int ax_xmit(struct sk_buff *skb, struct net_device *dev)
421 {
422         struct ax_disp *ax = netdev_priv(dev);
423
424         if (!netif_running(dev))  {
425                 printk(KERN_ERR "mkiss: %s: xmit call when iface is down\n", dev->name);
426                 return 1;
427         }
428
429         if (netif_queue_stopped(dev)) {
430                 /*
431                  * May be we must check transmitter timeout here ?
432                  *      14 Oct 1994 Dmitry Gorodchanin.
433                  */
434                 if (jiffies - dev->trans_start  < 20 * HZ) {
435                         /* 20 sec timeout not reached */
436                         return 1;
437                 }
438
439                 printk(KERN_ERR "mkiss: %s: transmit timed out, %s?\n", dev->name,
440                        (ax->tty->driver->chars_in_buffer(ax->tty) || ax->xleft) ?
441                        "bad line quality" : "driver error");
442
443                 ax->xleft = 0;
444                 ax->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
445                 ax_unlock(ax);
446         }
447
448         /* We were not busy, so we are now... :-) */
449         if (skb != NULL) {
450                 ax_lock(ax);
451                 ax_encaps(ax, skb->data, skb->len);
452                 kfree_skb(skb);
453         }
454
455         return 0;
456 }
457
458 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
459
460 /* Return the frame type ID */
461 static int ax_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
462           void *daddr, void *saddr, unsigned len)
463 {
464 #ifdef CONFIG_INET
465         if (type != htons(ETH_P_AX25))
466                 return ax25_encapsulate(skb, dev, type, daddr, saddr, len);
467 #endif
468         return 0;
469 }
470
471
472 static int ax_rebuild_header(struct sk_buff *skb)
473 {
474 #ifdef CONFIG_INET
475         return ax25_rebuild_header(skb);
476 #else
477         return 0;
478 #endif
479 }
480
481 #endif  /* CONFIG_{AX25,AX25_MODULE} */
482
483 /* Open the low-level part of the AX25 channel. Easy! */
484 static int ax_open(struct net_device *dev)
485 {
486         struct ax_disp *ax = netdev_priv(dev);
487         unsigned long len;
488
489         if (ax->tty == NULL)
490                 return -ENODEV;
491
492         /*
493          * Allocate the frame buffers:
494          *
495          * rbuff        Receive buffer.
496          * xbuff        Transmit buffer.
497          */
498         len = dev->mtu * 2;
499
500         /*
501          * allow for arrival of larger UDP packets, even if we say not to
502          * also fixes a bug in which SunOS sends 512-byte packets even with
503          * an MSS of 128
504          */
505         if (len < 576 * 2)
506                 len = 576 * 2;
507
508         if ((ax->rbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
509                 goto norbuff;
510
511         if ((ax->xbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
512                 goto noxbuff;
513
514         ax->mtu      = dev->mtu + 73;
515         ax->buffsize = len;
516         ax->rcount   = 0;
517         ax->xleft    = 0;
518
519         ax->flags   &= (1 << AXF_INUSE);      /* Clear ESCAPE & ERROR flags */
520
521         spin_lock_init(&ax->buflock);
522
523         netif_start_queue(dev);
524         return 0;
525
526 noxbuff:
527         kfree(ax->rbuff);
528
529 norbuff:
530         return -ENOMEM;
531 }
532
533
534 /* Close the low-level part of the AX25 channel. Easy! */
535 static int ax_close(struct net_device *dev)
536 {
537         struct ax_disp *ax = netdev_priv(dev);
538
539         if (ax->tty == NULL)
540                 return -EBUSY;
541
542         ax->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
543
544         netif_stop_queue(dev);
545
546         return 0;
547 }
548
549 static int ax25_receive_room(struct tty_struct *tty)
550 {
551         return 65536;  /* We can handle an infinite amount of data. :-) */
552 }
553
554 /*
555  * Handle the 'receiver data ready' interrupt.
556  * This function is called by the 'tty_io' module in the kernel when
557  * a block of data has been received, which can now be decapsulated
558  * and sent on to the AX.25 layer for further processing.
559  */
560 static void ax25_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
561 {
562         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
563
564         if (ax == NULL || ax->magic != AX25_MAGIC || !netif_running(ax->dev))
565                 return;
566
567         /*
568          * Argh! mtu change time! - costs us the packet part received
569          * at the change
570          */
571         if (ax->mtu != ax->dev->mtu + 73)
572                 ax_changedmtu(ax);
573
574         /* Read the characters out of the buffer */
575         while (count--) {
576                 if (fp != NULL && *fp++) {
577                         if (!test_and_set_bit(AXF_ERROR, &ax->flags))
578                                 ax->rx_errors++;
579                         cp++;
580                         continue;
581                 }
582
583                 kiss_unesc(ax, *cp++);
584         }
585 }
586
587 static int ax25_open(struct tty_struct *tty)
588 {
589         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
590         int err;
591
592         /* First make sure we're not already connected. */
593         if (ax && ax->magic == AX25_MAGIC)
594                 return -EEXIST;
595
596         /* OK.  Find a free AX25 channel to use. */
597         if ((ax = ax_alloc()) == NULL)
598                 return -ENFILE;
599
600         ax->tty = tty;
601         tty->disc_data = ax;
602
603         if (tty->driver->flush_buffer)
604                 tty->driver->flush_buffer(tty);
605
606         /* Restore default settings */
607         ax->dev->type = ARPHRD_AX25;
608
609         /* Perform the low-level AX25 initialization. */
610         if ((err = ax_open(ax->dev)))
611                 return err;
612
613         /* Done.  We have linked the TTY line to a channel. */
614         return ax->dev->base_addr;
615 }
616
617 static void ax25_close(struct tty_struct *tty)
618 {
619         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
620
621         /* First make sure we're connected. */
622         if (ax == NULL || ax->magic != AX25_MAGIC)
623                 return;
624
625         unregister_netdev(ax->dev);
626
627         tty->disc_data = NULL;
628         ax->tty        = NULL;
629
630         ax_free(ax);
631 }
632
633
634 static struct net_device_stats *ax_get_stats(struct net_device *dev)
635 {
636         static struct net_device_stats stats;
637         struct ax_disp *ax = netdev_priv(dev);
638
639         memset(&stats, 0, sizeof(struct net_device_stats));
640
641         stats.rx_packets     = ax->rx_packets;
642         stats.tx_packets     = ax->tx_packets;
643         stats.rx_bytes       = ax->rx_bytes;
644         stats.tx_bytes       = ax->tx_bytes;
645         stats.rx_dropped     = ax->rx_dropped;
646         stats.tx_dropped     = ax->tx_dropped;
647         stats.tx_errors      = ax->tx_errors;
648         stats.rx_errors      = ax->rx_errors;
649         stats.rx_over_errors = ax->rx_over_errors;
650
651         return &stats;
652 }
653
654
655 /************************************************************************
656  *                         STANDARD ENCAPSULATION                        *
657  ************************************************************************/
658
659 static int kiss_esc(unsigned char *s, unsigned char *d, int len)
660 {
661         unsigned char *ptr = d;
662         unsigned char c;
663
664         /*
665          * Send an initial END character to flush out any
666          * data that may have accumulated in the receiver
667          * due to line noise.
668          */
669
670         *ptr++ = END;
671
672         while (len-- > 0) {
673                 switch (c = *s++) {
674                         case END:
675                                 *ptr++ = ESC;
676                                 *ptr++ = ESC_END;
677                                 break;
678                         case ESC:
679                                 *ptr++ = ESC;
680                                 *ptr++ = ESC_ESC;
681                                 break;
682                         default:
683                                 *ptr++ = c;
684                                 break;
685                 }
686         }
687
688         *ptr++ = END;
689
690         return ptr - d;
691 }
692
693 /*
694  * MW:
695  * OK its ugly, but tell me a better solution without copying the
696  * packet to a temporary buffer :-)
697  */
698 static int kiss_esc_crc(unsigned char *s, unsigned char *d, unsigned short crc, int len)
699 {
700         unsigned char *ptr = d;
701         unsigned char c=0;
702
703         *ptr++ = END;
704         while (len > 0) {
705                 if (len > 2) 
706                         c = *s++;
707                 else if (len > 1)
708                         c = crc >> 8;
709                 else if (len > 0)
710                         c = crc & 0xff;
711
712                 len--;
713
714                 switch (c) {
715                         case END:
716                                 *ptr++ = ESC;
717                                 *ptr++ = ESC_END;
718                                 break;
719                         case ESC:
720                                 *ptr++ = ESC;
721                                 *ptr++ = ESC_ESC;
722                                 break;
723                         default:
724                                 *ptr++ = c;
725                                 break;
726                 }
727         }
728         *ptr++ = END;
729         return ptr - d;         
730 }
731
732 static void kiss_unesc(struct ax_disp *ax, unsigned char s)
733 {
734         switch (s) {
735                 case END:
736                         /* drop keeptest bit = VSV */
737                         if (test_bit(AXF_KEEPTEST, &ax->flags))
738                                 clear_bit(AXF_KEEPTEST, &ax->flags);
739
740                         if (!test_and_clear_bit(AXF_ERROR, &ax->flags) && (ax->rcount > 2))
741                                 ax_bump(ax);
742
743                         clear_bit(AXF_ESCAPE, &ax->flags);
744                         ax->rcount = 0;
745                         return;
746
747                 case ESC:
748                         set_bit(AXF_ESCAPE, &ax->flags);
749                         return;
750                 case ESC_ESC:
751                         if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
752                                 s = ESC;
753                         break;
754                 case ESC_END:
755                         if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
756                                 s = END;
757                         break;
758         }
759
760         spin_lock_bh(&ax->buflock);
761         if (!test_bit(AXF_ERROR, &ax->flags)) {
762                 if (ax->rcount < ax->buffsize) {
763                         ax->rbuff[ax->rcount++] = s;
764                         spin_unlock_bh(&ax->buflock);
765                         return;
766                 }
767
768                 ax->rx_over_errors++;
769                 set_bit(AXF_ERROR, &ax->flags);
770         }
771         spin_unlock_bh(&ax->buflock);
772 }
773
774
775 static int ax_set_mac_address(struct net_device *dev, void __user *addr)
776 {
777         if (copy_from_user(dev->dev_addr, addr, AX25_ADDR_LEN))
778                 return -EFAULT;
779         return 0;
780 }
781
782 static int ax_set_dev_mac_address(struct net_device *dev, void *addr)
783 {
784         struct sockaddr *sa = addr;
785
786         memcpy(dev->dev_addr, sa->sa_data, AX25_ADDR_LEN);
787
788         return 0;
789 }
790
791
792 /* Perform I/O control on an active ax25 channel. */
793 static int ax25_disp_ioctl(struct tty_struct *tty, void *file, int cmd, void __user *arg)
794 {
795         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
796         unsigned int tmp;
797
798         /* First make sure we're connected. */
799         if (ax == NULL || ax->magic != AX25_MAGIC)
800                 return -EINVAL;
801
802         switch (cmd) {
803                 case SIOCGIFNAME:
804                         if (copy_to_user(arg, ax->dev->name, strlen(ax->dev->name) + 1))
805                                 return -EFAULT;
806                         return 0;
807
808                 case SIOCGIFENCAP:
809                         return put_user(4, (int __user *)arg);
810
811                 case SIOCSIFENCAP:
812                         if (get_user(tmp, (int __user *)arg))
813                                 return -EFAULT;
814                         ax->mode = tmp;
815                         ax->dev->addr_len        = AX25_ADDR_LEN;         /* sizeof an AX.25 addr */
816                         ax->dev->hard_header_len = AX25_KISS_HEADER_LEN + AX25_MAX_HEADER_LEN + 3;
817                         ax->dev->type            = ARPHRD_AX25;
818                         return 0;
819
820                  case SIOCSIFHWADDR:
821                         return ax_set_mac_address(ax->dev, arg);
822
823                 default:
824                         return -ENOIOCTLCMD;
825         }
826 }
827
828 static int ax_open_dev(struct net_device *dev)
829 {
830         struct ax_disp *ax = netdev_priv(dev);
831
832         if (ax->tty == NULL)
833                 return -ENODEV;
834
835         return 0;
836 }
837
838
839 /* Initialize the driver.  Called by network startup. */
840 static int ax25_init(struct net_device *dev)
841 {
842         struct ax_disp *ax = netdev_priv(dev);
843
844         static char ax25_bcast[AX25_ADDR_LEN] =
845                 {'Q'<<1,'S'<<1,'T'<<1,' '<<1,' '<<1,' '<<1,'0'<<1};
846         static char ax25_test[AX25_ADDR_LEN] =
847                 {'L'<<1,'I'<<1,'N'<<1,'U'<<1,'X'<<1,' '<<1,'1'<<1};
848
849         if (ax == NULL)         /* Allocation failed ?? */
850                 return -ENODEV;
851
852         /* Set up the "AX25 Control Block". (And clear statistics) */
853         memset(ax, 0, sizeof (struct ax_disp));
854         ax->magic  = AX25_MAGIC;
855         ax->dev    = dev;
856
857         /* Finish setting up the DEVICE info. */
858         dev->mtu             = AX_MTU;
859         dev->hard_start_xmit = ax_xmit;
860         dev->open            = ax_open_dev;
861         dev->stop            = ax_close;
862         dev->get_stats       = ax_get_stats;
863         dev->set_mac_address = ax_set_dev_mac_address;
864         dev->hard_header_len = 0;
865         dev->addr_len        = 0;
866         dev->type            = ARPHRD_AX25;
867         dev->tx_queue_len    = 10;
868         dev->hard_header     = ax_header;
869         dev->rebuild_header  = ax_rebuild_header;
870
871         memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
872         memcpy(dev->dev_addr,  ax25_test,  AX25_ADDR_LEN);
873
874         /* New-style flags. */
875         dev->flags      = IFF_BROADCAST | IFF_MULTICAST;
876
877         return 0;
878 }
879
880
881 /* ******************************************************************** */
882 /* *                    Init MKISS driver                             * */
883 /* ******************************************************************** */
884
885 static int __init mkiss_init_driver(void)
886 {
887         int status;
888
889         printk(banner);
890
891         if (ax25_maxdev < 4)
892           ax25_maxdev = 4; /* Sanity */
893
894         if ((ax25_ctrls = kmalloc(sizeof(void *) * ax25_maxdev, GFP_KERNEL)) == NULL) {
895                 printk(KERN_ERR "mkiss: Can't allocate ax25_ctrls[] array!\n");
896                 return -ENOMEM;
897         }
898
899         /* Clear the pointer array, we allocate devices when we need them */
900         memset(ax25_ctrls, 0, sizeof(void*) * ax25_maxdev); /* Pointers */
901
902         /* Fill in our line protocol discipline, and register it */
903         ax_ldisc.magic          = TTY_LDISC_MAGIC;
904         ax_ldisc.name           = "mkiss";
905         ax_ldisc.open           = ax25_open;
906         ax_ldisc.close          = ax25_close;
907         ax_ldisc.ioctl          = (int (*)(struct tty_struct *, struct file *,
908                                         unsigned int, unsigned long))ax25_disp_ioctl;
909         ax_ldisc.receive_buf    = ax25_receive_buf;
910         ax_ldisc.receive_room   = ax25_receive_room;
911         ax_ldisc.write_wakeup   = ax25_write_wakeup;
912
913         if ((status = tty_register_ldisc(N_AX25, &ax_ldisc)) != 0) {
914                 printk(KERN_ERR "mkiss: can't register line discipline (err = %d)\n", status);
915                 kfree(ax25_ctrls);
916         }
917         return status;
918 }
919
920 static void __exit mkiss_exit_driver(void)
921 {
922         int i;
923
924         for (i = 0; i < ax25_maxdev; i++) {
925                 if (ax25_ctrls[i]) {
926                         /*
927                         * VSV = if dev->start==0, then device
928                         * unregistered while close proc.
929                         */
930                         if (netif_running(&ax25_ctrls[i]->dev))
931                                 unregister_netdev(&ax25_ctrls[i]->dev);
932                         kfree(ax25_ctrls[i]);
933                 }
934         }
935
936         kfree(ax25_ctrls);
937         ax25_ctrls = NULL;
938
939         if ((i = tty_register_ldisc(N_AX25, NULL)))
940                 printk(KERN_ERR "mkiss: can't unregister line discipline (err = %d)\n", i);
941 }
942
943 MODULE_AUTHOR("Hans Albas PE1AYX <hans@esrac.ele.tue.nl>");
944 MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs");
945 MODULE_PARM(ax25_maxdev, "i");
946 MODULE_PARM_DESC(ax25_maxdev, "number of MKISS devices");
947 MODULE_LICENSE("GPL");
948 MODULE_ALIAS_LDISC(N_AX25);
949 module_init(mkiss_init_driver);
950 module_exit(mkiss_exit_driver);
951