e04bad6c5bafbf0a13d5978a73b2dd4429edf415
[linux-2.6.git] / drivers / isdn / mISDN / tei.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 #include "layer2.h"
18 #include <linux/random.h>
19 #include "core.h"
20
21 #define ID_REQUEST      1
22 #define ID_ASSIGNED     2
23 #define ID_DENIED       3
24 #define ID_CHK_REQ      4
25 #define ID_CHK_RES      5
26 #define ID_REMOVE       6
27 #define ID_VERIFY       7
28
29 #define TEI_ENTITY_ID   0xf
30
31 #define MGR_PH_ACTIVE   16
32 #define MGR_PH_NOTREADY 17
33
34 #define DATIMER_VAL     10000
35
36 static  u_int   *debug;
37
38 static struct Fsm deactfsm = {NULL, 0, 0, NULL, NULL};
39 static struct Fsm teifsmu = {NULL, 0, 0, NULL, NULL};
40 static struct Fsm teifsmn = {NULL, 0, 0, NULL, NULL};
41
42 enum {
43         ST_L1_DEACT,
44         ST_L1_DEACT_PENDING,
45         ST_L1_ACTIV,
46 };
47 #define DEACT_STATE_COUNT (ST_L1_ACTIV+1)
48
49 static char *strDeactState[] =
50 {
51         "ST_L1_DEACT",
52         "ST_L1_DEACT_PENDING",
53         "ST_L1_ACTIV",
54 };
55
56 enum {
57         EV_ACTIVATE,
58         EV_ACTIVATE_IND,
59         EV_DEACTIVATE,
60         EV_DEACTIVATE_IND,
61         EV_UI,
62         EV_DATIMER,
63 };
64
65 #define DEACT_EVENT_COUNT (EV_DATIMER+1)
66
67 static char *strDeactEvent[] =
68 {
69         "EV_ACTIVATE",
70         "EV_ACTIVATE_IND",
71         "EV_DEACTIVATE",
72         "EV_DEACTIVATE_IND",
73         "EV_UI",
74         "EV_DATIMER",
75 };
76
77 static void
78 da_debug(struct FsmInst *fi, char *fmt, ...)
79 {
80         struct manager  *mgr = fi->userdata;
81         va_list va;
82
83         if (!(*debug & DEBUG_L2_TEIFSM))
84                 return;
85         va_start(va, fmt);
86         printk(KERN_DEBUG "mgr(%d): ", mgr->ch.st->dev->id);
87         vprintk(fmt, va);
88         printk("\n");
89         va_end(va);
90 }
91
92 static void
93 da_activate(struct FsmInst *fi, int event, void *arg)
94 {
95         struct manager  *mgr = fi->userdata;
96
97         if (fi->state == ST_L1_DEACT_PENDING)
98                 mISDN_FsmDelTimer(&mgr->datimer, 1);
99         mISDN_FsmChangeState(fi, ST_L1_ACTIV);
100 }
101
102 static void
103 da_deactivate_ind(struct FsmInst *fi, int event, void *arg)
104 {
105         mISDN_FsmChangeState(fi, ST_L1_DEACT);
106 }
107
108 static void
109 da_deactivate(struct FsmInst *fi, int event, void *arg)
110 {
111         struct manager  *mgr = fi->userdata;
112         struct layer2   *l2;
113         u_long          flags;
114
115         read_lock_irqsave(&mgr->lock, flags);
116         list_for_each_entry(l2, &mgr->layer2, list) {
117                 if (l2->l2m.state > ST_L2_4) {
118                         /* have still activ TEI */
119                         read_unlock_irqrestore(&mgr->lock, flags);
120                         return;
121                 }
122         }
123         read_unlock_irqrestore(&mgr->lock, flags);
124         /* All TEI are inactiv */
125         if (!test_bit(OPTION_L1_HOLD, &mgr->options)) {
126                 mISDN_FsmAddTimer(&mgr->datimer, DATIMER_VAL, EV_DATIMER,
127                         NULL, 1);
128                 mISDN_FsmChangeState(fi, ST_L1_DEACT_PENDING);
129         }
130 }
131
132 static void
133 da_ui(struct FsmInst *fi, int event, void *arg)
134 {
135         struct manager  *mgr = fi->userdata;
136
137         /* restart da timer */
138         if (!test_bit(OPTION_L1_HOLD, &mgr->options)) {
139                 mISDN_FsmDelTimer(&mgr->datimer, 2);
140                 mISDN_FsmAddTimer(&mgr->datimer, DATIMER_VAL, EV_DATIMER,
141                         NULL, 2);
142         }
143 }
144
145 static void
146 da_timer(struct FsmInst *fi, int event, void *arg)
147 {
148         struct manager  *mgr = fi->userdata;
149         struct layer2   *l2;
150         u_long          flags;
151
152         /* check again */
153         read_lock_irqsave(&mgr->lock, flags);
154         list_for_each_entry(l2, &mgr->layer2, list) {
155                 if (l2->l2m.state > ST_L2_4) {
156                         /* have still activ TEI */
157                         read_unlock_irqrestore(&mgr->lock, flags);
158                         mISDN_FsmChangeState(fi, ST_L1_ACTIV);
159                         return;
160                 }
161         }
162         read_unlock_irqrestore(&mgr->lock, flags);
163         /* All TEI are inactiv */
164         mISDN_FsmChangeState(fi, ST_L1_DEACT);
165         _queue_data(&mgr->ch, PH_DEACTIVATE_REQ, MISDN_ID_ANY, 0, NULL,
166             GFP_ATOMIC);
167 }
168
169 static struct FsmNode DeactFnList[] =
170 {
171         {ST_L1_DEACT, EV_ACTIVATE_IND, da_activate},
172         {ST_L1_ACTIV, EV_DEACTIVATE_IND, da_deactivate_ind},
173         {ST_L1_ACTIV, EV_DEACTIVATE, da_deactivate},
174         {ST_L1_DEACT_PENDING, EV_ACTIVATE, da_activate},
175         {ST_L1_DEACT_PENDING, EV_UI, da_ui},
176         {ST_L1_DEACT_PENDING, EV_DATIMER, da_timer},
177 };
178
179 enum {
180         ST_TEI_NOP,
181         ST_TEI_IDREQ,
182         ST_TEI_IDVERIFY,
183 };
184
185 #define TEI_STATE_COUNT (ST_TEI_IDVERIFY+1)
186
187 static char *strTeiState[] =
188 {
189         "ST_TEI_NOP",
190         "ST_TEI_IDREQ",
191         "ST_TEI_IDVERIFY",
192 };
193
194 enum {
195         EV_IDREQ,
196         EV_ASSIGN,
197         EV_ASSIGN_REQ,
198         EV_DENIED,
199         EV_CHKREQ,
200         EV_CHKRESP,
201         EV_REMOVE,
202         EV_VERIFY,
203         EV_TIMER,
204 };
205
206 #define TEI_EVENT_COUNT (EV_TIMER+1)
207
208 static char *strTeiEvent[] =
209 {
210         "EV_IDREQ",
211         "EV_ASSIGN",
212         "EV_ASSIGN_REQ",
213         "EV_DENIED",
214         "EV_CHKREQ",
215         "EV_CHKRESP",
216         "EV_REMOVE",
217         "EV_VERIFY",
218         "EV_TIMER",
219 };
220
221 static void
222 tei_debug(struct FsmInst *fi, char *fmt, ...)
223 {
224         struct teimgr   *tm = fi->userdata;
225         va_list va;
226
227         if (!(*debug & DEBUG_L2_TEIFSM))
228                 return;
229         va_start(va, fmt);
230         printk(KERN_DEBUG "sapi(%d) tei(%d): ", tm->l2->sapi, tm->l2->tei);
231         vprintk(fmt, va);
232         printk("\n");
233         va_end(va);
234 }
235
236
237
238 static int
239 get_free_id(struct manager *mgr)
240 {
241         u64             ids = 0;
242         int             i;
243         struct layer2   *l2;
244
245         list_for_each_entry(l2, &mgr->layer2, list) {
246                 if (l2->ch.nr > 63) {
247                         printk(KERN_WARNING
248                             "%s: more as 63 layer2 for one device\n",
249                             __func__);
250                         return -EBUSY;
251                 }
252                 test_and_set_bit(l2->ch.nr, (u_long *)&ids);
253         }
254         for (i = 1; i < 64; i++)
255                 if (!test_bit(i, (u_long *)&ids))
256                         return i;
257         printk(KERN_WARNING "%s: more as 63 layer2 for one device\n",
258             __func__);
259         return -EBUSY;
260 }
261
262 static int
263 get_free_tei(struct manager *mgr)
264 {
265         u64             ids = 0;
266         int             i;
267         struct layer2   *l2;
268
269         list_for_each_entry(l2, &mgr->layer2, list) {
270                 if (l2->ch.nr == 0)
271                         continue;
272                 if ((l2->ch.addr & 0xff) != 0)
273                         continue;
274                 i = l2->ch.addr >> 8;
275                 if (i < 64)
276                         continue;
277                 i -= 64;
278
279                 test_and_set_bit(i, (u_long *)&ids);
280         }
281         for (i = 0; i < 64; i++)
282                 if (!test_bit(i, (u_long *)&ids))
283                         return i + 64;
284         printk(KERN_WARNING "%s: more as 63 dynamic tei for one device\n",
285             __func__);
286         return -1;
287 }
288
289 static void
290 teiup_create(struct manager *mgr, u_int prim, int len, void *arg)
291 {
292         struct sk_buff  *skb;
293         struct mISDNhead *hh;
294         int             err;
295
296         skb = mI_alloc_skb(len, GFP_ATOMIC);
297         if (!skb)
298                 return;
299         hh = mISDN_HEAD_P(skb);
300         hh->prim = prim;
301         hh->id = (mgr->ch.nr << 16) | mgr->ch.addr;
302         if (len)
303                 memcpy(skb_put(skb, len), arg, len);
304         err = mgr->up->send(mgr->up, skb);
305         if (err) {
306                 printk(KERN_WARNING "%s: err=%d\n", __func__, err);
307                 dev_kfree_skb(skb);
308         }
309 }
310
311 static u_int
312 new_id(struct manager *mgr)
313 {
314         u_int   id;
315
316         id = mgr->nextid++;
317         if (id == 0x7fff)
318                 mgr->nextid = 1;
319         id <<= 16;
320         id |= GROUP_TEI << 8;
321         id |= TEI_SAPI;
322         return id;
323 }
324
325 static void
326 do_send(struct manager *mgr)
327 {
328         if (!test_bit(MGR_PH_ACTIVE, &mgr->options))
329                 return;
330
331         if (!test_and_set_bit(MGR_PH_NOTREADY, &mgr->options)) {
332                 struct sk_buff  *skb = skb_dequeue(&mgr->sendq);
333
334                 if (!skb) {
335                         test_and_clear_bit(MGR_PH_NOTREADY, &mgr->options);
336                         return;
337                 }
338                 mgr->lastid = mISDN_HEAD_ID(skb);
339                 mISDN_FsmEvent(&mgr->deact, EV_UI, NULL);
340                 if (mgr->ch.recv(mgr->ch.peer, skb)) {
341                         dev_kfree_skb(skb);
342                         test_and_clear_bit(MGR_PH_NOTREADY, &mgr->options);
343                         mgr->lastid = MISDN_ID_NONE;
344                 }
345         }
346 }
347
348 static void
349 do_ack(struct manager *mgr, u_int id)
350 {
351         if (test_bit(MGR_PH_NOTREADY, &mgr->options)) {
352                 if (id == mgr->lastid) {
353                         if (test_bit(MGR_PH_ACTIVE, &mgr->options)) {
354                                 struct sk_buff  *skb;
355
356                                 skb = skb_dequeue(&mgr->sendq);
357                                 if (skb) {
358                                         mgr->lastid = mISDN_HEAD_ID(skb);
359                                         if (!mgr->ch.recv(mgr->ch.peer, skb))
360                                                 return;
361                                         dev_kfree_skb(skb);
362                                 }
363                         }
364                         mgr->lastid = MISDN_ID_NONE;
365                         test_and_clear_bit(MGR_PH_NOTREADY, &mgr->options);
366                 }
367         }
368 }
369
370 static void
371 mgr_send_down(struct manager *mgr, struct sk_buff *skb)
372 {
373         skb_queue_tail(&mgr->sendq, skb);
374         if (!test_bit(MGR_PH_ACTIVE, &mgr->options)) {
375                 _queue_data(&mgr->ch, PH_ACTIVATE_REQ, MISDN_ID_ANY, 0,
376                     NULL, GFP_KERNEL);
377         } else {
378                 do_send(mgr);
379         }
380 }
381
382 static int
383 dl_unit_data(struct manager *mgr, struct sk_buff *skb)
384 {
385         if (!test_bit(MGR_OPT_NETWORK, &mgr->options)) /* only net send UI */
386                 return -EINVAL;
387         if (!test_bit(MGR_PH_ACTIVE, &mgr->options))
388                 _queue_data(&mgr->ch, PH_ACTIVATE_REQ, MISDN_ID_ANY, 0,
389                     NULL, GFP_KERNEL);
390         skb_push(skb, 3);
391         skb->data[0] = 0x02; /* SAPI 0 C/R = 1 */
392         skb->data[1] = 0xff; /* TEI 127 */
393         skb->data[2] = UI;   /* UI frame */
394         mISDN_HEAD_PRIM(skb) = PH_DATA_REQ;
395         mISDN_HEAD_ID(skb) = new_id(mgr);
396         skb_queue_tail(&mgr->sendq, skb);
397         do_send(mgr);
398         return 0;
399 }
400
401 static unsigned int
402 random_ri(void)
403 {
404         u16 x;
405
406         get_random_bytes(&x, sizeof(x));
407         return x;
408 }
409
410 static struct layer2 *
411 findtei(struct manager *mgr, int tei)
412 {
413         struct layer2   *l2;
414         u_long          flags;
415
416         read_lock_irqsave(&mgr->lock, flags);
417         list_for_each_entry(l2, &mgr->layer2, list) {
418                 if ((l2->sapi == 0) && (l2->tei > 0) &&
419                     (l2->tei != GROUP_TEI) && (l2->tei == tei))
420                         goto done;
421         }
422         l2 = NULL;
423 done:
424         read_unlock_irqrestore(&mgr->lock, flags);
425         return l2;
426 }
427
428 static void
429 put_tei_msg(struct manager *mgr, u_char m_id, unsigned int ri, int tei)
430 {
431         struct sk_buff *skb;
432         u_char bp[8];
433
434         bp[0] = (TEI_SAPI << 2);
435         if (test_bit(MGR_OPT_NETWORK, &mgr->options))
436                 bp[0] |= 2; /* CR:=1 for net command */
437         bp[1] = (GROUP_TEI << 1) | 0x1;
438         bp[2] = UI;
439         bp[3] = TEI_ENTITY_ID;
440         bp[4] = ri >> 8;
441         bp[5] = ri & 0xff;
442         bp[6] = m_id;
443         bp[7] = ((tei << 1) & 0xff) | 1;
444         skb = _alloc_mISDN_skb(PH_DATA_REQ, new_id(mgr), 8, bp, GFP_ATOMIC);
445         if (!skb) {
446                 printk(KERN_WARNING "%s: no skb for tei msg\n", __func__);
447                 return;
448         }
449         mgr_send_down(mgr, skb);
450 }
451
452 static void
453 tei_id_request(struct FsmInst *fi, int event, void *arg)
454 {
455         struct teimgr *tm = fi->userdata;
456
457         if (tm->l2->tei != GROUP_TEI) {
458                 tm->tei_m.printdebug(&tm->tei_m,
459                         "assign request for allready assigned tei %d",
460                         tm->l2->tei);
461                 return;
462         }
463         tm->ri = random_ri();
464         if (*debug & DEBUG_L2_TEI)
465                 tm->tei_m.printdebug(&tm->tei_m,
466                         "assign request ri %d", tm->ri);
467         put_tei_msg(tm->mgr, ID_REQUEST, tm->ri, GROUP_TEI);
468         mISDN_FsmChangeState(fi, ST_TEI_IDREQ);
469         mISDN_FsmAddTimer(&tm->timer, tm->tval, EV_TIMER, NULL, 1);
470         tm->nval = 3;
471 }
472
473 static void
474 tei_id_assign(struct FsmInst *fi, int event, void *arg)
475 {
476         struct teimgr   *tm = fi->userdata;
477         struct layer2   *l2;
478         u_char *dp = arg;
479         int ri, tei;
480
481         ri = ((unsigned int) *dp++ << 8);
482         ri += *dp++;
483         dp++;
484         tei = *dp >> 1;
485         if (*debug & DEBUG_L2_TEI)
486                 tm->tei_m.printdebug(fi, "identity assign ri %d tei %d",
487                         ri, tei);
488         l2 = findtei(tm->mgr, tei);
489         if (l2) {       /* same tei is in use */
490                 if (ri != l2->tm->ri) {
491                         tm->tei_m.printdebug(fi,
492                                 "possible duplicate assignment tei %d", tei);
493                         tei_l2(l2, MDL_ERROR_RSP, 0);
494                 }
495         } else if (ri == tm->ri) {
496                 mISDN_FsmDelTimer(&tm->timer, 1);
497                 mISDN_FsmChangeState(fi, ST_TEI_NOP);
498                 tei_l2(tm->l2, MDL_ASSIGN_REQ, tei);
499         }
500 }
501
502 static void
503 tei_id_test_dup(struct FsmInst *fi, int event, void *arg)
504 {
505         struct teimgr   *tm = fi->userdata;
506         struct layer2   *l2;
507         u_char *dp = arg;
508         int tei, ri;
509
510         ri = ((unsigned int) *dp++ << 8);
511         ri += *dp++;
512         dp++;
513         tei = *dp >> 1;
514         if (*debug & DEBUG_L2_TEI)
515                 tm->tei_m.printdebug(fi, "foreign identity assign ri %d tei %d",
516                         ri, tei);
517         l2 = findtei(tm->mgr, tei);
518         if (l2) {       /* same tei is in use */
519                 if (ri != l2->tm->ri) { /* and it wasn't our request */
520                         tm->tei_m.printdebug(fi,
521                                 "possible duplicate assignment tei %d", tei);
522                         mISDN_FsmEvent(&l2->tm->tei_m, EV_VERIFY, NULL);
523                 }
524         }
525 }
526
527 static void
528 tei_id_denied(struct FsmInst *fi, int event, void *arg)
529 {
530         struct teimgr *tm = fi->userdata;
531         u_char *dp = arg;
532         int ri, tei;
533
534         ri = ((unsigned int) *dp++ << 8);
535         ri += *dp++;
536         dp++;
537         tei = *dp >> 1;
538         if (*debug & DEBUG_L2_TEI)
539                 tm->tei_m.printdebug(fi, "identity denied ri %d tei %d",
540                         ri, tei);
541 }
542
543 static void
544 tei_id_chk_req(struct FsmInst *fi, int event, void *arg)
545 {
546         struct teimgr *tm = fi->userdata;
547         u_char *dp = arg;
548         int tei;
549
550         tei = *(dp+3) >> 1;
551         if (*debug & DEBUG_L2_TEI)
552                 tm->tei_m.printdebug(fi, "identity check req tei %d", tei);
553         if ((tm->l2->tei != GROUP_TEI) && ((tei == GROUP_TEI) ||
554             (tei == tm->l2->tei))) {
555                 mISDN_FsmDelTimer(&tm->timer, 4);
556                 mISDN_FsmChangeState(&tm->tei_m, ST_TEI_NOP);
557                 put_tei_msg(tm->mgr, ID_CHK_RES, random_ri(), tm->l2->tei);
558         }
559 }
560
561 static void
562 tei_id_remove(struct FsmInst *fi, int event, void *arg)
563 {
564         struct teimgr *tm = fi->userdata;
565         u_char *dp = arg;
566         int tei;
567
568         tei = *(dp+3) >> 1;
569         if (*debug & DEBUG_L2_TEI)
570                 tm->tei_m.printdebug(fi, "identity remove tei %d", tei);
571         if ((tm->l2->tei != GROUP_TEI) &&
572             ((tei == GROUP_TEI) || (tei == tm->l2->tei))) {
573                 mISDN_FsmDelTimer(&tm->timer, 5);
574                 mISDN_FsmChangeState(&tm->tei_m, ST_TEI_NOP);
575                 tei_l2(tm->l2, MDL_REMOVE_REQ, 0);
576         }
577 }
578
579 static void
580 tei_id_verify(struct FsmInst *fi, int event, void *arg)
581 {
582         struct teimgr *tm = fi->userdata;
583
584         if (*debug & DEBUG_L2_TEI)
585                 tm->tei_m.printdebug(fi, "id verify request for tei %d",
586                         tm->l2->tei);
587         put_tei_msg(tm->mgr, ID_VERIFY, 0, tm->l2->tei);
588         mISDN_FsmChangeState(&tm->tei_m, ST_TEI_IDVERIFY);
589         mISDN_FsmAddTimer(&tm->timer, tm->tval, EV_TIMER, NULL, 2);
590         tm->nval = 2;
591 }
592
593 static void
594 tei_id_req_tout(struct FsmInst *fi, int event, void *arg)
595 {
596         struct teimgr *tm = fi->userdata;
597
598         if (--tm->nval) {
599                 tm->ri = random_ri();
600                 if (*debug & DEBUG_L2_TEI)
601                         tm->tei_m.printdebug(fi, "assign req(%d) ri %d",
602                                 4 - tm->nval, tm->ri);
603                 put_tei_msg(tm->mgr, ID_REQUEST, tm->ri, GROUP_TEI);
604                 mISDN_FsmAddTimer(&tm->timer, tm->tval, EV_TIMER, NULL, 3);
605         } else {
606                 tm->tei_m.printdebug(fi, "assign req failed");
607                 tei_l2(tm->l2, MDL_ERROR_RSP, 0);
608                 mISDN_FsmChangeState(fi, ST_TEI_NOP);
609         }
610 }
611
612 static void
613 tei_id_ver_tout(struct FsmInst *fi, int event, void *arg)
614 {
615         struct teimgr *tm = fi->userdata;
616
617         if (--tm->nval) {
618                 if (*debug & DEBUG_L2_TEI)
619                         tm->tei_m.printdebug(fi,
620                                 "id verify req(%d) for tei %d",
621                                 3 - tm->nval, tm->l2->tei);
622                 put_tei_msg(tm->mgr, ID_VERIFY, 0, tm->l2->tei);
623                 mISDN_FsmAddTimer(&tm->timer, tm->tval, EV_TIMER, NULL, 4);
624         } else {
625                 tm->tei_m.printdebug(fi, "verify req for tei %d failed",
626                         tm->l2->tei);
627                 tei_l2(tm->l2, MDL_REMOVE_REQ, 0);
628                 mISDN_FsmChangeState(fi, ST_TEI_NOP);
629         }
630 }
631
632 static struct FsmNode TeiFnListUser[] =
633 {
634         {ST_TEI_NOP, EV_IDREQ, tei_id_request},
635         {ST_TEI_NOP, EV_ASSIGN, tei_id_test_dup},
636         {ST_TEI_NOP, EV_VERIFY, tei_id_verify},
637         {ST_TEI_NOP, EV_REMOVE, tei_id_remove},
638         {ST_TEI_NOP, EV_CHKREQ, tei_id_chk_req},
639         {ST_TEI_IDREQ, EV_TIMER, tei_id_req_tout},
640         {ST_TEI_IDREQ, EV_ASSIGN, tei_id_assign},
641         {ST_TEI_IDREQ, EV_DENIED, tei_id_denied},
642         {ST_TEI_IDVERIFY, EV_TIMER, tei_id_ver_tout},
643         {ST_TEI_IDVERIFY, EV_REMOVE, tei_id_remove},
644         {ST_TEI_IDVERIFY, EV_CHKREQ, tei_id_chk_req},
645 };
646
647 static void
648 tei_l2remove(struct layer2 *l2)
649 {
650         put_tei_msg(l2->tm->mgr, ID_REMOVE, 0, l2->tei);
651         tei_l2(l2, MDL_REMOVE_REQ, 0);
652         list_del(&l2->ch.list);
653         l2->ch.ctrl(&l2->ch, CLOSE_CHANNEL, NULL);
654 }
655
656 static void
657 tei_assign_req(struct FsmInst *fi, int event, void *arg)
658 {
659         struct teimgr *tm = fi->userdata;
660         u_char *dp = arg;
661
662         if (tm->l2->tei == GROUP_TEI) {
663                 tm->tei_m.printdebug(&tm->tei_m,
664                         "net tei assign request without tei");
665                 return;
666         }
667         tm->ri = ((unsigned int) *dp++ << 8);
668         tm->ri += *dp++;
669         if (*debug & DEBUG_L2_TEI)
670                 tm->tei_m.printdebug(&tm->tei_m,
671                         "net assign request ri %d teim %d", tm->ri, *dp);
672         put_tei_msg(tm->mgr, ID_ASSIGNED, tm->ri, tm->l2->tei);
673         mISDN_FsmChangeState(fi, ST_TEI_NOP);
674 }
675
676 static void
677 tei_id_chk_req_net(struct FsmInst *fi, int event, void *arg)
678 {
679         struct teimgr   *tm = fi->userdata;
680
681         if (*debug & DEBUG_L2_TEI)
682                 tm->tei_m.printdebug(fi, "id check request for tei %d",
683                     tm->l2->tei);
684         tm->rcnt = 0;
685         put_tei_msg(tm->mgr, ID_CHK_REQ, 0, tm->l2->tei);
686         mISDN_FsmChangeState(&tm->tei_m, ST_TEI_IDVERIFY);
687         mISDN_FsmAddTimer(&tm->timer, tm->tval, EV_TIMER, NULL, 2);
688         tm->nval = 2;
689 }
690
691 static void
692 tei_id_chk_resp(struct FsmInst *fi, int event, void *arg)
693 {
694         struct teimgr *tm = fi->userdata;
695         u_char *dp = arg;
696         int tei;
697
698         tei = dp[3] >> 1;
699         if (*debug & DEBUG_L2_TEI)
700                 tm->tei_m.printdebug(fi, "identity check resp tei %d", tei);
701         if (tei == tm->l2->tei)
702                 tm->rcnt++;
703 }
704
705 static void
706 tei_id_verify_net(struct FsmInst *fi, int event, void *arg)
707 {
708         struct teimgr *tm = fi->userdata;
709         u_char *dp = arg;
710         int tei;
711
712         tei = dp[3] >> 1;
713         if (*debug & DEBUG_L2_TEI)
714                 tm->tei_m.printdebug(fi, "identity verify req tei %d/%d",
715                     tei, tm->l2->tei);
716         if (tei == tm->l2->tei)
717                 tei_id_chk_req_net(fi, event, arg);
718 }
719
720 static void
721 tei_id_ver_tout_net(struct FsmInst *fi, int event, void *arg)
722 {
723         struct teimgr *tm = fi->userdata;
724
725         if (tm->rcnt == 1) {
726                 if (*debug & DEBUG_L2_TEI)
727                         tm->tei_m.printdebug(fi,
728                             "check req for tei %d sucessful\n", tm->l2->tei);
729                 mISDN_FsmChangeState(fi, ST_TEI_NOP);
730         } else if (tm->rcnt > 1) {
731                 /* duplicate assignment; remove */
732                 tei_l2remove(tm->l2);
733         } else if (--tm->nval) {
734                 if (*debug & DEBUG_L2_TEI)
735                         tm->tei_m.printdebug(fi,
736                                 "id check req(%d) for tei %d",
737                                 3 - tm->nval, tm->l2->tei);
738                 put_tei_msg(tm->mgr, ID_CHK_REQ, 0, tm->l2->tei);
739                 mISDN_FsmAddTimer(&tm->timer, tm->tval, EV_TIMER, NULL, 4);
740         } else {
741                 tm->tei_m.printdebug(fi, "check req for tei %d failed",
742                         tm->l2->tei);
743                 mISDN_FsmChangeState(fi, ST_TEI_NOP);
744                 tei_l2remove(tm->l2);
745         }
746 }
747
748 static struct FsmNode TeiFnListNet[] =
749 {
750         {ST_TEI_NOP, EV_ASSIGN_REQ, tei_assign_req},
751         {ST_TEI_NOP, EV_VERIFY, tei_id_verify_net},
752         {ST_TEI_NOP, EV_CHKREQ, tei_id_chk_req_net},
753         {ST_TEI_IDVERIFY, EV_TIMER, tei_id_ver_tout_net},
754         {ST_TEI_IDVERIFY, EV_CHKRESP, tei_id_chk_resp},
755 };
756
757 static void
758 tei_ph_data_ind(struct teimgr *tm, u_int mt, u_char *dp, int len)
759 {
760         if (test_bit(FLG_FIXED_TEI, &tm->l2->flag))
761                 return;
762         if (*debug & DEBUG_L2_TEI)
763                 tm->tei_m.printdebug(&tm->tei_m, "tei handler mt %x", mt);
764         if (mt == ID_ASSIGNED)
765                 mISDN_FsmEvent(&tm->tei_m, EV_ASSIGN, dp);
766         else if (mt == ID_DENIED)
767                 mISDN_FsmEvent(&tm->tei_m, EV_DENIED, dp);
768         else if (mt == ID_CHK_REQ)
769                 mISDN_FsmEvent(&tm->tei_m, EV_CHKREQ, dp);
770         else if (mt == ID_REMOVE)
771                 mISDN_FsmEvent(&tm->tei_m, EV_REMOVE, dp);
772         else if (mt == ID_VERIFY)
773                 mISDN_FsmEvent(&tm->tei_m, EV_VERIFY, dp);
774         else if (mt == ID_CHK_RES)
775                 mISDN_FsmEvent(&tm->tei_m, EV_CHKRESP, dp);
776 }
777
778 static struct layer2 *
779 create_new_tei(struct manager *mgr, int tei, int sapi)
780 {
781         u_long          opt = 0;
782         u_long          flags;
783         int             id;
784         struct layer2   *l2;
785
786         if (!mgr->up)
787                 return NULL;
788         if ((tei >= 0) && (tei < 64))
789                 test_and_set_bit(OPTION_L2_FIXEDTEI, &opt);
790         if (mgr->ch.st->dev->Dprotocols
791           & ((1 << ISDN_P_TE_E1) | (1 << ISDN_P_NT_E1)))
792                 test_and_set_bit(OPTION_L2_PMX, &opt);
793         l2 = create_l2(mgr->up, ISDN_P_LAPD_NT, opt, tei, sapi);
794         if (!l2) {
795                 printk(KERN_WARNING "%s:no memory for layer2\n", __func__);
796                 return NULL;
797         }
798         l2->tm = kzalloc(sizeof(struct teimgr), GFP_KERNEL);
799         if (!l2->tm) {
800                 kfree(l2);
801                 printk(KERN_WARNING "%s:no memory for teimgr\n", __func__);
802                 return NULL;
803         }
804         l2->tm->mgr = mgr;
805         l2->tm->l2 = l2;
806         l2->tm->tei_m.debug = *debug & DEBUG_L2_TEIFSM;
807         l2->tm->tei_m.userdata = l2->tm;
808         l2->tm->tei_m.printdebug = tei_debug;
809         l2->tm->tei_m.fsm = &teifsmn;
810         l2->tm->tei_m.state = ST_TEI_NOP;
811         l2->tm->tval = 2000; /* T202  2 sec */
812         mISDN_FsmInitTimer(&l2->tm->tei_m, &l2->tm->timer);
813         write_lock_irqsave(&mgr->lock, flags);
814         id = get_free_id(mgr);
815         list_add_tail(&l2->list, &mgr->layer2);
816         write_unlock_irqrestore(&mgr->lock, flags);
817         if (id < 0) {
818                 l2->ch.ctrl(&l2->ch, CLOSE_CHANNEL, NULL);
819                 printk(KERN_WARNING "%s:no free id\n", __func__);
820                 return NULL;
821         } else {
822                 l2->ch.nr = id;
823                 __add_layer2(&l2->ch, mgr->ch.st);
824                 l2->ch.recv = mgr->ch.recv;
825                 l2->ch.peer = mgr->ch.peer;
826                 l2->ch.ctrl(&l2->ch, OPEN_CHANNEL, NULL);
827         }
828         return l2;
829 }
830
831 static void
832 new_tei_req(struct manager *mgr, u_char *dp)
833 {
834         int             tei, ri;
835         struct layer2   *l2;
836
837         ri = dp[0] << 8;
838         ri += dp[1];
839         if (!mgr->up)
840                 goto denied;
841         if (!(dp[3] & 1)) /* Extension bit != 1 */
842                 goto denied;
843         if (dp[3] != 0xff)
844                 tei = dp[3] >> 1; /* 3GPP TS 08.56 6.1.11.2 */
845         else
846                 tei = get_free_tei(mgr);
847         if (tei < 0) {
848                 printk(KERN_WARNING "%s:No free tei\n", __func__);
849                 goto denied;
850         }
851         l2 = create_new_tei(mgr, tei, CTRL_SAPI);
852         if (!l2)
853                 goto denied;
854         else
855                 mISDN_FsmEvent(&l2->tm->tei_m, EV_ASSIGN_REQ, dp);
856         return;
857 denied:
858         put_tei_msg(mgr, ID_DENIED, ri, GROUP_TEI);
859 }
860
861 static int
862 ph_data_ind(struct manager *mgr, struct sk_buff *skb)
863 {
864         int             ret = -EINVAL;
865         struct layer2   *l2, *nl2;
866         u_char          mt;
867
868         if (skb->len < 8) {
869                 if (*debug  & DEBUG_L2_TEI)
870                         printk(KERN_DEBUG "%s: short mgr frame %d/8\n",
871                             __func__, skb->len);
872                 goto done;
873         }
874
875         if ((skb->data[0] >> 2) != TEI_SAPI) /* not for us */
876                 goto done;
877         if (skb->data[0] & 1) /* EA0 formal error */
878                 goto done;
879         if (!(skb->data[1] & 1)) /* EA1 formal error */
880                 goto done;
881         if ((skb->data[1] >> 1) != GROUP_TEI) /* not for us */
882                 goto done;
883         if ((skb->data[2] & 0xef) != UI) /* not UI */
884                 goto done;
885         if (skb->data[3] != TEI_ENTITY_ID) /* not tei entity */
886                 goto done;
887         mt = skb->data[6];
888         switch (mt) {
889         case ID_REQUEST:
890         case ID_CHK_RES:
891         case ID_VERIFY:
892                 if (!test_bit(MGR_OPT_NETWORK, &mgr->options))
893                         goto done;
894                 break;
895         case ID_ASSIGNED:
896         case ID_DENIED:
897         case ID_CHK_REQ:
898         case ID_REMOVE:
899                 if (test_bit(MGR_OPT_NETWORK, &mgr->options))
900                         goto done;
901                 break;
902         default:
903                 goto done;
904         }
905         ret = 0;
906         if (mt == ID_REQUEST) {
907                 new_tei_req(mgr, &skb->data[4]);
908                 goto done;
909         }
910         list_for_each_entry_safe(l2, nl2, &mgr->layer2, list) {
911                 tei_ph_data_ind(l2->tm, mt, &skb->data[4], skb->len - 4);
912         }
913 done:
914         return ret;
915 }
916
917 int
918 l2_tei(struct layer2 *l2, u_int cmd, u_long arg)
919 {
920         struct teimgr   *tm = l2->tm;
921
922         if (test_bit(FLG_FIXED_TEI, &l2->flag))
923                 return 0;
924         if (*debug & DEBUG_L2_TEI)
925                 printk(KERN_DEBUG "%s: cmd(%x)\n", __func__, cmd);
926         switch (cmd) {
927         case MDL_ASSIGN_IND:
928                 mISDN_FsmEvent(&tm->tei_m, EV_IDREQ, NULL);
929                 break;
930         case MDL_ERROR_IND:
931                 if (test_bit(MGR_OPT_NETWORK, &tm->mgr->options))
932                         mISDN_FsmEvent(&tm->tei_m, EV_CHKREQ, &l2->tei);
933                 if (test_bit(MGR_OPT_USER, &tm->mgr->options))
934                         mISDN_FsmEvent(&tm->tei_m, EV_VERIFY, NULL);
935                 break;
936         case MDL_STATUS_UP_IND:
937                 if (test_bit(MGR_OPT_NETWORK, &tm->mgr->options))
938                         mISDN_FsmEvent(&tm->mgr->deact, EV_ACTIVATE, NULL);
939                 break;
940         case MDL_STATUS_DOWN_IND:
941                 if (test_bit(MGR_OPT_NETWORK, &tm->mgr->options))
942                         mISDN_FsmEvent(&tm->mgr->deact, EV_DEACTIVATE, NULL);
943                 break;
944         case MDL_STATUS_UI_IND:
945                 if (test_bit(MGR_OPT_NETWORK, &tm->mgr->options))
946                         mISDN_FsmEvent(&tm->mgr->deact, EV_UI, NULL);
947                 break;
948         }
949         return 0;
950 }
951
952 void
953 TEIrelease(struct layer2 *l2)
954 {
955         struct teimgr   *tm = l2->tm;
956         u_long          flags;
957
958         mISDN_FsmDelTimer(&tm->timer, 1);
959         write_lock_irqsave(&tm->mgr->lock, flags);
960         list_del(&l2->list);
961         write_unlock_irqrestore(&tm->mgr->lock, flags);
962         l2->tm = NULL;
963         kfree(tm);
964 }
965
966 static int
967 create_teimgr(struct manager *mgr, struct channel_req *crq)
968 {
969         struct layer2   *l2;
970         u_long          opt = 0;
971         u_long          flags;
972         int             id;
973
974         if (*debug & DEBUG_L2_TEI)
975                 printk(KERN_DEBUG "%s: %s proto(%x) adr(%d %d %d %d)\n",
976                         __func__, dev_name(&mgr->ch.st->dev->dev),
977                         crq->protocol, crq->adr.dev, crq->adr.channel,
978                         crq->adr.sapi, crq->adr.tei);
979         if (crq->adr.tei > GROUP_TEI)
980                 return -EINVAL;
981         if (crq->adr.tei < 64)
982                 test_and_set_bit(OPTION_L2_FIXEDTEI, &opt);
983         if (crq->adr.tei == 0)
984                 test_and_set_bit(OPTION_L2_PTP, &opt);
985         if (test_bit(MGR_OPT_NETWORK, &mgr->options)) {
986                 if (crq->protocol == ISDN_P_LAPD_TE)
987                         return -EPROTONOSUPPORT;
988                 if ((crq->adr.tei != 0) && (crq->adr.tei != 127))
989                         return -EINVAL;
990                 if (mgr->up) {
991                         printk(KERN_WARNING
992                             "%s: only one network manager is allowed\n",
993                             __func__);
994                         return -EBUSY;
995                 }
996         } else if (test_bit(MGR_OPT_USER, &mgr->options)) {
997                 if (crq->protocol == ISDN_P_LAPD_NT)
998                         return -EPROTONOSUPPORT;
999                 if ((crq->adr.tei >= 64) && (crq->adr.tei < GROUP_TEI))
1000                         return -EINVAL; /* dyn tei */
1001         } else {
1002                 if (crq->protocol == ISDN_P_LAPD_NT)
1003                         test_and_set_bit(MGR_OPT_NETWORK, &mgr->options);
1004                 if (crq->protocol == ISDN_P_LAPD_TE)
1005                         test_and_set_bit(MGR_OPT_USER, &mgr->options);
1006         }
1007         if (mgr->ch.st->dev->Dprotocols
1008           & ((1 << ISDN_P_TE_E1) | (1 << ISDN_P_NT_E1)))
1009                 test_and_set_bit(OPTION_L2_PMX, &opt);
1010         if ((crq->protocol == ISDN_P_LAPD_NT) && (crq->adr.tei == 127)) {
1011                 mgr->up = crq->ch;
1012                 id = DL_INFO_L2_CONNECT;
1013                 teiup_create(mgr, DL_INFORMATION_IND, sizeof(id), &id);
1014                 crq->ch = NULL;
1015                 if (!list_empty(&mgr->layer2)) {
1016                         read_lock_irqsave(&mgr->lock, flags);
1017                         list_for_each_entry(l2, &mgr->layer2, list) {
1018                                 l2->up = mgr->up;
1019                                 l2->ch.ctrl(&l2->ch, OPEN_CHANNEL, NULL);
1020                         }
1021                         read_unlock_irqrestore(&mgr->lock, flags);
1022                 }
1023                 return 0;
1024         }
1025         l2 = create_l2(crq->ch, crq->protocol, opt,
1026                 crq->adr.tei, crq->adr.sapi);
1027         if (!l2)
1028                 return -ENOMEM;
1029         l2->tm = kzalloc(sizeof(struct teimgr), GFP_KERNEL);
1030         if (!l2->tm) {
1031                 kfree(l2);
1032                 printk(KERN_ERR "kmalloc teimgr failed\n");
1033                 return -ENOMEM;
1034         }
1035         l2->tm->mgr = mgr;
1036         l2->tm->l2 = l2;
1037         l2->tm->tei_m.debug = *debug & DEBUG_L2_TEIFSM;
1038         l2->tm->tei_m.userdata = l2->tm;
1039         l2->tm->tei_m.printdebug = tei_debug;
1040         if (crq->protocol == ISDN_P_LAPD_TE) {
1041                 l2->tm->tei_m.fsm = &teifsmu;
1042                 l2->tm->tei_m.state = ST_TEI_NOP;
1043                 l2->tm->tval = 1000; /* T201  1 sec */
1044         } else {
1045                 l2->tm->tei_m.fsm = &teifsmn;
1046                 l2->tm->tei_m.state = ST_TEI_NOP;
1047                 l2->tm->tval = 2000; /* T202  2 sec */
1048         }
1049         mISDN_FsmInitTimer(&l2->tm->tei_m, &l2->tm->timer);
1050         write_lock_irqsave(&mgr->lock, flags);
1051         id = get_free_id(mgr);
1052         list_add_tail(&l2->list, &mgr->layer2);
1053         write_unlock_irqrestore(&mgr->lock, flags);
1054         if (id < 0) {
1055                 l2->ch.ctrl(&l2->ch, CLOSE_CHANNEL, NULL);
1056         } else {
1057                 l2->ch.nr = id;
1058                 l2->up->nr = id;
1059                 crq->ch = &l2->ch;
1060                 id = 0;
1061         }
1062         return id;
1063 }
1064
1065 static int
1066 mgr_send(struct mISDNchannel *ch, struct sk_buff *skb)
1067 {
1068         struct manager  *mgr;
1069         struct mISDNhead        *hh =  mISDN_HEAD_P(skb);
1070         int                     ret = -EINVAL;
1071
1072         mgr = container_of(ch, struct manager, ch);
1073         if (*debug & DEBUG_L2_RECV)
1074                 printk(KERN_DEBUG "%s: prim(%x) id(%x)\n",
1075                     __func__, hh->prim, hh->id);
1076         switch (hh->prim) {
1077         case PH_DATA_IND:
1078                 mISDN_FsmEvent(&mgr->deact, EV_UI, NULL);
1079                 ret = ph_data_ind(mgr, skb);
1080                 break;
1081         case PH_DATA_CNF:
1082                 do_ack(mgr, hh->id);
1083                 ret = 0;
1084                 break;
1085         case PH_ACTIVATE_IND:
1086                 test_and_set_bit(MGR_PH_ACTIVE, &mgr->options);
1087                 mISDN_FsmEvent(&mgr->deact, EV_ACTIVATE_IND, NULL);
1088                 do_send(mgr);
1089                 ret = 0;
1090                 break;
1091         case PH_DEACTIVATE_IND:
1092                 test_and_clear_bit(MGR_PH_ACTIVE, &mgr->options);
1093                 mISDN_FsmEvent(&mgr->deact, EV_DEACTIVATE_IND, NULL);
1094                 ret = 0;
1095                 break;
1096         case DL_UNITDATA_REQ:
1097                 return dl_unit_data(mgr, skb);
1098         }
1099         if (!ret)
1100                 dev_kfree_skb(skb);
1101         return ret;
1102 }
1103
1104 static int
1105 free_teimanager(struct manager *mgr)
1106 {
1107         struct layer2   *l2, *nl2;
1108
1109         test_and_clear_bit(OPTION_L1_HOLD, &mgr->options);
1110         if (test_bit(MGR_OPT_NETWORK, &mgr->options)) {
1111                 /* not locked lock is taken in release tei */
1112                 mgr->up = NULL;
1113                 if (test_bit(OPTION_L2_CLEANUP, &mgr->options)) {
1114                         list_for_each_entry_safe(l2, nl2, &mgr->layer2, list) {
1115                                 put_tei_msg(mgr, ID_REMOVE, 0, l2->tei);
1116                                 mutex_lock(&mgr->ch.st->lmutex);
1117                                 list_del(&l2->ch.list);
1118                                 mutex_unlock(&mgr->ch.st->lmutex);
1119                                 l2->ch.ctrl(&l2->ch, CLOSE_CHANNEL, NULL);
1120                         }
1121                         test_and_clear_bit(MGR_OPT_NETWORK, &mgr->options);
1122                 } else {
1123                         list_for_each_entry_safe(l2, nl2, &mgr->layer2, list) {
1124                                 l2->up = NULL;
1125                         }
1126                 }
1127         }
1128         if (test_bit(MGR_OPT_USER, &mgr->options)) {
1129                 if (list_empty(&mgr->layer2))
1130                         test_and_clear_bit(MGR_OPT_USER, &mgr->options);
1131         }
1132         mgr->ch.st->dev->D.ctrl(&mgr->ch.st->dev->D, CLOSE_CHANNEL, NULL);
1133         return 0;
1134 }
1135
1136 static int
1137 ctrl_teimanager(struct manager *mgr, void *arg)
1138 {
1139         /* currently we only have one option */
1140         int     *val = (int *)arg;
1141         int     ret = 0;
1142
1143         switch (val[0]) {
1144         case IMCLEAR_L2:
1145                 if (val[1])
1146                         test_and_set_bit(OPTION_L2_CLEANUP, &mgr->options);
1147                 else
1148                         test_and_clear_bit(OPTION_L2_CLEANUP, &mgr->options);
1149                 break;
1150         case IMHOLD_L1:
1151                 if (val[1])
1152                         test_and_set_bit(OPTION_L1_HOLD, &mgr->options);
1153                 else
1154                         test_and_clear_bit(OPTION_L1_HOLD, &mgr->options);
1155                 break;
1156         default:
1157                 ret = -EINVAL;
1158         }
1159         return ret;
1160 }
1161
1162 /* This function does create a L2 for fixed TEI in NT Mode */
1163 static int
1164 check_data(struct manager *mgr, struct sk_buff *skb)
1165 {
1166         struct mISDNhead        *hh =  mISDN_HEAD_P(skb);
1167         int                     ret, tei, sapi;
1168         struct layer2           *l2;
1169
1170         if (*debug & DEBUG_L2_CTRL)
1171                 printk(KERN_DEBUG "%s: prim(%x) id(%x)\n",
1172                     __func__, hh->prim, hh->id);
1173         if (test_bit(MGR_OPT_USER, &mgr->options))
1174                 return -ENOTCONN;
1175         if (hh->prim != PH_DATA_IND)
1176                 return -ENOTCONN;
1177         if (skb->len != 3)
1178                 return -ENOTCONN;
1179         if (skb->data[0] & 3) /* EA0 and CR must be  0 */
1180                 return -EINVAL;
1181         sapi = skb->data[0] >> 2;
1182         if (!(skb->data[1] & 1)) /* invalid EA1 */
1183                 return -EINVAL;
1184         tei = skb->data[1] >> 1;
1185         if (tei > 63) /* not a fixed tei */
1186                 return -ENOTCONN;
1187         if ((skb->data[2] & ~0x10) != SABME)
1188                 return -ENOTCONN;
1189         /* We got a SABME for a fixed TEI */
1190         if (*debug & DEBUG_L2_CTRL)
1191                 printk(KERN_DEBUG "%s: SABME sapi(%d) tei(%d)\n",
1192                     __func__, sapi, tei);
1193         l2 = create_new_tei(mgr, tei, sapi);
1194         if (!l2) {
1195                 if (*debug & DEBUG_L2_CTRL)
1196                         printk(KERN_DEBUG "%s: failed to create new tei\n",
1197                             __func__);
1198                 return -ENOMEM;
1199         }
1200         ret = l2->ch.send(&l2->ch, skb);
1201         return ret;
1202 }
1203
1204 void
1205 delete_teimanager(struct mISDNchannel *ch)
1206 {
1207         struct manager  *mgr;
1208         struct layer2   *l2, *nl2;
1209
1210         mgr = container_of(ch, struct manager, ch);
1211         /* not locked lock is taken in release tei */
1212         list_for_each_entry_safe(l2, nl2, &mgr->layer2, list) {
1213                 mutex_lock(&mgr->ch.st->lmutex);
1214                 list_del(&l2->ch.list);
1215                 mutex_unlock(&mgr->ch.st->lmutex);
1216                 l2->ch.ctrl(&l2->ch, CLOSE_CHANNEL, NULL);
1217         }
1218         list_del(&mgr->ch.list);
1219         list_del(&mgr->bcast.list);
1220         skb_queue_purge(&mgr->sendq);
1221         kfree(mgr);
1222 }
1223
1224 static int
1225 mgr_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1226 {
1227         struct manager  *mgr;
1228         int             ret = -EINVAL;
1229
1230         mgr = container_of(ch, struct manager, ch);
1231         if (*debug & DEBUG_L2_CTRL)
1232                 printk(KERN_DEBUG "%s(%x, %p)\n", __func__, cmd, arg);
1233         switch (cmd) {
1234         case OPEN_CHANNEL:
1235                 ret = create_teimgr(mgr, arg);
1236                 break;
1237         case CLOSE_CHANNEL:
1238                 ret = free_teimanager(mgr);
1239                 break;
1240         case CONTROL_CHANNEL:
1241                 ret = ctrl_teimanager(mgr, arg);
1242                 break;
1243         case CHECK_DATA:
1244                 ret = check_data(mgr, arg);
1245                 break;
1246         }
1247         return ret;
1248 }
1249
1250 static int
1251 mgr_bcast(struct mISDNchannel *ch, struct sk_buff *skb)
1252 {
1253         struct manager          *mgr = container_of(ch, struct manager, bcast);
1254         struct mISDNhead        *hh = mISDN_HEAD_P(skb);
1255         struct sk_buff          *cskb = NULL;
1256         struct layer2           *l2;
1257         u_long                  flags;
1258         int                     ret;
1259
1260         read_lock_irqsave(&mgr->lock, flags);
1261         list_for_each_entry(l2, &mgr->layer2, list) {
1262                 if ((hh->id & MISDN_ID_SAPI_MASK) ==
1263                     (l2->ch.addr & MISDN_ID_SAPI_MASK)) {
1264                         if (list_is_last(&l2->list, &mgr->layer2)) {
1265                                 cskb = skb;
1266                                 skb = NULL;
1267                         } else {
1268                                 if (!cskb)
1269                                         cskb = skb_copy(skb, GFP_KERNEL);
1270                         }
1271                         if (cskb) {
1272                                 ret = l2->ch.send(&l2->ch, cskb);
1273                                 if (ret) {
1274                                         if (*debug & DEBUG_SEND_ERR)
1275                                                 printk(KERN_DEBUG
1276                                                     "%s ch%d prim(%x) addr(%x)"
1277                                                     " err %d\n",
1278                                                     __func__, l2->ch.nr,
1279                                                     hh->prim, l2->ch.addr, ret);
1280                                 } else
1281                                         cskb = NULL;
1282                         } else {
1283                                 printk(KERN_WARNING "%s ch%d addr %x no mem\n",
1284                                     __func__, ch->nr, ch->addr);
1285                                 goto out;
1286                         }
1287                 }
1288         }
1289 out:
1290         read_unlock_irqrestore(&mgr->lock, flags);
1291         if (cskb)
1292                 dev_kfree_skb(cskb);
1293         if (skb)
1294                 dev_kfree_skb(skb);
1295         return 0;
1296 }
1297
1298 static int
1299 mgr_bcast_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
1300 {
1301
1302         return -EINVAL;
1303 }
1304
1305 int
1306 create_teimanager(struct mISDNdevice *dev)
1307 {
1308         struct manager *mgr;
1309
1310         mgr = kzalloc(sizeof(struct manager), GFP_KERNEL);
1311         if (!mgr)
1312                 return -ENOMEM;
1313         INIT_LIST_HEAD(&mgr->layer2);
1314         rwlock_init(&mgr->lock);
1315         skb_queue_head_init(&mgr->sendq);
1316         mgr->nextid = 1;
1317         mgr->lastid = MISDN_ID_NONE;
1318         mgr->ch.send = mgr_send;
1319         mgr->ch.ctrl = mgr_ctrl;
1320         mgr->ch.st = dev->D.st;
1321         set_channel_address(&mgr->ch, TEI_SAPI, GROUP_TEI);
1322         add_layer2(&mgr->ch, dev->D.st);
1323         mgr->bcast.send = mgr_bcast;
1324         mgr->bcast.ctrl = mgr_bcast_ctrl;
1325         mgr->bcast.st = dev->D.st;
1326         set_channel_address(&mgr->bcast, 0, GROUP_TEI);
1327         add_layer2(&mgr->bcast, dev->D.st);
1328         mgr->deact.debug = *debug & DEBUG_MANAGER;
1329         mgr->deact.userdata = mgr;
1330         mgr->deact.printdebug = da_debug;
1331         mgr->deact.fsm = &deactfsm;
1332         mgr->deact.state = ST_L1_DEACT;
1333         mISDN_FsmInitTimer(&mgr->deact, &mgr->datimer);
1334         dev->teimgr = &mgr->ch;
1335         return 0;
1336 }
1337
1338 int TEIInit(u_int *deb)
1339 {
1340         debug = deb;
1341         teifsmu.state_count = TEI_STATE_COUNT;
1342         teifsmu.event_count = TEI_EVENT_COUNT;
1343         teifsmu.strEvent = strTeiEvent;
1344         teifsmu.strState = strTeiState;
1345         mISDN_FsmNew(&teifsmu, TeiFnListUser, ARRAY_SIZE(TeiFnListUser));
1346         teifsmn.state_count = TEI_STATE_COUNT;
1347         teifsmn.event_count = TEI_EVENT_COUNT;
1348         teifsmn.strEvent = strTeiEvent;
1349         teifsmn.strState = strTeiState;
1350         mISDN_FsmNew(&teifsmn, TeiFnListNet, ARRAY_SIZE(TeiFnListNet));
1351         deactfsm.state_count =  DEACT_STATE_COUNT;
1352         deactfsm.event_count = DEACT_EVENT_COUNT;
1353         deactfsm.strEvent = strDeactEvent;
1354         deactfsm.strState = strDeactState;
1355         mISDN_FsmNew(&deactfsm, DeactFnList, ARRAY_SIZE(DeactFnList));
1356         return 0;
1357 }
1358
1359 void TEIFree(void)
1360 {
1361         mISDN_FsmFree(&teifsmu);
1362         mISDN_FsmFree(&teifsmn);
1363         mISDN_FsmFree(&deactfsm);
1364 }