2 * 6pack.c This module implements the 6pack protocol for kernel-based
3 * devices like TTY. It interfaces between a raw TTY and the
4 * kernel's AX.25 protocol layers.
6 * Authors: Andreas Könsgen <ajk@comnets.uni-bremen.de>
7 * Ralf Baechle DL5RB <ralf@linux-mips.org>
9 * Quite a lot of stuff "stolen" by Joerg Reuter from slip.c, written by
11 * Laurence Culhane, <loz@holmes.demon.co.uk>
12 * Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
15 #include <linux/module.h>
16 #include <linux/uaccess.h>
17 #include <linux/bitops.h>
18 #include <linux/string.h>
20 #include <linux/interrupt.h>
22 #include <linux/tty.h>
23 #include <linux/errno.h>
24 #include <linux/netdevice.h>
25 #include <linux/timer.h>
26 #include <linux/slab.h>
28 #include <linux/etherdevice.h>
29 #include <linux/skbuff.h>
30 #include <linux/rtnetlink.h>
31 #include <linux/spinlock.h>
32 #include <linux/if_arp.h>
33 #include <linux/init.h>
35 #include <linux/tcp.h>
36 #include <linux/semaphore.h>
37 #include <linux/compat.h>
38 #include <linux/refcount.h>
40 #define SIXPACK_VERSION "Revision: 0.3.0"
42 /* sixpack priority commands */
43 #define SIXP_SEOF 0x40 /* start and end of a 6pack frame */
44 #define SIXP_TX_URUN 0x48 /* transmit overrun */
45 #define SIXP_RX_ORUN 0x50 /* receive overrun */
46 #define SIXP_RX_BUF_OVL 0x58 /* receive buffer overflow */
48 #define SIXP_CHKSUM 0xFF /* valid checksum of a 6pack frame */
50 /* masks to get certain bits out of the status bytes sent by the TNC */
52 #define SIXP_CMD_MASK 0xC0
53 #define SIXP_CHN_MASK 0x07
54 #define SIXP_PRIO_CMD_MASK 0x80
55 #define SIXP_STD_CMD_MASK 0x40
56 #define SIXP_PRIO_DATA_MASK 0x38
57 #define SIXP_TX_MASK 0x20
58 #define SIXP_RX_MASK 0x10
59 #define SIXP_RX_DCD_MASK 0x18
60 #define SIXP_LEDS_ON 0x78
61 #define SIXP_LEDS_OFF 0x60
65 #define SIXP_FOUND_TNC 0xe9
66 #define SIXP_CON_ON 0x68
67 #define SIXP_DCD_MASK 0x08
68 #define SIXP_DAMA_OFF 0
70 /* default level 2 parameters */
71 #define SIXP_TXDELAY (HZ/4) /* in 1 s */
72 #define SIXP_PERSIST 50 /* in 256ths */
73 #define SIXP_SLOTTIME (HZ/10) /* in 1 s */
74 #define SIXP_INIT_RESYNC_TIMEOUT (3*HZ/2) /* in 1 s */
75 #define SIXP_RESYNC_TIMEOUT 5*HZ /* in 1 s */
77 /* 6pack configuration. */
78 #define SIXP_NRUNIT 31 /* MAX number of 6pack channels */
79 #define SIXP_MTU 256 /* Default MTU */
82 SIXPF_ERROR, /* Parity, etc. error */
87 struct tty_struct *tty; /* ptr to TTY structure */
88 struct net_device *dev; /* easy for intr handling */
90 /* These are pointers to the malloc()ed frame buffers. */
91 unsigned char *rbuff; /* receiver buffer */
92 int rcount; /* received chars counter */
93 unsigned char *xbuff; /* transmitter buffer */
94 unsigned char *xhead; /* next byte to XMIT */
95 int xleft; /* bytes left in XMIT queue */
97 unsigned char raw_buf[4];
98 unsigned char cooked_buf[400];
100 unsigned int rx_count;
101 unsigned int rx_count_cooked;
103 int mtu; /* Our mtu (to spot changes!) */
104 int buffsize; /* Max buffers sizes */
106 unsigned long flags; /* Flag values/ mode etc */
107 unsigned char mode; /* 6pack mode */
110 unsigned char tx_delay;
111 unsigned char persistence;
112 unsigned char slottime;
113 unsigned char duplex;
114 unsigned char led_state;
115 unsigned char status;
116 unsigned char status1;
117 unsigned char status2;
118 unsigned char tx_enable;
119 unsigned char tnc_state;
121 struct timer_list tx_t;
122 struct timer_list resync_t;
124 struct semaphore dead_sem;
128 #define AX25_6PACK_HEADER_LEN 0
130 static void sixpack_decode(struct sixpack *, const unsigned char[], int);
131 static int encode_sixpack(unsigned char *, unsigned char *, int, unsigned char);
134 * Perform the persistence/slottime algorithm for CSMA access. If the
135 * persistence check was successful, write the data to the serial driver.
136 * Note that in case of DAMA operation, the data is not sent here.
139 static void sp_xmit_on_air(struct timer_list *t)
141 struct sixpack *sp = from_timer(sp, t, tx_t);
142 int actual, when = sp->slottime;
143 static unsigned char random;
145 random = random * 17 + 41;
147 if (((sp->status1 & SIXP_DCD_MASK) == 0) && (random < sp->persistence)) {
148 sp->led_state = 0x70;
149 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
151 actual = sp->tty->ops->write(sp->tty, sp->xbuff, sp->status2);
154 sp->led_state = 0x60;
155 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
158 mod_timer(&sp->tx_t, jiffies + ((when + 1) * HZ) / 100);
161 /* ----> 6pack timer interrupt handler and friends. <---- */
163 /* Encapsulate one AX.25 frame and stuff into a TTY queue. */
164 static void sp_encaps(struct sixpack *sp, unsigned char *icp, int len)
166 unsigned char *msg, *p = icp;
169 if (len > sp->mtu) { /* sp->mtu = AX25_MTU = max. PACLEN = 256 */
170 msg = "oversized transmit packet!";
174 if (len > sp->mtu) { /* sp->mtu = AX25_MTU = max. PACLEN = 256 */
175 msg = "oversized transmit packet!";
180 msg = "invalid KISS command";
184 if ((p[0] != 0) && (len > 2)) {
185 msg = "KISS control packet too long";
189 if ((p[0] == 0) && (len < 15)) {
190 msg = "bad AX.25 packet to transmit";
194 count = encode_sixpack(p, sp->xbuff, len, sp->tx_delay);
195 set_bit(TTY_DO_WRITE_WAKEUP, &sp->tty->flags);
198 case 1: sp->tx_delay = p[1];
200 case 2: sp->persistence = p[1];
202 case 3: sp->slottime = p[1];
204 case 4: /* ignored */
206 case 5: sp->duplex = p[1];
214 * In case of fullduplex or DAMA operation, we don't take care about the
215 * state of the DCD or of any timers, as the determination of the
216 * correct time to send is the job of the AX.25 layer. We send
217 * immediately after data has arrived.
219 if (sp->duplex == 1) {
220 sp->led_state = 0x70;
221 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
223 actual = sp->tty->ops->write(sp->tty, sp->xbuff, count);
224 sp->xleft = count - actual;
225 sp->xhead = sp->xbuff + actual;
226 sp->led_state = 0x60;
227 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
230 sp->xhead = sp->xbuff;
232 sp_xmit_on_air(&sp->tx_t);
238 sp->dev->stats.tx_dropped++;
239 netif_start_queue(sp->dev);
241 printk(KERN_DEBUG "%s: %s - dropped.\n", sp->dev->name, msg);
244 /* Encapsulate an IP datagram and kick it into a TTY queue. */
246 static netdev_tx_t sp_xmit(struct sk_buff *skb, struct net_device *dev)
248 struct sixpack *sp = netdev_priv(dev);
250 if (skb->protocol == htons(ETH_P_IP))
251 return ax25_ip_xmit(skb);
253 spin_lock_bh(&sp->lock);
254 /* We were not busy, so we are now... :-) */
255 netif_stop_queue(dev);
256 dev->stats.tx_bytes += skb->len;
257 sp_encaps(sp, skb->data, skb->len);
258 spin_unlock_bh(&sp->lock);
265 static int sp_open_dev(struct net_device *dev)
267 struct sixpack *sp = netdev_priv(dev);
274 /* Close the low-level part of the 6pack channel. */
275 static int sp_close(struct net_device *dev)
277 struct sixpack *sp = netdev_priv(dev);
279 spin_lock_bh(&sp->lock);
281 /* TTY discipline is running. */
282 clear_bit(TTY_DO_WRITE_WAKEUP, &sp->tty->flags);
284 netif_stop_queue(dev);
285 spin_unlock_bh(&sp->lock);
290 static int sp_set_mac_address(struct net_device *dev, void *addr)
292 struct sockaddr_ax25 *sa = addr;
294 netif_tx_lock_bh(dev);
295 netif_addr_lock(dev);
296 memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN);
297 netif_addr_unlock(dev);
298 netif_tx_unlock_bh(dev);
303 static const struct net_device_ops sp_netdev_ops = {
304 .ndo_open = sp_open_dev,
305 .ndo_stop = sp_close,
306 .ndo_start_xmit = sp_xmit,
307 .ndo_set_mac_address = sp_set_mac_address,
310 static void sp_setup(struct net_device *dev)
312 /* Finish setting up the DEVICE info. */
313 dev->netdev_ops = &sp_netdev_ops;
314 dev->needs_free_netdev = true;
316 dev->hard_header_len = AX25_MAX_HEADER_LEN;
317 dev->header_ops = &ax25_header_ops;
319 dev->addr_len = AX25_ADDR_LEN;
320 dev->type = ARPHRD_AX25;
321 dev->tx_queue_len = 10;
323 /* Only activated in AX.25 mode */
324 memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
325 memcpy(dev->dev_addr, &ax25_defaddr, AX25_ADDR_LEN);
330 /* Send one completely decapsulated IP datagram to the IP layer. */
333 * This is the routine that sends the received data to the kernel AX.25.
334 * 'cmd' is the KISS command. For AX.25 data, it is zero.
337 static void sp_bump(struct sixpack *sp, char cmd)
343 count = sp->rcount + 1;
345 sp->dev->stats.rx_bytes += count;
347 if ((skb = dev_alloc_skb(count)) == NULL)
350 ptr = skb_put(skb, count);
351 *ptr++ = cmd; /* KISS command */
353 memcpy(ptr, sp->cooked_buf + 1, count);
354 skb->protocol = ax25_type_trans(skb, sp->dev);
356 sp->dev->stats.rx_packets++;
361 sp->dev->stats.rx_dropped++;
365 /* ----------------------------------------------------------------------- */
368 * We have a potential race on dereferencing tty->disc_data, because the tty
369 * layer provides no locking at all - thus one cpu could be running
370 * sixpack_receive_buf while another calls sixpack_close, which zeroes
371 * tty->disc_data and frees the memory that sixpack_receive_buf is using. The
372 * best way to fix this is to use a rwlock in the tty struct, but for now we
373 * use a single global rwlock for all ttys in ppp line discipline.
375 static DEFINE_RWLOCK(disc_data_lock);
377 static struct sixpack *sp_get(struct tty_struct *tty)
381 read_lock(&disc_data_lock);
384 refcount_inc(&sp->refcnt);
385 read_unlock(&disc_data_lock);
390 static void sp_put(struct sixpack *sp)
392 if (refcount_dec_and_test(&sp->refcnt))
397 * Called by the TTY driver when there's room for more data. If we have
398 * more packets to send, we send them here.
400 static void sixpack_write_wakeup(struct tty_struct *tty)
402 struct sixpack *sp = sp_get(tty);
407 if (sp->xleft <= 0) {
408 /* Now serial buffer is almost free & we can start
409 * transmission of another packet */
410 sp->dev->stats.tx_packets++;
411 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
413 netif_wake_queue(sp->dev);
418 actual = tty->ops->write(tty, sp->xhead, sp->xleft);
427 /* ----------------------------------------------------------------------- */
430 * Handle the 'receiver data ready' interrupt.
431 * This function is called by the tty module in the kernel when
432 * a block of 6pack data has been received, which can now be decapsulated
433 * and sent on to some IP layer for further processing.
435 static void sixpack_receive_buf(struct tty_struct *tty,
436 const unsigned char *cp, char *fp, int count)
448 /* Read the characters out of the buffer */
453 if (!test_and_set_bit(SIXPF_ERROR, &sp->flags))
454 sp->dev->stats.rx_errors++;
458 sixpack_decode(sp, cp, count1);
465 * Try to resync the TNC. Called by the resync timer defined in
466 * decode_prio_command
469 #define TNC_UNINITIALIZED 0
470 #define TNC_UNSYNC_STARTUP 1
471 #define TNC_UNSYNCED 2
472 #define TNC_IN_SYNC 3
474 static void __tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
478 switch (new_tnc_state) {
479 default: /* gcc oh piece-o-crap ... */
480 case TNC_UNSYNC_STARTUP:
481 msg = "Synchronizing with TNC";
484 msg = "Lost synchronization with TNC\n";
491 sp->tnc_state = new_tnc_state;
492 printk(KERN_INFO "%s: %s\n", sp->dev->name, msg);
495 static inline void tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
497 int old_tnc_state = sp->tnc_state;
499 if (old_tnc_state != new_tnc_state)
500 __tnc_set_sync_state(sp, new_tnc_state);
503 static void resync_tnc(struct timer_list *t)
505 struct sixpack *sp = from_timer(sp, t, resync_t);
506 static char resync_cmd = 0xe8;
508 /* clear any data that might have been received */
511 sp->rx_count_cooked = 0;
513 /* reset state machine */
521 sp->led_state = 0x60;
522 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
523 sp->tty->ops->write(sp->tty, &resync_cmd, 1);
526 /* Start resync timer again -- the TNC might be still absent */
527 mod_timer(&sp->resync_t, jiffies + SIXP_RESYNC_TIMEOUT);
530 static inline int tnc_init(struct sixpack *sp)
532 unsigned char inbyte = 0xe8;
534 tnc_set_sync_state(sp, TNC_UNSYNC_STARTUP);
536 sp->tty->ops->write(sp->tty, &inbyte, 1);
538 mod_timer(&sp->resync_t, jiffies + SIXP_RESYNC_TIMEOUT);
544 * Open the high-level part of the 6pack channel.
545 * This function is called by the TTY module when the
546 * 6pack line discipline is called for. Because we are
547 * sure the tty line exists, we only have to link it to
548 * a free 6pcack channel...
550 static int sixpack_open(struct tty_struct *tty)
552 char *rbuff = NULL, *xbuff = NULL;
553 struct net_device *dev;
558 if (!capable(CAP_NET_ADMIN))
560 if (tty->ops->write == NULL)
563 dev = alloc_netdev(sizeof(struct sixpack), "sp%d", NET_NAME_UNKNOWN,
570 sp = netdev_priv(dev);
573 spin_lock_init(&sp->lock);
574 refcount_set(&sp->refcnt, 1);
575 sema_init(&sp->dead_sem, 0);
577 /* !!! length of the buffers. MTU is IP MTU, not PACLEN! */
581 rbuff = kmalloc(len + 4, GFP_KERNEL);
582 xbuff = kmalloc(len + 4, GFP_KERNEL);
584 if (rbuff == NULL || xbuff == NULL) {
589 spin_lock_bh(&sp->lock);
596 sp->mtu = AX25_MTU + 73;
600 sp->rx_count_cooked = 0;
603 sp->flags = 0; /* Clear ESCAPE & ERROR flags */
606 sp->tx_delay = SIXP_TXDELAY;
607 sp->persistence = SIXP_PERSIST;
608 sp->slottime = SIXP_SLOTTIME;
609 sp->led_state = 0x60;
615 netif_start_queue(dev);
617 timer_setup(&sp->tx_t, sp_xmit_on_air, 0);
619 timer_setup(&sp->resync_t, resync_tnc, 0);
621 spin_unlock_bh(&sp->lock);
623 /* Done. We have linked the TTY line to a channel. */
625 tty->receive_room = 65536;
627 /* Now we're ready to register. */
628 err = register_netdev(dev);
648 * Close down a 6pack channel.
649 * This means flushing out any pending queues, and then restoring the
650 * TTY line discipline to what it was before it got hooked to 6pack
651 * (which usually is TTY again).
653 static void sixpack_close(struct tty_struct *tty)
657 write_lock_irq(&disc_data_lock);
659 tty->disc_data = NULL;
660 write_unlock_irq(&disc_data_lock);
665 * We have now ensured that nobody can start using ap from now on, but
666 * we have to wait for all existing users to finish.
668 if (!refcount_dec_and_test(&sp->refcnt))
671 /* We must stop the queue to avoid potentially scribbling
672 * on the free buffers. The sp->dead_sem is not sufficient
673 * to protect us from sp->xbuff access.
675 netif_stop_queue(sp->dev);
677 del_timer_sync(&sp->tx_t);
678 del_timer_sync(&sp->resync_t);
680 /* Free all 6pack frame buffers. */
684 unregister_netdev(sp->dev);
687 /* Perform I/O control on an active 6pack channel. */
688 static int sixpack_ioctl(struct tty_struct *tty, struct file *file,
689 unsigned int cmd, unsigned long arg)
691 struct sixpack *sp = sp_get(tty);
692 struct net_device *dev;
693 unsigned int tmp, err;
701 err = copy_to_user((void __user *) arg, dev->name,
702 strlen(dev->name) + 1) ? -EFAULT : 0;
706 err = put_user(0, (int __user *) arg);
710 if (get_user(tmp, (int __user *) arg)) {
716 dev->addr_len = AX25_ADDR_LEN;
717 dev->hard_header_len = AX25_KISS_HEADER_LEN +
718 AX25_MAX_HEADER_LEN + 3;
719 dev->type = ARPHRD_AX25;
724 case SIOCSIFHWADDR: {
725 char addr[AX25_ADDR_LEN];
727 if (copy_from_user(&addr,
728 (void __user *) arg, AX25_ADDR_LEN)) {
733 netif_tx_lock_bh(dev);
734 memcpy(dev->dev_addr, &addr, AX25_ADDR_LEN);
735 netif_tx_unlock_bh(dev);
742 err = tty_mode_ioctl(tty, file, cmd, arg);
751 static long sixpack_compat_ioctl(struct tty_struct * tty, struct file * file,
752 unsigned int cmd, unsigned long arg)
759 return sixpack_ioctl(tty, file, cmd,
760 (unsigned long)compat_ptr(arg));
767 static struct tty_ldisc_ops sp_ldisc = {
768 .owner = THIS_MODULE,
769 .magic = TTY_LDISC_MAGIC,
771 .open = sixpack_open,
772 .close = sixpack_close,
773 .ioctl = sixpack_ioctl,
775 .compat_ioctl = sixpack_compat_ioctl,
777 .receive_buf = sixpack_receive_buf,
778 .write_wakeup = sixpack_write_wakeup,
781 /* Initialize 6pack control device -- register 6pack line discipline */
783 static const char msg_banner[] __initconst = KERN_INFO \
784 "AX.25: 6pack driver, " SIXPACK_VERSION "\n";
785 static const char msg_regfail[] __initconst = KERN_ERR \
786 "6pack: can't register line discipline (err = %d)\n";
788 static int __init sixpack_init_driver(void)
794 /* Register the provided line protocol discipline */
795 if ((status = tty_register_ldisc(N_6PACK, &sp_ldisc)) != 0)
796 printk(msg_regfail, status);
801 static const char msg_unregfail[] = KERN_ERR \
802 "6pack: can't unregister line discipline (err = %d)\n";
804 static void __exit sixpack_exit_driver(void)
808 if ((ret = tty_unregister_ldisc(N_6PACK)))
809 printk(msg_unregfail, ret);
812 /* encode an AX.25 packet into 6pack */
814 static int encode_sixpack(unsigned char *tx_buf, unsigned char *tx_buf_raw,
815 int length, unsigned char tx_delay)
818 unsigned char checksum = 0, buf[400];
821 tx_buf_raw[raw_count++] = SIXP_PRIO_CMD_MASK | SIXP_TX_MASK;
822 tx_buf_raw[raw_count++] = SIXP_SEOF;
825 for (count = 1; count < length; count++)
826 buf[count] = tx_buf[count];
828 for (count = 0; count < length; count++)
829 checksum += buf[count];
830 buf[length] = (unsigned char) 0xff - checksum;
832 for (count = 0; count <= length; count++) {
833 if ((count % 3) == 0) {
834 tx_buf_raw[raw_count++] = (buf[count] & 0x3f);
835 tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x30);
836 } else if ((count % 3) == 1) {
837 tx_buf_raw[raw_count++] |= (buf[count] & 0x0f);
838 tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x3c);
840 tx_buf_raw[raw_count++] |= (buf[count] & 0x03);
841 tx_buf_raw[raw_count++] = (buf[count] >> 2);
844 if ((length % 3) != 2)
846 tx_buf_raw[raw_count++] = SIXP_SEOF;
850 /* decode 4 sixpack-encoded bytes into 3 data bytes */
852 static void decode_data(struct sixpack *sp, unsigned char inbyte)
856 if (sp->rx_count != 3) {
857 sp->raw_buf[sp->rx_count++] = inbyte;
863 sp->cooked_buf[sp->rx_count_cooked++] =
864 buf[0] | ((buf[1] << 2) & 0xc0);
865 sp->cooked_buf[sp->rx_count_cooked++] =
866 (buf[1] & 0x0f) | ((buf[2] << 2) & 0xf0);
867 sp->cooked_buf[sp->rx_count_cooked++] =
868 (buf[2] & 0x03) | (inbyte << 2);
872 /* identify and execute a 6pack priority command byte */
874 static void decode_prio_command(struct sixpack *sp, unsigned char cmd)
878 if ((cmd & SIXP_PRIO_DATA_MASK) != 0) { /* idle ? */
880 /* RX and DCD flags can only be set in the same prio command,
881 if the DCD flag has been set without the RX flag in the previous
882 prio command. If DCD has not been set before, something in the
883 transmission has gone wrong. In this case, RX and DCD are
884 cleared in order to prevent the decode_data routine from
885 reading further data that might be corrupt. */
887 if (((sp->status & SIXP_DCD_MASK) == 0) &&
888 ((cmd & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)) {
890 printk(KERN_DEBUG "6pack: protocol violation\n");
893 cmd &= ~SIXP_RX_DCD_MASK;
895 sp->status = cmd & SIXP_PRIO_DATA_MASK;
896 } else { /* output watchdog char if idle */
897 if ((sp->status2 != 0) && (sp->duplex == 1)) {
898 sp->led_state = 0x70;
899 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
901 actual = sp->tty->ops->write(sp->tty, sp->xbuff, sp->status2);
904 sp->led_state = 0x60;
910 /* needed to trigger the TNC watchdog */
911 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
913 /* if the state byte has been received, the TNC is present,
914 so the resync timer can be reset. */
916 if (sp->tnc_state == TNC_IN_SYNC)
917 mod_timer(&sp->resync_t, jiffies + SIXP_INIT_RESYNC_TIMEOUT);
919 sp->status1 = cmd & SIXP_PRIO_DATA_MASK;
922 /* identify and execute a standard 6pack command byte */
924 static void decode_std_command(struct sixpack *sp, unsigned char cmd)
926 unsigned char checksum = 0, rest = 0;
929 switch (cmd & SIXP_CMD_MASK) { /* normal command */
931 if ((sp->rx_count == 0) && (sp->rx_count_cooked == 0)) {
932 if ((sp->status & SIXP_RX_DCD_MASK) ==
934 sp->led_state = 0x68;
935 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
938 sp->led_state = 0x60;
939 /* fill trailing bytes with zeroes */
940 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
943 for (i = rest; i <= 3; i++)
946 sp->rx_count_cooked -= 2;
948 sp->rx_count_cooked -= 1;
949 for (i = 0; i < sp->rx_count_cooked; i++)
950 checksum += sp->cooked_buf[i];
951 if (checksum != SIXP_CHKSUM) {
952 printk(KERN_DEBUG "6pack: bad checksum %2.2x\n", checksum);
954 sp->rcount = sp->rx_count_cooked-2;
957 sp->rx_count_cooked = 0;
960 case SIXP_TX_URUN: printk(KERN_DEBUG "6pack: TX underrun\n");
962 case SIXP_RX_ORUN: printk(KERN_DEBUG "6pack: RX overrun\n");
964 case SIXP_RX_BUF_OVL:
965 printk(KERN_DEBUG "6pack: RX buffer overflow\n");
969 /* decode a 6pack packet */
972 sixpack_decode(struct sixpack *sp, const unsigned char *pre_rbuff, int count)
974 unsigned char inbyte;
977 for (count1 = 0; count1 < count; count1++) {
978 inbyte = pre_rbuff[count1];
979 if (inbyte == SIXP_FOUND_TNC) {
980 tnc_set_sync_state(sp, TNC_IN_SYNC);
981 del_timer(&sp->resync_t);
983 if ((inbyte & SIXP_PRIO_CMD_MASK) != 0)
984 decode_prio_command(sp, inbyte);
985 else if ((inbyte & SIXP_STD_CMD_MASK) != 0)
986 decode_std_command(sp, inbyte);
987 else if ((sp->status & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)
988 decode_data(sp, inbyte);
992 MODULE_AUTHOR("Ralf Baechle DO1GRB <ralf@linux-mips.org>");
993 MODULE_DESCRIPTION("6pack driver for AX.25");
994 MODULE_LICENSE("GPL");
995 MODULE_ALIAS_LDISC(N_6PACK);
997 module_init(sixpack_init_driver);
998 module_exit(sixpack_exit_driver);