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