[deliverable/linux.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 "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 hlist_node	*node;
	struct sock		*sk;
	struct sk_buff		*cskb = NULL;

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