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@iehk.rwth-aachen.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 <asm/system.h>
17 #include <asm/uaccess.h>
18 #include <linux/bitops.h>
19 #include <linux/string.h>
21 #include <linux/interrupt.h>
23 #include <linux/tty.h>
24 #include <linux/errno.h>
25 #include <linux/netdevice.h>
26 #include <linux/timer.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 <asm/atomic.h>
39 #define SIXPACK_VERSION "Revision: 0.3.0"
41 /* sixpack priority commands */
42 #define SIXP_SEOF 0x40 /* start and end of a 6pack frame */
43 #define SIXP_TX_URUN 0x48 /* transmit overrun */
44 #define SIXP_RX_ORUN 0x50 /* receive overrun */
45 #define SIXP_RX_BUF_OVL 0x58 /* receive buffer overflow */
47 #define SIXP_CHKSUM 0xFF /* valid checksum of a 6pack frame */
49 /* masks to get certain bits out of the status bytes sent by the TNC */
51 #define SIXP_CMD_MASK 0xC0
52 #define SIXP_CHN_MASK 0x07
53 #define SIXP_PRIO_CMD_MASK 0x80
54 #define SIXP_STD_CMD_MASK 0x40
55 #define SIXP_PRIO_DATA_MASK 0x38
56 #define SIXP_TX_MASK 0x20
57 #define SIXP_RX_MASK 0x10
58 #define SIXP_RX_DCD_MASK 0x18
59 #define SIXP_LEDS_ON 0x78
60 #define SIXP_LEDS_OFF 0x60
64 #define SIXP_FOUND_TNC 0xe9
65 #define SIXP_CON_ON 0x68
66 #define SIXP_DCD_MASK 0x08
67 #define SIXP_DAMA_OFF 0
69 /* default level 2 parameters */
70 #define SIXP_TXDELAY (HZ/4) /* in 1 s */
71 #define SIXP_PERSIST 50 /* in 256ths */
72 #define SIXP_SLOTTIME (HZ/10) /* in 1 s */
73 #define SIXP_INIT_RESYNC_TIMEOUT (3*HZ/2) /* in 1 s */
74 #define SIXP_RESYNC_TIMEOUT 5*HZ /* in 1 s */
76 /* 6pack configuration. */
77 #define SIXP_NRUNIT 31 /* MAX number of 6pack channels */
78 #define SIXP_MTU 256 /* Default MTU */
81 SIXPF_ERROR, /* Parity, etc. error */
86 struct tty_struct *tty; /* ptr to TTY structure */
87 struct net_device *dev; /* easy for intr handling */
89 /* These are pointers to the malloc()ed frame buffers. */
90 unsigned char *rbuff; /* receiver buffer */
91 int rcount; /* received chars counter */
92 unsigned char *xbuff; /* transmitter buffer */
93 unsigned char *xhead; /* next byte to XMIT */
94 int xleft; /* bytes left in XMIT queue */
96 unsigned char raw_buf[4];
97 unsigned char cooked_buf[400];
99 unsigned int rx_count;
100 unsigned int rx_count_cooked;
102 /* 6pack interface statistics. */
103 struct net_device_stats stats;
105 int mtu; /* Our mtu (to spot changes!) */
106 int buffsize; /* Max buffers sizes */
108 unsigned long flags; /* Flag values/ mode etc */
109 unsigned char mode; /* 6pack mode */
112 unsigned char tx_delay;
113 unsigned char persistence;
114 unsigned char slottime;
115 unsigned char duplex;
116 unsigned char led_state;
117 unsigned char status;
118 unsigned char status1;
119 unsigned char status2;
120 unsigned char tx_enable;
121 unsigned char tnc_state;
123 struct timer_list tx_t;
124 struct timer_list resync_t;
126 struct semaphore dead_sem;
130 #define AX25_6PACK_HEADER_LEN 0
132 static void sixpack_decode(struct sixpack *, unsigned char[], int);
133 static int encode_sixpack(unsigned char *, unsigned char *, int, unsigned char);
136 * Perform the persistence/slottime algorithm for CSMA access. If the
137 * persistence check was successful, write the data to the serial driver.
138 * Note that in case of DAMA operation, the data is not sent here.
141 static void sp_xmit_on_air(unsigned long channel)
143 struct sixpack *sp = (struct sixpack *) channel;
144 int actual, when = sp->slottime;
145 static unsigned char random;
147 random = random * 17 + 41;
149 if (((sp->status1 & SIXP_DCD_MASK) == 0) && (random < sp->persistence)) {
150 sp->led_state = 0x70;
151 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
153 actual = sp->tty->ops->write(sp->tty, sp->xbuff, sp->status2);
156 sp->led_state = 0x60;
157 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
160 mod_timer(&sp->tx_t, jiffies + ((when + 1) * HZ) / 100);
163 /* ----> 6pack timer interrupt handler and friends. <---- */
165 /* Encapsulate one AX.25 frame and stuff into a TTY queue. */
166 static void sp_encaps(struct sixpack *sp, unsigned char *icp, int len)
168 unsigned char *msg, *p = icp;
171 if (len > sp->mtu) { /* sp->mtu = AX25_MTU = max. PACLEN = 256 */
172 msg = "oversized transmit packet!";
176 if (len > sp->mtu) { /* sp->mtu = AX25_MTU = max. PACLEN = 256 */
177 msg = "oversized transmit packet!";
182 msg = "invalid KISS command";
186 if ((p[0] != 0) && (len > 2)) {
187 msg = "KISS control packet too long";
191 if ((p[0] == 0) && (len < 15)) {
192 msg = "bad AX.25 packet to transmit";
196 count = encode_sixpack(p, sp->xbuff, len, sp->tx_delay);
197 set_bit(TTY_DO_WRITE_WAKEUP, &sp->tty->flags);
200 case 1: sp->tx_delay = p[1];
202 case 2: sp->persistence = p[1];
204 case 3: sp->slottime = p[1];
206 case 4: /* ignored */
208 case 5: sp->duplex = p[1];
216 * In case of fullduplex or DAMA operation, we don't take care about the
217 * state of the DCD or of any timers, as the determination of the
218 * correct time to send is the job of the AX.25 layer. We send
219 * immediately after data has arrived.
221 if (sp->duplex == 1) {
222 sp->led_state = 0x70;
223 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
225 actual = sp->tty->ops->write(sp->tty, sp->xbuff, count);
226 sp->xleft = count - actual;
227 sp->xhead = sp->xbuff + actual;
228 sp->led_state = 0x60;
229 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
232 sp->xhead = sp->xbuff;
234 sp_xmit_on_air((unsigned long)sp);
240 sp->stats.tx_dropped++;
241 netif_start_queue(sp->dev);
243 printk(KERN_DEBUG "%s: %s - dropped.\n", sp->dev->name, msg);
246 /* Encapsulate an IP datagram and kick it into a TTY queue. */
248 static int sp_xmit(struct sk_buff *skb, struct net_device *dev)
250 struct sixpack *sp = netdev_priv(dev);
252 spin_lock_bh(&sp->lock);
253 /* We were not busy, so we are now... :-) */
254 netif_stop_queue(dev);
255 sp->stats.tx_bytes += skb->len;
256 sp_encaps(sp, skb->data, skb->len);
257 spin_unlock_bh(&sp->lock);
264 static int sp_open_dev(struct net_device *dev)
266 struct sixpack *sp = netdev_priv(dev);
273 /* Close the low-level part of the 6pack channel. */
274 static int sp_close(struct net_device *dev)
276 struct sixpack *sp = netdev_priv(dev);
278 spin_lock_bh(&sp->lock);
280 /* TTY discipline is running. */
281 clear_bit(TTY_DO_WRITE_WAKEUP, &sp->tty->flags);
283 netif_stop_queue(dev);
284 spin_unlock_bh(&sp->lock);
289 /* Return the frame type ID */
290 static int sp_header(struct sk_buff *skb, struct net_device *dev,
291 unsigned short type, const void *daddr,
292 const void *saddr, unsigned len)
295 if (type != ETH_P_AX25)
296 return ax25_hard_header(skb, dev, type, daddr, saddr, len);
301 static struct net_device_stats *sp_get_stats(struct net_device *dev)
303 struct sixpack *sp = netdev_priv(dev);
307 static int sp_set_mac_address(struct net_device *dev, void *addr)
309 struct sockaddr_ax25 *sa = addr;
311 netif_tx_lock_bh(dev);
312 memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN);
313 netif_tx_unlock_bh(dev);
318 static int sp_rebuild_header(struct sk_buff *skb)
321 return ax25_rebuild_header(skb);
327 static const struct header_ops sp_header_ops = {
329 .rebuild = sp_rebuild_header,
332 static void sp_setup(struct net_device *dev)
334 /* Finish setting up the DEVICE info. */
336 dev->hard_start_xmit = sp_xmit;
337 dev->open = sp_open_dev;
338 dev->destructor = free_netdev;
339 dev->stop = sp_close;
341 dev->get_stats = sp_get_stats;
342 dev->set_mac_address = sp_set_mac_address;
343 dev->hard_header_len = AX25_MAX_HEADER_LEN;
344 dev->header_ops = &sp_header_ops;
346 dev->addr_len = AX25_ADDR_LEN;
347 dev->type = ARPHRD_AX25;
348 dev->tx_queue_len = 10;
349 dev->tx_timeout = NULL;
351 /* Only activated in AX.25 mode */
352 memcpy(dev->broadcast, &ax25_bcast, AX25_ADDR_LEN);
353 memcpy(dev->dev_addr, &ax25_defaddr, AX25_ADDR_LEN);
358 /* Send one completely decapsulated IP datagram to the IP layer. */
361 * This is the routine that sends the received data to the kernel AX.25.
362 * 'cmd' is the KISS command. For AX.25 data, it is zero.
365 static void sp_bump(struct sixpack *sp, char cmd)
371 count = sp->rcount + 1;
373 sp->stats.rx_bytes += count;
375 if ((skb = dev_alloc_skb(count)) == NULL)
378 ptr = skb_put(skb, count);
379 *ptr++ = cmd; /* KISS command */
381 memcpy(ptr, sp->cooked_buf + 1, count);
382 skb->protocol = ax25_type_trans(skb, sp->dev);
384 sp->dev->last_rx = jiffies;
385 sp->stats.rx_packets++;
390 sp->stats.rx_dropped++;
394 /* ----------------------------------------------------------------------- */
397 * We have a potential race on dereferencing tty->disc_data, because the tty
398 * layer provides no locking at all - thus one cpu could be running
399 * sixpack_receive_buf while another calls sixpack_close, which zeroes
400 * tty->disc_data and frees the memory that sixpack_receive_buf is using. The
401 * best way to fix this is to use a rwlock in the tty struct, but for now we
402 * use a single global rwlock for all ttys in ppp line discipline.
404 static DEFINE_RWLOCK(disc_data_lock);
406 static struct sixpack *sp_get(struct tty_struct *tty)
410 read_lock(&disc_data_lock);
413 atomic_inc(&sp->refcnt);
414 read_unlock(&disc_data_lock);
419 static void sp_put(struct sixpack *sp)
421 if (atomic_dec_and_test(&sp->refcnt))
426 * Called by the TTY driver when there's room for more data. If we have
427 * more packets to send, we send them here.
429 static void sixpack_write_wakeup(struct tty_struct *tty)
431 struct sixpack *sp = sp_get(tty);
436 if (sp->xleft <= 0) {
437 /* Now serial buffer is almost free & we can start
438 * transmission of another packet */
439 sp->stats.tx_packets++;
440 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
442 netif_wake_queue(sp->dev);
447 actual = tty->ops->write(tty, sp->xhead, sp->xleft);
456 /* ----------------------------------------------------------------------- */
459 * Handle the 'receiver data ready' interrupt.
460 * This function is called by the 'tty_io' module in the kernel when
461 * a block of 6pack data has been received, which can now be decapsulated
462 * and sent on to some IP layer for further processing.
464 static void sixpack_receive_buf(struct tty_struct *tty,
465 const unsigned char *cp, char *fp, int count)
468 unsigned char buf[512];
478 memcpy(buf, cp, count < sizeof(buf) ? count : sizeof(buf));
480 /* Read the characters out of the buffer */
486 if (!test_and_set_bit(SIXPF_ERROR, &sp->flags))
487 sp->stats.rx_errors++;
491 sixpack_decode(sp, buf, count1);
494 if (test_and_clear_bit(TTY_THROTTLED, &tty->flags)
495 && tty->ops->unthrottle)
496 tty->ops->unthrottle(tty);
500 * Try to resync the TNC. Called by the resync timer defined in
501 * decode_prio_command
504 #define TNC_UNINITIALIZED 0
505 #define TNC_UNSYNC_STARTUP 1
506 #define TNC_UNSYNCED 2
507 #define TNC_IN_SYNC 3
509 static void __tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
513 switch (new_tnc_state) {
514 default: /* gcc oh piece-o-crap ... */
515 case TNC_UNSYNC_STARTUP:
516 msg = "Synchronizing with TNC";
519 msg = "Lost synchronization with TNC\n";
526 sp->tnc_state = new_tnc_state;
527 printk(KERN_INFO "%s: %s\n", sp->dev->name, msg);
530 static inline void tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
532 int old_tnc_state = sp->tnc_state;
534 if (old_tnc_state != new_tnc_state)
535 __tnc_set_sync_state(sp, new_tnc_state);
538 static void resync_tnc(unsigned long channel)
540 struct sixpack *sp = (struct sixpack *) channel;
541 static char resync_cmd = 0xe8;
543 /* clear any data that might have been received */
546 sp->rx_count_cooked = 0;
548 /* reset state machine */
556 sp->led_state = 0x60;
557 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
558 sp->tty->ops->write(sp->tty, &resync_cmd, 1);
561 /* Start resync timer again -- the TNC might be still absent */
563 del_timer(&sp->resync_t);
564 sp->resync_t.data = (unsigned long) sp;
565 sp->resync_t.function = resync_tnc;
566 sp->resync_t.expires = jiffies + SIXP_RESYNC_TIMEOUT;
567 add_timer(&sp->resync_t);
570 static inline int tnc_init(struct sixpack *sp)
572 unsigned char inbyte = 0xe8;
574 tnc_set_sync_state(sp, TNC_UNSYNC_STARTUP);
576 sp->tty->ops->write(sp->tty, &inbyte, 1);
578 del_timer(&sp->resync_t);
579 sp->resync_t.data = (unsigned long) sp;
580 sp->resync_t.function = resync_tnc;
581 sp->resync_t.expires = jiffies + SIXP_RESYNC_TIMEOUT;
582 add_timer(&sp->resync_t);
588 * Open the high-level part of the 6pack channel.
589 * This function is called by the TTY module when the
590 * 6pack line discipline is called for. Because we are
591 * sure the tty line exists, we only have to link it to
592 * a free 6pcack channel...
594 static int sixpack_open(struct tty_struct *tty)
596 char *rbuff = NULL, *xbuff = NULL;
597 struct net_device *dev;
602 if (!capable(CAP_NET_ADMIN))
604 if (tty->ops->write == NULL)
607 dev = alloc_netdev(sizeof(struct sixpack), "sp%d", sp_setup);
613 sp = netdev_priv(dev);
616 spin_lock_init(&sp->lock);
617 atomic_set(&sp->refcnt, 1);
618 init_MUTEX_LOCKED(&sp->dead_sem);
620 /* !!! length of the buffers. MTU is IP MTU, not PACLEN! */
624 rbuff = kmalloc(len + 4, GFP_KERNEL);
625 xbuff = kmalloc(len + 4, GFP_KERNEL);
627 if (rbuff == NULL || xbuff == NULL) {
632 spin_lock_bh(&sp->lock);
639 sp->mtu = AX25_MTU + 73;
643 sp->rx_count_cooked = 0;
646 sp->flags = 0; /* Clear ESCAPE & ERROR flags */
649 sp->tx_delay = SIXP_TXDELAY;
650 sp->persistence = SIXP_PERSIST;
651 sp->slottime = SIXP_SLOTTIME;
652 sp->led_state = 0x60;
658 netif_start_queue(dev);
660 init_timer(&sp->tx_t);
661 sp->tx_t.function = sp_xmit_on_air;
662 sp->tx_t.data = (unsigned long) sp;
664 init_timer(&sp->resync_t);
666 spin_unlock_bh(&sp->lock);
668 /* Done. We have linked the TTY line to a channel. */
670 tty->receive_room = 65536;
672 /* Now we're ready to register. */
673 if (register_netdev(dev))
693 * Close down a 6pack channel.
694 * This means flushing out any pending queues, and then restoring the
695 * TTY line discipline to what it was before it got hooked to 6pack
696 * (which usually is TTY again).
698 static void sixpack_close(struct tty_struct *tty)
702 write_lock(&disc_data_lock);
704 tty->disc_data = NULL;
705 write_unlock(&disc_data_lock);
710 * We have now ensured that nobody can start using ap from now on, but
711 * we have to wait for all existing users to finish.
713 if (!atomic_dec_and_test(&sp->refcnt))
716 unregister_netdev(sp->dev);
718 del_timer(&sp->tx_t);
719 del_timer(&sp->resync_t);
721 /* Free all 6pack frame buffers. */
726 /* Perform I/O control on an active 6pack channel. */
727 static int sixpack_ioctl(struct tty_struct *tty, struct file *file,
728 unsigned int cmd, unsigned long arg)
730 struct sixpack *sp = sp_get(tty);
731 struct net_device *dev = sp->dev;
732 unsigned int tmp, err;
739 err = copy_to_user((void __user *) arg, dev->name,
740 strlen(dev->name) + 1) ? -EFAULT : 0;
744 err = put_user(0, (int __user *) arg);
748 if (get_user(tmp, (int __user *) arg)) {
754 dev->addr_len = AX25_ADDR_LEN;
755 dev->hard_header_len = AX25_KISS_HEADER_LEN +
756 AX25_MAX_HEADER_LEN + 3;
757 dev->type = ARPHRD_AX25;
762 case SIOCSIFHWADDR: {
763 char addr[AX25_ADDR_LEN];
765 if (copy_from_user(&addr,
766 (void __user *) arg, AX25_ADDR_LEN)) {
771 netif_tx_lock_bh(dev);
772 memcpy(dev->dev_addr, &addr, AX25_ADDR_LEN);
773 netif_tx_unlock_bh(dev);
780 err = tty_mode_ioctl(tty, file, cmd, arg);
788 static struct tty_ldisc sp_ldisc = {
789 .owner = THIS_MODULE,
790 .magic = TTY_LDISC_MAGIC,
792 .open = sixpack_open,
793 .close = sixpack_close,
794 .ioctl = sixpack_ioctl,
795 .receive_buf = sixpack_receive_buf,
796 .write_wakeup = sixpack_write_wakeup,
799 /* Initialize 6pack control device -- register 6pack line discipline */
801 static char msg_banner[] __initdata = KERN_INFO \
802 "AX.25: 6pack driver, " SIXPACK_VERSION "\n";
803 static char msg_regfail[] __initdata = KERN_ERR \
804 "6pack: can't register line discipline (err = %d)\n";
806 static int __init sixpack_init_driver(void)
812 /* Register the provided line protocol discipline */
813 if ((status = tty_register_ldisc(N_6PACK, &sp_ldisc)) != 0)
814 printk(msg_regfail, status);
819 static const char msg_unregfail[] __exitdata = KERN_ERR \
820 "6pack: can't unregister line discipline (err = %d)\n";
822 static void __exit sixpack_exit_driver(void)
826 if ((ret = tty_unregister_ldisc(N_6PACK)))
827 printk(msg_unregfail, ret);
830 /* encode an AX.25 packet into 6pack */
832 static int encode_sixpack(unsigned char *tx_buf, unsigned char *tx_buf_raw,
833 int length, unsigned char tx_delay)
836 unsigned char checksum = 0, buf[400];
839 tx_buf_raw[raw_count++] = SIXP_PRIO_CMD_MASK | SIXP_TX_MASK;
840 tx_buf_raw[raw_count++] = SIXP_SEOF;
843 for (count = 1; count < length; count++)
844 buf[count] = tx_buf[count];
846 for (count = 0; count < length; count++)
847 checksum += buf[count];
848 buf[length] = (unsigned char) 0xff - checksum;
850 for (count = 0; count <= length; count++) {
851 if ((count % 3) == 0) {
852 tx_buf_raw[raw_count++] = (buf[count] & 0x3f);
853 tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x30);
854 } else if ((count % 3) == 1) {
855 tx_buf_raw[raw_count++] |= (buf[count] & 0x0f);
856 tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x3c);
858 tx_buf_raw[raw_count++] |= (buf[count] & 0x03);
859 tx_buf_raw[raw_count++] = (buf[count] >> 2);
862 if ((length % 3) != 2)
864 tx_buf_raw[raw_count++] = SIXP_SEOF;
868 /* decode 4 sixpack-encoded bytes into 3 data bytes */
870 static void decode_data(struct sixpack *sp, unsigned char inbyte)
874 if (sp->rx_count != 3) {
875 sp->raw_buf[sp->rx_count++] = inbyte;
881 sp->cooked_buf[sp->rx_count_cooked++] =
882 buf[0] | ((buf[1] << 2) & 0xc0);
883 sp->cooked_buf[sp->rx_count_cooked++] =
884 (buf[1] & 0x0f) | ((buf[2] << 2) & 0xf0);
885 sp->cooked_buf[sp->rx_count_cooked++] =
886 (buf[2] & 0x03) | (inbyte << 2);
890 /* identify and execute a 6pack priority command byte */
892 static void decode_prio_command(struct sixpack *sp, unsigned char cmd)
894 unsigned char channel;
897 channel = cmd & SIXP_CHN_MASK;
898 if ((cmd & SIXP_PRIO_DATA_MASK) != 0) { /* idle ? */
900 /* RX and DCD flags can only be set in the same prio command,
901 if the DCD flag has been set without the RX flag in the previous
902 prio command. If DCD has not been set before, something in the
903 transmission has gone wrong. In this case, RX and DCD are
904 cleared in order to prevent the decode_data routine from
905 reading further data that might be corrupt. */
907 if (((sp->status & SIXP_DCD_MASK) == 0) &&
908 ((cmd & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)) {
910 printk(KERN_DEBUG "6pack: protocol violation\n");
913 cmd &= ~SIXP_RX_DCD_MASK;
915 sp->status = cmd & SIXP_PRIO_DATA_MASK;
916 } else { /* output watchdog char if idle */
917 if ((sp->status2 != 0) && (sp->duplex == 1)) {
918 sp->led_state = 0x70;
919 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
921 actual = sp->tty->ops->write(sp->tty, sp->xbuff, sp->status2);
924 sp->led_state = 0x60;
930 /* needed to trigger the TNC watchdog */
931 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
933 /* if the state byte has been received, the TNC is present,
934 so the resync timer can be reset. */
936 if (sp->tnc_state == TNC_IN_SYNC) {
937 del_timer(&sp->resync_t);
938 sp->resync_t.data = (unsigned long) sp;
939 sp->resync_t.function = resync_tnc;
940 sp->resync_t.expires = jiffies + SIXP_INIT_RESYNC_TIMEOUT;
941 add_timer(&sp->resync_t);
944 sp->status1 = cmd & SIXP_PRIO_DATA_MASK;
947 /* identify and execute a standard 6pack command byte */
949 static void decode_std_command(struct sixpack *sp, unsigned char cmd)
951 unsigned char checksum = 0, rest = 0, channel;
954 channel = cmd & SIXP_CHN_MASK;
955 switch (cmd & SIXP_CMD_MASK) { /* normal command */
957 if ((sp->rx_count == 0) && (sp->rx_count_cooked == 0)) {
958 if ((sp->status & SIXP_RX_DCD_MASK) ==
960 sp->led_state = 0x68;
961 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
964 sp->led_state = 0x60;
965 /* fill trailing bytes with zeroes */
966 sp->tty->ops->write(sp->tty, &sp->led_state, 1);
969 for (i = rest; i <= 3; i++)
972 sp->rx_count_cooked -= 2;
974 sp->rx_count_cooked -= 1;
975 for (i = 0; i < sp->rx_count_cooked; i++)
976 checksum += sp->cooked_buf[i];
977 if (checksum != SIXP_CHKSUM) {
978 printk(KERN_DEBUG "6pack: bad checksum %2.2x\n", checksum);
980 sp->rcount = sp->rx_count_cooked-2;
983 sp->rx_count_cooked = 0;
986 case SIXP_TX_URUN: printk(KERN_DEBUG "6pack: TX underrun\n");
988 case SIXP_RX_ORUN: printk(KERN_DEBUG "6pack: RX overrun\n");
990 case SIXP_RX_BUF_OVL:
991 printk(KERN_DEBUG "6pack: RX buffer overflow\n");
995 /* decode a 6pack packet */
998 sixpack_decode(struct sixpack *sp, unsigned char *pre_rbuff, int count)
1000 unsigned char inbyte;
1003 for (count1 = 0; count1 < count; count1++) {
1004 inbyte = pre_rbuff[count1];
1005 if (inbyte == SIXP_FOUND_TNC) {
1006 tnc_set_sync_state(sp, TNC_IN_SYNC);
1007 del_timer(&sp->resync_t);
1009 if ((inbyte & SIXP_PRIO_CMD_MASK) != 0)
1010 decode_prio_command(sp, inbyte);
1011 else if ((inbyte & SIXP_STD_CMD_MASK) != 0)
1012 decode_std_command(sp, inbyte);
1013 else if ((sp->status & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)
1014 decode_data(sp, inbyte);
1018 MODULE_AUTHOR("Ralf Baechle DO1GRB <ralf@linux-mips.org>");
1019 MODULE_DESCRIPTION("6pack driver for AX.25");
1020 MODULE_LICENSE("GPL");
1021 MODULE_ALIAS_LDISC(N_6PACK);
1023 module_init(sixpack_init_driver);
1024 module_exit(sixpack_exit_driver);