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