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.
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
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/>.
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>
18 #include <linux/module.h>
19 #include <linux/bitops.h>
20 #include <asm/uaccess.h>
21 #include <linux/crc16.h>
22 #include <linux/string.h>
24 #include <linux/interrupt.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 #include <linux/compat.h>
44 /* some arch define END as assembly function ending, just undef it */
46 /* SLIP/KISS protocol characters. */
47 #define END 0300 /* indicates end of frame */
48 #define ESC 0333 /* indicates byte stuffing */
49 #define ESC_END 0334 /* ESC ESC_END means END 'data' */
50 #define ESC_ESC 0335 /* ESC ESC_ESC means ESC 'data' */
53 struct tty_struct *tty; /* ptr to TTY structure */
54 struct net_device *dev; /* easy for intr handling */
56 /* These are pointers to the malloc()ed frame buffers. */
57 spinlock_t buflock;/* lock for rbuf and xbuf */
58 unsigned char *rbuff; /* receiver buffer */
59 int rcount; /* received chars counter */
60 unsigned char *xbuff; /* transmitter buffer */
61 unsigned char *xhead; /* pointer to next byte to XMIT */
62 int xleft; /* bytes left in XMIT queue */
64 /* Detailed SLIP statistics. */
65 int mtu; /* Our mtu (to spot changes!) */
66 int buffsize; /* Max buffers sizes */
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 */
77 int crcmode; /* MW: for FlexNet, SMACK etc. */
78 int crcauto; /* CRC auto mode */
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
87 struct semaphore dead_sem;
90 /*---------------------------------------------------------------------------*/
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
127 static unsigned short calc_crc_flex(unsigned char *cp, int size)
129 unsigned short crc = 0xffff;
132 crc = (crc << 8) ^ crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
137 static int check_crc_flex(unsigned char *cp, int size)
139 unsigned short crc = 0xffff;
145 crc = (crc << 8) ^ crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
147 if ((crc & 0xffff) != 0x7070)
153 static int check_crc_16(unsigned char *cp, int size)
155 unsigned short crc = 0x0000;
160 crc = crc16(0, cp, size);
169 * Standard encapsulation
172 static int kiss_esc(unsigned char *s, unsigned char *d, int len)
174 unsigned char *ptr = d;
178 * Send an initial END character to flush out any data that may have
179 * accumulated in the receiver due to line noise.
207 * OK its ugly, but tell me a better solution without copying the
208 * packet to a temporary buffer :-)
210 static int kiss_esc_crc(unsigned char *s, unsigned char *d, unsigned short crc,
213 unsigned char *ptr = d;
246 /* Send one completely decapsulated AX.25 packet to the AX.25 layer. */
247 static void ax_bump(struct mkiss *ax)
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->dev->stats.rx_errors++;
257 spin_unlock_bh(&ax->buflock);
261 if (ax->crcmode != CRC_MODE_SMACK && ax->crcauto) {
263 "mkiss: %s: Switching to crc-smack\n",
265 ax->crcmode = CRC_MODE_SMACK;
269 } else if (ax->rbuff[0] & 0x20) {
270 if (check_crc_flex(ax->rbuff, ax->rcount) < 0) {
271 ax->dev->stats.rx_errors++;
272 spin_unlock_bh(&ax->buflock);
275 if (ax->crcmode != CRC_MODE_FLEX && ax->crcauto) {
277 "mkiss: %s: Switching to crc-flexnet\n",
279 ax->crcmode = CRC_MODE_FLEX;
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
295 if ((skb = dev_alloc_skb(count)) == NULL) {
296 printk(KERN_ERR "mkiss: %s: memory squeeze, dropping packet.\n",
298 ax->dev->stats.rx_dropped++;
299 spin_unlock_bh(&ax->buflock);
303 memcpy(skb_put(skb,count), ax->rbuff, count);
304 skb->protocol = ax25_type_trans(skb, ax->dev);
306 ax->dev->stats.rx_packets++;
307 ax->dev->stats.rx_bytes += count;
308 spin_unlock_bh(&ax->buflock);
311 static void kiss_unesc(struct mkiss *ax, unsigned char s)
315 /* drop keeptest bit = VSV */
316 if (test_bit(AXF_KEEPTEST, &ax->flags))
317 clear_bit(AXF_KEEPTEST, &ax->flags);
319 if (!test_and_clear_bit(AXF_ERROR, &ax->flags) && (ax->rcount > 2))
322 clear_bit(AXF_ESCAPE, &ax->flags);
327 set_bit(AXF_ESCAPE, &ax->flags);
330 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
334 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
339 spin_lock_bh(&ax->buflock);
340 if (!test_bit(AXF_ERROR, &ax->flags)) {
341 if (ax->rcount < ax->buffsize) {
342 ax->rbuff[ax->rcount++] = s;
343 spin_unlock_bh(&ax->buflock);
347 ax->dev->stats.rx_over_errors++;
348 set_bit(AXF_ERROR, &ax->flags);
350 spin_unlock_bh(&ax->buflock);
353 static int ax_set_mac_address(struct net_device *dev, void *addr)
355 struct sockaddr_ax25 *sa = addr;
357 netif_tx_lock_bh(dev);
358 netif_addr_lock(dev);
359 memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN);
360 netif_addr_unlock(dev);
361 netif_tx_unlock_bh(dev);
366 /*---------------------------------------------------------------------------*/
368 static void ax_changedmtu(struct mkiss *ax)
370 struct net_device *dev = ax->dev;
371 unsigned char *xbuff, *rbuff, *oxbuff, *orbuff;
377 * allow for arrival of larger UDP packets, even if we say not to
378 * also fixes a bug in which SunOS sends 512-byte packets even with
384 xbuff = kmalloc(len + 4, GFP_ATOMIC);
385 rbuff = kmalloc(len + 4, GFP_ATOMIC);
387 if (xbuff == NULL || rbuff == NULL) {
388 printk(KERN_ERR "mkiss: %s: unable to grow ax25 buffers, "
389 "MTU change cancelled.\n",
397 spin_lock_bh(&ax->buflock);
405 if (ax->xleft <= len) {
406 memcpy(ax->xbuff, ax->xhead, ax->xleft);
409 dev->stats.tx_dropped++;
413 ax->xhead = ax->xbuff;
416 if (ax->rcount <= len) {
417 memcpy(ax->rbuff, orbuff, ax->rcount);
420 dev->stats.rx_over_errors++;
421 set_bit(AXF_ERROR, &ax->flags);
425 ax->mtu = dev->mtu + 73;
428 spin_unlock_bh(&ax->buflock);
434 /* Encapsulate one AX.25 packet and stuff into a TTY queue. */
435 static void ax_encaps(struct net_device *dev, unsigned char *icp, int len)
437 struct mkiss *ax = netdev_priv(dev);
441 if (ax->mtu != ax->dev->mtu + 73) /* Someone has been ifconfigging */
444 if (len > ax->mtu) { /* Sigh, shouldn't occur BUT ... */
446 printk(KERN_ERR "mkiss: %s: truncating oversized transmit packet!\n", ax->dev->name);
447 dev->stats.tx_dropped++;
448 netif_start_queue(dev);
454 spin_lock_bh(&ax->buflock);
455 if ((*p & 0x0f) != 0) {
456 /* Configuration Command (kissparms(1).
457 * Protocol spec says: never append CRC.
458 * This fixes a very old bug in the linux
459 * kiss driver. -- dl9sau */
462 /* command from userspace especially for us,
463 * not for delivery to the tnc */
465 int cmd = (p[1] & 0xff);
468 ax->crcmode = CRC_MODE_SMACK;
471 ax->crcmode = CRC_MODE_FLEX;
474 ax->crcmode = CRC_MODE_NONE;
478 ax->crcmode = CRC_MODE_SMACK_TEST;
481 ax->crcauto = (cmd ? 0 : 1);
482 printk(KERN_INFO "mkiss: %s: crc mode %s %d\n", ax->dev->name, (len) ? "set to" : "is", cmd);
484 spin_unlock_bh(&ax->buflock);
485 netif_start_queue(dev);
489 count = kiss_esc(p, ax->xbuff, len);
493 switch (ax->crcmode) {
494 case CRC_MODE_SMACK_TEST:
495 ax->crcmode = CRC_MODE_FLEX_TEST;
496 printk(KERN_INFO "mkiss: %s: Trying crc-smack\n", ax->dev->name);
500 crc = swab16(crc16(0, p, len));
501 count = kiss_esc_crc(p, ax->xbuff, crc, len+2);
503 case CRC_MODE_FLEX_TEST:
504 ax->crcmode = CRC_MODE_NONE;
505 printk(KERN_INFO "mkiss: %s: Trying crc-flexnet\n", ax->dev->name);
509 crc = calc_crc_flex(p, len);
510 count = kiss_esc_crc(p, ax->xbuff, crc, len+2);
514 count = kiss_esc(p, ax->xbuff, len);
517 spin_unlock_bh(&ax->buflock);
519 set_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
520 actual = ax->tty->ops->write(ax->tty, ax->xbuff, count);
521 dev->stats.tx_packets++;
522 dev->stats.tx_bytes += actual;
524 netif_trans_update(ax->dev);
525 ax->xleft = count - actual;
526 ax->xhead = ax->xbuff + actual;
529 /* Encapsulate an AX.25 packet and kick it into a TTY queue. */
530 static netdev_tx_t ax_xmit(struct sk_buff *skb, struct net_device *dev)
532 struct mkiss *ax = netdev_priv(dev);
534 if (skb->protocol == htons(ETH_P_IP))
535 return ax25_ip_xmit(skb);
537 if (!netif_running(dev)) {
538 printk(KERN_ERR "mkiss: %s: xmit call when iface is down\n", dev->name);
539 return NETDEV_TX_BUSY;
542 if (netif_queue_stopped(dev)) {
544 * May be we must check transmitter timeout here ?
545 * 14 Oct 1994 Dmitry Gorodchanin.
547 if (time_before(jiffies, dev_trans_start(dev) + 20 * HZ)) {
548 /* 20 sec timeout not reached */
549 return NETDEV_TX_BUSY;
552 printk(KERN_ERR "mkiss: %s: transmit timed out, %s?\n", dev->name,
553 (tty_chars_in_buffer(ax->tty) || ax->xleft) ?
554 "bad line quality" : "driver error");
557 clear_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
558 netif_start_queue(dev);
561 /* We were not busy, so we are now... :-) */
562 netif_stop_queue(dev);
563 ax_encaps(dev, skb->data, skb->len);
569 static int ax_open_dev(struct net_device *dev)
571 struct mkiss *ax = netdev_priv(dev);
579 /* Open the low-level part of the AX25 channel. Easy! */
580 static int ax_open(struct net_device *dev)
582 struct mkiss *ax = netdev_priv(dev);
589 * Allocate the frame buffers:
591 * rbuff Receive buffer.
592 * xbuff Transmit buffer.
597 * allow for arrival of larger UDP packets, even if we say not to
598 * also fixes a bug in which SunOS sends 512-byte packets even with
604 if ((ax->rbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
607 if ((ax->xbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
610 ax->mtu = dev->mtu + 73;
615 ax->flags &= (1 << AXF_INUSE); /* Clear ESCAPE & ERROR flags */
617 spin_lock_init(&ax->buflock);
629 /* Close the low-level part of the AX25 channel. Easy! */
630 static int ax_close(struct net_device *dev)
632 struct mkiss *ax = netdev_priv(dev);
635 clear_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
637 netif_stop_queue(dev);
642 static const struct net_device_ops ax_netdev_ops = {
643 .ndo_open = ax_open_dev,
644 .ndo_stop = ax_close,
645 .ndo_start_xmit = ax_xmit,
646 .ndo_set_mac_address = ax_set_mac_address,
649 static void ax_setup(struct net_device *dev)
651 /* Finish setting up the DEVICE info. */
653 dev->hard_header_len = AX25_MAX_HEADER_LEN;
654 dev->addr_len = AX25_ADDR_LEN;
655 dev->type = ARPHRD_AX25;
656 dev->tx_queue_len = 10;
657 dev->header_ops = &ax25_header_ops;
658 dev->netdev_ops = &ax_netdev_ops;
661 memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
662 memcpy(dev->dev_addr, &ax25_defaddr, AX25_ADDR_LEN);
664 dev->flags = IFF_BROADCAST | IFF_MULTICAST;
668 * We have a potential race on dereferencing tty->disc_data, because the tty
669 * layer provides no locking at all - thus one cpu could be running
670 * sixpack_receive_buf while another calls sixpack_close, which zeroes
671 * tty->disc_data and frees the memory that sixpack_receive_buf is using. The
672 * best way to fix this is to use a rwlock in the tty struct, but for now we
673 * use a single global rwlock for all ttys in ppp line discipline.
675 static DEFINE_RWLOCK(disc_data_lock);
677 static struct mkiss *mkiss_get(struct tty_struct *tty)
681 read_lock(&disc_data_lock);
684 atomic_inc(&ax->refcnt);
685 read_unlock(&disc_data_lock);
690 static void mkiss_put(struct mkiss *ax)
692 if (atomic_dec_and_test(&ax->refcnt))
696 static int crc_force = 0; /* Can be overridden with insmod */
698 static int mkiss_open(struct tty_struct *tty)
700 struct net_device *dev;
704 if (!capable(CAP_NET_ADMIN))
706 if (tty->ops->write == NULL)
709 dev = alloc_netdev(sizeof(struct mkiss), "ax%d", NET_NAME_UNKNOWN,
716 ax = netdev_priv(dev);
719 spin_lock_init(&ax->buflock);
720 atomic_set(&ax->refcnt, 1);
721 sema_init(&ax->dead_sem, 0);
725 tty->receive_room = 65535;
727 tty_driver_flush_buffer(tty);
729 /* Restore default settings */
730 dev->type = ARPHRD_AX25;
732 /* Perform the low-level AX25 initialization. */
733 err = ax_open(ax->dev);
735 goto out_free_netdev;
737 err = register_netdev(dev);
739 goto out_free_buffers;
741 /* after register_netdev() - because else printk smashes the kernel */
744 ax->crcmode = CRC_MODE_SMACK;
745 printk(KERN_INFO "mkiss: %s: crc mode smack forced.\n",
749 ax->crcmode = CRC_MODE_FLEX;
750 printk(KERN_INFO "mkiss: %s: crc mode flexnet forced.\n",
754 ax->crcmode = CRC_MODE_NONE;
755 printk(KERN_INFO "mkiss: %s: crc mode disabled.\n",
762 printk(KERN_INFO "mkiss: %s: crc mode is auto.\n",
764 ax->crcmode = CRC_MODE_SMACK_TEST;
766 ax->crcauto = (crc_force ? 0 : 1);
768 netif_start_queue(dev);
770 /* Done. We have linked the TTY line to a channel. */
784 static void mkiss_close(struct tty_struct *tty)
788 write_lock_irq(&disc_data_lock);
790 tty->disc_data = NULL;
791 write_unlock_irq(&disc_data_lock);
797 * We have now ensured that nobody can start using ap from now on, but
798 * we have to wait for all existing users to finish.
800 if (!atomic_dec_and_test(&ax->refcnt))
803 * Halt the transmit queue so that a new transmit cannot scribble
806 netif_stop_queue(ax->dev);
808 unregister_netdev(ax->dev);
810 /* Free all AX25 frame buffers after unreg. */
816 free_netdev(ax->dev);
819 /* Perform I/O control on an active ax25 channel. */
820 static int mkiss_ioctl(struct tty_struct *tty, struct file *file,
821 unsigned int cmd, unsigned long arg)
823 struct mkiss *ax = mkiss_get(tty);
824 struct net_device *dev;
825 unsigned int tmp, err;
827 /* First make sure we're connected. */
834 err = copy_to_user((void __user *) arg, ax->dev->name,
835 strlen(ax->dev->name) + 1) ? -EFAULT : 0;
839 err = put_user(4, (int __user *) arg);
843 if (get_user(tmp, (int __user *) arg)) {
849 dev->addr_len = AX25_ADDR_LEN;
850 dev->hard_header_len = AX25_KISS_HEADER_LEN +
851 AX25_MAX_HEADER_LEN + 3;
852 dev->type = ARPHRD_AX25;
857 case SIOCSIFHWADDR: {
858 char addr[AX25_ADDR_LEN];
860 if (copy_from_user(&addr,
861 (void __user *) arg, AX25_ADDR_LEN)) {
866 netif_tx_lock_bh(dev);
867 memcpy(dev->dev_addr, addr, AX25_ADDR_LEN);
868 netif_tx_unlock_bh(dev);
883 static long mkiss_compat_ioctl(struct tty_struct *tty, struct file *file,
884 unsigned int cmd, unsigned long arg)
891 return mkiss_ioctl(tty, file, cmd,
892 (unsigned long)compat_ptr(arg));
900 * Handle the 'receiver data ready' interrupt.
901 * This function is called by the 'tty_io' module in the kernel when
902 * a block of data has been received, which can now be decapsulated
903 * and sent on to the AX.25 layer for further processing.
905 static void mkiss_receive_buf(struct tty_struct *tty, const unsigned char *cp,
908 struct mkiss *ax = mkiss_get(tty);
914 * Argh! mtu change time! - costs us the packet part received
917 if (ax->mtu != ax->dev->mtu + 73)
920 /* Read the characters out of the buffer */
922 if (fp != NULL && *fp++) {
923 if (!test_and_set_bit(AXF_ERROR, &ax->flags))
924 ax->dev->stats.rx_errors++;
929 kiss_unesc(ax, *cp++);
937 * Called by the driver when there's room for more data. If we have
938 * more packets to send, we send them here.
940 static void mkiss_write_wakeup(struct tty_struct *tty)
942 struct mkiss *ax = mkiss_get(tty);
948 if (ax->xleft <= 0) {
949 /* Now serial buffer is almost free & we can start
950 * transmission of another packet
952 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
954 netif_wake_queue(ax->dev);
958 actual = tty->ops->write(tty, ax->xhead, ax->xleft);
966 static struct tty_ldisc_ops ax_ldisc = {
967 .owner = THIS_MODULE,
968 .magic = TTY_LDISC_MAGIC,
971 .close = mkiss_close,
972 .ioctl = mkiss_ioctl,
974 .compat_ioctl = mkiss_compat_ioctl,
976 .receive_buf = mkiss_receive_buf,
977 .write_wakeup = mkiss_write_wakeup
980 static const char banner[] __initconst = KERN_INFO \
981 "mkiss: AX.25 Multikiss, Hans Albas PE1AYX\n";
982 static const char msg_regfail[] __initconst = KERN_ERR \
983 "mkiss: can't register line discipline (err = %d)\n";
985 static int __init mkiss_init_driver(void)
991 status = tty_register_ldisc(N_AX25, &ax_ldisc);
993 printk(msg_regfail, status);
998 static const char msg_unregfail[] = KERN_ERR \
999 "mkiss: can't unregister line discipline (err = %d)\n";
1001 static void __exit mkiss_exit_driver(void)
1005 if ((ret = tty_unregister_ldisc(N_AX25)))
1006 printk(msg_unregfail, ret);
1009 MODULE_AUTHOR("Ralf Baechle DL5RB <ralf@linux-mips.org>");
1010 MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs");
1011 module_param(crc_force, int, 0);
1012 MODULE_PARM_DESC(crc_force, "crc [0 = auto | 1 = none | 2 = flexnet | 3 = smack]");
1013 MODULE_LICENSE("GPL");
1014 MODULE_ALIAS_LDISC(N_AX25);
1016 module_init(mkiss_init_driver);
1017 module_exit(mkiss_exit_driver);