[GitHub/LineageOS/android_kernel_motorola_exynos9610.git] / drivers / isdn / mISDN / stack.c

/*
 *
 * Author	Karsten Keil <kkeil@novell.com>
 *
 * Copyright 2008  by Karsten Keil <kkeil@novell.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */

#include <linux/slab.h>
#include <linux/mISDNif.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/sched/cputime.h>
#include <linux/signal.h>

#include "core.h"

static u_int	*debug;

static inline void
_queue_message(struct mISDNstack *st, struct sk_buff *skb)
{
	struct mISDNhead	*hh = mISDN_HEAD_P(skb);

	if (*debug & DEBUG_QUEUE_FUNC)
		printk(KERN_DEBUG "%s prim(%x) id(%x) %p\n",
		       __func__, hh->prim, hh->id, skb);
	skb_queue_tail(&st->msgq, skb);
	if (likely(!test_bit(mISDN_STACK_STOPPED, &st->status))) {
		test_and_set_bit(mISDN_STACK_WORK, &st->status);
		wake_up_interruptible(&st->workq);
	}
}

static int
mISDN_queue_message(struct mISDNchannel *ch, struct sk_buff *skb)
{
	_queue_message(ch->st, skb);
	return 0;
}

static struct mISDNchannel *
get_channel4id(struct mISDNstack *st, u_int id)
{
	struct mISDNchannel	*ch;

	mutex_lock(&st->lmutex);
	list_for_each_entry(ch, &st->layer2, list) {
		if (id == ch->nr)
			goto unlock;
	}
	ch = NULL;
unlock:
	mutex_unlock(&st->lmutex);
	return ch;
}

static void
send_socklist(struct mISDN_sock_list *sl, struct sk_buff *skb)
{
	struct sock		*sk;
	struct sk_buff		*cskb = NULL;

	read_lock(&sl->lock);
	sk_for_each(sk, &sl->head) {
		if (sk->sk_state != MISDN_BOUND)
			continue;
		if (!cskb)
			cskb = skb_copy(skb, GFP_ATOMIC);
		if (!cskb) {
			printk(KERN_WARNING "%s no skb\n", __func__);
			break;
		}
		if (!sock_queue_rcv_skb(sk, cskb))
			cskb = NULL;
	}
	read_unlock(&sl->lock);
	if (cskb)
		dev_kfree_skb(cskb);
}

static void
send_layer2(struct mISDNstack *st, struct sk_buff *skb)
{
	struct sk_buff		*cskb;
	struct mISDNhead	*hh = mISDN_HEAD_P(skb);
	struct mISDNchannel	*ch;
	int			ret;

	if (!st)
		return;
	mutex_lock(&st->lmutex);
	if ((hh->id & MISDN_ID_ADDR_MASK) == MISDN_ID_ANY) { /* L2 for all */
		list_for_each_entry(ch, &st->layer2, list) {
			if (list_is_last(&ch->list, &st->layer2)) {
				cskb = skb;
				skb = NULL;
			} else {
				cskb = skb_copy(skb, GFP_KERNEL);
			}
			if (cskb) {
				ret = ch->send(ch, cskb);
				if (ret) {
					if (*debug & DEBUG_SEND_ERR)
						printk(KERN_DEBUG
						       "%s ch%d prim(%x) addr(%x)"
						       " err %d\n",
						       __func__, ch->nr,
						       hh->prim, ch->addr, ret);
					dev_kfree_skb(cskb);
				}
			} else {
				printk(KERN_WARNING "%s ch%d addr %x no mem\n",
				       __func__, ch->nr, ch->addr);
				goto out;
			}
		}
	} else {
		list_for_each_entry(ch, &st->layer2, list) {
			if ((hh->id & MISDN_ID_ADDR_MASK) == ch->addr) {
				ret = ch->send(ch, skb);
				if (!ret)
					skb = NULL;
				goto out;
			}
		}
		ret = st->dev->teimgr->ctrl(st->dev->teimgr, CHECK_DATA, skb);
		if (!ret)
			skb = NULL;
		else if (*debug & DEBUG_SEND_ERR)
			printk(KERN_DEBUG
			       "%s mgr prim(%x) err %d\n",
			       __func__, hh->prim, ret);
	}
out:
	mutex_unlock(&st->lmutex);
	if (skb)
		dev_kfree_skb(skb);
}

static inline int
send_msg_to_layer(struct mISDNstack *st, struct sk_buff *skb)
{
	struct mISDNhead	*hh = mISDN_HEAD_P(skb);
	struct mISDNchannel	*ch;
	int	lm;

	lm = hh->prim & MISDN_LAYERMASK;
	if (*debug & DEBUG_QUEUE_FUNC)
		printk(KERN_DEBUG "%s prim(%x) id(%x) %p\n",
		       __func__, hh->prim, hh->id, skb);
	if (lm == 0x1) {
		if (!hlist_empty(&st->l1sock.head)) {
			__net_timestamp(skb);
			send_socklist(&st->l1sock, skb);
		}
		return st->layer1->send(st->layer1, skb);
	} else if (lm == 0x2) {
		if (!hlist_empty(&st->l1sock.head))
			send_socklist(&st->l1sock, skb);
		send_layer2(st, skb);
		return 0;
	} else if (lm == 0x4) {
		ch = get_channel4id(st, hh->id);
		if (ch)
			return ch->send(ch, skb);
		else
			printk(KERN_WARNING
			       "%s: dev(%s) prim(%x) id(%x) no channel\n",
			       __func__, dev_name(&st->dev->dev), hh->prim,
			       hh->id);
	} else if (lm == 0x8) {
		WARN_ON(lm == 0x8);
		ch = get_channel4id(st, hh->id);
		if (ch)
			return ch->send(ch, skb);
		else
			printk(KERN_WARNING
			       "%s: dev(%s) prim(%x) id(%x) no channel\n",
			       __func__, dev_name(&st->dev->dev), hh->prim,
			       hh->id);
	} else {
		/* broadcast not handled yet */
		printk(KERN_WARNING "%s: dev(%s) prim %x not delivered\n",
		       __func__, dev_name(&st->dev->dev), hh->prim);
	}
	return -ESRCH;
}

static void
do_clear_stack(struct mISDNstack *st)
{
}

static int
mISDNStackd(void *data)
{
	struct mISDNstack *st = data;
#ifdef MISDN_MSG_STATS
	u64 utime, stime;
#endif
	int err = 0;

	sigfillset(&current->blocked);
	if (*debug & DEBUG_MSG_THREAD)
		printk(KERN_DEBUG "mISDNStackd %s started\n",
		       dev_name(&st->dev->dev));

	if (st->notify != NULL) {
		complete(st->notify);
		st->notify = NULL;
	}

	for (;;) {
		struct sk_buff	*skb;

		if (unlikely(test_bit(mISDN_STACK_STOPPED, &st->status))) {
			test_and_clear_bit(mISDN_STACK_WORK, &st->status);
			test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
		} else
			test_and_set_bit(mISDN_STACK_RUNNING, &st->status);
		while (test_bit(mISDN_STACK_WORK, &st->status)) {
			skb = skb_dequeue(&st->msgq);
			if (!skb) {
				test_and_clear_bit(mISDN_STACK_WORK,
						   &st->status);
				/* test if a race happens */
				skb = skb_dequeue(&st->msgq);
				if (!skb)
					continue;
				test_and_set_bit(mISDN_STACK_WORK,
						 &st->status);
			}
#ifdef MISDN_MSG_STATS
			st->msg_cnt++;
#endif
			err = send_msg_to_layer(st, skb);
			if (unlikely(err)) {
				if (*debug & DEBUG_SEND_ERR)
					printk(KERN_DEBUG
					       "%s: %s prim(%x) id(%x) "
					       "send call(%d)\n",
					       __func__, dev_name(&st->dev->dev),
					       mISDN_HEAD_PRIM(skb),
					       mISDN_HEAD_ID(skb), err);
				dev_kfree_skb(skb);
				continue;
			}
			if (unlikely(test_bit(mISDN_STACK_STOPPED,
					      &st->status))) {
				test_and_clear_bit(mISDN_STACK_WORK,
						   &st->status);
				test_and_clear_bit(mISDN_STACK_RUNNING,
						   &st->status);
				break;
			}
		}
		if (test_bit(mISDN_STACK_CLEARING, &st->status)) {
			test_and_set_bit(mISDN_STACK_STOPPED, &st->status);
			test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
			do_clear_stack(st);
			test_and_clear_bit(mISDN_STACK_CLEARING, &st->status);
			test_and_set_bit(mISDN_STACK_RESTART, &st->status);
		}
		if (test_and_clear_bit(mISDN_STACK_RESTART, &st->status)) {
			test_and_clear_bit(mISDN_STACK_STOPPED, &st->status);
			test_and_set_bit(mISDN_STACK_RUNNING, &st->status);
			if (!skb_queue_empty(&st->msgq))
				test_and_set_bit(mISDN_STACK_WORK,
						 &st->status);
		}
		if (test_bit(mISDN_STACK_ABORT, &st->status))
			break;
		if (st->notify != NULL) {
			complete(st->notify);
			st->notify = NULL;
		}
#ifdef MISDN_MSG_STATS
		st->sleep_cnt++;
#endif
		test_and_clear_bit(mISDN_STACK_ACTIVE, &st->status);
		wait_event_interruptible(st->workq, (st->status &
						     mISDN_STACK_ACTION_MASK));
		if (*debug & DEBUG_MSG_THREAD)
			printk(KERN_DEBUG "%s: %s wake status %08lx\n",
			       __func__, dev_name(&st->dev->dev), st->status);
		test_and_set_bit(mISDN_STACK_ACTIVE, &st->status);

		test_and_clear_bit(mISDN_STACK_WAKEUP, &st->status);

		if (test_bit(mISDN_STACK_STOPPED, &st->status)) {
			test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
#ifdef MISDN_MSG_STATS
			st->stopped_cnt++;
#endif
		}
	}
#ifdef MISDN_MSG_STATS
	printk(KERN_DEBUG "mISDNStackd daemon for %s proceed %d "
	       "msg %d sleep %d stopped\n",
	       dev_name(&st->dev->dev), st->msg_cnt, st->sleep_cnt,
	       st->stopped_cnt);
	task_cputime(st->thread, &utime, &stime);
	printk(KERN_DEBUG
	       "mISDNStackd daemon for %s utime(%llu) stime(%llu)\n",
	       dev_name(&st->dev->dev), utime, stime);
	printk(KERN_DEBUG
	       "mISDNStackd daemon for %s nvcsw(%ld) nivcsw(%ld)\n",
	       dev_name(&st->dev->dev), st->thread->nvcsw, st->thread->nivcsw);
	printk(KERN_DEBUG "mISDNStackd daemon for %s killed now\n",
	       dev_name(&st->dev->dev));
#endif
	test_and_set_bit(mISDN_STACK_KILLED, &st->status);
	test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
	test_and_clear_bit(mISDN_STACK_ACTIVE, &st->status);
	test_and_clear_bit(mISDN_STACK_ABORT, &st->status);
	skb_queue_purge(&st->msgq);
	st->thread = NULL;
	if (st->notify != NULL) {
		complete(st->notify);
		st->notify = NULL;
	}
	return 0;
}

static int
l1_receive(struct mISDNchannel *ch, struct sk_buff *skb)
{
	if (!ch->st)
		return -ENODEV;
	__net_timestamp(skb);
	_queue_message(ch->st, skb);
	return 0;
}

void
set_channel_address(struct mISDNchannel *ch, u_int sapi, u_int tei)
{
	ch->addr = sapi | (tei << 8);
}

void
__add_layer2(struct mISDNchannel *ch, struct mISDNstack *st)
{
	list_add_tail(&ch->list, &st->layer2);
}

void
add_layer2(struct mISDNchannel *ch, struct mISDNstack *st)
{
	mutex_lock(&st->lmutex);
	__add_layer2(ch, st);
	mutex_unlock(&st->lmutex);
}

static int
st_own_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
{
	if (!ch->st || !ch->st->layer1)
		return -EINVAL;
	return ch->st->layer1->ctrl(ch->st->layer1, cmd, arg);
}

int
create_stack(struct mISDNdevice *dev)
{
	struct mISDNstack	*newst;
	int			err;
	DECLARE_COMPLETION_ONSTACK(done);

	newst = kzalloc(sizeof(struct mISDNstack), GFP_KERNEL);
	if (!newst) {
		printk(KERN_ERR "kmalloc mISDN_stack failed\n");
		return -ENOMEM;
	}
	newst->dev = dev;
	INIT_LIST_HEAD(&newst->layer2);
	INIT_HLIST_HEAD(&newst->l1sock.head);
	rwlock_init(&newst->l1sock.lock);
	init_waitqueue_head(&newst->workq);
	skb_queue_head_init(&newst->msgq);
	mutex_init(&newst->lmutex);
	dev->D.st = newst;
	err = create_teimanager(dev);
	if (err) {
		printk(KERN_ERR "kmalloc teimanager failed\n");
		kfree(newst);
		return err;
	}
	dev->teimgr->peer = &newst->own;
	dev->teimgr->recv = mISDN_queue_message;
	dev->teimgr->st = newst;
	newst->layer1 = &dev->D;
	dev->D.recv = l1_receive;
	dev->D.peer = &newst->own;
	newst->own.st = newst;
	newst->own.ctrl = st_own_ctrl;
	newst->own.send = mISDN_queue_message;
	newst->own.recv = mISDN_queue_message;
	if (*debug & DEBUG_CORE_FUNC)
		printk(KERN_DEBUG "%s: st(%s)\n", __func__,
		       dev_name(&newst->dev->dev));
	newst->notify = &done;
	newst->thread = kthread_run(mISDNStackd, (void *)newst, "mISDN_%s",
				    dev_name(&newst->dev->dev));
	if (IS_ERR(newst->thread)) {
		err = PTR_ERR(newst->thread);
		printk(KERN_ERR
		       "mISDN:cannot create kernel thread for %s (%d)\n",
		       dev_name(&newst->dev->dev), err);
		delete_teimanager(dev->teimgr);
		kfree(newst);
	} else
		wait_for_completion(&done);
	return err;
}

int
connect_layer1(struct mISDNdevice *dev, struct mISDNchannel *ch,
	       u_int protocol, struct sockaddr_mISDN *adr)
{
	struct mISDN_sock	*msk = container_of(ch, struct mISDN_sock, ch);
	struct channel_req	rq;
	int			err;


	if (*debug &  DEBUG_CORE_FUNC)
		printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n",
		       __func__, dev_name(&dev->dev), protocol, adr->dev,
		       adr->channel, adr->sapi, adr->tei);
	switch (protocol) {
	case ISDN_P_NT_S0:
	case ISDN_P_NT_E1:
	case ISDN_P_TE_S0:
	case ISDN_P_TE_E1:
		ch->recv = mISDN_queue_message;
		ch->peer = &dev->D.st->own;
		ch->st = dev->D.st;
		rq.protocol = protocol;
		rq.adr.channel = adr->channel;
		err = dev->D.ctrl(&dev->D, OPEN_CHANNEL, &rq);
		printk(KERN_DEBUG "%s: ret %d (dev %d)\n", __func__, err,
		       dev->id);
		if (err)
			return err;
		write_lock_bh(&dev->D.st->l1sock.lock);
		sk_add_node(&msk->sk, &dev->D.st->l1sock.head);
		write_unlock_bh(&dev->D.st->l1sock.lock);
		break;
	default:
		return -ENOPROTOOPT;
	}
	return 0;
}

int
connect_Bstack(struct mISDNdevice *dev, struct mISDNchannel *ch,
	       u_int protocol, struct sockaddr_mISDN *adr)
{
	struct channel_req	rq, rq2;
	int			pmask, err;
	struct Bprotocol	*bp;

	if (*debug &  DEBUG_CORE_FUNC)
		printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n",
		       __func__, dev_name(&dev->dev), protocol,
		       adr->dev, adr->channel, adr->sapi,
		       adr->tei);
	ch->st = dev->D.st;
	pmask = 1 << (protocol & ISDN_P_B_MASK);
	if (pmask & dev->Bprotocols) {
		rq.protocol = protocol;
		rq.adr = *adr;
		err = dev->D.ctrl(&dev->D, OPEN_CHANNEL, &rq);
		if (err)
			return err;
		ch->recv = rq.ch->send;
		ch->peer = rq.ch;
		rq.ch->recv = ch->send;
		rq.ch->peer = ch;
		rq.ch->st = dev->D.st;
	} else {
		bp = get_Bprotocol4mask(pmask);
		if (!bp)
			return -ENOPROTOOPT;
		rq2.protocol = protocol;
		rq2.adr = *adr;
		rq2.ch = ch;
		err = bp->create(&rq2);
		if (err)
			return err;
		ch->recv = rq2.ch->send;
		ch->peer = rq2.ch;
		rq2.ch->st = dev->D.st;
		rq.protocol = rq2.protocol;
		rq.adr = *adr;
		err = dev->D.ctrl(&dev->D, OPEN_CHANNEL, &rq);
		if (err) {
			rq2.ch->ctrl(rq2.ch, CLOSE_CHANNEL, NULL);
			return err;
		}
		rq2.ch->recv = rq.ch->send;
		rq2.ch->peer = rq.ch;
		rq.ch->recv = rq2.ch->send;
		rq.ch->peer = rq2.ch;
		rq.ch->st = dev->D.st;
	}
	ch->protocol = protocol;
	ch->nr = rq.ch->nr;
	return 0;
}

int
create_l2entity(struct mISDNdevice *dev, struct mISDNchannel *ch,
		u_int protocol, struct sockaddr_mISDN *adr)
{
	struct channel_req	rq;
	int			err;

	if (*debug &  DEBUG_CORE_FUNC)
		printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n",
		       __func__, dev_name(&dev->dev), protocol,
		       adr->dev, adr->channel, adr->sapi,
		       adr->tei);
	rq.protocol = ISDN_P_TE_S0;
	if (dev->Dprotocols & (1 << ISDN_P_TE_E1))
		rq.protocol = ISDN_P_TE_E1;
	switch (protocol) {
	case ISDN_P_LAPD_NT:
		rq.protocol = ISDN_P_NT_S0;
		if (dev->Dprotocols & (1 << ISDN_P_NT_E1))
			rq.protocol = ISDN_P_NT_E1;
	case ISDN_P_LAPD_TE:
		ch->recv = mISDN_queue_message;
		ch->peer = &dev->D.st->own;
		ch->st = dev->D.st;
		rq.adr.channel = 0;
		err = dev->D.ctrl(&dev->D, OPEN_CHANNEL, &rq);
		printk(KERN_DEBUG "%s: ret 1 %d\n", __func__, err);
		if (err)
			break;
		rq.protocol = protocol;
		rq.adr = *adr;
		rq.ch = ch;
		err = dev->teimgr->ctrl(dev->teimgr, OPEN_CHANNEL, &rq);
		printk(KERN_DEBUG "%s: ret 2 %d\n", __func__, err);
		if (!err) {
			if ((protocol == ISDN_P_LAPD_NT) && !rq.ch)
				break;
			add_layer2(rq.ch, dev->D.st);
			rq.ch->recv = mISDN_queue_message;
			rq.ch->peer = &dev->D.st->own;
			rq.ch->ctrl(rq.ch, OPEN_CHANNEL, NULL); /* can't fail */
		}
		break;
	default:
		err = -EPROTONOSUPPORT;
	}
	return err;
}

void
delete_channel(struct mISDNchannel *ch)
{
	struct mISDN_sock	*msk = container_of(ch, struct mISDN_sock, ch);
	struct mISDNchannel	*pch;

	if (!ch->st) {
		printk(KERN_WARNING "%s: no stack\n", __func__);
		return;
	}
	if (*debug & DEBUG_CORE_FUNC)
		printk(KERN_DEBUG "%s: st(%s) protocol(%x)\n", __func__,
		       dev_name(&ch->st->dev->dev), ch->protocol);
	if (ch->protocol >= ISDN_P_B_START) {
		if (ch->peer) {
			ch->peer->ctrl(ch->peer, CLOSE_CHANNEL, NULL);
			ch->peer = NULL;
		}
		return;
	}
	switch (ch->protocol) {
	case ISDN_P_NT_S0:
	case ISDN_P_TE_S0:
	case ISDN_P_NT_E1:
	case ISDN_P_TE_E1:
		write_lock_bh(&ch->st->l1sock.lock);
		sk_del_node_init(&msk->sk);
		write_unlock_bh(&ch->st->l1sock.lock);
		ch->st->dev->D.ctrl(&ch->st->dev->D, CLOSE_CHANNEL, NULL);
		break;
	case ISDN_P_LAPD_TE:
		pch = get_channel4id(ch->st, ch->nr);
		if (pch) {
			mutex_lock(&ch->st->lmutex);
			list_del(&pch->list);
			mutex_unlock(&ch->st->lmutex);
			pch->ctrl(pch, CLOSE_CHANNEL, NULL);
			pch = ch->st->dev->teimgr;
			pch->ctrl(pch, CLOSE_CHANNEL, NULL);
		} else
			printk(KERN_WARNING "%s: no l2 channel\n",
			       __func__);
		break;
	case ISDN_P_LAPD_NT:
		pch = ch->st->dev->teimgr;
		if (pch) {
			pch->ctrl(pch, CLOSE_CHANNEL, NULL);
		} else
			printk(KERN_WARNING "%s: no l2 channel\n",
			       __func__);
		break;
	default:
		break;
	}
	return;
}

void
delete_stack(struct mISDNdevice *dev)
{
	struct mISDNstack	*st = dev->D.st;
	DECLARE_COMPLETION_ONSTACK(done);

	if (*debug & DEBUG_CORE_FUNC)
		printk(KERN_DEBUG "%s: st(%s)\n", __func__,
		       dev_name(&st->dev->dev));
	if (dev->teimgr)
		delete_teimanager(dev->teimgr);
	if (st->thread) {
		if (st->notify) {
			printk(KERN_WARNING "%s: notifier in use\n",
			       __func__);
			complete(st->notify);
		}
		st->notify = &done;
		test_and_set_bit(mISDN_STACK_ABORT, &st->status);
		test_and_set_bit(mISDN_STACK_WAKEUP, &st->status);
		wake_up_interruptible(&st->workq);
		wait_for_completion(&done);
	}
	if (!list_empty(&st->layer2))
		printk(KERN_WARNING "%s: layer2 list not empty\n",
		       __func__);
	if (!hlist_empty(&st->l1sock.head))
		printk(KERN_WARNING "%s: layer1 list not empty\n",
		       __func__);
	kfree(st);
}

void
mISDN_initstack(u_int *dp)
{
	debug = dp;
}
Commit	Line	Data
1b2b03f8 KK	1	/*
	2	*
	3	* Author Karsten Keil <kkeil@novell.com>
	4	*
	5	* Copyright 2008 by Karsten Keil <kkeil@novell.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	*/
	17
5a0e3ad6	18	#include <linux/slab.h>
1b2b03f8 KK	19	#include <linux/mISDNif.h>
1b2b03f8 KK	20	#include <linux/kthread.h>
6fac4829	21	#include <linux/sched.h>
32ef5517	22	#include <linux/sched/cputime.h>
f361bf4a IM	23	#include <linux/signal.h>
f361bf4a IM	24
1b2b03f8 KK	25	#include "core.h"
	26
	27	static u_int *debug;
	28
	29	static inline void
	30	_queue_message(struct mISDNstack st, struct sk_buff skb)
	31	{
	32	struct mISDNhead *hh = mISDN_HEAD_P(skb);
	33
	34	if (*debug & DEBUG_QUEUE_FUNC)
	35	printk(KERN_DEBUG "%s prim(%x) id(%x) %p\n",
475be4d8	36	__func__, hh->prim, hh->id, skb);
1b2b03f8 KK	37	skb_queue_tail(&st->msgq, skb);
	38	if (likely(!test_bit(mISDN_STACK_STOPPED, &st->status))) {
	39	test_and_set_bit(mISDN_STACK_WORK, &st->status);
	40	wake_up_interruptible(&st->workq);
	41	}
	42	}
	43
5b834354	44	static int
1b2b03f8 KK	45	mISDN_queue_message(struct mISDNchannel ch, struct sk_buff skb)
	46	{
	47	_queue_message(ch->st, skb);
	48	return 0;
	49	}
	50
	51	static struct mISDNchannel *
	52	get_channel4id(struct mISDNstack *st, u_int id)
	53	{
	54	struct mISDNchannel *ch;
	55
	56	mutex_lock(&st->lmutex);
	57	list_for_each_entry(ch, &st->layer2, list) {
	58	if (id == ch->nr)
	59	goto unlock;
	60	}
	61	ch = NULL;
	62	unlock:
	63	mutex_unlock(&st->lmutex);
	64	return ch;
	65	}
	66
	67	static void
	68	send_socklist(struct mISDN_sock_list sl, struct sk_buff skb)
	69	{
1b2b03f8 KK	70	struct sock *sk;
	71	struct sk_buff *cskb = NULL;
	72
	73	read_lock(&sl->lock);
b67bfe0d	74	sk_for_each(sk, &sl->head) {
1b2b03f8 KK	75	if (sk->sk_state != MISDN_BOUND)
	76	continue;
	77	if (!cskb)
93818da5	78	cskb = skb_copy(skb, GFP_ATOMIC);
1b2b03f8 KK	79	if (!cskb) {
	80	printk(KERN_WARNING "%s no skb\n", __func__);
	81	break;
	82	}
	83	if (!sock_queue_rcv_skb(sk, cskb))
	84	cskb = NULL;
	85	}
	86	read_unlock(&sl->lock);
	87	if (cskb)
	88	dev_kfree_skb(cskb);
	89	}
	90
	91	static void
	92	send_layer2(struct mISDNstack st, struct sk_buff skb)
	93	{
	94	struct sk_buff *cskb;
	95	struct mISDNhead *hh = mISDN_HEAD_P(skb);
	96	struct mISDNchannel *ch;
	97	int ret;
	98
	99	if (!st)
	100	return;
	101	mutex_lock(&st->lmutex);
	102	if ((hh->id & MISDN_ID_ADDR_MASK) == MISDN_ID_ANY) { /* L2 for all */
	103	list_for_each_entry(ch, &st->layer2, list) {
	104	if (list_is_last(&ch->list, &st->layer2)) {
	105	cskb = skb;
	106	skb = NULL;
	107	} else {
	108	cskb = skb_copy(skb, GFP_KERNEL);
	109	}
	110	if (cskb) {
	111	ret = ch->send(ch, cskb);
	112	if (ret) {
	113	if (*debug & DEBUG_SEND_ERR)
	114	printk(KERN_DEBUG
475be4d8 JP	115	"%s ch%d prim(%x) addr(%x)"
	116	" err %d\n",
	117	__func__, ch->nr,
	118	hh->prim, ch->addr, ret);
1b2b03f8 KK	119	dev_kfree_skb(cskb);
	120	}
	121	} else {
	122	printk(KERN_WARNING "%s ch%d addr %x no mem\n",
475be4d8	123	__func__, ch->nr, ch->addr);
1b2b03f8 KK	124	goto out;
	125	}
	126	}
	127	} else {
	128	list_for_each_entry(ch, &st->layer2, list) {
	129	if ((hh->id & MISDN_ID_ADDR_MASK) == ch->addr) {
	130	ret = ch->send(ch, skb);
	131	if (!ret)
	132	skb = NULL;
	133	goto out;
	134	}
	135	}
	136	ret = st->dev->teimgr->ctrl(st->dev->teimgr, CHECK_DATA, skb);
	137	if (!ret)
	138	skb = NULL;
	139	else if (*debug & DEBUG_SEND_ERR)
	140	printk(KERN_DEBUG
1b9faf5e JL	141	"%s mgr prim(%x) err %d\n",
1b9faf5e JL	142	__func__, hh->prim, ret);
1b2b03f8 KK	143	}
	144	out:
	145	mutex_unlock(&st->lmutex);
	146	if (skb)
	147	dev_kfree_skb(skb);
	148	}
	149
	150	static inline int
	151	send_msg_to_layer(struct mISDNstack st, struct sk_buff skb)
	152	{
	153	struct mISDNhead *hh = mISDN_HEAD_P(skb);
	154	struct mISDNchannel *ch;
	155	int lm;
	156
	157	lm = hh->prim & MISDN_LAYERMASK;
	158	if (*debug & DEBUG_QUEUE_FUNC)
	159	printk(KERN_DEBUG "%s prim(%x) id(%x) %p\n",
475be4d8	160	__func__, hh->prim, hh->id, skb);
1b2b03f8 KK	161	if (lm == 0x1) {
	162	if (!hlist_empty(&st->l1sock.head)) {
	163	__net_timestamp(skb);
	164	send_socklist(&st->l1sock, skb);
	165	}
	166	return st->layer1->send(st->layer1, skb);
	167	} else if (lm == 0x2) {
	168	if (!hlist_empty(&st->l1sock.head))
	169	send_socklist(&st->l1sock, skb);
	170	send_layer2(st, skb);
	171	return 0;
	172	} else if (lm == 0x4) {
	173	ch = get_channel4id(st, hh->id);
	174	if (ch)
	175	return ch->send(ch, skb);
	176	else
	177	printk(KERN_WARNING
475be4d8 JP	178	"%s: dev(%s) prim(%x) id(%x) no channel\n",
	179	__func__, dev_name(&st->dev->dev), hh->prim,
	180	hh->id);
1b2b03f8 KK	181	} else if (lm == 0x8) {
	182	WARN_ON(lm == 0x8);
	183	ch = get_channel4id(st, hh->id);
	184	if (ch)
	185	return ch->send(ch, skb);
	186	else
	187	printk(KERN_WARNING
475be4d8 JP	188	"%s: dev(%s) prim(%x) id(%x) no channel\n",
	189	__func__, dev_name(&st->dev->dev), hh->prim,
	190	hh->id);
1b2b03f8 KK	191	} else {
	192	/* broadcast not handled yet */
	193	printk(KERN_WARNING "%s: dev(%s) prim %x not delivered\n",
475be4d8	194	__func__, dev_name(&st->dev->dev), hh->prim);
1b2b03f8 KK	195	}
	196	return -ESRCH;
	197	}
	198
	199	static void
	200	do_clear_stack(struct mISDNstack *st)
	201	{
	202	}
	203
	204	static int
	205	mISDNStackd(void *data)
	206	{
	207	struct mISDNstack *st = data;
6fac4829	208	#ifdef MISDN_MSG_STATS
c0e7a500	209	u64 utime, stime;
6fac4829	210	#endif
1b2b03f8 KK	211	int err = 0;
1b2b03f8 KK	212
1b2b03f8	213	sigfillset(&current->blocked);
1b2b03f8	214	if (*debug & DEBUG_MSG_THREAD)
837468d1	215	printk(KERN_DEBUG "mISDNStackd %s started\n",
475be4d8	216	dev_name(&st->dev->dev));
1b2b03f8 KK	217
	218	if (st->notify != NULL) {
	219	complete(st->notify);
	220	st->notify = NULL;
	221	}
	222
	223	for (;;) {
	224	struct sk_buff *skb;
	225
	226	if (unlikely(test_bit(mISDN_STACK_STOPPED, &st->status))) {
	227	test_and_clear_bit(mISDN_STACK_WORK, &st->status);
	228	test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
	229	} else
	230	test_and_set_bit(mISDN_STACK_RUNNING, &st->status);
	231	while (test_bit(mISDN_STACK_WORK, &st->status)) {
	232	skb = skb_dequeue(&st->msgq);
	233	if (!skb) {
	234	test_and_clear_bit(mISDN_STACK_WORK,
475be4d8	235	&st->status);
1b2b03f8 KK	236	/* test if a race happens */
	237	skb = skb_dequeue(&st->msgq);
	238	if (!skb)
	239	continue;
	240	test_and_set_bit(mISDN_STACK_WORK,
475be4d8	241	&st->status);
1b2b03f8 KK	242	}
	243	#ifdef MISDN_MSG_STATS
	244	st->msg_cnt++;
	245	#endif
	246	err = send_msg_to_layer(st, skb);
	247	if (unlikely(err)) {
	248	if (*debug & DEBUG_SEND_ERR)
	249	printk(KERN_DEBUG
475be4d8 JP	250	"%s: %s prim(%x) id(%x) "
	251	"send call(%d)\n",
	252	__func__, dev_name(&st->dev->dev),
	253	mISDN_HEAD_PRIM(skb),
	254	mISDN_HEAD_ID(skb), err);
1b2b03f8 KK	255	dev_kfree_skb(skb);
	256	continue;
	257	}
	258	if (unlikely(test_bit(mISDN_STACK_STOPPED,
475be4d8	259	&st->status))) {
1b2b03f8	260	test_and_clear_bit(mISDN_STACK_WORK,
475be4d8	261	&st->status);
1b2b03f8	262	test_and_clear_bit(mISDN_STACK_RUNNING,
475be4d8	263	&st->status);
1b2b03f8 KK	264	break;
	265	}
	266	}
	267	if (test_bit(mISDN_STACK_CLEARING, &st->status)) {
	268	test_and_set_bit(mISDN_STACK_STOPPED, &st->status);
	269	test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
	270	do_clear_stack(st);
	271	test_and_clear_bit(mISDN_STACK_CLEARING, &st->status);
	272	test_and_set_bit(mISDN_STACK_RESTART, &st->status);
	273	}
	274	if (test_and_clear_bit(mISDN_STACK_RESTART, &st->status)) {
	275	test_and_clear_bit(mISDN_STACK_STOPPED, &st->status);
	276	test_and_set_bit(mISDN_STACK_RUNNING, &st->status);
	277	if (!skb_queue_empty(&st->msgq))
	278	test_and_set_bit(mISDN_STACK_WORK,
475be4d8	279	&st->status);
1b2b03f8 KK	280	}
	281	if (test_bit(mISDN_STACK_ABORT, &st->status))
	282	break;
	283	if (st->notify != NULL) {
	284	complete(st->notify);
	285	st->notify = NULL;
	286	}
	287	#ifdef MISDN_MSG_STATS
	288	st->sleep_cnt++;
	289	#endif
	290	test_and_clear_bit(mISDN_STACK_ACTIVE, &st->status);
	291	wait_event_interruptible(st->workq, (st->status &
475be4d8	292	mISDN_STACK_ACTION_MASK));
1b2b03f8 KK	293	if (*debug & DEBUG_MSG_THREAD)
1b2b03f8 KK	294	printk(KERN_DEBUG "%s: %s wake status %08lx\n",
475be4d8	295	__func__, dev_name(&st->dev->dev), st->status);
1b2b03f8 KK	296	test_and_set_bit(mISDN_STACK_ACTIVE, &st->status);
	297
	298	test_and_clear_bit(mISDN_STACK_WAKEUP, &st->status);
	299
	300	if (test_bit(mISDN_STACK_STOPPED, &st->status)) {
	301	test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
	302	#ifdef MISDN_MSG_STATS
	303	st->stopped_cnt++;
	304	#endif
	305	}
	306	}
	307	#ifdef MISDN_MSG_STATS
	308	printk(KERN_DEBUG "mISDNStackd daemon for %s proceed %d "
475be4d8 JP	309	"msg %d sleep %d stopped\n",
	310	dev_name(&st->dev->dev), st->msg_cnt, st->sleep_cnt,
	311	st->stopped_cnt);
c0e7a500	312	task_cputime(st->thread, &utime, &stime);
1b2b03f8	313	printk(KERN_DEBUG
c0e7a500	314	"mISDNStackd daemon for %s utime(%llu) stime(%llu)\n",
6fac4829	315	dev_name(&st->dev->dev), utime, stime);
1b2b03f8	316	printk(KERN_DEBUG
475be4d8 JP	317	"mISDNStackd daemon for %s nvcsw(%ld) nivcsw(%ld)\n",
475be4d8 JP	318	dev_name(&st->dev->dev), st->thread->nvcsw, st->thread->nivcsw);
1b2b03f8	319	printk(KERN_DEBUG "mISDNStackd daemon for %s killed now\n",
475be4d8	320	dev_name(&st->dev->dev));
1b2b03f8 KK	321	#endif
	322	test_and_set_bit(mISDN_STACK_KILLED, &st->status);
	323	test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
	324	test_and_clear_bit(mISDN_STACK_ACTIVE, &st->status);
	325	test_and_clear_bit(mISDN_STACK_ABORT, &st->status);
	326	skb_queue_purge(&st->msgq);
	327	st->thread = NULL;
	328	if (st->notify != NULL) {
	329	complete(st->notify);
	330	st->notify = NULL;
	331	}
	332	return 0;
	333	}
	334
	335	static int
	336	l1_receive(struct mISDNchannel ch, struct sk_buff skb)
	337	{
	338	if (!ch->st)
	339	return -ENODEV;
	340	__net_timestamp(skb);
	341	_queue_message(ch->st, skb);
	342	return 0;
	343	}
	344
	345	void
	346	set_channel_address(struct mISDNchannel *ch, u_int sapi, u_int tei)
	347	{
	348	ch->addr = sapi \| (tei << 8);
	349	}
	350
	351	void
	352	__add_layer2(struct mISDNchannel ch, struct mISDNstack st)
	353	{
	354	list_add_tail(&ch->list, &st->layer2);
	355	}
	356
	357	void
	358	add_layer2(struct mISDNchannel ch, struct mISDNstack st)
	359	{
	360	mutex_lock(&st->lmutex);
	361	__add_layer2(ch, st);
	362	mutex_unlock(&st->lmutex);
	363	}
	364
	365	static int
	366	st_own_ctrl(struct mISDNchannel ch, u_int cmd, void arg)
	367	{
08cb3f60	368	if (!ch->st \|\| !ch->st->layer1)
1b2b03f8 KK	369	return -EINVAL;
	370	return ch->st->layer1->ctrl(ch->st->layer1, cmd, arg);
	371	}
	372
	373	int
	374	create_stack(struct mISDNdevice *dev)
	375	{
	376	struct mISDNstack *newst;
	377	int err;
	378	DECLARE_COMPLETION_ONSTACK(done);
	379
	380	newst = kzalloc(sizeof(struct mISDNstack), GFP_KERNEL);
	381	if (!newst) {
	382	printk(KERN_ERR "kmalloc mISDN_stack failed\n");
	383	return -ENOMEM;
	384	}
	385	newst->dev = dev;
	386	INIT_LIST_HEAD(&newst->layer2);
	387	INIT_HLIST_HEAD(&newst->l1sock.head);
	388	rwlock_init(&newst->l1sock.lock);
	389	init_waitqueue_head(&newst->workq);
	390	skb_queue_head_init(&newst->msgq);
	391	mutex_init(&newst->lmutex);
	392	dev->D.st = newst;
	393	err = create_teimanager(dev);
	394	if (err) {
	395	printk(KERN_ERR "kmalloc teimanager failed\n");
	396	kfree(newst);
	397	return err;
	398	}
	399	dev->teimgr->peer = &newst->own;
	400	dev->teimgr->recv = mISDN_queue_message;
	401	dev->teimgr->st = newst;
	402	newst->layer1 = &dev->D;
	403	dev->D.recv = l1_receive;
	404	dev->D.peer = &newst->own;
	405	newst->own.st = newst;
	406	newst->own.ctrl = st_own_ctrl;
	407	newst->own.send = mISDN_queue_message;
	408	newst->own.recv = mISDN_queue_message;
	409	if (*debug & DEBUG_CORE_FUNC)
837468d1	410	printk(KERN_DEBUG "%s: st(%s)\n", __func__,
475be4d8	411	dev_name(&newst->dev->dev));
1b2b03f8 KK	412	newst->notify = &done;
1b2b03f8 KK	413	newst->thread = kthread_run(mISDNStackd, (void *)newst, "mISDN_%s",
475be4d8	414	dev_name(&newst->dev->dev));
1b2b03f8 KK	415	if (IS_ERR(newst->thread)) {
	416	err = PTR_ERR(newst->thread);
	417	printk(KERN_ERR
475be4d8 JP	418	"mISDN:cannot create kernel thread for %s (%d)\n",
475be4d8 JP	419	dev_name(&newst->dev->dev), err);
1b2b03f8 KK	420	delete_teimanager(dev->teimgr);
	421	kfree(newst);
	422	} else
	423	wait_for_completion(&done);
	424	return err;
	425	}
	426
	427	int
	428	connect_layer1(struct mISDNdevice dev, struct mISDNchannel ch,
475be4d8	429	u_int protocol, struct sockaddr_mISDN *adr)
1b2b03f8 KK	430	{
	431	struct mISDN_sock *msk = container_of(ch, struct mISDN_sock, ch);
	432	struct channel_req rq;
	433	int err;
	434
	435
	436	if (*debug & DEBUG_CORE_FUNC)
	437	printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n",
475be4d8 JP	438	__func__, dev_name(&dev->dev), protocol, adr->dev,
475be4d8 JP	439	adr->channel, adr->sapi, adr->tei);
1b2b03f8 KK	440	switch (protocol) {
	441	case ISDN_P_NT_S0:
	442	case ISDN_P_NT_E1:
	443	case ISDN_P_TE_S0:
	444	case ISDN_P_TE_E1:
1b2b03f8 KK	445	ch->recv = mISDN_queue_message;
	446	ch->peer = &dev->D.st->own;
	447	ch->st = dev->D.st;
	448	rq.protocol = protocol;
1f28fa19	449	rq.adr.channel = adr->channel;
1b2b03f8	450	err = dev->D.ctrl(&dev->D, OPEN_CHANNEL, &rq);
9a812553	451	printk(KERN_DEBUG "%s: ret %d (dev %d)\n", __func__, err,
475be4d8	452	dev->id);
1b2b03f8 KK	453	if (err)
	454	return err;
	455	write_lock_bh(&dev->D.st->l1sock.lock);
	456	sk_add_node(&msk->sk, &dev->D.st->l1sock.head);
	457	write_unlock_bh(&dev->D.st->l1sock.lock);
	458	break;
	459	default:
	460	return -ENOPROTOOPT;
	461	}
	462	return 0;
	463	}
	464
	465	int
	466	connect_Bstack(struct mISDNdevice dev, struct mISDNchannel ch,
475be4d8	467	u_int protocol, struct sockaddr_mISDN *adr)
1b2b03f8 KK	468	{
	469	struct channel_req rq, rq2;
	470	int pmask, err;
	471	struct Bprotocol *bp;
	472
	473	if (*debug & DEBUG_CORE_FUNC)
	474	printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n",
475be4d8 JP	475	__func__, dev_name(&dev->dev), protocol,
	476	adr->dev, adr->channel, adr->sapi,
	477	adr->tei);
1b2b03f8 KK	478	ch->st = dev->D.st;
	479	pmask = 1 << (protocol & ISDN_P_B_MASK);
	480	if (pmask & dev->Bprotocols) {
	481	rq.protocol = protocol;
	482	rq.adr = *adr;
	483	err = dev->D.ctrl(&dev->D, OPEN_CHANNEL, &rq);
	484	if (err)
	485	return err;
	486	ch->recv = rq.ch->send;
	487	ch->peer = rq.ch;
	488	rq.ch->recv = ch->send;
	489	rq.ch->peer = ch;
	490	rq.ch->st = dev->D.st;
	491	} else {
	492	bp = get_Bprotocol4mask(pmask);
	493	if (!bp)
	494	return -ENOPROTOOPT;
	495	rq2.protocol = protocol;
	496	rq2.adr = *adr;
	497	rq2.ch = ch;
	498	err = bp->create(&rq2);
	499	if (err)
	500	return err;
	501	ch->recv = rq2.ch->send;
	502	ch->peer = rq2.ch;
	503	rq2.ch->st = dev->D.st;
	504	rq.protocol = rq2.protocol;
	505	rq.adr = *adr;
	506	err = dev->D.ctrl(&dev->D, OPEN_CHANNEL, &rq);
	507	if (err) {
	508	rq2.ch->ctrl(rq2.ch, CLOSE_CHANNEL, NULL);
	509	return err;
	510	}
	511	rq2.ch->recv = rq.ch->send;
	512	rq2.ch->peer = rq.ch;
	513	rq.ch->recv = rq2.ch->send;
	514	rq.ch->peer = rq2.ch;
	515	rq.ch->st = dev->D.st;
	516	}
	517	ch->protocol = protocol;
	518	ch->nr = rq.ch->nr;
	519	return 0;
	520	}
	521
	522	int
	523	create_l2entity(struct mISDNdevice dev, struct mISDNchannel ch,
475be4d8	524	u_int protocol, struct sockaddr_mISDN *adr)
1b2b03f8 KK	525	{
	526	struct channel_req rq;
	527	int err;
	528
	529	if (*debug & DEBUG_CORE_FUNC)
	530	printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n",
475be4d8 JP	531	__func__, dev_name(&dev->dev), protocol,
	532	adr->dev, adr->channel, adr->sapi,
	533	adr->tei);
1b2b03f8 KK	534	rq.protocol = ISDN_P_TE_S0;
	535	if (dev->Dprotocols & (1 << ISDN_P_TE_E1))
	536	rq.protocol = ISDN_P_TE_E1;
	537	switch (protocol) {
	538	case ISDN_P_LAPD_NT:
	539	rq.protocol = ISDN_P_NT_S0;
	540	if (dev->Dprotocols & (1 << ISDN_P_NT_E1))
	541	rq.protocol = ISDN_P_NT_E1;
	542	case ISDN_P_LAPD_TE:
1b2b03f8 KK	543	ch->recv = mISDN_queue_message;
	544	ch->peer = &dev->D.st->own;
	545	ch->st = dev->D.st;
	546	rq.adr.channel = 0;
	547	err = dev->D.ctrl(&dev->D, OPEN_CHANNEL, &rq);
	548	printk(KERN_DEBUG "%s: ret 1 %d\n", __func__, err);
	549	if (err)
	550	break;
	551	rq.protocol = protocol;
	552	rq.adr = *adr;
	553	rq.ch = ch;
	554	err = dev->teimgr->ctrl(dev->teimgr, OPEN_CHANNEL, &rq);
	555	printk(KERN_DEBUG "%s: ret 2 %d\n", __func__, err);
	556	if (!err) {
	557	if ((protocol == ISDN_P_LAPD_NT) && !rq.ch)
	558	break;
	559	add_layer2(rq.ch, dev->D.st);
	560	rq.ch->recv = mISDN_queue_message;
	561	rq.ch->peer = &dev->D.st->own;
	562	rq.ch->ctrl(rq.ch, OPEN_CHANNEL, NULL); /* can't fail */
	563	}
	564	break;
	565	default:
	566	err = -EPROTONOSUPPORT;
	567	}
	568	return err;
	569	}
	570
	571	void
	572	delete_channel(struct mISDNchannel *ch)
	573	{
	574	struct mISDN_sock *msk = container_of(ch, struct mISDN_sock, ch);
	575	struct mISDNchannel *pch;
	576
	577	if (!ch->st) {
	578	printk(KERN_WARNING "%s: no stack\n", __func__);
	579	return;
	580	}
	581	if (*debug & DEBUG_CORE_FUNC)
	582	printk(KERN_DEBUG "%s: st(%s) protocol(%x)\n", __func__,
475be4d8	583	dev_name(&ch->st->dev->dev), ch->protocol);
1b2b03f8 KK	584	if (ch->protocol >= ISDN_P_B_START) {
	585	if (ch->peer) {
	586	ch->peer->ctrl(ch->peer, CLOSE_CHANNEL, NULL);
	587	ch->peer = NULL;
	588	}
	589	return;
	590	}
	591	switch (ch->protocol) {
	592	case ISDN_P_NT_S0:
	593	case ISDN_P_TE_S0:
	594	case ISDN_P_NT_E1:
	595	case ISDN_P_TE_E1:
	596	write_lock_bh(&ch->st->l1sock.lock);
	597	sk_del_node_init(&msk->sk);
	598	write_unlock_bh(&ch->st->l1sock.lock);
	599	ch->st->dev->D.ctrl(&ch->st->dev->D, CLOSE_CHANNEL, NULL);
	600	break;
	601	case ISDN_P_LAPD_TE:
	602	pch = get_channel4id(ch->st, ch->nr);
	603	if (pch) {
	604	mutex_lock(&ch->st->lmutex);
	605	list_del(&pch->list);
	606	mutex_unlock(&ch->st->lmutex);
	607	pch->ctrl(pch, CLOSE_CHANNEL, NULL);
	608	pch = ch->st->dev->teimgr;
	609	pch->ctrl(pch, CLOSE_CHANNEL, NULL);
	610	} else
	611	printk(KERN_WARNING "%s: no l2 channel\n",
475be4d8	612	__func__);
1b2b03f8 KK	613	break;
	614	case ISDN_P_LAPD_NT:
	615	pch = ch->st->dev->teimgr;
	616	if (pch) {
	617	pch->ctrl(pch, CLOSE_CHANNEL, NULL);
	618	} else
	619	printk(KERN_WARNING "%s: no l2 channel\n",
475be4d8	620	__func__);
1b2b03f8 KK	621	break;
	622	default:
	623	break;
	624	}
	625	return;
	626	}
	627
	628	void
	629	delete_stack(struct mISDNdevice *dev)
	630	{
	631	struct mISDNstack *st = dev->D.st;
	632	DECLARE_COMPLETION_ONSTACK(done);
	633
	634	if (*debug & DEBUG_CORE_FUNC)
	635	printk(KERN_DEBUG "%s: st(%s)\n", __func__,
475be4d8	636	dev_name(&st->dev->dev));
1b2b03f8 KK	637	if (dev->teimgr)
	638	delete_teimanager(dev->teimgr);
	639	if (st->thread) {
	640	if (st->notify) {
	641	printk(KERN_WARNING "%s: notifier in use\n",
475be4d8 JP	642	__func__);
475be4d8 JP	643	complete(st->notify);
1b2b03f8 KK	644	}
	645	st->notify = &done;
	646	test_and_set_bit(mISDN_STACK_ABORT, &st->status);
	647	test_and_set_bit(mISDN_STACK_WAKEUP, &st->status);
	648	wake_up_interruptible(&st->workq);
	649	wait_for_completion(&done);
	650	}
	651	if (!list_empty(&st->layer2))
	652	printk(KERN_WARNING "%s: layer2 list not empty\n",
475be4d8	653	__func__);
1b2b03f8 KK	654	if (!hlist_empty(&st->l1sock.head))
1b2b03f8 KK	655	printk(KERN_WARNING "%s: layer1 list not empty\n",
475be4d8	656	__func__);
1b2b03f8 KK	657	kfree(st);
	658	}
	659
	660	void
	661	mISDN_initstack(u_int *dp)
	662	{
	663	debug = dp;
	664	}