1/*
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.
5 *
6 * Authors:	Andreas Könsgen <ajk@comnets.uni-bremen.de>
7 *              Ralf Baechle DL5RB <ralf@linux-mips.org>
8 *
9 * Quite a lot of stuff "stolen" by Joerg Reuter from slip.c, written by
10 *
11 *		Laurence Culhane, <loz@holmes.demon.co.uk>
12 *		Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
13 */
14
15#include <linux/module.h>
16#include <asm/uaccess.h>
17#include <linux/bitops.h>
18#include <linux/string.h>
19#include <linux/mm.h>
20#include <linux/interrupt.h>
21#include <linux/in.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>
27#include <net/ax25.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>
34#include <linux/ip.h>
35#include <linux/tcp.h>
36#include <linux/semaphore.h>
37#include <linux/compat.h>
38#include <linux/atomic.h>
39
40#define SIXPACK_VERSION    "Revision: 0.3.0"
41
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 */
47
48#define SIXP_CHKSUM		0xFF	/* valid checksum of a 6pack frame */
49
50/* masks to get certain bits out of the status bytes sent by the TNC */
51
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
62#define SIXP_CON		0x08
63#define SIXP_STA		0x10
64
65#define SIXP_FOUND_TNC		0xe9
66#define SIXP_CON_ON		0x68
67#define SIXP_DCD_MASK		0x08
68#define SIXP_DAMA_OFF		0
69
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 */
76
77/* 6pack configuration. */
78#define SIXP_NRUNIT			31      /* MAX number of 6pack channels */
79#define SIXP_MTU			256	/* Default MTU */
80
81enum sixpack_flags {
82	SIXPF_ERROR,	/* Parity, etc. error	*/
83};
84
85struct sixpack {
86	/* Various fields. */
87	struct tty_struct	*tty;		/* ptr to TTY structure	*/
88	struct net_device	*dev;		/* easy for intr handling  */
89
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  */
96
97	unsigned char		raw_buf[4];
98	unsigned char		cooked_buf[400];
99
100	unsigned int		rx_count;
101	unsigned int		rx_count_cooked;
102
103	int			mtu;		/* Our mtu (to spot changes!) */
104	int			buffsize;       /* Max buffers sizes */
105
106	unsigned long		flags;		/* Flag values/ mode etc */
107	unsigned char		mode;		/* 6pack mode */
108
109	/* 6pack stuff */
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;
120
121	struct timer_list	tx_t;
122	struct timer_list	resync_t;
123	atomic_t		refcnt;
124	struct semaphore	dead_sem;
125	spinlock_t		lock;
126};
127
128#define AX25_6PACK_HEADER_LEN 0
129
130static void sixpack_decode(struct sixpack *, unsigned char[], int);
131static int encode_sixpack(unsigned char *, unsigned char *, int, unsigned char);
132
133/*
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.
137 */
138
139static void sp_xmit_on_air(unsigned long channel)
140{
141	struct sixpack *sp = (struct sixpack *) channel;
142	int actual, when = sp->slottime;
143	static unsigned char random;
144
145	random = random * 17 + 41;
146
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);
150		sp->tx_enable = 1;
151		actual = sp->tty->ops->write(sp->tty, sp->xbuff, sp->status2);
152		sp->xleft -= actual;
153		sp->xhead += actual;
154		sp->led_state = 0x60;
155		sp->tty->ops->write(sp->tty, &sp->led_state, 1);
156		sp->status2 = 0;
157	} else
158		mod_timer(&sp->tx_t, jiffies + ((when + 1) * HZ) / 100);
159}
160
161/* ----> 6pack timer interrupt handler and friends. <---- */
162
163/* Encapsulate one AX.25 frame and stuff into a TTY queue. */
164static void sp_encaps(struct sixpack *sp, unsigned char *icp, int len)
165{
166	unsigned char *msg, *p = icp;
167	int actual, count;
168
169	if (len > sp->mtu) {	/* sp->mtu = AX25_MTU = max. PACLEN = 256 */
170		msg = "oversized transmit packet!";
171		goto out_drop;
172	}
173
174	if (len > sp->mtu) {	/* sp->mtu = AX25_MTU = max. PACLEN = 256 */
175		msg = "oversized transmit packet!";
176		goto out_drop;
177	}
178
179	if (p[0] > 5) {
180		msg = "invalid KISS command";
181		goto out_drop;
182	}
183
184	if ((p[0] != 0) && (len > 2)) {
185		msg = "KISS control packet too long";
186		goto out_drop;
187	}
188
189	if ((p[0] == 0) && (len < 15)) {
190		msg = "bad AX.25 packet to transmit";
191		goto out_drop;
192	}
193
194	count = encode_sixpack(p, sp->xbuff, len, sp->tx_delay);
195	set_bit(TTY_DO_WRITE_WAKEUP, &sp->tty->flags);
196
197	switch (p[0]) {
198	case 1:	sp->tx_delay = p[1];
199		return;
200	case 2:	sp->persistence = p[1];
201		return;
202	case 3:	sp->slottime = p[1];
203		return;
204	case 4:	/* ignored */
205		return;
206	case 5:	sp->duplex = p[1];
207		return;
208	}
209
210	if (p[0] != 0)
211		return;
212
213	/*
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.
218	 */
219	if (sp->duplex == 1) {
220		sp->led_state = 0x70;
221		sp->tty->ops->write(sp->tty, &sp->led_state, 1);
222		sp->tx_enable = 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);
228	} else {
229		sp->xleft = count;
230		sp->xhead = sp->xbuff;
231		sp->status2 = count;
232		sp_xmit_on_air((unsigned long)sp);
233	}
234
235	return;
236
237out_drop:
238	sp->dev->stats.tx_dropped++;
239	netif_start_queue(sp->dev);
240	if (net_ratelimit())
241		printk(KERN_DEBUG "%s: %s - dropped.\n", sp->dev->name, msg);
242}
243
244/* Encapsulate an IP datagram and kick it into a TTY queue. */
245
246static netdev_tx_t sp_xmit(struct sk_buff *skb, struct net_device *dev)
247{
248	struct sixpack *sp = netdev_priv(dev);
249
250	if (skb->protocol == htons(ETH_P_IP))
251		return ax25_ip_xmit(skb);
252
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);
259
260	dev_kfree_skb(skb);
261
262	return NETDEV_TX_OK;
263}
264
265static int sp_open_dev(struct net_device *dev)
266{
267	struct sixpack *sp = netdev_priv(dev);
268
269	if (sp->tty == NULL)
270		return -ENODEV;
271	return 0;
272}
273
274/* Close the low-level part of the 6pack channel. */
275static int sp_close(struct net_device *dev)
276{
277	struct sixpack *sp = netdev_priv(dev);
278
279	spin_lock_bh(&sp->lock);
280	if (sp->tty) {
281		/* TTY discipline is running. */
282		clear_bit(TTY_DO_WRITE_WAKEUP, &sp->tty->flags);
283	}
284	netif_stop_queue(dev);
285	spin_unlock_bh(&sp->lock);
286
287	return 0;
288}
289
290static int sp_set_mac_address(struct net_device *dev, void *addr)
291{
292	struct sockaddr_ax25 *sa = addr;
293
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);
299
300	return 0;
301}
302
303static 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,
308};
309
310static void sp_setup(struct net_device *dev)
311{
312	/* Finish setting up the DEVICE info. */
313	dev->netdev_ops		= &sp_netdev_ops;
314	dev->destructor		= free_netdev;
315	dev->mtu		= SIXP_MTU;
316	dev->hard_header_len	= AX25_MAX_HEADER_LEN;
317	dev->header_ops 	= &ax25_header_ops;
318
319	dev->addr_len		= AX25_ADDR_LEN;
320	dev->type		= ARPHRD_AX25;
321	dev->tx_queue_len	= 10;
322
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);
326
327	dev->flags		= 0;
328}
329
330/* Send one completely decapsulated IP datagram to the IP layer. */
331
332/*
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.
335 */
336
337static void sp_bump(struct sixpack *sp, char cmd)
338{
339	struct sk_buff *skb;
340	int count;
341	unsigned char *ptr;
342
343	count = sp->rcount + 1;
344
345	sp->dev->stats.rx_bytes += count;
346
347	if ((skb = dev_alloc_skb(count)) == NULL)
348		goto out_mem;
349
350	ptr = skb_put(skb, count);
351	*ptr++ = cmd;	/* KISS command */
352
353	memcpy(ptr, sp->cooked_buf + 1, count);
354	skb->protocol = ax25_type_trans(skb, sp->dev);
355	netif_rx(skb);
356	sp->dev->stats.rx_packets++;
357
358	return;
359
360out_mem:
361	sp->dev->stats.rx_dropped++;
362}
363
364
365/* ----------------------------------------------------------------------- */
366
367/*
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.
374 */
375static DEFINE_RWLOCK(disc_data_lock);
376
377static struct sixpack *sp_get(struct tty_struct *tty)
378{
379	struct sixpack *sp;
380
381	read_lock(&disc_data_lock);
382	sp = tty->disc_data;
383	if (sp)
384		atomic_inc(&sp->refcnt);
385	read_unlock(&disc_data_lock);
386
387	return sp;
388}
389
390static void sp_put(struct sixpack *sp)
391{
392	if (atomic_dec_and_test(&sp->refcnt))
393		up(&sp->dead_sem);
394}
395
396/*
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.
399 */
400static void sixpack_write_wakeup(struct tty_struct *tty)
401{
402	struct sixpack *sp = sp_get(tty);
403	int actual;
404
405	if (!sp)
406		return;
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);
412		sp->tx_enable = 0;
413		netif_wake_queue(sp->dev);
414		goto out;
415	}
416
417	if (sp->tx_enable) {
418		actual = tty->ops->write(tty, sp->xhead, sp->xleft);
419		sp->xleft -= actual;
420		sp->xhead += actual;
421	}
422
423out:
424	sp_put(sp);
425}
426
427/* ----------------------------------------------------------------------- */
428
429/*
430 * Handle the 'receiver data ready' interrupt.
431 * This function is called by the 'tty_io' 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.
434 */
435static void sixpack_receive_buf(struct tty_struct *tty,
436	const unsigned char *cp, char *fp, int count)
437{
438	struct sixpack *sp;
439	unsigned char buf[512];
440	int count1;
441
442	if (!count)
443		return;
444
445	sp = sp_get(tty);
446	if (!sp)
447		return;
448
449	memcpy(buf, cp, count < sizeof(buf) ? count : sizeof(buf));
450
451	/* Read the characters out of the buffer */
452
453	count1 = count;
454	while (count) {
455		count--;
456		if (fp && *fp++) {
457			if (!test_and_set_bit(SIXPF_ERROR, &sp->flags))
458				sp->dev->stats.rx_errors++;
459			continue;
460		}
461	}
462	sixpack_decode(sp, buf, count1);
463
464	sp_put(sp);
465	tty_unthrottle(tty);
466}
467
468/*
469 * Try to resync the TNC. Called by the resync timer defined in
470 * decode_prio_command
471 */
472
473#define TNC_UNINITIALIZED	0
474#define TNC_UNSYNC_STARTUP	1
475#define TNC_UNSYNCED		2
476#define TNC_IN_SYNC		3
477
478static void __tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
479{
480	char *msg;
481
482	switch (new_tnc_state) {
483	default:			/* gcc oh piece-o-crap ... */
484	case TNC_UNSYNC_STARTUP:
485		msg = "Synchronizing with TNC";
486		break;
487	case TNC_UNSYNCED:
488		msg = "Lost synchronization with TNC\n";
489		break;
490	case TNC_IN_SYNC:
491		msg = "Found TNC";
492		break;
493	}
494
495	sp->tnc_state = new_tnc_state;
496	printk(KERN_INFO "%s: %s\n", sp->dev->name, msg);
497}
498
499static inline void tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
500{
501	int old_tnc_state = sp->tnc_state;
502
503	if (old_tnc_state != new_tnc_state)
504		__tnc_set_sync_state(sp, new_tnc_state);
505}
506
507static void resync_tnc(unsigned long channel)
508{
509	struct sixpack *sp = (struct sixpack *) channel;
510	static char resync_cmd = 0xe8;
511
512	/* clear any data that might have been received */
513
514	sp->rx_count = 0;
515	sp->rx_count_cooked = 0;
516
517	/* reset state machine */
518
519	sp->status = 1;
520	sp->status1 = 1;
521	sp->status2 = 0;
522
523	/* resync the TNC */
524
525	sp->led_state = 0x60;
526	sp->tty->ops->write(sp->tty, &sp->led_state, 1);
527	sp->tty->ops->write(sp->tty, &resync_cmd, 1);
528
529
530	/* Start resync timer again -- the TNC might be still absent */
531
532	del_timer(&sp->resync_t);
533	sp->resync_t.data	= (unsigned long) sp;
534	sp->resync_t.function	= resync_tnc;
535	sp->resync_t.expires	= jiffies + SIXP_RESYNC_TIMEOUT;
536	add_timer(&sp->resync_t);
537}
538
539static inline int tnc_init(struct sixpack *sp)
540{
541	unsigned char inbyte = 0xe8;
542
543	tnc_set_sync_state(sp, TNC_UNSYNC_STARTUP);
544
545	sp->tty->ops->write(sp->tty, &inbyte, 1);
546
547	del_timer(&sp->resync_t);
548	sp->resync_t.data = (unsigned long) sp;
549	sp->resync_t.function = resync_tnc;
550	sp->resync_t.expires = jiffies + SIXP_RESYNC_TIMEOUT;
551	add_timer(&sp->resync_t);
552
553	return 0;
554}
555
556/*
557 * Open the high-level part of the 6pack channel.
558 * This function is called by the TTY module when the
559 * 6pack line discipline is called for.  Because we are
560 * sure the tty line exists, we only have to link it to
561 * a free 6pcack channel...
562 */
563static int sixpack_open(struct tty_struct *tty)
564{
565	char *rbuff = NULL, *xbuff = NULL;
566	struct net_device *dev;
567	struct sixpack *sp;
568	unsigned long len;
569	int err = 0;
570
571	if (!capable(CAP_NET_ADMIN))
572		return -EPERM;
573	if (tty->ops->write == NULL)
574		return -EOPNOTSUPP;
575
576	dev = alloc_netdev(sizeof(struct sixpack), "sp%d", NET_NAME_UNKNOWN,
577			   sp_setup);
578	if (!dev) {
579		err = -ENOMEM;
580		goto out;
581	}
582
583	sp = netdev_priv(dev);
584	sp->dev = dev;
585
586	spin_lock_init(&sp->lock);
587	atomic_set(&sp->refcnt, 1);
588	sema_init(&sp->dead_sem, 0);
589
590	/* !!! length of the buffers. MTU is IP MTU, not PACLEN!  */
591
592	len = dev->mtu * 2;
593
594	rbuff = kmalloc(len + 4, GFP_KERNEL);
595	xbuff = kmalloc(len + 4, GFP_KERNEL);
596
597	if (rbuff == NULL || xbuff == NULL) {
598		err = -ENOBUFS;
599		goto out_free;
600	}
601
602	spin_lock_bh(&sp->lock);
603
604	sp->tty = tty;
605
606	sp->rbuff	= rbuff;
607	sp->xbuff	= xbuff;
608
609	sp->mtu		= AX25_MTU + 73;
610	sp->buffsize	= len;
611	sp->rcount	= 0;
612	sp->rx_count	= 0;
613	sp->rx_count_cooked = 0;
614	sp->xleft	= 0;
615
616	sp->flags	= 0;		/* Clear ESCAPE & ERROR flags */
617
618	sp->duplex	= 0;
619	sp->tx_delay    = SIXP_TXDELAY;
620	sp->persistence = SIXP_PERSIST;
621	sp->slottime    = SIXP_SLOTTIME;
622	sp->led_state   = 0x60;
623	sp->status      = 1;
624	sp->status1     = 1;
625	sp->status2     = 0;
626	sp->tx_enable   = 0;
627
628	netif_start_queue(dev);
629
630	init_timer(&sp->tx_t);
631	sp->tx_t.function = sp_xmit_on_air;
632	sp->tx_t.data = (unsigned long) sp;
633
634	init_timer(&sp->resync_t);
635
636	spin_unlock_bh(&sp->lock);
637
638	/* Done.  We have linked the TTY line to a channel. */
639	tty->disc_data = sp;
640	tty->receive_room = 65536;
641
642	/* Now we're ready to register. */
643	err = register_netdev(dev);
644	if (err)
645		goto out_free;
646
647	tnc_init(sp);
648
649	return 0;
650
651out_free:
652	kfree(xbuff);
653	kfree(rbuff);
654
655	free_netdev(dev);
656
657out:
658	return err;
659}
660
661
662/*
663 * Close down a 6pack channel.
664 * This means flushing out any pending queues, and then restoring the
665 * TTY line discipline to what it was before it got hooked to 6pack
666 * (which usually is TTY again).
667 */
668static void sixpack_close(struct tty_struct *tty)
669{
670	struct sixpack *sp;
671
672	write_lock_bh(&disc_data_lock);
673	sp = tty->disc_data;
674	tty->disc_data = NULL;
675	write_unlock_bh(&disc_data_lock);
676	if (!sp)
677		return;
678
679	/*
680	 * We have now ensured that nobody can start using ap from now on, but
681	 * we have to wait for all existing users to finish.
682	 */
683	if (!atomic_dec_and_test(&sp->refcnt))
684		down(&sp->dead_sem);
685
686	unregister_netdev(sp->dev);
687
688	del_timer(&sp->tx_t);
689	del_timer(&sp->resync_t);
690
691	/* Free all 6pack frame buffers. */
692	kfree(sp->rbuff);
693	kfree(sp->xbuff);
694}
695
696/* Perform I/O control on an active 6pack channel. */
697static int sixpack_ioctl(struct tty_struct *tty, struct file *file,
698	unsigned int cmd, unsigned long arg)
699{
700	struct sixpack *sp = sp_get(tty);
701	struct net_device *dev;
702	unsigned int tmp, err;
703
704	if (!sp)
705		return -ENXIO;
706	dev = sp->dev;
707
708	switch(cmd) {
709	case SIOCGIFNAME:
710		err = copy_to_user((void __user *) arg, dev->name,
711		                   strlen(dev->name) + 1) ? -EFAULT : 0;
712		break;
713
714	case SIOCGIFENCAP:
715		err = put_user(0, (int __user *) arg);
716		break;
717
718	case SIOCSIFENCAP:
719		if (get_user(tmp, (int __user *) arg)) {
720			err = -EFAULT;
721			break;
722		}
723
724		sp->mode = tmp;
725		dev->addr_len        = AX25_ADDR_LEN;
726		dev->hard_header_len = AX25_KISS_HEADER_LEN +
727		                       AX25_MAX_HEADER_LEN + 3;
728		dev->type            = ARPHRD_AX25;
729
730		err = 0;
731		break;
732
733	 case SIOCSIFHWADDR: {
734		char addr[AX25_ADDR_LEN];
735
736		if (copy_from_user(&addr,
737		                   (void __user *) arg, AX25_ADDR_LEN)) {
738				err = -EFAULT;
739				break;
740			}
741
742			netif_tx_lock_bh(dev);
743			memcpy(dev->dev_addr, &addr, AX25_ADDR_LEN);
744			netif_tx_unlock_bh(dev);
745
746			err = 0;
747			break;
748		}
749
750	default:
751		err = tty_mode_ioctl(tty, file, cmd, arg);
752	}
753
754	sp_put(sp);
755
756	return err;
757}
758
759#ifdef CONFIG_COMPAT
760static long sixpack_compat_ioctl(struct tty_struct * tty, struct file * file,
761				unsigned int cmd, unsigned long arg)
762{
763	switch (cmd) {
764	case SIOCGIFNAME:
765	case SIOCGIFENCAP:
766	case SIOCSIFENCAP:
767	case SIOCSIFHWADDR:
768		return sixpack_ioctl(tty, file, cmd,
769				(unsigned long)compat_ptr(arg));
770	}
771
772	return -ENOIOCTLCMD;
773}
774#endif
775
776static struct tty_ldisc_ops sp_ldisc = {
777	.owner		= THIS_MODULE,
778	.magic		= TTY_LDISC_MAGIC,
779	.name		= "6pack",
780	.open		= sixpack_open,
781	.close		= sixpack_close,
782	.ioctl		= sixpack_ioctl,
783#ifdef CONFIG_COMPAT
784	.compat_ioctl	= sixpack_compat_ioctl,
785#endif
786	.receive_buf	= sixpack_receive_buf,
787	.write_wakeup	= sixpack_write_wakeup,
788};
789
790/* Initialize 6pack control device -- register 6pack line discipline */
791
792static const char msg_banner[]  __initconst = KERN_INFO \
793	"AX.25: 6pack driver, " SIXPACK_VERSION "\n";
794static const char msg_regfail[] __initconst = KERN_ERR  \
795	"6pack: can't register line discipline (err = %d)\n";
796
797static int __init sixpack_init_driver(void)
798{
799	int status;
800
801	printk(msg_banner);
802
803	/* Register the provided line protocol discipline */
804	if ((status = tty_register_ldisc(N_6PACK, &sp_ldisc)) != 0)
805		printk(msg_regfail, status);
806
807	return status;
808}
809
810static const char msg_unregfail[] = KERN_ERR \
811	"6pack: can't unregister line discipline (err = %d)\n";
812
813static void __exit sixpack_exit_driver(void)
814{
815	int ret;
816
817	if ((ret = tty_unregister_ldisc(N_6PACK)))
818		printk(msg_unregfail, ret);
819}
820
821/* encode an AX.25 packet into 6pack */
822
823static int encode_sixpack(unsigned char *tx_buf, unsigned char *tx_buf_raw,
824	int length, unsigned char tx_delay)
825{
826	int count = 0;
827	unsigned char checksum = 0, buf[400];
828	int raw_count = 0;
829
830	tx_buf_raw[raw_count++] = SIXP_PRIO_CMD_MASK | SIXP_TX_MASK;
831	tx_buf_raw[raw_count++] = SIXP_SEOF;
832
833	buf[0] = tx_delay;
834	for (count = 1; count < length; count++)
835		buf[count] = tx_buf[count];
836
837	for (count = 0; count < length; count++)
838		checksum += buf[count];
839	buf[length] = (unsigned char) 0xff - checksum;
840
841	for (count = 0; count <= length; count++) {
842		if ((count % 3) == 0) {
843			tx_buf_raw[raw_count++] = (buf[count] & 0x3f);
844			tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x30);
845		} else if ((count % 3) == 1) {
846			tx_buf_raw[raw_count++] |= (buf[count] & 0x0f);
847			tx_buf_raw[raw_count] =	((buf[count] >> 2) & 0x3c);
848		} else {
849			tx_buf_raw[raw_count++] |= (buf[count] & 0x03);
850			tx_buf_raw[raw_count++] = (buf[count] >> 2);
851		}
852	}
853	if ((length % 3) != 2)
854		raw_count++;
855	tx_buf_raw[raw_count++] = SIXP_SEOF;
856	return raw_count;
857}
858
859/* decode 4 sixpack-encoded bytes into 3 data bytes */
860
861static void decode_data(struct sixpack *sp, unsigned char inbyte)
862{
863	unsigned char *buf;
864
865	if (sp->rx_count != 3) {
866		sp->raw_buf[sp->rx_count++] = inbyte;
867
868		return;
869	}
870
871	buf = sp->raw_buf;
872	sp->cooked_buf[sp->rx_count_cooked++] =
873		buf[0] | ((buf[1] << 2) & 0xc0);
874	sp->cooked_buf[sp->rx_count_cooked++] =
875		(buf[1] & 0x0f) | ((buf[2] << 2) & 0xf0);
876	sp->cooked_buf[sp->rx_count_cooked++] =
877		(buf[2] & 0x03) | (inbyte << 2);
878	sp->rx_count = 0;
879}
880
881/* identify and execute a 6pack priority command byte */
882
883static void decode_prio_command(struct sixpack *sp, unsigned char cmd)
884{
885	unsigned char channel;
886	int actual;
887
888	channel = cmd & SIXP_CHN_MASK;
889	if ((cmd & SIXP_PRIO_DATA_MASK) != 0) {     /* idle ? */
890
891	/* RX and DCD flags can only be set in the same prio command,
892	   if the DCD flag has been set without the RX flag in the previous
893	   prio command. If DCD has not been set before, something in the
894	   transmission has gone wrong. In this case, RX and DCD are
895	   cleared in order to prevent the decode_data routine from
896	   reading further data that might be corrupt. */
897
898		if (((sp->status & SIXP_DCD_MASK) == 0) &&
899			((cmd & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)) {
900				if (sp->status != 1)
901					printk(KERN_DEBUG "6pack: protocol violation\n");
902				else
903					sp->status = 0;
904				cmd &= ~SIXP_RX_DCD_MASK;
905		}
906		sp->status = cmd & SIXP_PRIO_DATA_MASK;
907	} else { /* output watchdog char if idle */
908		if ((sp->status2 != 0) && (sp->duplex == 1)) {
909			sp->led_state = 0x70;
910			sp->tty->ops->write(sp->tty, &sp->led_state, 1);
911			sp->tx_enable = 1;
912			actual = sp->tty->ops->write(sp->tty, sp->xbuff, sp->status2);
913			sp->xleft -= actual;
914			sp->xhead += actual;
915			sp->led_state = 0x60;
916			sp->status2 = 0;
917
918		}
919	}
920
921	/* needed to trigger the TNC watchdog */
922	sp->tty->ops->write(sp->tty, &sp->led_state, 1);
923
924        /* if the state byte has been received, the TNC is present,
925           so the resync timer can be reset. */
926
927	if (sp->tnc_state == TNC_IN_SYNC) {
928		del_timer(&sp->resync_t);
929		sp->resync_t.data	= (unsigned long) sp;
930		sp->resync_t.function	= resync_tnc;
931		sp->resync_t.expires	= jiffies + SIXP_INIT_RESYNC_TIMEOUT;
932		add_timer(&sp->resync_t);
933	}
934
935	sp->status1 = cmd & SIXP_PRIO_DATA_MASK;
936}
937
938/* identify and execute a standard 6pack command byte */
939
940static void decode_std_command(struct sixpack *sp, unsigned char cmd)
941{
942	unsigned char checksum = 0, rest = 0, channel;
943	short i;
944
945	channel = cmd & SIXP_CHN_MASK;
946	switch (cmd & SIXP_CMD_MASK) {     /* normal command */
947	case SIXP_SEOF:
948		if ((sp->rx_count == 0) && (sp->rx_count_cooked == 0)) {
949			if ((sp->status & SIXP_RX_DCD_MASK) ==
950				SIXP_RX_DCD_MASK) {
951				sp->led_state = 0x68;
952				sp->tty->ops->write(sp->tty, &sp->led_state, 1);
953			}
954		} else {
955			sp->led_state = 0x60;
956			/* fill trailing bytes with zeroes */
957			sp->tty->ops->write(sp->tty, &sp->led_state, 1);
958			rest = sp->rx_count;
959			if (rest != 0)
960				 for (i = rest; i <= 3; i++)
961					decode_data(sp, 0);
962			if (rest == 2)
963				sp->rx_count_cooked -= 2;
964			else if (rest == 3)
965				sp->rx_count_cooked -= 1;
966			for (i = 0; i < sp->rx_count_cooked; i++)
967				checksum += sp->cooked_buf[i];
968			if (checksum != SIXP_CHKSUM) {
969				printk(KERN_DEBUG "6pack: bad checksum %2.2x\n", checksum);
970			} else {
971				sp->rcount = sp->rx_count_cooked-2;
972				sp_bump(sp, 0);
973			}
974			sp->rx_count_cooked = 0;
975		}
976		break;
977	case SIXP_TX_URUN: printk(KERN_DEBUG "6pack: TX underrun\n");
978		break;
979	case SIXP_RX_ORUN: printk(KERN_DEBUG "6pack: RX overrun\n");
980		break;
981	case SIXP_RX_BUF_OVL:
982		printk(KERN_DEBUG "6pack: RX buffer overflow\n");
983	}
984}
985
986/* decode a 6pack packet */
987
988static void
989sixpack_decode(struct sixpack *sp, unsigned char *pre_rbuff, int count)
990{
991	unsigned char inbyte;
992	int count1;
993
994	for (count1 = 0; count1 < count; count1++) {
995		inbyte = pre_rbuff[count1];
996		if (inbyte == SIXP_FOUND_TNC) {
997			tnc_set_sync_state(sp, TNC_IN_SYNC);
998			del_timer(&sp->resync_t);
999		}
1000		if ((inbyte & SIXP_PRIO_CMD_MASK) != 0)
1001			decode_prio_command(sp, inbyte);
1002		else if ((inbyte & SIXP_STD_CMD_MASK) != 0)
1003			decode_std_command(sp, inbyte);
1004		else if ((sp->status & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)
1005			decode_data(sp, inbyte);
1006	}
1007}
1008
1009MODULE_AUTHOR("Ralf Baechle DO1GRB <ralf@linux-mips.org>");
1010MODULE_DESCRIPTION("6pack driver for AX.25");
1011MODULE_LICENSE("GPL");
1012MODULE_ALIAS_LDISC(N_6PACK);
1013
1014module_init(sixpack_init_driver);
1015module_exit(sixpack_exit_driver);
1016