[GitHub/mt8127/android_kernel_alcatel_ttab.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/smp_lock.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 ch%d mgr prim(%x) addr(%x) err %d\n",
			    __func__, ch->nr, hh->prim, ch->addr, 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;

#ifdef CONFIG_SMP
	lock_kernel();
#endif
	sigfillset(&current->blocked);
#ifdef CONFIG_SMP
	unlock_kernel();
#endif
	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>
1b2b03f8 KK	20	#include <linux/kthread.h>
405f5571	21	#include <linux/smp_lock.h>
1b2b03f8 KK	22	#include "core.h"
	23
	24	static u_int *debug;
	25
	26	static inline void
	27	_queue_message(struct mISDNstack st, struct sk_buff skb)
	28	{
	29	struct mISDNhead *hh = mISDN_HEAD_P(skb);
	30
	31	if (*debug & DEBUG_QUEUE_FUNC)
	32	printk(KERN_DEBUG "%s prim(%x) id(%x) %p\n",
	33	__func__, hh->prim, hh->id, skb);
	34	skb_queue_tail(&st->msgq, skb);
	35	if (likely(!test_bit(mISDN_STACK_STOPPED, &st->status))) {
	36	test_and_set_bit(mISDN_STACK_WORK, &st->status);
	37	wake_up_interruptible(&st->workq);
	38	}
	39	}
	40
5b834354	41	static int
1b2b03f8 KK	42	mISDN_queue_message(struct mISDNchannel ch, struct sk_buff skb)
	43	{
	44	_queue_message(ch->st, skb);
	45	return 0;
	46	}
	47
	48	static struct mISDNchannel *
	49	get_channel4id(struct mISDNstack *st, u_int id)
	50	{
	51	struct mISDNchannel *ch;
	52
	53	mutex_lock(&st->lmutex);
	54	list_for_each_entry(ch, &st->layer2, list) {
	55	if (id == ch->nr)
	56	goto unlock;
	57	}
	58	ch = NULL;
	59	unlock:
	60	mutex_unlock(&st->lmutex);
	61	return ch;
	62	}
	63
	64	static void
	65	send_socklist(struct mISDN_sock_list sl, struct sk_buff skb)
	66	{
	67	struct hlist_node *node;
	68	struct sock *sk;
	69	struct sk_buff *cskb = NULL;
	70
	71	read_lock(&sl->lock);
	72	sk_for_each(sk, node, &sl->head) {
	73	if (sk->sk_state != MISDN_BOUND)
	74	continue;
	75	if (!cskb)
	76	cskb = skb_copy(skb, GFP_KERNEL);
	77	if (!cskb) {
	78	printk(KERN_WARNING "%s no skb\n", __func__);
	79	break;
	80	}
	81	if (!sock_queue_rcv_skb(sk, cskb))
	82	cskb = NULL;
	83	}
	84	read_unlock(&sl->lock);
	85	if (cskb)
	86	dev_kfree_skb(cskb);
	87	}
	88
	89	static void
	90	send_layer2(struct mISDNstack st, struct sk_buff skb)
	91	{
	92	struct sk_buff *cskb;
	93	struct mISDNhead *hh = mISDN_HEAD_P(skb);
	94	struct mISDNchannel *ch;
	95	int ret;
	96
	97	if (!st)
	98	return;
	99	mutex_lock(&st->lmutex);
	100	if ((hh->id & MISDN_ID_ADDR_MASK) == MISDN_ID_ANY) { /* L2 for all */
	101	list_for_each_entry(ch, &st->layer2, list) {
	102	if (list_is_last(&ch->list, &st->layer2)) {
	103	cskb = skb;
	104	skb = NULL;
	105	} else {
106	cskb = skb_copy(skb, GFP_KERNEL);
107	}
108	if (cskb) {
109	ret = ch->send(ch, cskb);
110	if (ret) {
111	if (*debug & DEBUG_SEND_ERR)
112	printk(KERN_DEBUG
113	"%s ch%d prim(%x) addr(%x)"
114	" err %d\n",
115	__func__, ch->nr,
116	hh->prim, ch->addr, ret);
117	dev_kfree_skb(cskb);
118	}
119	} else {
120	printk(KERN_WARNING "%s ch%d addr %x no mem\n",
121	__func__, ch->nr, ch->addr);
122	goto out;
123	}
124	}
125	} else {
126	list_for_each_entry(ch, &st->layer2, list) {
127	if ((hh->id & MISDN_ID_ADDR_MASK) == ch->addr) {
128	ret = ch->send(ch, skb);
129	if (!ret)
130	skb = NULL;
131	goto out;
132	}
133	}
134	ret = st->dev->teimgr->ctrl(st->dev->teimgr, CHECK_DATA, skb);
135	if (!ret)
136	skb = NULL;
137	else if (*debug & DEBUG_SEND_ERR)
138	printk(KERN_DEBUG
139	"%s ch%d mgr prim(%x) addr(%x) err %d\n",
140	__func__, ch->nr, hh->prim, ch->addr, ret);
141	}
142	out:
143	mutex_unlock(&st->lmutex);
144	if (skb)
145	dev_kfree_skb(skb);
146	}
147
148	static inline int
149	send_msg_to_layer(struct mISDNstack st, struct sk_buff skb)
150	{
151	struct mISDNhead *hh = mISDN_HEAD_P(skb);
152	struct mISDNchannel *ch;
153	int lm;
154
155	lm = hh->prim & MISDN_LAYERMASK;
156	if (*debug & DEBUG_QUEUE_FUNC)
157	printk(KERN_DEBUG "%s prim(%x) id(%x) %p\n",
158	__func__, hh->prim, hh->id, skb);
159	if (lm == 0x1) {
160	if (!hlist_empty(&st->l1sock.head)) {
161	__net_timestamp(skb);
162	send_socklist(&st->l1sock, skb);
163	}
164	return st->layer1->send(st->layer1, skb);
165	} else if (lm == 0x2) {
166	if (!hlist_empty(&st->l1sock.head))
167	send_socklist(&st->l1sock, skb);
168	send_layer2(st, skb);
169	return 0;
170	} else if (lm == 0x4) {
171	ch = get_channel4id(st, hh->id);
172	if (ch)
173	return ch->send(ch, skb);
174	else
175	printk(KERN_WARNING
176	"%s: dev(%s) prim(%x) id(%x) no channel\n",
837468d1 MU	177	__func__, dev_name(&st->dev->dev), hh->prim,
837468d1 MU	178	hh->id);
1b2b03f8 KK	179	} else if (lm == 0x8) {
	180	WARN_ON(lm == 0x8);
	181	ch = get_channel4id(st, hh->id);
	182	if (ch)
	183	return ch->send(ch, skb);
	184	else
	185	printk(KERN_WARNING
	186	"%s: dev(%s) prim(%x) id(%x) no channel\n",
837468d1 MU	187	__func__, dev_name(&st->dev->dev), hh->prim,
837468d1 MU	188	hh->id);
1b2b03f8 KK	189	} else {
	190	/* broadcast not handled yet */
	191	printk(KERN_WARNING "%s: dev(%s) prim %x not delivered\n",
837468d1	192	__func__, dev_name(&st->dev->dev), hh->prim);
1b2b03f8 KK	193	}
	194	return -ESRCH;
	195	}
	196
	197	static void
	198	do_clear_stack(struct mISDNstack *st)
	199	{
	200	}
	201
	202	static int
	203	mISDNStackd(void *data)
	204	{
	205	struct mISDNstack *st = data;
	206	int err = 0;
	207
	208	#ifdef CONFIG_SMP
	209	lock_kernel();
	210	#endif
	211	sigfillset(&current->blocked);
	212	#ifdef CONFIG_SMP
	213	unlock_kernel();
	214	#endif
	215	if (*debug & DEBUG_MSG_THREAD)
837468d1 MU	216	printk(KERN_DEBUG "mISDNStackd %s started\n",
837468d1 MU	217	dev_name(&st->dev->dev));
1b2b03f8 KK	218
	219	if (st->notify != NULL) {
	220	complete(st->notify);
	221	st->notify = NULL;
	222	}
	223
	224	for (;;) {
	225	struct sk_buff *skb;
	226
	227	if (unlikely(test_bit(mISDN_STACK_STOPPED, &st->status))) {
	228	test_and_clear_bit(mISDN_STACK_WORK, &st->status);
	229	test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
	230	} else
	231	test_and_set_bit(mISDN_STACK_RUNNING, &st->status);
	232	while (test_bit(mISDN_STACK_WORK, &st->status)) {
	233	skb = skb_dequeue(&st->msgq);
	234	if (!skb) {
	235	test_and_clear_bit(mISDN_STACK_WORK,
	236	&st->status);
	237	/* test if a race happens */
	238	skb = skb_dequeue(&st->msgq);
	239	if (!skb)
	240	continue;
	241	test_and_set_bit(mISDN_STACK_WORK,
	242	&st->status);
	243	}
	244	#ifdef MISDN_MSG_STATS
	245	st->msg_cnt++;
	246	#endif
	247	err = send_msg_to_layer(st, skb);
	248	if (unlikely(err)) {
	249	if (*debug & DEBUG_SEND_ERR)
	250	printk(KERN_DEBUG
	251	"%s: %s prim(%x) id(%x) "
	252	"send call(%d)\n",
837468d1	253	__func__, dev_name(&st->dev->dev),
1b2b03f8 KK	254	mISDN_HEAD_PRIM(skb),
	255	mISDN_HEAD_ID(skb), err);
	256	dev_kfree_skb(skb);
	257	continue;
	258	}
	259	if (unlikely(test_bit(mISDN_STACK_STOPPED,
	260	&st->status))) {
	261	test_and_clear_bit(mISDN_STACK_WORK,
	262	&st->status);
	263	test_and_clear_bit(mISDN_STACK_RUNNING,
	264	&st->status);
	265	break;
	266	}
	267	}
	268	if (test_bit(mISDN_STACK_CLEARING, &st->status)) {
	269	test_and_set_bit(mISDN_STACK_STOPPED, &st->status);
	270	test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
	271	do_clear_stack(st);
	272	test_and_clear_bit(mISDN_STACK_CLEARING, &st->status);
	273	test_and_set_bit(mISDN_STACK_RESTART, &st->status);
	274	}
	275	if (test_and_clear_bit(mISDN_STACK_RESTART, &st->status)) {
	276	test_and_clear_bit(mISDN_STACK_STOPPED, &st->status);
	277	test_and_set_bit(mISDN_STACK_RUNNING, &st->status);
	278	if (!skb_queue_empty(&st->msgq))
	279	test_and_set_bit(mISDN_STACK_WORK,
	280	&st->status);
	281	}
	282	if (test_bit(mISDN_STACK_ABORT, &st->status))
	283	break;
	284	if (st->notify != NULL) {
	285	complete(st->notify);
	286	st->notify = NULL;
	287	}
	288	#ifdef MISDN_MSG_STATS
	289	st->sleep_cnt++;
	290	#endif
	291	test_and_clear_bit(mISDN_STACK_ACTIVE, &st->status);
	292	wait_event_interruptible(st->workq, (st->status &
	293	mISDN_STACK_ACTION_MASK));
	294	if (*debug & DEBUG_MSG_THREAD)
	295	printk(KERN_DEBUG "%s: %s wake status %08lx\n",
837468d1	296	__func__, dev_name(&st->dev->dev), st->status);
1b2b03f8 KK	297	test_and_set_bit(mISDN_STACK_ACTIVE, &st->status);
	298
	299	test_and_clear_bit(mISDN_STACK_WAKEUP, &st->status);
	300
	301	if (test_bit(mISDN_STACK_STOPPED, &st->status)) {
	302	test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
	303	#ifdef MISDN_MSG_STATS
	304	st->stopped_cnt++;
	305	#endif
	306	}
	307	}
	308	#ifdef MISDN_MSG_STATS
	309	printk(KERN_DEBUG "mISDNStackd daemon for %s proceed %d "
	310	"msg %d sleep %d stopped\n",
837468d1 MU	311	dev_name(&st->dev->dev), st->msg_cnt, st->sleep_cnt,
837468d1 MU	312	st->stopped_cnt);
1b2b03f8 KK	313	printk(KERN_DEBUG
1b2b03f8 KK	314	"mISDNStackd daemon for %s utime(%ld) stime(%ld)\n",
837468d1	315	dev_name(&st->dev->dev), st->thread->utime, st->thread->stime);
1b2b03f8 KK	316	printk(KERN_DEBUG
1b2b03f8 KK	317	"mISDNStackd daemon for %s nvcsw(%ld) nivcsw(%ld)\n",
837468d1	318	dev_name(&st->dev->dev), st->thread->nvcsw, st->thread->nivcsw);
1b2b03f8	319	printk(KERN_DEBUG "mISDNStackd daemon for %s killed now\n",
837468d1	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 MU	410	printk(KERN_DEBUG "%s: st(%s)\n", __func__,
837468d1 MU	411	dev_name(&newst->dev->dev));
1b2b03f8 KK	412	newst->notify = &done;
1b2b03f8 KK	413	newst->thread = kthread_run(mISDNStackd, (void *)newst, "mISDN_%s",
837468d1	414	dev_name(&newst->dev->dev));
1b2b03f8 KK	415	if (IS_ERR(newst->thread)) {
	416	err = PTR_ERR(newst->thread);
	417	printk(KERN_ERR
	418	"mISDN:cannot create kernel thread for %s (%d)\n",
837468d1	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,
	429	u_int protocol, struct sockaddr_mISDN *adr)
	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",
837468d1 MU	438	__func__, dev_name(&dev->dev), protocol, adr->dev,
837468d1 MU	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 AE	451	printk(KERN_DEBUG "%s: ret %d (dev %d)\n", __func__, err,
9a812553 AE	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,
	467	u_int protocol, struct sockaddr_mISDN *adr)
	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",
837468d1	475	__func__, dev_name(&dev->dev), protocol,
1b2b03f8 KK	476	adr->dev, adr->channel, adr->sapi,
	477	adr->tei);
	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,
	524	u_int protocol, struct sockaddr_mISDN *adr)
	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",
837468d1	531	__func__, dev_name(&dev->dev), protocol,
1b2b03f8 KK	532	adr->dev, adr->channel, adr->sapi,
	533	adr->tei);
	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__,
837468d1	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",
	612	__func__);
	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",
	620	__func__);
	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__,
837468d1	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",
	642	__func__);
	643	complete(st->notify);
	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",
	653	__func__);
	654	if (!hlist_empty(&st->l1sock.head))
	655	printk(KERN_WARNING "%s: layer1 list not empty\n",
	656	__func__);
	657	kfree(st);
	658	}
	659
	660	void
	661	mISDN_initstack(u_int *dp)
	662	{
	663	debug = dp;
	664	}