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.
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.
18 * Hans Alblas <hans@esrac.ele.tue.nl>
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 * Jeroen (PE1RXQ) Removed old MKISS_MAGIC stuff and calls to
27 * Remove cli() and fix rtnl lock usage.
30 #include <linux/config.h>
31 #include <linux/module.h>
32 #include <asm/system.h>
33 #include <asm/bitops.h>
34 #include <asm/uaccess.h>
35 #include <linux/string.h>
37 #include <linux/interrupt.h>
39 #include <linux/inet.h>
40 #include <linux/tty.h>
41 #include <linux/errno.h>
42 #include <linux/netdevice.h>
43 #include <linux/major.h>
44 #include <linux/init.h>
45 #include <linux/rtnetlink.h>
46 #include <linux/etherdevice.h>
47 #include <linux/skbuff.h>
48 #include <linux/if_arp.h>
56 #include <linux/tcp.h>
59 static char banner[] __initdata = KERN_INFO "mkiss: AX.25 Multikiss, Hans Albas PE1AYX\n";
61 typedef struct ax25_ctrl {
62 struct ax_disp ctrl; /* */
63 struct net_device dev; /* the device */
66 static ax25_ctrl_t **ax25_ctrls;
68 int ax25_maxdev = AX25_MAXDEV; /* Can be overridden with insmod! */
70 static struct tty_ldisc ax_ldisc;
72 static int ax25_init(struct net_device *);
73 static int kiss_esc(unsigned char *, unsigned char *, int);
74 static int kiss_esc_crc(unsigned char *, unsigned char *, unsigned short, int);
75 static void kiss_unesc(struct ax_disp *, unsigned char);
77 /*---------------------------------------------------------------------------*/
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
114 /*---------------------------------------------------------------------------*/
116 static unsigned short calc_crc_flex(unsigned char *cp, int size)
118 unsigned short crc = 0xffff;
121 crc = (crc << 8) ^ Crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
126 /*---------------------------------------------------------------------------*/
128 static int check_crc_flex(unsigned char *cp, int size)
130 unsigned short crc = 0xffff;
136 crc = (crc << 8) ^ Crc_flex_table[((crc >> 8) ^ *cp++) & 0xff];
138 if ((crc & 0xffff) != 0x7070)
144 /*---------------------------------------------------------------------------*/
146 /* Find a free channel, and link in this `tty' line. */
147 static inline struct ax_disp *ax_alloc(void)
149 ax25_ctrl_t *axp=NULL;
152 for (i = 0; i < ax25_maxdev; i++) {
155 /* Not allocated ? */
160 if (!test_and_set_bit(AXF_INUSE, &axp->ctrl.flags))
164 /* Sorry, too many, all slots in use */
165 if (i >= ax25_maxdev)
168 /* If no channels are available, allocate one */
169 if (axp == NULL && (ax25_ctrls[i] = kmalloc(sizeof(ax25_ctrl_t), GFP_KERNEL)) != NULL) {
172 memset(axp, 0, sizeof(ax25_ctrl_t));
174 /* Initialize channel control data */
175 set_bit(AXF_INUSE, &axp->ctrl.flags);
176 sprintf(axp->dev.name, "ax%d", i++);
177 axp->ctrl.tty = NULL;
178 axp->dev.base_addr = i;
179 axp->dev.priv = (void *)&axp->ctrl;
180 axp->dev.next = NULL;
181 axp->dev.init = ax25_init;
185 * register device so that it can be ifconfig'ed
186 * ax25_init() will be called as a side-effect
187 * SIDE-EFFECT WARNING: ax25_init() CLEARS axp->ctrl !
189 if (register_netdev(&axp->dev) == 0) {
190 /* (Re-)Set the INUSE bit. Very Important! */
191 set_bit(AXF_INUSE, &axp->ctrl.flags);
192 axp->ctrl.dev = &axp->dev;
193 axp->dev.priv = (void *) &axp->ctrl;
197 clear_bit(AXF_INUSE,&axp->ctrl.flags);
198 printk(KERN_ERR "mkiss: ax_alloc() - register_netdev() failure.\n");
205 /* Free an AX25 channel. */
206 static inline void ax_free(struct ax_disp *ax)
208 /* Free all AX25 frame buffers. */
215 if (!test_and_clear_bit(AXF_INUSE, &ax->flags))
216 printk(KERN_ERR "mkiss: %s: ax_free for already free unit.\n", ax->dev->name);
219 static void ax_changedmtu(struct ax_disp *ax)
221 struct net_device *dev = ax->dev;
222 unsigned char *xbuff, *rbuff, *oxbuff, *orbuff;
228 * allow for arrival of larger UDP packets, even if we say not to
229 * also fixes a bug in which SunOS sends 512-byte packets even with
235 xbuff = kmalloc(len + 4, GFP_ATOMIC);
236 rbuff = kmalloc(len + 4, GFP_ATOMIC);
238 if (xbuff == NULL || rbuff == NULL) {
239 printk(KERN_ERR "mkiss: %s: unable to grow ax25 buffers, MTU change cancelled.\n",
249 spin_lock_bh(&ax->buflock);
257 if (ax->xleft <= len) {
258 memcpy(ax->xbuff, ax->xhead, ax->xleft);
265 ax->xhead = ax->xbuff;
268 if (ax->rcount <= len) {
269 memcpy(ax->rbuff, orbuff, ax->rcount);
272 ax->rx_over_errors++;
273 set_bit(AXF_ERROR, &ax->flags);
277 ax->mtu = dev->mtu + 73;
280 spin_unlock_bh(&ax->buflock);
289 /* Set the "sending" flag. This must be atomic. */
290 static inline void ax_lock(struct ax_disp *ax)
292 netif_stop_queue(ax->dev);
296 /* Clear the "sending" flag. This must be atomic. */
297 static inline void ax_unlock(struct ax_disp *ax)
299 netif_start_queue(ax->dev);
302 /* Send one completely decapsulated AX.25 packet to the AX.25 layer. */
303 static void ax_bump(struct ax_disp *ax)
308 spin_lock_bh(&ax->buflock);
309 if (ax->rbuff[0] > 0x0f) {
310 if (ax->rbuff[0] & 0x20) {
311 ax->crcmode = CRC_MODE_FLEX;
312 if (check_crc_flex(ax->rbuff, ax->rcount) < 0) {
317 /* dl9sau bugfix: the trailling two bytes flexnet crc
318 * will not be passed to the kernel. thus we have
319 * to correct the kissparm signature, because it
320 * indicates a crc but there's none
325 spin_unlock_bh(&ax->buflock);
329 if ((skb = dev_alloc_skb(count)) == NULL) {
330 printk(KERN_ERR "mkiss: %s: memory squeeze, dropping packet.\n", ax->dev->name);
336 spin_lock_bh(&ax->buflock);
337 memcpy(skb_put(skb,count), ax->rbuff, count);
338 spin_unlock_bh(&ax->buflock);
339 skb->mac.raw = skb->data;
340 skb->protocol = htons(ETH_P_AX25);
342 ax->dev->last_rx = jiffies;
347 /* Encapsulate one AX.25 packet and stuff into a TTY queue. */
348 static void ax_encaps(struct ax_disp *ax, unsigned char *icp, int len)
353 if (ax->mtu != ax->dev->mtu + 73) /* Someone has been ifconfigging */
356 if (len > ax->mtu) { /* Sigh, shouldn't occur BUT ... */
358 printk(KERN_ERR "mkiss: %s: truncating oversized transmit packet!\n", ax->dev->name);
366 spin_lock_bh(&ax->buflock);
367 switch (ax->crcmode) {
372 crc = calc_crc_flex(p, len);
373 count = kiss_esc_crc(p, (unsigned char *)ax->xbuff, crc, len+2);
377 count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
381 ax->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
382 actual = ax->tty->driver->write(ax->tty, 0, ax->xbuff, count);
384 ax->tx_bytes+=actual;
385 ax->dev->trans_start = jiffies;
386 ax->xleft = count - actual;
387 ax->xhead = ax->xbuff + actual;
389 spin_unlock_bh(&ax->buflock);
393 * Called by the driver when there's room for more data. If we have
394 * more packets to send, we send them here.
396 static void ax25_write_wakeup(struct tty_struct *tty)
399 struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
401 /* First make sure we're connected. */
402 if (ax == NULL || ax->magic != AX25_MAGIC || !netif_running(ax->dev))
404 if (ax->xleft <= 0) {
405 /* Now serial buffer is almost free & we can start
406 * transmission of another packet
408 tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
410 netif_wake_queue(ax->dev);
414 actual = tty->driver->write(tty, 0, ax->xhead, ax->xleft);
419 /* Encapsulate an AX.25 packet and kick it into a TTY queue. */
420 static int ax_xmit(struct sk_buff *skb, struct net_device *dev)
422 struct ax_disp *ax = (struct ax_disp *) dev->priv;
424 if (!netif_running(dev)) {
425 printk(KERN_ERR "mkiss: %s: xmit call when iface is down\n", dev->name);
429 if (netif_queue_stopped(dev)) {
431 * May be we must check transmitter timeout here ?
432 * 14 Oct 1994 Dmitry Gorodchanin.
434 if (jiffies - dev->trans_start < 20 * HZ) {
435 /* 20 sec timeout not reached */
439 printk(KERN_ERR "mkiss: %s: transmit timed out, %s?\n", dev->name,
440 (ax->tty->driver->chars_in_buffer(ax->tty) || ax->xleft) ?
441 "bad line quality" : "driver error");
444 ax->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
448 /* We were not busy, so we are now... :-) */
451 ax_encaps(ax, skb->data, skb->len);
458 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
460 /* Return the frame type ID */
461 static int ax_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
462 void *daddr, void *saddr, unsigned len)
465 if (type != htons(ETH_P_AX25))
466 return ax25_encapsulate(skb, dev, type, daddr, saddr, len);
472 static int ax_rebuild_header(struct sk_buff *skb)
475 return ax25_rebuild_header(skb);
481 #endif /* CONFIG_{AX25,AX25_MODULE} */
483 /* Open the low-level part of the AX25 channel. Easy! */
484 static int ax_open(struct net_device *dev)
486 struct ax_disp *ax = (struct ax_disp *) dev->priv;
493 * Allocate the frame buffers:
495 * rbuff Receive buffer.
496 * xbuff Transmit buffer.
501 * allow for arrival of larger UDP packets, even if we say not to
502 * also fixes a bug in which SunOS sends 512-byte packets even with
508 if ((ax->rbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
511 if ((ax->xbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
514 ax->mtu = dev->mtu + 73;
519 ax->flags &= (1 << AXF_INUSE); /* Clear ESCAPE & ERROR flags */
521 ax->buflock = SPIN_LOCK_UNLOCKED;
523 netif_start_queue(dev);
534 /* Close the low-level part of the AX25 channel. Easy! */
535 static int ax_close(struct net_device *dev)
537 struct ax_disp *ax = (struct ax_disp *) dev->priv;
542 ax->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
544 netif_stop_queue(dev);
549 static int ax25_receive_room(struct tty_struct *tty)
551 return 65536; /* We can handle an infinite amount of data. :-) */
555 * Handle the 'receiver data ready' interrupt.
556 * This function is called by the 'tty_io' module in the kernel when
557 * a block of data has been received, which can now be decapsulated
558 * and sent on to the AX.25 layer for further processing.
560 static void ax25_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
562 struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
564 if (ax == NULL || ax->magic != AX25_MAGIC || !netif_running(ax->dev))
568 * Argh! mtu change time! - costs us the packet part received
571 if (ax->mtu != ax->dev->mtu + 73)
574 /* Read the characters out of the buffer */
576 if (fp != NULL && *fp++) {
577 if (!test_and_set_bit(AXF_ERROR, &ax->flags))
583 kiss_unesc(ax, *cp++);
587 static int ax25_open(struct tty_struct *tty)
589 struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
592 /* First make sure we're not already connected. */
593 if (ax && ax->magic == AX25_MAGIC)
596 /* OK. Find a free AX25 channel to use. */
597 if ((ax = ax_alloc()) == NULL)
603 if (tty->driver->flush_buffer)
604 tty->driver->flush_buffer(tty);
605 if (tty->ldisc.flush_buffer)
606 tty->ldisc.flush_buffer(tty);
608 /* Restore default settings */
609 ax->dev->type = ARPHRD_AX25;
611 /* Perform the low-level AX25 initialization. */
612 if ((err = ax_open(ax->dev)))
615 /* Done. We have linked the TTY line to a channel. */
616 return ax->dev->base_addr;
619 static void ax25_close(struct tty_struct *tty)
621 struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
623 /* First make sure we're connected. */
624 if (ax == NULL || ax->magic != AX25_MAGIC)
627 unregister_netdev(ax->dev);
636 static struct net_device_stats *ax_get_stats(struct net_device *dev)
638 static struct net_device_stats stats;
639 struct ax_disp *ax = (struct ax_disp *) dev->priv;
641 memset(&stats, 0, sizeof(struct net_device_stats));
643 stats.rx_packets = ax->rx_packets;
644 stats.tx_packets = ax->tx_packets;
645 stats.rx_bytes = ax->rx_bytes;
646 stats.tx_bytes = ax->tx_bytes;
647 stats.rx_dropped = ax->rx_dropped;
648 stats.tx_dropped = ax->tx_dropped;
649 stats.tx_errors = ax->tx_errors;
650 stats.rx_errors = ax->rx_errors;
651 stats.rx_over_errors = ax->rx_over_errors;
657 /************************************************************************
658 * STANDARD ENCAPSULATION *
659 ************************************************************************/
661 static int kiss_esc(unsigned char *s, unsigned char *d, int len)
663 unsigned char *ptr = d;
667 * Send an initial END character to flush out any
668 * data that may have accumulated in the receiver
697 * OK its ugly, but tell me a better solution without copying the
698 * packet to a temporary buffer :-)
700 static int kiss_esc_crc(unsigned char *s, unsigned char *d, unsigned short crc, int len)
702 unsigned char *ptr = d;
734 static void kiss_unesc(struct ax_disp *ax, unsigned char s)
738 /* drop keeptest bit = VSV */
739 if (test_bit(AXF_KEEPTEST, &ax->flags))
740 clear_bit(AXF_KEEPTEST, &ax->flags);
742 if (!test_and_clear_bit(AXF_ERROR, &ax->flags) && (ax->rcount > 2))
745 clear_bit(AXF_ESCAPE, &ax->flags);
750 set_bit(AXF_ESCAPE, &ax->flags);
753 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
757 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
762 spin_lock_bh(&ax->buflock);
763 if (!test_bit(AXF_ERROR, &ax->flags)) {
764 if (ax->rcount < ax->buffsize) {
765 ax->rbuff[ax->rcount++] = s;
766 spin_unlock_bh(&ax->buflock);
770 ax->rx_over_errors++;
771 set_bit(AXF_ERROR, &ax->flags);
773 spin_unlock_bh(&ax->buflock);
777 static int ax_set_mac_address(struct net_device *dev, void *addr)
779 if (copy_from_user(dev->dev_addr, addr, AX25_ADDR_LEN))
784 static int ax_set_dev_mac_address(struct net_device *dev, void *addr)
786 struct sockaddr *sa = addr;
788 memcpy(dev->dev_addr, sa->sa_data, AX25_ADDR_LEN);
794 /* Perform I/O control on an active ax25 channel. */
795 static int ax25_disp_ioctl(struct tty_struct *tty, void *file, int cmd, void *arg)
797 struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
800 /* First make sure we're connected. */
801 if (ax == NULL || ax->magic != AX25_MAGIC)
806 if (copy_to_user(arg, ax->dev->name, strlen(ax->dev->name) + 1))
811 return put_user(4, (int *)arg);
814 if (get_user(tmp, (int *)arg))
817 ax->dev->addr_len = AX25_ADDR_LEN; /* sizeof an AX.25 addr */
818 ax->dev->hard_header_len = AX25_KISS_HEADER_LEN + AX25_MAX_HEADER_LEN + 3;
819 ax->dev->type = ARPHRD_AX25;
823 return ax_set_mac_address(ax->dev, arg);
830 static int ax_open_dev(struct net_device *dev)
832 struct ax_disp *ax = (struct ax_disp *) dev->priv;
841 /* Initialize the driver. Called by network startup. */
842 static int ax25_init(struct net_device *dev)
844 struct ax_disp *ax = (struct ax_disp *) dev->priv;
846 static char ax25_bcast[AX25_ADDR_LEN] =
847 {'Q'<<1,'S'<<1,'T'<<1,' '<<1,' '<<1,' '<<1,'0'<<1};
848 static char ax25_test[AX25_ADDR_LEN] =
849 {'L'<<1,'I'<<1,'N'<<1,'U'<<1,'X'<<1,' '<<1,'1'<<1};
851 if (ax == NULL) /* Allocation failed ?? */
854 /* Set up the "AX25 Control Block". (And clear statistics) */
855 memset(ax, 0, sizeof (struct ax_disp));
856 ax->magic = AX25_MAGIC;
859 /* Finish setting up the DEVICE info. */
861 dev->hard_start_xmit = ax_xmit;
862 dev->open = ax_open_dev;
863 dev->stop = ax_close;
864 dev->get_stats = ax_get_stats;
865 dev->set_mac_address = ax_set_dev_mac_address;
866 dev->hard_header_len = 0;
868 dev->type = ARPHRD_AX25;
869 dev->tx_queue_len = 10;
870 dev->hard_header = ax_header;
871 dev->rebuild_header = ax_rebuild_header;
873 memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
874 memcpy(dev->dev_addr, ax25_test, AX25_ADDR_LEN);
876 /* New-style flags. */
877 dev->flags = IFF_BROADCAST | IFF_MULTICAST;
883 /* ******************************************************************** */
884 /* * Init MKISS driver * */
885 /* ******************************************************************** */
887 static int __init mkiss_init_driver(void)
894 ax25_maxdev = 4; /* Sanity */
896 if ((ax25_ctrls = kmalloc(sizeof(void *) * ax25_maxdev, GFP_KERNEL)) == NULL) {
897 printk(KERN_ERR "mkiss: Can't allocate ax25_ctrls[] array!\n");
901 /* Clear the pointer array, we allocate devices when we need them */
902 memset(ax25_ctrls, 0, sizeof(void*) * ax25_maxdev); /* Pointers */
904 /* Fill in our line protocol discipline, and register it */
905 ax_ldisc.magic = TTY_LDISC_MAGIC;
906 ax_ldisc.name = "mkiss";
907 ax_ldisc.open = ax25_open;
908 ax_ldisc.close = ax25_close;
909 ax_ldisc.ioctl = (int (*)(struct tty_struct *, struct file *,
910 unsigned int, unsigned long))ax25_disp_ioctl;
911 ax_ldisc.receive_buf = ax25_receive_buf;
912 ax_ldisc.receive_room = ax25_receive_room;
913 ax_ldisc.write_wakeup = ax25_write_wakeup;
915 if ((status = tty_register_ldisc(N_AX25, &ax_ldisc)) != 0) {
916 printk(KERN_ERR "mkiss: can't register line discipline (err = %d)\n", status);
922 static void __exit mkiss_exit_driver(void)
926 for (i = 0; i < ax25_maxdev; i++) {
929 * VSV = if dev->start==0, then device
930 * unregistered while close proc.
932 if (netif_running(&ax25_ctrls[i]->dev))
933 unregister_netdev(&ax25_ctrls[i]->dev);
934 kfree(ax25_ctrls[i]);
941 if ((i = tty_register_ldisc(N_AX25, NULL)))
942 printk(KERN_ERR "mkiss: can't unregister line discipline (err = %d)\n", i);
945 MODULE_AUTHOR("Hans Albas PE1AYX <hans@esrac.ele.tue.nl>");
946 MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs");
947 MODULE_PARM(ax25_maxdev, "i");
948 MODULE_PARM_DESC(ax25_maxdev, "number of MKISS devices");
949 MODULE_LICENSE("GPL");
950 MODULE_ALIAS_LDISC(N_AX25);
951 module_init(mkiss_init_driver);
952 module_exit(mkiss_exit_driver);