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