tty: make receive_buf() return the amout of bytes received
[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/slab.h>
30 #include <linux/tty.h>
31 #include <linux/errno.h>
32 #include <linux/netdevice.h>
33 #include <linux/major.h>
34 #include <linux/init.h>
35 #include <linux/rtnetlink.h>
36 #include <linux/etherdevice.h>
37 #include <linux/skbuff.h>
38 #include <linux/if_arp.h>
39 #include <linux/jiffies.h>
40 #include <linux/compat.h>
41
42 #include <net/ax25.h>
43
44 #define AX_MTU          236
45
46 /* SLIP/KISS protocol characters. */
47 #define END             0300            /* indicates end of frame       */
48 #define ESC             0333            /* indicates byte stuffing      */
49 #define ESC_END         0334            /* ESC ESC_END means END 'data' */
50 #define ESC_ESC         0335            /* ESC ESC_ESC means ESC 'data' */
51
52 struct mkiss {
53         struct tty_struct       *tty;   /* ptr to TTY structure         */
54         struct net_device       *dev;   /* easy for intr handling       */
55
56         /* These are pointers to the malloc()ed frame buffers. */
57         spinlock_t              buflock;/* lock for rbuf and xbuf */
58         unsigned char           *rbuff; /* receiver buffer              */
59         int                     rcount; /* received chars counter       */
60         unsigned char           *xbuff; /* transmitter buffer           */
61         unsigned char           *xhead; /* pointer to next byte to XMIT */
62         int                     xleft;  /* bytes left in XMIT queue     */
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->dev->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: Switching 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->dev->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: Switching 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->dev->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->stats.rx_packets++;
307         ax->dev->stats.rx_bytes += count;
308         spin_unlock_bh(&ax->buflock);
309 }
310
311 static void kiss_unesc(struct mkiss *ax, unsigned char s)
312 {
313         switch (s) {
314         case END:
315                 /* drop keeptest bit = VSV */
316                 if (test_bit(AXF_KEEPTEST, &ax->flags))
317                         clear_bit(AXF_KEEPTEST, &ax->flags);
318
319                 if (!test_and_clear_bit(AXF_ERROR, &ax->flags) && (ax->rcount > 2))
320                         ax_bump(ax);
321
322                 clear_bit(AXF_ESCAPE, &ax->flags);
323                 ax->rcount = 0;
324                 return;
325
326         case ESC:
327                 set_bit(AXF_ESCAPE, &ax->flags);
328                 return;
329         case ESC_ESC:
330                 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
331                         s = ESC;
332                 break;
333         case ESC_END:
334                 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
335                         s = END;
336                 break;
337         }
338
339         spin_lock_bh(&ax->buflock);
340         if (!test_bit(AXF_ERROR, &ax->flags)) {
341                 if (ax->rcount < ax->buffsize) {
342                         ax->rbuff[ax->rcount++] = s;
343                         spin_unlock_bh(&ax->buflock);
344                         return;
345                 }
346
347                 ax->dev->stats.rx_over_errors++;
348                 set_bit(AXF_ERROR, &ax->flags);
349         }
350         spin_unlock_bh(&ax->buflock);
351 }
352
353 static int ax_set_mac_address(struct net_device *dev, void *addr)
354 {
355         struct sockaddr_ax25 *sa = addr;
356
357         netif_tx_lock_bh(dev);
358         netif_addr_lock(dev);
359         memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN);
360         netif_addr_unlock(dev);
361         netif_tx_unlock_bh(dev);
362
363         return 0;
364 }
365
366 /*---------------------------------------------------------------------------*/
367
368 static void ax_changedmtu(struct mkiss *ax)
369 {
370         struct net_device *dev = ax->dev;
371         unsigned char *xbuff, *rbuff, *oxbuff, *orbuff;
372         int len;
373
374         len = dev->mtu * 2;
375
376         /*
377          * allow for arrival of larger UDP packets, even if we say not to
378          * also fixes a bug in which SunOS sends 512-byte packets even with
379          * an MSS of 128
380          */
381         if (len < 576 * 2)
382                 len = 576 * 2;
383
384         xbuff = kmalloc(len + 4, GFP_ATOMIC);
385         rbuff = kmalloc(len + 4, GFP_ATOMIC);
386
387         if (xbuff == NULL || rbuff == NULL)  {
388                 printk(KERN_ERR "mkiss: %s: unable to grow ax25 buffers, "
389                        "MTU change cancelled.\n",
390                        ax->dev->name);
391                 dev->mtu = ax->mtu;
392                 kfree(xbuff);
393                 kfree(rbuff);
394                 return;
395         }
396
397         spin_lock_bh(&ax->buflock);
398
399         oxbuff    = ax->xbuff;
400         ax->xbuff = xbuff;
401         orbuff    = ax->rbuff;
402         ax->rbuff = rbuff;
403
404         if (ax->xleft) {
405                 if (ax->xleft <= len) {
406                         memcpy(ax->xbuff, ax->xhead, ax->xleft);
407                 } else  {
408                         ax->xleft = 0;
409                         dev->stats.tx_dropped++;
410                 }
411         }
412
413         ax->xhead = ax->xbuff;
414
415         if (ax->rcount) {
416                 if (ax->rcount <= len) {
417                         memcpy(ax->rbuff, orbuff, ax->rcount);
418                 } else  {
419                         ax->rcount = 0;
420                         dev->stats.rx_over_errors++;
421                         set_bit(AXF_ERROR, &ax->flags);
422                 }
423         }
424
425         ax->mtu      = dev->mtu + 73;
426         ax->buffsize = len;
427
428         spin_unlock_bh(&ax->buflock);
429
430         kfree(oxbuff);
431         kfree(orbuff);
432 }
433
434 /* Encapsulate one AX.25 packet and stuff into a TTY queue. */
435 static void ax_encaps(struct net_device *dev, unsigned char *icp, int len)
436 {
437         struct mkiss *ax = netdev_priv(dev);
438         unsigned char *p;
439         int actual, count;
440
441         if (ax->mtu != ax->dev->mtu + 73)       /* Someone has been ifconfigging */
442                 ax_changedmtu(ax);
443
444         if (len > ax->mtu) {            /* Sigh, shouldn't occur BUT ... */
445                 len = ax->mtu;
446                 printk(KERN_ERR "mkiss: %s: truncating oversized transmit packet!\n", ax->dev->name);
447                 dev->stats.tx_dropped++;
448                 netif_start_queue(dev);
449                 return;
450         }
451
452         p = icp;
453
454         spin_lock_bh(&ax->buflock);
455         if ((*p & 0x0f) != 0) {
456                 /* Configuration Command (kissparms(1).
457                  * Protocol spec says: never append CRC.
458                  * This fixes a very old bug in the linux
459                  * kiss driver. -- dl9sau */
460                 switch (*p & 0xff) {
461                 case 0x85:
462                         /* command from userspace especially for us,
463                          * not for delivery to the tnc */
464                         if (len > 1) {
465                                 int cmd = (p[1] & 0xff);
466                                 switch(cmd) {
467                                 case 3:
468                                   ax->crcmode = CRC_MODE_SMACK;
469                                   break;
470                                 case 2:
471                                   ax->crcmode = CRC_MODE_FLEX;
472                                   break;
473                                 case 1:
474                                   ax->crcmode = CRC_MODE_NONE;
475                                   break;
476                                 case 0:
477                                 default:
478                                   ax->crcmode = CRC_MODE_SMACK_TEST;
479                                   cmd = 0;
480                                 }
481                                 ax->crcauto = (cmd ? 0 : 1);
482                                 printk(KERN_INFO "mkiss: %s: crc mode %s %d\n", ax->dev->name, (len) ? "set to" : "is", cmd);
483                         }
484                         spin_unlock_bh(&ax->buflock);
485                         netif_start_queue(dev);
486
487                         return;
488                 default:
489                         count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
490                 }
491         } else {
492                 unsigned short crc;
493                 switch (ax->crcmode) {
494                 case CRC_MODE_SMACK_TEST:
495                         ax->crcmode  = CRC_MODE_FLEX_TEST;
496                         printk(KERN_INFO "mkiss: %s: Trying crc-smack\n", ax->dev->name);
497                         // fall through
498                 case CRC_MODE_SMACK:
499                         *p |= 0x80;
500                         crc = swab16(crc16(0, p, len));
501                         count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
502                         break;
503                 case CRC_MODE_FLEX_TEST:
504                         ax->crcmode = CRC_MODE_NONE;
505                         printk(KERN_INFO "mkiss: %s: Trying crc-flexnet\n", ax->dev->name);
506                         // fall through
507                 case CRC_MODE_FLEX:
508                         *p |= 0x20;
509                         crc = calc_crc_flex(p, len);
510                         count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
511                         break;
512
513                 default:
514                         count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
515                 }
516         }
517         spin_unlock_bh(&ax->buflock);
518
519         set_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
520         actual = ax->tty->ops->write(ax->tty, ax->xbuff, count);
521         dev->stats.tx_packets++;
522         dev->stats.tx_bytes += actual;
523
524         ax->dev->trans_start = jiffies;
525         ax->xleft = count - actual;
526         ax->xhead = ax->xbuff + actual;
527 }
528
529 /* Encapsulate an AX.25 packet and kick it into a TTY queue. */
530 static netdev_tx_t ax_xmit(struct sk_buff *skb, struct net_device *dev)
531 {
532         struct mkiss *ax = netdev_priv(dev);
533
534         if (!netif_running(dev))  {
535                 printk(KERN_ERR "mkiss: %s: xmit call when iface is down\n", dev->name);
536                 return NETDEV_TX_BUSY;
537         }
538
539         if (netif_queue_stopped(dev)) {
540                 /*
541                  * May be we must check transmitter timeout here ?
542                  *      14 Oct 1994 Dmitry Gorodchanin.
543                  */
544                 if (time_before(jiffies, dev->trans_start + 20 * HZ)) {
545                         /* 20 sec timeout not reached */
546                         return NETDEV_TX_BUSY;
547                 }
548
549                 printk(KERN_ERR "mkiss: %s: transmit timed out, %s?\n", dev->name,
550                        (tty_chars_in_buffer(ax->tty) || ax->xleft) ?
551                        "bad line quality" : "driver error");
552
553                 ax->xleft = 0;
554                 clear_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
555                 netif_start_queue(dev);
556         }
557
558         /* We were not busy, so we are now... :-) */
559         if (skb != NULL) {
560                 netif_stop_queue(dev);
561                 ax_encaps(dev, skb->data, skb->len);
562                 kfree_skb(skb);
563         }
564
565         return NETDEV_TX_OK;
566 }
567
568 static int ax_open_dev(struct net_device *dev)
569 {
570         struct mkiss *ax = netdev_priv(dev);
571
572         if (ax->tty == NULL)
573                 return -ENODEV;
574
575         return 0;
576 }
577
578 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
579
580 /* Return the frame type ID */
581 static int ax_header(struct sk_buff *skb, struct net_device *dev,
582                      unsigned short type, const void *daddr,
583                      const void *saddr, unsigned len)
584 {
585 #ifdef CONFIG_INET
586         if (type != ETH_P_AX25)
587                 return ax25_hard_header(skb, dev, type, daddr, saddr, len);
588 #endif
589         return 0;
590 }
591
592
593 static int ax_rebuild_header(struct sk_buff *skb)
594 {
595 #ifdef CONFIG_INET
596         return ax25_rebuild_header(skb);
597 #else
598         return 0;
599 #endif
600 }
601
602 #endif  /* CONFIG_{AX25,AX25_MODULE} */
603
604 /* Open the low-level part of the AX25 channel. Easy! */
605 static int ax_open(struct net_device *dev)
606 {
607         struct mkiss *ax = netdev_priv(dev);
608         unsigned long len;
609
610         if (ax->tty == NULL)
611                 return -ENODEV;
612
613         /*
614          * Allocate the frame buffers:
615          *
616          * rbuff        Receive buffer.
617          * xbuff        Transmit buffer.
618          */
619         len = dev->mtu * 2;
620
621         /*
622          * allow for arrival of larger UDP packets, even if we say not to
623          * also fixes a bug in which SunOS sends 512-byte packets even with
624          * an MSS of 128
625          */
626         if (len < 576 * 2)
627                 len = 576 * 2;
628
629         if ((ax->rbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
630                 goto norbuff;
631
632         if ((ax->xbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
633                 goto noxbuff;
634
635         ax->mtu      = dev->mtu + 73;
636         ax->buffsize = len;
637         ax->rcount   = 0;
638         ax->xleft    = 0;
639
640         ax->flags   &= (1 << AXF_INUSE);      /* Clear ESCAPE & ERROR flags */
641
642         spin_lock_init(&ax->buflock);
643
644         return 0;
645
646 noxbuff:
647         kfree(ax->rbuff);
648
649 norbuff:
650         return -ENOMEM;
651 }
652
653
654 /* Close the low-level part of the AX25 channel. Easy! */
655 static int ax_close(struct net_device *dev)
656 {
657         struct mkiss *ax = netdev_priv(dev);
658
659         if (ax->tty)
660                 clear_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
661
662         netif_stop_queue(dev);
663
664         return 0;
665 }
666
667 static const struct header_ops ax_header_ops = {
668         .create    = ax_header,
669         .rebuild   = ax_rebuild_header,
670 };
671
672 static const struct net_device_ops ax_netdev_ops = {
673         .ndo_open            = ax_open_dev,
674         .ndo_stop            = ax_close,
675         .ndo_start_xmit      = ax_xmit,
676         .ndo_set_mac_address = ax_set_mac_address,
677 };
678
679 static void ax_setup(struct net_device *dev)
680 {
681         /* Finish setting up the DEVICE info. */
682         dev->mtu             = AX_MTU;
683         dev->hard_header_len = 0;
684         dev->addr_len        = 0;
685         dev->type            = ARPHRD_AX25;
686         dev->tx_queue_len    = 10;
687         dev->header_ops      = &ax_header_ops;
688         dev->netdev_ops      = &ax_netdev_ops;
689
690
691         memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
692         memcpy(dev->dev_addr,  &ax25_defaddr,  AX25_ADDR_LEN);
693
694         dev->flags      = IFF_BROADCAST | IFF_MULTICAST;
695 }
696
697 /*
698  * We have a potential race on dereferencing tty->disc_data, because the tty
699  * layer provides no locking at all - thus one cpu could be running
700  * sixpack_receive_buf while another calls sixpack_close, which zeroes
701  * tty->disc_data and frees the memory that sixpack_receive_buf is using.  The
702  * best way to fix this is to use a rwlock in the tty struct, but for now we
703  * use a single global rwlock for all ttys in ppp line discipline.
704  */
705 static DEFINE_RWLOCK(disc_data_lock);
706
707 static struct mkiss *mkiss_get(struct tty_struct *tty)
708 {
709         struct mkiss *ax;
710
711         read_lock(&disc_data_lock);
712         ax = tty->disc_data;
713         if (ax)
714                 atomic_inc(&ax->refcnt);
715         read_unlock(&disc_data_lock);
716
717         return ax;
718 }
719
720 static void mkiss_put(struct mkiss *ax)
721 {
722         if (atomic_dec_and_test(&ax->refcnt))
723                 up(&ax->dead_sem);
724 }
725
726 static int crc_force = 0;       /* Can be overridden with insmod */
727
728 static int mkiss_open(struct tty_struct *tty)
729 {
730         struct net_device *dev;
731         struct mkiss *ax;
732         int err;
733
734         if (!capable(CAP_NET_ADMIN))
735                 return -EPERM;
736         if (tty->ops->write == NULL)
737                 return -EOPNOTSUPP;
738
739         dev = alloc_netdev(sizeof(struct mkiss), "ax%d", ax_setup);
740         if (!dev) {
741                 err = -ENOMEM;
742                 goto out;
743         }
744
745         ax = netdev_priv(dev);
746         ax->dev = dev;
747
748         spin_lock_init(&ax->buflock);
749         atomic_set(&ax->refcnt, 1);
750         sema_init(&ax->dead_sem, 0);
751
752         ax->tty = tty;
753         tty->disc_data = ax;
754         tty->receive_room = 65535;
755
756         tty_driver_flush_buffer(tty);
757
758         /* Restore default settings */
759         dev->type = ARPHRD_AX25;
760
761         /* Perform the low-level AX25 initialization. */
762         if ((err = ax_open(ax->dev))) {
763                 goto out_free_netdev;
764         }
765
766         if (register_netdev(dev))
767                 goto out_free_buffers;
768
769         /* after register_netdev() - because else printk smashes the kernel */
770         switch (crc_force) {
771         case 3:
772                 ax->crcmode  = CRC_MODE_SMACK;
773                 printk(KERN_INFO "mkiss: %s: crc mode smack forced.\n",
774                        ax->dev->name);
775                 break;
776         case 2:
777                 ax->crcmode  = CRC_MODE_FLEX;
778                 printk(KERN_INFO "mkiss: %s: crc mode flexnet forced.\n",
779                        ax->dev->name);
780                 break;
781         case 1:
782                 ax->crcmode  = CRC_MODE_NONE;
783                 printk(KERN_INFO "mkiss: %s: crc mode disabled.\n",
784                        ax->dev->name);
785                 break;
786         case 0:
787                 /* fall through */
788         default:
789                 crc_force = 0;
790                 printk(KERN_INFO "mkiss: %s: crc mode is auto.\n",
791                        ax->dev->name);
792                 ax->crcmode  = CRC_MODE_SMACK_TEST;
793         }
794         ax->crcauto = (crc_force ? 0 : 1);
795
796         netif_start_queue(dev);
797
798         /* Done.  We have linked the TTY line to a channel. */
799         return 0;
800
801 out_free_buffers:
802         kfree(ax->rbuff);
803         kfree(ax->xbuff);
804
805 out_free_netdev:
806         free_netdev(dev);
807
808 out:
809         return err;
810 }
811
812 static void mkiss_close(struct tty_struct *tty)
813 {
814         struct mkiss *ax;
815
816         write_lock(&disc_data_lock);
817         ax = tty->disc_data;
818         tty->disc_data = NULL;
819         write_unlock(&disc_data_lock);
820
821         if (!ax)
822                 return;
823
824         /*
825          * We have now ensured that nobody can start using ap from now on, but
826          * we have to wait for all existing users to finish.
827          */
828         if (!atomic_dec_and_test(&ax->refcnt))
829                 down(&ax->dead_sem);
830
831         unregister_netdev(ax->dev);
832
833         /* Free all AX25 frame buffers. */
834         kfree(ax->rbuff);
835         kfree(ax->xbuff);
836
837         ax->tty = NULL;
838 }
839
840 /* Perform I/O control on an active ax25 channel. */
841 static int mkiss_ioctl(struct tty_struct *tty, struct file *file,
842         unsigned int cmd, unsigned long arg)
843 {
844         struct mkiss *ax = mkiss_get(tty);
845         struct net_device *dev;
846         unsigned int tmp, err;
847
848         /* First make sure we're connected. */
849         if (ax == NULL)
850                 return -ENXIO;
851         dev = ax->dev;
852
853         switch (cmd) {
854         case SIOCGIFNAME:
855                 err = copy_to_user((void __user *) arg, ax->dev->name,
856                                    strlen(ax->dev->name) + 1) ? -EFAULT : 0;
857                 break;
858
859         case SIOCGIFENCAP:
860                 err = put_user(4, (int __user *) arg);
861                 break;
862
863         case SIOCSIFENCAP:
864                 if (get_user(tmp, (int __user *) arg)) {
865                         err = -EFAULT;
866                         break;
867                 }
868
869                 ax->mode = tmp;
870                 dev->addr_len        = AX25_ADDR_LEN;
871                 dev->hard_header_len = AX25_KISS_HEADER_LEN +
872                                        AX25_MAX_HEADER_LEN + 3;
873                 dev->type            = ARPHRD_AX25;
874
875                 err = 0;
876                 break;
877
878         case SIOCSIFHWADDR: {
879                 char addr[AX25_ADDR_LEN];
880
881                 if (copy_from_user(&addr,
882                                    (void __user *) arg, AX25_ADDR_LEN)) {
883                         err = -EFAULT;
884                         break;
885                 }
886
887                 netif_tx_lock_bh(dev);
888                 memcpy(dev->dev_addr, addr, AX25_ADDR_LEN);
889                 netif_tx_unlock_bh(dev);
890
891                 err = 0;
892                 break;
893         }
894         default:
895                 err = -ENOIOCTLCMD;
896         }
897
898         mkiss_put(ax);
899
900         return err;
901 }
902
903 #ifdef CONFIG_COMPAT
904 static long mkiss_compat_ioctl(struct tty_struct *tty, struct file *file,
905         unsigned int cmd, unsigned long arg)
906 {
907         switch (cmd) {
908         case SIOCGIFNAME:
909         case SIOCGIFENCAP:
910         case SIOCSIFENCAP:
911         case SIOCSIFHWADDR:
912                 return mkiss_ioctl(tty, file, cmd,
913                                    (unsigned long)compat_ptr(arg));
914         }
915
916         return -ENOIOCTLCMD;
917 }
918 #endif
919
920 /*
921  * Handle the 'receiver data ready' interrupt.
922  * This function is called by the 'tty_io' module in the kernel when
923  * a block of data has been received, which can now be decapsulated
924  * and sent on to the AX.25 layer for further processing.
925  */
926 static unsigned int mkiss_receive_buf(struct tty_struct *tty,
927                 const unsigned char *cp, char *fp, int count)
928 {
929         struct mkiss *ax = mkiss_get(tty);
930         int bytes = count;
931
932         if (!ax)
933                 return -ENODEV;
934
935         /*
936          * Argh! mtu change time! - costs us the packet part received
937          * at the change
938          */
939         if (ax->mtu != ax->dev->mtu + 73)
940                 ax_changedmtu(ax);
941
942         /* Read the characters out of the buffer */
943         while (bytes--) {
944                 if (fp != NULL && *fp++) {
945                         if (!test_and_set_bit(AXF_ERROR, &ax->flags))
946                                 ax->dev->stats.rx_errors++;
947                         cp++;
948                         continue;
949                 }
950
951                 kiss_unesc(ax, *cp++);
952         }
953
954         mkiss_put(ax);
955         tty_unthrottle(tty);
956
957         return count;
958 }
959
960 /*
961  * Called by the driver when there's room for more data.  If we have
962  * more packets to send, we send them here.
963  */
964 static void mkiss_write_wakeup(struct tty_struct *tty)
965 {
966         struct mkiss *ax = mkiss_get(tty);
967         int actual;
968
969         if (!ax)
970                 return;
971
972         if (ax->xleft <= 0)  {
973                 /* Now serial buffer is almost free & we can start
974                  * transmission of another packet
975                  */
976                 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
977
978                 netif_wake_queue(ax->dev);
979                 goto out;
980         }
981
982         actual = tty->ops->write(tty, ax->xhead, ax->xleft);
983         ax->xleft -= actual;
984         ax->xhead += actual;
985
986 out:
987         mkiss_put(ax);
988 }
989
990 static struct tty_ldisc_ops ax_ldisc = {
991         .owner          = THIS_MODULE,
992         .magic          = TTY_LDISC_MAGIC,
993         .name           = "mkiss",
994         .open           = mkiss_open,
995         .close          = mkiss_close,
996         .ioctl          = mkiss_ioctl,
997 #ifdef CONFIG_COMPAT
998         .compat_ioctl   = mkiss_compat_ioctl,
999 #endif
1000         .receive_buf    = mkiss_receive_buf,
1001         .write_wakeup   = mkiss_write_wakeup
1002 };
1003
1004 static const char banner[] __initdata = KERN_INFO \
1005         "mkiss: AX.25 Multikiss, Hans Albas PE1AYX\n";
1006 static const char msg_regfail[] __initdata = KERN_ERR \
1007         "mkiss: can't register line discipline (err = %d)\n";
1008
1009 static int __init mkiss_init_driver(void)
1010 {
1011         int status;
1012
1013         printk(banner);
1014
1015         status = tty_register_ldisc(N_AX25, &ax_ldisc);
1016         if (status != 0)
1017                 printk(msg_regfail, status);
1018
1019         return status;
1020 }
1021
1022 static const char msg_unregfail[] __exitdata = KERN_ERR \
1023         "mkiss: can't unregister line discipline (err = %d)\n";
1024
1025 static void __exit mkiss_exit_driver(void)
1026 {
1027         int ret;
1028
1029         if ((ret = tty_unregister_ldisc(N_AX25)))
1030                 printk(msg_unregfail, ret);
1031 }
1032
1033 MODULE_AUTHOR("Ralf Baechle DL5RB <ralf@linux-mips.org>");
1034 MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs");
1035 module_param(crc_force, int, 0);
1036 MODULE_PARM_DESC(crc_force, "crc [0 = auto | 1 = none | 2 = flexnet | 3 = smack]");
1037 MODULE_LICENSE("GPL");
1038 MODULE_ALIAS_LDISC(N_AX25);
1039
1040 module_init(mkiss_init_driver);
1041 module_exit(mkiss_exit_driver);