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);
606 /* Restore default settings */
607 ax->dev->type = ARPHRD_AX25;
609 /* Perform the low-level AX25 initialization. */
610 if ((err = ax_open(ax->dev)))
613 /* Done. We have linked the TTY line to a channel. */
614 return ax->dev->base_addr;
617 static void ax25_close(struct tty_struct *tty)
619 struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
621 /* First make sure we're connected. */
622 if (ax == NULL || ax->magic != AX25_MAGIC)
625 unregister_netdev(ax->dev);
627 tty->disc_data = NULL;
634 static struct net_device_stats *ax_get_stats(struct net_device *dev)
636 static struct net_device_stats stats;
637 struct ax_disp *ax = (struct ax_disp *) dev->priv;
639 memset(&stats, 0, sizeof(struct net_device_stats));
641 stats.rx_packets = ax->rx_packets;
642 stats.tx_packets = ax->tx_packets;
643 stats.rx_bytes = ax->rx_bytes;
644 stats.tx_bytes = ax->tx_bytes;
645 stats.rx_dropped = ax->rx_dropped;
646 stats.tx_dropped = ax->tx_dropped;
647 stats.tx_errors = ax->tx_errors;
648 stats.rx_errors = ax->rx_errors;
649 stats.rx_over_errors = ax->rx_over_errors;
655 /************************************************************************
656 * STANDARD ENCAPSULATION *
657 ************************************************************************/
659 static int kiss_esc(unsigned char *s, unsigned char *d, int len)
661 unsigned char *ptr = d;
665 * Send an initial END character to flush out any
666 * data that may have accumulated in the receiver
695 * OK its ugly, but tell me a better solution without copying the
696 * packet to a temporary buffer :-)
698 static int kiss_esc_crc(unsigned char *s, unsigned char *d, unsigned short crc, int len)
700 unsigned char *ptr = d;
732 static void kiss_unesc(struct ax_disp *ax, unsigned char s)
736 /* drop keeptest bit = VSV */
737 if (test_bit(AXF_KEEPTEST, &ax->flags))
738 clear_bit(AXF_KEEPTEST, &ax->flags);
740 if (!test_and_clear_bit(AXF_ERROR, &ax->flags) && (ax->rcount > 2))
743 clear_bit(AXF_ESCAPE, &ax->flags);
748 set_bit(AXF_ESCAPE, &ax->flags);
751 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
755 if (test_and_clear_bit(AXF_ESCAPE, &ax->flags))
760 spin_lock_bh(&ax->buflock);
761 if (!test_bit(AXF_ERROR, &ax->flags)) {
762 if (ax->rcount < ax->buffsize) {
763 ax->rbuff[ax->rcount++] = s;
764 spin_unlock_bh(&ax->buflock);
768 ax->rx_over_errors++;
769 set_bit(AXF_ERROR, &ax->flags);
771 spin_unlock_bh(&ax->buflock);
775 static int ax_set_mac_address(struct net_device *dev, void __user *addr)
777 if (copy_from_user(dev->dev_addr, addr, AX25_ADDR_LEN))
782 static int ax_set_dev_mac_address(struct net_device *dev, void *addr)
784 struct sockaddr *sa = addr;
786 memcpy(dev->dev_addr, sa->sa_data, AX25_ADDR_LEN);
792 /* Perform I/O control on an active ax25 channel. */
793 static int ax25_disp_ioctl(struct tty_struct *tty, void *file, int cmd, void __user *arg)
795 struct ax_disp *ax = (struct ax_disp *) tty->disc_data;
798 /* First make sure we're connected. */
799 if (ax == NULL || ax->magic != AX25_MAGIC)
804 if (copy_to_user(arg, ax->dev->name, strlen(ax->dev->name) + 1))
809 return put_user(4, (int __user *)arg);
812 if (get_user(tmp, (int __user *)arg))
815 ax->dev->addr_len = AX25_ADDR_LEN; /* sizeof an AX.25 addr */
816 ax->dev->hard_header_len = AX25_KISS_HEADER_LEN + AX25_MAX_HEADER_LEN + 3;
817 ax->dev->type = ARPHRD_AX25;
821 return ax_set_mac_address(ax->dev, arg);
828 static int ax_open_dev(struct net_device *dev)
830 struct ax_disp *ax = (struct ax_disp *) dev->priv;
839 /* Initialize the driver. Called by network startup. */
840 static int ax25_init(struct net_device *dev)
842 struct ax_disp *ax = (struct ax_disp *) dev->priv;
844 static char ax25_bcast[AX25_ADDR_LEN] =
845 {'Q'<<1,'S'<<1,'T'<<1,' '<<1,' '<<1,' '<<1,'0'<<1};
846 static char ax25_test[AX25_ADDR_LEN] =
847 {'L'<<1,'I'<<1,'N'<<1,'U'<<1,'X'<<1,' '<<1,'1'<<1};
849 if (ax == NULL) /* Allocation failed ?? */
852 /* Set up the "AX25 Control Block". (And clear statistics) */
853 memset(ax, 0, sizeof (struct ax_disp));
854 ax->magic = AX25_MAGIC;
857 /* Finish setting up the DEVICE info. */
859 dev->hard_start_xmit = ax_xmit;
860 dev->open = ax_open_dev;
861 dev->stop = ax_close;
862 dev->get_stats = ax_get_stats;
863 dev->set_mac_address = ax_set_dev_mac_address;
864 dev->hard_header_len = 0;
866 dev->type = ARPHRD_AX25;
867 dev->tx_queue_len = 10;
868 dev->hard_header = ax_header;
869 dev->rebuild_header = ax_rebuild_header;
871 memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
872 memcpy(dev->dev_addr, ax25_test, AX25_ADDR_LEN);
874 /* New-style flags. */
875 dev->flags = IFF_BROADCAST | IFF_MULTICAST;
881 /* ******************************************************************** */
882 /* * Init MKISS driver * */
883 /* ******************************************************************** */
885 static int __init mkiss_init_driver(void)
892 ax25_maxdev = 4; /* Sanity */
894 if ((ax25_ctrls = kmalloc(sizeof(void *) * ax25_maxdev, GFP_KERNEL)) == NULL) {
895 printk(KERN_ERR "mkiss: Can't allocate ax25_ctrls[] array!\n");
899 /* Clear the pointer array, we allocate devices when we need them */
900 memset(ax25_ctrls, 0, sizeof(void*) * ax25_maxdev); /* Pointers */
902 /* Fill in our line protocol discipline, and register it */
903 ax_ldisc.magic = TTY_LDISC_MAGIC;
904 ax_ldisc.name = "mkiss";
905 ax_ldisc.open = ax25_open;
906 ax_ldisc.close = ax25_close;
907 ax_ldisc.ioctl = (int (*)(struct tty_struct *, struct file *,
908 unsigned int, unsigned long))ax25_disp_ioctl;
909 ax_ldisc.receive_buf = ax25_receive_buf;
910 ax_ldisc.receive_room = ax25_receive_room;
911 ax_ldisc.write_wakeup = ax25_write_wakeup;
913 if ((status = tty_register_ldisc(N_AX25, &ax_ldisc)) != 0) {
914 printk(KERN_ERR "mkiss: can't register line discipline (err = %d)\n", status);
920 static void __exit mkiss_exit_driver(void)
924 for (i = 0; i < ax25_maxdev; i++) {
927 * VSV = if dev->start==0, then device
928 * unregistered while close proc.
930 if (netif_running(&ax25_ctrls[i]->dev))
931 unregister_netdev(&ax25_ctrls[i]->dev);
932 kfree(ax25_ctrls[i]);
939 if ((i = tty_register_ldisc(N_AX25, NULL)))
940 printk(KERN_ERR "mkiss: can't unregister line discipline (err = %d)\n", i);
943 MODULE_AUTHOR("Hans Albas PE1AYX <hans@esrac.ele.tue.nl>");
944 MODULE_DESCRIPTION("KISS driver for AX.25 over TTYs");
945 MODULE_PARM(ax25_maxdev, "i");
946 MODULE_PARM_DESC(ax25_maxdev, "number of MKISS devices");
947 MODULE_LICENSE("GPL");
948 MODULE_ALIAS_LDISC(N_AX25);
949 module_init(mkiss_init_driver);
950 module_exit(mkiss_exit_driver);