1 /*
2 * MKISS Driver
3 *
4 * This module:
5 * This module is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version
8 * 2 of the License, or (at your option) any later version.
9 *
10 * This module implements the AX.25 protocol for kernel-based
11 * devices like TTYs. It interfaces between a raw TTY, and the
12 * kernel's AX.25 protocol layers, just like slip.c.
13 * AX.25 needs to be separated from slip.c while slip.c is no
14 * longer a static kernel device since it is a module.
15 * This method clears the way to implement other kiss protocols
16 * like mkiss smack g8bpq ..... so far only mkiss is implemented.
17 *
18 * Hans Alblas <hans@esrac.ele.tue.nl>
19 *
20 * History
21 * Jonathan (G4KLX) Fixed to match Linux networking changes - 2.1.15.
22 * Matthias (DG2FEF) Added support for FlexNet CRC (on special request)
23 * Fixed bug in ax25_close(): dev_lock_wait() was
24 * called twice, causing a deadlock.
25 */
26
27 #include <linux/config.h>
28 #include <linux/module.h>
29 #include <asm/system.h>
30 #include <asm/segment.h>
31 #include <asm/bitops.h>
32 #include <asm/uaccess.h>
33 #include <linux/string.h>
34 #include <linux/mm.h>
35 #include <linux/interrupt.h>
36 #include <linux/in.h>
37 #include <linux/inet.h>
38 #include <linux/tty.h>
39 #include <linux/errno.h>
40 #include <linux/netdevice.h>
41 #include <linux/major.h>
42 #include <linux/init.h>
43 #include <linux/rtnetlink.h>
44 #include <linux/etherdevice.h>
45 #include <linux/skbuff.h>
46 #include <linux/if_arp.h>
47
48 #include <net/ax25.h>
49
50 #include "mkiss.h"
51
52 #ifdef CONFIG_INET
53 #include <linux/ip.h>
54 #include <linux/tcp.h>
55 #endif
56
57 static char banner[] __initdata = KERN_INFO "mkiss: AX.25 Multikiss, Hans Albas PE1AYX\n";
58
59 #define NR_MKISS 4
60 #define MKISS_SERIAL_TYPE_NORMAL 1
61
62 struct mkiss_channel {
63 int magic; /* magic word */
64 int init; /* channel exists? */
65 struct tty_struct *tty; /* link to tty control structure */
66 };
67
68 typedef struct ax25_ctrl {
69 struct ax_disp ctrl; /* */
70 struct net_device dev; /* the device */
71 } ax25_ctrl_t;
72
73 static ax25_ctrl_t **ax25_ctrls;
74
75 int ax25_maxdev = AX25_MAXDEV; /* Can be overridden with insmod! */
76
77 static struct tty_ldisc ax_ldisc;
78
79 static int ax25_init(struct net_device *);
80 static int kiss_esc(unsigned char *, unsigned char *, int);
81 static int kiss_esc_crc(unsigned char *, unsigned char *, unsigned short, int);
82 static void kiss_unesc(struct ax_disp *, unsigned char);
83
84 /*---------------------------------------------------------------------------*/
85
86 static const unsigned short Crc_flex_table[] = {
87 0x0f87, 0x1e0e, 0x2c95, 0x3d1c, 0x49a3, 0x582a, 0x6ab1, 0x7b38,
88 0x83cf, 0x9246, 0xa0dd, 0xb154, 0xc5eb, 0xd462, 0xe6f9, 0xf770,
89 0x1f06, 0x0e8f, 0x3c14, 0x2d9d, 0x5922, 0x48ab, 0x7a30, 0x6bb9,
90 0x934e, 0x82c7, 0xb05c, 0xa1d5, 0xd56a, 0xc4e3, 0xf678, 0xe7f1,
91 0x2e85, 0x3f0c, 0x0d97, 0x1c1e, 0x68a1, 0x7928, 0x4bb3, 0x5a3a,
92 0xa2cd, 0xb344, 0x81df, 0x9056, 0xe4e9, 0xf560, 0xc7fb, 0xd672,
93 0x3e04, 0x2f8d, 0x1d16, 0x0c9f, 0x7820, 0x69a9, 0x5b32, 0x4abb,
94 0xb24c, 0xa3c5, 0x915e, 0x80d7, 0xf468, 0xe5e1, 0xd77a, 0xc6f3,
95 0x4d83, 0x5c0a, 0x6e91, 0x7f18, 0x0ba7, 0x1a2e, 0x28b5, 0x393c,
96 0xc1cb, 0xd042, 0xe2d9, 0xf350, 0x87ef, 0x9666, 0xa4fd, 0xb574,
97 0x5d02, 0x4c8b, 0x7e10, 0x6f99, 0x1b26, 0x0aaf, 0x3834, 0x29bd,
98 0xd14a, 0xc0c3, 0xf258, 0xe3d1, 0x976e, 0x86e7, 0xb47c, 0xa5f5,
99 0x6c81, 0x7d08, 0x4f93, 0x5e1a, 0x2aa5, 0x3b2c, 0x09b7, 0x183e,
100 0xe0c9, 0xf140, 0xc3db, 0xd252, 0xa6ed, 0xb764, 0x85ff, 0x9476,
101 0x7c00, 0x6d89, 0x5f12, 0x4e9b, 0x3a24, 0x2bad, 0x1936, 0x08bf,
102 0xf048, 0xe1c1, 0xd35a, 0xc2d3, 0xb66c, 0xa7e5, 0x957e, 0x84f7,
103 0x8b8f, 0x9a06, 0xa89d, 0xb914, 0xcdab, 0xdc22, 0xeeb9, 0xff30,
104 0x07c7, 0x164e, 0x24d5, 0x355c, 0x41e3, 0x506a, 0x62f1, 0x7378,
105 0x9b0e, 0x8a87, 0xb81c, 0xa995, 0xdd2a, 0xcca3, 0xfe38, 0xefb1,
106 0x1746, 0x06cf, 0x3454, 0x25dd, 0x5162, 0x40eb, 0x7270, 0x63f9,
107 0xaa8d, 0xbb04, 0x899f, 0x9816, 0xeca9, 0xfd20, 0xcfbb, 0xde32,
108 0x26c5, 0x374c, 0x05d7, 0x145e, 0x60e1, 0x7168, 0x43f3, 0x527a,
109 0xba0c, 0xab85, 0x991e, 0x8897, 0xfc28, 0xeda1, 0xdf3a, 0xceb3,
110 0x3644, 0x27cd, 0x1556, 0x04df, 0x7060, 0x61e9, 0x5372, 0x42fb,
111 0xc98b, 0xd802, 0xea99, 0xfb10, 0x8faf, 0x9e26, 0xacbd, 0xbd34,
112 0x45c3, 0x544a, 0x66d1, 0x7758, 0x03e7, 0x126e, 0x20f5, 0x317c,
113 0xd90a, 0xc883, 0xfa18, 0xeb91, 0x9f2e, 0x8ea7, 0xbc3c, 0xadb5,
114 0x5542, 0x44cb, 0x7650, 0x67d9, 0x1366, 0x02ef, 0x3074, 0x21fd,
115 0xe889, 0xf900, 0xcb9b, 0xda12, 0xaead, 0xbf24, 0x8dbf, 0x9c36,
116 0x64c1, 0x7548, 0x47d3, 0x565a, 0x22e5, 0x336c, 0x01f7, 0x107e,
117 0xf808, 0xe981, 0xdb1a, 0xca93, 0xbe2c, 0xafa5, 0x9d3e, 0x8cb7,
118 0x7440, 0x65c9, 0x5752, 0x46db, 0x3264, 0x23ed, 0x1176, 0x00ff
119 };
120
121 /*---------------------------------------------------------------------------*/
122
calc_crc_flex(unsigned char * cp,int size)123 static unsigned short calc_crc_flex(unsigned char *cp, int size)
124 {
125 unsigned short crc = 0xffff;
126
127 while (size--)
128 crc = (crc << 8) ^ Crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
129
130 return crc;
131 }
132
133 /*---------------------------------------------------------------------------*/
134
check_crc_flex(unsigned char * cp,int size)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 /*---------------------------------------------------------------------------*/
152
153 /* Find a free channel, and link in this `tty' line. */
ax_alloc(void)154 static inline struct ax_disp *ax_alloc(void)
155 {
156 ax25_ctrl_t *axp=NULL;
157 int i;
158
159 for (i = 0; i < ax25_maxdev; i++) {
160 axp = ax25_ctrls[i];
161
162 /* Not allocated ? */
163 if (axp == NULL)
164 break;
165
166 /* Not in use ? */
167 if (!test_and_set_bit(AXF_INUSE, &axp->ctrl.flags))
168 break;
169 }
170
171 /* Sorry, too many, all slots in use */
172 if (i >= ax25_maxdev)
173 return NULL;
174
175 /* If no channels are available, allocate one */
176 if (axp == NULL && (ax25_ctrls[i] = kmalloc(sizeof(ax25_ctrl_t), GFP_KERNEL)) != NULL) {
177 axp = ax25_ctrls[i];
178 memset(axp, 0, sizeof(ax25_ctrl_t));
179
180 /* Initialize channel control data */
181 set_bit(AXF_INUSE, &axp->ctrl.flags);
182 sprintf(axp->dev.name, "ax%d", i++);
183 axp->ctrl.tty = NULL;
184 axp->dev.base_addr = i;
185 axp->dev.priv = (void *)&axp->ctrl;
186 axp->dev.next = NULL;
187 axp->dev.init = ax25_init;
188 }
189
190 if (axp != NULL) {
191 /*
192 * register device so that it can be ifconfig'ed
193 * ax25_init() will be called as a side-effect
194 * SIDE-EFFECT WARNING: ax25_init() CLEARS axp->ctrl !
195 */
196 if (register_netdev(&axp->dev) == 0) {
197 /* (Re-)Set the INUSE bit. Very Important! */
198 set_bit(AXF_INUSE, &axp->ctrl.flags);
199 axp->ctrl.dev = &axp->dev;
200 axp->dev.priv = (void *) &axp->ctrl;
201
202 return &axp->ctrl;
203 } else {
204 clear_bit(AXF_INUSE,&axp->ctrl.flags);
205 printk(KERN_ERR "mkiss: ax_alloc() - register_netdev() failure.\n");
206 }
207 }
208
209 return NULL;
210 }
211
212 /* Free an AX25 channel. */
ax_free(struct ax_disp * ax)213 static inline void ax_free(struct ax_disp *ax)
214 {
215 /* Free all AX25 frame buffers. */
216 if (ax->rbuff)
217 kfree(ax->rbuff);
218 ax->rbuff = NULL;
219 if (ax->xbuff)
220 kfree(ax->xbuff);
221 ax->xbuff = NULL;
222 if (!test_and_clear_bit(AXF_INUSE, &ax->flags))
223 printk(KERN_ERR "mkiss: %s: ax_free for already free unit.\n", ax->dev->name);
224 }
225
ax_changedmtu(struct ax_disp * ax)226 static void ax_changedmtu(struct ax_disp *ax)
227 {
228 struct net_device *dev = ax->dev;
229 unsigned char *xbuff, *rbuff, *oxbuff, *orbuff;
230 int len;
231 unsigned long flags;
232
233 len = dev->mtu * 2;
234
235 /*
236 * allow for arrival of larger UDP packets, even if we say not to
237 * also fixes a bug in which SunOS sends 512-byte packets even with
238 * an MSS of 128
239 */
240 if (len < 576 * 2)
241 len = 576 * 2;
242
243 xbuff = kmalloc(len + 4, GFP_ATOMIC);
244 rbuff = kmalloc(len + 4, GFP_ATOMIC);
245
246 if (xbuff == NULL || rbuff == NULL) {
247 printk(KERN_ERR "mkiss: %s: unable to grow ax25 buffers, MTU change cancelled.\n",
248 ax->dev->name);
249 dev->mtu = ax->mtu;
250 if (xbuff != NULL)
251 kfree(xbuff);
252 if (rbuff != NULL)
253 kfree(rbuff);
254 return;
255 }
256
257 save_flags(flags);
258 cli();
259
260 oxbuff = ax->xbuff;
261 ax->xbuff = xbuff;
262 orbuff = ax->rbuff;
263 ax->rbuff = rbuff;
264
265 if (ax->xleft) {
266 if (ax->xleft <= len) {
267 memcpy(ax->xbuff, ax->xhead, ax->xleft);
268 } else {
269 ax->xleft = 0;
270 ax->tx_dropped++;
271 }
272 }
273
274 ax->xhead = ax->xbuff;
275
276 if (ax->rcount) {
277 if (ax->rcount <= len) {
278 memcpy(ax->rbuff, orbuff, ax->rcount);
279 } else {
280 ax->rcount = 0;
281 ax->rx_over_errors++;
282 set_bit(AXF_ERROR, &ax->flags);
283 }
284 }
285
286 ax->mtu = dev->mtu + 73;
287 ax->buffsize = len;
288
289 restore_flags(flags);
290
291 if (oxbuff != NULL)
292 kfree(oxbuff);
293 if (orbuff != NULL)
294 kfree(orbuff);
295 }
296
297
298 /* Set the "sending" flag. This must be atomic. */
ax_lock(struct ax_disp * ax)299 static inline void ax_lock(struct ax_disp *ax)
300 {
301 netif_stop_queue(ax->dev);
302 }
303
304
305 /* Clear the "sending" flag. This must be atomic. */
ax_unlock(struct ax_disp * ax)306 static inline void ax_unlock(struct ax_disp *ax)
307 {
308 netif_start_queue(ax->dev);
309 }
310
311 /* Send one completely decapsulated AX.25 packet to the AX.25 layer. */
ax_bump(struct ax_disp * ax)312 static void ax_bump(struct ax_disp *ax)
313 {
314 struct ax_disp *tmp_ax;
315 struct sk_buff *skb;
316 struct mkiss_channel *mkiss;
317 int count;
318
319 tmp_ax = ax;
320
321 if (ax->rbuff[0] > 0x0f) {
322 if (ax->mkiss != NULL) {
323 mkiss= ax->mkiss->tty->driver_data;
324 if (mkiss->magic == MKISS_DRIVER_MAGIC)
325 tmp_ax = ax->mkiss;
326 } else if (ax->rbuff[0] & 0x20) {
327 ax->crcmode = CRC_MODE_FLEX;
328 if (check_crc_flex(ax->rbuff, ax->rcount) < 0) {
329 ax->rx_errors++;
330 return;
331 }
332 ax->rcount -= 2;
333 /* dl9sau bugfix: the trailling two bytes flexnet crc
334 * will not be passed to the kernel. thus we have
335 * to correct the kissparm signature, because it
336 * indicates a crc but there's none
337 */
338 *ax->rbuff &= ~0x20;
339 }
340 }
341
342 count = ax->rcount;
343
344 if ((skb = dev_alloc_skb(count)) == NULL) {
345 printk(KERN_ERR "mkiss: %s: memory squeeze, dropping packet.\n", ax->dev->name);
346 ax->rx_dropped++;
347 return;
348 }
349
350 skb->dev = tmp_ax->dev;
351 memcpy(skb_put(skb,count), ax->rbuff, count);
352 skb->mac.raw = skb->data;
353 skb->protocol = htons(ETH_P_AX25);
354 netif_rx(skb);
355 tmp_ax->rx_packets++;
356 tmp_ax->rx_bytes+=count;
357 }
358
359 /* Encapsulate one AX.25 packet and stuff into a TTY queue. */
ax_encaps(struct ax_disp * ax,unsigned char * icp,int len)360 static void ax_encaps(struct ax_disp *ax, unsigned char *icp, int len)
361 {
362 unsigned char *p;
363 int actual, count;
364 struct mkiss_channel *mkiss = ax->tty->driver_data;
365
366 if (ax->mtu != ax->dev->mtu + 73) /* Someone has been ifconfigging */
367 ax_changedmtu(ax);
368
369 if (len > ax->mtu) { /* Sigh, shouldn't occur BUT ... */
370 len = ax->mtu;
371 printk(KERN_ERR "mkiss: %s: truncating oversized transmit packet!\n", ax->dev->name);
372 ax->tx_dropped++;
373 ax_unlock(ax);
374 return;
375 }
376
377 p = icp;
378
379 if (mkiss->magic != MKISS_DRIVER_MAGIC) {
380 switch (ax->crcmode) {
381 unsigned short crc;
382
383 case CRC_MODE_FLEX:
384 *p |= 0x20;
385 crc = calc_crc_flex(p, len);
386 count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
387 break;
388
389 default:
390 count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
391 break;
392 }
393 ax->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
394 actual = ax->tty->driver.write(ax->tty, 0, ax->xbuff, count);
395 ax->tx_packets++;
396 ax->tx_bytes+=actual;
397 ax->dev->trans_start = jiffies;
398 ax->xleft = count - actual;
399 ax->xhead = ax->xbuff + actual;
400 } else {
401 count = kiss_esc(p, (unsigned char *) ax->mkiss->xbuff, len);
402 ax->mkiss->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
403 actual = ax->mkiss->tty->driver.write(ax->mkiss->tty, 0, ax->mkiss->xbuff, count);
404 ax->tx_packets++;
405 ax->tx_bytes+=actual;
406 ax->mkiss->dev->trans_start = jiffies;
407 ax->mkiss->xleft = count - actual;
408 ax->mkiss->xhead = ax->mkiss->xbuff + actual;
409 }
410 }
411
412 /*
413 * Called by the driver when there's room for more data. If we have
414 * more packets to send, we send them here.
415 */
ax25_write_wakeup(struct tty_struct * tty)416 static void ax25_write_wakeup(struct tty_struct *tty)
417 {
418 int actual;
419 struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
420 struct mkiss_channel *mkiss;
421
422 /* First make sure we're connected. */
423 if (ax == NULL || ax->magic != AX25_MAGIC || !netif_running(ax->dev))
424 return;
425 if (ax->xleft <= 0) {
426 /* Now serial buffer is almost free & we can start
427 * transmission of another packet
428 */
429 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
430
431 if (ax->mkiss != NULL) {
432 mkiss= ax->mkiss->tty->driver_data;
433 if (mkiss->magic == MKISS_DRIVER_MAGIC)
434 ax_unlock(ax->mkiss);
435 }
436
437 netif_wake_queue(ax->dev);
438 return;
439 }
440
441 actual = tty->driver.write(tty, 0, ax->xhead, ax->xleft);
442 ax->xleft -= actual;
443 ax->xhead += actual;
444 }
445
446 /* Encapsulate an AX.25 packet and kick it into a TTY queue. */
ax_xmit(struct sk_buff * skb,struct net_device * dev)447 static int ax_xmit(struct sk_buff *skb, struct net_device *dev)
448 {
449 struct ax_disp *ax = (struct ax_disp *) dev->priv;
450 struct mkiss_channel *mkiss = ax->tty->driver_data;
451 struct ax_disp *tmp_ax;
452
453 tmp_ax = NULL;
454
455 if (mkiss->magic == MKISS_DRIVER_MAGIC) {
456 if (skb->data[0] < 0x10)
457 skb->data[0] = skb->data[0] + 0x10;
458 tmp_ax = ax->mkiss;
459 }
460
461 if (!netif_running(dev)) {
462 printk(KERN_ERR "mkiss: %s: xmit call when iface is down\n", dev->name);
463 return 1;
464 }
465
466 if (tmp_ax != NULL)
467 if (netif_queue_stopped(tmp_ax->dev))
468 return 1;
469
470 if (tmp_ax != NULL)
471 if (netif_queue_stopped(dev)) {
472 printk(KERN_ERR "mkiss: dev busy while serial dev is free\n");
473 ax_unlock(ax);
474 }
475
476 if (netif_queue_stopped(dev)) {
477 /*
478 * May be we must check transmitter timeout here ?
479 * 14 Oct 1994 Dmitry Gorodchanin.
480 */
481 if (jiffies - dev->trans_start < 20 * HZ) {
482 /* 20 sec timeout not reached */
483 return 1;
484 }
485
486 printk(KERN_ERR "mkiss: %s: transmit timed out, %s?\n", dev->name,
487 (ax->tty->driver.chars_in_buffer(ax->tty) || ax->xleft) ?
488 "bad line quality" : "driver error");
489
490 ax->xleft = 0;
491 ax->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
492 ax_unlock(ax);
493 }
494
495 /* We were not busy, so we are now... :-) */
496 if (skb != NULL) {
497 ax_lock(ax);
498 if (tmp_ax != NULL)
499 ax_lock(tmp_ax);
500 ax_encaps(ax, skb->data, skb->len);
501 kfree_skb(skb);
502 }
503
504 return 0;
505 }
506
507 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
508
509 /* Return the frame type ID */
ax_header(struct sk_buff * skb,struct net_device * dev,unsigned short type,void * daddr,void * saddr,unsigned len)510 static int ax_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
511 void *daddr, void *saddr, unsigned len)
512 {
513 #ifdef CONFIG_INET
514 if (type != htons(ETH_P_AX25))
515 return ax25_encapsulate(skb, dev, type, daddr, saddr, len);
516 #endif
517 return 0;
518 }
519
520
ax_rebuild_header(struct sk_buff * skb)521 static int ax_rebuild_header(struct sk_buff *skb)
522 {
523 #ifdef CONFIG_INET
524 return ax25_rebuild_header(skb);
525 #else
526 return 0;
527 #endif
528 }
529
530 #endif /* CONFIG_{AX25,AX25_MODULE} */
531
532 /* Open the low-level part of the AX25 channel. Easy! */
ax_open(struct net_device * dev)533 static int ax_open(struct net_device *dev)
534 {
535 struct ax_disp *ax = (struct ax_disp *) dev->priv;
536 unsigned long len;
537
538 if (ax->tty == NULL)
539 return -ENODEV;
540
541 /*
542 * Allocate the frame buffers:
543 *
544 * rbuff Receive buffer.
545 * xbuff Transmit buffer.
546 */
547 len = dev->mtu * 2;
548
549 /*
550 * allow for arrival of larger UDP packets, even if we say not to
551 * also fixes a bug in which SunOS sends 512-byte packets even with
552 * an MSS of 128
553 */
554 if (len < 576 * 2)
555 len = 576 * 2;
556
557 if ((ax->rbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
558 goto norbuff;
559
560 if ((ax->xbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
561 goto noxbuff;
562
563 ax->mtu = dev->mtu + 73;
564 ax->buffsize = len;
565 ax->rcount = 0;
566 ax->xleft = 0;
567
568 ax->flags &= (1 << AXF_INUSE); /* Clear ESCAPE & ERROR flags */
569
570 netif_start_queue(dev);
571 return 0;
572
573 noxbuff:
574 kfree(ax->rbuff);
575
576 norbuff:
577 return -ENOMEM;
578 }
579
580
581 /* Close the low-level part of the AX25 channel. Easy! */
ax_close(struct net_device * dev)582 static int ax_close(struct net_device *dev)
583 {
584 struct ax_disp *ax = (struct ax_disp *) dev->priv;
585
586 if (ax->tty == NULL)
587 return -EBUSY;
588
589 ax->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
590
591 netif_stop_queue(dev);
592
593 return 0;
594 }
595
ax25_receive_room(struct tty_struct * tty)596 static int ax25_receive_room(struct tty_struct *tty)
597 {
598 return 65536; /* We can handle an infinite amount of data. :-) */
599 }
600
601 /*
602 * Handle the 'receiver data ready' interrupt.
603 * This function is called by the 'tty_io' module in the kernel when
604 * a block of data has been received, which can now be decapsulated
605 * and sent on to the AX.25 layer for further processing.
606 */
ax25_receive_buf(struct tty_struct * tty,const unsigned char * cp,char * fp,int count)607 static void ax25_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
608 {
609 struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
610
611 if (ax == NULL || ax->magic != AX25_MAGIC || !netif_running(ax->dev))
612 return;
613
614 /*
615 * Argh! mtu change time! - costs us the packet part received
616 * at the change
617 */
618 if (ax->mtu != ax->dev->mtu + 73)
619 ax_changedmtu(ax);
620
621 /* Read the characters out of the buffer */
622 while (count--) {
623 if (fp != NULL && *fp++) {
624 if (!test_and_set_bit(AXF_ERROR, &ax->flags))
625 ax->rx_errors++;
626 cp++;
627 continue;
628 }
629
630 kiss_unesc(ax, *cp++);
631 }
632 }
633
ax25_open(struct tty_struct * tty)634 static int ax25_open(struct tty_struct *tty)
635 {
636 struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
637 struct ax_disp *tmp_ax;
638 struct mkiss_channel *mkiss;
639 int err, cnt;
640
641 /* First make sure we're not already connected. */
642 if (ax && ax->magic == AX25_MAGIC)
643 return -EEXIST;
644
645 /* OK. Find a free AX25 channel to use. */
646 if ((ax = ax_alloc()) == NULL)
647 return -ENFILE;
648
649 ax->tty = tty;
650 tty->disc_data = ax;
651
652 ax->mkiss = NULL;
653 tmp_ax = NULL;
654
655 if (tty->driver.flush_buffer)
656 tty->driver.flush_buffer(tty);
657 tty_ldisc_flush(tty);
658
659 /* Restore default settings */
660 ax->dev->type = ARPHRD_AX25;
661
662 /* Perform the low-level AX25 initialization. */
663 if ((err = ax_open(ax->dev)))
664 return err;
665
666 mkiss = ax->tty->driver_data;
667
668 if (mkiss->magic == MKISS_DRIVER_MAGIC) {
669 for (cnt = 1; cnt < ax25_maxdev; cnt++) {
670 if (ax25_ctrls[cnt]) {
671 if (netif_running(&ax25_ctrls[cnt]->dev)) {
672 if (ax == &ax25_ctrls[cnt]->ctrl) {
673 cnt--;
674 tmp_ax = &ax25_ctrls[cnt]->ctrl;
675 break;
676 }
677 }
678 }
679 }
680 }
681
682 if (tmp_ax != NULL) {
683 ax->mkiss = tmp_ax;
684 tmp_ax->mkiss = ax;
685 }
686
687 MOD_INC_USE_COUNT;
688
689 /* Done. We have linked the TTY line to a channel. */
690 return ax->dev->base_addr;
691 }
692
ax25_close(struct tty_struct * tty)693 static void ax25_close(struct tty_struct *tty)
694 {
695 struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
696
697 /* First make sure we're connected. */
698 if (ax == NULL || ax->magic != AX25_MAGIC)
699 return;
700
701 unregister_netdev(ax->dev);
702
703 tty->disc_data = 0;
704 ax->tty = NULL;
705
706 ax_free(ax);
707 MOD_DEC_USE_COUNT;
708 }
709
710
ax_get_stats(struct net_device * dev)711 static struct net_device_stats *ax_get_stats(struct net_device *dev)
712 {
713 static struct net_device_stats stats;
714 struct ax_disp *ax = (struct ax_disp *) dev->priv;
715
716 memset(&stats, 0, sizeof(struct net_device_stats));
717
718 stats.rx_packets = ax->rx_packets;
719 stats.tx_packets = ax->tx_packets;
720 stats.rx_bytes = ax->rx_bytes;
721 stats.tx_bytes = ax->tx_bytes;
722 stats.rx_dropped = ax->rx_dropped;
723 stats.tx_dropped = ax->tx_dropped;
724 stats.tx_errors = ax->tx_errors;
725 stats.rx_errors = ax->rx_errors;
726 stats.rx_over_errors = ax->rx_over_errors;
727
728 return &stats;
729 }
730
731
732 /************************************************************************
733 * STANDARD ENCAPSULATION *
734 ************************************************************************/
735
kiss_esc(unsigned char * s,unsigned char * d,int len)736 static int kiss_esc(unsigned char *s, unsigned char *d, int len)
737 {
738 unsigned char *ptr = d;
739 unsigned char c;
740
741 /*
742 * Send an initial END character to flush out any
743 * data that may have accumulated in the receiver
744 * due to line noise.
745 */
746
747 *ptr++ = END;
748
749 while (len-- > 0) {
750 switch (c = *s++) {
751 case END:
752 *ptr++ = ESC;
753 *ptr++ = ESC_END;
754 break;
755 case ESC:
756 *ptr++ = ESC;
757 *ptr++ = ESC_ESC;
758 break;
759 default:
760 *ptr++ = c;
761 break;
762 }
763 }
764
765 *ptr++ = END;
766
767 return ptr - d;
768 }
769
770 /*
771 * MW:
772 * OK its ugly, but tell me a better solution without copying the
773 * packet to a temporary buffer :-)
774 */
kiss_esc_crc(unsigned char * s,unsigned char * d,unsigned short crc,int len)775 static int kiss_esc_crc(unsigned char *s, unsigned char *d, unsigned short crc, int len)
776 {
777 unsigned char *ptr = d;
778 unsigned char c=0;
779
780 *ptr++ = END;
781 while (len > 0) {
782 if (len > 2)
783 c = *s++;
784 else if (len > 1)
785 c = crc >> 8;
786 else if (len > 0)
787 c = crc & 0xff;
788
789 len--;
790
791 switch (c) {
792 case END:
793 *ptr++ = ESC;
794 *ptr++ = ESC_END;
795 break;
796 case ESC:
797 *ptr++ = ESC;
798 *ptr++ = ESC_ESC;
799 break;
800 default:
801 *ptr++ = c;
802 break;
803 }
804 }
805 *ptr++ = END;
806 return ptr - d;
807 }
808
kiss_unesc(struct ax_disp * ax,unsigned char s)809 static void kiss_unesc(struct ax_disp *ax, unsigned char s)
810 {
811 switch (s) {
812 case END:
813 /* drop keeptest bit = VSV */
814 if (test_bit(AXF_KEEPTEST, &ax->flags))
815 clear_bit(AXF_KEEPTEST, &ax->flags);
816
817 if (!test_and_clear_bit(AXF_ERROR, &ax->flags) && (ax->rcount > 2))
818 ax_bump(ax);
819
820 clear_bit(AXF_ESCAPE, &ax->flags);
821 ax->rcount = 0;
822 return;
823
824 case ESC:
825 set_bit(AXF_ESCAPE, &ax->flags);
826 return;
827 case ESC_ESC:
828 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
829 s = ESC;
830 break;
831 case ESC_END:
832 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
833 s = END;
834 break;
835 }
836
837 if (!test_bit(AXF_ERROR, &ax->flags)) {
838 if (ax->rcount < ax->buffsize) {
839 ax->rbuff[ax->rcount++] = s;
840 return;
841 }
842
843 ax->rx_over_errors++;
844 set_bit(AXF_ERROR, &ax->flags);
845 }
846 }
847
848
ax_set_mac_address(struct net_device * dev,void * addr)849 static int ax_set_mac_address(struct net_device *dev, void *addr)
850 {
851 if (copy_from_user(dev->dev_addr, addr, AX25_ADDR_LEN))
852 return -EFAULT;
853 return 0;
854 }
855
ax_set_dev_mac_address(struct net_device * dev,void * addr)856 static int ax_set_dev_mac_address(struct net_device *dev, void *addr)
857 {
858 struct sockaddr *sa = addr;
859
860 memcpy(dev->dev_addr, sa->sa_data, AX25_ADDR_LEN);
861
862 return 0;
863 }
864
865
866 /* Perform I/O control on an active ax25 channel. */
ax25_disp_ioctl(struct tty_struct * tty,void * file,int cmd,void * arg)867 static int ax25_disp_ioctl(struct tty_struct *tty, void *file, int cmd, void *arg)
868 {
869 struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
870 unsigned int tmp;
871
872 /* First make sure we're connected. */
873 if (ax == NULL || ax->magic != AX25_MAGIC)
874 return -EINVAL;
875
876 switch (cmd) {
877 case SIOCGIFNAME:
878 if (copy_to_user(arg, ax->dev->name, strlen(ax->dev->name) + 1))
879 return -EFAULT;
880 return 0;
881
882 case SIOCGIFENCAP:
883 return put_user(4, (int *)arg);
884
885 case SIOCSIFENCAP:
886 if (get_user(tmp, (int *)arg))
887 return -EFAULT;
888 ax->mode = tmp;
889 ax->dev->addr_len = AX25_ADDR_LEN; /* sizeof an AX.25 addr */
890 ax->dev->hard_header_len = AX25_KISS_HEADER_LEN + AX25_MAX_HEADER_LEN + 3;
891 ax->dev->type = ARPHRD_AX25;
892 return 0;
893
894 case SIOCSIFHWADDR:
895 return ax_set_mac_address(ax->dev, arg);
896
897 default:
898 return -ENOIOCTLCMD;
899 }
900 }
901
ax_open_dev(struct net_device * dev)902 static int ax_open_dev(struct net_device *dev)
903 {
904 struct ax_disp *ax = (struct ax_disp *) dev->priv;
905
906 if (ax->tty == NULL)
907 return -ENODEV;
908
909 return 0;
910 }
911
912
913 /* Initialize the driver. Called by network startup. */
ax25_init(struct net_device * dev)914 static int ax25_init(struct net_device *dev)
915 {
916 struct ax_disp *ax = (struct ax_disp *) dev->priv;
917
918 static char ax25_bcast[AX25_ADDR_LEN] =
919 {'Q'<<1,'S'<<1,'T'<<1,' '<<1,' '<<1,' '<<1,'0'<<1};
920 static char ax25_test[AX25_ADDR_LEN] =
921 {'L'<<1,'I'<<1,'N'<<1,'U'<<1,'X'<<1,' '<<1,'1'<<1};
922
923 if (ax == NULL) /* Allocation failed ?? */
924 return -ENODEV;
925
926 /* Set up the "AX25 Control Block". (And clear statistics) */
927 memset(ax, 0, sizeof (struct ax_disp));
928 ax->magic = AX25_MAGIC;
929 ax->dev = dev;
930
931 /* Finish setting up the DEVICE info. */
932 dev->mtu = AX_MTU;
933 dev->hard_start_xmit = ax_xmit;
934 dev->open = ax_open_dev;
935 dev->stop = ax_close;
936 dev->get_stats = ax_get_stats;
937 dev->set_mac_address = ax_set_dev_mac_address;
938 dev->hard_header_len = 0;
939 dev->addr_len = 0;
940 dev->type = ARPHRD_AX25;
941 dev->tx_queue_len = 10;
942 dev->hard_header = ax_header;
943 dev->rebuild_header = ax_rebuild_header;
944
945 memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
946 memcpy(dev->dev_addr, ax25_test, AX25_ADDR_LEN);
947
948 /* New-style flags. */
949 dev->flags = IFF_BROADCAST | IFF_MULTICAST;
950
951 return 0;
952 }
953
954
955 /* ******************************************************************** */
956 /* * Init MKISS driver * */
957 /* ******************************************************************** */
958
mkiss_init_driver(void)959 static int __init mkiss_init_driver(void)
960 {
961 int status;
962
963 printk(banner);
964
965 if (ax25_maxdev < 4)
966 ax25_maxdev = 4; /* Sanity */
967
968 if ((ax25_ctrls = kmalloc(sizeof(void *) * ax25_maxdev, GFP_KERNEL)) == NULL) {
969 printk(KERN_ERR "mkiss: Can't allocate ax25_ctrls[] array!\n");
970 return -ENOMEM;
971 }
972
973 /* Clear the pointer array, we allocate devices when we need them */
974 memset(ax25_ctrls, 0, sizeof(void*) * ax25_maxdev); /* Pointers */
975
976 /* Fill in our line protocol discipline, and register it */
977 ax_ldisc.magic = TTY_LDISC_MAGIC;
978 ax_ldisc.name = "mkiss";
979 ax_ldisc.open = ax25_open;
980 ax_ldisc.close = ax25_close;
981 ax_ldisc.ioctl = (int (*)(struct tty_struct *, struct file *,
982 unsigned int, unsigned long))ax25_disp_ioctl;
983 ax_ldisc.receive_buf = ax25_receive_buf;
984 ax_ldisc.receive_room = ax25_receive_room;
985 ax_ldisc.write_wakeup = ax25_write_wakeup;
986
987 if ((status = tty_register_ldisc(N_AX25, &ax_ldisc)) != 0) {
988 printk(KERN_ERR "mkiss: can't register line discipline (err = %d)\n", status);
989 kfree(ax25_ctrls);
990 }
991 return status;
992 }
993
mkiss_exit_driver(void)994 static void __exit mkiss_exit_driver(void)
995 {
996 int i;
997
998 for (i = 0; i < ax25_maxdev; i++) {
999 if (ax25_ctrls[i]) {
1000 /*
1001 * VSV = if dev->start==0, then device
1002 * unregistered while close proc.
1003 */
1004 if (netif_running(&ax25_ctrls[i]->dev))
1005 unregister_netdev(&ax25_ctrls[i]->dev);
1006 kfree(ax25_ctrls[i]);
1007 }
1008 }
1009
1010 kfree(ax25_ctrls);
1011 ax25_ctrls = NULL;
1012
1013 if ((i = tty_register_ldisc(N_AX25, NULL)))
1014 printk(KERN_ERR "mkiss: can't unregister line discipline (err = %d)\n", i);
1015 }
1016
1017 MODULE_AUTHOR("Hans Albas PE1AYX <hans@esrac.ele.tue.nl>");
1018 MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs");
1019 MODULE_PARM(ax25_maxdev, "i");
1020 MODULE_PARM_DESC(ax25_maxdev, "number of MKISS devices");
1021 MODULE_LICENSE("GPL");
1022
1023 module_init(mkiss_init_driver);
1024 module_exit(mkiss_exit_driver);
1025
1026