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