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/mISDNif.h>
  19 #include <linux/kthread.h>
  20 #include <linux/smp_lock.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 #ifdef CONFIG_SMP
 208         lock_kernel();
 209 #endif
 210         sigfillset(&current->blocked);
 211 #ifdef CONFIG_SMP
 212         unlock_kernel();
 213 #endif
 214         if (*debug & DEBUG_MSG_THREAD)
 215                 printk(KERN_DEBUG "mISDNStackd %s started\n",
 216                     dev_name(&st->dev->dev));
 217
 218         if (st->notify != NULL) {
 219                 complete(st->notify);
 220                 st->notify = NULL;
 221         }
 222
 223         for (;;) {
 224                 struct sk_buff  *skb;
 225
 226                 if (unlikely(test_bit(mISDN_STACK_STOPPED, &st->status))) {
 227                         test_and_clear_bit(mISDN_STACK_WORK, &st->status);
 228                         test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
 229                 } else
 230                         test_and_set_bit(mISDN_STACK_RUNNING, &st->status);
 231                 while (test_bit(mISDN_STACK_WORK, &st->status)) {
 232                         skb = skb_dequeue(&st->msgq);
 233                         if (!skb) {
 234                                 test_and_clear_bit(mISDN_STACK_WORK,
 235                                         &st->status);
 236                                 /* test if a race happens */
 237                                 skb = skb_dequeue(&st->msgq);
 238                                 if (!skb)
 239                                         continue;
 240                                 test_and_set_bit(mISDN_STACK_WORK,
 241                                     &st->status);
 242                         }
 243 #ifdef MISDN_MSG_STATS
 244                         st->msg_cnt++;
 245 #endif
 246                         err = send_msg_to_layer(st, skb);
 247                         if (unlikely(err)) {
 248                                 if (*debug & DEBUG_SEND_ERR)
 249                                         printk(KERN_DEBUG
 250                                             "%s: %s prim(%x) id(%x) "
 251                                             "send call(%d)\n",
 252                                             __func__, dev_name(&st->dev->dev),
 253                                             mISDN_HEAD_PRIM(skb),
 254                                             mISDN_HEAD_ID(skb), err);
 255                                 dev_kfree_skb(skb);
 256                                 continue;
 257                         }
 258                         if (unlikely(test_bit(mISDN_STACK_STOPPED,
 259                             &st->status))) {
 260                                 test_and_clear_bit(mISDN_STACK_WORK,
 261                                     &st->status);
 262                                 test_and_clear_bit(mISDN_STACK_RUNNING,
 263                                     &st->status);
 264                                 break;
 265                         }
 266                 }
 267                 if (test_bit(mISDN_STACK_CLEARING, &st->status)) {
 268                         test_and_set_bit(mISDN_STACK_STOPPED, &st->status);
 269                         test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
 270                         do_clear_stack(st);
 271                         test_and_clear_bit(mISDN_STACK_CLEARING, &st->status);
 272                         test_and_set_bit(mISDN_STACK_RESTART, &st->status);
 273                 }
 274                 if (test_and_clear_bit(mISDN_STACK_RESTART, &st->status)) {
 275                         test_and_clear_bit(mISDN_STACK_STOPPED, &st->status);
 276                         test_and_set_bit(mISDN_STACK_RUNNING, &st->status);
 277                         if (!skb_queue_empty(&st->msgq))
 278                                 test_and_set_bit(mISDN_STACK_WORK,
 279                                     &st->status);
 280                 }
 281                 if (test_bit(mISDN_STACK_ABORT, &st->status))
 282                         break;
 283                 if (st->notify != NULL) {
 284                         complete(st->notify);
 285                         st->notify = NULL;
 286                 }
 287 #ifdef MISDN_MSG_STATS
 288                 st->sleep_cnt++;
 289 #endif
 290                 test_and_clear_bit(mISDN_STACK_ACTIVE, &st->status);
 291                 wait_event_interruptible(st->workq, (st->status &
 292                     mISDN_STACK_ACTION_MASK));
 293                 if (*debug & DEBUG_MSG_THREAD)
 294                         printk(KERN_DEBUG "%s: %s wake status %08lx\n",
 295                             __func__, dev_name(&st->dev->dev), st->status);
 296                 test_and_set_bit(mISDN_STACK_ACTIVE, &st->status);
 297
 298                 test_and_clear_bit(mISDN_STACK_WAKEUP, &st->status);
 299
 300                 if (test_bit(mISDN_STACK_STOPPED, &st->status)) {
 301                         test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
 302 #ifdef MISDN_MSG_STATS
 303                         st->stopped_cnt++;
 304 #endif
 305                 }
 306         }
 307 #ifdef MISDN_MSG_STATS
 308         printk(KERN_DEBUG "mISDNStackd daemon for %s proceed %d "
 309             "msg %d sleep %d stopped\n",
 310             dev_name(&st->dev->dev), st->msg_cnt, st->sleep_cnt,
 311             st->stopped_cnt);
 312         printk(KERN_DEBUG
 313             "mISDNStackd daemon for %s utime(%ld) stime(%ld)\n",
 314             dev_name(&st->dev->dev), st->thread->utime, st->thread->stime);
 315         printk(KERN_DEBUG
 316             "mISDNStackd daemon for %s nvcsw(%ld) nivcsw(%ld)\n",
 317             dev_name(&st->dev->dev), st->thread->nvcsw, st->thread->nivcsw);
 318         printk(KERN_DEBUG "mISDNStackd daemon for %s killed now\n",
 319             dev_name(&st->dev->dev));
 320 #endif
 321         test_and_set_bit(mISDN_STACK_KILLED, &st->status);
 322         test_and_clear_bit(mISDN_STACK_RUNNING, &st->status);
 323         test_and_clear_bit(mISDN_STACK_ACTIVE, &st->status);
 324         test_and_clear_bit(mISDN_STACK_ABORT, &st->status);
 325         skb_queue_purge(&st->msgq);
 326         st->thread = NULL;
 327         if (st->notify != NULL) {
 328                 complete(st->notify);
 329                 st->notify = NULL;
 330         }
 331         return 0;
 332 }
 333
 334 static int
 335 l1_receive(struct mISDNchannel *ch, struct sk_buff *skb)
 336 {
 337         if (!ch->st)
 338                 return -ENODEV;
 339         __net_timestamp(skb);
 340         _queue_message(ch->st, skb);
 341         return 0;
 342 }
 343
 344 void
 345 set_channel_address(struct mISDNchannel *ch, u_int sapi, u_int tei)
 346 {
 347         ch->addr = sapi | (tei << 8);
 348 }
 349
 350 void
 351 __add_layer2(struct mISDNchannel *ch, struct mISDNstack *st)
 352 {
 353         list_add_tail(&ch->list, &st->layer2);
 354 }
 355
 356 void
 357 add_layer2(struct mISDNchannel *ch, struct mISDNstack *st)
 358 {
 359         mutex_lock(&st->lmutex);
 360         __add_layer2(ch, st);
 361         mutex_unlock(&st->lmutex);
 362 }
 363
 364 static int
 365 st_own_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
 366 {
 367         if (!ch->st || ch->st->layer1)
 368                 return -EINVAL;
 369         return ch->st->layer1->ctrl(ch->st->layer1, cmd, arg);
 370 }
 371
 372 int
 373 create_stack(struct mISDNdevice *dev)
 374 {
 375         struct mISDNstack       *newst;
 376         int                     err;
 377         DECLARE_COMPLETION_ONSTACK(done);
 378
 379         newst = kzalloc(sizeof(struct mISDNstack), GFP_KERNEL);
 380         if (!newst) {
 381                 printk(KERN_ERR "kmalloc mISDN_stack failed\n");
 382                 return -ENOMEM;
 383         }
 384         newst->dev = dev;
 385         INIT_LIST_HEAD(&newst->layer2);
 386         INIT_HLIST_HEAD(&newst->l1sock.head);
 387         rwlock_init(&newst->l1sock.lock);
 388         init_waitqueue_head(&newst->workq);
 389         skb_queue_head_init(&newst->msgq);
 390         mutex_init(&newst->lmutex);
 391         dev->D.st = newst;
 392         err = create_teimanager(dev);
 393         if (err) {
 394                 printk(KERN_ERR "kmalloc teimanager failed\n");
 395                 kfree(newst);
 396                 return err;
 397         }
 398         dev->teimgr->peer = &newst->own;
 399         dev->teimgr->recv = mISDN_queue_message;
 400         dev->teimgr->st = newst;
 401         newst->layer1 = &dev->D;
 402         dev->D.recv = l1_receive;
 403         dev->D.peer = &newst->own;
 404         newst->own.st = newst;
 405         newst->own.ctrl = st_own_ctrl;
 406         newst->own.send = mISDN_queue_message;
 407         newst->own.recv = mISDN_queue_message;
 408         if (*debug & DEBUG_CORE_FUNC)
 409                 printk(KERN_DEBUG "%s: st(%s)\n", __func__,
 410                     dev_name(&newst->dev->dev));
 411         newst->notify = &done;
 412         newst->thread = kthread_run(mISDNStackd, (void *)newst, "mISDN_%s",
 413                 dev_name(&newst->dev->dev));
 414         if (IS_ERR(newst->thread)) {
 415                 err = PTR_ERR(newst->thread);
 416                 printk(KERN_ERR
 417                         "mISDN:cannot create kernel thread for %s (%d)\n",
 418                         dev_name(&newst->dev->dev), err);
 419                 delete_teimanager(dev->teimgr);
 420                 kfree(newst);
 421         } else
 422                 wait_for_completion(&done);
 423         return err;
 424 }
 425
 426 int
 427 connect_layer1(struct mISDNdevice *dev, struct mISDNchannel *ch,
 428                 u_int protocol, struct sockaddr_mISDN *adr)
 429 {
 430         struct mISDN_sock       *msk = container_of(ch, struct mISDN_sock, ch);
 431         struct channel_req      rq;
 432         int                     err;
 433
 434
 435         if (*debug &  DEBUG_CORE_FUNC)
 436                 printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n",
 437                         __func__, dev_name(&dev->dev), protocol, adr->dev,
 438                         adr->channel, adr->sapi, adr->tei);
 439         switch (protocol) {
 440         case ISDN_P_NT_S0:
 441         case ISDN_P_NT_E1:
 442         case ISDN_P_TE_S0:
 443         case ISDN_P_TE_E1:
 444                 ch->recv = mISDN_queue_message;
 445                 ch->peer = &dev->D.st->own;
 446                 ch->st = dev->D.st;
 447                 rq.protocol = protocol;
 448                 rq.adr.channel = adr->channel;
 449                 err = dev->D.ctrl(&dev->D, OPEN_CHANNEL, &rq);
 450                 printk(KERN_DEBUG "%s: ret %d (dev %d)\n", __func__, err,
 451                         dev->id);
 452                 if (err)
 453                         return err;
 454                 write_lock_bh(&dev->D.st->l1sock.lock);
 455                 sk_add_node(&msk->sk, &dev->D.st->l1sock.head);
 456                 write_unlock_bh(&dev->D.st->l1sock.lock);
 457                 break;
 458         default:
 459                 return -ENOPROTOOPT;
 460         }
 461         return 0;
 462 }
 463
 464 int
 465 connect_Bstack(struct mISDNdevice *dev, struct mISDNchannel *ch,
 466     u_int protocol, struct sockaddr_mISDN *adr)
 467 {
 468         struct channel_req      rq, rq2;
 469         int                     pmask, err;
 470         struct Bprotocol        *bp;
 471
 472         if (*debug &  DEBUG_CORE_FUNC)
 473                 printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n",
 474                         __func__, dev_name(&dev->dev), protocol,
 475                         adr->dev, adr->channel, adr->sapi,
 476                         adr->tei);
 477         ch->st = dev->D.st;
 478         pmask = 1 << (protocol & ISDN_P_B_MASK);
 479         if (pmask & dev->Bprotocols) {
 480                 rq.protocol = protocol;
 481                 rq.adr = *adr;
 482                 err = dev->D.ctrl(&dev->D, OPEN_CHANNEL, &rq);
 483                 if (err)
 484                         return err;
 485                 ch->recv = rq.ch->send;
 486                 ch->peer = rq.ch;
 487                 rq.ch->recv = ch->send;
 488                 rq.ch->peer = ch;
 489                 rq.ch->st = dev->D.st;
 490         } else {
 491                 bp = get_Bprotocol4mask(pmask);
 492                 if (!bp)
 493                         return -ENOPROTOOPT;
 494                 rq2.protocol = protocol;
 495                 rq2.adr = *adr;
 496                 rq2.ch = ch;
 497                 err = bp->create(&rq2);
 498                 if (err)
 499                         return err;
 500                 ch->recv = rq2.ch->send;
 501                 ch->peer = rq2.ch;
 502                 rq2.ch->st = dev->D.st;
 503                 rq.protocol = rq2.protocol;
 504                 rq.adr = *adr;
 505                 err = dev->D.ctrl(&dev->D, OPEN_CHANNEL, &rq);
 506                 if (err) {
 507                         rq2.ch->ctrl(rq2.ch, CLOSE_CHANNEL, NULL);
 508                         return err;
 509                 }
 510                 rq2.ch->recv = rq.ch->send;
 511                 rq2.ch->peer = rq.ch;
 512                 rq.ch->recv = rq2.ch->send;
 513                 rq.ch->peer = rq2.ch;
 514                 rq.ch->st = dev->D.st;
 515         }
 516         ch->protocol = protocol;
 517         ch->nr = rq.ch->nr;
 518         return 0;
 519 }
 520
 521 int
 522 create_l2entity(struct mISDNdevice *dev, struct mISDNchannel *ch,
 523     u_int protocol, struct sockaddr_mISDN *adr)
 524 {
 525         struct channel_req      rq;
 526         int                     err;
 527
 528         if (*debug &  DEBUG_CORE_FUNC)
 529                 printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n",
 530                         __func__, dev_name(&dev->dev), protocol,
 531                         adr->dev, adr->channel, adr->sapi,
 532                         adr->tei);
 533         rq.protocol = ISDN_P_TE_S0;
 534         if (dev->Dprotocols & (1 << ISDN_P_TE_E1))
 535                 rq.protocol = ISDN_P_TE_E1;
 536         switch (protocol) {
 537         case ISDN_P_LAPD_NT:
 538                 rq.protocol = ISDN_P_NT_S0;
 539                 if (dev->Dprotocols & (1 << ISDN_P_NT_E1))
 540                         rq.protocol = ISDN_P_NT_E1;
 541         case ISDN_P_LAPD_TE:
 542                 ch->recv = mISDN_queue_message;
 543                 ch->peer = &dev->D.st->own;
 544                 ch->st = dev->D.st;
 545                 rq.adr.channel = 0;
 546                 err = dev->D.ctrl(&dev->D, OPEN_CHANNEL, &rq);
 547                 printk(KERN_DEBUG "%s: ret 1 %d\n", __func__, err);
 548                 if (err)
 549                         break;
 550                 rq.protocol = protocol;
 551                 rq.adr = *adr;
 552                 rq.ch = ch;
 553                 err = dev->teimgr->ctrl(dev->teimgr, OPEN_CHANNEL, &rq);
 554                 printk(KERN_DEBUG "%s: ret 2 %d\n", __func__, err);
 555                 if (!err) {
 556                         if ((protocol == ISDN_P_LAPD_NT) && !rq.ch)
 557                                 break;
 558                         add_layer2(rq.ch, dev->D.st);
 559                         rq.ch->recv = mISDN_queue_message;
 560                         rq.ch->peer = &dev->D.st->own;
 561                         rq.ch->ctrl(rq.ch, OPEN_CHANNEL, NULL); /* can't fail */
 562                 }
 563                 break;
 564         default:
 565                 err = -EPROTONOSUPPORT;
 566         }
 567         return err;
 568 }
 569
 570 void
 571 delete_channel(struct mISDNchannel *ch)
 572 {
 573         struct mISDN_sock       *msk = container_of(ch, struct mISDN_sock, ch);
 574         struct mISDNchannel     *pch;
 575
 576         if (!ch->st) {
 577                 printk(KERN_WARNING "%s: no stack\n", __func__);
 578                 return;
 579         }
 580         if (*debug & DEBUG_CORE_FUNC)
 581                 printk(KERN_DEBUG "%s: st(%s) protocol(%x)\n", __func__,
 582                     dev_name(&ch->st->dev->dev), ch->protocol);
 583         if (ch->protocol >= ISDN_P_B_START) {
 584                 if (ch->peer) {
 585                         ch->peer->ctrl(ch->peer, CLOSE_CHANNEL, NULL);
 586                         ch->peer = NULL;
 587                 }
 588                 return;
 589         }
 590         switch (ch->protocol) {
 591         case ISDN_P_NT_S0:
 592         case ISDN_P_TE_S0:
 593         case ISDN_P_NT_E1:
 594         case ISDN_P_TE_E1:
 595                 write_lock_bh(&ch->st->l1sock.lock);
 596                 sk_del_node_init(&msk->sk);
 597                 write_unlock_bh(&ch->st->l1sock.lock);
 598                 ch->st->dev->D.ctrl(&ch->st->dev->D, CLOSE_CHANNEL, NULL);
 599                 break;
 600         case ISDN_P_LAPD_TE:
 601                 pch = get_channel4id(ch->st, ch->nr);
 602                 if (pch) {
 603                         mutex_lock(&ch->st->lmutex);
 604                         list_del(&pch->list);
 605                         mutex_unlock(&ch->st->lmutex);
 606                         pch->ctrl(pch, CLOSE_CHANNEL, NULL);
 607                         pch = ch->st->dev->teimgr;
 608                         pch->ctrl(pch, CLOSE_CHANNEL, NULL);
 609                 } else
 610                         printk(KERN_WARNING "%s: no l2 channel\n",
 611                             __func__);
 612                 break;
 613         case ISDN_P_LAPD_NT:
 614                 pch = ch->st->dev->teimgr;
 615                 if (pch) {
 616                         pch->ctrl(pch, CLOSE_CHANNEL, NULL);
 617                 } else
 618                         printk(KERN_WARNING "%s: no l2 channel\n",
 619                             __func__);
 620                 break;
 621         default:
 622                 break;
 623         }
 624         return;
 625 }
 626
 627 void
 628 delete_stack(struct mISDNdevice *dev)
 629 {
 630         struct mISDNstack       *st = dev->D.st;
 631         DECLARE_COMPLETION_ONSTACK(done);
 632
 633         if (*debug & DEBUG_CORE_FUNC)
 634                 printk(KERN_DEBUG "%s: st(%s)\n", __func__,
 635                     dev_name(&st->dev->dev));
 636         if (dev->teimgr)
 637                 delete_teimanager(dev->teimgr);
 638         if (st->thread) {
 639                 if (st->notify) {
 640                         printk(KERN_WARNING "%s: notifier in use\n",
 641                             __func__);
 642                                 complete(st->notify);
 643                 }
 644                 st->notify = &done;
 645                 test_and_set_bit(mISDN_STACK_ABORT, &st->status);
 646                 test_and_set_bit(mISDN_STACK_WAKEUP, &st->status);
 647                 wake_up_interruptible(&st->workq);
 648                 wait_for_completion(&done);
 649         }
 650         if (!list_empty(&st->layer2))
 651                 printk(KERN_WARNING "%s: layer2 list not empty\n",
 652                     __func__);
 653         if (!hlist_empty(&st->l1sock.head))
 654                 printk(KERN_WARNING "%s: layer1 list not empty\n",
 655                     __func__);
 656         kfree(st);
 657 }
 658
 659 void
 660 mISDN_initstack(u_int *dp)
 661 {
 662         debug = dp;
 663 }