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