drivers/isdn/mISDN/stack.c

   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
  18 #include <linux/slab.h>
  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",
  32                     __func__, hh->prim, hh->id, skb);
  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
  40 static int
  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
 112                                                     "%s ch%d prim(%x) addr(%x)"
 113                                                     " err %d\n",
 114                                                     __func__, ch->nr,
 115                                                     hh->prim, ch->addr, ret);
 116                                         dev_kfree_skb(cskb);
 117                                 }
 118                         } else {
 119                                 printk(KERN_WARNING "%s ch%d addr %x no mem\n",
 120                                     __func__, ch->nr, ch->addr);
 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
 138                             "%s ch%d mgr prim(%x) addr(%x) err %d\n",
 139                             __func__, ch->nr, hh->prim, ch->addr, ret);
 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",
 157                     __func__, hh->prim, hh->id, skb);
 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
 175                             "%s: dev(%s) prim(%x) id(%x) no channel\n",
 176                             __func__, dev_name(&st->dev->dev), hh->prim,
 177                             hh->id);
 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
 185                             "%s: dev(%s) prim(%x) id(%x) no channel\n",
 186                             __func__, dev_name(&st->dev->dev), hh->prim,
 187                             hh->id);
 188         } else {
 189                 /* broadcast not handled yet */
 190                 printk(KERN_WARNING "%s: dev(%s) prim %x not delivered\n",
 191                     __func__, dev_name(&st->dev->dev), hh->prim);
 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
 207         sigfillset(&current->blocked);
 208         if (*debug & DEBUG_MSG_THREAD)
 209                 printk(KERN_DEBUG "mISDNStackd %s started\n",
 210                     dev_name(&st->dev->dev));
 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,
 229                                         &st->status);
 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,
 235                                     &st->status);
 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
 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);
 249                                 dev_kfree_skb(skb);
 250                                 continue;
 251                         }
 252                         if (unlikely(test_bit(mISDN_STACK_STOPPED,
 253                             &st->status))) {
 254                                 test_and_clear_bit(mISDN_STACK_WORK,
 255                                     &st->status);
 256                                 test_and_clear_bit(mISDN_STACK_RUNNING,
 257                                     &st->status);
 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,
 273                                     &st->status);
 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 &
 286                     mISDN_STACK_ACTION_MASK));
 287                 if (*debug & DEBUG_MSG_THREAD)
 288                         printk(KERN_DEBUG "%s: %s wake status %08lx\n",
 289                             __func__, dev_name(&st->dev->dev), st->status);
 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 "
 303             "msg %d sleep %d stopped\n",
 304             dev_name(&st->dev->dev), st->msg_cnt, st->sleep_cnt,
 305             st->stopped_cnt);
 306         printk(KERN_DEBUG
 307             "mISDNStackd daemon for %s utime(%ld) stime(%ld)\n",
 308             dev_name(&st->dev->dev), st->thread->utime, st->thread->stime);
 309         printk(KERN_DEBUG
 310             "mISDNStackd daemon for %s nvcsw(%ld) nivcsw(%ld)\n",
 311             dev_name(&st->dev->dev), st->thread->nvcsw, st->thread->nivcsw);
 312         printk(KERN_DEBUG "mISDNStackd daemon for %s killed now\n",
 313             dev_name(&st->dev->dev));
 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 {
 361         if (!ch->st || !ch->st->layer1)
 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)
 403                 printk(KERN_DEBUG "%s: st(%s)\n", __func__,
 404                     dev_name(&newst->dev->dev));
 405         newst->notify = &done;
 406         newst->thread = kthread_run(mISDNStackd, (void *)newst, "mISDN_%s",
 407                 dev_name(&newst->dev->dev));
 408         if (IS_ERR(newst->thread)) {
 409                 err = PTR_ERR(newst->thread);
 410                 printk(KERN_ERR
 411                         "mISDN:cannot create kernel thread for %s (%d)\n",
 412                         dev_name(&newst->dev->dev), err);
 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,
 422                 u_int protocol, struct sockaddr_mISDN *adr)
 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",
 431                         __func__, dev_name(&dev->dev), protocol, adr->dev,
 432                         adr->channel, adr->sapi, adr->tei);
 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:
 438                 ch->recv = mISDN_queue_message;
 439                 ch->peer = &dev->D.st->own;
 440                 ch->st = dev->D.st;
 441                 rq.protocol = protocol;
 442                 rq.adr.channel = adr->channel;
 443                 err = dev->D.ctrl(&dev->D, OPEN_CHANNEL, &rq);
 444                 printk(KERN_DEBUG "%s: ret %d (dev %d)\n", __func__, err,
 445                         dev->id);
 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,
 460     u_int protocol, struct sockaddr_mISDN *adr)
 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",
 468                         __func__, dev_name(&dev->dev), protocol,
 469                         adr->dev, adr->channel, adr->sapi,
 470                         adr->tei);
 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,
 517     u_int protocol, struct sockaddr_mISDN *adr)
 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",
 524                         __func__, dev_name(&dev->dev), protocol,
 525                         adr->dev, adr->channel, adr->sapi,
 526                         adr->tei);
 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:
 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__,
 576                     dev_name(&ch->st->dev->dev), ch->protocol);
 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",
 605                             __func__);
 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",
 613                             __func__);
 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__,
 629                     dev_name(&st->dev->dev));
 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",
 635                             __func__);
 636                                 complete(st->notify);
 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",
 646                     __func__);
 647         if (!hlist_empty(&st->l1sock.head))
 648                 printk(KERN_WARNING "%s: layer1 list not empty\n",
 649                     __func__);
 650         kfree(st);
 651 }
 652
 653 void
 654 mISDN_initstack(u_int *dp)
 655 {
 656         debug = dp;
 657 }