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/config.h>
16 #include <linux/module.h>
17 #include <asm/system.h>
18 #include <asm/uaccess.h>
19 #include <linux/bitops.h>
20 #include <linux/string.h>
22 #include <linux/interrupt.h>
24 #include <linux/tty.h>
25 #include <linux/errno.h>
26 #include <linux/netdevice.h>
27 #include <linux/timer.h>
29 #include <linux/etherdevice.h>
30 #include <linux/skbuff.h>
31 #include <linux/rtnetlink.h>
32 #include <linux/spinlock.h>
33 #include <linux/if_arp.h>
34 #include <linux/init.h>
36 #include <linux/tcp.h>
37 #include <asm/semaphore.h>
38 #include <asm/atomic.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 /* 6pack interface statistics. */
104 struct net_device_stats stats;
106 int mtu; /* Our mtu (to spot changes!) */
107 int buffsize; /* Max buffers sizes */
109 unsigned long flags; /* Flag values/ mode etc */
110 unsigned char mode; /* 6pack mode */
113 unsigned char tx_delay;
114 unsigned char persistence;
115 unsigned char slottime;
116 unsigned char duplex;
117 unsigned char led_state;
118 unsigned char status;
119 unsigned char status1;
120 unsigned char status2;
121 unsigned char tx_enable;
122 unsigned char tnc_state;
124 struct timer_list tx_t;
125 struct timer_list resync_t;
127 struct semaphore dead_sem;
131 #define AX25_6PACK_HEADER_LEN 0
133 static void sixpack_decode(struct sixpack *, unsigned char[], int);
134 static int encode_sixpack(unsigned char *, unsigned char *, int, unsigned char);
137 * Perform the persistence/slottime algorithm for CSMA access. If the
138 * persistence check was successful, write the data to the serial driver.
139 * Note that in case of DAMA operation, the data is not sent here.
142 static void sp_xmit_on_air(unsigned long channel)
144 struct sixpack *sp = (struct sixpack *) channel;
145 int actual, when = sp->slottime;
146 static unsigned char random;
148 random = random * 17 + 41;
150 if (((sp->status1 & SIXP_DCD_MASK) == 0) && (random < sp->persistence)) {
151 sp->led_state = 0x70;
152 sp->tty->driver->write(sp->tty, &sp->led_state, 1);
154 actual = sp->tty->driver->write(sp->tty, sp->xbuff, sp->status2);
157 sp->led_state = 0x60;
158 sp->tty->driver->write(sp->tty, &sp->led_state, 1);
161 mod_timer(&sp->tx_t, jiffies + ((when + 1) * HZ) / 100);
164 /* ----> 6pack timer interrupt handler and friends. <---- */
166 /* Encapsulate one AX.25 frame and stuff into a TTY queue. */
167 static void sp_encaps(struct sixpack *sp, unsigned char *icp, int len)
169 unsigned char *msg, *p = icp;
172 if (len > sp->mtu) { /* sp->mtu = AX25_MTU = max. PACLEN = 256 */
173 msg = "oversized transmit packet!";
177 if (len > sp->mtu) { /* sp->mtu = AX25_MTU = max. PACLEN = 256 */
178 msg = "oversized transmit packet!";
183 msg = "invalid KISS command";
187 if ((p[0] != 0) && (len > 2)) {
188 msg = "KISS control packet too long";
192 if ((p[0] == 0) && (len < 15)) {
193 msg = "bad AX.25 packet to transmit";
197 count = encode_sixpack(p, sp->xbuff, len, sp->tx_delay);
198 set_bit(TTY_DO_WRITE_WAKEUP, &sp->tty->flags);
201 case 1: sp->tx_delay = p[1];
203 case 2: sp->persistence = p[1];
205 case 3: sp->slottime = p[1];
207 case 4: /* ignored */
209 case 5: sp->duplex = p[1];
217 * In case of fullduplex or DAMA operation, we don't take care about the
218 * state of the DCD or of any timers, as the determination of the
219 * correct time to send is the job of the AX.25 layer. We send
220 * immediately after data has arrived.
222 if (sp->duplex == 1) {
223 sp->led_state = 0x70;
224 sp->tty->driver->write(sp->tty, &sp->led_state, 1);
226 actual = sp->tty->driver->write(sp->tty, sp->xbuff, count);
227 sp->xleft = count - actual;
228 sp->xhead = sp->xbuff + actual;
229 sp->led_state = 0x60;
230 sp->tty->driver->write(sp->tty, &sp->led_state, 1);
233 sp->xhead = sp->xbuff;
235 sp_xmit_on_air((unsigned long)sp);
241 sp->stats.tx_dropped++;
242 netif_start_queue(sp->dev);
244 printk(KERN_DEBUG "%s: %s - dropped.\n", sp->dev->name, msg);
247 /* Encapsulate an IP datagram and kick it into a TTY queue. */
249 static int sp_xmit(struct sk_buff *skb, struct net_device *dev)
251 struct sixpack *sp = netdev_priv(dev);
253 spin_lock_bh(&sp->lock);
254 /* We were not busy, so we are now... :-) */
255 netif_stop_queue(dev);
256 sp->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 /* Return the frame type ID */
291 static int sp_header(struct sk_buff *skb, struct net_device *dev,
292 unsigned short type, void *daddr, void *saddr, unsigned len)
295 if (type != htons(ETH_P_AX25))
296 return ax25_encapsulate(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 spin_lock_irq(&dev->xmit_lock);
312 memcpy(dev->dev_addr, &sa->sax25_call, AX25_ADDR_LEN);
313 spin_unlock_irq(&dev->xmit_lock);
318 static int sp_rebuild_header(struct sk_buff *skb)
321 return ax25_rebuild_header(skb);
327 static void sp_setup(struct net_device *dev)
329 static char ax25_bcast[AX25_ADDR_LEN] =
330 {'Q'<<1,'S'<<1,'T'<<1,' '<<1,' '<<1,' '<<1,'0'<<1};
331 static char ax25_test[AX25_ADDR_LEN] =
332 {'L'<<1,'I'<<1,'N'<<1,'U'<<1,'X'<<1,' '<<1,'1'<<1};
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;
340 dev->hard_header = sp_header;
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->addr_len = AX25_ADDR_LEN;
345 dev->type = ARPHRD_AX25;
346 dev->tx_queue_len = 10;
347 dev->rebuild_header = sp_rebuild_header;
348 dev->tx_timeout = NULL;
350 /* Only activated in AX.25 mode */
351 memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
352 memcpy(dev->dev_addr, ax25_test, AX25_ADDR_LEN);
354 SET_MODULE_OWNER(dev);
359 /* Send one completely decapsulated IP datagram to the IP layer. */
362 * This is the routine that sends the received data to the kernel AX.25.
363 * 'cmd' is the KISS command. For AX.25 data, it is zero.
366 static void sp_bump(struct sixpack *sp, char cmd)
372 count = sp->rcount + 1;
374 sp->stats.rx_bytes += count;
376 if ((skb = dev_alloc_skb(count)) == NULL)
379 ptr = skb_put(skb, count);
380 *ptr++ = cmd; /* KISS command */
382 memcpy(ptr, sp->cooked_buf + 1, count);
383 skb->protocol = ax25_type_trans(skb, sp->dev);
385 sp->dev->last_rx = jiffies;
386 sp->stats.rx_packets++;
391 sp->stats.rx_dropped++;
395 /* ----------------------------------------------------------------------- */
398 * We have a potential race on dereferencing tty->disc_data, because the tty
399 * layer provides no locking at all - thus one cpu could be running
400 * sixpack_receive_buf while another calls sixpack_close, which zeroes
401 * tty->disc_data and frees the memory that sixpack_receive_buf is using. The
402 * best way to fix this is to use a rwlock in the tty struct, but for now we
403 * use a single global rwlock for all ttys in ppp line discipline.
405 static DEFINE_RWLOCK(disc_data_lock);
407 static struct sixpack *sp_get(struct tty_struct *tty)
411 read_lock(&disc_data_lock);
414 atomic_inc(&sp->refcnt);
415 read_unlock(&disc_data_lock);
420 static void sp_put(struct sixpack *sp)
422 if (atomic_dec_and_test(&sp->refcnt))
427 * Called by the TTY driver when there's room for more data. If we have
428 * more packets to send, we send them here.
430 static void sixpack_write_wakeup(struct tty_struct *tty)
432 struct sixpack *sp = sp_get(tty);
437 if (sp->xleft <= 0) {
438 /* Now serial buffer is almost free & we can start
439 * transmission of another packet */
440 sp->stats.tx_packets++;
441 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
443 netif_wake_queue(sp->dev);
448 actual = tty->driver->write(tty, sp->xhead, sp->xleft);
457 /* ----------------------------------------------------------------------- */
459 static int sixpack_receive_room(struct tty_struct *tty)
461 return 65536; /* We can handle an infinite amount of data. :-) */
465 * Handle the 'receiver data ready' interrupt.
466 * This function is called by the 'tty_io' module in the kernel when
467 * a block of 6pack data has been received, which can now be decapsulated
468 * and sent on to some IP layer for further processing.
470 static void sixpack_receive_buf(struct tty_struct *tty,
471 const unsigned char *cp, char *fp, int count)
474 unsigned char buf[512];
484 memcpy(buf, cp, count < sizeof(buf) ? count : sizeof(buf));
486 /* Read the characters out of the buffer */
492 if (!test_and_set_bit(SIXPF_ERROR, &sp->flags))
493 sp->stats.rx_errors++;
497 sixpack_decode(sp, buf, count1);
500 if (test_and_clear_bit(TTY_THROTTLED, &tty->flags)
501 && tty->driver->unthrottle)
502 tty->driver->unthrottle(tty);
506 * Try to resync the TNC. Called by the resync timer defined in
507 * decode_prio_command
510 #define TNC_UNINITIALIZED 0
511 #define TNC_UNSYNC_STARTUP 1
512 #define TNC_UNSYNCED 2
513 #define TNC_IN_SYNC 3
515 static void __tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
519 switch (new_tnc_state) {
520 default: /* gcc oh piece-o-crap ... */
521 case TNC_UNSYNC_STARTUP:
522 msg = "Synchronizing with TNC";
525 msg = "Lost synchronization with TNC\n";
532 sp->tnc_state = new_tnc_state;
533 printk(KERN_INFO "%s: %s\n", sp->dev->name, msg);
536 static inline void tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
538 int old_tnc_state = sp->tnc_state;
540 if (old_tnc_state != new_tnc_state)
541 __tnc_set_sync_state(sp, new_tnc_state);
544 static void resync_tnc(unsigned long channel)
546 struct sixpack *sp = (struct sixpack *) channel;
547 static char resync_cmd = 0xe8;
549 /* clear any data that might have been received */
552 sp->rx_count_cooked = 0;
554 /* reset state machine */
562 sp->led_state = 0x60;
563 sp->tty->driver->write(sp->tty, &sp->led_state, 1);
564 sp->tty->driver->write(sp->tty, &resync_cmd, 1);
567 /* Start resync timer again -- the TNC might be still absent */
569 del_timer(&sp->resync_t);
570 sp->resync_t.data = (unsigned long) sp;
571 sp->resync_t.function = resync_tnc;
572 sp->resync_t.expires = jiffies + SIXP_RESYNC_TIMEOUT;
573 add_timer(&sp->resync_t);
576 static inline int tnc_init(struct sixpack *sp)
578 unsigned char inbyte = 0xe8;
580 tnc_set_sync_state(sp, TNC_UNSYNC_STARTUP);
582 sp->tty->driver->write(sp->tty, &inbyte, 1);
584 del_timer(&sp->resync_t);
585 sp->resync_t.data = (unsigned long) sp;
586 sp->resync_t.function = resync_tnc;
587 sp->resync_t.expires = jiffies + SIXP_RESYNC_TIMEOUT;
588 add_timer(&sp->resync_t);
594 * Open the high-level part of the 6pack channel.
595 * This function is called by the TTY module when the
596 * 6pack line discipline is called for. Because we are
597 * sure the tty line exists, we only have to link it to
598 * a free 6pcack channel...
600 static int sixpack_open(struct tty_struct *tty)
602 char *rbuff = NULL, *xbuff = NULL;
603 struct net_device *dev;
608 if (!capable(CAP_NET_ADMIN))
611 dev = alloc_netdev(sizeof(struct sixpack), "sp%d", sp_setup);
617 sp = netdev_priv(dev);
620 spin_lock_init(&sp->lock);
621 atomic_set(&sp->refcnt, 1);
622 init_MUTEX_LOCKED(&sp->dead_sem);
624 /* !!! length of the buffers. MTU is IP MTU, not PACLEN! */
628 rbuff = kmalloc(len + 4, GFP_KERNEL);
629 xbuff = kmalloc(len + 4, GFP_KERNEL);
631 if (rbuff == NULL || xbuff == NULL) {
636 spin_lock_bh(&sp->lock);
643 sp->mtu = AX25_MTU + 73;
647 sp->rx_count_cooked = 0;
650 sp->flags = 0; /* Clear ESCAPE & ERROR flags */
653 sp->tx_delay = SIXP_TXDELAY;
654 sp->persistence = SIXP_PERSIST;
655 sp->slottime = SIXP_SLOTTIME;
656 sp->led_state = 0x60;
662 netif_start_queue(dev);
664 init_timer(&sp->tx_t);
665 sp->tx_t.function = sp_xmit_on_air;
666 sp->tx_t.data = (unsigned long) sp;
668 init_timer(&sp->resync_t);
670 spin_unlock_bh(&sp->lock);
672 /* Done. We have linked the TTY line to a channel. */
675 /* Now we're ready to register. */
676 if (register_netdev(dev))
696 * Close down a 6pack channel.
697 * This means flushing out any pending queues, and then restoring the
698 * TTY line discipline to what it was before it got hooked to 6pack
699 * (which usually is TTY again).
701 static void sixpack_close(struct tty_struct *tty)
705 write_lock(&disc_data_lock);
707 tty->disc_data = NULL;
708 write_unlock(&disc_data_lock);
713 * We have now ensured that nobody can start using ap from now on, but
714 * we have to wait for all existing users to finish.
716 if (!atomic_dec_and_test(&sp->refcnt))
719 unregister_netdev(sp->dev);
721 del_timer(&sp->tx_t);
722 del_timer(&sp->resync_t);
724 /* Free all 6pack frame buffers. */
729 /* Perform I/O control on an active 6pack channel. */
730 static int sixpack_ioctl(struct tty_struct *tty, struct file *file,
731 unsigned int cmd, unsigned long arg)
733 struct sixpack *sp = sp_get(tty);
734 struct net_device *dev = sp->dev;
735 unsigned int tmp, err;
742 err = copy_to_user((void __user *) arg, dev->name,
743 strlen(dev->name) + 1) ? -EFAULT : 0;
747 err = put_user(0, (int __user *) arg);
751 if (get_user(tmp, (int __user *) arg)) {
757 dev->addr_len = AX25_ADDR_LEN;
758 dev->hard_header_len = AX25_KISS_HEADER_LEN +
759 AX25_MAX_HEADER_LEN + 3;
760 dev->type = ARPHRD_AX25;
765 case SIOCSIFHWADDR: {
766 char addr[AX25_ADDR_LEN];
768 if (copy_from_user(&addr,
769 (void __user *) arg, AX25_ADDR_LEN)) {
774 spin_lock_irq(&dev->xmit_lock);
775 memcpy(dev->dev_addr, &addr, AX25_ADDR_LEN);
776 spin_unlock_irq(&dev->xmit_lock);
782 /* Allow stty to read, but not set, the serial port */
785 err = n_tty_ioctl(tty, (struct file *) file, cmd, arg);
797 static struct tty_ldisc sp_ldisc = {
798 .owner = THIS_MODULE,
799 .magic = TTY_LDISC_MAGIC,
801 .open = sixpack_open,
802 .close = sixpack_close,
803 .ioctl = sixpack_ioctl,
804 .receive_buf = sixpack_receive_buf,
805 .receive_room = sixpack_receive_room,
806 .write_wakeup = sixpack_write_wakeup,
809 /* Initialize 6pack control device -- register 6pack line discipline */
811 static char msg_banner[] __initdata = KERN_INFO \
812 "AX.25: 6pack driver, " SIXPACK_VERSION "\n";
813 static char msg_regfail[] __initdata = KERN_ERR \
814 "6pack: can't register line discipline (err = %d)\n";
816 static int __init sixpack_init_driver(void)
822 /* Register the provided line protocol discipline */
823 if ((status = tty_register_ldisc(N_6PACK, &sp_ldisc)) != 0)
824 printk(msg_regfail, status);
829 static const char msg_unregfail[] __exitdata = KERN_ERR \
830 "6pack: can't unregister line discipline (err = %d)\n";
832 static void __exit sixpack_exit_driver(void)
836 if ((ret = tty_unregister_ldisc(N_6PACK)))
837 printk(msg_unregfail, ret);
840 /* encode an AX.25 packet into 6pack */
842 static int encode_sixpack(unsigned char *tx_buf, unsigned char *tx_buf_raw,
843 int length, unsigned char tx_delay)
846 unsigned char checksum = 0, buf[400];
849 tx_buf_raw[raw_count++] = SIXP_PRIO_CMD_MASK | SIXP_TX_MASK;
850 tx_buf_raw[raw_count++] = SIXP_SEOF;
853 for (count = 1; count < length; count++)
854 buf[count] = tx_buf[count];
856 for (count = 0; count < length; count++)
857 checksum += buf[count];
858 buf[length] = (unsigned char) 0xff - checksum;
860 for (count = 0; count <= length; count++) {
861 if ((count % 3) == 0) {
862 tx_buf_raw[raw_count++] = (buf[count] & 0x3f);
863 tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x30);
864 } else if ((count % 3) == 1) {
865 tx_buf_raw[raw_count++] |= (buf[count] & 0x0f);
866 tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x3c);
868 tx_buf_raw[raw_count++] |= (buf[count] & 0x03);
869 tx_buf_raw[raw_count++] = (buf[count] >> 2);
872 if ((length % 3) != 2)
874 tx_buf_raw[raw_count++] = SIXP_SEOF;
878 /* decode 4 sixpack-encoded bytes into 3 data bytes */
880 static void decode_data(struct sixpack *sp, unsigned char inbyte)
884 if (sp->rx_count != 3) {
885 sp->raw_buf[sp->rx_count++] = inbyte;
891 sp->cooked_buf[sp->rx_count_cooked++] =
892 buf[0] | ((buf[1] << 2) & 0xc0);
893 sp->cooked_buf[sp->rx_count_cooked++] =
894 (buf[1] & 0x0f) | ((buf[2] << 2) & 0xf0);
895 sp->cooked_buf[sp->rx_count_cooked++] =
896 (buf[2] & 0x03) | (inbyte << 2);
900 /* identify and execute a 6pack priority command byte */
902 static void decode_prio_command(struct sixpack *sp, unsigned char cmd)
904 unsigned char channel;
907 channel = cmd & SIXP_CHN_MASK;
908 if ((cmd & SIXP_PRIO_DATA_MASK) != 0) { /* idle ? */
910 /* RX and DCD flags can only be set in the same prio command,
911 if the DCD flag has been set without the RX flag in the previous
912 prio command. If DCD has not been set before, something in the
913 transmission has gone wrong. In this case, RX and DCD are
914 cleared in order to prevent the decode_data routine from
915 reading further data that might be corrupt. */
917 if (((sp->status & SIXP_DCD_MASK) == 0) &&
918 ((cmd & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)) {
920 printk(KERN_DEBUG "6pack: protocol violation\n");
923 cmd &= !SIXP_RX_DCD_MASK;
925 sp->status = cmd & SIXP_PRIO_DATA_MASK;
926 } else { /* output watchdog char if idle */
927 if ((sp->status2 != 0) && (sp->duplex == 1)) {
928 sp->led_state = 0x70;
929 sp->tty->driver->write(sp->tty, &sp->led_state, 1);
931 actual = sp->tty->driver->write(sp->tty, sp->xbuff, sp->status2);
934 sp->led_state = 0x60;
940 /* needed to trigger the TNC watchdog */
941 sp->tty->driver->write(sp->tty, &sp->led_state, 1);
943 /* if the state byte has been received, the TNC is present,
944 so the resync timer can be reset. */
946 if (sp->tnc_state == TNC_IN_SYNC) {
947 del_timer(&sp->resync_t);
948 sp->resync_t.data = (unsigned long) sp;
949 sp->resync_t.function = resync_tnc;
950 sp->resync_t.expires = jiffies + SIXP_INIT_RESYNC_TIMEOUT;
951 add_timer(&sp->resync_t);
954 sp->status1 = cmd & SIXP_PRIO_DATA_MASK;
957 /* identify and execute a standard 6pack command byte */
959 static void decode_std_command(struct sixpack *sp, unsigned char cmd)
961 unsigned char checksum = 0, rest = 0, channel;
964 channel = cmd & SIXP_CHN_MASK;
965 switch (cmd & SIXP_CMD_MASK) { /* normal command */
967 if ((sp->rx_count == 0) && (sp->rx_count_cooked == 0)) {
968 if ((sp->status & SIXP_RX_DCD_MASK) ==
970 sp->led_state = 0x68;
971 sp->tty->driver->write(sp->tty, &sp->led_state, 1);
974 sp->led_state = 0x60;
975 /* fill trailing bytes with zeroes */
976 sp->tty->driver->write(sp->tty, &sp->led_state, 1);
979 for (i = rest; i <= 3; i++)
982 sp->rx_count_cooked -= 2;
984 sp->rx_count_cooked -= 1;
985 for (i = 0; i < sp->rx_count_cooked; i++)
986 checksum += sp->cooked_buf[i];
987 if (checksum != SIXP_CHKSUM) {
988 printk(KERN_DEBUG "6pack: bad checksum %2.2x\n", checksum);
990 sp->rcount = sp->rx_count_cooked-2;
993 sp->rx_count_cooked = 0;
996 case SIXP_TX_URUN: printk(KERN_DEBUG "6pack: TX underrun\n");
998 case SIXP_RX_ORUN: printk(KERN_DEBUG "6pack: RX overrun\n");
1000 case SIXP_RX_BUF_OVL:
1001 printk(KERN_DEBUG "6pack: RX buffer overflow\n");
1005 /* decode a 6pack packet */
1008 sixpack_decode(struct sixpack *sp, unsigned char *pre_rbuff, int count)
1010 unsigned char inbyte;
1013 for (count1 = 0; count1 < count; count1++) {
1014 inbyte = pre_rbuff[count1];
1015 if (inbyte == SIXP_FOUND_TNC) {
1016 tnc_set_sync_state(sp, TNC_IN_SYNC);
1017 del_timer(&sp->resync_t);
1019 if ((inbyte & SIXP_PRIO_CMD_MASK) != 0)
1020 decode_prio_command(sp, inbyte);
1021 else if ((inbyte & SIXP_STD_CMD_MASK) != 0)
1022 decode_std_command(sp, inbyte);
1023 else if ((sp->status & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)
1024 decode_data(sp, inbyte);
1028 MODULE_AUTHOR("Ralf Baechle DO1GRB <ralf@linux-mips.org>");
1029 MODULE_DESCRIPTION("6pack driver for AX.25");
1030 MODULE_LICENSE("GPL");
1031 MODULE_ALIAS_LDISC(N_6PACK);
1033 module_init(sixpack_init_driver);
1034 module_exit(sixpack_exit_driver);