Merge tp1.ruhr-uni-bochum.de:/home/kai/src/kernel/v2.5/linux-2.5

into tp1.ruhr-uni-bochum.de:/home/kai/src/kernel/v2.5/linux-2.5.isdn

14 files changed, 2120 insertions, 2325 deletions

diff --git a/drivers/isdn/i4l/Makefile b/drivers/isdn/i4l/Makefile
index 407501c0d6b1..58c4e6d3ed35 100644
--- a/drivers/isdn/i4l/Makefile
+++ b/drivers/isdn/i4l/Makefile
@@ -19,7 +19,7 @@ isdn-objs				:= isdn_net.o isdn_net_lib.o \
 
 # Optional parts of multipart objects.
 
-isdn-objs-$(CONFIG_ISDN_PPP)		+= isdn_ppp.o
+isdn-objs-$(CONFIG_ISDN_PPP)		+= isdn_ppp.o isdn_ppp_ccp.o
 isdn-objs-$(CONFIG_ISDN_X25)		+= isdn_concap.o isdn_x25iface.o
 isdn-objs-$(CONFIG_ISDN_AUDIO)		+= isdn_audio.o
 isdn-objs-$(CONFIG_ISDN_TTY_FAX)	+= isdn_ttyfax.o
diff --git a/drivers/isdn/i4l/isdn_bsdcomp.c b/drivers/isdn/i4l/isdn_bsdcomp.c
index 6049970e1f2a..c48275b76141 100644
--- a/drivers/isdn/i4l/isdn_bsdcomp.c
+++ b/drivers/isdn/i4l/isdn_bsdcomp.c
@@ -907,16 +907,15 @@ static int bsd_decompress (void *state, struct sk_buff *skb_in, struct sk_buff *
  *************************************************************/
 
 static struct isdn_ppp_compressor ippp_bsd_compress = {
-	NULL,NULL,		/* prev,next: overwritten by isdn_ppp */
-	CI_BSD_COMPRESS,	/* compress_proto */
-	bsd_alloc,		/* alloc */
-	bsd_free,		/* free */
-	bsd_init,		/* init */
-	bsd_reset,		/* reset */
-	bsd_compress,		/* compress */
-	bsd_decompress,		/* decompress */
-	bsd_incomp,		/* incomp */
-	bsd_stats		/* comp_stat */
+	.num            = CI_BSD_COMPRESS,
+	.alloc          = bsd_alloc,
+	.free           = bsd_free,
+	.init           = bsd_init,
+	.reset          = bsd_reset,
+	.compress       = bsd_compress,
+	.decompress     = bsd_decompress,
+	.incomp         = bsd_incomp,
+	.stat           = bsd_stats,
 };
 
 /*************************************************************
diff --git a/drivers/isdn/i4l/isdn_ciscohdlck.c b/drivers/isdn/i4l/isdn_ciscohdlck.c
index 0f08f3daea88..cab5b1a2100f 100644
--- a/drivers/isdn/i4l/isdn_ciscohdlck.c
+++ b/drivers/isdn/i4l/isdn_ciscohdlck.c
@@ -20,6 +20,19 @@
 #include <linux/if_arp.h>
 #include <linux/inetdevice.h>
 
+/*
+ * Definitions for Cisco-HDLC header.
+ */
+
+#define CISCO_ADDR_UNICAST    0x0f
+#define CISCO_ADDR_BROADCAST  0x8f
+#define CISCO_CTRL            0x00
+#define CISCO_TYPE_CDP        0x2000
+#define CISCO_TYPE_SLARP      0x8035
+#define CISCO_SLARP_REQUEST   0
+#define CISCO_SLARP_REPLY     1
+#define CISCO_SLARP_KEEPALIVE 2
+
 /* 
  * CISCO HDLC keepalive specific stuff
  */
diff --git a/drivers/isdn/i4l/isdn_common.h b/drivers/isdn/i4l/isdn_common.h
index 3c81ffcb5d80..64e1c1e9c819 100644
--- a/drivers/isdn/i4l/isdn_common.h
+++ b/drivers/isdn/i4l/isdn_common.h
@@ -47,7 +47,7 @@
 #endif
 
 #define isdn_BUG() \
-do { printk(KERN_WARNING "ISDN Bug at %s:%d\n", __FILE__, __LINE__); \
+do { printk(KERN_WARNING "ISDN BUG at %s:%d\n", __FILE__, __LINE__); \
 } while(0)
 
 #define HERE printk("%s:%d (%s)\n", __FILE__, __LINE__, __FUNCTION__)
diff --git a/drivers/isdn/i4l/isdn_net.c b/drivers/isdn/i4l/isdn_net.c
index 4b504da722de..f41603c1287d 100644
--- a/drivers/isdn/i4l/isdn_net.c
+++ b/drivers/isdn/i4l/isdn_net.c
@@ -33,412 +33,8 @@
 #include "isdn_concap.h"
 #include "isdn_ciscohdlck.h"
 
-/*
- * Outline of new tbusy handling: 
- *
- * Old method, roughly spoken, consisted of setting tbusy when entering
- * isdn_net_start_xmit() and at several other locations and clearing
- * it from isdn_net_start_xmit() thread when sending was successful.
- *
- * With 2.3.x multithreaded network core, to prevent problems, tbusy should
- * only be set by the isdn_net_start_xmit() thread and only when a tx-busy
- * condition is detected. Other threads (in particular isdn_net_stat_callb())
- * are only allowed to clear tbusy.
- *
- * -HE
- */
-
-/*
- * About SOFTNET:
- * Most of the changes were pretty obvious and basically done by HE already.
- *
- * One problem of the isdn net device code is that is uses struct net_device
- * for masters and slaves. However, only master interface are registered to 
- * the network layer, and therefore, it only makes sense to call netif_* 
- * functions on them.
- *
- * --KG
- */
-
-/* 
- * Find out if the netdevice has been ifup-ed yet.
- */
-static inline int
-isdn_net_device_started(isdn_net_dev *idev)
-{
-	return netif_running(&idev->mlp->dev);
-}
-
-/*
- * stop the network -> net_device queue.
- */
-static inline void
-isdn_net_dev_stop_queue(isdn_net_dev *idev)
-{
-	netif_stop_queue(&idev->mlp->dev);
-}
-
-/*
- * find out if the net_device which this lp belongs to (lp can be
- * master or slave) is busy. It's busy iff all (master and slave) 
- * queues are busy
- */
-static inline int
-isdn_net_device_busy(isdn_net_dev *idev)
-{
-	isdn_net_local *mlp = idev->mlp;
-	unsigned long flags;
-	int retval = 1;
-
-	if (!isdn_net_dev_busy(idev))
-		return 0;
-
-	spin_lock_irqsave(&mlp->online_lock, flags);
-	list_for_each_entry(idev, &mlp->online, online) {
-		if (!isdn_net_dev_busy(idev)) {
-			retval = 0;
-			break;
-		}
-	}
-	spin_unlock_irqrestore(&mlp->online_lock, flags);
-	return retval;
-}
-
-static inline
-void isdn_net_inc_frame_cnt(isdn_net_dev *idev)
-{
-	atomic_inc(&idev->frame_cnt);
-	if (isdn_net_device_busy(idev))
-		isdn_net_dev_stop_queue(idev);
-}
-
-static inline void
-isdn_net_dec_frame_cnt(isdn_net_dev *idev)
-{
-	atomic_dec(&idev->frame_cnt);
-
-	if (!isdn_net_device_busy(idev)) {
-		if (!skb_queue_empty(&idev->super_tx_queue))
-			tasklet_schedule(&idev->tlet);
-		else
-			isdn_net_dev_wake_queue(idev);
-       }                                                                      
-}
-
-static inline
-void isdn_net_zero_frame_cnt(isdn_net_dev *idev)
-{
-	atomic_set(&idev->frame_cnt, 0);
-}
-
-/* Prototypes */
-
-int isdn_net_handle_event(isdn_net_dev *idev, int pr, void *arg);
-
 char *isdn_net_revision = "$Revision: 1.140.6.11 $";
 
-/* A packet has successfully been sent out. */
-
-int
-isdn_net_bsent(isdn_net_dev *idev, isdn_ctrl *c)
-{
-	isdn_net_local *mlp = idev->mlp;
-
-	isdn_net_dec_frame_cnt(idev);
-	mlp->stats.tx_packets++;
-	mlp->stats.tx_bytes += c->parm.length;
-	return 1;
-}
-
-static void
-isdn_net_unreachable(struct net_device *dev, struct sk_buff *skb, char *reason)
-{
-	u_short proto = ntohs(skb->protocol);
-	
-	printk(KERN_DEBUG "isdn_net: %s: %s, signalling dst_link_failure %s\n",
-	       dev->name,
-	       (reason != NULL) ? reason : "unknown",
-	       (proto != ETH_P_IP) ? "Protocol != ETH_P_IP" : "");
-	
-	dst_link_failure(skb);
-}
-
-static void
-isdn_net_log_skb(struct sk_buff *skb, isdn_net_dev *idev)
-{
-	unsigned char *p = skb->nh.raw; /* hopefully, this was set correctly */
-	unsigned short proto = ntohs(skb->protocol);
-	int data_ofs;
-	struct ip_ports {
-		unsigned short source;
-		unsigned short dest;
-	} *ipp;
-	char addinfo[100];
-
-	data_ofs = ((p[0] & 15) * 4);
-	switch (proto) {
-	case ETH_P_IP:
-		switch (p[9]) {
-		case IPPROTO_ICMP:
-			strcpy(addinfo, "ICMP");
-			break;
-		case IPPROTO_TCP:
-		case IPPROTO_UDP:
-			ipp = (struct ip_ports *) (&p[data_ofs]);
-			sprintf(addinfo, "%s, port: %d -> %d",
-				p[9] == IPPROTO_TCP ? "TCP" : "UDP",
-				ntohs(ipp->source), ntohs(ipp->dest));
-			break;
-		default:
-			sprintf(addinfo, "type %d", p[9]);
-		}
-		printk(KERN_INFO
-		       "OPEN: %u.%u.%u.%u -> %u.%u.%u.%u %s\n",
-		       
-		       NIPQUAD(*(u32 *)(p + 12)), NIPQUAD(*(u32 *)(p + 16)),
-		       addinfo);
-		break;
-	case ETH_P_ARP:
-		printk(KERN_INFO
-		       "OPEN: ARP %d.%d.%d.%d -> *.*.*.* ?%d.%d.%d.%d\n",
-		       NIPQUAD(*(u32 *)(p + 14)), NIPQUAD(*(u32 *)(p + 24)));
-		break;
-	default:
-		printk(KERN_INFO "OPEN: unknown proto %#x\n", proto);
-	}
-}
-
-/*
- * this function is used to send supervisory data, i.e. data which was
- * not received from the network layer, but e.g. frames from ipppd, CCP
- * reset frames etc.
- */
-void
-isdn_net_write_super(isdn_net_dev *idev, struct sk_buff *skb)
-{
-	if (in_irq()) {
-		// we can't grab the lock from irq context, 
-		// so we just queue the packet
-		skb_queue_tail(&idev->super_tx_queue, skb); 
-
-		tasklet_schedule(&idev->tlet);
-		return;
-	}
-
-	spin_lock_bh(&idev->xmit_lock);
-	if (!isdn_net_dev_busy(idev)) {
-		isdn_net_writebuf_skb(idev, skb);
-	} else {
-		skb_queue_tail(&idev->super_tx_queue, skb);
-	}
-	spin_unlock_bh(&idev->xmit_lock);
-}
-
-/* 
- * all frames sent from the (net) LL to a HL driver should go via this function
- * it's serialized by the caller holding the idev->xmit_lock spinlock
- */
-void isdn_net_writebuf_skb(isdn_net_dev *idev, struct sk_buff *skb)
-{
-	isdn_net_local *mlp = idev->mlp;
-	int ret;
-	int len = skb->len;     /* save len */
-
-	/* before obtaining the lock the caller should have checked that
-	   the lp isn't busy */
-	if (isdn_net_dev_busy(idev)) {
-		isdn_BUG();
-		goto error;
-	}
-
-	if (!isdn_net_online(idev)) {
-		isdn_BUG();
-		goto error;
-	}
-	ret = isdn_slot_write(idev->isdn_slot, skb);
-	if (ret != len) {
-		/* we should never get here */
-		printk(KERN_WARNING "%s: HL driver queue full\n", idev->name);
-		goto error;
-	}
-	
-	idev->transcount += len;
-	isdn_net_inc_frame_cnt(idev);
-	return;
-
- error:
-	dev_kfree_skb(skb);
-	mlp->stats.tx_errors++;
-}
-
-static void
-isdn_net_dial_slave(isdn_net_local *mlp)
-{
-	isdn_net_dev *idev;
-
-	list_for_each_entry(idev, &mlp->slaves, slaves) {
-		if (!isdn_net_bound(idev)) {
-			isdn_net_dial(idev);
-			break;
-		}
-	}
-}
-
-/*
- *  Based on cps-calculation, check if device is overloaded.
- *  If so, and if a slave exists, trigger dialing for it.
- *  If any slave is online, deliver packets using a simple round robin
- *  scheme.
- *
- *  Return: 0 on success, !0 on failure.
- */
-
-int
-isdn_net_start_xmit(struct sk_buff *skb, struct net_device *ndev)
-{
-	isdn_net_dev *idev;
-	isdn_net_local *mlp = ndev->priv;
-
-	ndev->trans_start = jiffies;
-
-	if (list_empty(&mlp->online))
-		return isdn_net_autodial(skb, ndev);
-
-	idev = isdn_net_get_locked_dev(mlp);
-	if (!idev) {
-		printk(KERN_WARNING "%s: all channels busy - requeuing!\n", ndev->name);
-		netif_stop_queue(ndev);
-		return 1;
-	}
-	/* we have our idev locked from now on */
-
-	isdn_net_writebuf_skb(idev, skb);
-	spin_unlock_bh(&idev->xmit_lock);
-
-	/* the following stuff is here for backwards compatibility.
-	 * in future, start-up and hangup of slaves (based on current load)
-	 * should move to userspace and get based on an overall cps
-	 * calculation
-	 */
-	if (jiffies != idev->last_jiffies) {
-		idev->cps = idev->transcount * HZ / (jiffies - idev->last_jiffies);
-		idev->last_jiffies = jiffies;
-		idev->transcount = 0;
-	}
-	if (dev->net_verbose > 3)
-		printk(KERN_DEBUG "%s: %d bogocps\n", idev->name, idev->cps);
-
-	if (idev->cps > mlp->triggercps) {
-		if (!idev->sqfull) {
-			/* First time overload: set timestamp only */
-			idev->sqfull = 1;
-			idev->sqfull_stamp = jiffies;
-		} else {
-			/* subsequent overload: if slavedelay exceeded, start dialing */
-			if (time_after(jiffies, idev->sqfull_stamp + mlp->slavedelay)) {
-				isdn_net_dial_slave(mlp);
-			}
-		}
-	} else {
-		if (idev->sqfull && time_after(jiffies, idev->sqfull_stamp + mlp->slavedelay + 10 * HZ)) {
-			idev->sqfull = 0;
-		}
-		/* this is a hack to allow auto-hangup for slaves on moderate loads */
-		list_del(&mlp->online);
-		list_add_tail(&mlp->online, &idev->online);
-	}
-
-	return 0;
-}
-
-int
-isdn_net_autodial(struct sk_buff *skb, struct net_device *ndev)
-{
-	isdn_net_local *mlp = ndev->priv;
-	isdn_net_dev *idev = list_entry(mlp->slaves.next, isdn_net_dev, slaves);
-
-	/* are we dialing already? */
-	if (isdn_net_bound(idev))
-		goto stop_queue;
-
-	if (ISDN_NET_DIALMODE(*mlp) != ISDN_NET_DM_AUTO)
-		goto discard;
-
-	if (isdn_net_dial(idev) < 0)
-		goto discard;
-
-	/* Log packet, which triggered dialing */
-	if (dev->net_verbose)
-		isdn_net_log_skb(skb, idev);
-
- stop_queue:
-	netif_stop_queue(ndev);
-	return 1;
-
- discard:
-	isdn_net_unreachable(ndev, skb, "dial rejected");
-	dev_kfree_skb(skb);
-	return 0;
-}
-
-
-/*
- * Got a packet from ISDN-Channel.
- */
-static void
-isdn_net_receive(isdn_net_dev *idev, struct sk_buff *skb)
-{
-	isdn_net_local *mlp = idev->mlp;
-
-	idev->transcount += skb->len;
-
-	mlp->stats.rx_packets++;
-	mlp->stats.rx_bytes += skb->len;
-	skb->dev = &mlp->dev;
-	skb->pkt_type = PACKET_HOST;
-	skb->mac.raw = skb->data;
-	isdn_dumppkt("R:", skb->data, skb->len, 40);
-
-	mlp->ops->receive(mlp, idev, skb);
-}
-
-/*
- * A packet arrived via ISDN. Search interface-chain for a corresponding
- * interface. If found, deliver packet to receiver-function and return 1,
- * else return 0.
- */
-int
-isdn_net_rcv_skb(int idx, struct sk_buff *skb)
-{
-	isdn_net_dev *idev = isdn_slot_idev(idx);
-
-	if (!idev) {
-		HERE;
-		return 0;
-	}
-	if (!isdn_net_online(idev))
-		return 0;
-
-	isdn_net_receive(idev, skb);
-	return 0;
-}
-
-/*
- * This is called from certain upper protocol layers (multilink ppp
- * and x25iface encapsulation module) that want to initiate dialing
- * themselves.
- */
-int
-isdn_net_dial_req(isdn_net_dev *idev)
-{
-	isdn_net_local *mlp = idev->mlp;
-	/* is there a better error code? */
-	if (ISDN_NET_DIALMODE(*mlp) != ISDN_NET_DM_AUTO)
-		return -EBUSY;
-
-	return isdn_net_dial(idev);
-}
-
 // ISDN_NET_ENCAP_IPTYP
 // ethernet type field
 // ======================================================================
@@ -581,6 +177,8 @@ static struct isdn_netif_ops ether_ops = {
 void
 isdn_net_init(void)
 {
+	isdn_net_lib_init();
+
 	register_isdn_netif(ISDN_NET_ENCAP_ETHER,      &ether_ops);
 	register_isdn_netif(ISDN_NET_ENCAP_RAWIP,      &rawip_ops);
 	register_isdn_netif(ISDN_NET_ENCAP_IPTYP,      &iptyp_ops);
@@ -593,7 +191,11 @@ isdn_net_init(void)
 #ifdef CONFIG_ISDN_PPP
 	register_isdn_netif(ISDN_NET_ENCAP_SYNCPPP,    &isdn_ppp_ops);
 #endif
+}
 
-	isdn_net_lib_init();
+void
+isdn_net_exit(void)
+{
+	isdn_net_lib_exit();
 }
 
diff --git a/drivers/isdn/i4l/isdn_net.h b/drivers/isdn/i4l/isdn_net.h
index 16a443f584dd..14f94befc91f 100644
--- a/drivers/isdn/i4l/isdn_net.h
+++ b/drivers/isdn/i4l/isdn_net.h
@@ -14,138 +14,29 @@
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
 #include <linux/isdn.h>
-  			      /* Definitions for hupflags:                */
-#define ISDN_CHARGEHUP   4      /* We want to use the charge mechanism      */
-#define ISDN_INHUP       8      /* Even if incoming, close after huptimeout */
-#define ISDN_MANCHARGE  16      /* Charge Interval manually set             */
 
-/*
- * Definitions for Cisco-HDLC header.
- */
-
-#define CISCO_ADDR_UNICAST    0x0f
-#define CISCO_ADDR_BROADCAST  0x8f
-#define CISCO_CTRL            0x00
-#define CISCO_TYPE_CDP        0x2000
-#define CISCO_TYPE_SLARP      0x8035
-#define CISCO_SLARP_REQUEST   0
-#define CISCO_SLARP_REPLY     1
-#define CISCO_SLARP_KEEPALIVE 2
-
-extern void isdn_net_init(void);
-extern void isdn_net_exit(void);
-extern void isdn_net_lib_init(void);
-extern void isdn_net_lib_exit(void);
-extern void isdn_net_hangup_all(void);
-extern int isdn_net_ioctl(struct inode *, struct file *, uint, ulong);
-
-extern int register_isdn_netif(int encap, struct isdn_netif_ops *ops);
-extern int isdn_net_autodial(struct sk_buff *skb, struct net_device *ndev);
-extern int isdn_net_start_xmit(struct sk_buff *skb, struct net_device *ndev);
-
-extern int  isdn_net_dial(isdn_net_dev *idev);
-
-extern int  isdn_net_bsent(isdn_net_dev *idev, isdn_ctrl *c);
-
-extern int isdn_net_stat_callback(int, isdn_ctrl *);
-extern int isdn_net_find_icall(int, int, int, setup_parm *);
-extern int isdn_net_hangup(isdn_net_dev *);
-extern int isdn_net_rcv_skb(int, struct sk_buff *);
-extern int isdn_net_dial_req(isdn_net_dev *);
-extern void isdn_net_writebuf_skb(isdn_net_dev *, struct sk_buff *skb);
-extern void isdn_net_write_super(isdn_net_dev *, struct sk_buff *skb);
-extern int isdn_net_online(isdn_net_dev *);
-
-enum {
-	ST_CHARGE_NULL,
-	ST_CHARGE_GOT_CINF,  /* got a first charge info */
-	ST_CHARGE_HAVE_CINT, /* got a second chare info and thus the timing */
-};
-
-#define ISDN_NET_MAX_QUEUE_LENGTH 2
-
-/*
- * is this particular channel busy?
- */
-static inline int
-isdn_net_dev_busy(isdn_net_dev *idev)
-{
-	if (atomic_read(&idev->frame_cnt) < ISDN_NET_MAX_QUEUE_LENGTH)
-		return 0;
-	else 
-		return 1;
-}
-
-/*
- * For the given net device, this will get a non-busy channel out of the
- * corresponding bundle. The returned channel is locked.
- */
-static inline isdn_net_dev *
-isdn_net_get_locked_dev(isdn_net_local *mlp)
-{
-	unsigned long flags;
-	isdn_net_dev *idev;
-
-	spin_lock_irqsave(&mlp->online_lock, flags);
-
-	list_for_each_entry(idev, &mlp->online, online) {
-		spin_lock_bh(&idev->xmit_lock);
-		if (!isdn_net_dev_busy(idev)) {
-			/* point the head to next online channel */
-			list_del(&mlp->online);
-			list_add(&mlp->online, &idev->online);
-			goto found;
-		}
-		spin_unlock_bh(&idev->xmit_lock);
-	}
-	idev = NULL;
-
- found:
-	spin_unlock_irqrestore(&mlp->online_lock, flags);
-	return idev;
-}
-
-/*
- * add a channel to a bundle
- */
-static inline void
-isdn_net_add_to_bundle(isdn_net_local *mlp, isdn_net_dev *idev)
-{
-	unsigned long flags;
-
-	spin_lock_irqsave(&mlp->online_lock, flags);
-	list_add(&idev->online, &mlp->online);
-	spin_unlock_irqrestore(&mlp->online_lock, flags);
-}
-/*
- * remove a channel from the bundle it belongs to
- */
-static inline void
-isdn_net_rm_from_bundle(isdn_net_dev *idev)
-{
-	isdn_net_local *mlp = idev->mlp;
-	unsigned long flags;
-
-	spin_lock_irqsave(&mlp->online_lock, flags);
-	//	list_del(&idev->online); FIXME
-	spin_unlock_irqrestore(&mlp->online_lock, flags);
-}
-
-/*
- * wake up the network -> net_device queue.
- * For slaves, wake the corresponding master interface.
- */
-static inline void
-isdn_net_dev_wake_queue(isdn_net_dev *idev)
-{
-	netif_wake_queue(&idev->mlp->dev);
-}
-
-static inline int
-isdn_net_bound(isdn_net_dev *idev)
-{
-	return idev->isdn_slot >= 0;
-}
+void isdn_net_init(void);
+void isdn_net_exit(void);
+void isdn_net_lib_init(void);
+void isdn_net_lib_exit(void);
+void isdn_net_hangup_all(void);
+int  isdn_net_ioctl(struct inode *, struct file *, uint, ulong);
+
+int  register_isdn_netif(int encap, struct isdn_netif_ops *ops);
+int  isdn_net_start_xmit(struct sk_buff *skb, struct net_device *ndev);
+void isdn_net_online(isdn_net_dev *idev);
+void isdn_net_offline(isdn_net_dev *idev);
+
+int  isdn_net_stat_callback(int, isdn_ctrl *);
+int  isdn_net_find_icall(int, int, int, setup_parm *);
+int  isdn_net_rcv_skb(int, struct sk_buff *);
+
+int  isdn_net_hangup(isdn_net_dev *);
+int  isdn_net_dial_req(isdn_net_dev *);
+void isdn_net_writebuf_skb(isdn_net_dev *, struct sk_buff *skb);
+void isdn_net_write_super(isdn_net_dev *, struct sk_buff *skb);
+int  isdn_net_autodial(struct sk_buff *skb, struct net_device *ndev);
+isdn_net_dev *isdn_net_get_xmit_dev(isdn_net_local *mlp);
 
 static inline int
 put_u8(unsigned char *p, u8 x)
diff --git a/drivers/isdn/i4l/isdn_net_lib.c b/drivers/isdn/i4l/isdn_net_lib.c
index 4cb417240aae..ba0144200c1f 100644
--- a/drivers/isdn/i4l/isdn_net_lib.c
+++ b/drivers/isdn/i4l/isdn_net_lib.c
@@ -80,12 +80,13 @@ lp_put(isdn_net_local *lp)
 		isdn_BUG();
 }
 
-int isdn_net_handle_event(isdn_net_dev *idev, int pr, void *arg); /* FIXME */
-
+static int isdn_net_handle_event(isdn_net_dev *idev, int pr, void *arg);
 static void isdn_net_tasklet(unsigned long data);
 static void isdn_net_dial_timer(unsigned long data);
 static int isdn_init_netif(struct net_device *ndev);
 static void isdn_net_dev_debug(struct fsm_inst *fi, char *fmt, ...);
+static int isdn_net_dial(isdn_net_dev *idev);
+static int isdn_net_bsent(isdn_net_dev *idev, isdn_ctrl *c);
 
 static struct fsm isdn_net_fsm;
 
@@ -151,6 +152,18 @@ static char *isdn_net_ev_str[] = {
 	"EV_DO_ACCEPT",
 };
 
+/* Definitions for hupflags: */
+
+#define ISDN_CHARGEHUP   4      /* We want to use the charge mechanism      */
+#define ISDN_INHUP       8      /* Even if incoming, close after huptimeout */
+#define ISDN_MANCHARGE  16      /* Charge Interval manually set             */
+
+enum {
+	ST_CHARGE_NULL,
+	ST_CHARGE_GOT_CINF,  /* got a first charge info */
+	ST_CHARGE_HAVE_CINT, /* got a second chare info and thus the timing */
+};
+
 /* ====================================================================== */
 /* Registration of ISDN network interface types                           */
 /* ====================================================================== */
@@ -208,7 +221,8 @@ isdn_net_set_encap(isdn_net_local *lp, int encap)
 	if (lp->ops && lp->ops->cleanup)
 		lp->ops->cleanup(lp);
 
-	if (encap < 0 || encap >= ISDN_NET_ENCAP_NR) {
+	if (encap < 0 || encap >= ISDN_NET_ENCAP_NR ||
+	    !isdn_netif_ops[encap]) {
 		lp->p_encap = -1;
 		lp->ops = NULL;
 		retval = -EINVAL;
@@ -348,7 +362,6 @@ isdn_net_addif(char *name, isdn_net_local *mlp)
 	strcpy(idev->name, name);
 
 	tasklet_init(&idev->tlet, isdn_net_tasklet, (unsigned long) idev);
-	spin_lock_init(&idev->xmit_lock);
 	skb_queue_head_init(&idev->super_tx_queue);
 
 	idev->isdn_slot = -1;
@@ -356,7 +369,7 @@ isdn_net_addif(char *name, isdn_net_local *mlp)
 	idev->pre_channel = -1;
 	idev->exclusive = -1;
 
-	idev->ppp_slot = -1;
+	idev->ipppd = NULL;
 	idev->pppbind = -1;
 
 	init_timer(&idev->dial_timer);
@@ -380,6 +393,7 @@ isdn_net_addif(char *name, isdn_net_local *mlp)
 		mlp->magic = ISDN_NET_MAGIC;
 		INIT_LIST_HEAD(&mlp->slaves);
 		INIT_LIST_HEAD(&mlp->online);
+		spin_lock_init(&mlp->xmit_lock);
 
 		mlp->p_encap = -1;
 		isdn_net_set_encap(mlp, ISDN_NET_ENCAP_RAWIP);
@@ -1007,7 +1021,7 @@ isdn_net_hangup_all(void)
  * Remove all network-interfaces
  */
 void
-isdn_net_exit(void)
+isdn_net_cleanup(void)
 {
 	isdn_net_dev *idev;
 	int retval;
@@ -1025,9 +1039,6 @@ isdn_net_exit(void)
 			isdn_BUG();
 	}
 	up(&sem);
-
-	// FIXME
-	isdn_net_lib_exit();
 }
 
 /* ====================================================================== */
@@ -1053,7 +1064,7 @@ isdn_net_open(struct net_device *dev)
 	if (lp->ops->open)
 		retval = lp->ops->open(lp);
 
-	if (!retval)
+	if (retval)
 		return retval;
 	
 	netif_start_queue(dev);
@@ -1069,7 +1080,6 @@ isdn_net_open(struct net_device *dev)
 /*
  * Shutdown a net-interface.
  */
-// FIXME share?
 static int
 isdn_net_close(struct net_device *dev)
 {
@@ -1083,14 +1093,14 @@ isdn_net_close(struct net_device *dev)
 
 	netif_stop_queue(dev);
 
-	list_for_each_safe(l, n, &lp->online) {
-		sdev = list_entry(l, isdn_net_dev, online);
+	list_for_each_safe(l, n, &lp->slaves) {
+		sdev = list_entry(l, isdn_net_dev, slaves);
 		isdn_net_hangup(sdev);
 	}
 	/* The hangup will make the refcnt drop back to
 	 * 1 (referenced by list only) soon. */
 	spin_lock_irqsave(&running_devs_lock, flags);
-	while (atomic_read(&dev->refcnt) != 1) {
+	while (atomic_read(&lp->refcnt) != 1) {
 		spin_unlock_irqrestore(&running_devs_lock, flags);
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		schedule_timeout(HZ/10);
@@ -1147,29 +1157,12 @@ isdn_init_netif(struct net_device *ndev)
 }
 
 /* ====================================================================== */
-
-static void
-isdn_net_tasklet(unsigned long data)
-{
-	isdn_net_dev *idev = (isdn_net_dev *) data;
-	struct sk_buff *skb;
-
-	spin_lock_bh(&idev->xmit_lock);
-	while (!isdn_net_dev_busy(idev)) {
-		skb = skb_dequeue(&idev->super_tx_queue);
-		if (!skb)
-			break;
-		isdn_net_writebuf_skb(idev, skb);
-	}
-	spin_unlock_bh(&idev->xmit_lock);
-}
-
-/* ====================================================================== */
 /* call control state machine                                             */
 /* ====================================================================== */
 
 // FIXME
-int isdn_net_online(isdn_net_dev *idev)
+static int
+isdn_net_is_connected(isdn_net_dev *idev)
 {
 	return idev->fi.state == ST_ACTIVE;
 }
@@ -1234,7 +1227,7 @@ isdn_net_bind_channel(isdn_net_dev *idev, int slot)
 	return retval;
 }
 
-int
+static int
 isdn_net_dial(isdn_net_dev *idev)
 {
 	int retval;
@@ -1250,6 +1243,127 @@ isdn_net_dial(isdn_net_dev *idev)
 	return retval;
 }
 
+static void
+isdn_net_unreachable(struct net_device *dev, struct sk_buff *skb, char *reason)
+{
+	u_short proto = ntohs(skb->protocol);
+	
+	printk(KERN_DEBUG "isdn_net: %s: %s, signalling dst_link_failure %s\n",
+	       dev->name,
+	       (reason != NULL) ? reason : "unknown",
+	       (proto != ETH_P_IP) ? "Protocol != ETH_P_IP" : "");
+	
+	dst_link_failure(skb);
+}
+
+/*
+ * This is called from certain upper protocol layers (multilink ppp
+ * and x25iface encapsulation module) that want to initiate dialing
+ * themselves.
+ */
+int
+isdn_net_dial_req(isdn_net_dev *idev)
+{
+	isdn_net_local *mlp = idev->mlp;
+	/* is there a better error code? */
+	if (ISDN_NET_DIALMODE(*mlp) != ISDN_NET_DM_AUTO)
+		return -EBUSY;
+
+	return isdn_net_dial(idev);
+}
+
+static void
+isdn_net_log_skb(struct sk_buff *skb, isdn_net_dev *idev)
+{
+	unsigned char *p = skb->nh.raw; /* hopefully, this was set correctly */
+	unsigned short proto = ntohs(skb->protocol);
+	int data_ofs;
+	struct ip_ports {
+		unsigned short source;
+		unsigned short dest;
+	} *ipp;
+	char addinfo[100];
+
+	data_ofs = ((p[0] & 15) * 4);
+	switch (proto) {
+	case ETH_P_IP:
+		switch (p[9]) {
+		case IPPROTO_ICMP:
+			strcpy(addinfo, "ICMP");
+			break;
+		case IPPROTO_TCP:
+		case IPPROTO_UDP:
+			ipp = (struct ip_ports *) (&p[data_ofs]);
+			sprintf(addinfo, "%s, port: %d -> %d",
+				p[9] == IPPROTO_TCP ? "TCP" : "UDP",
+				ntohs(ipp->source), ntohs(ipp->dest));
+			break;
+		default:
+			sprintf(addinfo, "type %d", p[9]);
+		}
+		printk(KERN_INFO
+		       "OPEN: %u.%u.%u.%u -> %u.%u.%u.%u %s\n",
+		       
+		       NIPQUAD(*(u32 *)(p + 12)), NIPQUAD(*(u32 *)(p + 16)),
+		       addinfo);
+		break;
+	case ETH_P_ARP:
+		printk(KERN_INFO
+		       "OPEN: ARP %d.%d.%d.%d -> *.*.*.* ?%d.%d.%d.%d\n",
+		       NIPQUAD(*(u32 *)(p + 14)), NIPQUAD(*(u32 *)(p + 24)));
+		break;
+	default:
+		printk(KERN_INFO "OPEN: unknown proto %#x\n", proto);
+	}
+}
+
+int
+isdn_net_autodial(struct sk_buff *skb, struct net_device *ndev)
+{
+	isdn_net_local *mlp = ndev->priv;
+	isdn_net_dev *idev = list_entry(mlp->slaves.next, isdn_net_dev, slaves);
+	int retval;
+
+	if (ISDN_NET_DIALMODE(*mlp) != ISDN_NET_DM_AUTO)
+		goto discard;
+
+	retval = isdn_net_dial(idev);
+	if (retval == -ESRCH)
+		goto stop_queue;
+
+	if (retval < 0)
+		goto discard;
+
+	/* Log packet, which triggered dialing */
+	if (dev->net_verbose)
+		isdn_net_log_skb(skb, idev);
+
+ stop_queue:
+	netif_stop_queue(ndev);
+	return 1;
+
+ discard:
+	isdn_net_unreachable(ndev, skb, "dial rejected");
+	dev_kfree_skb(skb);
+	return 0;
+}
+
+
+static void
+isdn_net_dial_slave(isdn_net_local *mlp)
+{
+	isdn_net_dev *idev;
+
+	if (ISDN_NET_DIALMODE(*mlp) != ISDN_NET_DM_AUTO)
+		return;
+
+	list_for_each_entry(idev, &mlp->slaves, slaves) {
+		if (fsm_event(&idev->fi, EV_DO_DIAL, NULL) != -ESRCH) {
+			break;
+		}
+	}
+}
+
 static int
 accept_icall(struct fsm_inst *fi, int pr, void *arg)
 {
@@ -1640,14 +1754,12 @@ bconn(struct fsm_inst *fi, int pr, void *arg)
 		del_timer(&idev->dial_timer);
 	}
 
-	isdn_net_add_to_bundle(mlp, idev);
-
 	printk(KERN_INFO "%s connected\n", idev->name);
 	/* If first Chargeinfo comes before B-Channel connect,
 	 * we correct the timestamp here.
 	 */
 	idev->chargetime = jiffies;
-	
+	idev->frame_cnt = 0;
 	idev->transcount = 0;
 	idev->cps = 0;
 	idev->last_jiffies = jiffies;
@@ -1655,8 +1767,8 @@ bconn(struct fsm_inst *fi, int pr, void *arg)
 	if (mlp->ops->connected)
 		mlp->ops->connected(idev);
 	else
-		isdn_net_dev_wake_queue(idev);
-
+		isdn_net_online(idev);
+       
 	return 0;
 }
 
@@ -1669,11 +1781,11 @@ bhup(struct fsm_inst *fi, int pr, void *arg)
 	del_timer(&idev->dial_timer);
 	if (mlp->ops->disconnected)
 		mlp->ops->disconnected(idev);
+	else 
+		isdn_net_offline(idev);
 
 	printk(KERN_INFO "%s: disconnected\n", idev->name);
 	fsm_change_state(fi, ST_WAIT_DHUP);
-	isdn_net_rm_from_bundle(idev);
-	return 0;
 }
 
 static int
@@ -1748,10 +1860,7 @@ isdn_net_hangup(isdn_net_dev *idev)
 	isdn_ctrl cmd;
 
 	del_timer(&idev->dial_timer);
-	if (!isdn_net_bound(idev)) {
-		isdn_BUG();
-		return 1;
-	}
+
 	printk(KERN_INFO "%s: local hangup\n", idev->name);
 	isdn_slot_command(idev->isdn_slot, ISDN_CMD_HANGUP, &cmd);
 	return 1;
@@ -1769,7 +1878,6 @@ isdn_net_stat_callback(int idx, isdn_ctrl *c)
 	isdn_net_dev *idev = isdn_slot_idev(idx);
 
 	if (!idev) {
-		HERE;
 		return 0;
 	}
 	switch (c->command) {
@@ -1791,7 +1899,7 @@ isdn_net_stat_callback(int idx, isdn_ctrl *c)
 	}
 }
 
-int
+static int
 isdn_net_handle_event(isdn_net_dev *idev, int pr, void *arg)
 {
 	fsm_event(&idev->fi, pr, arg);
@@ -1873,6 +1981,326 @@ static void isdn_net_dev_debug(struct fsm_inst *fi, char *fmt, ...)
 	printk(KERN_DEBUG "%s\n", buf);
 }
 
+/* ====================================================================== */
+/* xmit path                                                              */
+/* ====================================================================== */
+
+#define ISDN_NET_MAX_QUEUE_LENGTH 2
+
+/*
+ * is this particular channel busy?
+ */
+static inline int
+isdn_net_dev_busy(isdn_net_dev *idev)
+{
+	return idev->frame_cnt >= ISDN_NET_MAX_QUEUE_LENGTH;
+}
+
+/*
+ * find out if the net_device which this mlp is belongs to is busy.
+ * It's busy iff all channels are busy.
+ * must hold mlp->xmit_lock
+ * FIXME: Use a mlp->frame_cnt instead of loop?
+ */
+static inline int
+isdn_net_local_busy(isdn_net_local *mlp)
+{
+	isdn_net_dev *idev;
+
+	list_for_each_entry(idev, &mlp->online, online) {
+		if (!isdn_net_dev_busy(idev))
+			return 0;
+	}
+	return 1;
+}
+
+/*
+ * For the given net device, this will get a non-busy channel out of the
+ * corresponding bundle.
+ * must hold mlp->xmit_lock
+ */
+isdn_net_dev *
+isdn_net_get_xmit_dev(isdn_net_local *mlp)
+{
+	isdn_net_dev *idev;
+
+	list_for_each_entry(idev, &mlp->online, online) {
+		if (!isdn_net_dev_busy(idev)) {
+			/* point the head to next online channel */
+			list_del(&mlp->online);
+			list_add(&mlp->online, &idev->online);
+			return idev;
+		}
+	}
+	return NULL;
+}
+
+/* mlp->xmit_lock must be held */
+static inline void
+isdn_net_inc_frame_cnt(isdn_net_dev *idev)
+{
+	isdn_net_local *mlp = idev->mlp;
+
+	if (isdn_net_dev_busy(idev))
+		isdn_BUG();
+		
+	idev->frame_cnt++;
+	if (isdn_net_local_busy(mlp))
+		netif_stop_queue(&mlp->dev);
+}
+
+/* mlp->xmit_lock must be held */
+static inline void
+isdn_net_dec_frame_cnt(isdn_net_dev *idev)
+{
+	isdn_net_local *mlp = idev->mlp;
+
+	idev->frame_cnt--;
+
+	if (isdn_net_dev_busy(idev))
+		isdn_BUG();
+
+	if (!skb_queue_empty(&idev->super_tx_queue))
+		tasklet_schedule(&idev->tlet);
+	else
+		netif_wake_queue(&mlp->dev);
+}
+
+static void
+isdn_net_tasklet(unsigned long data)
+{
+	isdn_net_dev *idev = (isdn_net_dev *) data;
+	isdn_net_local *mlp = idev->mlp;
+	struct sk_buff *skb;
+	unsigned long flags;
+
+	spin_lock_irqsave(&mlp->xmit_lock, flags);
+	while (!isdn_net_dev_busy(idev) &&
+	       (skb = skb_dequeue(&idev->super_tx_queue))) {
+		isdn_net_writebuf_skb(idev, skb);
+	}
+	spin_unlock_irqrestore(&mlp->xmit_lock, flags);
+}
+
+/* We're good to accept (IP/whatever) traffic now */
+
+void
+isdn_net_online(isdn_net_dev *idev)
+{
+	// FIXME check we're connected
+	isdn_net_local *mlp = idev->mlp;
+	unsigned long flags;
+
+	spin_lock_irqsave(&mlp->xmit_lock, flags);
+	list_add(&idev->online, &mlp->online);
+	spin_unlock_irqrestore(&mlp->xmit_lock, flags);
+
+	netif_wake_queue(&mlp->dev);
+}
+
+/* No more (IP/whatever) traffic over the net interface */
+
+void
+isdn_net_offline(isdn_net_dev *idev)
+{
+	isdn_net_local *mlp = idev->mlp;
+	unsigned long flags;
+
+	spin_lock_irqsave(&mlp->xmit_lock, flags);
+	list_del(&idev->online);
+	spin_unlock_irqrestore(&mlp->xmit_lock, flags);
+	
+	skb_queue_purge(&idev->super_tx_queue);
+}
+
+/* 
+ * all frames sent from the (net) LL to a HL driver should go via this function
+ * must hold mlp->xmit_lock
+ */
+void
+isdn_net_writebuf_skb(isdn_net_dev *idev, struct sk_buff *skb)
+{
+	isdn_net_local *mlp = idev->mlp;
+	int ret;
+	int len = skb->len;     /* save len */
+
+	/* before obtaining the lock the caller should have checked that
+	   the lp isn't busy */
+	if (isdn_net_dev_busy(idev)) {
+		isdn_BUG();
+		goto error;
+	}
+
+	if (!isdn_net_is_connected(idev)) {
+		isdn_BUG();
+		goto error;
+	}
+	ret = isdn_slot_write(idev->isdn_slot, skb);
+	if (ret != len) {
+		/* we should never get here */
+		printk(KERN_WARNING "%s: HL driver queue full\n", idev->name);
+		goto error;
+	}
+	
+	idev->transcount += len;
+	isdn_net_inc_frame_cnt(idev);
+	return;
+
+ error:
+	dev_kfree_skb(skb);
+	mlp->stats.tx_errors++;
+}
+
+/* A packet has successfully been sent out. */
+
+static int
+isdn_net_bsent(isdn_net_dev *idev, isdn_ctrl *c)
+{
+	isdn_net_local *mlp = idev->mlp;
+	unsigned long flags;
+
+	spin_lock_irqsave(&mlp->xmit_lock, flags);
+	isdn_net_dec_frame_cnt(idev);
+	spin_unlock_irqrestore(&mlp->xmit_lock, flags);
+	mlp->stats.tx_packets++;
+	mlp->stats.tx_bytes += c->parm.length;
+	return 1;
+}
+
+/*
+ *  Based on cps-calculation, check if device is overloaded.
+ *  If so, and if a slave exists, trigger dialing for it.
+ *  If any slave is online, deliver packets using a simple round robin
+ *  scheme.
+ *
+ *  Return: 0 on success, !0 on failure.
+ */
+
+int
+isdn_net_start_xmit(struct sk_buff *skb, struct net_device *ndev)
+{
+	isdn_net_dev *idev;
+	isdn_net_local *mlp = ndev->priv;
+	unsigned long flags;
+	int retval;
+
+	ndev->trans_start = jiffies;
+
+	spin_lock_irqsave(&mlp->xmit_lock, flags);
+
+	if (list_empty(&mlp->online)) {
+		retval = isdn_net_autodial(skb, ndev);
+		goto out;
+	}
+
+	idev = isdn_net_get_xmit_dev(mlp);
+	if (!idev) {
+		printk(KERN_INFO "%s: all channels busy - requeuing!\n", ndev->name);
+		netif_stop_queue(ndev);
+		retval = 1;
+		goto out;
+	}
+
+	isdn_net_writebuf_skb(idev, skb);
+
+	/* the following stuff is here for backwards compatibility.
+	 * in future, start-up and hangup of slaves (based on current load)
+	 * should move to userspace and get based on an overall cps
+	 * calculation
+	 */
+	if (jiffies != idev->last_jiffies) {
+		idev->cps = idev->transcount * HZ / (jiffies - idev->last_jiffies);
+		idev->last_jiffies = jiffies;
+		idev->transcount = 0;
+	}
+	if (dev->net_verbose > 3)
+		printk(KERN_DEBUG "%s: %d bogocps\n", idev->name, idev->cps);
+
+	if (idev->cps > mlp->triggercps) {
+		if (!idev->sqfull) {
+			/* First time overload: set timestamp only */
+			idev->sqfull = 1;
+			idev->sqfull_stamp = jiffies;
+		} else {
+			/* subsequent overload: if slavedelay exceeded, start dialing */
+			if (time_after(jiffies, idev->sqfull_stamp + mlp->slavedelay)) {
+				isdn_net_dial_slave(mlp);
+			}
+		}
+	} else {
+		if (idev->sqfull && time_after(jiffies, idev->sqfull_stamp + mlp->slavedelay + 10 * HZ)) {
+			idev->sqfull = 0;
+		}
+		/* this is a hack to allow auto-hangup for slaves on moderate loads */
+		list_del(&mlp->online);
+		list_add_tail(&mlp->online, &idev->online);
+	}
+
+	retval = 0;
+ out:
+	spin_unlock_irqrestore(&mlp->xmit_lock, flags);
+	return retval;
+}
+
+/*
+ * this function is used to send supervisory data, i.e. data which was
+ * not received from the network layer, but e.g. frames from ipppd, CCP
+ * reset frames etc.
+ * must hold mlp->xmit_lock
+ */
+void
+isdn_net_write_super(isdn_net_dev *idev, struct sk_buff *skb)
+{
+	if (!isdn_net_dev_busy(idev)) {
+		isdn_net_writebuf_skb(idev, skb);
+	} else {
+		skb_queue_tail(&idev->super_tx_queue, skb);
+	}
+}
+
+/* ====================================================================== */
+/* receive path                                                           */
+/* ====================================================================== */
+
+/*
+ * A packet arrived via ISDN. Search interface-chain for a corresponding
+ * interface. If found, deliver packet to receiver-function and return 1,
+ * else return 0.
+ */
+int
+isdn_net_rcv_skb(int idx, struct sk_buff *skb)
+{
+	isdn_net_dev *idev = isdn_slot_idev(idx);
+	isdn_net_local *mlp;
+
+	if (!idev) {
+		isdn_BUG();
+		return 0;
+	}
+	if (!isdn_net_is_connected(idev)) {
+		isdn_BUG();
+		return 0;
+	}
+
+	mlp = idev->mlp;
+
+	idev->transcount += skb->len;
+
+	mlp->stats.rx_packets++;
+	mlp->stats.rx_bytes += skb->len;
+	skb->dev = &mlp->dev;
+	skb->pkt_type = PACKET_HOST;
+	isdn_dumppkt("R:", skb->data, skb->len, 40);
+
+	mlp->ops->receive(mlp, idev, skb);
+
+	return 1;
+}
+
+/* ====================================================================== */
+/* init / exit                                                            */
+/* ====================================================================== */
+
 void
 isdn_net_lib_init(void)
 {
@@ -1882,5 +2310,7 @@ isdn_net_lib_init(void)
 void
 isdn_net_lib_exit(void)
 {
+	isdn_net_cleanup();
+
 	fsm_free(&isdn_net_fsm);
 }
diff --git a/drivers/isdn/i4l/isdn_ppp.c b/drivers/isdn/i4l/isdn_ppp.c
index 3c59a373459b..13395d86720a 100644
--- a/drivers/isdn/i4l/isdn_ppp.c
+++ b/drivers/isdn/i4l/isdn_ppp.c
@@ -18,635 +18,535 @@
 
 #include "isdn_common.h"
 #include "isdn_ppp.h"
+#include "isdn_ppp_ccp.h"
 #include "isdn_net.h"
 
-/* Prototypes */
-static int isdn_ppp_fill_rq(unsigned char *buf, int len, int proto, int slot);
-static int isdn_ppp_closewait(int slot);
-static void isdn_ppp_push_higher(isdn_net_local *lp, isdn_net_dev *idev,
-				 struct sk_buff *skb, int proto);
-static int isdn_ppp_if_get_unit(char *namebuf);
-static int isdn_ppp_set_compressor(struct ippp_struct *is,struct isdn_ppp_comp_data *);
-static struct sk_buff *isdn_ppp_decompress(struct sk_buff *,
-				struct ippp_struct *,struct ippp_struct *,int *proto);
-static void isdn_ppp_receive_ccp(isdn_net_dev * net_dev, isdn_net_local * lp,
-				struct sk_buff *skb,int proto);
-static struct sk_buff *isdn_ppp_compress(struct sk_buff *skb_in,int *proto,
-	struct ippp_struct *is,struct ippp_struct *master,int type);
-static void isdn_ppp_send_ccp(isdn_net_dev *net_dev, isdn_net_local *lp,
-	 struct sk_buff *skb);
+static struct sk_buff *
+isdn_ppp_dev_alloc_skb(void *priv, int len, int gfp_mask);
 
-/* New CCP stuff */
-static void isdn_ppp_ccp_kickup(struct ippp_struct *is);
-static void isdn_ppp_ccp_xmit_reset(struct ippp_struct *is, int proto,
-				    unsigned char code, unsigned char id,
-				    unsigned char *data, int len);
-static struct ippp_ccp_reset *isdn_ppp_ccp_reset_alloc(struct ippp_struct *is);
-static void isdn_ppp_ccp_reset_free(struct ippp_struct *is);
-static void isdn_ppp_ccp_reset_free_state(struct ippp_struct *is,
-					  unsigned char id);
-static void isdn_ppp_ccp_timer_callback(unsigned long closure);
-static struct ippp_ccp_reset_state *isdn_ppp_ccp_reset_alloc_state(struct ippp_struct *is,
-						      unsigned char id);
-static void isdn_ppp_ccp_reset_trans(struct ippp_struct *is,
-				     struct isdn_ppp_resetparams *rp);
-static void isdn_ppp_ccp_reset_ack_rcvd(struct ippp_struct *is,
-					unsigned char id);
+static int
+isdn_ppp_set_compressor(isdn_net_dev *idev, struct isdn_ppp_comp_data *);
 
+/* ====================================================================== */
+/* IPPPD handling                                                         */
+/* ====================================================================== */
 
+/* We use reference counting for struct ipppd. It is alloced on
+ * open() on /dev/ipppX and saved into file->private, making for one
+ * reference. release() will release this reference, after all other
+ * references are gone, the destructor frees it.
+ *
+ * Another reference is taken by isdn_ppp_bind() and freed by
+ * isdn_ppp_unbind(). The callbacks from isdn_net_lib.c happen only
+ * between isdn_ppp_bind() and isdn_ppp_unbind(), i.e. access to 
+ * idev->ipppd is safe without further locking.
+ */
 
-#ifdef CONFIG_ISDN_MPP
-static ippp_bundle * isdn_ppp_bundle_arr = NULL;
- 
-static int isdn_ppp_mp_bundle_array_init(void);
-static int isdn_ppp_mp_init(isdn_net_local *lp, ippp_bundle *add_to);
-static void isdn_ppp_mp_receive(isdn_net_local *lp, isdn_net_dev *idev, 
-				struct sk_buff *skb);
-static void isdn_ppp_mp_cleanup(isdn_net_local *lp );
+#define IPPPD_DEBUG
 
-static int isdn_ppp_bundle(struct ippp_struct *, int unit);
-#endif	/* CONFIG_ISDN_MPP */
-  
-char *isdn_ppp_revision = "$Revision: 1.85.6.9 $";
+#ifdef IPPPD_DEBUG
+#define ipppd_debug(i, fmt, arg...) \
+        printk(KERN_DEBUG "ipppd %p minor %d state %#x %s: " fmt "\n", (i), \
+               (i)->minor, (i)->state, __FUNCTION__ , ## arg)
+#else
+#define ipppd_debug(...) do { } while (0)
+#endif
 
-static struct ippp_struct *ippp_table[ISDN_MAX_CHANNELS];
+/* ipppd::flags */
+enum {
+	IPPPD_FL_HUP    = 0x01,
+	IPPPD_FL_WAKEUP = 0x02,
+};
 
-static struct isdn_ppp_compressor *ipc_head = NULL;
+/* ipppd::state */
+enum {
+	IPPPD_ST_OPEN,
+	IPPPD_ST_ASSIGNED,
+	IPPPD_ST_CONNECTED,
+};
+
+struct ipppd {
+	struct list_head ipppds;
+	int state;
+	int flags;
+	struct sk_buff_head rq;
+	wait_queue_head_t wq;
+	struct isdn_net_dev_s *idev;
+	int unit;
+	int minor;
+	unsigned long debug;
+	atomic_t refcnt;
+};
+
+/* ====================================================================== */
+
+static spinlock_t ipppds_lock = SPIN_LOCK_UNLOCKED;
+static LIST_HEAD(ipppds);
 
-/*
- * frame log (debug)
- */
 static void
-isdn_ppp_frame_log(char *info, char *data, int len, int maxlen,int unit,int slot)
+ipppd_destroy(struct ipppd *ipppd)
 {
-	int cnt,
-	 j,
-	 i;
-	char buf[80];
+	HERE;
 
-	if (len < maxlen)
-		maxlen = len;
+	skb_queue_purge(&ipppd->rq);
+	kfree(ipppd);
+}
 
-	for (i = 0, cnt = 0; cnt < maxlen; i++) {
-		for (j = 0; j < 16 && cnt < maxlen; j++, cnt++)
-			sprintf(buf + j * 3, "%02x ", (unsigned char) data[cnt]);
-		printk(KERN_DEBUG "[%d/%d].%s[%d]: %s\n",unit,slot, info, i, buf);
-	}
+static inline struct ipppd *
+ipppd_get(struct ipppd *ipppd)
+{
+	atomic_inc(&ipppd->refcnt);
+	printk("%s: %d\n", __FUNCTION__, atomic_read(&ipppd->refcnt));
+	return ipppd;
 }
 
-/*
- * unbind isdn_net_local <=> ippp-device
- * note: it can happen, that we hangup/free the master before the slaves
- *       in this case we bind another lp to the master device
- */
-static void
-isdn_ppp_free(isdn_net_dev *idev)
+static inline void 
+ipppd_put(struct ipppd *ipppd)
+{
+	printk("%s: %d\n", __FUNCTION__, atomic_read(&ipppd->refcnt));
+
+	if (atomic_dec_and_test(&ipppd->refcnt))
+		ipppd_destroy(ipppd);
+}
+
+/* ====================================================================== */
+/* char dev ops                                                           */
+
+/* --- open ------------------------------------------------------------- */
+
+static int
+ipppd_open(struct inode *ino, struct file *file)
 {
 	unsigned long flags;
-	struct ippp_struct *is;
+	unsigned int minor = minor(ino->i_rdev) - ISDN_MINOR_PPP;
+	struct ipppd *ipppd;
 
-	if (idev->ppp_slot < 0 || idev->ppp_slot > ISDN_MAX_CHANNELS) {
-		printk(KERN_ERR "%s: ppp_slot(%d) out of range\n",
-		       __FUNCTION__ , idev->ppp_slot);
-		return;
-	}
+	ipppd = kmalloc(sizeof(*ipppd), GFP_KERNEL);
+	if (!ipppd)
+		return -ENOMEM;
 
-	save_flags(flags);
-	cli();
+	memset(ipppd, 0, sizeof(*ipppd));
+	atomic_set(&ipppd->refcnt, 0);
+	
+	/* file->private_data holds a reference */
+	file->private_data = ipppd_get(ipppd);
+
+	ipppd->unit = -1;          /* set by isdn_ppp_bind */
+	ipppd->minor = minor;
+	ipppd->state = IPPPD_ST_OPEN;
+	init_waitqueue_head(&ipppd->wq);
+	skb_queue_head_init(&ipppd->rq);
+
+	spin_lock_irqsave(&ipppds, flags);
+	list_add(&ipppd->ipppds, &ipppds);
+	spin_unlock_irqrestore(&ipppds, flags);
+	
+	ipppd_debug(ipppd, "minor %d", minor);
 
-#ifdef CONFIG_ISDN_MPP
-	spin_lock(&idev->pb->lock);
-#endif
-	isdn_net_rm_from_bundle(idev);
-#ifdef CONFIG_ISDN_MPP
-	if (lp->netdev->pb->ref_ct == 1)	/* last link in queue? */
-		isdn_ppp_mp_cleanup(lp);
+	return 0;
+}
 
-	lp->netdev->pb->ref_ct--;
-	spin_unlock(&lp->netdev->pb->lock);
-#endif /* CONFIG_ISDN_MPP */
-	if (idev->ppp_slot < 0 || idev->ppp_slot > ISDN_MAX_CHANNELS) {
-		printk(KERN_ERR "%s: ppp_slot(%d) now invalid\n",
-		       __FUNCTION__ , idev->ppp_slot);
-		restore_flags(flags);
-		return;
-	}
-	is = ippp_table[idev->ppp_slot];
-	if ((is->state & IPPP_CONNECT))
-		isdn_ppp_closewait(idev->ppp_slot);	/* force wakeup on ippp device */
-	else if (is->state & IPPP_ASSIGNED)
-		is->state = IPPP_OPEN;	/* fallback to 'OPEN but not ASSIGNED' state */
+/* --- release  --------------------------------------------------------- */
 
-	if (is->debug & 0x1)
-		printk(KERN_DEBUG "isdn_ppp_free %d %p\n", idev->ppp_slot, is->idev);
+static int
+ipppd_release(struct inode *ino, struct file *file)
+{
+	unsigned long flags;
+	struct ipppd *ipppd = file->private_data;
 
-	is->idev = NULL;          /* link is down .. set lp to NULL */
-	idev->ppp_slot = -1;      /* is this OK ?? */
+	ipppd_debug(ipppd, "");
 
-	restore_flags(flags);
-	return;
+	if (ipppd->state == IPPPD_ST_CONNECTED)
+		isdn_net_hangup(ipppd->idev);
+
+	spin_lock_irqsave(&ipppds, flags);
+	list_del(&ipppd->ipppds);
+	spin_unlock_irqrestore(&ipppds, flags);
+
+	ipppd_put(ipppd);
+
+	return 0;
 }
 
-/*
- * bind isdn_net_local <=> ippp-device
- */
-int
-isdn_ppp_bind(isdn_net_dev *idev)
+/* --- read ------------------------------------------------------------- */
+
+/* read() is always non blocking */
+static ssize_t
+ipppd_read(struct file *file, char *buf, size_t count, loff_t *off)
 {
-	int i;
-	int unit = 0;
-	long flags;
-	struct ippp_struct *is;
+	struct ipppd *is;
+	struct sk_buff *skb;
 	int retval;
 
-	save_flags(flags);
-	cli();
-	if (idev->pppbind < 0) {  /* device bound to ippp device ? */
-		struct list_head *l;
-		char exclusive[ISDN_MAX_CHANNELS];	/* exclusive flags */
-		memset(exclusive, 0, ISDN_MAX_CHANNELS);
-		/* step through net devices to find exclusive minors */
-		list_for_each(l, &isdn_net_devs) {
-			isdn_net_dev *p = list_entry(l, isdn_net_dev, global_list);
-			if (p->pppbind >= 0)
-				exclusive[p->pppbind] = 1;
-		}
-		/*
-		 * search a free device / slot
-		 */
-		for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
-			if (ippp_table[i]->state == IPPP_OPEN && !exclusive[ippp_table[i]->minor]) {	/* OPEN, but not connected! */
-				break;
-			}
-		}
-	} else {
-		for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
-			if (ippp_table[i]->minor == idev->pppbind &&
-			    (ippp_table[i]->state & IPPP_OPEN) == IPPP_OPEN)
-				break;
-		}
-	}
+	if (off != &file->f_pos)
+		return -ESPIPE;
+	
+	is = file->private_data;
 
-	if (i >= ISDN_MAX_CHANNELS) {
-		restore_flags(flags);
-		printk(KERN_WARNING "isdn_ppp_bind: Can't find a (free) connection to the ipppd daemon.\n");
-		retval = -1;
+	skb = skb_dequeue(&is->rq);
+	if (!skb) {
+		retval = -EAGAIN;
 		goto out;
 	}
-	unit = isdn_ppp_if_get_unit(idev->name);	/* get unit number from interface name .. ugly! */
-	if (unit < 0) {
-		printk(KERN_ERR "isdn_ppp_bind: illegal interface name %s.\n", idev->name);
-		retval = -1;
-		goto out;
+	if (skb->len > count) {
+		retval = -EMSGSIZE;
+		goto out_free;
 	}
-	
-	idev->ppp_slot = i;
-	is = ippp_table[i];
-	is->idev = idev;
-	is->unit = unit;
-	is->state = IPPP_OPEN | IPPP_ASSIGNED;	/* assigned to a netdevice but not connected */
-#ifdef CONFIG_ISDN_MPP
-	retval = isdn_ppp_mp_init(lp, NULL);
-	if (retval < 0)
-		goto out;
-#endif /* CONFIG_ISDN_MPP */
-
-	retval = idev->ppp_slot;
+	if (copy_to_user(buf, skb->data, skb->len)) {
+		retval = -EFAULT;
+		goto out_free;
+	}
+	retval = skb->len;
 
+ out_free:
+	dev_kfree_skb(skb);
  out:
-	restore_flags(flags);
 	return retval;
 }
 
-/*
- * kick the ipppd on the device
- * (wakes up daemon after B-channel connect)
- */
+/* --- write ------------------------------------------------------------ */
 
-static void
-isdn_ppp_wakeup_daemon(isdn_net_dev *idev)
+/* write() is always non blocking */
+static ssize_t
+ipppd_write(struct file *file, const char *buf, size_t count, loff_t *off)
 {
-	if (idev->ppp_slot < 0 || idev->ppp_slot >= ISDN_MAX_CHANNELS) {
-		printk(KERN_ERR "%s: ppp_slot(%d) out of range\n",
-		       __FUNCTION__, idev->ppp_slot);
-		return;
-	}
-	ippp_table[idev->ppp_slot]->state = IPPP_OPEN | IPPP_CONNECT | IPPP_NOBLOCK;
-	wake_up_interruptible(&ippp_table[idev->ppp_slot]->wq);
-}
+	isdn_net_dev *idev;
+	struct ipppd *ipppd;
+	struct sk_buff *skb;
+	char *p;
+	int retval;
+	u16 proto;
 
-/*
- * there was a hangup on the netdevice
- * force wakeup of the ippp device
- * go into 'device waits for release' state
- */
-static int
-isdn_ppp_closewait(int slot)
-{
-	struct ippp_struct *is;
+	if (off != &file->f_pos)
+		return -ESPIPE;
 
-	if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
-		printk(KERN_ERR "%s: slot(%d) out of range\n",
-		       __FUNCTION__ , slot);
-		return 0;
-	}
-	is = ippp_table[slot];
-	if (is->state)
-		wake_up_interruptible(&is->wq);
-	is->state = IPPP_CLOSEWAIT;
-	return 1;
-}
+	ipppd = file->private_data;
+	ipppd_debug(ipppd, "count = %d", count);
 
-/*
- * isdn_ppp_find_slot / isdn_ppp_free_slot
- */
+	if (ipppd->state != IPPPD_ST_CONNECTED) {
+		retval = -ENOTCONN;
+		goto out;
+	}
 
-static int
-isdn_ppp_get_slot(void)
-{
-	int i;
-	for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
-		if (!ippp_table[i]->state)
-			return i;
+	idev = ipppd->idev;
+	if (!idev) {
+		isdn_BUG();
+		retval = -ENODEV;
+		goto out;
 	}
-	return -1;
+	/* Daemon needs to send at least full header, AC + proto */
+	if (count < 4) {
+		retval = -EMSGSIZE;
+		goto out;
+	}
+	skb = isdn_ppp_dev_alloc_skb(idev, count, GFP_KERNEL);
+	if (!skb) {
+		retval = -ENOMEM;
+		goto out;
+	}
+	p = skb_put(skb, count);
+	if (copy_from_user(p, buf, count)) {
+		kfree_skb(skb);
+		retval = -EFAULT;
+		goto out;
+	}
+	/* Don't reset huptimer for LCP packets. (Echo requests). */
+	proto = PPP_PROTOCOL(p);
+	if (proto != PPP_LCP)
+		idev->huptimer = 0;
+	
+	/* Keeps CCP/compression states in sync */
+	switch (proto) {
+	case PPP_CCP:
+		ippp_ccp_send_ccp(idev->mlp->ccp, skb);
+		break;
+	case PPP_CCPFRAG:
+		ippp_ccp_send_ccp(idev->ccp, skb);
+		break;
+	}
+	/* FIXME: Somewhere we need protection against the
+	 * queue growing too large */
+	isdn_net_write_super(idev, skb);
+
+	retval = count;
+	
+ out:
+	return retval;
 }
 
-/*
- * isdn_ppp_open
- */
+/* --- poll ------------------------------------------------------------- */
 
-static int
-isdn_ppp_open(struct inode *ino, struct file *file)
+static unsigned int
+ipppd_poll(struct file *file, poll_table * wait)
 {
-	uint minor = minor(ino->i_rdev) - ISDN_MINOR_PPP;
-	int slot;
-	struct ippp_struct *is;
+	unsigned int mask;
+	struct ipppd *is;
 
-	slot = isdn_ppp_get_slot();
-	if (slot < 0) {
-		return -EBUSY;
-	}
-	is = file->private_data = ippp_table[slot];
+	is = file->private_data;
 
-	printk(KERN_DEBUG "ippp, open, slot: %d, minor: %d, state: %04x\n", slot, minor, is->state);
+	ipppd_debug(is, "");
 
-	/* compression stuff */
-	is->link_compressor   = is->compressor = NULL;
-	is->link_decompressor = is->decompressor = NULL;
-	is->link_comp_stat    = is->comp_stat = NULL;
-	is->link_decomp_stat  = is->decomp_stat = NULL;
-	is->compflags = 0;
+	/* just registers wait_queue hook. This doesn't really wait. */
+	poll_wait(file, &is->wq, wait);
 
-	is->reset = isdn_ppp_ccp_reset_alloc(is);
+	if (is->flags & IPPPD_FL_HUP) {
+		mask = POLLHUP;
+		goto out;
+	}
+	/* we're always ready to send .. */
+	mask = POLLOUT | POLLWRNORM;
 
-	is->idev = NULL;
-	is->mp_seqno = 0;       /* MP sequence number */
-	is->pppcfg = 0;         /* ppp configuration */
-	is->mpppcfg = 0;        /* mppp configuration */
-	is->last_link_seqno = -1;	/* MP: maybe set to Bundle-MIN, when joining a bundle ?? */
-	is->unit = -1;          /* set, when we have our interface */
-	is->mru = 1524;         /* MRU, default 1524 */
-	is->maxcid = 16;        /* VJ: maxcid */
-	is->tk = current;
-	init_waitqueue_head(&is->wq);
-	is->minor = minor;
-#ifdef CONFIG_ISDN_PPP_VJ
 	/*
-	 * VJ header compression init
+	 * if IPPP_FL_WAKEUP is set we return even if we have nothing to read
 	 */
-	is->slcomp = slhc_init(16, 16);	/* not necessary for 2. link in bundle */
-#endif
-
-	is->state = IPPP_OPEN;
-	isdn_lock_drivers();
-
-	return 0;
-}
-
-/*
- * release ippp device
- */
-static int
-isdn_ppp_release(struct inode *ino, struct file *file)
-{
-	uint minor = minor(ino->i_rdev) - ISDN_MINOR_PPP;
-	struct ippp_struct *is;
-
-	lock_kernel();
-
-	is = file->private_data;
-
-	if (is->debug & 0x1)
-		printk(KERN_DEBUG "ippp: release, minor: %d %p\n", minor, is->idev);
-
-	if (is->idev) {           /* a lp address says: this link is still up */
-		/*
-		 * isdn_net_hangup() calls isdn_ppp_free()
-		 * isdn_ppp_free() sets is->lp to NULL and lp->ppp_slot to -1
-		 * removing the IPPP_CONNECT flag omits calling of isdn_ppp_wakeup_daemon()
-		 */
-		is->state &= ~IPPP_CONNECT;
-		isdn_net_hangup(is->idev);
+	if (!skb_queue_empty(&is->rq) || is->flags & IPPPD_FL_WAKEUP) {
+		is->flags &= ~IPPPD_FL_WAKEUP;
+		mask |= POLLIN | POLLRDNORM;
+		set_current_state(TASK_INTERRUPTIBLE); // FIXME
+		schedule_timeout(HZ);
 	}
-	skb_queue_purge(&is->rq);
-
-#ifdef CONFIG_ISDN_PPP_VJ
-/* TODO: if this was the previous master: link the slcomp to the new master */
-	slhc_free(is->slcomp);
-	is->slcomp = NULL;
-#endif
 
-/* TODO: if this was the previous master: link the the stuff to the new master */
-	if(is->comp_stat)
-		is->compressor->free(is->comp_stat);
-	if(is->link_comp_stat)
-		is->link_compressor->free(is->link_comp_stat);
-	if(is->link_decomp_stat)
-		is->link_decompressor->free(is->link_decomp_stat);
-	if(is->decomp_stat)
-		is->decompressor->free(is->decomp_stat);
-        is->compressor   = is->link_compressor   = NULL;
-        is->decompressor = is->link_decompressor = NULL;
-	is->comp_stat    = is->link_comp_stat    = NULL;
-        is->decomp_stat  = is->link_decomp_stat  = NULL;
-
-	/* Clean up if necessary */
-	if(is->reset)
-		isdn_ppp_ccp_reset_free(is);
-
-	/* this slot is ready for new connections */
-	is->state = 0;
-
-	isdn_unlock_drivers();
-	
-	unlock_kernel();
-	return 0;
+ out:
+	return mask;
 }
 
-/*
- * get_arg .. ioctl helper
- */
+/* --- ioctl ------------------------------------------------------------ */
+
+/* get_arg .. ioctl helper */
 static int
-get_arg(void *b, void *val, int len)
+get_arg(unsigned long arg, void *val, int len)
 {
-	if (len <= 0)
-		len = sizeof(void *);
-	if (copy_from_user((void *) val, b, len))
+	if (copy_from_user((void *) val, (void *) arg, len))
 		return -EFAULT;
 	return 0;
 }
 
-/*
- * set arg .. ioctl helper
- */
+/* set arg .. ioctl helper */
 static int
-set_arg(void *b, void *val,int len)
+set_arg(unsigned long arg, void *val,int len)
 {
-	if (copy_to_user(b, (void *) val, len))
+	if (copy_to_user((void *) arg, (void *) val, len))
 		return -EFAULT;
 	return 0;
 }
 
-/*
- * ippp device ioctl
- */
 static int
-isdn_ppp_ioctl(struct inode *ino, struct file *file, unsigned int cmd, unsigned long arg)
+ipppd_ioctl(struct inode *ino, struct file *file, unsigned int cmd,
+	    unsigned long arg)
 {
 	isdn_net_dev *idev;
 	unsigned long val;
-	int r,i,j;
-	struct ippp_struct *is;
+	int r;
+	struct ipppd *is;
 	struct isdn_ppp_comp_data data;
+	unsigned int cfg;
 
-	is = (struct ippp_struct *) file->private_data;
+	is = file->private_data;
 	idev = is->idev;
 
-	if (is->debug & 0x1)
-		printk(KERN_DEBUG "isdn_ppp_ioctl: minor: %d cmd: %x state: %x\n", is->minor, cmd, is->state);
-
-	if (!(is->state & IPPP_OPEN))
-		return -EINVAL;
+	ipppd_debug(is, "cmd %#x", cmd);
 
 	switch (cmd) {
-		case PPPIOCBUNDLE:
+	case PPPIOCBUNDLE:
 #ifdef CONFIG_ISDN_MPP
-			if (!(is->state & IPPP_CONNECT))
-				return -EINVAL;
-			if ((r = get_arg((void *) arg, &val, sizeof(val) )))
-				return r;
-			printk(KERN_DEBUG "iPPP-bundle: minor: %d, slave unit: %d, master unit: %d\n",
-			       (int) is->minor, (int) is->unit, (int) val);
-			return isdn_ppp_bundle(is, val);
-#else
-			return -1;
-#endif
-			break;
-		case PPPIOCGUNIT:	/* get ppp/isdn unit number */
-			if ((r = set_arg((void *) arg, &is->unit, sizeof(is->unit) )))
-				return r;
-			break;
-		case PPPIOCGIFNAME:
-			if(!idev)
-				return -EINVAL;
-			if ((r = set_arg((void *) arg, idev->name, strlen(idev->name))))
-				return r;
-			break;
-		case PPPIOCGMPFLAGS:	/* get configuration flags */
-			if ((r = set_arg((void *) arg, &is->mpppcfg, sizeof(is->mpppcfg) )))
-				return r;
+		if (is->state != IPPPD_ST_CONNECTED) {
+			r = -EINVAL;
 			break;
-		case PPPIOCSMPFLAGS:	/* set configuration flags */
-			if ((r = get_arg((void *) arg, &val, sizeof(val) )))
-				return r;
-			is->mpppcfg = val;
-			break;
-		case PPPIOCGFLAGS:	/* get configuration flags */
-			if ((r = set_arg((void *) arg, &is->pppcfg,sizeof(is->pppcfg) )))
-				return r;
+		}
+		r = get_arg(arg, &val, sizeof(val));
+		if (r)
 			break;
-		case PPPIOCSFLAGS:	/* set configuration flags */
-			if ((r = get_arg((void *) arg, &val, sizeof(val) ))) {
-				return r;
-			}
-			if (val & SC_ENABLE_IP && !(is->pppcfg & SC_ENABLE_IP) && (is->state & IPPP_CONNECT)) {
-				if (idev) {
-					/* OK .. we are ready to send buffers */
-					isdn_net_dev_wake_queue(idev);
-				}
-			}
-			is->pppcfg = val;
+
+		printk(KERN_DEBUG "iPPP-bundle: minor: %d, slave unit: %d, master unit: %d\n",
+		       is->minor, is->unit, val);
+		r = isdn_ppp_bundle(is, val);
+#else
+		r = -EINVAL;
+#endif
+		break;
+	case PPPIOCGUNIT:	/* get ppp/isdn unit number */
+		r = set_arg(arg, &is->unit, sizeof(is->unit));
+		break;
+	case PPPIOCGDEBUG:
+		r = set_arg(arg, &is->debug, sizeof(is->debug));
+		break;
+	case PPPIOCSDEBUG:
+		r = get_arg(arg, &val, sizeof(val));
+		if (r)
 			break;
-		case PPPIOCGIDLE:	/* get idle time information */
-			if (idev) {
-				struct ppp_idle pidle;
-				pidle.xmit_idle = pidle.recv_idle = idev->huptimer;
-				if ((r = set_arg((void *) arg, &pidle,sizeof(struct ppp_idle))))
-					 return r;
-			}
+		is->debug = val;
+		if (idev) {
+			idev->debug = val;
+			idev->mlp->debug = val;
+		}
+		break;
+	case PPPIOCGCOMPRESSORS:
+	{
+		unsigned long protos[8];
+		ippp_ccp_get_compressors(protos);
+		r = set_arg(arg, protos, sizeof(protos));
+		break;
+	}
+	default:
+		r = -ENOTTY;
+		break;
+	}
+
+	if (r != -ENOTTY)
+		goto out;
+
+	if (!idev) {
+		r = -ENODEV;
+		goto out;
+	}
+
+	switch (cmd) {
+	case PPPIOCGIFNAME:
+		r = set_arg(arg, idev->name, strlen(idev->name)+1);
+		break;
+	case PPPIOCGMPFLAGS:	/* get configuration flags */
+		r = set_arg(arg, &idev->mlp->mpppcfg, sizeof(idev->mlp->mpppcfg));
+		break;
+	case PPPIOCSMPFLAGS:	/* set configuration flags */
+		r = get_arg(arg, &val, sizeof(val));
+		if (r)
 			break;
-		case PPPIOCSMRU:	/* set receive unit size for PPP */
-			if ((r = get_arg((void *) arg, &val, sizeof(val) )))
-				return r;
-			is->mru = val;
+		idev->mlp->mpppcfg = val;
+		break;
+	case PPPIOCGFLAGS:	/* get configuration flags */
+		cfg = idev->pppcfg | ippp_ccp_get_flags(idev->ccp);
+		r = set_arg(arg, &cfg, sizeof(cfg));
+		break;
+	case PPPIOCSFLAGS:	/* set configuration flags */
+		r = get_arg(arg, &val, sizeof(val));
+		if (r)
 			break;
-		case PPPIOCSMPMRU:
+		if ((val & SC_ENABLE_IP) && !(idev->pppcfg & SC_ENABLE_IP)) {
+			idev->pppcfg = val;
+			/* OK .. we are ready to send buffers */
+			isdn_net_online(idev);
 			break;
-		case PPPIOCSMPMTU:
+		}
+		idev->pppcfg = val;
+		break;
+	case PPPIOCGIDLE:	/* get idle time information */
+	{
+		struct ppp_idle pidle;
+		pidle.xmit_idle = pidle.recv_idle = idev->huptimer;
+		r = set_arg(arg, &pidle,sizeof(pidle));
+		break;
+	}
+	case PPPIOCSMRU:	/* set receive unit size for PPP */
+		r = get_arg(arg, &val, sizeof(val));
+		if (r)
 			break;
-		case PPPIOCSMAXCID:	/* set the maximum compression slot id */
-			if ((r = get_arg((void *) arg, &val, sizeof(val) )))
-				return r;
-			val++;
-			if (is->maxcid != val) {
-#ifdef CONFIG_ISDN_PPP_VJ
-				struct slcompress *sltmp;
-#endif
-				if (is->debug & 0x1)
-					printk(KERN_DEBUG "ippp, ioctl: changed MAXCID to %ld\n", val);
-				is->maxcid = val;
+		r = ippp_ccp_set_mru(idev->ccp, val);
+		break;
+	case PPPIOCSMPMRU:
+		break;
+	case PPPIOCSMPMTU:
+		break;
 #ifdef CONFIG_ISDN_PPP_VJ
-				sltmp = slhc_init(16, val);
-				if (!sltmp) {
-					printk(KERN_ERR "ippp, can't realloc slhc struct\n");
-					return -ENOMEM;
-				}
-				if (is->slcomp)
-					slhc_free(is->slcomp);
-				is->slcomp = sltmp;
-#endif
-			}
-			break;
-		case PPPIOCGDEBUG:
-			if ((r = set_arg((void *) arg, &is->debug, sizeof(is->debug) )))
-				return r;
+	case PPPIOCSMAXCID:	/* set the maximum compression slot id */
+	{
+		struct slcompress *sltmp;
+		r = get_arg(arg, &val, sizeof(val));
+		if (r)
 			break;
-		case PPPIOCSDEBUG:
-			if ((r = get_arg((void *) arg, &val, sizeof(val) )))
-				return r;
-			is->debug = val;
+		val++;
+		sltmp = slhc_init(16, val);
+		if (!sltmp) {
+			r = -ENOMEM;
 			break;
-		case PPPIOCGCOMPRESSORS:
-			{
-				unsigned long protos[8] = {0,};
-				struct isdn_ppp_compressor *ipc = ipc_head;
-				while(ipc) {
-					j = ipc->num / (sizeof(long)*8);
-					i = ipc->num % (sizeof(long)*8);
-					if(j < 8)
-						protos[j] |= (0x1<<i);
-					ipc = ipc->next;
-				}
-				if ((r = set_arg((void *) arg,protos,8*sizeof(long) )))
-					return r;
-			}
+		}
+		if (idev->mlp->slcomp)
+			slhc_free(idev->mlp->slcomp);
+		idev->mlp->slcomp = sltmp;
+		r = 0;
+		break;
+	}
+#endif
+	case PPPIOCSCOMPRESSOR:
+		r = get_arg(arg, &data, sizeof(data));
+		if (r)
 			break;
-		case PPPIOCSCOMPRESSOR:
-			if ((r = get_arg((void *) arg, &data, sizeof(struct isdn_ppp_comp_data))))
-				return r;
-			return isdn_ppp_set_compressor(is, &data);
-		case PPPIOCGCALLINFO:
-			{
-				isdn_net_local *mlp;
-				struct isdn_net_phone *phone;
-				struct pppcallinfo pci;
-				int i;
-				memset((char *) &pci,0,sizeof(struct pppcallinfo));
-				if(idev) {
-					mlp = idev->mlp;
-					strncpy(pci.local_num, mlp->msn, 63);
-					i = 0;
-					list_for_each_entry(phone, &mlp->phone[1], list) {
-						if (i++ == idev->dial) {
-							strncpy(pci.remote_num,phone->num,63);
-							break;
-						}
-					}
-					pci.charge_units = idev->charge;
-					if(idev->outgoing)
-						pci.calltype = CALLTYPE_OUTGOING;
-					else
-						pci.calltype = CALLTYPE_INCOMING;
-					if(mlp->flags & ISDN_NET_CALLBACK)
-						pci.calltype |= CALLTYPE_CALLBACK;
-				}
-				return set_arg((void *)arg,&pci,sizeof(struct pppcallinfo));
+		r = isdn_ppp_set_compressor(idev, &data);
+		break;
+	case PPPIOCGCALLINFO:
+	{
+		isdn_net_local *mlp;
+		struct isdn_net_phone *phone;
+		struct pppcallinfo pci;
+		int i;
+		memset(&pci, 0, sizeof(pci));
+
+		mlp = idev->mlp;
+		strncpy(pci.local_num, mlp->msn, 63);
+		i = 0;
+		list_for_each_entry(phone, &mlp->phone[1], list) {
+			if (i++ == idev->dial) {
+				strncpy(pci.remote_num,phone->num,63);
+				break;
 			}
-		default:
-			break;
-	}
-	return 0;
-}
-
-static unsigned int
-isdn_ppp_poll(struct file *file, poll_table * wait)
-{
-	unsigned int mask;
-	struct ippp_struct *is;
-
-	is = file->private_data;
-
-	if (is->debug & 0x2)
-		printk(KERN_DEBUG "isdn_ppp_poll: minor: %d\n",
-				minor(file->f_dentry->d_inode->i_rdev));
-
-	/* just registers wait_queue hook. This doesn't really wait. */
-	poll_wait(file, &is->wq, wait);
-
-	if (!(is->state & IPPP_OPEN)) {
-		if(is->state == IPPP_CLOSEWAIT) {
-			mask = POLLHUP;
-			goto out;
 		}
-		printk(KERN_DEBUG "isdn_ppp: device not open\n");
-		mask = POLLERR;
-		goto out;
+		pci.charge_units = idev->charge;
+		if (idev->outgoing)
+			pci.calltype = CALLTYPE_OUTGOING;
+		else
+			pci.calltype = CALLTYPE_INCOMING;
+		if (mlp->flags & ISDN_NET_CALLBACK)
+			pci.calltype |= CALLTYPE_CALLBACK;
+		r = set_arg(arg, &pci, sizeof(pci));
+		break;
 	}
-	/* we're always ready to send .. */
-	mask = POLLOUT | POLLWRNORM;
-
-	/*
-	 * if IPPP_NOBLOCK is set we return even if we have nothing to read
-	 */
-	if (!skb_queue_empty(&is->rq) || is->state & IPPP_NOBLOCK) {
-		is->state &= ~IPPP_NOBLOCK;
-		mask |= POLLIN | POLLRDNORM;
+	default:
+		r = -ENOTTY;
+		break;
 	}
-
  out:
-	return mask;
+	return r;
 }
 
-/*
- *  fill up isdn_ppp_read() queue ..
- */
+/* --- fops ------------------------------------------------------------- */
+
+struct file_operations isdn_ppp_fops =
+{
+	.owner		= THIS_MODULE,
+	.llseek		= no_llseek,
+	.read		= ipppd_read,
+	.write		= ipppd_write,
+	.poll		= ipppd_poll,
+	.ioctl		= ipppd_ioctl,
+	.open		= ipppd_open,
+	.release	= ipppd_release,
+};
+
+/* --- ipppd_queue_read ------------------------------------------------- */
+
+/* Queue packets for ipppd to read(). */
 
 static int
-isdn_ppp_fill_rq(unsigned char *buf, int len, int proto, int slot)
+ipppd_queue_read(struct ipppd *is, u16 proto, unsigned char *buf, int len)
 {
 	struct sk_buff *skb;
 	unsigned char *p;
-	struct ippp_struct *is;
-
-	if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
-		printk(KERN_WARNING "ippp: illegal slot(%d).\n", slot);
-		return 0;
-	}
-	is = ippp_table[slot];
+	int retval;
 
-	if (!(is->state & IPPP_CONNECT)) {
-		printk(KERN_DEBUG "ippp: device not activated.\n");
-		return 0;
+	if (is->state != IPPPD_ST_CONNECTED) {
+		printk(KERN_DEBUG "ippp: device not connected.\n");
+		retval = -ENOTCONN;
+		goto out;
 	}
 	if (skb_queue_len(&is->rq) > IPPP_MAX_RQ_LEN) {
 		printk(KERN_WARNING "ippp: Queue is full\n");
-		return 0;
+		retval = -EBUSY;
+		goto out;
 	}
 	skb = dev_alloc_skb(len + 4);
 	if (!skb) {
 		printk(KERN_WARNING "ippp: Can't alloc buf\n");
-		return 0;
+		retval = -ENOMEM;
+		goto out;
 	}
 	p = skb_put(skb, 4);
 	p += put_u8(p, PPP_ALLSTATIONS);
@@ -655,151 +555,274 @@ isdn_ppp_fill_rq(unsigned char *buf, int len, int proto, int slot)
 	memcpy(skb_put(skb, len), buf, len);
 
 	skb_queue_tail(&is->rq, skb);
-	wake_up_interruptible(&is->wq);
+	wake_up(&is->wq);
 
-	return len;
+	retval = len;
+ out:
+	return retval;
 }
 
+/* ====================================================================== */
+
+/* Prototypes */
+static void isdn_ppp_push_higher(isdn_net_local *lp, isdn_net_dev *idev,
+				 struct sk_buff *skb, int proto);
+static int isdn_ppp_if_get_unit(char *namebuf);
+
+static void
+isdn_ppp_dev_push_header(void *priv, struct sk_buff *skb, u16 proto);
+
+static void
+isdn_ppp_dev_xmit(void *priv, struct sk_buff *skb);
+
+static struct sk_buff *
+isdn_ppp_lp_alloc_skb(void *priv, int len, int gfp_mask);
+
+static void
+isdn_ppp_lp_push_header(void *priv, struct sk_buff *skb, u16 proto);
+
+/* New CCP stuff */
+static void
+isdn_ppp_dev_kick_up(void *priv);
+
+#ifdef CONFIG_ISDN_MPP
+static ippp_bundle * isdn_ppp_bundle_arr = NULL;
+ 
+static int isdn_ppp_mp_bundle_array_init(void);
+static int isdn_ppp_mp_init(isdn_net_local *lp, ippp_bundle *add_to);
+static void isdn_ppp_mp_receive(isdn_net_local *lp, isdn_net_dev *idev, 
+				struct sk_buff *skb);
+static void isdn_ppp_mp_cleanup(isdn_net_local *lp );
+
+static int isdn_ppp_bundle(struct ipppd *, int unit);
+#endif	/* CONFIG_ISDN_MPP */
+  
+char *isdn_ppp_revision = "$Revision: 1.85.6.9 $";
+
 /*
- * read() .. non-blocking: ipppd calls it only after select()
- *           reports, that there is data
+ * frame log (debug)
  */
-
-static ssize_t
-isdn_ppp_read(struct file *file, char *buf, size_t count, loff_t *off)
+void
+isdn_ppp_frame_log(char *info, char *data, int len, int maxlen,int unit,int slot)
 {
-	struct ippp_struct *is;
-	struct sk_buff *skb;
-	int retval;
+	int cnt,
+	 j,
+	 i;
+	char buf[80];
 
-	if (off != &file->f_pos)
-		return -ESPIPE;
-	
-	is = file->private_data;
+	if (len < maxlen)
+		maxlen = len;
 
-	if (!(is->state & IPPP_OPEN)) {
-		retval = 0;
-		goto out;
-	}
-	skb = skb_dequeue(&is->rq);
-	if (!skb) {
-		retval = -EAGAIN;
-		goto out;
-	}
-	if (skb->len > count) {
-		retval = -EMSGSIZE;
-		goto out_free;
+	for (i = 0, cnt = 0; cnt < maxlen; i++) {
+		for (j = 0; j < 16 && cnt < maxlen; j++, cnt++)
+			sprintf(buf + j * 3, "%02x ", (unsigned char) data[cnt]);
+		printk(KERN_DEBUG "[%d/%d].%s[%d]: %s\n",unit,slot, info, i, buf);
 	}
-	if (copy_to_user(buf, skb->data, skb->len)) {
-		retval = -EFAULT;
-		goto out_free;
+}
+
+
+static void
+isdn_ppp_push_header(isdn_net_dev *idev, struct sk_buff *skb, u16 proto)
+{
+	unsigned char *p;
+
+	if (skb_headroom(skb) < 4) {
+		isdn_BUG();
+		return;
 	}
-	retval = skb->len;
 
- out_free:
-	dev_kfree_skb(skb);
- out:
-	return retval;
+	if ((idev->pppcfg & SC_COMP_PROT) && proto <= 0xff)
+		put_u8(skb_push(skb, 1), proto);
+	else
+		put_u16(skb_push(skb, 2), proto);
+
+	if (idev->pppcfg & SC_COMP_AC)
+		return;
+
+	p = skb_push(skb, 2);	
+	p += put_u8(p, PPP_ALLSTATIONS);
+	p += put_u8(p, PPP_UI);
 }
 
 /*
- * ipppd wanna write a packet to the card .. non-blocking
+ * unbind isdn_net_local <=> ippp-device
+ * note: it can happen, that we hangup/free the master before the slaves
+ *       in this case we bind another lp to the master device
  */
-
-static ssize_t
-isdn_ppp_write(struct file *file, const char *buf, size_t count, loff_t *off)
+static void
+isdn_ppp_unbind(isdn_net_dev *idev)
 {
-	isdn_net_dev *idev;
-	struct ippp_struct *is;
-	int proto;
-	unsigned char protobuf[4];
-	int retval;
+	struct ipppd *is = idev->ipppd;
+	
+	if (!is) {
+		isdn_BUG();
+		return;
+	}
 
-	if (off != &file->f_pos)
-		return -ESPIPE;
+	ipppd_debug(is, "");
 
-	lock_kernel();
+	if (is->state != IPPPD_ST_ASSIGNED)
+		isdn_BUG();
 
-	is = file->private_data;
+	is->state = IPPPD_ST_OPEN;
 
-	if (!(is->state & IPPP_CONNECT)) {
-		retval = 0;
-		goto out;
-	}
+	/* is->idev will be invalid shortly */
+	ippp_ccp_free(idev->ccp);
 
-	/* -> push it directly to the lowlevel interface */
+	is->idev = NULL;
+	/* lose the reference we took on isdn_ppp_bind */
+	ipppd_put(is); 
+	idev->ipppd = NULL;
 
-	idev = is->idev;
-	if (!idev)
-		printk(KERN_DEBUG "isdn_ppp_write: idev == NULL\n");
-	else {
+	return;
+}
+
+/*
+ * bind isdn_net_local <=> ippp-device
+ */
+int
+isdn_ppp_bind(isdn_net_dev *idev)
+{
+	int unit = 0;
+	unsigned long flags;
+	int retval = 0;
+	struct ipppd *ipppd;
+
+	if (idev->ipppd) {
+		isdn_BUG();
+		return 0;
+	}
+
+	spin_lock_irqsave(&ipppds_lock, flags);
+	if (idev->pppbind < 0) {  /* device bound to ippp device ? */
+		struct list_head *l;
+		char exclusive[ISDN_MAX_CHANNELS];	/* exclusive flags */
+		memset(exclusive, 0, ISDN_MAX_CHANNELS);
+		/* step through net devices to find exclusive minors */
+		list_for_each(l, &isdn_net_devs) {
+			isdn_net_dev *p = list_entry(l, isdn_net_dev, global_list);
+			if (p->pppbind >= 0 && p->pppbind < ISDN_MAX_CHANNELS)
+				exclusive[p->pppbind] = 1;
+		}
 		/*
-		 * Don't reset huptimer for
-		 * LCP packets. (Echo requests).
+		 * search a free device / slot
 		 */
-		if (copy_from_user(protobuf, buf, 4)) {
-			retval = -EFAULT;
-			goto out;
+		list_for_each_entry(ipppd, &ipppds, ipppds) {
+			if (!ipppd)
+				continue;
+			if (ipppd->state != IPPPD_ST_OPEN)
+				continue;
+			if (!exclusive[ipppd->minor])
+				break;
+			goto found;
 		}
-		proto = PPP_PROTOCOL(protobuf);
-		if (proto != PPP_LCP)
-			idev->huptimer = 0;
-
-		if (idev->isdn_slot < 0) {
-			retval = 0;
-			goto out;
+	} else {
+		list_for_each_entry(ipppd, &ipppds, ipppds) {
+			if (!ipppd)
+				continue;
+			if (ipppd->state != IPPPD_ST_OPEN)
+				continue;
+			if (ipppd->minor == idev->pppbind)
+				goto found;
 		}
-		if ((dev->drv[isdn_slot_driver(idev->isdn_slot)]->flags & DRV_FLAG_RUNNING) &&
-		    isdn_net_online(idev)) {
-			unsigned short hl;
-			struct sk_buff *skb;
-			/*
-			 * we need to reserve enought space in front of
-			 * sk_buff. old call to dev_alloc_skb only reserved
-			 * 16 bytes, now we are looking what the driver want
-			 */
-			hl = isdn_slot_hdrlen(idev->isdn_slot);
-			skb = alloc_skb(hl+count, GFP_ATOMIC);
-			if (!skb) {
-				printk(KERN_WARNING "isdn_ppp_write: out of memory!\n");
-				retval = count;
-				goto out;
-			}
-			skb_reserve(skb, hl);
-			if (copy_from_user(skb_put(skb, count), buf, count))
-			{
-				kfree_skb(skb);
-				retval = -EFAULT;
-				goto out;
-			}
-			if (is->debug & 0x40) {
-				printk(KERN_DEBUG "ppp xmit: len %d\n", (int) skb->len);
-				isdn_ppp_frame_log("xmit", skb->data, skb->len, 32,is->unit,idev->ppp_slot);
-			}
+	}
 
-			isdn_ppp_send_ccp(idev,idev->mlp,skb); /* keeps CCP/compression states in sync */
+	printk(KERN_INFO "isdn_ppp_bind: no ipppd\n");
+	retval = -ESRCH;
+	goto err;
 
-			isdn_net_write_super(idev, skb);
-		}
+ found:
+	unit = isdn_ppp_if_get_unit(idev->name);	/* get unit number from interface name .. ugly! */
+	if (unit < 0) {
+		printk(KERN_INFO "isdn_ppp_bind: illegal interface name %s.\n", idev->name);
+		retval = -ENODEV;
+		goto err;
 	}
-	retval = count;
 	
+	ipppd->unit = unit;
+	ipppd->state = IPPPD_ST_ASSIGNED;
+	ipppd->idev = idev;
+	/* we hold a reference until isdn_ppp_unbind() */
+	idev->ipppd = ipppd_get(ipppd);
+	spin_unlock_irqrestore(&ipppds_lock, flags);
+
+	idev->pppcfg = 0;         /* config flags */
+	/* seq no last seen, maybe set to bundle min, when joining? */
+	idev->pppseq = -1;
+
+	idev->ccp = ippp_ccp_alloc();
+	if (!idev->ccp) {
+		retval = -ENOMEM;
+		goto out;
+	}
+	idev->ccp->proto       = PPP_COMPFRAG;
+	idev->ccp->priv        = idev;
+	idev->ccp->alloc_skb   = isdn_ppp_dev_alloc_skb;
+	idev->ccp->push_header = isdn_ppp_dev_push_header;
+	idev->ccp->xmit        = isdn_ppp_dev_xmit;
+	idev->ccp->kick_up     = isdn_ppp_dev_kick_up;
+
+#ifdef CONFIG_ISDN_MPP
+	retval = isdn_ppp_mp_init(lp, NULL);
+#endif /* CONFIG_ISDN_MPP */
  out:
-	unlock_kernel();
+	if (retval) {
+		idev->ipppd->state = IPPPD_ST_OPEN;
+		ipppd_put(idev->ipppd);
+		idev->ipppd = NULL;
+	}
+
+	return retval;
+
+ err:
+	spin_unlock_irqrestore(&ipppds_lock, flags);
 	return retval;
 }
 
-struct file_operations isdn_ppp_fops =
+/*
+ * kick the ipppd on the device
+ * (wakes up daemon after B-channel connect)
+ */
+
+static void
+isdn_ppp_connected(isdn_net_dev *idev)
 {
-	.owner		= THIS_MODULE,
-	.llseek		= no_llseek,
-	.read		= isdn_ppp_read,
-	.write		= isdn_ppp_write,
-	.poll		= isdn_ppp_poll,
-	.ioctl		= isdn_ppp_ioctl,
-	.open		= isdn_ppp_open,
-	.release	= isdn_ppp_release,
-};
+	struct ipppd *ipppd = idev->ipppd;
+
+	ipppd_debug(ipppd, "");
+
+	ipppd->state  = IPPPD_ST_CONNECTED;
+	ipppd->flags |= IPPPD_FL_WAKEUP;
+	wake_up(&ipppd->wq);
+}
+
+static void
+isdn_ppp_disconnected(isdn_net_dev *idev)
+{
+	struct ipppd *ipppd = idev->ipppd;
+
+	ipppd_debug(ipppd, "");
+
+	if (idev->pppcfg & SC_ENABLE_IP)
+		isdn_net_offline(idev);
+
+	if (ipppd->state != IPPPD_ST_CONNECTED)
+		isdn_BUG();
+	
+	ipppd->state  = IPPPD_ST_ASSIGNED;
+	ipppd->flags |= IPPPD_FL_HUP;
+	wake_up(&ipppd->wq);
+
+#ifdef CONFIG_ISDN_MPP
+	spin_lock(&idev->pb->lock);
+	if (lp->netdev->pb->ref_ct == 1)	/* last link in queue? */
+		isdn_ppp_mp_cleanup(lp);
+
+	lp->netdev->pb->ref_ct--;
+	spin_unlock(&lp->netdev->pb->lock);
+#endif /* CONFIG_ISDN_MPP */
+
+}
 
 /*
  * init memory, structures etc.
@@ -808,37 +831,17 @@ struct file_operations isdn_ppp_fops =
 int
 isdn_ppp_init(void)
 {
-	int i,
-	 j;
-	 
 #ifdef CONFIG_ISDN_MPP
 	if( isdn_ppp_mp_bundle_array_init() < 0 )
 		return -ENOMEM;
 #endif /* CONFIG_ISDN_MPP */
 
-	for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
-		if (!(ippp_table[i] = (struct ippp_struct *)
-		      kmalloc(sizeof(struct ippp_struct), GFP_KERNEL))) {
-			printk(KERN_WARNING "isdn_ppp_init: Could not alloc ippp_table\n");
-			for (j = 0; j < i; j++)
-				kfree(ippp_table[j]);
-			return -1;
-		}
-		memset((char *) ippp_table[i], 0, sizeof(struct ippp_struct));
-		ippp_table[i]->state = 0;
-		skb_queue_head_init(&ippp_table[i]->rq);
-	}
 	return 0;
 }
 
 void
 isdn_ppp_cleanup(void)
 {
-	int i;
-
-	for (i = 0; i < ISDN_MAX_CHANNELS; i++)
-		kfree(ippp_table[i]);
-
 #ifdef CONFIG_ISDN_MPP
 	if (isdn_ppp_bundle_arr)
 		kfree(isdn_ppp_bundle_arr);
@@ -850,25 +853,31 @@ isdn_ppp_cleanup(void)
  * check for address/control field and skip if allowed
  * retval != 0 -> discard packet silently
  */
-static int isdn_ppp_skip_ac(struct ippp_struct *is, struct sk_buff *skb) 
+static int isdn_ppp_skip_ac(isdn_net_dev *idev, struct sk_buff *skb) 
 {
+	u8 val;
+
 	if (skb->len < 1)
 		return -1;
 
-	if (skb->data[0] == 0xff) {
-		if (skb->len < 2)
-			return -1;
-
-		if (skb->data[1] != 0x03)
+	get_u8(skb->data, &val);
+	if (val != PPP_ALLSTATIONS) {
+		/* if AC compression was not negotiated, but no AC present,
+		   discard packet */
+		if (idev->pppcfg & SC_REJ_COMP_AC)
 			return -1;
 
-		// skip address/control (AC) field
-		skb_pull(skb, 2);
-	} else { 
-		if (is->pppcfg & SC_REJ_COMP_AC)
-			// if AC compression was not negotiated, but used, discard packet
-			return -1;
+		return 0;
 	}
+	if (skb->len < 2)
+		return -1;
+
+	get_u8(skb->data + 1, &val);
+	if (val != PPP_UI)
+		return -1;
+
+	/* skip address/control (AC) field */
+	skb_pull(skb, 2);
 	return 0;
 }
 
@@ -876,84 +885,80 @@ static int isdn_ppp_skip_ac(struct ippp_struct *is, struct sk_buff *skb)
  * get the PPP protocol header and pull skb
  * retval < 0 -> discard packet silently
  */
-static int isdn_ppp_strip_proto(struct sk_buff *skb) 
+int isdn_ppp_strip_proto(struct sk_buff *skb) 
 {
-	int proto;
-	
+	u16 proto;
+	u8 val;
+
 	if (skb->len < 1)
 		return -1;
 
-	if (skb->data[0] & 0x1) {
-		// protocol field is compressed
-		proto = skb->data[0];
+	get_u8(skb->data, &val);
+	if (val & 0x1) {
+		/* protocol field is compressed */
+		proto = val;
 		skb_pull(skb, 1);
 	} else {
 		if (skb->len < 2)
 			return -1;
-		proto = ((int) skb->data[0] << 8) + skb->data[1];
+		get_u16(skb->data, &proto);
 		skb_pull(skb, 2);
 	}
 	return proto;
 }
 
-
 /*
  * handler for incoming packets on a syncPPP interface
  */
 static void isdn_ppp_receive(isdn_net_local *lp, isdn_net_dev *idev, 
 			     struct sk_buff *skb)
 {
-	struct ippp_struct *is;
-	int slot;
+	struct ipppd *is;
 	int proto;
 
-	/*
-	 * If encapsulation is syncppp, don't reset
-	 * huptimer on LCP packets.
-	 */
-	if (PPP_PROTOCOL(skb->data) != PPP_LCP)
-		idev->huptimer = 0;
-
-	slot = idev->ppp_slot;
-	if (slot < 0 || slot > ISDN_MAX_CHANNELS) {
-		printk(KERN_ERR "isdn_ppp_receive: lp->ppp_slot(%d)\n",
-		       slot);
-		kfree_skb(skb);
-		return;
-	}
-	is = ippp_table[slot];
+	is = idev->ipppd;
+	if (!is) 
+		goto err;
 
 	if (is->debug & 0x4) {
-		printk(KERN_DEBUG "ippp_receive: is:%p lp:%p slot:%d unit:%d len:%d\n",
-		       is,lp,idev->ppp_slot,is->unit,(int) skb->len);
-		isdn_ppp_frame_log("receive", skb->data, skb->len, 32,is->unit,idev->ppp_slot);
+		printk(KERN_DEBUG "ippp_receive: is:%p lp:%p unit:%d len:%d\n",
+		       is, lp, is->unit, skb->len);
+		isdn_ppp_frame_log("receive", skb->data, skb->len, 32,is->unit,-1);
 	}
 
- 	if (isdn_ppp_skip_ac(is, skb) < 0) {
- 		kfree_skb(skb);
- 		return;
- 	}
+ 	if (isdn_ppp_skip_ac(idev, skb) < 0)
+		goto err;
+
   	proto = isdn_ppp_strip_proto(skb);
- 	if (proto < 0) {
- 		kfree_skb(skb);
- 		return;
- 	}
+ 	if (proto < 0)
+		goto err;
+
+	/* Don't reset huptimer on LCP packets. */
+	if (proto != PPP_LCP)
+		idev->huptimer = 0;
   
 #ifdef CONFIG_ISDN_MPP
  	if (is->compflags & SC_LINK_DECOMP_ON) {
  		skb = isdn_ppp_decompress(skb, is, NULL, &proto);
  		if (!skb) // decompression error
- 			return;
+			goto put;
  	}
 	
  	if (!(is->mpppcfg & SC_REJ_MP_PROT)) { // we agreed to receive MPPP
   		if (proto == PPP_MP) {
   			isdn_ppp_mp_receive(lp, idev, skb);
- 			return;
+			goto put;
  		}
  	} 
-#endif
  	isdn_ppp_push_higher(lp, idev, skb, proto);
+ put:
+#else
+ 	isdn_ppp_push_higher(lp, idev, skb, proto);
+#endif
+	return;
+
+ err:
+	kfree_skb(skb);
 }
 
 /*
@@ -966,28 +971,16 @@ isdn_ppp_push_higher(isdn_net_local *lp, isdn_net_dev *idev,
 		     struct sk_buff *skb, int proto)
 {
 	struct net_device *dev = &lp->dev;
- 	struct ippp_struct *is, *mis;
-	int slot;
-
-	slot = idev->ppp_slot;
-	if (slot < 0 || slot > ISDN_MAX_CHANNELS) {
-		printk(KERN_ERR "isdn_ppp_push_higher: lp->ppp_slot(%d)\n",
-		       slot);
-		goto drop_packet;
-	}
-	is = ippp_table[slot];
- 	
- 	mis = ippp_table[slot];
+ 	struct ipppd *is = idev->ipppd;
 
 	if (is->debug & 0x10) {
 		printk(KERN_DEBUG "push, skb %d %04x\n", (int) skb->len, proto);
-		isdn_ppp_frame_log("rpush", skb->data, skb->len, 32,is->unit,slot);
+		isdn_ppp_frame_log("rpush", skb->data, skb->len, 32,is->unit, -1);
 	}
-	if (mis->compflags & SC_DECOMP_ON) {
-		skb = isdn_ppp_decompress(skb, is, mis, &proto);
-		if (!skb) // decompression error
-  			return;
-  	}
+	skb = ippp_ccp_decompress(lp->ccp, skb, &proto);
+	if (!skb) // decompression error
+		goto out;
+
 	switch (proto) {
 		case PPP_IPX:  /* untested */
 			if (is->debug & 0x20)
@@ -1002,19 +995,14 @@ isdn_ppp_push_higher(isdn_net_local *lp, isdn_net_dev *idev,
 		case PPP_COMP:
 		case PPP_COMPFRAG:
 			printk(KERN_INFO "isdn_ppp: unexpected compressed frame dropped\n");
-			goto drop_packet;
+			goto drop;
 #ifdef CONFIG_ISDN_PPP_VJ
 		case PPP_VJC_UNCOMP:
 			if (is->debug & 0x20)
 				printk(KERN_DEBUG "isdn_ppp: VJC_UNCOMP\n");
-			if (idev->ppp_slot < 0) {
-				printk(KERN_ERR "%s: net_dev->ppp_slot(%d) out of range\n",
-				       __FUNCTION__ , idev->ppp_slot);
-				goto drop_packet;
-			}
-			if (slhc_remember(ippp_table[idev->ppp_slot]->slcomp, skb->data, skb->len) <= 0) {
+			if (slhc_remember(lp->slcomp, skb->data, skb->len) <= 0) {
 				printk(KERN_WARNING "isdn_ppp: received illegal VJC_UNCOMP frame!\n");
-				goto drop_packet;
+				goto drop;
 			}
 			skb->protocol = htons(ETH_P_IP);
 			break;
@@ -1029,82 +1017,55 @@ isdn_ppp_push_higher(isdn_net_local *lp, isdn_net_dev *idev,
 				if (!skb) {
 					printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
 					skb = skb_old;
-					goto drop_packet;
+					goto drop;
 				}
 				skb_put(skb, skb_old->len + 128);
 				memcpy(skb->data, skb_old->data, skb_old->len);
-				if (idev->ppp_slot < 0) {
-					printk(KERN_ERR "%s: net_dev->ppp_slot(%d) out of range\n",
-					       __FUNCTION__ , idev->ppp_slot);
-					goto drop_packet;
-				}
-				pkt_len = slhc_uncompress(ippp_table[idev->ppp_slot]->slcomp,
+				pkt_len = slhc_uncompress(lp->slcomp,
 						skb->data, skb_old->len);
 				kfree_skb(skb_old);
 				if (pkt_len < 0)
-					goto drop_packet;
+					goto drop;
 
 				skb_trim(skb, pkt_len);
 				skb->protocol = htons(ETH_P_IP);
 			}
 			break;
 #endif
-		case PPP_CCP:
 		case PPP_CCPFRAG:
-			isdn_ppp_receive_ccp(idev,lp,skb,proto);
+			ippp_ccp_receive_ccp(idev->ccp, skb);
+			goto ccp;
+		case PPP_CCP:
+			ippp_ccp_receive_ccp(lp->ccp, skb);
+	ccp:
 			/* Dont pop up ResetReq/Ack stuff to the daemon any
 			   longer - the job is done already */
 			if(skb->data[0] == CCP_RESETREQ ||
 			   skb->data[0] == CCP_RESETACK)
-				break;
+				goto free;
 			/* fall through */
 		default:
-			isdn_ppp_fill_rq(skb->data, skb->len, proto, idev->ppp_slot);	/* push data to pppd device */
-			kfree_skb(skb);
-			return;
+			// FIXME use skb directly
+			ipppd_queue_read(is, proto, skb->data, skb->len);
+			goto free;
 	}
 
  	/* Reset hangup-timer */
  	idev->huptimer = 0;
 
 	skb->dev = dev;
-	skb->mac.raw = skb->data;
 	netif_rx(skb);
 	/* net_dev->local->stats.rx_packets++; done in isdn_net.c */
+ out:
 	return;
 
- drop_packet:
+ drop:
 	lp->stats.rx_dropped++;
+ free:
 	kfree_skb(skb);
 }
 
 /*
- * isdn_ppp_skb_push ..
- * checks whether we have enough space at the beginning of the skb
- * and allocs a new SKB if necessary
- */
-static unsigned char *isdn_ppp_skb_push(struct sk_buff **skb_p,int len)
-{
-	struct sk_buff *skb = *skb_p;
-
-	if(skb_headroom(skb) < len) {
-		struct sk_buff *nskb = skb_realloc_headroom(skb, len);
-
-		if (!nskb) {
-			printk(KERN_ERR "isdn_ppp_skb_push: can't realloc headroom!\n");
-			dev_kfree_skb(skb);
-			return NULL;
-		}
-		printk(KERN_DEBUG "isdn_ppp_skb_push:under %d %d\n",skb_headroom(skb),len);
-		dev_kfree_skb(skb);
-		*skb_p = nskb;
-		return skb_push(nskb, len);
-	}
-	return skb_push(skb,len);
-}
-
-
-/*
  * send ppp frame .. we expect a PIDCOMPressable proto --
  *  (here: currently always PPP_IP,PPP_VJC_COMP,PPP_VJC_UNCOMP)
  *
@@ -1118,30 +1079,13 @@ isdn_ppp_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 	isdn_net_local *mlp = ndev->priv;
 	isdn_net_dev *idev = list_entry(mlp->online.next, isdn_net_dev, online);
 	unsigned int proto = PPP_IP;     /* 0x21 */
-	struct ippp_struct *ipt,*ipts;
-	int slot;
+	struct ipppd *ipppd;
 
 	ndev->trans_start = jiffies;
 
 	if (list_empty(&mlp->online))
 		return isdn_net_autodial(skb, ndev);
 
-	slot = idev->ppp_slot;
-	if (slot < 0 || slot > ISDN_MAX_CHANNELS) {
-		printk(KERN_ERR "isdn_ppp_xmit: lp->ppp_slot(%d)\n",
-		       slot);
-		kfree_skb(skb);
-		return 0;
-	}
-	ipts = ippp_table[slot];
-
-	if (!(ipts->pppcfg & SC_ENABLE_IP)) {	/* PPP connected ? */
-		if (ipts->debug & 0x1)
-			printk(KERN_INFO "%s: IP frame delayed.\n", ndev->name);
-		netif_stop_queue(ndev);
-		return 1;
-	}
-
 	switch (ntohs(skb->protocol)) {
 		case ETH_P_IP:
 			proto = PPP_IP;
@@ -1153,42 +1097,32 @@ isdn_ppp_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 			printk(KERN_ERR "isdn_ppp: skipped unsupported protocol: %#x.\n", 
 			       skb->protocol);
 			dev_kfree_skb(skb);
-			return 0;
+			goto out;
 	}
 
-	idev = isdn_net_get_locked_dev(mlp);
+	idev = isdn_net_get_xmit_dev(mlp);
 	if (!idev) {
-		printk(KERN_WARNING "%s: all channels busy - requeuing!\n", ndev->name);
-		netif_stop_queue(ndev);
-		return 1;
+		printk(KERN_INFO "%s: IP frame delayed.\n", ndev->name);
+		goto stop;
 	}
-	/* we have our lp locked from now on */
-	slot = idev->ppp_slot;
-	if (slot < 0 || slot > ISDN_MAX_CHANNELS) {
-		printk(KERN_ERR "isdn_ppp_xmit: lp->ppp_slot(%d)\n",
-		       slot);
-		kfree_skb(skb);
-		return 0;
+	if (!(idev->pppcfg & SC_ENABLE_IP)) {	/* PPP connected ? */
+		isdn_BUG();
+		goto stop;
 	}
-	ipt = ippp_table[slot];
+	ipppd = idev->ipppd;
 	idev->huptimer = 0;
 
 	/*
 	 * after this line .. requeueing in the device queue is no longer allowed!!!
 	 */
 
-	/* Pull off the fake header we stuck on earlier to keep
-	 * the fragmentation code happy.
-	 */
-	skb_pull(skb,IPPP_MAX_HEADER);
-
-	if (ipt->debug & 0x4)
+	if (ipppd->debug & 0x4)
 		printk(KERN_DEBUG "xmit skb, len %d\n", (int) skb->len);
-        if (ipts->debug & 0x40)
-                isdn_ppp_frame_log("xmit0", skb->data, skb->len, 32,ipts->unit,idev->ppp_slot);
+        if (ipppd->debug & 0x40)
+                isdn_ppp_frame_log("xmit0", skb->data, skb->len, 32, ipppd->unit, -1);
 
 #ifdef CONFIG_ISDN_PPP_VJ
-	if (proto == PPP_IP && ipts->pppcfg & SC_COMP_TCP) {	/* ipts here? probably yes, but check this again */
+	if (proto == PPP_IP && idev->pppcfg & SC_COMP_TCP) {	/* ipts here? probably yes, but check this again */
 		struct sk_buff *new_skb;
 	        unsigned short hl;
 		/*
@@ -1213,8 +1147,8 @@ isdn_ppp_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 			skb_put(new_skb, skb->len);
 			buf = skb->data;
 
-			pktlen = slhc_compress(ipts->slcomp, skb->data, skb->len, new_skb->data,
-				 &buf, !(ipts->pppcfg & SC_NO_TCP_CCID));
+			pktlen = slhc_compress(mlp->slcomp, skb->data, skb->len, new_skb->data,
+				 &buf, !(idev->pppcfg & SC_NO_TCP_CCID));
 
 			if (buf != skb->data) {	
 				if (new_skb->data != buf)
@@ -1241,17 +1175,9 @@ isdn_ppp_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 	/*
 	 * normal (single link) or bundle compression
 	 */
-	if(ipts->compflags & SC_COMP_ON) {
-		/* We send compressed only if both down- und upstream
-		   compression is negotiated, that means, CCP is up */
-		if(ipts->compflags & SC_DECOMP_ON) {
-			skb = isdn_ppp_compress(skb,&proto,ipt,ipts,0);
-		} else {
-			printk(KERN_DEBUG "isdn_ppp: CCP not yet up - sending as-is\n");
-		}
-	}
+	skb = ippp_ccp_compress(mlp->ccp, skb, &proto);
 
-	if (ipt->debug & 0x24)
+	if (ipppd->debug & 0x24)
 		printk(KERN_DEBUG "xmit2 skb, len %d, proto %04x\n", (int) skb->len, proto);
 
 #ifdef CONFIG_ISDN_MPP
@@ -1281,45 +1207,29 @@ isdn_ppp_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 	}
 #endif
 
+#if 0
 	/*
 	 * 'link in bundle' compression  ...
 	 */
-	if(ipt->compflags & SC_LINK_COMP_ON)
+	if (ipt->compflags & SC_LINK_COMP_ON)
 		skb = isdn_ppp_compress(skb,&proto,ipt,ipts,1);
+#endif
 
-	if( (ipt->pppcfg & SC_COMP_PROT) && (proto <= 0xff) ) {
-		unsigned char *data = isdn_ppp_skb_push(&skb,1);
-		if(!data)
-			goto unlock;
-		data[0] = proto & 0xff;
-	}
-	else {
-		unsigned char *data = isdn_ppp_skb_push(&skb,2);
-		if(!data)
-			goto unlock;
-		data[0] = (proto >> 8) & 0xff;
-		data[1] = proto & 0xff;
-	}
-	if(!(ipt->pppcfg & SC_COMP_AC)) {
-		unsigned char *data = isdn_ppp_skb_push(&skb,2);
-		if(!data)
-			goto unlock;
-		data[0] = 0xff;    /* All Stations */
-		data[1] = 0x03;    /* Unnumbered information */
-	}
-
-	/* tx-stats are now updated via BSENT-callback */
+	isdn_ppp_push_header(idev, skb, proto);
 
-	if (ipts->debug & 0x40) {
+	if (ipppd->debug & 0x40) {
 		printk(KERN_DEBUG "skb xmit: len: %d\n", (int) skb->len);
-		isdn_ppp_frame_log("xmit", skb->data, skb->len, 32,ipt->unit,idev->ppp_slot);
+		isdn_ppp_frame_log("xmit", skb->data, skb->len, 32, ipppd->unit, -1);
 	}
 	
 	isdn_net_writebuf_skb(idev, skb);
 
- unlock:
-	spin_unlock_bh(&idev->xmit_lock);
+ out:
 	return 0;
+
+ stop:
+	netif_stop_queue(ndev);
+	return 1;
 }
 
 #ifdef CONFIG_ISDN_MPP
@@ -1372,7 +1282,7 @@ static ippp_bundle * isdn_ppp_mp_bundle_alloc(void)
 static int isdn_ppp_mp_init( isdn_net_local * lp, ippp_bundle * add_to )
 {
 	isdn_net_dev *idev = lp->netdev;
-	struct ippp_struct * is;
+	struct ipppd * is;
 
 	if (idev->ppp_slot < 0) {
 		printk(KERN_ERR "%s: >ppp_slot(%d) out of range\n",
@@ -1396,7 +1306,7 @@ static int isdn_ppp_mp_init( isdn_net_local * lp, ippp_bundle * add_to )
 	}
 	lp->netdev->pb->ref_ct++;
 	
-	is->last_link_seqno = 0;
+	is->pppseq = 0;
 	return 0;
 }
 
@@ -1413,7 +1323,7 @@ static void isdn_ppp_mp_receive(isdn_net_local *lp, isdn_net_dev *dev,
 				struct sk_buff *skb)
 {
 	isdn_net_dev *idev = lp->netdev;
-	struct ippp_struct *is;
+	struct ipppd *is;
 	isdn_net_dev *qdev;
 	ippp_bundle * mp;
 	isdn_mppp_stats * stats;
@@ -1442,7 +1352,7 @@ static void isdn_ppp_mp_receive(isdn_net_local *lp, isdn_net_dev *dev,
 		isdn_ppp_mp_print_recv_pkt(slot, skb);
 
 	newseq = isdn_ppp_mp_get_seq(is->mpppcfg & SC_IN_SHORT_SEQ, 
-						skb, is->last_link_seqno);
+						skb, is->pppseq);
 
 
 	/* if this packet seq # is less than last already processed one,
@@ -1460,14 +1370,14 @@ static void isdn_ppp_mp_receive(isdn_net_local *lp, isdn_net_dev *dev,
 	}
 	
 	/* find the minimum received sequence number over all links */
-	is->last_link_seqno = minseq = newseq;
+	is->pppseq = minseq = newseq;
 	list_for_each_entry(qdev, &lp->online, online) {
 		slot = qdev->ppp_slot;
 		if (slot < 0 || slot > ISDN_MAX_CHANNELS) {
 			printk(KERN_ERR "%s: lpq->ppp_slot(%d)\n",
 			       __FUNCTION__ ,slot);
 		} else {
-			u32 lls = ippp_table[slot]->last_link_seqno;
+			u32 lls = ippp_table[slot]->pppseq;
 			if (MP_LT(lls, minseq))
 				minseq = lls;
 		}
@@ -1754,7 +1664,7 @@ static void isdn_ppp_mp_print_recv_pkt( int slot, struct sk_buff * skb )
 }
 
 static int
-isdn_ppp_bundle(struct ippp_struct *is, int unit)
+isdn_ppp_bundle(struct ipppd *is, int unit)
 {
 	char ifn[IFNAMSIZ + 1];
 	isdn_net_dev *p;
@@ -1804,11 +1714,11 @@ out:
  */
 
 static int
-isdn_ppp_dev_ioctl_stats(int slot, struct ifreq *ifr, struct net_device *dev)
+isdn_ppp_dev_ioctl_stats(struct ifreq *ifr, struct net_device *dev)
 {
-	struct ppp_stats *res,
-	 t;
+	struct ppp_stats *res, t;
 	isdn_net_local *lp = (isdn_net_local *) dev->priv;
+	struct slcompress *slcomp;
 	int err;
 
 	res = (struct ppp_stats *) ifr->ifr_ifru.ifru_data;
@@ -1828,8 +1738,8 @@ isdn_ppp_dev_ioctl_stats(int slot, struct ifreq *ifr, struct net_device *dev)
 		t.p.ppp_obytes = lp->stats.tx_bytes;
 		t.p.ppp_oerrors = lp->stats.tx_errors;
 #ifdef CONFIG_ISDN_PPP_VJ
-		if (slot >= 0 && ippp_table[slot]->slcomp) {
-			struct slcompress *slcomp = ippp_table[slot]->slcomp;
+		slcomp = lp->slcomp;
+		if (slcomp) {
 			t.vj.vjs_packets = slcomp->sls_o_compressed + slcomp->sls_o_uncompressed;
 			t.vj.vjs_compressed = slcomp->sls_o_compressed;
 			t.vj.vjs_searches = slcomp->sls_o_searches;
@@ -1858,17 +1768,18 @@ isdn_ppp_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 		return -EINVAL;
 
 	switch (cmd) {
-		case SIOCGPPPVER:
-			r = (char *) ifr->ifr_ifru.ifru_data;
-			len = strlen(PPP_VERSION) + 1;
-			if(copy_to_user(r, PPP_VERSION, len)) error = -EFAULT;
-			break;
-		case SIOCGPPPSTATS:
-			error = isdn_ppp_dev_ioctl_stats(0, ifr, dev);
-			break;
-		default:
-			error = -EINVAL;
-			break;
+	case SIOCGPPPVER:
+		r = (char *) ifr->ifr_ifru.ifru_data;
+		len = strlen(PPP_VERSION) + 1;
+		if (copy_to_user(r, PPP_VERSION, len))
+			error = -EFAULT;
+		break;
+	case SIOCGPPPSTATS:
+		error = isdn_ppp_dev_ioctl_stats(ifr, dev);
+		break;
+	default:
+		error = -EINVAL;
+		break;
 	}
 	return error;
 }
@@ -1962,868 +1873,167 @@ isdn_ppp_hangup_slave(char *name)
 /* Push an empty CCP Data Frame up to the daemon to wake it up and let it
    generate a CCP Reset-Request or tear down CCP altogether */
 
-static void isdn_ppp_ccp_kickup(struct ippp_struct *is)
+static void isdn_ppp_dev_kick_up(void *priv)
 {
-	isdn_ppp_fill_rq(NULL, 0, PPP_COMP, is->idev->ppp_slot);
+	isdn_net_dev *idev = priv;
+
+	ipppd_queue_read(idev->ipppd, PPP_COMPFRAG, NULL, 0);
 }
 
-/* In-kernel handling of CCP Reset-Request and Reset-Ack is necessary,
-   but absolutely nontrivial. The most abstruse problem we are facing is
-   that the generation, reception and all the handling of timeouts and
-   resends including proper request id management should be entirely left
-   to the (de)compressor, but indeed is not covered by the current API to
-   the (de)compressor. The API is a prototype version from PPP where only
-   some (de)compressors have yet been implemented and all of them are
-   rather simple in their reset handling. Especially, their is only one
-   outstanding ResetAck at a time with all of them and ResetReq/-Acks do
-   not have parameters. For this very special case it was sufficient to
-   just return an error code from the decompressor and have a single
-   reset() entry to communicate all the necessary information between
-   the framework and the (de)compressor. Bad enough, LZS is different
-   (and any other compressor may be different, too). It has multiple
-   histories (eventually) and needs to Reset each of them independently
-   and thus uses multiple outstanding Acks and history numbers as an
-   additional parameter to Reqs/Acks.
-   All that makes it harder to port the reset state engine into the
-   kernel because it is not just the same simple one as in (i)pppd but
-   it must be able to pass additional parameters and have multiple out-
-   standing Acks. We are trying to achieve the impossible by handling
-   reset transactions independent by their id. The id MUST change when
-   the data portion changes, thus any (de)compressor who uses more than
-   one resettable state must provide and recognize individual ids for
-   each individual reset transaction. The framework itself does _only_
-   differentiate them by id, because it has no other semantics like the
-   (de)compressor might.
-   This looks like a major redesign of the interface would be nice,
-   but I don't have an idea how to do it better. */
-
-/* Send a CCP Reset-Request or Reset-Ack directly from the kernel. This is
-   getting that lengthy because there is no simple "send-this-frame-out"
-   function above but every wrapper does a bit different. Hope I guess
-   correct in this hack... */
-
-static void isdn_ppp_ccp_xmit_reset(struct ippp_struct *is, int proto,
-				    unsigned char code, unsigned char id,
-				    unsigned char *data, int len)
+static void isdn_ppp_lp_kick_up(void *priv)
 {
-	struct sk_buff *skb;
-	unsigned char *p;
-	int hl;
-	int cnt = 0;
-	isdn_net_dev *idev = is->idev;
-
-	/* Alloc large enough skb */
-	hl = isdn_slot_hdrlen(idev->isdn_slot);
-	skb = alloc_skb(len + hl + 16,GFP_ATOMIC);
-	if(!skb) {
-		printk(KERN_WARNING
-		       "ippp: CCP cannot send reset - out of memory\n");
-		return;
-	}
-	skb_reserve(skb, hl);
-
-	/* We may need to stuff an address and control field first */
-	if(!(is->pppcfg & SC_COMP_AC)) {
-		p = skb_put(skb, 2);
-		*p++ = 0xff;
-		*p++ = 0x03;
-	}
+	isdn_net_local *lp = priv;
+	isdn_net_dev *idev;
 
-	/* Stuff proto, code, id and length */
-	p = skb_put(skb, 6);
-	*p++ = (proto >> 8);
-	*p++ = (proto & 0xff);
-	*p++ = code;
-	*p++ = id;
-	cnt = 4 + len;
-	*p++ = (cnt >> 8);
-	*p++ = (cnt & 0xff);
-
-	/* Now stuff remaining bytes */
-	if(len) {
-		p = skb_put(skb, len);
-		memcpy(p, data, len);
+	if (list_empty(&lp->online)) {
+		isdn_BUG();
+		return;
 	}
-
-	/* skb is now ready for xmit */
-	printk(KERN_DEBUG "Sending CCP Frame:\n");
-	isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, is->unit,idev->ppp_slot);
-
-	isdn_net_write_super(idev, skb);
+	idev = list_entry(lp->online.next, isdn_net_dev, online);
+	ipppd_queue_read(idev->ipppd, PPP_COMP, NULL, 0);
 }
 
-/* Allocate the reset state vector */
-static struct ippp_ccp_reset *isdn_ppp_ccp_reset_alloc(struct ippp_struct *is)
-{
-	struct ippp_ccp_reset *r;
-	r = kmalloc(sizeof(struct ippp_ccp_reset), GFP_KERNEL);
-	if(!r) {
-		printk(KERN_ERR "ippp_ccp: failed to allocate reset data"
-		       " structure - no mem\n");
-		return NULL;
-	}
-	memset(r, 0, sizeof(struct ippp_ccp_reset));
-	printk(KERN_DEBUG "ippp_ccp: allocated reset data structure %p\n", r);
-	is->reset = r;
-	return r;
-}
+/* Send a CCP Reset-Request or Reset-Ack directly from the kernel. */
 
-/* Destroy the reset state vector. Kill all pending timers first. */
-static void isdn_ppp_ccp_reset_free(struct ippp_struct *is)
+static struct sk_buff *
+__isdn_ppp_alloc_skb(isdn_net_dev *idev, int len, unsigned int gfp_mask)
 {
-	unsigned int id;
+	int hl = IPPP_MAX_HEADER + isdn_slot_hdrlen(idev->isdn_slot); 
+	struct sk_buff *skb;
 
-	printk(KERN_DEBUG "ippp_ccp: freeing reset data structure %p\n",
-	       is->reset);
-	for(id = 0; id < 256; id++) {
-		if(is->reset->rs[id]) {
-			isdn_ppp_ccp_reset_free_state(is, (unsigned char)id);
-		}
-	}
-	kfree(is->reset);
-	is->reset = NULL;
-}
+	skb = alloc_skb(hl + len, gfp_mask);
+	if (!skb)
+		return NULL;
 
-/* Free a given state and clear everything up for later reallocation */
-static void isdn_ppp_ccp_reset_free_state(struct ippp_struct *is,
-					  unsigned char id)
-{
-	struct ippp_ccp_reset_state *rs;
-
-	if(is->reset->rs[id]) {
-		printk(KERN_DEBUG "ippp_ccp: freeing state for id %d\n", id);
-		rs = is->reset->rs[id];
-		/* Make sure the kernel will not call back later */
-		if(rs->ta)
-			del_timer(&rs->timer);
-		is->reset->rs[id] = NULL;
-		kfree(rs);
-	} else {
-		printk(KERN_WARNING "ippp_ccp: id %d is not allocated\n", id);
-	}
+	skb_reserve(skb, hl);
+	return skb;
 }
 
-/* The timer callback function which is called when a ResetReq has timed out,
-   aka has never been answered by a ResetAck */
-static void isdn_ppp_ccp_timer_callback(unsigned long closure)
+static struct sk_buff *
+isdn_ppp_dev_alloc_skb(void *priv, int len, int gfp_mask)
 {
-	struct ippp_ccp_reset_state *rs =
-		(struct ippp_ccp_reset_state *)closure;
+	isdn_net_dev *idev = priv;
 
-	if(!rs) {
-		printk(KERN_ERR "ippp_ccp: timer cb with zero closure.\n");
-		return;
-	}
-	if(rs->ta && rs->state == CCPResetSentReq) {
-		/* We are correct here */
-		if(!rs->expra) {
-			/* Hmm, there is no Ack really expected. We can clean
-			   up the state now, it will be reallocated if the
-			   decompressor insists on another reset */
-			rs->ta = 0;
-			isdn_ppp_ccp_reset_free_state(rs->is, rs->id);
-			return;
-		}
-		printk(KERN_DEBUG "ippp_ccp: CCP Reset timed out for id %d\n",
-		       rs->id);
-		/* Push it again */
-		isdn_ppp_ccp_xmit_reset(rs->is, PPP_CCP, CCP_RESETREQ, rs->id,
-					rs->data, rs->dlen);
-		/* Restart timer */
-		rs->timer.expires = jiffies + HZ*5;
-		add_timer(&rs->timer);
-	} else {
-		printk(KERN_WARNING "ippp_ccp: timer cb in wrong state %d\n",
-		       rs->state);
-	}
+	return __isdn_ppp_alloc_skb(idev, len, gfp_mask);
 }
 
-/* Allocate a new reset transaction state */
-static struct ippp_ccp_reset_state *isdn_ppp_ccp_reset_alloc_state(struct ippp_struct *is,
-						      unsigned char id)
+static struct sk_buff *
+isdn_ppp_lp_alloc_skb(void *priv, int len, int gfp_mask)
 {
-	struct ippp_ccp_reset_state *rs;
-	if(is->reset->rs[id]) {
-		printk(KERN_WARNING "ippp_ccp: old state exists for id %d\n",
-		       id);
+	isdn_net_local *lp = priv;
+	isdn_net_dev *idev;
+
+	if (list_empty(&lp->online)) {
+		isdn_BUG();
 		return NULL;
-	} else {
-		rs = kmalloc(sizeof(struct ippp_ccp_reset_state), GFP_KERNEL);
-		if(!rs)
-			return NULL;
-		memset(rs, 0, sizeof(struct ippp_ccp_reset_state));
-		rs->state = CCPResetIdle;
-		rs->is = is;
-		rs->id = id;
-		rs->timer.data = (unsigned long)rs;
-		rs->timer.function = isdn_ppp_ccp_timer_callback;
-		is->reset->rs[id] = rs;
 	}
-	return rs;
+	idev = list_entry(lp->online.next, isdn_net_dev, online);
+	return __isdn_ppp_alloc_skb(idev, len, gfp_mask);
 }
 
-
-/* A decompressor wants a reset with a set of parameters - do what is
-   necessary to fulfill it */
-static void isdn_ppp_ccp_reset_trans(struct ippp_struct *is,
-				     struct isdn_ppp_resetparams *rp)
+static void
+isdn_ppp_dev_push_header(void *priv, struct sk_buff *skb, u16 proto)
 {
-	struct ippp_ccp_reset_state *rs;
-
-	if(rp->valid) {
-		/* The decompressor defines parameters by itself */
-		if(rp->rsend) {
-			/* And he wants us to send a request */
-			if(!(rp->idval)) {
-				printk(KERN_ERR "ippp_ccp: decompressor must"
-				       " specify reset id\n");
-				return;
-			}
-			if(is->reset->rs[rp->id]) {
-				/* There is already a transaction in existence
-				   for this id. May be still waiting for a
-				   Ack or may be wrong. */
-				rs = is->reset->rs[rp->id];
-				if(rs->state == CCPResetSentReq && rs->ta) {
-					printk(KERN_DEBUG "ippp_ccp: reset"
-					       " trans still in progress"
-					       " for id %d\n", rp->id);
-				} else {
-					printk(KERN_WARNING "ippp_ccp: reset"
-					       " trans in wrong state %d for"
-					       " id %d\n", rs->state, rp->id);
-				}
-			} else {
-				/* Ok, this is a new transaction */
-				printk(KERN_DEBUG "ippp_ccp: new trans for id"
-				       " %d to be started\n", rp->id);
-				rs = isdn_ppp_ccp_reset_alloc_state(is, rp->id);
-				if(!rs) {
-					printk(KERN_ERR "ippp_ccp: out of mem"
-					       " allocing ccp trans\n");
-					return;
-				}
-				rs->state = CCPResetSentReq;
-				rs->expra = rp->expra;
-				if(rp->dtval) {
-					rs->dlen = rp->dlen;
-					memcpy(rs->data, rp->data, rp->dlen);
-				}
-				/* HACK TODO - add link comp here */
-				isdn_ppp_ccp_xmit_reset(is, PPP_CCP,
-							CCP_RESETREQ, rs->id,
-							rs->data, rs->dlen);
-				/* Start the timer */
-				rs->timer.expires = jiffies + 5*HZ;
-				add_timer(&rs->timer);
-				rs->ta = 1;
-			}
-		} else {
-			printk(KERN_DEBUG "ippp_ccp: no reset sent\n");
-		}
-	} else {
-		/* The reset params are invalid. The decompressor does not
-		   care about them, so we just send the minimal requests
-		   and increase ids only when an Ack is received for a
-		   given id */
-		if(is->reset->rs[is->reset->lastid]) {
-			/* There is already a transaction in existence
-			   for this id. May be still waiting for a
-			   Ack or may be wrong. */
-			rs = is->reset->rs[is->reset->lastid];
-			if(rs->state == CCPResetSentReq && rs->ta) {
-				printk(KERN_DEBUG "ippp_ccp: reset"
-				       " trans still in progress"
-				       " for id %d\n", rp->id);
-			} else {
-				printk(KERN_WARNING "ippp_ccp: reset"
-				       " trans in wrong state %d for"
-				       " id %d\n", rs->state, rp->id);
-			}
-		} else {
-			printk(KERN_DEBUG "ippp_ccp: new trans for id"
-			       " %d to be started\n", is->reset->lastid);
-			rs = isdn_ppp_ccp_reset_alloc_state(is,
-							    is->reset->lastid);
-			if(!rs) {
-				printk(KERN_ERR "ippp_ccp: out of mem"
-				       " allocing ccp trans\n");
-				return;
-			}
-			rs->state = CCPResetSentReq;
-			/* We always expect an Ack if the decompressor doesnt
-			   know	better */
-			rs->expra = 1;
-			rs->dlen = 0;
-			/* HACK TODO - add link comp here */
-			isdn_ppp_ccp_xmit_reset(is, PPP_CCP, CCP_RESETREQ,
-						rs->id, NULL, 0);
-			/* Start the timer */
-			rs->timer.expires = jiffies + 5*HZ;
-			add_timer(&rs->timer);
-			rs->ta = 1;
-		}
-	}
-}
+	isdn_net_dev *idev = priv;
 
-/* An Ack was received for this id. This means we stop the timer and clean
-   up the state prior to calling the decompressors reset routine. */
-static void isdn_ppp_ccp_reset_ack_rcvd(struct ippp_struct *is,
-					unsigned char id)
-{
-	struct ippp_ccp_reset_state *rs = is->reset->rs[id];
-
-	if(rs) {
-		if(rs->ta && rs->state == CCPResetSentReq) {
-			/* Great, we are correct */
-			if(!rs->expra)
-				printk(KERN_DEBUG "ippp_ccp: ResetAck received"
-				       " for id %d but not expected\n", id);
-		} else {
-			printk(KERN_INFO "ippp_ccp: ResetAck received out of"
-			       "sync for id %d\n", id);
-		}
-		if(rs->ta) {
-			rs->ta = 0;
-			del_timer(&rs->timer);
-		}
-		isdn_ppp_ccp_reset_free_state(is, id);
-	} else {
-		printk(KERN_INFO "ippp_ccp: ResetAck received for unknown id"
-		       " %d\n", id);
-	}
-	/* Make sure the simple reset stuff uses a new id next time */
-	is->reset->lastid++;
+	isdn_ppp_push_header(idev, skb, proto);
 }
 
-/* 
- * decompress packet
- *
- * if master = 0, we're trying to uncompress an per-link compressed packet,
- * as opposed to an compressed reconstructed-from-MPPP packet.
- * proto is updated to protocol field of uncompressed packet.
- *
- * retval: decompressed packet,
- *         same packet if uncompressed,
- *	   NULL if decompression error
- */
-
-static struct sk_buff *isdn_ppp_decompress(struct sk_buff *skb,struct ippp_struct *is,struct ippp_struct *master,
-	int *proto)
+static void
+isdn_ppp_lp_push_header(void *priv, struct sk_buff *skb, u16 proto)
 {
-	void *stat = NULL;
-	struct isdn_ppp_compressor *ipc = NULL;
-	struct sk_buff *skb_out;
-	int len;
-	struct ippp_struct *ri;
-	struct isdn_ppp_resetparams rsparm;
-	unsigned char rsdata[IPPP_RESET_MAXDATABYTES];
-
-	if(!master) {
-		// per-link decompression 
-		stat = is->link_decomp_stat;
-		ipc = is->link_decompressor;
-		ri = is;
-	} else {
-		stat = master->decomp_stat;
-		ipc = master->decompressor;
-		ri = master;
-	}
-
-	if (!ipc) {
-		// no decompressor -> we can't decompress.
-		printk(KERN_DEBUG "ippp: no decompressor defined!\n");
-		return skb;
-	}
-	if (!stat) // if we have a compressor, stat has been set as well
-		BUG();
-
-	if((master && *proto == PPP_COMP) || (!master && *proto == PPP_COMPFRAG) ) {
-		// compressed packets are compressed by their protocol type
+	isdn_net_local *lp = priv;
+	isdn_net_dev *idev;
 
-		// Set up reset params for the decompressor
-  		memset(&rsparm, 0, sizeof(rsparm));
-  		rsparm.data = rsdata;
-  		rsparm.maxdlen = IPPP_RESET_MAXDATABYTES;
-  
-  		skb_out = dev_alloc_skb(is->mru + PPP_HDRLEN);
-		len = ipc->decompress(stat, skb, skb_out, &rsparm);
-		kfree_skb(skb);
-		if (len <= 0) {
-			switch(len) {
-			case DECOMP_ERROR:
-				printk(KERN_INFO "ippp: decomp wants reset %s params\n",
-				       rsparm.valid ? "with" : "without");
-				
-				isdn_ppp_ccp_reset_trans(ri, &rsparm);
-				break;
-			case DECOMP_FATALERROR:
-				ri->pppcfg |= SC_DC_FERROR;
-				/* Kick ipppd to recognize the error */
-				isdn_ppp_ccp_kickup(ri);
-				break;
-			}
-			kfree_skb(skb_out);
-			return NULL;
-		}
-		*proto = isdn_ppp_strip_proto(skb_out);
-		if (*proto < 0) {
-			kfree_skb(skb_out);
-			return NULL;
-		}
-		return skb_out;
-	} else { 
-		// uncompressed packets are fed through the decompressor to
-		// update the decompressor state
-		ipc->incomp(stat, skb, *proto);
-		return skb;
+	if (list_empty(&lp->online)) {
+		isdn_BUG();
+		return;
 	}
+	idev = list_entry(lp->online.next, isdn_net_dev, online);
+	isdn_ppp_push_header(idev, skb, proto);
 }
 
-/*
- * compress a frame 
- *   type=0: normal/bundle compression
- *       =1: link compression
- * returns original skb if we haven't compressed the frame
- * and a new skb pointer if we've done it
- */
-static struct sk_buff *isdn_ppp_compress(struct sk_buff *skb_in,int *proto,
-	struct ippp_struct *is,struct ippp_struct *master,int type)
+static void
+isdn_ppp_dev_xmit(void *priv, struct sk_buff *skb)
 {
-    int ret;
-    int new_proto;
-    struct isdn_ppp_compressor *compressor;
-    void *stat;
-    struct sk_buff *skb_out;
-
-	/* we do not compress control protocols */
-    if(*proto < 0 || *proto > 0x3fff) {
-	    return skb_in;
-    }
-
-	if(type) { /* type=1 => Link compression */
-		return skb_in;
-	}
-	else {
-		if(!master) {
-			compressor = is->compressor;
-			stat = is->comp_stat;
-		}
-		else {
-			compressor = master->compressor;
-			stat = master->comp_stat;
-		}
-		new_proto = PPP_COMP;
-	}
-
-	if(!compressor) {
-		printk(KERN_ERR "isdn_ppp: No compressor set!\n");
-		return skb_in;
-	}
-	if(!stat) {
-		printk(KERN_ERR "isdn_ppp: Compressor not initialized?\n");
-		return skb_in;
-	}
+	isdn_net_dev *idev = priv;
 
-	/* Allow for at least 150 % expansion (for now) */
-	skb_out = alloc_skb(skb_in->len + skb_in->len/2 + 32 +
-		skb_headroom(skb_in), GFP_ATOMIC);
-	if(!skb_out)
-		return skb_in;
-	skb_reserve(skb_out, skb_headroom(skb_in));
-
-	ret = (compressor->compress)(stat,skb_in,skb_out,*proto);
-	if(!ret) {
-		dev_kfree_skb(skb_out);
-		return skb_in;
-	}
-	
-	dev_kfree_skb(skb_in);
-	*proto = new_proto;
-	return skb_out;
+	isdn_net_write_super(idev, skb);
 }
 
-/*
- * we received a CCP frame .. 
- * not a clean solution, but we MUST handle a few cases in the kernel
- */
-static void isdn_ppp_receive_ccp(isdn_net_dev *idev, isdn_net_local *lp,
-	 struct sk_buff *skb,int proto)
+static void
+isdn_ppp_lp_xmit(void *priv, struct sk_buff *skb)
 {
-	struct ippp_struct *is;
-	struct ippp_struct *mis;
-	int len;
-	struct isdn_ppp_resetparams rsparm;
-	unsigned char rsdata[IPPP_RESET_MAXDATABYTES];	
+	isdn_net_local *lp = priv;
+	isdn_net_dev *idev;
 
-	printk(KERN_DEBUG "Received CCP frame from peer slot(%d)\n",
-	       idev->ppp_slot);
-	if (idev->ppp_slot < 0 || idev->ppp_slot > ISDN_MAX_CHANNELS) {
-		printk(KERN_ERR "%s: ppp_slot(%d) out of range\n",
-		       __FUNCTION__ , idev->ppp_slot);
+	if (list_empty(&lp->online)) {
+		isdn_BUG();
 		return;
 	}
-	is = ippp_table[idev->ppp_slot];
-	isdn_ppp_frame_log("ccp-rcv", skb->data, skb->len, 32, is->unit,idev->ppp_slot);
-
-	mis = is;
-
-	switch(skb->data[0]) {
-	case CCP_CONFREQ:
-		if(is->debug & 0x10)
-			printk(KERN_DEBUG "Disable compression here!\n");
-		if(proto == PPP_CCP)
-			mis->compflags &= ~SC_COMP_ON;		
-		else
-			is->compflags &= ~SC_LINK_COMP_ON;		
-		break;
-	case CCP_TERMREQ:
-	case CCP_TERMACK:
-		if(is->debug & 0x10)
-			printk(KERN_DEBUG "Disable (de)compression here!\n");
-		if(proto == PPP_CCP)
-			mis->compflags &= ~(SC_DECOMP_ON|SC_COMP_ON);		
-		else
-			is->compflags &= ~(SC_LINK_DECOMP_ON|SC_LINK_COMP_ON);		
-		break;
-	case CCP_CONFACK:
-		/* if we RECEIVE an ackowledge we enable the decompressor */
-		if(is->debug & 0x10)
-			printk(KERN_DEBUG "Enable decompression here!\n");
-		if(proto == PPP_CCP) {
-			if (!mis->decompressor)
-				break;
-			mis->compflags |= SC_DECOMP_ON;
-		} else {
-			if (!is->decompressor)
-				break;
-			is->compflags |= SC_LINK_DECOMP_ON;
-		}
-		break;
-
-	case CCP_RESETACK:
-		printk(KERN_DEBUG "Received ResetAck from peer\n");
-		len = (skb->data[2] << 8) | skb->data[3];
-		len -= 4;
-
-		if(proto == PPP_CCP) {
-			/* If a reset Ack was outstanding for this id, then
-			   clean up the state engine */
-			isdn_ppp_ccp_reset_ack_rcvd(mis, skb->data[1]);
-			if(mis->decompressor && mis->decomp_stat)
-				mis->decompressor->
-					reset(mis->decomp_stat,
-					      skb->data[0],
-					      skb->data[1],
-					      len ? &skb->data[4] : NULL,
-					      len, NULL);
-			/* TODO: This is not easy to decide here */
-			mis->compflags &= ~SC_DECOMP_DISCARD;
-		}
-		else {
-			isdn_ppp_ccp_reset_ack_rcvd(is, skb->data[1]);
-			if(is->link_decompressor && is->link_decomp_stat)
-				is->link_decompressor->
-					reset(is->link_decomp_stat,
-					      skb->data[0],
-					      skb->data[1],
-					      len ? &skb->data[4] : NULL,
-					      len, NULL);
-			/* TODO: neither here */
-			is->compflags &= ~SC_LINK_DECOMP_DISCARD;
-		}
-		break;
-
-	case CCP_RESETREQ:
-		printk(KERN_DEBUG "Received ResetReq from peer\n");
-		/* Receiving a ResetReq means we must reset our compressor */
-		/* Set up reset params for the reset entry */
-		memset(&rsparm, 0, sizeof(rsparm));
-		rsparm.data = rsdata;
-		rsparm.maxdlen = IPPP_RESET_MAXDATABYTES; 
-		/* Isolate data length */
-		len = (skb->data[2] << 8) | skb->data[3];
-		len -= 4;
-		if(proto == PPP_CCP) {
-			if(mis->compressor && mis->comp_stat)
-				mis->compressor->
-					reset(mis->comp_stat,
-					      skb->data[0],
-					      skb->data[1],
-					      len ? &skb->data[4] : NULL,
-					      len, &rsparm);
-		}
-		else {
-			if(is->link_compressor && is->link_comp_stat)
-				is->link_compressor->
-					reset(is->link_comp_stat,
-					      skb->data[0],
-					      skb->data[1],
-					      len ? &skb->data[4] : NULL,
-					      len, &rsparm);
-		}
-		/* Ack the Req as specified by rsparm */
-		if(rsparm.valid) {
-			/* Compressor reset handler decided how to answer */
-			if(rsparm.rsend) {
-				/* We should send a Frame */
-				isdn_ppp_ccp_xmit_reset(is, proto, CCP_RESETACK,
-							rsparm.idval ? rsparm.id
-							: skb->data[1],
-							rsparm.dtval ?
-							rsparm.data : NULL,
-							rsparm.dtval ?
-							rsparm.dlen : 0);
-			} else {
-				printk(KERN_DEBUG "ResetAck suppressed\n");
-			}
-		} else {
-			/* We answer with a straight reflected Ack */
-			isdn_ppp_ccp_xmit_reset(is, proto, CCP_RESETACK,
-						skb->data[1],
-						len ? &skb->data[4] : NULL,
-						len);
-		}
-		break;
-	}
+	idev = list_entry(lp->online.next, isdn_net_dev, online);
+	isdn_net_write_super(idev, skb);
 }
 
-
-/*
- * Daemon sends a CCP frame ...
- */
-
-/* TODO: Clean this up with new Reset semantics */
-
-/* I believe the CCP handling as-is is done wrong. Compressed frames
- * should only be sent/received after CCP reaches UP state, which means
- * both sides have sent CONF_ACK. Currently, we handle both directions
- * independently, which means we may accept compressed frames too early
- * (supposedly not a problem), but may also mean we send compressed frames
- * too early, which may turn out to be a problem.
- * This part of state machine should actually be handled by (i)pppd, but
- * that's too big of a change now. --kai
- */
-
-/* Actually, we might turn this into an advantage: deal with the RFC in
- * the old tradition of beeing generous on what we accept, but beeing
- * strict on what we send. Thus we should just
- * - accept compressed frames as soon as decompression is negotiated
- * - send compressed frames only when decomp *and* comp are negotiated
- * - drop rx compressed frames if we cannot decomp (instead of pushing them
- *   up to ipppd)
- * and I tried to modify this file according to that. --abp
- */
-
-static void isdn_ppp_send_ccp(isdn_net_dev *idev, isdn_net_local *lp, struct sk_buff *skb)
+static int
+isdn_ppp_set_compressor(isdn_net_dev *idev, struct isdn_ppp_comp_data *data)
 {
-	struct ippp_struct *mis,*is;
-	int proto, slot = idev->ppp_slot;
-	unsigned char *data;
-
-	if(!skb || skb->len < 3)
-		return;
-	if (slot < 0 || slot > ISDN_MAX_CHANNELS) {
-		printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
-		       __FUNCTION__ , slot);
-		return;
-	}	
-	is = ippp_table[slot];
-	/* Daemon may send with or without address and control field comp */
-	data = skb->data;
-	if(!(is->pppcfg & SC_COMP_AC) && data[0] == 0xff && data[1] == 0x03) {
-		data += 2;
-		if(skb->len < 5)
-			return;
-	}
-
-	proto = ((int)data[0]<<8)+data[1];
-	if(proto != PPP_CCP && proto != PPP_CCPFRAG)
-		return;
+	struct ippp_ccp *ccp;
 
-	printk(KERN_DEBUG "Received CCP frame from daemon:\n");
-	isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, is->unit,idev->ppp_slot);
+	if (data->flags & IPPP_COMP_FLAG_LINK)
+		ccp = idev->ccp;
+	else
+		ccp = idev->mlp->ccp;
 
-	mis = is;
-	if (mis != is)
-		printk(KERN_DEBUG "isdn_ppp: Ouch! Master CCP sends on slave slot!\n");
-	
-        switch(data[2]) {
-	case CCP_CONFREQ:
-		if(is->debug & 0x10)
-			printk(KERN_DEBUG "Disable decompression here!\n");
-		if(proto == PPP_CCP)
-			is->compflags &= ~SC_DECOMP_ON;
-		else
-			is->compflags &= ~SC_LINK_DECOMP_ON;
-		break;
-	case CCP_TERMREQ:
-	case CCP_TERMACK:
-		if(is->debug & 0x10)
-			printk(KERN_DEBUG "Disable (de)compression here!\n");
-		if(proto == PPP_CCP)
-			is->compflags &= ~(SC_DECOMP_ON|SC_COMP_ON);
-		else
-			is->compflags &= ~(SC_LINK_DECOMP_ON|SC_LINK_COMP_ON);
-		break;
-	case CCP_CONFACK:
-		/* if we SEND an ackowledge we can/must enable the compressor */
-		if(is->debug & 0x10)
-			printk(KERN_DEBUG "Enable compression here!\n");
-		if(proto == PPP_CCP) {
-			if (!is->compressor)
-				break;
-			is->compflags |= SC_COMP_ON;
-		} else {
-			if (!is->compressor)
-				break;
-			is->compflags |= SC_LINK_COMP_ON;
-		}
-		break;
-	case CCP_RESETACK:
-		/* If we send a ACK we should reset our compressor */
-		if(is->debug & 0x10)
-			printk(KERN_DEBUG "Reset decompression state here!\n");
-		printk(KERN_DEBUG "ResetAck from daemon passed by\n");
-		if(proto == PPP_CCP) {
-			/* link to master? */
-			if(is->compressor && is->comp_stat)
-				is->compressor->reset(is->comp_stat, 0, 0,
-						      NULL, 0, NULL);
-			is->compflags &= ~SC_COMP_DISCARD;	
-		}
-		else {
-			if(is->link_compressor && is->link_comp_stat)
-				is->link_compressor->reset(is->link_comp_stat,
-							   0, 0, NULL, 0, NULL);
-			is->compflags &= ~SC_LINK_COMP_DISCARD;	
-		}
-		break;
-	case CCP_RESETREQ:
-		/* Just let it pass by */
-		printk(KERN_DEBUG "ResetReq from daemon passed by\n");
-		break;
-	}
+	return ippp_ccp_set_compressor(ccp, idev->ipppd->unit, data);
 }
 
-int isdn_ppp_register_compressor(struct isdn_ppp_compressor *ipc)
-{
-	ipc->next = ipc_head;
-	ipc->prev = NULL;
-	if(ipc_head) {
-		ipc_head->prev = ipc;
-	}
-	ipc_head = ipc;
-	return 0;
-}
+// ISDN_NET_ENCAP_SYNCPPP
+// ======================================================================
 
-int isdn_ppp_unregister_compressor(struct isdn_ppp_compressor *ipc)
+static int
+isdn_ppp_open(isdn_net_local *lp)
 {
-	if(ipc->prev)
-		ipc->prev->next = ipc->next;
-	else
-		ipc_head = ipc->next;
-	if(ipc->next)
-		ipc->next->prev = ipc->prev;
-	ipc->prev = ipc->next = NULL;
-	return 0;
-}
+	lp->mpppcfg = 0;        /* mppp configuration */
+	lp->mp_seqno = 0;       /* MP sequence number */
 
-static int isdn_ppp_set_compressor(struct ippp_struct *is, struct isdn_ppp_comp_data *data)
-{
-	struct isdn_ppp_compressor *ipc = ipc_head;
-	int ret;
-	void *stat;
-	int num = data->num;
-
-	if(is->debug & 0x10)
-		printk(KERN_DEBUG "[%d] Set %s type %d\n",is->unit,
-			(data->flags&IPPP_COMP_FLAG_XMIT)?"compressor":"decompressor",num);
-
-	/* If is has no valid reset state vector, we cannot allocate a
-	   decompressor. The decompressor would cause reset transactions
-	   sooner or later, and they need that vector. */
-
-	if(!(data->flags & IPPP_COMP_FLAG_XMIT) && !is->reset) {
-		printk(KERN_ERR "ippp_ccp: no reset data structure - can't"
-		       " allow decompression.\n");
+#ifdef CONFIG_ISDN_PPP_VJ
+	lp->slcomp = slhc_init(16, 16);
+#endif
+	lp->ccp = ippp_ccp_alloc();
+	if (!lp->ccp)
 		return -ENOMEM;
-	}
+	lp->ccp->proto       = PPP_COMP;
+	lp->ccp->priv        = lp;
+	lp->ccp->alloc_skb   = isdn_ppp_lp_alloc_skb;
+	lp->ccp->push_header = isdn_ppp_lp_push_header;
+	lp->ccp->xmit        = isdn_ppp_lp_xmit;
+	lp->ccp->kick_up     = isdn_ppp_lp_kick_up;
 
-	while(ipc) {
-		if(ipc->num == num) {
-			stat = ipc->alloc(data);
-			if(stat) {
-				ret = ipc->init(stat,data,is->unit,0);
-				if(!ret) {
-					printk(KERN_ERR "Can't init (de)compression!\n");
-					ipc->free(stat);
-					stat = NULL;
-					break;
-				}
-			}
-			else {
-				printk(KERN_ERR "Can't alloc (de)compression!\n");
-				break;
-			}
-
-                        if(data->flags & IPPP_COMP_FLAG_XMIT) {
-				if(data->flags & IPPP_COMP_FLAG_LINK) {
-					if(is->link_comp_stat)
-						is->link_compressor->free(is->link_comp_stat);
-					is->link_comp_stat = stat;
-                                	is->link_compressor = ipc;
-				}
-				else {
-					if(is->comp_stat)
-						is->compressor->free(is->comp_stat);
-					is->comp_stat = stat;
-                                	is->compressor = ipc;
-				}
-			}
-                        else {
-				if(data->flags & IPPP_COMP_FLAG_LINK) {
-					if(is->link_decomp_stat)
-						is->link_decompressor->free(is->link_decomp_stat);
-					is->link_decomp_stat = stat;
-        	                        is->link_decompressor = ipc;
-				}
-				else {
-					if(is->decomp_stat)
-						is->decompressor->free(is->decomp_stat);
-					is->decomp_stat = stat;
-        	                        is->decompressor = ipc;
-				}
-			}
-			return 0;
-		}
-		ipc = ipc->next;
-	}
-	return -EINVAL;
+	return 0;
 }
 
-// ISDN_NET_ENCAP_SYNCPPP
-// ======================================================================
-
-static int
-isdn_ppp_header(struct sk_buff *skb, struct net_device *dev,
-		unsigned short type, void *daddr, void *saddr, 
-		unsigned plen)
+static void
+isdn_ppp_close(isdn_net_local *lp)
 {
-	skb_push(skb, IPPP_MAX_HEADER);
-
-	return IPPP_MAX_HEADER;
+#ifdef CONFIG_ISDN_PPP_VJ
+	slhc_free(lp->slcomp);
+	lp->slcomp = NULL;
+#endif
+	ippp_ccp_free(lp->ccp);
+	lp->ccp = NULL;
 }
 
 struct isdn_netif_ops isdn_ppp_ops = {
 	.hard_start_xmit     = isdn_ppp_start_xmit,
-	.hard_header         = isdn_ppp_header,
 	.do_ioctl            = isdn_ppp_dev_ioctl,
 	.flags               = IFF_NOARP | IFF_POINTOPOINT,
 	.type                = ARPHRD_PPP,
 	.receive             = isdn_ppp_receive,
-	.connected           = isdn_ppp_wakeup_daemon,
+	.connected           = isdn_ppp_connected,
+	.disconnected        = isdn_ppp_disconnected,
 	.bind                = isdn_ppp_bind,
-	.unbind              = isdn_ppp_free,
-	
+	.unbind              = isdn_ppp_unbind,
+	.open                = isdn_ppp_open,
+	.close               = isdn_ppp_close,
 };
diff --git a/drivers/isdn/i4l/isdn_ppp.h b/drivers/isdn/i4l/isdn_ppp.h
index af6f50fd11db..20745b31ef1d 100644
--- a/drivers/isdn/i4l/isdn_ppp.h
+++ b/drivers/isdn/i4l/isdn_ppp.h
@@ -15,17 +15,15 @@
 extern struct file_operations isdn_ppp_fops;
 extern struct isdn_netif_ops isdn_ppp_ops;
 
-extern int isdn_ppp_init(void);
-extern void isdn_ppp_cleanup(void);
-extern int isdn_ppp_dial_slave(char *);
-extern int isdn_ppp_hangup_slave(char *);
+int isdn_ppp_init(void);
+void isdn_ppp_cleanup(void);
+int isdn_ppp_dial_slave(char *);
+int isdn_ppp_hangup_slave(char *);
 
-#define IPPP_OPEN	0x01
-#define IPPP_CONNECT	0x02
-#define IPPP_CLOSEWAIT	0x04
-#define IPPP_NOBLOCK	0x08
-#define IPPP_ASSIGNED	0x10
+void
+isdn_ppp_frame_log(char *info, char *data, int len, int maxlen, 
+		   int unit, int slot);
+int
+isdn_ppp_strip_proto(struct sk_buff *skb);
 
 #define IPPP_MAX_HEADER 10
-
-
diff --git a/drivers/isdn/i4l/isdn_ppp_ccp.c b/drivers/isdn/i4l/isdn_ppp_ccp.c
new file mode 100644
index 000000000000..ab573e7a6376
--- /dev/null
+++ b/drivers/isdn/i4l/isdn_ppp_ccp.c
@@ -0,0 +1,601 @@
+
+#include "isdn_ppp_ccp.h"
+#include "isdn_common.h"
+#include "isdn_net.h"
+#include "isdn_ppp.h"
+#include <linux/ppp-comp.h>
+
+/* In-kernel handling of CCP Reset-Request and Reset-Ack is necessary,
+   but absolutely nontrivial. The most abstruse problem we are facing is
+   that the generation, reception and all the handling of timeouts and
+   resends including proper request id management should be entirely left
+   to the (de)compressor, but indeed is not covered by the current API to
+   the (de)compressor. The API is a prototype version from PPP where only
+   some (de)compressors have yet been implemented and all of them are
+   rather simple in their reset handling. Especially, their is only one
+   outstanding ResetAck at a time with all of them and ResetReq/-Acks do
+   not have parameters. For this very special case it was sufficient to
+   just return an error code from the decompressor and have a single
+   reset() entry to communicate all the necessary information between
+   the framework and the (de)compressor. Bad enough, LZS is different
+   (and any other compressor may be different, too). It has multiple
+   histories (eventually) and needs to Reset each of them independently
+   and thus uses multiple outstanding Acks and history numbers as an
+   additional parameter to Reqs/Acks.
+   All that makes it harder to port the reset state engine into the
+   kernel because it is not just the same simple one as in (i)pppd but
+   it must be able to pass additional parameters and have multiple out-
+   standing Acks. We are trying to achieve the impossible by handling
+   reset transactions independent by their id. The id MUST change when
+   the data portion changes, thus any (de)compressor who uses more than
+   one resettable state must provide and recognize individual ids for
+   each individual reset transaction. The framework itself does _only_
+   differentiate them by id, because it has no other semantics like the
+   (de)compressor might.
+   This looks like a major redesign of the interface would be nice,
+   but I don't have an idea how to do it better. */
+
+/* ====================================================================== */
+
+/* Free a given state and clear everything up for later reallocation */
+static void
+ippp_ccp_reset_free_state(struct ippp_ccp *ccp, unsigned char id)
+{
+	struct ippp_ccp_reset_state *rs	= ccp->reset->rs[id];
+
+	if (!rs)
+		return;
+	
+	if (rs->ta) // FIXME?
+		del_timer_sync(&rs->timer);
+
+	kfree(rs);
+	ccp->reset->rs[id] = NULL;
+}
+
+static void
+do_xmit_reset(struct ippp_ccp *ccp, unsigned char code, unsigned char id,
+	      unsigned char *data, int len)
+{
+	struct sk_buff *skb;
+	unsigned char *p;
+	u16 proto = ccp->proto == PPP_COMP ? PPP_CCP : PPP_CCPFRAG;
+
+	skb = ccp->alloc_skb(ccp->priv, 4 + len, GFP_ATOMIC);
+	ccp->push_header(ccp->priv, skb, proto);
+
+	p = skb_put(skb, 4);
+	p += put_u8 (p, code);
+	p += put_u8 (p, id);
+	p += put_u16(p, len + 4);
+
+	if (len)
+		memcpy(skb_put(skb, len), data, len);
+
+	isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, -1, -1);
+
+	ccp->xmit(ccp->priv, skb);
+}
+
+/* The timer callback function which is called when a ResetReq has timed out,
+   aka has never been answered by a ResetAck */
+static void
+isdn_ppp_ccp_timer_callback(unsigned long data)
+{
+	struct ippp_ccp_reset_state *rs = (struct ippp_ccp_reset_state *) data;
+
+	if (!rs->ta) {
+		isdn_BUG();
+		return;
+	}
+	if (rs->state != CCPResetSentReq) {
+		printk(KERN_WARNING "ippp_ccp: timer cb in wrong state %d\n",
+		       rs->state);
+		rs->ta = 0;
+		return;
+	}
+	/* We are correct here */
+	if (!rs->expra) {
+		/* Hmm, there is no Ack really expected. We can clean
+		   up the state now, it will be reallocated if the
+		   decompressor insists on another reset */
+		rs->ta = 0;
+		ippp_ccp_reset_free_state(rs->ccp, rs->id);
+		return;
+	}
+	printk(KERN_DEBUG "ippp_ccp: CCP Reset timed out for id %d\n",
+	       rs->id);
+	/* Push it again */
+	do_xmit_reset(rs->ccp, CCP_RESETREQ, rs->id, rs->data, rs->dlen);
+
+	mod_timer(&rs->timer, jiffies + 5 * HZ);
+}
+
+/* Allocate a new reset transaction state */
+static struct ippp_ccp_reset_state *
+ippp_ccp_reset_alloc_state(struct ippp_ccp *ccp, unsigned char id)
+{
+	struct ippp_ccp_reset_state *rs;
+
+	rs = kmalloc(sizeof(struct ippp_ccp_reset_state), GFP_KERNEL);
+	if(!rs)
+		return NULL;
+	memset(rs, 0, sizeof(struct ippp_ccp_reset_state));
+	rs->state = CCPResetIdle;
+	rs->ccp = ccp;
+	rs->id = id;
+	init_timer(&rs->timer);
+	rs->timer.data = (unsigned long)rs;
+	rs->timer.function = isdn_ppp_ccp_timer_callback;
+
+	ccp->reset->rs[id] = rs;
+	return rs;
+}
+
+/* A decompressor wants a reset with a set of parameters - do what is
+   necessary to fulfill it */
+static void
+ippp_ccp_reset_xmit(struct ippp_ccp *ccp,
+		    struct isdn_ppp_resetparams *rp)
+{
+	struct ippp_ccp_reset_state *rs;
+	int id;
+
+	if (rp->valid) {
+		/* The decompressor defines parameters by itself */
+		if (!rp->rsend)
+			return;
+
+		/* And it wants us to send a request */
+		if (!rp->idval) {
+			isdn_BUG();
+			return;
+		}
+		id = rp->id;
+	} else {
+		/* The reset params are invalid. The decompressor does not
+		   care about them, so we just send the minimal requests
+		   and increase ids only when an Ack is received for a
+		   given id */
+		id = ccp->reset->lastid++;
+		/* We always expect an Ack if the decompressor doesnt
+		   know	better */
+		rp->expra = 1;
+		rp->dtval = 0;
+	}
+	rs = ccp->reset->rs[id];
+	if (rs) {
+		printk(KERN_INFO "ippp_ccp: reset xmit in wrong state %d "
+		       "for id %d (%d)\n", rs->state, id, rs->ta);
+		return;
+	}
+	/* Ok, this is a new transaction */
+	printk(KERN_DEBUG "ippp_ccp: new xmit for id %d\n", id);
+	rs = ippp_ccp_reset_alloc_state(ccp, id);
+	if(!rs) {
+		printk(KERN_INFO "ippp_ccp: out of mem allocing ccp trans\n");
+		return;
+	}
+	rs->expra = rp->expra;
+	rs->id = id;
+	if (rp->dtval) {
+		rs->dlen = rp->dlen;
+		memcpy(rs->data, rp->data, rp->dlen);
+	} else {
+		rs->dlen = 0;
+	}
+
+	rs->state = CCPResetSentReq;
+	do_xmit_reset(rs->ccp, CCP_RESETREQ, rs->id, rs->data, rs->dlen);
+
+	/* Start the timer */
+	rs->timer.expires = jiffies + 5*HZ;
+	add_timer(&rs->timer);
+	rs->ta = 1;
+}
+
+/* ====================================================================== */
+
+struct ippp_ccp *
+ippp_ccp_alloc(void)
+{
+	struct ippp_ccp *ccp;
+
+	ccp = kmalloc(sizeof(*ccp), GFP_ATOMIC); // FIXME
+	memset(ccp, 0, sizeof(*ccp));
+	ccp->mru = 1524;      /* MRU, default 1524 */
+	ccp->reset = kmalloc(sizeof(*ccp->reset), GFP_ATOMIC); // FIXME alloc together?
+	if (!ccp->reset) {
+		kfree(ccp);
+		return NULL;
+	}
+	memset(ccp->reset, 0, sizeof(*ccp->reset));
+	return ccp;
+}
+
+void
+ippp_ccp_free(struct ippp_ccp *ccp)
+{
+	int id;
+
+	if (ccp->comp_stat)
+		ccp->compressor->free(ccp->comp_stat);
+	if (ccp->decomp_stat)
+		ccp->decompressor->free(ccp->decomp_stat);
+
+	for (id = 0; id < 256; id++) {
+		if (ccp->reset->rs[id])
+			ippp_ccp_reset_free_state(ccp, id);
+	}
+	kfree(ccp->reset);
+	kfree(ccp);
+}
+
+int
+ippp_ccp_set_mru(struct ippp_ccp *ccp, unsigned int mru)
+{
+	ccp->mru = mru;
+	return 0;
+}
+
+unsigned int
+ippp_ccp_get_flags(struct ippp_ccp *ccp)
+{
+	return ccp->compflags & (SC_DC_ERROR|SC_DC_FERROR);
+}
+
+/*
+ * compress a frame 
+ * returns original skb if we did not compress the frame
+ * and a new skb otherwise
+ */
+struct sk_buff *
+ippp_ccp_compress(struct ippp_ccp *ccp, struct sk_buff *skb_in, int *proto)
+{
+	struct sk_buff *skb;
+
+	if (!(ccp->compflags & (SC_COMP_ON|SC_DECOMP_ON))) {
+		/* We send compressed only if both down- und upstream
+		   compression is negotiated, that means, CCP is up */
+		return skb_in;
+	}
+	/* we do not compress control protocols */
+	if (*proto < 0 || *proto > 0x3fff) {
+		return skb_in;
+	}
+	if (!ccp->compressor || !ccp->comp_stat) {
+		isdn_BUG();
+		return skb_in;
+	}
+	/* Allow for at least 150 % expansion (for now) */
+	skb = alloc_skb(skb_in->len*2 + skb_headroom(skb_in), GFP_ATOMIC);
+	if (!skb)
+		return skb_in;
+
+	skb_reserve(skb, skb_headroom(skb_in));
+	if (!ccp->compressor->compress(ccp->comp_stat, skb_in, skb, *proto)) {
+		dev_kfree_skb(skb);
+		return skb_in;
+	}
+	isdn_ppp_frame_log("comp  in:", skb_in->data, skb_in->len, 20, -1, -1);
+	isdn_ppp_frame_log("comp out:", skb->data, skb->len, 20, -1, -1);
+	dev_kfree_skb(skb_in);
+	*proto = ccp->proto;
+	return skb;
+}
+
+/* 
+ * decompress packet
+ *
+ * proto is updated to protocol field of uncompressed packet.
+ * retval: decompressed packet,
+ *         same packet if uncompressed,
+ *	   NULL if decompression error
+ */
+
+struct sk_buff *
+ippp_ccp_decompress(struct ippp_ccp *ccp, struct sk_buff *skb_in, int *proto)
+{
+	struct sk_buff *skb;
+	struct isdn_ppp_resetparams rsparm;
+	unsigned char rsdata[IPPP_RESET_MAXDATABYTES];
+	int len;
+
+	if (!(ccp->compflags & SC_DECOMP_ON)) {
+		return skb_in;
+	}
+	if (!ccp->decompressor || !ccp->decomp_stat) {
+		isdn_BUG();
+		return skb_in;
+	}
+	if (*proto != ccp->proto) {
+		/* uncompressed packets are fed through the decompressor to
+		 * update the decompressor state */
+		ccp->decompressor->incomp(ccp->decomp_stat, skb_in, *proto);
+		return skb_in;
+	}
+	skb = dev_alloc_skb(ccp->mru + PPP_HDRLEN); // FIXME oom?
+
+	// Set up reset params for the decompressor
+	memset(&rsparm, 0, sizeof(rsparm));
+	rsparm.data = rsdata;
+	rsparm.maxdlen = IPPP_RESET_MAXDATABYTES;
+
+	len = ccp->decompressor->decompress(ccp->decomp_stat, skb_in, skb,
+					    &rsparm);
+	isdn_ppp_frame_log("deco  in:", skb_in->data, skb_in->len, 20, -1, -1);
+	isdn_ppp_frame_log("deco out:", skb->data, skb->len, 20, -1, -1);
+	kfree_skb(skb_in);
+
+	if (len <= 0) {
+		switch(len) {
+		case DECOMP_ERROR:
+			printk(KERN_INFO "ippp: decomp wants reset with%s params\n",
+			       rsparm.valid ? "" : "out");
+			
+			ippp_ccp_reset_xmit(ccp, &rsparm);
+			break;
+		case DECOMP_FATALERROR:
+			ccp->compflags |= SC_DC_FERROR;
+			/* Kick ipppd to recognize the error */
+			ccp->kick_up(ccp->priv);
+			break;
+		}
+		kfree_skb(skb);
+		return NULL;
+	}
+	*proto = isdn_ppp_strip_proto(skb);
+	if (*proto < 0) {
+		kfree_skb(skb);
+		return NULL;
+	}
+	return skb;
+}
+
+/* An Ack was received for this id. This means we stop the timer and clean
+   up the state prior to calling the decompressors reset routine. */
+static void
+isdn_ppp_ccp_reset_ack_rcvd(struct ippp_ccp *ccp, unsigned char id)
+{
+	struct ippp_ccp_reset_state *rs = ccp->reset->rs[id];
+
+	if (!rs) {
+		printk(KERN_INFO "ippp_ccp: ResetAck received for unknown id"
+		       " %d\n", id);
+		return;
+	}
+
+	if (rs->ta && rs->state == CCPResetSentReq) {
+		/* Great, we are correct */
+		if(!rs->expra)
+			printk(KERN_DEBUG "ippp_ccp: ResetAck received"
+			       " for id %d but not expected\n", id);
+	} else {
+		printk(KERN_INFO "ippp_ccp: ResetAck received out of"
+		       "sync for id %d\n", id);
+	}
+	if(rs->ta) {
+		rs->ta = 0;
+		del_timer(&rs->timer);
+	}
+	ippp_ccp_reset_free_state(ccp, id);
+}
+
+void
+ippp_ccp_receive_ccp(struct ippp_ccp *ccp, struct sk_buff *skb)
+{
+	int len;
+	struct isdn_ppp_resetparams rsparm;
+	unsigned char rsdata[IPPP_RESET_MAXDATABYTES];	
+
+	isdn_ppp_frame_log("ccp-recv", skb->data, skb->len, 32, -1, -1);
+
+	switch(skb->data[0]) {
+	case CCP_CONFREQ:
+		if (ccp->debug & 0x10)
+			printk(KERN_DEBUG "Disable compression here!\n");
+
+		ccp->compflags &= ~SC_COMP_ON;		
+		break;
+	case CCP_TERMREQ:
+	case CCP_TERMACK:
+		if (ccp->debug & 0x10)
+			printk(KERN_DEBUG "Disable (de)compression here!\n");
+
+		ccp->compflags &= ~(SC_DECOMP_ON|SC_COMP_ON);		
+		break;
+	case CCP_CONFACK:
+		/* if we RECEIVE an ackowledge we enable the decompressor */
+		if (ccp->debug & 0x10)
+			printk(KERN_DEBUG "Enable decompression here!\n");
+
+		if (!ccp->decomp_stat)
+			break;
+		ccp->compflags |= SC_DECOMP_ON;
+		break;
+	case CCP_RESETACK:
+		printk(KERN_DEBUG "Received ResetAck from peer\n");
+		len = (skb->data[2] << 8) | skb->data[3];
+		len -= 4;
+
+		/* If a reset Ack was outstanding for this id, then
+		   clean up the state engine */
+		isdn_ppp_ccp_reset_ack_rcvd(ccp, skb->data[1]);
+		if (ccp->decomp_stat)
+			ccp->decompressor->reset(ccp->decomp_stat,
+						 skb->data[0], skb->data[1],
+						 len ? &skb->data[4] : NULL,
+						 len, NULL);
+		/* TODO: This is not easy to decide here */
+		ccp->compflags &= ~SC_DECOMP_DISCARD;
+		break;
+	case CCP_RESETREQ:
+		printk(KERN_DEBUG "Received ResetReq from peer\n");
+		/* Receiving a ResetReq means we must reset our compressor */
+		/* Set up reset params for the reset entry */
+		memset(&rsparm, 0, sizeof(rsparm));
+		rsparm.data = rsdata;
+		rsparm.maxdlen = IPPP_RESET_MAXDATABYTES; 
+		/* Isolate data length */
+		len = (skb->data[2] << 8) | skb->data[3];
+		len -= 4;
+		if (ccp->comp_stat)
+			ccp->compressor->reset(ccp->comp_stat,
+					       skb->data[0], skb->data[1],
+					       len ? &skb->data[4] : NULL,
+					       len, &rsparm);
+		/* Ack the Req as specified by rsparm */
+		if (rsparm.valid) {
+			/* Compressor reset handler decided how to answer */
+			if (!rsparm.rsend) {
+				printk(KERN_DEBUG "ResetAck suppressed\n");
+				return;
+			}
+			/* We should send a Frame */
+			do_xmit_reset(ccp, CCP_RESETACK,
+				      rsparm.idval ? rsparm.id : skb->data[1],
+				      rsparm.data,
+				      rsparm.dtval ? rsparm.dlen : 0);
+			return;
+		}
+		/* We answer with a straight reflected Ack */
+		do_xmit_reset(ccp, CCP_RESETACK, skb->data[1], 
+			      skb->data + 4, len);
+	}
+}
+
+void
+ippp_ccp_send_ccp(struct ippp_ccp *ccp, struct sk_buff *skb)
+{
+	isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, -1, -1);
+
+        switch (skb->data[2]) {
+	case CCP_CONFREQ:
+		if (ccp->debug & 0x10)
+			printk(KERN_DEBUG "Disable decompression here!\n");
+
+		ccp->compflags &= ~SC_DECOMP_ON;
+		break;
+	case CCP_TERMREQ:
+	case CCP_TERMACK:
+		if (ccp->debug & 0x10)
+			printk(KERN_DEBUG "Disable (de)compression here!\n");
+
+		ccp->compflags &= ~(SC_DECOMP_ON|SC_COMP_ON);
+		break;
+	case CCP_CONFACK:
+		/* if we SEND an ackowledge we can/must enable the compressor */
+		if (ccp->debug & 0x10)
+			printk(KERN_DEBUG "Enable compression here!\n");
+
+		if (!ccp->compressor)
+			break;
+
+		ccp->compflags |= SC_COMP_ON;
+		break;
+	case CCP_RESETACK:
+		/* If we send a ACK we should reset our compressor */
+		if (ccp->debug & 0x10)
+			printk(KERN_DEBUG "Reset decompression state here!\n");
+
+		printk(KERN_DEBUG "ResetAck from daemon passed by\n");
+
+		if (!ccp->comp_stat)
+			break;
+
+		ccp->compressor->reset(ccp->comp_stat, 0, 0, NULL, 0, NULL);
+		ccp->compflags &= ~SC_COMP_DISCARD;	
+		break;
+	case CCP_RESETREQ:
+		/* Just let it pass by */
+		printk(KERN_DEBUG "ResetReq from daemon passed by\n");
+		break;
+	}
+}
+
+static struct isdn_ppp_compressor *ipc_head = NULL;
+
+int
+ippp_ccp_set_compressor(struct ippp_ccp *ccp, int unit,
+			struct isdn_ppp_comp_data *data)
+{
+	struct isdn_ppp_compressor *ipc = ipc_head;
+	int ret;
+	void *stat;
+	int num = data->num;
+
+	if (ccp->debug & 0x10)
+		printk(KERN_DEBUG "[%d] Set %scompressor type %d\n", unit,
+		       data->flags & IPPP_COMP_FLAG_XMIT ? "" : "de", num);
+
+	for (ipc = ipc_head; ipc; ipc = ipc->next) {
+		if (ipc->num != num)
+			continue;
+		
+		stat = ipc->alloc(data);
+		if (!stat) {
+			printk(KERN_ERR "Can't alloc (de)compression!\n");
+			break;
+		}
+		ret = ipc->init(stat, data, unit, 0);
+		if(!ret) {
+			printk(KERN_ERR "Can't init (de)compression!\n");
+			ipc->free(stat);
+			break;
+		}
+		if (data->flags & IPPP_COMP_FLAG_XMIT) {
+			if (ccp->comp_stat)
+				ccp->compressor->free(ccp->comp_stat);
+			ccp->comp_stat = stat;
+			ccp->compressor = ipc;
+		} else {
+			if (ccp->decomp_stat)
+				ccp->decompressor->free(ccp->decomp_stat);
+			ccp->decomp_stat = stat;
+			ccp->decompressor = ipc;
+		}
+		return 0;
+	}
+	return -EINVAL;
+}
+
+void
+ippp_ccp_get_compressors(unsigned long protos[8])
+{
+	struct isdn_ppp_compressor *ipc;
+	int i, j;
+
+	memset(protos, 0, sizeof(unsigned long) * 8);
+	for (ipc = ipc_head; ipc; ipc = ipc->next) {
+		j = ipc->num / (sizeof(long)*8);
+		i = ipc->num % (sizeof(long)*8);
+		if (j < 8)
+			protos[j] |= 1 << i;
+	}
+}
+
+int
+isdn_ppp_register_compressor(struct isdn_ppp_compressor *ipc)
+{
+	ipc->next = ipc_head;
+	ipc->prev = NULL;
+	if (ipc_head) {
+		ipc_head->prev = ipc;
+	}
+	ipc_head = ipc;
+	return 0;
+}
+
+int
+isdn_ppp_unregister_compressor(struct isdn_ppp_compressor *ipc)
+{
+	if (ipc->prev)
+		ipc->prev->next = ipc->next;
+	else
+		ipc_head = ipc->next;
+	if (ipc->next)
+		ipc->next->prev = ipc->prev;
+	ipc->prev = ipc->next = NULL;
+	return 0;
+}
+
diff --git a/drivers/isdn/i4l/isdn_ppp_ccp.h b/drivers/isdn/i4l/isdn_ppp_ccp.h
new file mode 100644
index 000000000000..d9ece852d24f
--- /dev/null
+++ b/drivers/isdn/i4l/isdn_ppp_ccp.h
@@ -0,0 +1,66 @@
+
+#include <linux/kernel.h>
+#include <linux/isdn_ppp.h>
+
+/* for ippp_ccp::flags */
+
+#define SC_DECOMP_ON		0x01
+#define SC_COMP_ON		0x02
+#define SC_DECOMP_DISCARD	0x04
+#define SC_COMP_DISCARD		0x08
+
+/* SC_DC_ERROR/FERROR go in here as well, but are defined elsewhere
+
+   #define SC_DC_FERROR	0x00800000
+   #define SC_DC_ERROR	0x00400000
+*/
+
+struct ippp_ccp {
+	int proto;
+	struct isdn_ppp_compressor *compressor;
+	struct isdn_ppp_compressor *decompressor;
+	void                       *comp_stat;
+	void                       *decomp_stat;
+	unsigned long               compflags;
+	struct ippp_ccp_reset      *reset;
+	int                         mru;
+	int                         debug;
+	void                       *priv;
+	void            (*xmit)(void *priv, struct sk_buff *skb);
+	void            (*kick_up)(void *priv);
+	void            (*push_header)(void *priv, struct sk_buff *skb, u16);
+	struct sk_buff *(*alloc_skb)(void *priv, int len, int gfp_mask);
+};
+
+struct ippp_ccp *
+ippp_ccp_alloc(void);
+
+void
+ippp_ccp_free(struct ippp_ccp *ccp);
+
+int
+ippp_ccp_set_mru(struct ippp_ccp *ccp, unsigned int mru);
+
+unsigned int
+ippp_ccp_get_flags(struct ippp_ccp *ccp);
+
+struct sk_buff *
+ippp_ccp_compress(struct ippp_ccp *ccp, struct sk_buff *skb, int *proto);
+
+struct sk_buff *
+ippp_ccp_decompress(struct ippp_ccp *ccp, struct sk_buff *skb, int *proto);
+
+void
+ippp_ccp_send_ccp(struct ippp_ccp *ccp, struct sk_buff *skb);
+
+void
+ippp_ccp_receive_ccp(struct ippp_ccp *ccp, struct sk_buff *skb);
+
+void
+ippp_ccp_get_compressors(unsigned long protos[8]);
+
+int
+ippp_ccp_set_compressor(struct ippp_ccp *ccp, int unit,
+			struct isdn_ppp_comp_data *data);
+
+
diff --git a/drivers/isdn/isdnloop/isdnloop.c b/drivers/isdn/isdnloop/isdnloop.c
index e757d5063398..612c7b19c85a 100644
--- a/drivers/isdn/isdnloop/isdnloop.c
+++ b/drivers/isdn/isdnloop/isdnloop.c
@@ -11,11 +11,12 @@
 
 #include <linux/config.h>
 #include <linux/module.h>
+#include <linux/interrupt.h>
 #include <linux/init.h>
 #include "isdnloop.h"
 
 static char *revision = "$Revision: 1.11.6.7 $";
-static char *isdnloop_id;
+static char *isdnloop_id = "loop0";
 
 MODULE_DESCRIPTION("ISDN4Linux: Pseudo Driver that simulates an ISDN card");
 MODULE_AUTHOR("Fritz Elfert");
@@ -76,7 +77,7 @@ isdnloop_bchan_send(isdnloop_card * card, int ch)
 			};
 			cmd.command = ISDN_STAT_BSENT;
 			cmd.parm.length = len;
-			if ( ack ) card->interface.statcallb(&cmd);
+			card->interface.statcallb(&cmd);
 		} else
 			card->sndcount[ch] = 0;
 	}
@@ -421,8 +422,9 @@ isdnloop_sendbuf(int channel, struct sk_buff *skb, isdnloop_card * card)
 			return 0;
 		save_flags(flags);
 		cli();
-		nskb = skb_clone(skb, GFP_ATOMIC);
+		nskb = dev_alloc_skb(skb->len);
 		if (nskb) {
+			memcpy(skb_put(nskb, len), skb->data, len);
 			skb_queue_tail(&card->bqueue[channel], nskb);
 			dev_kfree_skb(skb);
 		} else
diff --git a/include/linux/isdn.h b/include/linux/isdn.h
index 8203314e2cb7..0d0ce25b333e 100644
--- a/include/linux/isdn.h
+++ b/include/linux/isdn.h
@@ -338,16 +338,35 @@ typedef struct isdn_net_local_s {
 				       /* phone[0] = Incoming Numbers      */
 				       /* phone[1] = Outgoing Numbers      */
 
-  struct list_head       slaves;       /* list of all bundled channels     */
-  struct list_head       online;       /* list of all bundled channels, 
-					  which are currently online       */
-  spinlock_t             online_lock;  /* lock to protect online list      */
+  struct list_head       slaves;       /* list of all bundled channels    
+					  protected by serializing config
+					  ioctls / no change allowed when
+					  interface is running             */
+  struct list_head       online;       /* list of all bundled channels 
+					  which can be used for actual
+					  data (IP) transfer              
+					  protected by xmit_lock           */
+
+  spinlock_t             xmit_lock;    /* used to protect the xmit path of 
+					  a net_device, including all
+					  associated channels's frame_cnt  */
   struct list_head       running_devs; /* member of global running_devs    */
   atomic_t               refcnt;       /* references held by ISDN code     */
 
 #ifdef CONFIG_ISDN_X25
   struct concap_device_ops *dops;      /* callbacks used by encapsulator   */
 #endif
+#ifdef CONFIG_ISDN_PPP
+  unsigned int           mpppcfg;
+  long                   mp_seqno;
+  struct ippp_ccp        *ccp;
+  unsigned long          debug;
+#ifdef CONFIG_ISDN_PPP_VJ
+  unsigned char         *cbuf;
+  struct slcompress     *slcomp;
+#endif
+#endif
+
   /* use an own struct for that in later versions */
   ulong cisco_myseq;                   /* Local keepalive seq. for Cisco   */
   ulong cisco_mineseen;                /* returned keepalive seq. from remote */
@@ -391,14 +410,11 @@ typedef struct isdn_net_dev_s {
   int                    chargeint;    /* Interval between charge-infos    */
 
   int                    pppbind;      /* ippp device for bindings         */
-  int			 ppp_slot;     /* PPPD device slot number          */
+  struct ipppd          *ipppd;        /* /dev/ipppX which controls us     */
 
-  spinlock_t             xmit_lock;    /* used to protect the xmit path of */
-                                       /* a particular channel (including  */
-                                       /* the frame_cnt                    */
   struct sk_buff_head    super_tx_queue; /* List of supervisory frames to  */
 	                               /* be transmitted asap              */
-  atomic_t               frame_cnt;    /* number of frames currently       */
+  int                    frame_cnt;    /* number of frames currently       */
                         	       /* queued in HL driver              */
   struct tasklet_struct  tlet;
 
@@ -410,6 +426,11 @@ typedef struct isdn_net_dev_s {
   char                   name[10];     /* Name of device                   */
   struct list_head       global_list;  /* global list of all isdn_net_devs */
 #ifdef CONFIG_ISDN_PPP
+  unsigned int           pppcfg;
+  unsigned int           pppseq;       /* last seq no seen                 */
+  struct ippp_ccp        *ccp;
+  unsigned long          debug;
+
   ippp_bundle * pb;		/* pointer to the common bundle structure
    			         * with the per-bundle data */
 #endif
diff --git a/include/linux/isdn_ppp.h b/include/linux/isdn_ppp.h
index 68353a39b98c..ec6016c37421 100644
--- a/include/linux/isdn_ppp.h
+++ b/include/linux/isdn_ppp.h
@@ -8,7 +8,6 @@
 #ifndef _LINUX_ISDN_PPP_H
 #define _LINUX_ISDN_PPP_H
 
-
 #define CALLTYPE_INCOMING 0x1
 #define CALLTYPE_OUTGOING 0x2
 #define CALLTYPE_CALLBACK 0x4
@@ -39,15 +38,6 @@ struct pppcallinfo
 #define SC_OUT_SHORT_SEQ 0x00000800
 #define SC_IN_SHORT_SEQ  0x00004000
 
-#define SC_DECOMP_ON		0x01
-#define SC_COMP_ON		0x02
-#define SC_DECOMP_DISCARD	0x04
-#define SC_COMP_DISCARD		0x08
-#define SC_LINK_DECOMP_ON	0x10
-#define SC_LINK_COMP_ON		0x20
-#define SC_LINK_DECOMP_DISCARD	0x40
-#define SC_LINK_COMP_DISCARD	0x80
-
 #define ISDN_PPP_COMP_MAX_OPTIONS 16
 
 #define IPPP_COMP_FLAG_XMIT 0x1
@@ -64,7 +54,8 @@ struct isdn_ppp_comp_data {
 
 
 #include <linux/config.h>
-
+#include <linux/skbuff.h>
+#include <linux/ppp_defs.h>
 
 #define DECOMP_ERR_NOMEM	(-10)
 
@@ -172,8 +163,8 @@ enum ippp_ccp_reset_states {
 
 struct ippp_ccp_reset_state {
   enum ippp_ccp_reset_states state;	/* State of this transaction */
-  struct ippp_struct *is;		/* Backlink to device stuff */
-  unsigned char id;			/* Backlink id index */
+  struct ippp_ccp *ccp;                 /* Backlink */
+  unsigned char id;			/* id index */
   unsigned char ta:1;			/* The timer is active (flag) */
   unsigned char expra:1;		/* We expect a ResetAck at all */
   int dlen;				/* Databytes stored in data */
@@ -191,34 +182,5 @@ struct ippp_ccp_reset {
   unsigned char lastid;			/* Last id allocated by the engine */
 };
 
-struct ippp_struct {
-  struct ippp_struct *next_link;
-  int state;
-  struct sk_buff_head rq;
-  wait_queue_head_t wq;
-  struct task_struct *tk;
-  unsigned int mpppcfg;
-  unsigned int pppcfg;
-  unsigned int mru;
-  unsigned int mpmru;
-  unsigned int mpmtu;
-  unsigned int maxcid;
-  struct isdn_net_dev_s *idev;
-  int unit;
-  int minor;
-  unsigned int last_link_seqno;
-  long mp_seqno;
-#ifdef CONFIG_ISDN_PPP_VJ
-  unsigned char *cbuf;
-  struct slcompress *slcomp;
-#endif
-  unsigned long debug;
-  struct isdn_ppp_compressor *compressor,*decompressor;
-  struct isdn_ppp_compressor *link_compressor,*link_decompressor;
-  void *decomp_stat,*comp_stat,*link_decomp_stat,*link_comp_stat;
-  struct ippp_ccp_reset *reset;	/* Allocated on demand, may never be needed */
-  unsigned long compflags;
-};
-
 #endif /* __KERNEL__ */
 #endif /* _LINUX_ISDN_PPP_H */