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 <linux/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/refcount.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	refcount_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 *, const 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(struct timer_list *t)
 140{
 141	struct sixpack *sp = from_timer(sp, t, tx_t);
 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(&sp->tx_t);
 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->needs_free_netdev	= true;
 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		refcount_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 (refcount_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 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	int count1;
 440
 441	if (!count)
 442		return;
 443
 444	sp = sp_get(tty);
 445	if (!sp)
 446		return;
 447
 448	/* Read the characters out of the buffer */
 449	count1 = count;
 450	while (count) {
 451		count--;
 452		if (fp && *fp++) {
 453			if (!test_and_set_bit(SIXPF_ERROR, &sp->flags))
 454				sp->dev->stats.rx_errors++;
 455			continue;
 456		}
 457	}
 458	sixpack_decode(sp, cp, count1);
 459
 460	sp_put(sp);
 461	tty_unthrottle(tty);
 462}
 463
 464/*
 465 * Try to resync the TNC. Called by the resync timer defined in
 466 * decode_prio_command
 467 */
 468
 469#define TNC_UNINITIALIZED	0
 470#define TNC_UNSYNC_STARTUP	1
 471#define TNC_UNSYNCED		2
 472#define TNC_IN_SYNC		3
 473
 474static void __tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
 475{
 476	char *msg;
 477
 478	switch (new_tnc_state) {
 479	default:			/* gcc oh piece-o-crap ... */
 480	case TNC_UNSYNC_STARTUP:
 481		msg = "Synchronizing with TNC";
 482		break;
 483	case TNC_UNSYNCED:
 484		msg = "Lost synchronization with TNC\n";
 485		break;
 486	case TNC_IN_SYNC:
 487		msg = "Found TNC";
 488		break;
 489	}
 490
 491	sp->tnc_state = new_tnc_state;
 492	printk(KERN_INFO "%s: %s\n", sp->dev->name, msg);
 493}
 494
 495static inline void tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
 496{
 497	int old_tnc_state = sp->tnc_state;
 498
 499	if (old_tnc_state != new_tnc_state)
 500		__tnc_set_sync_state(sp, new_tnc_state);
 501}
 502
 503static void resync_tnc(struct timer_list *t)
 504{
 505	struct sixpack *sp = from_timer(sp, t, resync_t);
 506	static char resync_cmd = 0xe8;
 507
 508	/* clear any data that might have been received */
 509
 510	sp->rx_count = 0;
 511	sp->rx_count_cooked = 0;
 512
 513	/* reset state machine */
 514
 515	sp->status = 1;
 516	sp->status1 = 1;
 517	sp->status2 = 0;
 518
 519	/* resync the TNC */
 520
 521	sp->led_state = 0x60;
 522	sp->tty->ops->write(sp->tty, &sp->led_state, 1);
 523	sp->tty->ops->write(sp->tty, &resync_cmd, 1);
 524
 525
 526	/* Start resync timer again -- the TNC might be still absent */
 527
 528	del_timer(&sp->resync_t);
 529	sp->resync_t.expires	= jiffies + SIXP_RESYNC_TIMEOUT;
 530	add_timer(&sp->resync_t);
 531}
 532
 533static inline int tnc_init(struct sixpack *sp)
 534{
 535	unsigned char inbyte = 0xe8;
 536
 537	tnc_set_sync_state(sp, TNC_UNSYNC_STARTUP);
 538
 539	sp->tty->ops->write(sp->tty, &inbyte, 1);
 540
 541	del_timer(&sp->resync_t);
 542	sp->resync_t.expires = jiffies + SIXP_RESYNC_TIMEOUT;
 543	add_timer(&sp->resync_t);
 544
 545	return 0;
 546}
 547
 548/*
 549 * Open the high-level part of the 6pack channel.
 550 * This function is called by the TTY module when the
 551 * 6pack line discipline is called for.  Because we are
 552 * sure the tty line exists, we only have to link it to
 553 * a free 6pcack channel...
 554 */
 555static int sixpack_open(struct tty_struct *tty)
 556{
 557	char *rbuff = NULL, *xbuff = NULL;
 558	struct net_device *dev;
 559	struct sixpack *sp;
 560	unsigned long len;
 561	int err = 0;
 562
 563	if (!capable(CAP_NET_ADMIN))
 564		return -EPERM;
 565	if (tty->ops->write == NULL)
 566		return -EOPNOTSUPP;
 567
 568	dev = alloc_netdev(sizeof(struct sixpack), "sp%d", NET_NAME_UNKNOWN,
 569			   sp_setup);
 570	if (!dev) {
 571		err = -ENOMEM;
 572		goto out;
 573	}
 574
 575	sp = netdev_priv(dev);
 576	sp->dev = dev;
 577
 578	spin_lock_init(&sp->lock);
 579	refcount_set(&sp->refcnt, 1);
 580	sema_init(&sp->dead_sem, 0);
 581
 582	/* !!! length of the buffers. MTU is IP MTU, not PACLEN!  */
 583
 584	len = dev->mtu * 2;
 585
 586	rbuff = kmalloc(len + 4, GFP_KERNEL);
 587	xbuff = kmalloc(len + 4, GFP_KERNEL);
 588
 589	if (rbuff == NULL || xbuff == NULL) {
 590		err = -ENOBUFS;
 591		goto out_free;
 592	}
 593
 594	spin_lock_bh(&sp->lock);
 595
 596	sp->tty = tty;
 597
 598	sp->rbuff	= rbuff;
 599	sp->xbuff	= xbuff;
 600
 601	sp->mtu		= AX25_MTU + 73;
 602	sp->buffsize	= len;
 603	sp->rcount	= 0;
 604	sp->rx_count	= 0;
 605	sp->rx_count_cooked = 0;
 606	sp->xleft	= 0;
 607
 608	sp->flags	= 0;		/* Clear ESCAPE & ERROR flags */
 609
 610	sp->duplex	= 0;
 611	sp->tx_delay    = SIXP_TXDELAY;
 612	sp->persistence = SIXP_PERSIST;
 613	sp->slottime    = SIXP_SLOTTIME;
 614	sp->led_state   = 0x60;
 615	sp->status      = 1;
 616	sp->status1     = 1;
 617	sp->status2     = 0;
 618	sp->tx_enable   = 0;
 619
 620	netif_start_queue(dev);
 621
 622	timer_setup(&sp->tx_t, sp_xmit_on_air, 0);
 623
 624	timer_setup(&sp->resync_t, resync_tnc, 0);
 625
 626	spin_unlock_bh(&sp->lock);
 627
 628	/* Done.  We have linked the TTY line to a channel. */
 629	tty->disc_data = sp;
 630	tty->receive_room = 65536;
 631
 632	/* Now we're ready to register. */
 633	err = register_netdev(dev);
 634	if (err)
 635		goto out_free;
 636
 637	tnc_init(sp);
 638
 639	return 0;
 640
 641out_free:
 642	kfree(xbuff);
 643	kfree(rbuff);
 644
 645	free_netdev(dev);
 646
 647out:
 648	return err;
 649}
 650
 651
 652/*
 653 * Close down a 6pack channel.
 654 * This means flushing out any pending queues, and then restoring the
 655 * TTY line discipline to what it was before it got hooked to 6pack
 656 * (which usually is TTY again).
 657 */
 658static void sixpack_close(struct tty_struct *tty)
 659{
 660	struct sixpack *sp;
 661
 662	write_lock_bh(&disc_data_lock);
 663	sp = tty->disc_data;
 664	tty->disc_data = NULL;
 665	write_unlock_bh(&disc_data_lock);
 666	if (!sp)
 667		return;
 668
 669	/*
 670	 * We have now ensured that nobody can start using ap from now on, but
 671	 * we have to wait for all existing users to finish.
 672	 */
 673	if (!refcount_dec_and_test(&sp->refcnt))
 674		down(&sp->dead_sem);
 675
 676	/* We must stop the queue to avoid potentially scribbling
 677	 * on the free buffers. The sp->dead_sem is not sufficient
 678	 * to protect us from sp->xbuff access.
 679	 */
 680	netif_stop_queue(sp->dev);
 681
 682	del_timer_sync(&sp->tx_t);
 683	del_timer_sync(&sp->resync_t);
 684
 685	/* Free all 6pack frame buffers. */
 686	kfree(sp->rbuff);
 687	kfree(sp->xbuff);
 688
 689	unregister_netdev(sp->dev);
 690}
 691
 692/* Perform I/O control on an active 6pack channel. */
 693static int sixpack_ioctl(struct tty_struct *tty, struct file *file,
 694	unsigned int cmd, unsigned long arg)
 695{
 696	struct sixpack *sp = sp_get(tty);
 697	struct net_device *dev;
 698	unsigned int tmp, err;
 699
 700	if (!sp)
 701		return -ENXIO;
 702	dev = sp->dev;
 703
 704	switch(cmd) {
 705	case SIOCGIFNAME:
 706		err = copy_to_user((void __user *) arg, dev->name,
 707		                   strlen(dev->name) + 1) ? -EFAULT : 0;
 708		break;
 709
 710	case SIOCGIFENCAP:
 711		err = put_user(0, (int __user *) arg);
 712		break;
 713
 714	case SIOCSIFENCAP:
 715		if (get_user(tmp, (int __user *) arg)) {
 716			err = -EFAULT;
 717			break;
 718		}
 719
 720		sp->mode = tmp;
 721		dev->addr_len        = AX25_ADDR_LEN;
 722		dev->hard_header_len = AX25_KISS_HEADER_LEN +
 723		                       AX25_MAX_HEADER_LEN + 3;
 724		dev->type            = ARPHRD_AX25;
 725
 726		err = 0;
 727		break;
 728
 729	 case SIOCSIFHWADDR: {
 730		char addr[AX25_ADDR_LEN];
 731
 732		if (copy_from_user(&addr,
 733		                   (void __user *) arg, AX25_ADDR_LEN)) {
 734				err = -EFAULT;
 735				break;
 736			}
 737
 738			netif_tx_lock_bh(dev);
 739			memcpy(dev->dev_addr, &addr, AX25_ADDR_LEN);
 740			netif_tx_unlock_bh(dev);
 741
 742			err = 0;
 743			break;
 744		}
 745
 746	default:
 747		err = tty_mode_ioctl(tty, file, cmd, arg);
 748	}
 749
 750	sp_put(sp);
 751
 752	return err;
 753}
 754
 755#ifdef CONFIG_COMPAT
 756static long sixpack_compat_ioctl(struct tty_struct * tty, struct file * file,
 757				unsigned int cmd, unsigned long arg)
 758{
 759	switch (cmd) {
 760	case SIOCGIFNAME:
 761	case SIOCGIFENCAP:
 762	case SIOCSIFENCAP:
 763	case SIOCSIFHWADDR:
 764		return sixpack_ioctl(tty, file, cmd,
 765				(unsigned long)compat_ptr(arg));
 766	}
 767
 768	return -ENOIOCTLCMD;
 769}
 770#endif
 771
 772static struct tty_ldisc_ops sp_ldisc = {
 773	.owner		= THIS_MODULE,
 774	.magic		= TTY_LDISC_MAGIC,
 775	.name		= "6pack",
 776	.open		= sixpack_open,
 777	.close		= sixpack_close,
 778	.ioctl		= sixpack_ioctl,
 779#ifdef CONFIG_COMPAT
 780	.compat_ioctl	= sixpack_compat_ioctl,
 781#endif
 782	.receive_buf	= sixpack_receive_buf,
 783	.write_wakeup	= sixpack_write_wakeup,
 784};
 785
 786/* Initialize 6pack control device -- register 6pack line discipline */
 787
 788static const char msg_banner[]  __initconst = KERN_INFO \
 789	"AX.25: 6pack driver, " SIXPACK_VERSION "\n";
 790static const char msg_regfail[] __initconst = KERN_ERR  \
 791	"6pack: can't register line discipline (err = %d)\n";
 792
 793static int __init sixpack_init_driver(void)
 794{
 795	int status;
 796
 797	printk(msg_banner);
 798
 799	/* Register the provided line protocol discipline */
 800	if ((status = tty_register_ldisc(N_6PACK, &sp_ldisc)) != 0)
 801		printk(msg_regfail, status);
 802
 803	return status;
 804}
 805
 806static const char msg_unregfail[] = KERN_ERR \
 807	"6pack: can't unregister line discipline (err = %d)\n";
 808
 809static void __exit sixpack_exit_driver(void)
 810{
 811	int ret;
 812
 813	if ((ret = tty_unregister_ldisc(N_6PACK)))
 814		printk(msg_unregfail, ret);
 815}
 816
 817/* encode an AX.25 packet into 6pack */
 818
 819static int encode_sixpack(unsigned char *tx_buf, unsigned char *tx_buf_raw,
 820	int length, unsigned char tx_delay)
 821{
 822	int count = 0;
 823	unsigned char checksum = 0, buf[400];
 824	int raw_count = 0;
 825
 826	tx_buf_raw[raw_count++] = SIXP_PRIO_CMD_MASK | SIXP_TX_MASK;
 827	tx_buf_raw[raw_count++] = SIXP_SEOF;
 828
 829	buf[0] = tx_delay;
 830	for (count = 1; count < length; count++)
 831		buf[count] = tx_buf[count];
 832
 833	for (count = 0; count < length; count++)
 834		checksum += buf[count];
 835	buf[length] = (unsigned char) 0xff - checksum;
 836
 837	for (count = 0; count <= length; count++) {
 838		if ((count % 3) == 0) {
 839			tx_buf_raw[raw_count++] = (buf[count] & 0x3f);
 840			tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x30);
 841		} else if ((count % 3) == 1) {
 842			tx_buf_raw[raw_count++] |= (buf[count] & 0x0f);
 843			tx_buf_raw[raw_count] =	((buf[count] >> 2) & 0x3c);
 844		} else {
 845			tx_buf_raw[raw_count++] |= (buf[count] & 0x03);
 846			tx_buf_raw[raw_count++] = (buf[count] >> 2);
 847		}
 848	}
 849	if ((length % 3) != 2)
 850		raw_count++;
 851	tx_buf_raw[raw_count++] = SIXP_SEOF;
 852	return raw_count;
 853}
 854
 855/* decode 4 sixpack-encoded bytes into 3 data bytes */
 856
 857static void decode_data(struct sixpack *sp, unsigned char inbyte)
 858{
 859	unsigned char *buf;
 860
 861	if (sp->rx_count != 3) {
 862		sp->raw_buf[sp->rx_count++] = inbyte;
 863
 864		return;
 865	}
 866
 867	buf = sp->raw_buf;
 868	sp->cooked_buf[sp->rx_count_cooked++] =
 869		buf[0] | ((buf[1] << 2) & 0xc0);
 870	sp->cooked_buf[sp->rx_count_cooked++] =
 871		(buf[1] & 0x0f) | ((buf[2] << 2) & 0xf0);
 872	sp->cooked_buf[sp->rx_count_cooked++] =
 873		(buf[2] & 0x03) | (inbyte << 2);
 874	sp->rx_count = 0;
 875}
 876
 877/* identify and execute a 6pack priority command byte */
 878
 879static void decode_prio_command(struct sixpack *sp, unsigned char cmd)
 880{
 881	unsigned char channel;
 882	int actual;
 883
 884	channel = cmd & SIXP_CHN_MASK;
 885	if ((cmd & SIXP_PRIO_DATA_MASK) != 0) {     /* idle ? */
 886
 887	/* RX and DCD flags can only be set in the same prio command,
 888	   if the DCD flag has been set without the RX flag in the previous
 889	   prio command. If DCD has not been set before, something in the
 890	   transmission has gone wrong. In this case, RX and DCD are
 891	   cleared in order to prevent the decode_data routine from
 892	   reading further data that might be corrupt. */
 893
 894		if (((sp->status & SIXP_DCD_MASK) == 0) &&
 895			((cmd & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)) {
 896				if (sp->status != 1)
 897					printk(KERN_DEBUG "6pack: protocol violation\n");
 898				else
 899					sp->status = 0;
 900				cmd &= ~SIXP_RX_DCD_MASK;
 901		}
 902		sp->status = cmd & SIXP_PRIO_DATA_MASK;
 903	} else { /* output watchdog char if idle */
 904		if ((sp->status2 != 0) && (sp->duplex == 1)) {
 905			sp->led_state = 0x70;
 906			sp->tty->ops->write(sp->tty, &sp->led_state, 1);
 907			sp->tx_enable = 1;
 908			actual = sp->tty->ops->write(sp->tty, sp->xbuff, sp->status2);
 909			sp->xleft -= actual;
 910			sp->xhead += actual;
 911			sp->led_state = 0x60;
 912			sp->status2 = 0;
 913
 914		}
 915	}
 916
 917	/* needed to trigger the TNC watchdog */
 918	sp->tty->ops->write(sp->tty, &sp->led_state, 1);
 919
 920        /* if the state byte has been received, the TNC is present,
 921           so the resync timer can be reset. */
 922
 923	if (sp->tnc_state == TNC_IN_SYNC) {
 924		del_timer(&sp->resync_t);
 925		sp->resync_t.expires	= jiffies + SIXP_INIT_RESYNC_TIMEOUT;
 926		add_timer(&sp->resync_t);
 927	}
 928
 929	sp->status1 = cmd & SIXP_PRIO_DATA_MASK;
 930}
 931
 932/* identify and execute a standard 6pack command byte */
 933
 934static void decode_std_command(struct sixpack *sp, unsigned char cmd)
 935{
 936	unsigned char checksum = 0, rest = 0, channel;
 937	short i;
 938
 939	channel = cmd & SIXP_CHN_MASK;
 940	switch (cmd & SIXP_CMD_MASK) {     /* normal command */
 941	case SIXP_SEOF:
 942		if ((sp->rx_count == 0) && (sp->rx_count_cooked == 0)) {
 943			if ((sp->status & SIXP_RX_DCD_MASK) ==
 944				SIXP_RX_DCD_MASK) {
 945				sp->led_state = 0x68;
 946				sp->tty->ops->write(sp->tty, &sp->led_state, 1);
 947			}
 948		} else {
 949			sp->led_state = 0x60;
 950			/* fill trailing bytes with zeroes */
 951			sp->tty->ops->write(sp->tty, &sp->led_state, 1);
 952			rest = sp->rx_count;
 953			if (rest != 0)
 954				 for (i = rest; i <= 3; i++)
 955					decode_data(sp, 0);
 956			if (rest == 2)
 957				sp->rx_count_cooked -= 2;
 958			else if (rest == 3)
 959				sp->rx_count_cooked -= 1;
 960			for (i = 0; i < sp->rx_count_cooked; i++)
 961				checksum += sp->cooked_buf[i];
 962			if (checksum != SIXP_CHKSUM) {
 963				printk(KERN_DEBUG "6pack: bad checksum %2.2x\n", checksum);
 964			} else {
 965				sp->rcount = sp->rx_count_cooked-2;
 966				sp_bump(sp, 0);
 967			}
 968			sp->rx_count_cooked = 0;
 969		}
 970		break;
 971	case SIXP_TX_URUN: printk(KERN_DEBUG "6pack: TX underrun\n");
 972		break;
 973	case SIXP_RX_ORUN: printk(KERN_DEBUG "6pack: RX overrun\n");
 974		break;
 975	case SIXP_RX_BUF_OVL:
 976		printk(KERN_DEBUG "6pack: RX buffer overflow\n");
 977	}
 978}
 979
 980/* decode a 6pack packet */
 981
 982static void
 983sixpack_decode(struct sixpack *sp, const unsigned char *pre_rbuff, int count)
 984{
 985	unsigned char inbyte;
 986	int count1;
 987
 988	for (count1 = 0; count1 < count; count1++) {
 989		inbyte = pre_rbuff[count1];
 990		if (inbyte == SIXP_FOUND_TNC) {
 991			tnc_set_sync_state(sp, TNC_IN_SYNC);
 992			del_timer(&sp->resync_t);
 993		}
 994		if ((inbyte & SIXP_PRIO_CMD_MASK) != 0)
 995			decode_prio_command(sp, inbyte);
 996		else if ((inbyte & SIXP_STD_CMD_MASK) != 0)
 997			decode_std_command(sp, inbyte);
 998		else if ((sp->status & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)
 999			decode_data(sp, inbyte);
1000	}
1001}
1002
1003MODULE_AUTHOR("Ralf Baechle DO1GRB <ralf@linux-mips.org>");
1004MODULE_DESCRIPTION("6pack driver for AX.25");
1005MODULE_LICENSE("GPL");
1006MODULE_ALIAS_LDISC(N_6PACK);
1007
1008module_init(sixpack_init_driver);
1009module_exit(sixpack_exit_driver);