Import newax25-2.4.3.patch.1.bz2HEADnewax25-2.4.3-1

And cleanup the *.orig and *.rej files and whitespace errors that are part
of the original patch.

Signed-off-by: Ralf Baechle <ralf@linux-mips.org>

1 files changed, 396 insertions, 504 deletions

diff --git a/drivers/net/hamradio/6pack.c b/drivers/net/hamradio/6pack.c
index 98b941224..9d483d1ea 100644
--- a/drivers/net/hamradio/6pack.c
+++ b/drivers/net/hamradio/6pack.c
@@ -1,11 +1,12 @@
 /*
  * 6pack.c	This module implements the 6pack protocol for kernel-based
  *		devices like TTY. It interfaces between a raw TTY and the
- *		kernel's AX.25 protocol layers.
+ *		kernel's new AX.25 protocol layer.
  *
- * Version:	@(#)6pack.c	0.3.0	04/07/98
+ * Version:	@(#)6pack.c	0.4.0	03/05/2000
  *
  * Authors:	Andreas Könsgen <ajk@iehk.rwth-aachen.de>
+ *		Jens David (rework) <dg1kjd@afthd.tu-darmstadt.de>
  *
  * Quite a lot of stuff "stolen" by Jörg Reuter from slip.c, written by
  *
@@ -28,145 +29,65 @@
 #include <linux/netdevice.h>
 #include <linux/timer.h>
 #include <net/ax25.h>
+#include <net/ax25dev.h>
 #include <linux/etherdevice.h>
 #include <linux/skbuff.h>
 #include <linux/rtnetlink.h>
 #include <linux/if_arp.h>
+#include <linux/if_slip.h>
 #include <linux/init.h>
 #include <linux/ip.h>
 #include <linux/tcp.h>
 
-#define SIXPACK_VERSION    "Revision: 0.3.0"
-
-/* sixpack priority commands */
-#define SIXP_SEOF	0x40	/* start and end of a 6pack frame */
-#define SIXP_TX_URUN	0x48	/* transmit overrun */
-#define SIXP_RX_ORUN	0x50	/* receive overrun */
-#define SIXP_RX_BUF_OVL	0x58	/* receive buffer overflow */
-
-#define SIXP_CHKSUM	0xFF	/* valid checksum of a 6pack frame */
-
-/* masks to get certain bits out of the status bytes sent by the TNC */
-
-#define SIXP_CMD_MASK		0xC0
-#define SIXP_CHN_MASK		0x07
-#define SIXP_PRIO_CMD_MASK	0x80
-#define SIXP_STD_CMD_MASK	0x40
-#define SIXP_PRIO_DATA_MASK	0x38
-#define SIXP_TX_MASK		0x20
-#define SIXP_RX_MASK		0x10
-#define SIXP_RX_DCD_MASK	0x18
-#define SIXP_LEDS_ON		0x78
-#define SIXP_LEDS_OFF		0x60
-#define SIXP_CON		0x08
-#define SIXP_STA		0x10
-
-#define SIXP_FOUND_TNC		0xe9
-#define SIXP_CON_ON		0x68
-#define SIXP_DCD_MASK		0x08
-#define SIXP_DAMA_OFF		0
-
-/* default level 2 parameters */
-#define SIXP_TXDELAY			25	/* in 10 ms */
-#define SIXP_PERSIST			50	/* in 256ths */
-#define SIXP_SLOTTIME			10	/* in 10 ms */
-#define SIXP_INIT_RESYNC_TIMEOUT	150	/* in 10 ms */
-#define SIXP_RESYNC_TIMEOUT		500	/* in 10 ms */
-
-/* 6pack configuration. */
-#define SIXP_NRUNIT			31      /* MAX number of 6pack channels */
-#define SIXP_MTU			256	/* Default MTU */
-
-enum sixpack_flags {
-	SIXPF_INUSE,	/* Channel in use	*/
-	SIXPF_ERROR,	/* Parity, etc. error	*/
-};
+#include "6pack.h"
 
-struct sixpack {
-	int			magic;
-
-	/* Various fields. */
-	struct tty_struct	*tty;		/* ptr to TTY structure		*/
-	struct net_device	*dev;		/* easy for intr handling	*/
-
-	/* These are pointers to the malloc()ed frame buffers. */
-	unsigned char		*rbuff;		/* receiver buffer		*/
-	int			rcount;         /* received chars counter       */
-	unsigned char		*xbuff;		/* transmitter buffer		*/
-	unsigned char		*xhead;         /* pointer to next byte to XMIT */
-	int			xleft;          /* bytes left in XMIT queue     */
-
-	unsigned char		raw_buf[4];
-	unsigned char		cooked_buf[400];
-
-	unsigned int		rx_count;
-	unsigned int		rx_count_cooked;
-
-	/* 6pack interface statistics. */
-	struct net_device_stats stats;
-
-	int			mtu;		/* Our mtu (to spot changes!)   */
-	int			buffsize;       /* Max buffers sizes            */
-
-	unsigned long		flags;		/* Flag values/ mode etc	*/
-	unsigned char		mode;		/* 6pack mode			*/
-
-	/* 6pack stuff */
-	unsigned char		tx_delay;
-	unsigned char		persistance;
-	unsigned char		slottime;
-	unsigned char		duplex;
-	unsigned char		led_state;
-	unsigned char		status;
-	unsigned char		status1;
-	unsigned char		status2;
-	unsigned char		tx_enable;
-	unsigned char		tnc_ok;
-
-	struct timer_list	tx_t;
-	struct timer_list	resync_t;
-};
+#define min(a, b) (((a) < (b)) ? (a) : (b))
+#define max(a, b) (((a) > (b)) ? (a) : (b))
 
-#define AX25_6PACK_HEADER_LEN 0
-#define SIXPACK_MAGIC 0x5304
+/* ----------------------------------------------------------------------- */
 
-typedef struct sixpack_ctrl {
-	struct sixpack	ctrl;			/* 6pack things			*/
-	struct net_device	dev;		/* the device			*/
-} sixpack_ctrl_t;
-static sixpack_ctrl_t **sixpack_ctrls;
+static struct sixpack_ctrl_t **sixpack_ctrls = NULL;
+int sixpack_maxdev = SIXP_NRUNIT; 	/* override with insmod */
 
-int sixpack_maxdev = SIXP_NRUNIT;	/* Can be overridden with insmod! */
-MODULE_PARM(sixpack_maxdev, "i");
-MODULE_PARM_DESC(sixpack_maxdev, "number of 6PACK devices");
+/* ----------------------------------------------------------------------- */
 
-static void sp_start_tx_timer(struct sixpack *);
-static void sp_xmit_on_air(unsigned long);
+/* prototypes */
 static void resync_tnc(unsigned long);
 static void sixpack_decode(struct sixpack *, unsigned char[], int);
-static int encode_sixpack(unsigned char *, unsigned char *, int, unsigned char);
-static int sixpack_init(struct net_device *dev);
-
+static int encode_sixpack(unsigned char *, unsigned char *, int, unsigned int);
 static void decode_prio_command(unsigned char, struct sixpack *);
 static void decode_std_command(unsigned char, struct sixpack *);
 static void decode_data(unsigned char, struct sixpack *);
-
 static int tnc_init(struct sixpack *);
+static unsigned int sixpack_ddi_report_dcd(struct net_device *dev);
+static unsigned int sixpack_ddi_report_ptt(struct net_device *dev);
+static void sixpack_parameter_change_notify(struct net_device *dev, int valueno,
+	int old, int new);
+
+static int sixpack_init(struct net_device *dev);
+
+/* ----------------------------------------------------------------------- */
 
 /* Find a free 6pack channel, and link in this `tty' line. */
-static inline struct sixpack *sp_alloc(void)
+static inline struct sixpack *sp_alloc(struct tty_struct *tty)
 {
-	sixpack_ctrl_t *spp = NULL;
+	struct sixpack_ctrl_t *spp = NULL;
 	int i;
 
-	for (i = 0; i < sixpack_maxdev; i++) {
+	if (sixpack_ctrls == NULL) return NULL;	/* Master array missing ! */
+
+	for (i = 0; i < sixpack_maxdev; i++)
+	{
 		spp = sixpack_ctrls[i];
 
 		if (spp == NULL)
 			break;
 
-		if (!test_and_set_bit(SIXPF_INUSE, &spp->ctrl.flags))
+		if (!spp->ctrl.flags.in_use)
+		{
+			spp->ctrl.flags.in_use = 1;
 			break;
+		}
 	}
 
 	/* Too many devices... */
@@ -174,42 +95,42 @@ static inline struct sixpack *sp_alloc(void)
 		return NULL;
 
 	/* If no channels are available, allocate one */
-	if (!spp &&
-	    (sixpack_ctrls[i] = (sixpack_ctrl_t *)kmalloc(sizeof(sixpack_ctrl_t),
-						    GFP_KERNEL)) != NULL) {
+	if (!spp && (sixpack_ctrls[i] = (struct sixpack_ctrl_t *) kmalloc(sizeof(struct sixpack_ctrl_t), GFP_KERNEL)) != NULL) {
 		spp = sixpack_ctrls[i];
-		memset(spp, 0, sizeof(sixpack_ctrl_t));
+		memset(spp, 0, sizeof(struct sixpack_ctrl_t));
 
 		/* Initialize channel control data */
-		set_bit(SIXPF_INUSE, &spp->ctrl.flags);
-		spp->ctrl.tty         = NULL;
+		spp->ctrl.flags.in_use= 1;
 		sprintf(spp->dev.name, "sp%d", i);
 		spp->dev.base_addr    = i;
-		spp->dev.priv         = (void *) &spp->ctrl;
+		spp->dev.priv         = (void*)&(spp->ctrl);
 		spp->dev.next         = NULL;
 		spp->dev.init         = sixpack_init;
 	}
 
-	if (spp != NULL) {
-		/* register device so that it can be ifconfig'ed       */
-		/* sixpack_init() will be called as a side-effect         */
-		/* SIDE-EFFECT WARNING: sixpack_init() CLEARS spp->ctrl ! */
-
-		if (register_netdev(&spp->dev) == 0) {
-			set_bit(SIXPF_INUSE, &spp->ctrl.flags);
-			spp->ctrl.dev = &spp->dev;
-			spp->dev.priv = (void *) &spp->ctrl;
-			SET_MODULE_OWNER(&spp->dev);
-			return &spp->ctrl;
+	if (spp != NULL)
+	{
+		spp->ctrl.tty         = tty;
+		/*
+		 * register device so that it can be ifconfig'ed
+		 * sixpack_init() will be called as a side-effect
+		 * SIDE-EFFECT WARNING: sixpack_init() CLEARS spp->ctrl !
+		 */
+		if (register_netdev(&(spp->dev)) == 0)
+		{
+			spp->ctrl.flags.in_use = 1;
+			spp->ctrl.dev = &(spp->dev);
+			spp->dev.priv = (void*)&(spp->ctrl);
+			return (&(spp->ctrl));
 		} else {
-			clear_bit(SIXPF_INUSE, &spp->ctrl.flags);
+			spp->ctrl.flags.in_use = 0;
 			printk(KERN_WARNING "sp_alloc() - register_netdev() failure.\n");
 		}
 	}
-
 	return NULL;
 }
 
+/* ----------------------------------------------------------------------- */
 
 /* Free a 6pack channel. */
 static inline void sp_free(struct sixpack *sp)
@@ -218,48 +139,40 @@ static inline void sp_free(struct sixpack *sp)
 	if (sp->rbuff)
 		kfree(sp->rbuff);
 	sp->rbuff = NULL;
-	if (sp->xbuff)
+	if (sp->xbuff) {
 		kfree(sp->xbuff);
+	}
 	sp->xbuff = NULL;
-
-	if (!test_and_clear_bit(SIXPF_INUSE, &sp->flags))
-		printk(KERN_WARNING "%s: sp_free for already free unit.\n", sp->dev->name);
 }
 
+/* ----------------------------------------------------------------------- */
 
 /* Send one completely decapsulated IP datagram to the IP layer. */
-
-/* This is the routine that sends the received data to the kernel AX.25.
-   'cmd' is the KISS command. For AX.25 data, it is zero. */
-
 static void sp_bump(struct sixpack *sp, char cmd)
 {
 	struct sk_buff *skb;
 	int count;
 	unsigned char *ptr;
 
-	count = sp->rcount+1;
-
+	count = sp->rcount;
 	sp->stats.rx_bytes += count;
 
-	if ((skb = dev_alloc_skb(count)) == NULL) {
+	skb = dev_alloc_skb(count);
+	if (skb == NULL)
+	{
 		printk(KERN_DEBUG "%s: memory squeeze, dropping packet.\n", sp->dev->name);
 		sp->stats.rx_dropped++;
 		return;
 	}
-
 	skb->dev = sp->dev;
 	ptr = skb_put(skb, count);
-	*ptr++ = cmd;	/* KISS command */
-
 	memcpy(ptr, (sp->cooked_buf)+1, count);
-	skb->mac.raw = skb->data;
-	skb->protocol = htons(ETH_P_AX25);
+	skb->mac.raw=skb->data;
+	skb->protocol=htons(ETH_P_AX25);
 	netif_rx(skb);
 	sp->stats.rx_packets++;
 }
 
-
 /* ----------------------------------------------------------------------- */
 
 /* Encapsulate one AX.25 frame and stuff into a TTY queue. */
@@ -267,70 +180,38 @@ static void sp_encaps(struct sixpack *sp, unsigned char *icp, int len)
 {
 	unsigned char *p;
 	int actual, count;
+	int tx_delay;
 
-	if (len > sp->mtu) {	/* sp->mtu = AX25_MTU = max. PACLEN = 256 */
-		printk(KERN_DEBUG "%s: truncating oversized transmit packet!\n", sp->dev->name);
+	if (len > sp->mtu) {
+		len = sp->mtu;
+		printk(KERN_DEBUG "%s: dropping oversized transmit packet!\n", sp->dev->name);
 		sp->stats.tx_dropped++;
-		netif_start_queue(sp->dev);
+		netif_wake_queue(sp->dev);
 		return;
 	}
 
 	p = icp;
 
-	if (p[0] > 5) {
-		printk(KERN_DEBUG "%s: invalid KISS command -- dropped\n", sp->dev->name);
-		netif_start_queue(sp->dev);
-		return;
-	}
+	tx_delay = ax25_dev_get_value(sp->dev, AX25_VALUES_MEDIA_TXDELAY);
+	if (tx_delay > 2550) tx_delay = 2550;
 
-	if ((p[0] != 0) && (len > 2)) {
-		printk(KERN_DEBUG "%s: KISS control packet too long -- dropped\n", sp->dev->name);
-		netif_start_queue(sp->dev);
-		return;
-	}
-
-	if ((p[0] == 0) && (len < 15)) {
-		printk(KERN_DEBUG "%s: bad AX.25 packet to transmit -- dropped\n", sp->dev->name);
-		netif_start_queue(sp->dev);
-		sp->stats.tx_dropped++;
-		return;
-	}
-
-	count = encode_sixpack(p, (unsigned char *) sp->xbuff, len, sp->tx_delay);
+	count = encode_sixpack(p, (unsigned char *) sp->xbuff, len, tx_delay);
 	sp->tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
 
-	switch (p[0]) {
-		case 1:	sp->tx_delay = p[1];		return;
-		case 2:	sp->persistance = p[1];		return;
-		case 3: sp->slottime = p[1];		return;
-		case 4: /* ignored */			return;
-		case 5: sp->duplex = p[1];		return;
-	}
+	sp->led_state = 0x70;
+	sp->tty->driver.write(sp->tty, 0, &(sp->led_state), 1);
 
-	if (p[0] == 0) {
-		/* in case of fullduplex or DAMA operation, we don't take care
-		   about the state of the DCD or of any timers, as the determination
-		   of the correct time to send is the job of the AX.25 layer. We send
-		   immediately after data has arrived. */
-		if (sp->duplex == 1) {
-			sp->led_state = 0x70;
-			sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
-			sp->tx_enable = 1;
-			actual = sp->tty->driver.write(sp->tty, 0, sp->xbuff, count);
-			sp->xleft = count - actual;
-			sp->xhead = sp->xbuff + actual;
-			sp->led_state = 0x60;
-			sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
-		} else {
-			sp->xleft = count;
-			sp->xhead = sp->xbuff;
-			sp->status2 = count;
-			if (sp->duplex == 0)
-				sp_start_tx_timer(sp);
-		}
-	}
+	sp->tx_counter++; /* TX counter +1 */
+	sp->tx_enable = 1;
+	actual = sp->tty->driver.write(sp->tty, 0, sp->xbuff, count);
+	sp->xleft = count - actual;
+	sp->xhead = sp->xbuff + actual;
+	sp->led_state = 0x60;
+	sp->tty->driver.write(sp->tty, 0, &(sp->led_state), 1);
 }
 
+/* ----------------------------------------------------------------------- */
+
 /*
  * Called by the TTY driver when there's room for more data.  If we have
  * more packets to send, we send them here.
@@ -341,9 +222,9 @@ static void sixpack_write_wakeup(struct tty_struct *tty)
 	struct sixpack *sp = (struct sixpack *) tty->disc_data;
 
 	/* First make sure we're connected. */
-	if (!sp || sp->magic != SIXPACK_MAGIC ||
-	    !netif_running(sp->dev))
+	if (!sp || !netif_running(sp->dev)) {
 		return;
+	}
 
 	if (sp->xleft <= 0)  {
 		/* Now serial buffer is almost free & we can start
@@ -365,83 +246,36 @@ static void sixpack_write_wakeup(struct tty_struct *tty)
 /* ----------------------------------------------------------------------- */
 
 /* Encapsulate an IP datagram and kick it into a TTY queue. */
-
 static int sp_xmit(struct sk_buff *skb, struct net_device *dev)
 {
 	struct sixpack *sp = (struct sixpack *) dev->priv;
 
 	/* We were not busy, so we are now... :-) */
-	netif_stop_queue(dev);
-	sp->stats.tx_bytes += skb->len;
-	sp_encaps(sp, skb->data, skb->len);
-	dev_kfree_skb(skb);
-	return 0;
-}
-
-
-/* perform the persistence/slottime algorithm for CSMA access. If the persistence
-   check was successful, write the data to the serial driver. Note that in case
-   of DAMA operation, the data is not sent here. */
-
-static void sp_xmit_on_air(unsigned long channel)
-{
-	struct sixpack *sp = (struct sixpack *) channel;
-	int actual;
-	static unsigned char random;
-
-	random = random * 17 + 41;
-
-	if (((sp->status1 & SIXP_DCD_MASK) == 0) && (random < sp->persistance)) {
-		sp->led_state = 0x70;
-		sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
-		sp->tx_enable = 1;
-		actual = sp->tty->driver.write(sp->tty, 0, sp->xbuff, sp->status2);
-		sp->xleft -= actual;
-		sp->xhead += actual;
-		sp->led_state = 0x60;
-		sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
-		sp->status2 = 0;
-	} else
-		sp_start_tx_timer(sp);
-}
-
-
-/* Return the frame type ID */
-static int sp_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
-	  void *daddr, void *saddr, unsigned len)
-{
-#ifdef CONFIG_INET
-	if (type != htons(ETH_P_AX25))
-		return ax25_encapsulate(skb, dev, type, daddr, saddr, len);
-#endif
-	return 0;
-}
-
-
-static int sp_rebuild_header(struct sk_buff *skb)
-{
-#ifdef CONFIG_INET
-	return ax25_rebuild_header(skb);
-#else
+	if (skb != NULL) {
+		netif_stop_queue(dev);
+		sp->stats.tx_bytes += skb->len;
+		sp_encaps(sp, skb->data, skb->len);
+		dev_kfree_skb(skb);
+	}
 	return 0;
-#endif
 }
 
+/* ----------------------------------------------------------------------- */
 
 /* Open the low-level part of the 6pack channel. */
 static int sp_open(struct net_device *dev)
 {
-	struct sixpack *sp = (struct sixpack *) dev->priv;
+	struct sixpack *sp = (struct sixpack*)(dev->priv);
 	unsigned long len;
 
 	if (sp->tty == NULL)
 		return -ENODEV;
-
 	/*
 	 * Allocate the 6pack frame buffers:
 	 *
 	 * rbuff	Receive buffer.
 	 * xbuff	Transmit buffer.
+	 * cbuff        Temporary compression buffer.
 	 */
 
 	/* !!! length of the buffers. MTU is IP MTU, not PACLEN!
@@ -449,62 +283,62 @@ static int sp_open(struct net_device *dev)
 
 	len = dev->mtu * 2;
 
-	if ((sp->rbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL)
+	sp->rbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
+	if (sp->rbuff == NULL)
 		return -ENOMEM;
 
-	if ((sp->xbuff = kmalloc(len + 4, GFP_KERNEL)) == NULL) {
+	sp->xbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
+	if (sp->xbuff == NULL)
+	{
 		kfree(sp->rbuff);
 		return -ENOMEM;
 	}
 
-	sp->mtu	     = AX25_MTU + 73;
-	sp->buffsize = len;
-	sp->rcount   = 0;
-	sp->rx_count = 0;
+	sp->mtu		= SIXP_MTU;
+	sp->buffsize	= len;
+	sp->rcount   	= 0;
+	sp->rx_count	= 0;
 	sp->rx_count_cooked = 0;
-	sp->xleft    = 0;
-
-	sp->flags   &= (1 << SIXPF_INUSE);      /* Clear ESCAPE & ERROR flags */
-
-	sp->duplex = 0;
-	sp->tx_delay    = SIXP_TXDELAY;
-	sp->persistance = SIXP_PERSIST;
-	sp->slottime    = SIXP_SLOTTIME;
+	sp->xleft	= 0;
+	sp->flags.error = 0;
 	sp->led_state   = 0x60;
 	sp->status      = 1;
 	sp->status1     = 1;
 	sp->status2     = 0;
 	sp->tnc_ok      = 0;
 	sp->tx_enable   = 0;
+	sp->tx_counter	= 0;
 
 	netif_start_queue(dev);
 
-	init_timer(&sp->tx_t);
 	init_timer(&sp->resync_t);
 	return 0;
 }
 
+/* ----------------------------------------------------------------------- */
 
 /* Close the low-level part of the 6pack channel. */
 static int sp_close(struct net_device *dev)
 {
-	struct sixpack *sp = (struct sixpack *) dev->priv;
+	struct sixpack *sp = (struct sixpack*)(dev->priv);
 
-	if (sp->tty == NULL)
+	if (sp->tty == NULL) {
 		return -EBUSY;
-
+	}
 	sp->tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
 
 	netif_stop_queue(dev);
 	return 0;
 }
 
+/* ----------------------------------------------------------------------- */
+
 static int sixpack_receive_room(struct tty_struct *tty)
 {
 	return 65536;  /* We can handle an infinite amount of data. :-) */
 }
 
-/* !!! receive state machine */
+/* ----------------------------------------------------------------------- */
 
 /*
  * Handle the 'receiver data ready' interrupt.
@@ -517,38 +351,41 @@ static void sixpack_receive_buf(struct tty_struct *tty, const unsigned char *cp,
 	unsigned char buf[512];
 	unsigned long flags;
 	int count1;
-
 	struct sixpack *sp = (struct sixpack *) tty->disc_data;
 
-	if (!sp || sp->magic != SIXPACK_MAGIC ||
-	    !netif_running(sp->dev) || !count)
+	if (!sp || !netif_running(sp->dev) || !count)
 		return;
 
 	save_flags(flags);
 	cli();
-	memcpy(buf, cp, count<sizeof(buf)? count:sizeof(buf));
+	memcpy(buf, cp, min(count, sizeof(buf)));
 	restore_flags(flags);
 
 	/* Read the characters out of the buffer */
-
 	count1 = count;
-	while (count) {
+	while(count)
+	{
 		count--;
 		if (fp && *fp++) {
-			if (!test_and_set_bit(SIXPF_ERROR, &sp->flags))
+			if (!sp->flags.error)
+			{
+				sp->flags.error = 1;
 				sp->stats.rx_errors++;
+			}
 			continue;
 		}
 	}
 	sixpack_decode(sp, buf, count1);
 }
 
+/* ----------------------------------------------------------------------- */
+
 /*
  * Open the high-level part of the 6pack channel.
  * This function is called by the TTY module when the
  * 6pack line discipline is called for.  Because we are
  * sure the tty line exists, we only have to link it to
- * a free 6pcack channel...
+ * a free 6pack channel...
  */
 static int sixpack_open(struct tty_struct *tty)
 {
@@ -556,35 +393,32 @@ static int sixpack_open(struct tty_struct *tty)
 	int err;
 
 	/* First make sure we're not already connected. */
-
-	if (sp && sp->magic == SIXPACK_MAGIC)
-		return -EEXIST;
+	if (sp) return -EEXIST;
 
 	/* OK.  Find a free 6pack channel to use. */
-	if ((sp = sp_alloc()) == NULL)
+	if ((sp = sp_alloc(tty)) == NULL)
 		return -ENFILE;
 	sp->tty = tty;
+
 	tty->disc_data = sp;
+
 	if (tty->driver.flush_buffer)
 		tty->driver.flush_buffer(tty);
-
 	if (tty->ldisc.flush_buffer)
 		tty->ldisc.flush_buffer(tty);
-
 	/* Restore default settings */
 	sp->dev->type = ARPHRD_AX25;
-
 	/* Perform the low-level 6pack initialization. */
 	if ((err = sp_open(sp->dev)))
 		return err;
+	MOD_INC_USE_COUNT;
 
 	/* Done.  We have linked the TTY line to a channel. */
-
 	tnc_init(sp);
-
 	return sp->dev->base_addr;
 }
 
+/* ----------------------------------------------------------------------- */
 
 /*
  * Close down a 6pack channel.
@@ -597,14 +431,11 @@ static void sixpack_close(struct tty_struct *tty)
 	struct sixpack *sp = (struct sixpack *) tty->disc_data;
 
 	/* First make sure we're connected. */
-	if (!sp || sp->magic != SIXPACK_MAGIC)
-		return;
-
+	if (!sp) return;
 	rtnl_lock();
-	dev_close(sp->dev);
-
-	del_timer(&sp->tx_t);
-	del_timer(&sp->resync_t);
+	if (sp->dev->flags & IFF_UP)
+		dev_close(sp->dev);
+	del_timer(&(sp->resync_t));
 
 	tty->disc_data = 0;
 	sp->tty = NULL;
@@ -612,28 +443,37 @@ static void sixpack_close(struct tty_struct *tty)
 	sp_free(sp);
 	unregister_netdevice(sp->dev);
 	rtnl_unlock();
+	MOD_DEC_USE_COUNT;
 }
 
+/* ----------------------------------------------------------------------- */
 
 static struct net_device_stats *sp_get_stats(struct net_device *dev)
 {
-	struct sixpack *sp = (struct sixpack *) dev->priv;
-	return &sp->stats;
+	struct sixpack *sp = (struct sixpack*) (dev->priv);
+	return (&sp->stats);
 }
 
+/* ----------------------------------------------------------------------- */
 
-static int sp_set_mac_address(struct net_device *dev, void *addr)
+static int sixpack_set_mac_address(struct net_device *dev, void *addr)
 {
-	return copy_from_user(dev->dev_addr, addr, AX25_ADDR_LEN) ? -EFAULT : 0;
+	if (copy_from_user(dev->dev_addr, addr, AX25_ADDR_LEN))
+		return -EFAULT;
+	return 0;
 }
 
-static int sp_set_dev_mac_address(struct net_device *dev, void *addr)
+/* ----------------------------------------------------------------------- */
+
+static int sixpack_dev_set_mac_address(struct net_device *dev, void *addr)
 {
 	struct sockaddr *sa = addr;
+
 	memcpy(dev->dev_addr, sa->sa_data, AX25_ADDR_LEN);
 	return 0;
 }
 
+/* ----------------------------------------------------------------------- */
 
 /* Perform I/O control on an active 6pack channel. */
 static int sixpack_ioctl(struct tty_struct *tty, void *file, int cmd, void *arg)
@@ -642,29 +482,28 @@ static int sixpack_ioctl(struct tty_struct *tty, void *file, int cmd, void *arg)
 	unsigned int tmp;
 
 	/* First make sure we're connected. */
-	if (!sp || sp->magic != SIXPACK_MAGIC)
+	if (!sp)
 		return -EINVAL;
 
 	switch(cmd) {
 	case SIOCGIFNAME:
-		return copy_to_user(arg, sp->dev->name, strlen(sp->dev->name) + 1) ? -EFAULT : 0;
+		if (copy_to_user(arg, sp->dev->name, IFNAMSIZ))
+			return -EFAULT;
+		return 0;
 
 	case SIOCGIFENCAP:
-		return put_user(0, (int *)arg);
+		if (put_user(sp->mode, (int *)arg))
+			return -EFAULT;
+		return 0;
 
 	case SIOCSIFENCAP:
-		if (get_user(tmp, (int *) arg))
+		if (get_user(tmp,(int *)arg))
 			return -EFAULT;
-
 		sp->mode = tmp;
-		sp->dev->addr_len        = AX25_ADDR_LEN;	  /* sizeof an AX.25 addr */
-		sp->dev->hard_header_len = AX25_KISS_HEADER_LEN + AX25_MAX_HEADER_LEN + 3;
-		sp->dev->type            = ARPHRD_AX25;
-
 		return 0;
 
-	 case SIOCSIFHWADDR:
-		return sp_set_mac_address(sp->dev, arg);
+	case SIOCSIFHWADDR:
+		return sixpack_set_mac_address(sp->dev, arg);
 
 	/* Allow stty to read, but not set, the serial port */
 	case TCGETS:
@@ -676,155 +515,115 @@ static int sixpack_ioctl(struct tty_struct *tty, void *file, int cmd, void *arg)
 	}
 }
 
-static int sp_open_dev(struct net_device *dev)
+/* ----------------------------------------------------------------------- */
+
+/* report DCD state to DDI layer */
+static unsigned int sixpack_ddi_report_dcd(struct net_device *dev)
 {
 	struct sixpack *sp = (struct sixpack *) dev->priv;
-	if (sp->tty == NULL)
-		return -ENODEV;
-	return 0;
+	return (sp->status1 & SIXP_DCD_MASK);
 }
 
-/* Fill in our line protocol discipline */
-static struct tty_ldisc sp_ldisc = {
-	magic:		TTY_LDISC_MAGIC,
-	name:		"6pack",
-	open:		sixpack_open,
-	close:		sixpack_close,
-	ioctl:		(int (*)(struct tty_struct *, struct file *,
-			unsigned int, unsigned long)) sixpack_ioctl,
-	receive_buf:	sixpack_receive_buf,
-	receive_room:	sixpack_receive_room,
-	write_wakeup:	sixpack_write_wakeup,
-};
-
-/* Initialize 6pack control device -- register 6pack line discipline */
-
-static const char msg_banner[]  __initdata = KERN_INFO "AX.25: 6pack driver, " SIXPACK_VERSION " (dynamic channels, max=%d)\n";
-static const char msg_invparm[] __initdata = KERN_ERR  "6pack: sixpack_maxdev parameter too large.\n";
-static const char msg_nomem[]   __initdata = KERN_ERR  "6pack: can't allocate sixpack_ctrls[] array! No 6pack available.\n";
-static const char msg_regfail[] __initdata = KERN_ERR  "6pack: can't register line discipline (err = %d)\n";
+/* ----------------------------------------------------------------------- */
 
-static int __init sixpack_init_driver(void)
+/* report PTT state to DDI layer */
+static unsigned int sixpack_ddi_report_ptt(struct net_device *dev)
 {
-	int status;
-
-	/* Do sanity checks on maximum device parameter. */
-	if (sixpack_maxdev < 4)
-		sixpack_maxdev = 4;
-	if (sixpack_maxdev * sizeof(void*) >= KMALLOC_MAXSIZE) {
-	        printk(msg_invparm);
-		return -ENFILE;
-	}
-
-	printk(msg_banner, sixpack_maxdev);
-
-	sixpack_ctrls = (sixpack_ctrl_t **) kmalloc(sizeof(void*)*sixpack_maxdev, GFP_KERNEL);
-	if (sixpack_ctrls == NULL) {
-		printk(msg_nomem);
-		return -ENOMEM;
-	}
+	struct sixpack *sp = (struct sixpack *) dev->priv;
+	return !!sp->tx_counter;
+}
 
-	/* Clear the pointer array, we allocate devices when we need them */
-	memset(sixpack_ctrls, 0, sizeof(void*)*sixpack_maxdev); /* Pointers */
+/* ----------------------------------------------------------------------- */
 
-	/* Register the provided line protocol discipline */
-	if ((status = tty_register_ldisc(N_6PACK, &sp_ldisc)) != 0) {
-		printk(msg_regfail, status);
-		kfree(sixpack_ctrls);
+/* this function if called by DDI layer whenever a parameter changes. */
+static void sixpack_parameter_change_notify(struct net_device *dev, int valueno, int old, int new)
+{
+	struct sixpack *sp = (struct sixpack *) dev->priv;
+	int br;
+
+	switch (valueno) {
+	case AX25_VALUES_MEDIA_RXBITRATE:
+	case AX25_VALUES_MEDIA_TXBITRATE:
+		/*
+		 * If anybody knows how to set TTY's baud rate
+		 * from kernel mode please add it here. We currently
+		 * reject baud rate change requests.
+		 */
+		br = tty_get_baud_rate(sp->tty);
+		ax25_dev_set_value(dev, AX25_VALUES_MEDIA_TXBITRATE, br);
+		ax25_dev_set_value(dev, AX25_VALUES_MEDIA_RXBITRATE, br);
+		break;
+	case AX25_VALUES_MEDIA_TXDELAY:
+	case AX25_VALUES_MEDIA_TXTAIL:
+		if (new >= 2500) ax25_dev_set_value(dev, valueno, 2490);
+		break;
+	case AX25_VALUES_MEDIA_DUPLEX:
+	default:
+		/* just let them do it. */
+		break;
 	}
-
-	return status;
+	return;
 }
 
-static const char msg_unregfail[] __exitdata = KERN_ERR "6pack: can't unregister line discipline (err = %d)\n";
+/* ----------------------------------------------------------------------- */
 
-static void __exit sixpack_exit_driver(void)
+static int sp_open_dev(struct net_device *dev)
 {
-	int i;
+	struct sixpack *sp = (struct sixpack*) (dev->priv);
 
-	if ((i = tty_register_ldisc(N_6PACK, NULL)))
-		printk(msg_unregfail, i);
-
-	for (i = 0; i < sixpack_maxdev; i++) {
-		if (sixpack_ctrls[i]) {
-			/*
-			* VSV = if dev->start==0, then device
-			* unregistered while close proc.
-			*/
-			if (netif_running(&sixpack_ctrls[i]->dev))
-				 unregister_netdev(&sixpack_ctrls[i]->dev);
-
-			kfree(sixpack_ctrls[i]);
-		}
-	}
-	kfree(sixpack_ctrls);
+	if (sp->tty == NULL) return -ENODEV;
+	return 0;
 }
 
+/* ----------------------------------------------------------------------- */
 
-/* Initialize the 6pack driver.  Called by DDI. */
+/* Initialize the 6pack driver.  Called by core/dev.c on registration */
 static int sixpack_init(struct net_device *dev)
 {
 	struct sixpack *sp = (struct sixpack *) dev->priv;
 
-	static char ax25_bcast[AX25_ADDR_LEN] =
-		{'Q'<<1,'S'<<1,'T'<<1,' '<<1,' '<<1,' '<<1,'0'<<1};
-	static char ax25_test[AX25_ADDR_LEN] =
-		{'L'<<1,'I'<<1,'N'<<1,'U'<<1,'X'<<1,' '<<1,'1'<<1};
-
-	if (sp == NULL)		/* Allocation failed ?? */
+	if (sp == NULL)
 		return -ENODEV;
 
 	/* Set up the "6pack Control Block". (And clear statistics) */
-
-	memset(sp, 0, sizeof (struct sixpack));
-	sp->magic  = SIXPACK_MAGIC;
-	sp->dev	   = dev;
+	sp->dev	   		= dev;
 
 	/* Finish setting up the DEVICE info. */
 	dev->mtu		= SIXP_MTU;
 	dev->hard_start_xmit	= sp_xmit;
 	dev->open		= sp_open_dev;
 	dev->stop		= sp_close;
-	dev->hard_header	= sp_header;
+	dev->hard_header	= NULL;
 	dev->get_stats	        = sp_get_stats;
-	dev->set_mac_address    = sp_set_dev_mac_address;
+	dev->set_mac_address    = sixpack_dev_set_mac_address;
 	dev->hard_header_len	= AX25_MAX_HEADER_LEN;
 	dev->addr_len		= AX25_ADDR_LEN;
 	dev->type		= ARPHRD_AX25;
 	dev->tx_queue_len	= 10;
-	dev->rebuild_header	= sp_rebuild_header;
+	dev->rebuild_header	= NULL;
 	dev->tx_timeout		= NULL;
-
-	memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);	/* Only activated in AX.25 mode */
-	memcpy(dev->dev_addr, ax25_test, AX25_ADDR_LEN);	/*    ""      ""       ""    "" */
+	dev->flags		= IFF_BROADCAST | IFF_MULTICAST;
+	AX25_PTR(dev)		= &sp->ax25dev;
+	memset(AX25_PTR(dev), 0, sizeof(struct ax25_dev));
+	AX25_PTR(dev)->hw.fast	= 0;
+	AX25_PTR(dev)->hw.dcd	= sixpack_ddi_report_dcd;
+	AX25_PTR(dev)->hw.ptt	= sixpack_ddi_report_ptt;
+	AX25_PTR(dev)->hw.cts	= NULL;
+	AX25_PTR(dev)->hw.rts	= NULL;
+	AX25_PTR(dev)->hw.parameter_change_notify = sixpack_parameter_change_notify;
+	ax25_dev_set_value(dev, AX25_VALUES_MEDIA_DUPLEX, 0);
+	ax25_dev_set_value(dev, AX25_VALUES_MEDIA_TXDELAY, 200);
+	ax25_dev_set_value(dev, AX25_VALUES_MEDIA_TXTAIL, 20);
+	ax25_dev_set_value(dev, AX25_VALUES_MEDIA_AUTO_ADJUST, 1);
 
 	dev_init_buffers(dev);
-
-	/* New-style flags. */
-	dev->flags		= 0;
-
 	return 0;
 }
 
-
-
-
-/* ----> 6pack timer interrupt handler and friends. <---- */
-static void sp_start_tx_timer(struct sixpack *sp)
-{
-	int when = sp->slottime;
-
-	del_timer(&sp->tx_t);
-	sp->tx_t.data = (unsigned long) sp;
-	sp->tx_t.function = sp_xmit_on_air;
-	sp->tx_t.expires = jiffies + ((when+1)*HZ)/100;
-	add_timer(&sp->tx_t);
-}
-
+/* ----------------------------------------------------------------------- */
 
 /* encode an AX.25 packet into 6pack */
-
-static int encode_sixpack(unsigned char *tx_buf, unsigned char *tx_buf_raw, int length, unsigned char tx_delay)
+int encode_sixpack(unsigned char *tx_buf, unsigned char *tx_buf_raw, int length, unsigned int tx_delay)
 {
 	int count = 0;
 	unsigned char checksum = 0, buf[400];
@@ -833,37 +632,39 @@ static int encode_sixpack(unsigned char *tx_buf, unsigned char *tx_buf_raw, int
 	tx_buf_raw[raw_count++] = SIXP_PRIO_CMD_MASK | SIXP_TX_MASK;
 	tx_buf_raw[raw_count++] = SIXP_SEOF;
 
-	buf[0] = tx_delay;
-	for (count = 1; count < length; count++)
-		buf[count] = tx_buf[count];
+	buf[0] = tx_delay/10;	/* 10 ms units */
+	memcpy(&buf[1], tx_buf, length);
+	length++;
 
-	for (count = 0; count < length; count++)
+	for(count = 0; count < length; count++)
 		checksum += buf[count];
 	buf[length] = (unsigned char) 0xff - checksum;
 
-	for (count = 0; count <= length; count++) {
-		if ((count % 3) == 0) {
+	for(count = 0; count <= length; count++) {
+		if((count % 3) == 0) {
 			tx_buf_raw[raw_count++] = (buf[count] & 0x3f);
 			tx_buf_raw[raw_count] = ((buf[count] >> 2) & 0x30);
-		} else if ((count % 3) == 1) {
+		}
+		else if((count % 3) == 1) {
 			tx_buf_raw[raw_count++] |= (buf[count] & 0x0f);
-			tx_buf_raw[raw_count] =	((buf[count] >> 2) & 0x3c);
+			tx_buf_raw[raw_count] =
+				((buf[count] >> 2) & 0x3c);
 		} else {
 			tx_buf_raw[raw_count++] |= (buf[count] & 0x03);
-			tx_buf_raw[raw_count++] = (buf[count] >> 2);
+			tx_buf_raw[raw_count++] =
+				(buf[count] >> 2);
 		}
 	}
 	if ((length % 3) != 2)
 		raw_count++;
 	tx_buf_raw[raw_count++] = SIXP_SEOF;
-	return raw_count;
+	return(raw_count);
 }
 
+/* ----------------------------------------------------------------------- */
 
 /* decode a 6pack packet */
-
-static void
-sixpack_decode(struct sixpack *sp, unsigned char pre_rbuff[], int count)
+void sixpack_decode(struct sixpack *sp, unsigned char pre_rbuff[], int count)
 {
 	unsigned char inbyte;
 	int count1;
@@ -873,134 +674,147 @@ sixpack_decode(struct sixpack *sp, unsigned char pre_rbuff[], int count)
 		if (inbyte == SIXP_FOUND_TNC) {
 			printk(KERN_INFO "6pack: TNC found.\n");
 			sp->tnc_ok = 1;
-			del_timer(&sp->resync_t);
+			sp->tx_counter = 0;
+			del_timer(&(sp->resync_t));
 		}
-		if ((inbyte & SIXP_PRIO_CMD_MASK) != 0)
+		if ((inbyte & SIXP_PRIO_CMD_MASK) != 0) {
 			decode_prio_command(inbyte, sp);
-		else if ((inbyte & SIXP_STD_CMD_MASK) != 0)
+		} else if((inbyte & SIXP_STD_CMD_MASK) != 0) {
 			decode_std_command(inbyte, sp);
-		else if ((sp->status & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)
+		} else {
 			decode_data(inbyte, sp);
+		}
 	}
 }
 
+/* ----------------------------------------------------------------------- */
+
 static int tnc_init(struct sixpack *sp)
 {
-	unsigned char inbyte = 0xe8;
+	static unsigned char inbyte = 0xe8;
 
 	sp->tty->driver.write(sp->tty, 0, &inbyte, 1);
 
-	del_timer(&sp->resync_t);
+	del_timer(&(sp->resync_t));
 	sp->resync_t.data = (unsigned long) sp;
 	sp->resync_t.function = resync_tnc;
 	sp->resync_t.expires = jiffies + SIXP_RESYNC_TIMEOUT;
-	add_timer(&sp->resync_t);
+	add_timer(&(sp->resync_t));
 
 	return 0;
 }
 
+/* ----------------------------------------------------------------------- */
 
 /* identify and execute a 6pack priority command byte */
-
-static void decode_prio_command(unsigned char cmd, struct sixpack *sp)
+void decode_prio_command(unsigned char cmd, struct sixpack *sp)
 {
 	unsigned char channel;
 	int actual;
+	int duplex;
+	struct net_device *dev = sp->dev;
 
+	duplex = ax25_dev_get_value(dev, AX25_VALUES_MEDIA_DUPLEX);
 	channel = cmd & SIXP_CHN_MASK;
-	if ((cmd & SIXP_PRIO_DATA_MASK) != 0) {     /* idle ? */
-
-	/* RX and DCD flags can only be set in the same prio command,
-	   if the DCD flag has been set without the RX flag in the previous
-	   prio command. If DCD has not been set before, something in the
-	   transmission has gone wrong. In this case, RX and DCD are
-	   cleared in order to prevent the decode_data routine from
-	   reading further data that might be corrupt. */
-
+	if ((cmd & SIXP_PRIO_DATA_MASK) != 0) {
+		/*
+		 * not idle.
+		 * RX and DCD flags can only be set in the same prio command,
+		 * if the DCD flag has been set without the RX flag in the previous
+		 * prio command. If DCD has not been set before, something in the
+		 * transmission has gone wrong. In this case, RX and DCD are
+		 * cleared in order to prevent the decode_data routine from
+		 * reading further data that might be corrupt.
+		 */
 		if (((sp->status & SIXP_DCD_MASK) == 0) &&
 			((cmd & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK)) {
-				if (sp->status != 1)
+				if (sp->status != 1) {
 					printk(KERN_DEBUG "6pack: protocol violation\n");
-				else
+					sp->tnc_ok = 0;
+				} else {
 					sp->status = 0;
+				}
 				cmd &= !SIXP_RX_DCD_MASK;
 		}
 		sp->status = cmd & SIXP_PRIO_DATA_MASK;
-	}
-	else { /* output watchdog char if idle */
-		if ((sp->status2 != 0) && (sp->duplex == 1)) {
+	} else {
+		/* output watchdog char if idle */
+		if ((sp->status2 != 0) && (duplex == 1)) {
 			sp->led_state = 0x70;
-			sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
+			sp->tty->driver.write(sp->tty, 0, &(sp->led_state), 1);
 			sp->tx_enable = 1;
 			actual = sp->tty->driver.write(sp->tty, 0, sp->xbuff, sp->status2);
 			sp->xleft -= actual;
 			sp->xhead += actual;
 			sp->led_state = 0x60;
 			sp->status2 = 0;
-
 		}
 	}
 
-	/* needed to trigger the TNC watchdog */
-	sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
+	if (((cmd & 0xc0) == 0x80) && (cmd & 0x20)) {
+		/* dirty hack for now */
+		if (--sp->tx_counter < 0)
+			sp->tnc_ok = 0;
+	}
 
-        /* if the state byte has been received, the TNC is present,
-           so the resync timer can be reset. */
+	/* needed to trigger the TNC watchdog */
+	sp->tty->driver.write(sp->tty, 0, &(sp->led_state), 1);
 
+        /*
+         * if the state byte has been received, the TNC is present,
+         * so the resync timer can be reset.
+	 */
 	if (sp->tnc_ok == 1) {
-		del_timer(&sp->resync_t);
+		del_timer(&(sp->resync_t));
 		sp->resync_t.data = (unsigned long) sp;
 		sp->resync_t.function = resync_tnc;
 		sp->resync_t.expires = jiffies + SIXP_INIT_RESYNC_TIMEOUT;
-		add_timer(&sp->resync_t);
+		add_timer(&(sp->resync_t));
 	}
 
 	sp->status1 = cmd & SIXP_PRIO_DATA_MASK;
 }
 
-/* try to resync the TNC. Called by the resync timer defined in
-  decode_prio_command */
+/* ----------------------------------------------------------------------- */
 
+/*
+ * try to resync the TNC. Called by the resync timer defined in
+ * decode_prio_command
+ */
 static void resync_tnc(unsigned long channel)
 {
 	static char resync_cmd = 0xe8;
 	struct sixpack *sp = (struct sixpack *) channel;
 
-	printk(KERN_INFO "6pack: resyncing TNC\n");
+	printk(KERN_INFO "6pack: resyncing TNC...\n");
 
 	/* clear any data that might have been received */
-
-	sp->rx_count = 0;
-	sp->rx_count_cooked = 0;
+	sp->rx_count		= 0;
+	sp->rx_count_cooked	= 0;
 
 	/* reset state machine */
-
-	sp->status = 1;
-	sp->status1 = 1;
-	sp->status2 = 0;
-	sp->tnc_ok = 0;
+	sp->status		= 1;
+	sp->status1		= 1;
+	sp->status2		= 0;
+	sp->tnc_ok		= 0;
 
 	/* resync the TNC */
-
 	sp->led_state = 0x60;
-	sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
+	sp->tty->driver.write(sp->tty, 0, &(sp->led_state), 1);
 	sp->tty->driver.write(sp->tty, 0, &resync_cmd, 1);
 
-
 	/* Start resync timer again -- the TNC might be still absent */
-
-	del_timer(&sp->resync_t);
+	del_timer(&(sp->resync_t));
 	sp->resync_t.data = (unsigned long) sp;
 	sp->resync_t.function = resync_tnc;
 	sp->resync_t.expires = jiffies + SIXP_RESYNC_TIMEOUT;
-	add_timer(&sp->resync_t);
+	add_timer(&(sp->resync_t));
 }
 
-
+/* ----------------------------------------------------------------------- */
 
 /* identify and execute a standard 6pack command byte */
-
-static void decode_std_command(unsigned char cmd, struct sixpack *sp)
+void decode_std_command(unsigned char cmd, struct sixpack *sp)
 {
 	unsigned char checksum = 0, rest = 0, channel;
 	short i;
@@ -1009,27 +823,27 @@ static void decode_std_command(unsigned char cmd, struct sixpack *sp)
 	switch (cmd & SIXP_CMD_MASK) {     /* normal command */
 		case SIXP_SEOF:
 			if ((sp->rx_count == 0) && (sp->rx_count_cooked == 0)) {
-				if ((sp->status & SIXP_RX_DCD_MASK) ==
-					SIXP_RX_DCD_MASK) {
+				if ((sp->status & SIXP_RX_DCD_MASK) == SIXP_RX_DCD_MASK) {
 					sp->led_state = 0x68;
-					sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
+					sp->tty->driver.write(sp->tty, 0, &(sp->led_state), 1);
 				}
 			} else {
 				sp->led_state = 0x60;
 				/* fill trailing bytes with zeroes */
-				sp->tty->driver.write(sp->tty, 0, &sp->led_state, 1);
+				sp->tty->driver.write(sp->tty, 0, &(sp->led_state), 1);
 				rest = sp->rx_count;
 				if (rest != 0)
-					 for (i = rest; i <= 3; i++)
+					 for(i=rest; i<=3; i++)
 						decode_data(0, sp);
-				if (rest == 2)
+				if (rest == 2) {
 					sp->rx_count_cooked -= 2;
-				else if (rest == 3)
+				} else if (rest == 3) {
 					sp->rx_count_cooked -= 1;
-				for (i = 0; i < sp->rx_count_cooked; i++)
-					checksum += sp->cooked_buf[i];
+				}
+				for (i=0; i<sp->rx_count_cooked; i++)
+					checksum+=sp->cooked_buf[i];
 				if (checksum != SIXP_CHKSUM) {
-					printk(KERN_DEBUG "6pack: bad checksum %2.2x\n", checksum);
+					sp->stats.rx_crc_errors++;
 				} else {
 					sp->rcount = sp->rx_count_cooked-2;
 					sp_bump(sp, 0);
@@ -1037,24 +851,30 @@ static void decode_std_command(unsigned char cmd, struct sixpack *sp)
 				sp->rx_count_cooked = 0;
 			}
 			break;
-		case SIXP_TX_URUN: printk(KERN_DEBUG "6pack: TX underrun\n");
+
+		case SIXP_TX_URUN:
+			sp->stats.tx_fifo_errors++;
 			break;
-		case SIXP_RX_ORUN: printk(KERN_DEBUG "6pack: RX overrun\n");
+
+		case SIXP_RX_ORUN:
+			sp->stats.rx_over_errors++;
 			break;
+
 		case SIXP_RX_BUF_OVL:
-			printk(KERN_DEBUG "6pack: RX buffer overflow\n");
+			sp->stats.rx_length_errors++;
 	}
 }
 
-/* decode 4 sixpack-encoded bytes into 3 data bytes */
+/* ----------------------------------------------------------------------- */
 
-static void decode_data(unsigned char inbyte, struct sixpack *sp)
+/* decode 4 sixpack-encoded bytes into 3 data bytes */
+void decode_data(unsigned char inbyte, struct sixpack *sp)
 {
 	unsigned char *buf;
 
-	if (sp->rx_count != 3)
+	if (sp->rx_count != 3) {
 		sp->raw_buf[sp->rx_count++] = inbyte;
-	else {
+	} else {
 		buf = sp->raw_buf;
 		sp->cooked_buf[sp->rx_count_cooked++] =
 			buf[0] | ((buf[1] << 2) & 0xc0);
@@ -1066,9 +886,81 @@ static void decode_data(unsigned char inbyte, struct sixpack *sp)
 	}
 }
 
+/* ----------------------------------------------------------------------- */
+
+/* Fill in our line protocol discipline */
+static struct tty_ldisc sp_ldisc = {
+       magic:          TTY_LDISC_MAGIC,
+       name:           "6pack",
+       open:           sixpack_open,
+       close:          sixpack_close,
+       ioctl:          (int (*)(struct tty_struct *, struct file *,
+                       unsigned int, unsigned long)) sixpack_ioctl,
+       receive_buf:    sixpack_receive_buf,
+       receive_room:   sixpack_receive_room,
+       write_wakeup:   sixpack_write_wakeup,
+};
+
+
+/* Initialize 6pack control device -- register 6pack line discipline */
+int __init sixpack_init_ctrl_dev(void)
+{
+	int status;
+
+	/* Do sanity checks on maximum device parameter. */
+	if (sixpack_maxdev < 4) sixpack_maxdev = 4;
+
+	printk(KERN_INFO "AX.25: 6pack driver, %s (dynamic channels, max=%d)\n",
+	       SIXPACK_VERSION, sixpack_maxdev);
+
+	sixpack_ctrls = (struct sixpack_ctrl_t **) kmalloc(sizeof(void *) *sixpack_maxdev, GFP_KERNEL);
+	if (sixpack_ctrls == NULL)
+	{
+		printk(KERN_WARNING "6pack: Can't allocate sixpack_ctrls[] array!  Uaargh! (-> No 6pack available)\n");
+		return -ENOMEM;
+	}
+
+	/* Clear the pointer array, we allocate devices when we need them */
+	memset(sixpack_ctrls, 0, sizeof(void*)*sixpack_maxdev);
+
+	if ((status = tty_register_ldisc(N_6PACK, &sp_ldisc)) != 0)  {
+		printk(KERN_WARNING "6pack: can't register line discipline (err = %d)\n", status);
+		kfree(sixpack_ctrls);
+	}
+
+	return 0;
+}
+
+void __exit sixpack_exit_driver(void)
+{
+	int i;
+
+	if (sixpack_ctrls != NULL) {
+		if ((i = tty_register_ldisc(N_6PACK, NULL)))
+			printk(KERN_WARNING "6pack: can't unregister line discipline (err = %d)\n", i);
+
+		for (i = 0; i < sixpack_maxdev; i++) {
+			if (sixpack_ctrls[i]) {
+				/*
+				 * VSV = if netif_running(), then device
+				 * unregistered while close proc.
+				 */
+				if (netif_running(&(sixpack_ctrls[i]->dev)))
+					unregister_netdev(&(sixpack_ctrls[i]->dev));
+
+				kfree(sixpack_ctrls[i]);
+				sixpack_ctrls[i] = NULL;
+			}
+		}
+		kfree(sixpack_ctrls);
+		sixpack_ctrls = NULL;
+	}
+}
 
 MODULE_AUTHOR("Andreas Könsgen <ajk@ccac.rwth-aachen.de>");
 MODULE_DESCRIPTION("6pack driver for AX.25");
+MODULE_PARM(sixpack_maxdev, "i");
+MODULE_PARM_DESC(sixpack_maxdev, "number of 6PACK devices");
 
-module_init(sixpack_init_driver);
+module_init(sixpack_init_ctrl_dev);
 module_exit(sixpack_exit_driver);