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