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