xref: /openbmc/linux/drivers/isdn/mISDN/tei.c (revision ecd25094)
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 }
1417