[AX25] Introduce ax25_type_trans
[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         spin_lock_bh(&ax->buflock);
336         memcpy(skb_put(skb,count), ax->rbuff, count);
337         spin_unlock_bh(&ax->buflock);
338         skb->protocol = ax25_type_trans(skb, ax->dev);
339         netif_rx(skb);
340         ax->dev->last_rx = jiffies;
341         ax->rx_packets++;
342         ax->rx_bytes+=count;
343 }
344
345 /* Encapsulate one AX.25 packet and stuff into a TTY queue. */
346 static void ax_encaps(struct ax_disp *ax, unsigned char *icp, int len)
347 {
348         unsigned char *p;
349         int actual, count;
350
351         if (ax->mtu != ax->dev->mtu + 73)       /* Someone has been ifconfigging */
352                 ax_changedmtu(ax);
353
354         if (len > ax->mtu) {            /* Sigh, shouldn't occur BUT ... */
355                 len = ax->mtu;
356                 printk(KERN_ERR "mkiss: %s: truncating oversized transmit packet!\n", ax->dev->name);
357                 ax->tx_dropped++;
358                 ax_unlock(ax);
359                 return;
360         }
361
362         p = icp;
363
364         spin_lock_bh(&ax->buflock);
365         switch (ax->crcmode) {
366                  unsigned short crc;
367
368         case CRC_MODE_FLEX:
369                  *p |= 0x20;
370                  crc = calc_crc_flex(p, len);
371                  count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
372                  break;
373
374         default:
375                  count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
376                  break;
377         }
378         
379         ax->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
380         actual = ax->tty->driver->write(ax->tty, ax->xbuff, count);
381         ax->tx_packets++;
382         ax->tx_bytes+=actual;
383         ax->dev->trans_start = jiffies;
384         ax->xleft = count - actual;
385         ax->xhead = ax->xbuff + actual;
386
387         spin_unlock_bh(&ax->buflock);
388 }
389
390 /*
391  * Called by the driver when there's room for more data.  If we have
392  * more packets to send, we send them here.
393  */
394 static void ax25_write_wakeup(struct tty_struct *tty)
395 {
396         int actual;
397         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
398
399         /* First make sure we're connected. */
400         if (ax == NULL || ax->magic != AX25_MAGIC || !netif_running(ax->dev))
401                 return;
402         if (ax->xleft <= 0)  {
403                 /* Now serial buffer is almost free & we can start
404                  * transmission of another packet
405                  */
406                 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
407
408                 netif_wake_queue(ax->dev);
409                 return;
410         }
411
412         actual = tty->driver->write(tty, ax->xhead, ax->xleft);
413         ax->xleft -= actual;
414         ax->xhead += actual;
415 }
416
417 /* Encapsulate an AX.25 packet and kick it into a TTY queue. */
418 static int ax_xmit(struct sk_buff *skb, struct net_device *dev)
419 {
420         struct ax_disp *ax = netdev_priv(dev);
421
422         if (!netif_running(dev))  {
423                 printk(KERN_ERR "mkiss: %s: xmit call when iface is down\n", dev->name);
424                 return 1;
425         }
426
427         if (netif_queue_stopped(dev)) {
428                 /*
429                  * May be we must check transmitter timeout here ?
430                  *      14 Oct 1994 Dmitry Gorodchanin.
431                  */
432                 if (jiffies - dev->trans_start  < 20 * HZ) {
433                         /* 20 sec timeout not reached */
434                         return 1;
435                 }
436
437                 printk(KERN_ERR "mkiss: %s: transmit timed out, %s?\n", dev->name,
438                        (ax->tty->driver->chars_in_buffer(ax->tty) || ax->xleft) ?
439                        "bad line quality" : "driver error");
440
441                 ax->xleft = 0;
442                 ax->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
443                 ax_unlock(ax);
444         }
445
446         /* We were not busy, so we are now... :-) */
447         if (skb != NULL) {
448                 ax_lock(ax);
449                 ax_encaps(ax, skb->data, skb->len);
450                 kfree_skb(skb);
451         }
452
453         return 0;
454 }
455
456 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
457
458 /* Return the frame type ID */
459 static int ax_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
460           void *daddr, void *saddr, unsigned len)
461 {
462 #ifdef CONFIG_INET
463         if (type != htons(ETH_P_AX25))
464                 return ax25_encapsulate(skb, dev, type, daddr, saddr, len);
465 #endif
466         return 0;
467 }
468
469
470 static int ax_rebuild_header(struct sk_buff *skb)
471 {
472 #ifdef CONFIG_INET
473         return ax25_rebuild_header(skb);
474 #else
475         return 0;
476 #endif
477 }
478
479 #endif  /* CONFIG_{AX25,AX25_MODULE} */
480
481 /* Open the low-level part of the AX25 channel. Easy! */
482 static int ax_open(struct net_device *dev)
483 {
484         struct ax_disp *ax = netdev_priv(dev);
485         unsigned long len;
486
487         if (ax->tty == NULL)
488                 return -ENODEV;
489
490         /*
491          * Allocate the frame buffers:
492          *
493          * rbuff        Receive buffer.
494          * xbuff        Transmit buffer.
495          */
496         len = dev->mtu * 2;
497
498         /*
499          * allow for arrival of larger UDP packets, even if we say not to
500          * also fixes a bug in which SunOS sends 512-byte packets even with
501          * an MSS of 128
502          */
503         if (len < 576 * 2)
504                 len = 576 * 2;
505
506         if ((ax->rbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
507                 goto norbuff;
508
509         if ((ax->xbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
510                 goto noxbuff;
511
512         ax->mtu      = dev->mtu + 73;
513         ax->buffsize = len;
514         ax->rcount   = 0;
515         ax->xleft    = 0;
516
517         ax->flags   &= (1 << AXF_INUSE);      /* Clear ESCAPE & ERROR flags */
518
519         spin_lock_init(&ax->buflock);
520
521         netif_start_queue(dev);
522         return 0;
523
524 noxbuff:
525         kfree(ax->rbuff);
526
527 norbuff:
528         return -ENOMEM;
529 }
530
531
532 /* Close the low-level part of the AX25 channel. Easy! */
533 static int ax_close(struct net_device *dev)
534 {
535         struct ax_disp *ax = netdev_priv(dev);
536
537         if (ax->tty == NULL)
538                 return -EBUSY;
539
540         ax->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
541
542         netif_stop_queue(dev);
543
544         return 0;
545 }
546
547 static int ax25_receive_room(struct tty_struct *tty)
548 {
549         return 65536;  /* We can handle an infinite amount of data. :-) */
550 }
551
552 /*
553  * Handle the 'receiver data ready' interrupt.
554  * This function is called by the 'tty_io' module in the kernel when
555  * a block of data has been received, which can now be decapsulated
556  * and sent on to the AX.25 layer for further processing.
557  */
558 static void ax25_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
559 {
560         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
561
562         if (ax == NULL || ax->magic != AX25_MAGIC || !netif_running(ax->dev))
563                 return;
564
565         /*
566          * Argh! mtu change time! - costs us the packet part received
567          * at the change
568          */
569         if (ax->mtu != ax->dev->mtu + 73)
570                 ax_changedmtu(ax);
571
572         /* Read the characters out of the buffer */
573         while (count--) {
574                 if (fp != NULL && *fp++) {
575                         if (!test_and_set_bit(AXF_ERROR, &ax->flags))
576                                 ax->rx_errors++;
577                         cp++;
578                         continue;
579                 }
580
581                 kiss_unesc(ax, *cp++);
582         }
583 }
584
585 static int ax25_open(struct tty_struct *tty)
586 {
587         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
588         int err;
589
590         /* First make sure we're not already connected. */
591         if (ax && ax->magic == AX25_MAGIC)
592                 return -EEXIST;
593
594         /* OK.  Find a free AX25 channel to use. */
595         if ((ax = ax_alloc()) == NULL)
596                 return -ENFILE;
597
598         ax->tty = tty;
599         tty->disc_data = ax;
600
601         if (tty->driver->flush_buffer)
602                 tty->driver->flush_buffer(tty);
603
604         /* Restore default settings */
605         ax->dev->type = ARPHRD_AX25;
606
607         /* Perform the low-level AX25 initialization. */
608         if ((err = ax_open(ax->dev)))
609                 return err;
610
611         /* Done.  We have linked the TTY line to a channel. */
612         return ax->dev->base_addr;
613 }
614
615 static void ax25_close(struct tty_struct *tty)
616 {
617         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
618
619         /* First make sure we're connected. */
620         if (ax == NULL || ax->magic != AX25_MAGIC)
621                 return;
622
623         unregister_netdev(ax->dev);
624
625         tty->disc_data = NULL;
626         ax->tty        = NULL;
627
628         ax_free(ax);
629 }
630
631
632 static struct net_device_stats *ax_get_stats(struct net_device *dev)
633 {
634         static struct net_device_stats stats;
635         struct ax_disp *ax = netdev_priv(dev);
636
637         memset(&stats, 0, sizeof(struct net_device_stats));
638
639         stats.rx_packets     = ax->rx_packets;
640         stats.tx_packets     = ax->tx_packets;
641         stats.rx_bytes       = ax->rx_bytes;
642         stats.tx_bytes       = ax->tx_bytes;
643         stats.rx_dropped     = ax->rx_dropped;
644         stats.tx_dropped     = ax->tx_dropped;
645         stats.tx_errors      = ax->tx_errors;
646         stats.rx_errors      = ax->rx_errors;
647         stats.rx_over_errors = ax->rx_over_errors;
648
649         return &stats;
650 }
651
652
653 /************************************************************************
654  *                         STANDARD ENCAPSULATION                        *
655  ************************************************************************/
656
657 static int kiss_esc(unsigned char *s, unsigned char *d, int len)
658 {
659         unsigned char *ptr = d;
660         unsigned char c;
661
662         /*
663          * Send an initial END character to flush out any
664          * data that may have accumulated in the receiver
665          * due to line noise.
666          */
667
668         *ptr++ = END;
669
670         while (len-- > 0) {
671                 switch (c = *s++) {
672                         case END:
673                                 *ptr++ = ESC;
674                                 *ptr++ = ESC_END;
675                                 break;
676                         case ESC:
677                                 *ptr++ = ESC;
678                                 *ptr++ = ESC_ESC;
679                                 break;
680                         default:
681                                 *ptr++ = c;
682                                 break;
683                 }
684         }
685
686         *ptr++ = END;
687
688         return ptr - d;
689 }
690
691 /*
692  * MW:
693  * OK its ugly, but tell me a better solution without copying the
694  * packet to a temporary buffer :-)
695  */
696 static int kiss_esc_crc(unsigned char *s, unsigned char *d, unsigned short crc, int len)
697 {
698         unsigned char *ptr = d;
699         unsigned char c=0;
700
701         *ptr++ = END;
702         while (len > 0) {
703                 if (len > 2) 
704                         c = *s++;
705                 else if (len > 1)
706                         c = crc >> 8;
707                 else if (len > 0)
708                         c = crc & 0xff;
709
710                 len--;
711
712                 switch (c) {
713                         case END:
714                                 *ptr++ = ESC;
715                                 *ptr++ = ESC_END;
716                                 break;
717                         case ESC:
718                                 *ptr++ = ESC;
719                                 *ptr++ = ESC_ESC;
720                                 break;
721                         default:
722                                 *ptr++ = c;
723                                 break;
724                 }
725         }
726         *ptr++ = END;
727         return ptr - d;         
728 }
729
730 static void kiss_unesc(struct ax_disp *ax, unsigned char s)
731 {
732         switch (s) {
733                 case END:
734                         /* drop keeptest bit = VSV */
735                         if (test_bit(AXF_KEEPTEST, &ax->flags))
736                                 clear_bit(AXF_KEEPTEST, &ax->flags);
737
738                         if (!test_and_clear_bit(AXF_ERROR, &ax->flags) && (ax->rcount > 2))
739                                 ax_bump(ax);
740
741                         clear_bit(AXF_ESCAPE, &ax->flags);
742                         ax->rcount = 0;
743                         return;
744
745                 case ESC:
746                         set_bit(AXF_ESCAPE, &ax->flags);
747                         return;
748                 case ESC_ESC:
749                         if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
750                                 s = ESC;
751                         break;
752                 case ESC_END:
753                         if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
754                                 s = END;
755                         break;
756         }
757
758         spin_lock_bh(&ax->buflock);
759         if (!test_bit(AXF_ERROR, &ax->flags)) {
760                 if (ax->rcount < ax->buffsize) {
761                         ax->rbuff[ax->rcount++] = s;
762                         spin_unlock_bh(&ax->buflock);
763                         return;
764                 }
765
766                 ax->rx_over_errors++;
767                 set_bit(AXF_ERROR, &ax->flags);
768         }
769         spin_unlock_bh(&ax->buflock);
770 }
771
772
773 static int ax_set_mac_address(struct net_device *dev, void __user *addr)
774 {
775         if (copy_from_user(dev->dev_addr, addr, AX25_ADDR_LEN))
776                 return -EFAULT;
777         return 0;
778 }
779
780 static int ax_set_dev_mac_address(struct net_device *dev, void *addr)
781 {
782         struct sockaddr *sa = addr;
783
784         memcpy(dev->dev_addr, sa->sa_data, AX25_ADDR_LEN);
785
786         return 0;
787 }
788
789
790 /* Perform I/O control on an active ax25 channel. */
791 static int ax25_disp_ioctl(struct tty_struct *tty, void *file, int cmd, void __user *arg)
792 {
793         struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
794         unsigned int tmp;
795
796         /* First make sure we're connected. */
797         if (ax == NULL || ax->magic != AX25_MAGIC)
798                 return -EINVAL;
799
800         switch (cmd) {
801                 case SIOCGIFNAME:
802                         if (copy_to_user(arg, ax->dev->name, strlen(ax->dev->name) + 1))
803                                 return -EFAULT;
804                         return 0;
805
806                 case SIOCGIFENCAP:
807                         return put_user(4, (int __user *)arg);
808
809                 case SIOCSIFENCAP:
810                         if (get_user(tmp, (int __user *)arg))
811                                 return -EFAULT;
812                         ax->mode = tmp;
813                         ax->dev->addr_len        = AX25_ADDR_LEN;         /* sizeof an AX.25 addr */
814                         ax->dev->hard_header_len = AX25_KISS_HEADER_LEN + AX25_MAX_HEADER_LEN + 3;
815                         ax->dev->type            = ARPHRD_AX25;
816                         return 0;
817
818                  case SIOCSIFHWADDR:
819                         return ax_set_mac_address(ax->dev, arg);
820
821                 default:
822                         return -ENOIOCTLCMD;
823         }
824 }
825
826 static int ax_open_dev(struct net_device *dev)
827 {
828         struct ax_disp *ax = netdev_priv(dev);
829
830         if (ax->tty == NULL)
831                 return -ENODEV;
832
833         return 0;
834 }
835
836
837 /* Initialize the driver.  Called by network startup. */
838 static int ax25_init(struct net_device *dev)
839 {
840         struct ax_disp *ax = netdev_priv(dev);
841
842         static char ax25_bcast[AX25_ADDR_LEN] =
843                 {'Q'<<1,'S'<<1,'T'<<1,' '<<1,' '<<1,' '<<1,'0'<<1};
844         static char ax25_test[AX25_ADDR_LEN] =
845                 {'L'<<1,'I'<<1,'N'<<1,'U'<<1,'X'<<1,' '<<1,'1'<<1};
846
847         if (ax == NULL)         /* Allocation failed ?? */
848                 return -ENODEV;
849
850         /* Set up the "AX25 Control Block". (And clear statistics) */
851         memset(ax, 0, sizeof (struct ax_disp));
852         ax->magic  = AX25_MAGIC;
853         ax->dev    = dev;
854
855         /* Finish setting up the DEVICE info. */
856         dev->mtu             = AX_MTU;
857         dev->hard_start_xmit = ax_xmit;
858         dev->open            = ax_open_dev;
859         dev->stop            = ax_close;
860         dev->get_stats       = ax_get_stats;
861         dev->set_mac_address = ax_set_dev_mac_address;
862         dev->hard_header_len = 0;
863         dev->addr_len        = 0;
864         dev->type            = ARPHRD_AX25;
865         dev->tx_queue_len    = 10;
866         dev->hard_header     = ax_header;
867         dev->rebuild_header  = ax_rebuild_header;
868
869         memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
870         memcpy(dev->dev_addr,  ax25_test,  AX25_ADDR_LEN);
871
872         /* New-style flags. */
873         dev->flags      = IFF_BROADCAST | IFF_MULTICAST;
874
875         return 0;
876 }
877
878
879 /* ******************************************************************** */
880 /* *                    Init MKISS driver                             * */
881 /* ******************************************************************** */
882
883 static int __init mkiss_init_driver(void)
884 {
885         int status;
886
887         printk(banner);
888
889         if (ax25_maxdev < 4)
890           ax25_maxdev = 4; /* Sanity */
891
892         if ((ax25_ctrls = kmalloc(sizeof(void *) * ax25_maxdev, GFP_KERNEL)) == NULL) {
893                 printk(KERN_ERR "mkiss: Can't allocate ax25_ctrls[] array!\n");
894                 return -ENOMEM;
895         }
896
897         /* Clear the pointer array, we allocate devices when we need them */
898         memset(ax25_ctrls, 0, sizeof(void*) * ax25_maxdev); /* Pointers */
899
900         /* Fill in our line protocol discipline, and register it */
901         ax_ldisc.magic          = TTY_LDISC_MAGIC;
902         ax_ldisc.name           = "mkiss";
903         ax_ldisc.open           = ax25_open;
904         ax_ldisc.close          = ax25_close;
905         ax_ldisc.ioctl          = (int (*)(struct tty_struct *, struct file *,
906                                         unsigned int, unsigned long))ax25_disp_ioctl;
907         ax_ldisc.receive_buf    = ax25_receive_buf;
908         ax_ldisc.receive_room   = ax25_receive_room;
909         ax_ldisc.write_wakeup   = ax25_write_wakeup;
910
911         if ((status = tty_register_ldisc(N_AX25, &ax_ldisc)) != 0) {
912                 printk(KERN_ERR "mkiss: can't register line discipline (err = %d)\n", status);
913                 kfree(ax25_ctrls);
914         }
915         return status;
916 }
917
918 static void __exit mkiss_exit_driver(void)
919 {
920         int i;
921
922         for (i = 0; i < ax25_maxdev; i++) {
923                 if (ax25_ctrls[i]) {
924                         /*
925                         * VSV = if dev->start==0, then device
926                         * unregistered while close proc.
927                         */
928                         if (netif_running(&ax25_ctrls[i]->dev))
929                                 unregister_netdev(&ax25_ctrls[i]->dev);
930                         kfree(ax25_ctrls[i]);
931                 }
932         }
933
934         kfree(ax25_ctrls);
935         ax25_ctrls = NULL;
936
937         if ((i = tty_register_ldisc(N_AX25, NULL)))
938                 printk(KERN_ERR "mkiss: can't unregister line discipline (err = %d)\n", i);
939 }
940
941 MODULE_AUTHOR("Hans Albas PE1AYX <hans@esrac.ele.tue.nl>");
942 MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs");
943 MODULE_PARM(ax25_maxdev, "i");
944 MODULE_PARM_DESC(ax25_maxdev, "number of MKISS devices");
945 MODULE_LICENSE("GPL");
946 MODULE_ALIAS_LDISC(N_AX25);
947 module_init(mkiss_init_driver);
948 module_exit(mkiss_exit_driver);
949