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