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