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
9	#include <linux/mISDNif.h>
10	#include <linux/slab.h>
11	#include "core.h"
12	#include "fsm.h"
13	#include "layer2.h"
14
15	static u_int *debug;
16
17	static
18	struct Fsm l2fsm = {NULL, 0, 0, NULL, NULL};
19
20	static char *strL2State[] =
21	{
22	"ST_L2_1",
23	"ST_L2_2",
24	"ST_L2_3",
25	"ST_L2_4",
26	"ST_L2_5",
27	"ST_L2_6",
28	"ST_L2_7",
29	"ST_L2_8",
30	};
31
32	enum {
33	EV_L2_UI,
34	EV_L2_SABME,
35	EV_L2_DISC,
36	EV_L2_DM,
37	EV_L2_UA,
38	EV_L2_FRMR,
39	EV_L2_SUPER,
40	EV_L2_I,
41	EV_L2_DL_DATA,
42	EV_L2_ACK_PULL,
43	EV_L2_DL_UNITDATA,
44	EV_L2_DL_ESTABLISH_REQ,
45	EV_L2_DL_RELEASE_REQ,
46	EV_L2_MDL_ASSIGN,
47	EV_L2_MDL_REMOVE,
48	EV_L2_MDL_ERROR,
49	EV_L1_DEACTIVATE,
50	EV_L2_T200,
51	EV_L2_T203,
52	EV_L2_T200I,
53	EV_L2_T203I,
54	EV_L2_SET_OWN_BUSY,
55	EV_L2_CLEAR_OWN_BUSY,
56	EV_L2_FRAME_ERROR,
57	};
58
59	#define L2_EVENT_COUNT (EV_L2_FRAME_ERROR + 1)
60
61	static char *strL2Event[] =
62	{
63	"EV_L2_UI",
64	"EV_L2_SABME",
65	"EV_L2_DISC",
66	"EV_L2_DM",
67	"EV_L2_UA",
68	"EV_L2_FRMR",
69	"EV_L2_SUPER",
70	"EV_L2_I",
71	"EV_L2_DL_DATA",
72	"EV_L2_ACK_PULL",
73	"EV_L2_DL_UNITDATA",
74	"EV_L2_DL_ESTABLISH_REQ",
75	"EV_L2_DL_RELEASE_REQ",
76	"EV_L2_MDL_ASSIGN",
77	"EV_L2_MDL_REMOVE",
78	"EV_L2_MDL_ERROR",
79	"EV_L1_DEACTIVATE",
80	"EV_L2_T200",
81	"EV_L2_T203",
82	"EV_L2_T200I",
83	"EV_L2_T203I",
84	"EV_L2_SET_OWN_BUSY",
85	"EV_L2_CLEAR_OWN_BUSY",
86	"EV_L2_FRAME_ERROR",
87	};
88
89	static void
90	l2m_debug(struct FsmInst *fi, char *fmt, ...)
91	{
92	struct layer2 *l2 = fi->userdata;
93	struct va_format vaf;
94	va_list va;
95
96	if (!(*debug & DEBUG_L2_FSM))
97	return;
98
99	va_start(va, fmt);
100
101	vaf.fmt = fmt;
102	vaf.va = &va;
103
104	printk(KERN_DEBUG "%s l2 (sapi %d tei %d): %pV\n",
105	mISDNDevName4ch(&l2->ch), l2->sapi, l2->tei, &vaf);
106
107	va_end(va);
108	}
109
110	inline u_int
111	l2headersize(struct layer2 *l2, int ui)
112	{
113	return ((test_bit(FLG_MOD128, &l2->flag) && (!ui)) ? 2 : 1) +
114	(test_bit(FLG_LAPD, &l2->flag) ? 2 : 1);
115	}
116
117	inline u_int
118	l2addrsize(struct layer2 *l2)
119	{
120	return test_bit(FLG_LAPD, &l2->flag) ? 2 : 1;
121	}
122
123	static u_int
124	l2_newid(struct layer2 *l2)
125	{
126	u_int id;
127
128	id = l2->next_id++;
129	if (id == 0x7fff)
130	l2->next_id = 1;
131	id <<= 16;
132	id |= l2->tei << 8;
133	id |= l2->sapi;
134	return id;
135	}
136
137	static void
138	l2up(struct layer2 *l2, u_int prim, struct sk_buff *skb)
139	{
140	int err;
141
142	if (!l2->up)
143	return;
144	mISDN_HEAD_PRIM(skb) = prim;
145	mISDN_HEAD_ID(skb) = (l2->ch.nr << 16) | l2->ch.addr;
146	err = l2->up->send(l2->up, skb);
147	if (err) {
148	printk(KERN_WARNING "%s: dev %s err=%d\n", __func__,
149	mISDNDevName4ch(&l2->ch), err);
150	dev_kfree_skb(skb);
151	}
152	}
153
154	static void
155	l2up_create(struct layer2 *l2, u_int prim, int len, void *arg)
156	{
157	struct sk_buff *skb;
158	struct mISDNhead *hh;
159	int err;
160
161	if (!l2->up)
162	return;
163	skb = mI_alloc_skb(len, GFP_ATOMIC);
164	if (!skb)
165	return;
166	hh = mISDN_HEAD_P(skb);
167	hh->prim = prim;
168	hh->id = (l2->ch.nr << 16) | l2->ch.addr;
169	if (len)
170	skb_put_data(skb, data: arg, len);
171	err = l2->up->send(l2->up, skb);
172	if (err) {
173	printk(KERN_WARNING "%s: dev %s err=%d\n", __func__,
174	mISDNDevName4ch(&l2->ch), err);
175	dev_kfree_skb(skb);
176	}
177	}
178
179	static int
180	l2down_skb(struct layer2 *l2, struct sk_buff *skb) {
181	int ret;
182
183	ret = l2->ch.recv(l2->ch.peer, skb);
184	if (ret && (*debug & DEBUG_L2_RECV))
185	printk(KERN_DEBUG "l2down_skb: dev %s ret(%d)\n",
186	mISDNDevName4ch(&l2->ch), ret);
187	return ret;
188	}
189
190	static int
191	l2down_raw(struct layer2 *l2, struct sk_buff *skb)
192	{
193	struct mISDNhead *hh = mISDN_HEAD_P(skb);
194
195	if (hh->prim == PH_DATA_REQ) {
196	if (test_and_set_bit(FLG_L1_NOTREADY, addr: &l2->flag)) {
197	skb_queue_tail(list: &l2->down_queue, newsk: skb);
198	return 0;
199	}
200	l2->down_id = mISDN_HEAD_ID(skb);
201	}
202	return l2down_skb(l2, skb);
203	}
204
205	static int
206	l2down(struct layer2 *l2, u_int prim, u_int id, struct sk_buff *skb)
207	{
208	struct mISDNhead *hh = mISDN_HEAD_P(skb);
209
210	hh->prim = prim;
211	hh->id = id;
212	return l2down_raw(l2, skb);
213	}
214
215	static int
216	l2down_create(struct layer2 *l2, u_int prim, u_int id, int len, void *arg)
217	{
218	struct sk_buff *skb;
219	int err;
220	struct mISDNhead *hh;
221
222	skb = mI_alloc_skb(len, GFP_ATOMIC);
223	if (!skb)
224	return -ENOMEM;
225	hh = mISDN_HEAD_P(skb);
226	hh->prim = prim;
227	hh->id = id;
228	if (len)
229	skb_put_data(skb, data: arg, len);
230	err = l2down_raw(l2, skb);
231	if (err)
232	dev_kfree_skb(skb);
233	return err;
234	}
235
236	static int
237	ph_data_confirm(struct layer2 *l2, struct mISDNhead *hh, struct sk_buff *skb) {
238	struct sk_buff *nskb = skb;
239	int ret = -EAGAIN;
240
241	if (test_bit(FLG_L1_NOTREADY, &l2->flag)) {
242	if (hh->id == l2->down_id) {
243	nskb = skb_dequeue(list: &l2->down_queue);
244	if (nskb) {
245	l2->down_id = mISDN_HEAD_ID(nskb);
246	if (l2down_skb(l2, skb: nskb)) {
247	dev_kfree_skb(nskb);
248	l2->down_id = MISDN_ID_NONE;
249	}
250	} else
251	l2->down_id = MISDN_ID_NONE;
252	if (ret) {
253	dev_kfree_skb(skb);
254	ret = 0;
255	}
256	if (l2->down_id == MISDN_ID_NONE) {
257	test_and_clear_bit(FLG_L1_NOTREADY, addr: &l2->flag);
258	mISDN_FsmEvent(&l2->l2m, EV_L2_ACK_PULL, NULL);
259	}
260	}
261	}
262	if (!test_and_set_bit(FLG_L1_NOTREADY, addr: &l2->flag)) {
263	nskb = skb_dequeue(list: &l2->down_queue);
264	if (nskb) {
265	l2->down_id = mISDN_HEAD_ID(nskb);
266	if (l2down_skb(l2, skb: nskb)) {
267	dev_kfree_skb(nskb);
268	l2->down_id = MISDN_ID_NONE;
269	test_and_clear_bit(FLG_L1_NOTREADY, addr: &l2->flag);
270	}
271	} else
272	test_and_clear_bit(FLG_L1_NOTREADY, addr: &l2->flag);
273	}
274	return ret;
275	}
276
277	static void
278	l2_timeout(struct FsmInst *fi, int event, void *arg)
279	{
280	struct layer2 *l2 = fi->userdata;
281	struct sk_buff *skb;
282	struct mISDNhead *hh;
283
284	skb = mI_alloc_skb(len: 0, GFP_ATOMIC);
285	if (!skb) {
286	printk(KERN_WARNING "%s: L2(%d,%d) nr:%x timer %s no skb\n",
287	mISDNDevName4ch(&l2->ch), l2->sapi, l2->tei,
288	l2->ch.nr, event == EV_L2_T200 ? "T200" : "T203");
289	return;
290	}
291	hh = mISDN_HEAD_P(skb);
292	hh->prim = event == EV_L2_T200 ? DL_TIMER200_IND : DL_TIMER203_IND;
293	hh->id = l2->ch.nr;
294	if (*debug & DEBUG_TIMER)
295	printk(KERN_DEBUG "%s: L2(%d,%d) nr:%x timer %s expired\n",
296	mISDNDevName4ch(&l2->ch), l2->sapi, l2->tei,
297	l2->ch.nr, event == EV_L2_T200 ? "T200" : "T203");
298	if (l2->ch.st)
299	l2->ch.st->own.recv(&l2->ch.st->own, skb);
300	}
301
302	static int
303	l2mgr(struct layer2 *l2, u_int prim, void *arg) {
304	long c = (long)arg;
305
306	printk(KERN_WARNING "l2mgr: dev %s addr:%x prim %x %c\n",
307	mISDNDevName4ch(&l2->ch), l2->id, prim, (char)c);
308	if (test_bit(FLG_LAPD, &l2->flag) &&
309	!test_bit(FLG_FIXED_TEI, &l2->flag)) {
310	switch (c) {
311	case 'C':
312	case 'D':
313	case 'G':
314	case 'H':
315	l2_tei(l2, prim, arg: (u_long)arg);
316	break;
317	}
318	}
319	return 0;
320	}
321
322	static void
323	set_peer_busy(struct layer2 *l2) {
324	test_and_set_bit(FLG_PEER_BUSY, addr: &l2->flag);
325	if (skb_queue_len(list_: &l2->i_queue) || skb_queue_len(list_: &l2->ui_queue))
326	test_and_set_bit(FLG_L2BLOCK, addr: &l2->flag);
327	}
328
329	static void
330	clear_peer_busy(struct layer2 *l2) {
331	if (test_and_clear_bit(FLG_PEER_BUSY, addr: &l2->flag))
332	test_and_clear_bit(FLG_L2BLOCK, addr: &l2->flag);
333	}
334
335	static void
336	InitWin(struct layer2 *l2)
337	{
338	int i;
339
340	for (i = 0; i < MAX_WINDOW; i++)
341	l2->windowar[i] = NULL;
342	}
343
344	static int
345	freewin(struct layer2 *l2)
346	{
347	int i, cnt = 0;
348
349	for (i = 0; i < MAX_WINDOW; i++) {
350	if (l2->windowar[i]) {
351	cnt++;
352	dev_kfree_skb(l2->windowar[i]);
353	l2->windowar[i] = NULL;
354	}
355	}
356	return cnt;
357	}
358
359	static void
360	ReleaseWin(struct layer2 *l2)
361	{
362	int cnt = freewin(l2);
363
364	if (cnt)
365	printk(KERN_WARNING
366	"isdnl2 freed %d skbuffs in release\n", cnt);
367	}
368
369	inline unsigned int
370	cansend(struct layer2 *l2)
371	{
372	unsigned int p1;
373
374	if (test_bit(FLG_MOD128, &l2->flag))
375	p1 = (l2->vs - l2->va) % 128;
376	else
377	p1 = (l2->vs - l2->va) % 8;
378	return (p1 < l2->window) && !test_bit(FLG_PEER_BUSY, &l2->flag);
379	}
380
381	inline void
382	clear_exception(struct layer2 *l2)
383	{
384	test_and_clear_bit(FLG_ACK_PEND, addr: &l2->flag);
385	test_and_clear_bit(FLG_REJEXC, addr: &l2->flag);
386	test_and_clear_bit(FLG_OWN_BUSY, addr: &l2->flag);
387	clear_peer_busy(l2);
388	}
389
390	static int
391	sethdraddr(struct layer2 *l2, u_char *header, int rsp)
392	{
393	u_char *ptr = header;
394	int crbit = rsp;
395
396	if (test_bit(FLG_LAPD, &l2->flag)) {
397	if (test_bit(FLG_LAPD_NET, &l2->flag))
398	crbit = !crbit;
399	*ptr++ = (l2->sapi << 2) | (crbit ? 2 : 0);
400	*ptr++ = (l2->tei << 1) | 1;
401	return 2;
402	} else {
403	if (test_bit(FLG_ORIG, &l2->flag))
404	crbit = !crbit;
405	if (crbit)
406	*ptr++ = l2->addr.B;
407	else
408	*ptr++ = l2->addr.A;
409	return 1;
410	}
411	}
412
413	static inline void
414	enqueue_super(struct layer2 *l2, struct sk_buff *skb)
415	{
416	if (l2down(l2, PH_DATA_REQ, id: l2_newid(l2), skb))
417	dev_kfree_skb(skb);
418	}
419
420	static inline void
421	enqueue_ui(struct layer2 *l2, struct sk_buff *skb)
422	{
423	if (l2->tm)
424	l2_tei(l2, MDL_STATUS_UI_IND, arg: 0);
425	if (l2down(l2, PH_DATA_REQ, id: l2_newid(l2), skb))
426	dev_kfree_skb(skb);
427	}
428
429	inline int
430	IsUI(u_char *data)
431	{
432	return (data[0] & 0xef) == UI;
433	}
434
435	inline int
436	IsUA(u_char *data)
437	{
438	return (data[0] & 0xef) == UA;
439	}
440
441	inline int
442	IsDM(u_char *data)
443	{
444	return (data[0] & 0xef) == DM;
445	}
446
447	inline int
448	IsDISC(u_char *data)
449	{
450	return (data[0] & 0xef) == DISC;
451	}
452
453	inline int
454	IsRR(u_char *data, struct layer2 *l2)
455	{
456	if (test_bit(FLG_MOD128, &l2->flag))
457	return data[0] == RR;
458	else
459	return (data[0] & 0xf) == 1;
460	}
461
462	inline int
463	IsSFrame(u_char *data, struct layer2 *l2)
464	{
465	register u_char d = *data;
466
467	if (!test_bit(FLG_MOD128, &l2->flag))
468	d &= 0xf;
469	return ((d & 0xf3) == 1) && ((d & 0x0c) != 0x0c);
470	}
471
472	inline int
473	IsSABME(u_char *data, struct layer2 *l2)
474	{
475	u_char d = data[0] & ~0x10;
476
477	return test_bit(FLG_MOD128, &l2->flag) ? d == SABME : d == SABM;
478	}
479
480	inline int
481	IsREJ(u_char *data, struct layer2 *l2)
482	{
483	return test_bit(FLG_MOD128, &l2->flag) ?
484	data[0] == REJ : (data[0] & 0xf) == REJ;
485	}
486
487	inline int
488	IsFRMR(u_char *data)
489	{
490	return (data[0] & 0xef) == FRMR;
491	}
492
493	inline int
494	IsRNR(u_char *data, struct layer2 *l2)
495	{
496	return test_bit(FLG_MOD128, &l2->flag) ?
497	data[0] == RNR : (data[0] & 0xf) == RNR;
498	}
499
500	static int
501	iframe_error(struct layer2 *l2, struct sk_buff *skb)
502	{
503	u_int i;
504	int rsp = *skb->data & 0x2;
505
506	i = l2addrsize(l2) + (test_bit(FLG_MOD128, &l2->flag) ? 2 : 1);
507	if (test_bit(FLG_ORIG, &l2->flag))
508	rsp = !rsp;
509	if (rsp)
510	return 'L';
511	if (skb->len < i)
512	return 'N';
513	if ((skb->len - i) > l2->maxlen)
514	return 'O';
515	return 0;
516	}
517
518	static int
519	super_error(struct layer2 *l2, struct sk_buff *skb)
520	{
521	if (skb->len != l2addrsize(l2) +
522	(test_bit(FLG_MOD128, &l2->flag) ? 2 : 1))
523	return 'N';
524	return 0;
525	}
526
527	static int
528	unnum_error(struct layer2 *l2, struct sk_buff *skb, int wantrsp)
529	{
530	int rsp = (*skb->data & 0x2) >> 1;
531	if (test_bit(FLG_ORIG, &l2->flag))
532	rsp = !rsp;
533	if (rsp != wantrsp)
534	return 'L';
535	if (skb->len != l2addrsize(l2) + 1)
536	return 'N';
537	return 0;
538	}
539
540	static int
541	UI_error(struct layer2 *l2, struct sk_buff *skb)
542	{
543	int rsp = *skb->data & 0x2;
544	if (test_bit(FLG_ORIG, &l2->flag))
545	rsp = !rsp;
546	if (rsp)
547	return 'L';
548	if (skb->len > l2->maxlen + l2addrsize(l2) + 1)
549	return 'O';
550	return 0;
551	}
552
553	static int
554	FRMR_error(struct layer2 *l2, struct sk_buff *skb)
555	{
556	u_int headers = l2addrsize(l2) + 1;
557	u_char *datap = skb->data + headers;
558	int rsp = *skb->data & 0x2;
559
560	if (test_bit(FLG_ORIG, &l2->flag))
561	rsp = !rsp;
562	if (!rsp)
563	return 'L';
564	if (test_bit(FLG_MOD128, &l2->flag)) {
565	if (skb->len < headers + 5)
566	return 'N';
567	else if (*debug & DEBUG_L2)
568	l2m_debug(fi: &l2->l2m,
569	fmt: "FRMR information %2x %2x %2x %2x %2x",
570	datap[0], datap[1], datap[2], datap[3], datap[4]);
571	} else {
572	if (skb->len < headers + 3)
573	return 'N';
574	else if (*debug & DEBUG_L2)
575	l2m_debug(fi: &l2->l2m,
576	fmt: "FRMR information %2x %2x %2x",
577	datap[0], datap[1], datap[2]);
578	}
579	return 0;
580	}
581
582	static unsigned int
583	legalnr(struct layer2 *l2, unsigned int nr)
584	{
585	if (test_bit(FLG_MOD128, &l2->flag))
586	return ((nr - l2->va) % 128) <= ((l2->vs - l2->va) % 128);
587	else
588	return ((nr - l2->va) % 8) <= ((l2->vs - l2->va) % 8);
589	}
590
591	static void
592	setva(struct layer2 *l2, unsigned int nr)
593	{
594	struct sk_buff *skb;
595
596	while (l2->va != nr) {
597	l2->va++;
598	if (test_bit(FLG_MOD128, &l2->flag))
599	l2->va %= 128;
600	else
601	l2->va %= 8;
602	if (l2->windowar[l2->sow]) {
603	skb_trim(skb: l2->windowar[l2->sow], len: 0);
604	skb_queue_tail(list: &l2->tmp_queue, newsk: l2->windowar[l2->sow]);
605	l2->windowar[l2->sow] = NULL;
606	}
607	l2->sow = (l2->sow + 1) % l2->window;
608	}
609	skb = skb_dequeue(list: &l2->tmp_queue);
610	while (skb) {
611	dev_kfree_skb(skb);
612	skb = skb_dequeue(list: &l2->tmp_queue);
613	}
614	}
615
616	static void
617	send_uframe(struct layer2 *l2, struct sk_buff *skb, u_char cmd, u_char cr)
618	{
619	u_char tmp[MAX_L2HEADER_LEN];
620	int i;
621
622	i = sethdraddr(l2, header: tmp, rsp: cr);
623	tmp[i++] = cmd;
624	if (skb)
625	skb_trim(skb, len: 0);
626	else {
627	skb = mI_alloc_skb(len: i, GFP_ATOMIC);
628	if (!skb) {
629	printk(KERN_WARNING "%s: can't alloc skbuff in %s\n",
630	mISDNDevName4ch(&l2->ch), __func__);
631	return;
632	}
633	}
634	skb_put_data(skb, data: tmp, len: i);
635	enqueue_super(l2, skb);
636	}
637
638
639	inline u_char
640	get_PollFlag(struct layer2 *l2, struct sk_buff *skb)
641	{
642	return skb->data[l2addrsize(l2)] & 0x10;
643	}
644
645	inline u_char
646	get_PollFlagFree(struct layer2 *l2, struct sk_buff *skb)
647	{
648	u_char PF;
649
650	PF = get_PollFlag(l2, skb);
651	dev_kfree_skb(skb);
652	return PF;
653	}
654
655	inline void
656	start_t200(struct layer2 *l2, int i)
657	{
658	mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, i);
659	test_and_set_bit(FLG_T200_RUN, addr: &l2->flag);
660	}
661
662	inline void
663	restart_t200(struct layer2 *l2, int i)
664	{
665	mISDN_FsmRestartTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, i);
666	test_and_set_bit(FLG_T200_RUN, addr: &l2->flag);
667	}
668
669	inline void
670	stop_t200(struct layer2 *l2, int i)
671	{
672	if (test_and_clear_bit(FLG_T200_RUN, addr: &l2->flag))
673	mISDN_FsmDelTimer(&l2->t200, i);
674	}
675
676	inline void
677	st5_dl_release_l2l3(struct layer2 *l2)
678	{
679	int pr;
680
681	if (test_and_clear_bit(FLG_PEND_REL, addr: &l2->flag))
682	pr = DL_RELEASE_CNF;
683	else
684	pr = DL_RELEASE_IND;
685	l2up_create(l2, prim: pr, len: 0, NULL);
686	}
687
688	inline void
689	lapb_dl_release_l2l3(struct layer2 *l2, int f)
690	{
691	if (test_bit(FLG_LAPB, &l2->flag))
692	l2down_create(l2, PH_DEACTIVATE_REQ, id: l2_newid(l2), len: 0, NULL);
693	l2up_create(l2, prim: f, len: 0, NULL);
694	}
695
696	static void
697	establishlink(struct FsmInst *fi)
698	{
699	struct layer2 *l2 = fi->userdata;
700	u_char cmd;
701
702	clear_exception(l2);
703	l2->rc = 0;
704	cmd = (test_bit(FLG_MOD128, &l2->flag) ? SABME : SABM) | 0x10;
705	send_uframe(l2, NULL, cmd, CMD);
706	mISDN_FsmDelTimer(&l2->t203, 1);
707	restart_t200(l2, i: 1);
708	test_and_clear_bit(FLG_PEND_REL, addr: &l2->flag);
709	freewin(l2);
710	mISDN_FsmChangeState(fi, ST_L2_5);
711	}
712
713	static void
714	l2_mdl_error_ua(struct FsmInst *fi, int event, void *arg)
715	{
716	struct sk_buff *skb = arg;
717	struct layer2 *l2 = fi->userdata;
718
719	if (get_PollFlagFree(l2, skb))
720	l2mgr(l2, MDL_ERROR_IND, arg: (void *) 'C');
721	else
722	l2mgr(l2, MDL_ERROR_IND, arg: (void *) 'D');
723
724	}
725
726	static void
727	l2_mdl_error_dm(struct FsmInst *fi, int event, void *arg)
728	{
729	struct sk_buff *skb = arg;
730	struct layer2 *l2 = fi->userdata;
731
732	if (get_PollFlagFree(l2, skb))
733	l2mgr(l2, MDL_ERROR_IND, arg: (void *) 'B');
734	else {
735	l2mgr(l2, MDL_ERROR_IND, arg: (void *) 'E');
736	establishlink(fi);
737	test_and_clear_bit(FLG_L3_INIT, addr: &l2->flag);
738	}
739	}
740
741	static void
742	l2_st8_mdl_error_dm(struct FsmInst *fi, int event, void *arg)
743	{
744	struct sk_buff *skb = arg;
745	struct layer2 *l2 = fi->userdata;
746
747	if (get_PollFlagFree(l2, skb))
748	l2mgr(l2, MDL_ERROR_IND, arg: (void *) 'B');
749	else
750	l2mgr(l2, MDL_ERROR_IND, arg: (void *) 'E');
751	establishlink(fi);
752	test_and_clear_bit(FLG_L3_INIT, addr: &l2->flag);
753	}
754
755	static void
756	l2_go_st3(struct FsmInst *fi, int event, void *arg)
757	{
758	dev_kfree_skb((struct sk_buff *)arg);
759	mISDN_FsmChangeState(fi, ST_L2_3);
760	}
761
762	static void
763	l2_mdl_assign(struct FsmInst *fi, int event, void *arg)
764	{
765	struct layer2 *l2 = fi->userdata;
766
767	mISDN_FsmChangeState(fi, ST_L2_3);
768	dev_kfree_skb((struct sk_buff *)arg);
769	l2_tei(l2, MDL_ASSIGN_IND, arg: 0);
770	}
771
772	static void
773	l2_queue_ui_assign(struct FsmInst *fi, int event, void *arg)
774	{
775	struct layer2 *l2 = fi->userdata;
776	struct sk_buff *skb = arg;
777
778	skb_queue_tail(list: &l2->ui_queue, newsk: skb);
779	mISDN_FsmChangeState(fi, ST_L2_2);
780	l2_tei(l2, MDL_ASSIGN_IND, arg: 0);
781	}
782
783	static void
784	l2_queue_ui(struct FsmInst *fi, int event, void *arg)
785	{
786	struct layer2 *l2 = fi->userdata;
787	struct sk_buff *skb = arg;
788
789	skb_queue_tail(list: &l2->ui_queue, newsk: skb);
790	}
791
792	static void
793	tx_ui(struct layer2 *l2)
794	{
795	struct sk_buff *skb;
796	u_char header[MAX_L2HEADER_LEN];
797	int i;
798
799	i = sethdraddr(l2, header, CMD);
800	if (test_bit(FLG_LAPD_NET, &l2->flag))
801	header[1] = 0xff; /* tei 127 */
802	header[i++] = UI;
803	while ((skb = skb_dequeue(list: &l2->ui_queue))) {
804	memcpy(skb_push(skb, i), header, i);
805	enqueue_ui(l2, skb);
806	}
807	}
808
809	static void
810	l2_send_ui(struct FsmInst *fi, int event, void *arg)
811	{
812	struct layer2 *l2 = fi->userdata;
813	struct sk_buff *skb = arg;
814
815	skb_queue_tail(list: &l2->ui_queue, newsk: skb);
816	tx_ui(l2);
817	}
818
819	static void
820	l2_got_ui(struct FsmInst *fi, int event, void *arg)
821	{
822	struct layer2 *l2 = fi->userdata;
823	struct sk_buff *skb = arg;
824
825	skb_pull(skb, len: l2headersize(l2, ui: 1));
826	/*
827	* in states 1-3 for broadcast
828	*/
829
830	if (l2->tm)
831	l2_tei(l2, MDL_STATUS_UI_IND, arg: 0);
832	l2up(l2, DL_UNITDATA_IND, skb);
833	}
834
835	static void
836	l2_establish(struct FsmInst *fi, int event, void *arg)
837	{
838	struct sk_buff *skb = arg;
839	struct layer2 *l2 = fi->userdata;
840
841	establishlink(fi);
842	test_and_set_bit(FLG_L3_INIT, addr: &l2->flag);
843	dev_kfree_skb(skb);
844	}
845
846	static void
847	l2_discard_i_setl3(struct FsmInst *fi, int event, void *arg)
848	{
849	struct sk_buff *skb = arg;
850	struct layer2 *l2 = fi->userdata;
851
852	skb_queue_purge(list: &l2->i_queue);
853	test_and_set_bit(FLG_L3_INIT, addr: &l2->flag);
854	test_and_clear_bit(FLG_PEND_REL, addr: &l2->flag);
855	dev_kfree_skb(skb);
856	}
857
858	static void
859	l2_l3_reestablish(struct FsmInst *fi, int event, void *arg)
860	{
861	struct sk_buff *skb = arg;
862	struct layer2 *l2 = fi->userdata;
863
864	skb_queue_purge(list: &l2->i_queue);
865	establishlink(fi);
866	test_and_set_bit(FLG_L3_INIT, addr: &l2->flag);
867	dev_kfree_skb(skb);
868	}
869
870	static void
871	l2_release(struct FsmInst *fi, int event, void *arg)
872	{
873	struct layer2 *l2 = fi->userdata;
874	struct sk_buff *skb = arg;
875
876	skb_trim(skb, len: 0);
877	l2up(l2, DL_RELEASE_CNF, skb);
878	}
879
880	static void
881	l2_pend_rel(struct FsmInst *fi, int event, void *arg)
882	{
883	struct sk_buff *skb = arg;
884	struct layer2 *l2 = fi->userdata;
885
886	test_and_set_bit(FLG_PEND_REL, addr: &l2->flag);
887	dev_kfree_skb(skb);
888	}
889
890	static void
891	l2_disconnect(struct FsmInst *fi, int event, void *arg)
892	{
893	struct layer2 *l2 = fi->userdata;
894	struct sk_buff *skb = arg;
895
896	skb_queue_purge(list: &l2->i_queue);
897	freewin(l2);
898	mISDN_FsmChangeState(fi, ST_L2_6);
899	l2->rc = 0;
900	send_uframe(l2, NULL, DISC | 0x10, CMD);
901	mISDN_FsmDelTimer(&l2->t203, 1);
902	restart_t200(l2, i: 2);
903	dev_kfree_skb(skb);
904	}
905
906	static void
907	l2_start_multi(struct FsmInst *fi, int event, void *arg)
908	{
909	struct layer2 *l2 = fi->userdata;
910	struct sk_buff *skb = arg;
911
912	l2->vs = 0;
913	l2->va = 0;
914	l2->vr = 0;
915	l2->sow = 0;
916	clear_exception(l2);
917	send_uframe(l2, NULL, UA | get_PollFlag(l2, skb), RSP);
918	mISDN_FsmChangeState(fi, ST_L2_7);
919	mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 3);
920	skb_trim(skb, len: 0);
921	l2up(l2, DL_ESTABLISH_IND, skb);
922	if (l2->tm)
923	l2_tei(l2, MDL_STATUS_UP_IND, arg: 0);
924	}
925
926	static void
927	l2_send_UA(struct FsmInst *fi, int event, void *arg)
928	{
929	struct layer2 *l2 = fi->userdata;
930	struct sk_buff *skb = arg;
931
932	send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
933	}
934
935	static void
936	l2_send_DM(struct FsmInst *fi, int event, void *arg)
937	{
938	struct layer2 *l2 = fi->userdata;
939	struct sk_buff *skb = arg;
940
941	send_uframe(l2, skb, DM | get_PollFlag(l2, skb), RSP);
942	}
943
944	static void
945	l2_restart_multi(struct FsmInst *fi, int event, void *arg)
946	{
947	struct layer2 *l2 = fi->userdata;
948	struct sk_buff *skb = arg;
949	int est = 0;
950
951	send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
952
953	l2mgr(l2, MDL_ERROR_IND, arg: (void *) 'F');
954
955	if (l2->vs != l2->va) {
956	skb_queue_purge(list: &l2->i_queue);
957	est = 1;
958	}
959
960	clear_exception(l2);
961	l2->vs = 0;
962	l2->va = 0;
963	l2->vr = 0;
964	l2->sow = 0;
965	mISDN_FsmChangeState(fi, ST_L2_7);
966	stop_t200(l2, i: 3);
967	mISDN_FsmRestartTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 3);
968
969	if (est)
970	l2up_create(l2, DL_ESTABLISH_IND, len: 0, NULL);
971	/* mISDN_queue_data(&l2->inst, l2->inst.id | MSG_BROADCAST,
972	* MGR_SHORTSTATUS | INDICATION, SSTATUS_L2_ESTABLISHED,
973	* 0, NULL, 0);
974	*/
975	if (skb_queue_len(list_: &l2->i_queue) && cansend(l2))
976	mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
977	}
978
979	static void
980	l2_stop_multi(struct FsmInst *fi, int event, void *arg)
981	{
982	struct layer2 *l2 = fi->userdata;
983	struct sk_buff *skb = arg;
984
985	mISDN_FsmChangeState(fi, ST_L2_4);
986	mISDN_FsmDelTimer(&l2->t203, 3);
987	stop_t200(l2, i: 4);
988
989	send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
990	skb_queue_purge(list: &l2->i_queue);
991	freewin(l2);
992	lapb_dl_release_l2l3(l2, DL_RELEASE_IND);
993	if (l2->tm)
994	l2_tei(l2, MDL_STATUS_DOWN_IND, arg: 0);
995	}
996
997	static void
998	l2_connected(struct FsmInst *fi, int event, void *arg)
999	{
1000	struct layer2 *l2 = fi->userdata;
1001	struct sk_buff *skb = arg;
1002	int pr = -1;
1003
1004	if (!get_PollFlag(l2, skb)) {
1005	l2_mdl_error_ua(fi, event, arg);
1006	return;
1007	}
1008	dev_kfree_skb(skb);
1009	if (test_and_clear_bit(FLG_PEND_REL, addr: &l2->flag))
1010	l2_disconnect(fi, event, NULL);
1011	if (test_and_clear_bit(FLG_L3_INIT, addr: &l2->flag)) {
1012	pr = DL_ESTABLISH_CNF;
1013	} else if (l2->vs != l2->va) {
1014	skb_queue_purge(list: &l2->i_queue);
1015	pr = DL_ESTABLISH_IND;
1016	}
1017	stop_t200(l2, i: 5);
1018	l2->vr = 0;
1019	l2->vs = 0;
1020	l2->va = 0;
1021	l2->sow = 0;
1022	mISDN_FsmChangeState(fi, ST_L2_7);
1023	mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 4);
1024	if (pr != -1)
1025	l2up_create(l2, prim: pr, len: 0, NULL);
1026
1027	if (skb_queue_len(list_: &l2->i_queue) && cansend(l2))
1028	mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1029
1030	if (l2->tm)
1031	l2_tei(l2, MDL_STATUS_UP_IND, arg: 0);
1032	}
1033
1034	static void
1035	l2_released(struct FsmInst *fi, int event, void *arg)
1036	{
1037	struct layer2 *l2 = fi->userdata;
1038	struct sk_buff *skb = arg;
1039
1040	if (!get_PollFlag(l2, skb)) {
1041	l2_mdl_error_ua(fi, event, arg);
1042	return;
1043	}
1044	dev_kfree_skb(skb);
1045	stop_t200(l2, i: 6);
1046	lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1047	mISDN_FsmChangeState(fi, ST_L2_4);
1048	if (l2->tm)
1049	l2_tei(l2, MDL_STATUS_DOWN_IND, arg: 0);
1050	}
1051
1052	static void
1053	l2_reestablish(struct FsmInst *fi, int event, void *arg)
1054	{
1055	struct layer2 *l2 = fi->userdata;
1056	struct sk_buff *skb = arg;
1057
1058	if (!get_PollFlagFree(l2, skb)) {
1059	establishlink(fi);
1060	test_and_set_bit(FLG_L3_INIT, addr: &l2->flag);
1061	}
1062	}
1063
1064	static void
1065	l2_st5_dm_release(struct FsmInst *fi, int event, void *arg)
1066	{
1067	struct layer2 *l2 = fi->userdata;
1068	struct sk_buff *skb = arg;
1069
1070	if (get_PollFlagFree(l2, skb)) {
1071	stop_t200(l2, i: 7);
1072	if (!test_bit(FLG_L3_INIT, &l2->flag))
1073	skb_queue_purge(list: &l2->i_queue);
1074	if (test_bit(FLG_LAPB, &l2->flag))
1075	l2down_create(l2, PH_DEACTIVATE_REQ,
1076	id: l2_newid(l2), len: 0, NULL);
1077	st5_dl_release_l2l3(l2);
1078	mISDN_FsmChangeState(fi, ST_L2_4);
1079	if (l2->tm)
1080	l2_tei(l2, MDL_STATUS_DOWN_IND, arg: 0);
1081	}
1082	}
1083
1084	static void
1085	l2_st6_dm_release(struct FsmInst *fi, int event, void *arg)
1086	{
1087	struct layer2 *l2 = fi->userdata;
1088	struct sk_buff *skb = arg;
1089
1090	if (get_PollFlagFree(l2, skb)) {
1091	stop_t200(l2, i: 8);
1092	lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1093	mISDN_FsmChangeState(fi, ST_L2_4);
1094	if (l2->tm)
1095	l2_tei(l2, MDL_STATUS_DOWN_IND, arg: 0);
1096	}
1097	}
1098
1099	static void
1100	enquiry_cr(struct layer2 *l2, u_char typ, u_char cr, u_char pf)
1101	{
1102	struct sk_buff *skb;
1103	u_char tmp[MAX_L2HEADER_LEN];
1104	int i;
1105
1106	i = sethdraddr(l2, header: tmp, rsp: cr);
1107	if (test_bit(FLG_MOD128, &l2->flag)) {
1108	tmp[i++] = typ;
1109	tmp[i++] = (l2->vr << 1) | (pf ? 1 : 0);
1110	} else
1111	tmp[i++] = (l2->vr << 5) | typ | (pf ? 0x10 : 0);
1112	skb = mI_alloc_skb(len: i, GFP_ATOMIC);
1113	if (!skb) {
1114	printk(KERN_WARNING "%s: isdnl2 can't alloc sbbuff in %s\n",
1115	mISDNDevName4ch(&l2->ch), __func__);
1116	return;
1117	}
1118	skb_put_data(skb, data: tmp, len: i);
1119	enqueue_super(l2, skb);
1120	}
1121
1122	inline void
1123	enquiry_response(struct layer2 *l2)
1124	{
1125	if (test_bit(FLG_OWN_BUSY, &l2->flag))
1126	enquiry_cr(l2, RNR, RSP, pf: 1);
1127	else
1128	enquiry_cr(l2, RR, RSP, pf: 1);
1129	test_and_clear_bit(FLG_ACK_PEND, addr: &l2->flag);
1130	}
1131
1132	inline void
1133	transmit_enquiry(struct layer2 *l2)
1134	{
1135	if (test_bit(FLG_OWN_BUSY, &l2->flag))
1136	enquiry_cr(l2, RNR, CMD, pf: 1);
1137	else
1138	enquiry_cr(l2, RR, CMD, pf: 1);
1139	test_and_clear_bit(FLG_ACK_PEND, addr: &l2->flag);
1140	start_t200(l2, i: 9);
1141	}
1142
1143
1144	static void
1145	nrerrorrecovery(struct FsmInst *fi)
1146	{
1147	struct layer2 *l2 = fi->userdata;
1148
1149	l2mgr(l2, MDL_ERROR_IND, arg: (void *) 'J');
1150	establishlink(fi);
1151	test_and_clear_bit(FLG_L3_INIT, addr: &l2->flag);
1152	}
1153
1154	static void
1155	invoke_retransmission(struct layer2 *l2, unsigned int nr)
1156	{
1157	u_int p1;
1158
1159	if (l2->vs != nr) {
1160	while (l2->vs != nr) {
1161	(l2->vs)--;
1162	if (test_bit(FLG_MOD128, &l2->flag)) {
1163	l2->vs %= 128;
1164	p1 = (l2->vs - l2->va) % 128;
1165	} else {
1166	l2->vs %= 8;
1167	p1 = (l2->vs - l2->va) % 8;
1168	}
1169	p1 = (p1 + l2->sow) % l2->window;
1170	if (l2->windowar[p1])
1171	skb_queue_head(list: &l2->i_queue, newsk: l2->windowar[p1]);
1172	else
1173	printk(KERN_WARNING
1174	"%s: windowar[%d] is NULL\n",
1175	mISDNDevName4ch(&l2->ch), p1);
1176	l2->windowar[p1] = NULL;
1177	}
1178	mISDN_FsmEvent(&l2->l2m, EV_L2_ACK_PULL, NULL);
1179	}
1180	}
1181
1182	static void
1183	l2_st7_got_super(struct FsmInst *fi, int event, void *arg)
1184	{
1185	struct layer2 *l2 = fi->userdata;
1186	struct sk_buff *skb = arg;
1187	int PollFlag, rsp, typ = RR;
1188	unsigned int nr;
1189
1190	rsp = *skb->data & 0x2;
1191	if (test_bit(FLG_ORIG, &l2->flag))
1192	rsp = !rsp;
1193
1194	skb_pull(skb, len: l2addrsize(l2));
1195	if (IsRNR(data: skb->data, l2)) {
1196	set_peer_busy(l2);
1197	typ = RNR;
1198	} else
1199	clear_peer_busy(l2);
1200	if (IsREJ(data: skb->data, l2))
1201	typ = REJ;
1202
1203	if (test_bit(FLG_MOD128, &l2->flag)) {
1204	PollFlag = (skb->data[1] & 0x1) == 0x1;
1205	nr = skb->data[1] >> 1;
1206	} else {
1207	PollFlag = (skb->data[0] & 0x10);
1208	nr = (skb->data[0] >> 5) & 0x7;
1209	}
1210	dev_kfree_skb(skb);
1211
1212	if (PollFlag) {
1213	if (rsp)
1214	l2mgr(l2, MDL_ERROR_IND, arg: (void *) 'A');
1215	else
1216	enquiry_response(l2);
1217	}
1218	if (legalnr(l2, nr)) {
1219	if (typ == REJ) {
1220	setva(l2, nr);
1221	invoke_retransmission(l2, nr);
1222	stop_t200(l2, i: 10);
1223	if (mISDN_FsmAddTimer(&l2->t203, l2->T203,
1224	EV_L2_T203, NULL, 6))
1225	l2m_debug(fi: &l2->l2m, fmt: "Restart T203 ST7 REJ");
1226	} else if ((nr == l2->vs) && (typ == RR)) {
1227	setva(l2, nr);
1228	stop_t200(l2, i: 11);
1229	mISDN_FsmRestartTimer(&l2->t203, l2->T203,
1230	EV_L2_T203, NULL, 7);
1231	} else if ((l2->va != nr) || (typ == RNR)) {
1232	setva(l2, nr);
1233	if (typ != RR)
1234	mISDN_FsmDelTimer(&l2->t203, 9);
1235	restart_t200(l2, i: 12);
1236	}
1237	if (skb_queue_len(list_: &l2->i_queue) && (typ == RR))
1238	mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1239	} else
1240	nrerrorrecovery(fi);
1241	}
1242
1243	static void
1244	l2_feed_i_if_reest(struct FsmInst *fi, int event, void *arg)
1245	{
1246	struct layer2 *l2 = fi->userdata;
1247	struct sk_buff *skb = arg;
1248
1249	if (!test_bit(FLG_L3_INIT, &l2->flag))
1250	skb_queue_tail(list: &l2->i_queue, newsk: skb);
1251	else
1252	dev_kfree_skb(skb);
1253	}
1254
1255	static void
1256	l2_feed_i_pull(struct FsmInst *fi, int event, void *arg)
1257	{
1258	struct layer2 *l2 = fi->userdata;
1259	struct sk_buff *skb = arg;
1260
1261	skb_queue_tail(list: &l2->i_queue, newsk: skb);
1262	mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1263	}
1264
1265	static void
1266	l2_feed_iqueue(struct FsmInst *fi, int event, void *arg)
1267	{
1268	struct layer2 *l2 = fi->userdata;
1269	struct sk_buff *skb = arg;
1270
1271	skb_queue_tail(list: &l2->i_queue, newsk: skb);
1272	}
1273
1274	static void
1275	l2_got_iframe(struct FsmInst *fi, int event, void *arg)
1276	{
1277	struct layer2 *l2 = fi->userdata;
1278	struct sk_buff *skb = arg;
1279	int PollFlag, i;
1280	u_int ns, nr;
1281
1282	i = l2addrsize(l2);
1283	if (test_bit(FLG_MOD128, &l2->flag)) {
1284	PollFlag = ((skb->data[i + 1] & 0x1) == 0x1);
1285	ns = skb->data[i] >> 1;
1286	nr = (skb->data[i + 1] >> 1) & 0x7f;
1287	} else {
1288	PollFlag = (skb->data[i] & 0x10);
1289	ns = (skb->data[i] >> 1) & 0x7;
1290	nr = (skb->data[i] >> 5) & 0x7;
1291	}
1292	if (test_bit(FLG_OWN_BUSY, &l2->flag)) {
1293	dev_kfree_skb(skb);
1294	if (PollFlag)
1295	enquiry_response(l2);
1296	} else {
1297	if (l2->vr == ns) {
1298	l2->vr++;
1299	if (test_bit(FLG_MOD128, &l2->flag))
1300	l2->vr %= 128;
1301	else
1302	l2->vr %= 8;
1303	test_and_clear_bit(FLG_REJEXC, addr: &l2->flag);
1304	if (PollFlag)
1305	enquiry_response(l2);
1306	else
1307	test_and_set_bit(FLG_ACK_PEND, addr: &l2->flag);
1308	skb_pull(skb, len: l2headersize(l2, ui: 0));
1309	l2up(l2, DL_DATA_IND, skb);
1310	} else {
1311	/* n(s)!=v(r) */
1312	dev_kfree_skb(skb);
1313	if (test_and_set_bit(FLG_REJEXC, addr: &l2->flag)) {
1314	if (PollFlag)
1315	enquiry_response(l2);
1316	} else {
1317	enquiry_cr(l2, REJ, RSP, pf: PollFlag);
1318	test_and_clear_bit(FLG_ACK_PEND, addr: &l2->flag);
1319	}
1320	}
1321	}
1322	if (legalnr(l2, nr)) {
1323	if (!test_bit(FLG_PEER_BUSY, &l2->flag) &&
1324	(fi->state == ST_L2_7)) {
1325	if (nr == l2->vs) {
1326	stop_t200(l2, i: 13);
1327	mISDN_FsmRestartTimer(&l2->t203, l2->T203,
1328	EV_L2_T203, NULL, 7);
1329	} else if (nr != l2->va)
1330	restart_t200(l2, i: 14);
1331	}
1332	setva(l2, nr);
1333	} else {
1334	nrerrorrecovery(fi);
1335	return;
1336	}
1337	if (skb_queue_len(list_: &l2->i_queue) && (fi->state == ST_L2_7))
1338	mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1339	if (test_and_clear_bit(FLG_ACK_PEND, addr: &l2->flag))
1340	enquiry_cr(l2, RR, RSP, pf: 0);
1341	}
1342
1343	static void
1344	l2_got_tei(struct FsmInst *fi, int event, void *arg)
1345	{
1346	struct layer2 *l2 = fi->userdata;
1347	u_int info;
1348
1349	l2->tei = (signed char)(long)arg;
1350	set_channel_address(&l2->ch, l2->sapi, l2->tei);
1351	info = DL_INFO_L2_CONNECT;
1352	l2up_create(l2, DL_INFORMATION_IND, len: sizeof(info), arg: &info);
1353	if (fi->state == ST_L2_3) {
1354	establishlink(fi);
1355	test_and_set_bit(FLG_L3_INIT, addr: &l2->flag);
1356	} else
1357	mISDN_FsmChangeState(fi, ST_L2_4);
1358	if (skb_queue_len(list_: &l2->ui_queue))
1359	tx_ui(l2);
1360	}
1361
1362	static void
1363	l2_st5_tout_200(struct FsmInst *fi, int event, void *arg)
1364	{
1365	struct layer2 *l2 = fi->userdata;
1366
1367	if (test_bit(FLG_LAPD, &l2->flag) &&
1368	test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1369	mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1370	} else if (l2->rc == l2->N200) {
1371	mISDN_FsmChangeState(fi, ST_L2_4);
1372	test_and_clear_bit(FLG_T200_RUN, addr: &l2->flag);
1373	skb_queue_purge(list: &l2->i_queue);
1374	l2mgr(l2, MDL_ERROR_IND, arg: (void *) 'G');
1375	if (test_bit(FLG_LAPB, &l2->flag))
1376	l2down_create(l2, PH_DEACTIVATE_REQ,
1377	id: l2_newid(l2), len: 0, NULL);
1378	st5_dl_release_l2l3(l2);
1379	if (l2->tm)
1380	l2_tei(l2, MDL_STATUS_DOWN_IND, arg: 0);
1381	} else {
1382	l2->rc++;
1383	mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1384	send_uframe(l2, NULL, cmd: (test_bit(FLG_MOD128, &l2->flag) ?
1385	SABME : SABM) | 0x10, CMD);
1386	}
1387	}
1388
1389	static void
1390	l2_st6_tout_200(struct FsmInst *fi, int event, void *arg)
1391	{
1392	struct layer2 *l2 = fi->userdata;
1393
1394	if (test_bit(FLG_LAPD, &l2->flag) &&
1395	test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1396	mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1397	} else if (l2->rc == l2->N200) {
1398	mISDN_FsmChangeState(fi, ST_L2_4);
1399	test_and_clear_bit(FLG_T200_RUN, addr: &l2->flag);
1400	l2mgr(l2, MDL_ERROR_IND, arg: (void *) 'H');
1401	lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1402	if (l2->tm)
1403	l2_tei(l2, MDL_STATUS_DOWN_IND, arg: 0);
1404	} else {
1405	l2->rc++;
1406	mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200,
1407	NULL, 9);
1408	send_uframe(l2, NULL, DISC | 0x10, CMD);
1409	}
1410	}
1411
1412	static void
1413	l2_st7_tout_200(struct FsmInst *fi, int event, void *arg)
1414	{
1415	struct layer2 *l2 = fi->userdata;
1416
1417	if (test_bit(FLG_LAPD, &l2->flag) &&
1418	test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1419	mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1420	return;
1421	}
1422	test_and_clear_bit(FLG_T200_RUN, addr: &l2->flag);
1423	l2->rc = 0;
1424	mISDN_FsmChangeState(fi, ST_L2_8);
1425	transmit_enquiry(l2);
1426	l2->rc++;
1427	}
1428
1429	static void
1430	l2_st8_tout_200(struct FsmInst *fi, int event, void *arg)
1431	{
1432	struct layer2 *l2 = fi->userdata;
1433
1434	if (test_bit(FLG_LAPD, &l2->flag) &&
1435	test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1436	mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1437	return;
1438	}
1439	test_and_clear_bit(FLG_T200_RUN, addr: &l2->flag);
1440	if (l2->rc == l2->N200) {
1441	l2mgr(l2, MDL_ERROR_IND, arg: (void *) 'I');
1442	establishlink(fi);
1443	test_and_clear_bit(FLG_L3_INIT, addr: &l2->flag);
1444	} else {
1445	transmit_enquiry(l2);
1446	l2->rc++;
1447	}
1448	}
1449
1450	static void
1451	l2_st7_tout_203(struct FsmInst *fi, int event, void *arg)
1452	{
1453	struct layer2 *l2 = fi->userdata;
1454
1455	if (test_bit(FLG_LAPD, &l2->flag) &&
1456	test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1457	mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 9);
1458	return;
1459	}
1460	mISDN_FsmChangeState(fi, ST_L2_8);
1461	transmit_enquiry(l2);
1462	l2->rc = 0;
1463	}
1464
1465	static void
1466	l2_pull_iqueue(struct FsmInst *fi, int event, void *arg)
1467	{
1468	struct layer2 *l2 = fi->userdata;
1469	struct sk_buff *skb, *nskb;
1470	u_char header[MAX_L2HEADER_LEN];
1471	u_int i, p1;
1472
1473	if (!cansend(l2))
1474	return;
1475
1476	skb = skb_dequeue(list: &l2->i_queue);
1477	if (!skb)
1478	return;
1479	i = sethdraddr(l2, header, CMD);
1480	if (test_bit(FLG_MOD128, &l2->flag)) {
1481	header[i++] = l2->vs << 1;
1482	header[i++] = l2->vr << 1;
1483	} else
1484	header[i++] = (l2->vr << 5) | (l2->vs << 1);
1485	nskb = skb_realloc_headroom(skb, headroom: i);
1486	if (!nskb) {
1487	printk(KERN_WARNING "%s: no headroom(%d) copy for IFrame\n",
1488	mISDNDevName4ch(&l2->ch), i);
1489	skb_queue_head(list: &l2->i_queue, newsk: skb);
1490	return;
1491	}
1492	if (test_bit(FLG_MOD128, &l2->flag)) {
1493	p1 = (l2->vs - l2->va) % 128;
1494	l2->vs = (l2->vs + 1) % 128;
1495	} else {
1496	p1 = (l2->vs - l2->va) % 8;
1497	l2->vs = (l2->vs + 1) % 8;
1498	}
1499	p1 = (p1 + l2->sow) % l2->window;
1500	if (l2->windowar[p1]) {
1501	printk(KERN_WARNING "%s: l2 try overwrite ack queue entry %d\n",
1502	mISDNDevName4ch(&l2->ch), p1);
1503	dev_kfree_skb(l2->windowar[p1]);
1504	}
1505	l2->windowar[p1] = skb;
1506	memcpy(skb_push(nskb, i), header, i);
1507	l2down(l2, PH_DATA_REQ, id: l2_newid(l2), skb: nskb);
1508	test_and_clear_bit(FLG_ACK_PEND, addr: &l2->flag);
1509	if (!test_and_set_bit(FLG_T200_RUN, addr: &l2->flag)) {
1510	mISDN_FsmDelTimer(&l2->t203, 13);
1511	mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 11);
1512	}
1513	}
1514
1515	static void
1516	l2_st8_got_super(struct FsmInst *fi, int event, void *arg)
1517	{
1518	struct layer2 *l2 = fi->userdata;
1519	struct sk_buff *skb = arg;
1520	int PollFlag, rsp, rnr = 0;
1521	unsigned int nr;
1522
1523	rsp = *skb->data & 0x2;
1524	if (test_bit(FLG_ORIG, &l2->flag))
1525	rsp = !rsp;
1526
1527	skb_pull(skb, len: l2addrsize(l2));
1528
1529	if (IsRNR(data: skb->data, l2)) {
1530	set_peer_busy(l2);
1531	rnr = 1;
1532	} else
1533	clear_peer_busy(l2);
1534
1535	if (test_bit(FLG_MOD128, &l2->flag)) {
1536	PollFlag = (skb->data[1] & 0x1) == 0x1;
1537	nr = skb->data[1] >> 1;
1538	} else {
1539	PollFlag = (skb->data[0] & 0x10);
1540	nr = (skb->data[0] >> 5) & 0x7;
1541	}
1542	dev_kfree_skb(skb);
1543	if (rsp && PollFlag) {
1544	if (legalnr(l2, nr)) {
1545	if (rnr) {
1546	restart_t200(l2, i: 15);
1547	} else {
1548	stop_t200(l2, i: 16);
1549	mISDN_FsmAddTimer(&l2->t203, l2->T203,
1550	EV_L2_T203, NULL, 5);
1551	setva(l2, nr);
1552	}
1553	invoke_retransmission(l2, nr);
1554	mISDN_FsmChangeState(fi, ST_L2_7);
1555	if (skb_queue_len(list_: &l2->i_queue) && cansend(l2))
1556	mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1557	} else
1558	nrerrorrecovery(fi);
1559	} else {
1560	if (!rsp && PollFlag)
1561	enquiry_response(l2);
1562	if (legalnr(l2, nr))
1563	setva(l2, nr);
1564	else
1565	nrerrorrecovery(fi);
1566	}
1567	}
1568
1569	static void
1570	l2_got_FRMR(struct FsmInst *fi, int event, void *arg)
1571	{
1572	struct layer2 *l2 = fi->userdata;
1573	struct sk_buff *skb = arg;
1574
1575	skb_pull(skb, len: l2addrsize(l2) + 1);
1576
1577	if (!(skb->data[0] & 1) || ((skb->data[0] & 3) == 1) || /* I or S */
1578	(IsUA(data: skb->data) && (fi->state == ST_L2_7))) {
1579	l2mgr(l2, MDL_ERROR_IND, arg: (void *) 'K');
1580	establishlink(fi);
1581	test_and_clear_bit(FLG_L3_INIT, addr: &l2->flag);
1582	}
1583	dev_kfree_skb(skb);
1584	}
1585
1586	static void
1587	l2_st24_tei_remove(struct FsmInst *fi, int event, void *arg)
1588	{
1589	struct layer2 *l2 = fi->userdata;
1590
1591	skb_queue_purge(list: &l2->ui_queue);
1592	l2->tei = GROUP_TEI;
1593	mISDN_FsmChangeState(fi, ST_L2_1);
1594	}
1595
1596	static void
1597	l2_st3_tei_remove(struct FsmInst *fi, int event, void *arg)
1598	{
1599	struct layer2 *l2 = fi->userdata;
1600
1601	skb_queue_purge(list: &l2->ui_queue);
1602	l2->tei = GROUP_TEI;
1603	l2up_create(l2, DL_RELEASE_IND, len: 0, NULL);
1604	mISDN_FsmChangeState(fi, ST_L2_1);
1605	}
1606
1607	static void
1608	l2_st5_tei_remove(struct FsmInst *fi, int event, void *arg)
1609	{
1610	struct layer2 *l2 = fi->userdata;
1611
1612	skb_queue_purge(list: &l2->i_queue);
1613	skb_queue_purge(list: &l2->ui_queue);
1614	freewin(l2);
1615	l2->tei = GROUP_TEI;
1616	stop_t200(l2, i: 17);
1617	st5_dl_release_l2l3(l2);
1618	mISDN_FsmChangeState(fi, ST_L2_1);
1619	}
1620
1621	static void
1622	l2_st6_tei_remove(struct FsmInst *fi, int event, void *arg)
1623	{
1624	struct layer2 *l2 = fi->userdata;
1625
1626	skb_queue_purge(list: &l2->ui_queue);
1627	l2->tei = GROUP_TEI;
1628	stop_t200(l2, i: 18);
1629	l2up_create(l2, DL_RELEASE_IND, len: 0, NULL);
1630	mISDN_FsmChangeState(fi, ST_L2_1);
1631	}
1632
1633	static void
1634	l2_tei_remove(struct FsmInst *fi, int event, void *arg)
1635	{
1636	struct layer2 *l2 = fi->userdata;
1637
1638	skb_queue_purge(list: &l2->i_queue);
1639	skb_queue_purge(list: &l2->ui_queue);
1640	freewin(l2);
1641	l2->tei = GROUP_TEI;
1642	stop_t200(l2, i: 17);
1643	mISDN_FsmDelTimer(&l2->t203, 19);
1644	l2up_create(l2, DL_RELEASE_IND, len: 0, NULL);
1645	/* mISDN_queue_data(&l2->inst, l2->inst.id | MSG_BROADCAST,
1646	* MGR_SHORTSTATUS_IND, SSTATUS_L2_RELEASED,
1647	* 0, NULL, 0);
1648	*/
1649	mISDN_FsmChangeState(fi, ST_L2_1);
1650	}
1651
1652	static void
1653	l2_st14_persistent_da(struct FsmInst *fi, int event, void *arg)
1654	{
1655	struct layer2 *l2 = fi->userdata;
1656	struct sk_buff *skb = arg;
1657
1658	skb_queue_purge(list: &l2->i_queue);
1659	skb_queue_purge(list: &l2->ui_queue);
1660	if (test_and_clear_bit(FLG_ESTAB_PEND, addr: &l2->flag))
1661	l2up(l2, DL_RELEASE_IND, skb);
1662	else
1663	dev_kfree_skb(skb);
1664	}
1665
1666	static void
1667	l2_st5_persistent_da(struct FsmInst *fi, int event, void *arg)
1668	{
1669	struct layer2 *l2 = fi->userdata;
1670	struct sk_buff *skb = arg;
1671
1672	skb_queue_purge(list: &l2->i_queue);
1673	skb_queue_purge(list: &l2->ui_queue);
1674	freewin(l2);
1675	stop_t200(l2, i: 19);
1676	st5_dl_release_l2l3(l2);
1677	mISDN_FsmChangeState(fi, ST_L2_4);
1678	if (l2->tm)
1679	l2_tei(l2, MDL_STATUS_DOWN_IND, arg: 0);
1680	dev_kfree_skb(skb);
1681	}
1682
1683	static void
1684	l2_st6_persistent_da(struct FsmInst *fi, int event, void *arg)
1685	{
1686	struct layer2 *l2 = fi->userdata;
1687	struct sk_buff *skb = arg;
1688
1689	skb_queue_purge(list: &l2->ui_queue);
1690	stop_t200(l2, i: 20);
1691	l2up(l2, DL_RELEASE_CNF, skb);
1692	mISDN_FsmChangeState(fi, ST_L2_4);
1693	if (l2->tm)
1694	l2_tei(l2, MDL_STATUS_DOWN_IND, arg: 0);
1695	}
1696
1697	static void
1698	l2_persistent_da(struct FsmInst *fi, int event, void *arg)
1699	{
1700	struct layer2 *l2 = fi->userdata;
1701	struct sk_buff *skb = arg;
1702
1703	skb_queue_purge(list: &l2->i_queue);
1704	skb_queue_purge(list: &l2->ui_queue);
1705	freewin(l2);
1706	stop_t200(l2, i: 19);
1707	mISDN_FsmDelTimer(&l2->t203, 19);
1708	l2up(l2, DL_RELEASE_IND, skb);
1709	mISDN_FsmChangeState(fi, ST_L2_4);
1710	if (l2->tm)
1711	l2_tei(l2, MDL_STATUS_DOWN_IND, arg: 0);
1712	}
1713
1714	static void
1715	l2_set_own_busy(struct FsmInst *fi, int event, void *arg)
1716	{
1717	struct layer2 *l2 = fi->userdata;
1718	struct sk_buff *skb = arg;
1719
1720	if (!test_and_set_bit(FLG_OWN_BUSY, addr: &l2->flag)) {
1721	enquiry_cr(l2, RNR, RSP, pf: 0);
1722	test_and_clear_bit(FLG_ACK_PEND, addr: &l2->flag);
1723	}
1724	dev_kfree_skb(skb);
1725	}
1726
1727	static void
1728	l2_clear_own_busy(struct FsmInst *fi, int event, void *arg)
1729	{
1730	struct layer2 *l2 = fi->userdata;
1731	struct sk_buff *skb = arg;
1732
1733	if (!test_and_clear_bit(FLG_OWN_BUSY, addr: &l2->flag)) {
1734	enquiry_cr(l2, RR, RSP, pf: 0);
1735	test_and_clear_bit(FLG_ACK_PEND, addr: &l2->flag);
1736	}
1737	dev_kfree_skb(skb);
1738	}
1739
1740	static void
1741	l2_frame_error(struct FsmInst *fi, int event, void *arg)
1742	{
1743	struct layer2 *l2 = fi->userdata;
1744
1745	l2mgr(l2, MDL_ERROR_IND, arg);
1746	}
1747
1748	static void
1749	l2_frame_error_reest(struct FsmInst *fi, int event, void *arg)
1750	{
1751	struct layer2 *l2 = fi->userdata;
1752
1753	l2mgr(l2, MDL_ERROR_IND, arg);
1754	establishlink(fi);
1755	test_and_clear_bit(FLG_L3_INIT, addr: &l2->flag);
1756	}
1757
1758	static struct FsmNode L2FnList[] =
1759	{
1760	{ST_L2_1, EV_L2_DL_ESTABLISH_REQ, l2_mdl_assign},
1761	{ST_L2_2, EV_L2_DL_ESTABLISH_REQ, l2_go_st3},
1762	{ST_L2_4, EV_L2_DL_ESTABLISH_REQ, l2_establish},
1763	{ST_L2_5, EV_L2_DL_ESTABLISH_REQ, l2_discard_i_setl3},
1764	{ST_L2_7, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish},
1765	{ST_L2_8, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish},
1766	{ST_L2_4, EV_L2_DL_RELEASE_REQ, l2_release},
1767	{ST_L2_5, EV_L2_DL_RELEASE_REQ, l2_pend_rel},
1768	{ST_L2_7, EV_L2_DL_RELEASE_REQ, l2_disconnect},
1769	{ST_L2_8, EV_L2_DL_RELEASE_REQ, l2_disconnect},
1770	{ST_L2_5, EV_L2_DL_DATA, l2_feed_i_if_reest},
1771	{ST_L2_7, EV_L2_DL_DATA, l2_feed_i_pull},
1772	{ST_L2_8, EV_L2_DL_DATA, l2_feed_iqueue},
1773	{ST_L2_1, EV_L2_DL_UNITDATA, l2_queue_ui_assign},
1774	{ST_L2_2, EV_L2_DL_UNITDATA, l2_queue_ui},
1775	{ST_L2_3, EV_L2_DL_UNITDATA, l2_queue_ui},
1776	{ST_L2_4, EV_L2_DL_UNITDATA, l2_send_ui},
1777	{ST_L2_5, EV_L2_DL_UNITDATA, l2_send_ui},
1778	{ST_L2_6, EV_L2_DL_UNITDATA, l2_send_ui},
1779	{ST_L2_7, EV_L2_DL_UNITDATA, l2_send_ui},
1780	{ST_L2_8, EV_L2_DL_UNITDATA, l2_send_ui},
1781	{ST_L2_1, EV_L2_MDL_ASSIGN, l2_got_tei},
1782	{ST_L2_2, EV_L2_MDL_ASSIGN, l2_got_tei},
1783	{ST_L2_3, EV_L2_MDL_ASSIGN, l2_got_tei},
1784	{ST_L2_2, EV_L2_MDL_ERROR, l2_st24_tei_remove},
1785	{ST_L2_3, EV_L2_MDL_ERROR, l2_st3_tei_remove},
1786	{ST_L2_4, EV_L2_MDL_REMOVE, l2_st24_tei_remove},
1787	{ST_L2_5, EV_L2_MDL_REMOVE, l2_st5_tei_remove},
1788	{ST_L2_6, EV_L2_MDL_REMOVE, l2_st6_tei_remove},
1789	{ST_L2_7, EV_L2_MDL_REMOVE, l2_tei_remove},
1790	{ST_L2_8, EV_L2_MDL_REMOVE, l2_tei_remove},
1791	{ST_L2_4, EV_L2_SABME, l2_start_multi},
1792	{ST_L2_5, EV_L2_SABME, l2_send_UA},
1793	{ST_L2_6, EV_L2_SABME, l2_send_DM},
1794	{ST_L2_7, EV_L2_SABME, l2_restart_multi},
1795	{ST_L2_8, EV_L2_SABME, l2_restart_multi},
1796	{ST_L2_4, EV_L2_DISC, l2_send_DM},
1797	{ST_L2_5, EV_L2_DISC, l2_send_DM},
1798	{ST_L2_6, EV_L2_DISC, l2_send_UA},
1799	{ST_L2_7, EV_L2_DISC, l2_stop_multi},
1800	{ST_L2_8, EV_L2_DISC, l2_stop_multi},
1801	{ST_L2_4, EV_L2_UA, l2_mdl_error_ua},
1802	{ST_L2_5, EV_L2_UA, l2_connected},
1803	{ST_L2_6, EV_L2_UA, l2_released},
1804	{ST_L2_7, EV_L2_UA, l2_mdl_error_ua},
1805	{ST_L2_8, EV_L2_UA, l2_mdl_error_ua},
1806	{ST_L2_4, EV_L2_DM, l2_reestablish},
1807	{ST_L2_5, EV_L2_DM, l2_st5_dm_release},
1808	{ST_L2_6, EV_L2_DM, l2_st6_dm_release},
1809	{ST_L2_7, EV_L2_DM, l2_mdl_error_dm},
1810	{ST_L2_8, EV_L2_DM, l2_st8_mdl_error_dm},
1811	{ST_L2_1, EV_L2_UI, l2_got_ui},
1812	{ST_L2_2, EV_L2_UI, l2_got_ui},
1813	{ST_L2_3, EV_L2_UI, l2_got_ui},
1814	{ST_L2_4, EV_L2_UI, l2_got_ui},
1815	{ST_L2_5, EV_L2_UI, l2_got_ui},
1816	{ST_L2_6, EV_L2_UI, l2_got_ui},
1817	{ST_L2_7, EV_L2_UI, l2_got_ui},
1818	{ST_L2_8, EV_L2_UI, l2_got_ui},
1819	{ST_L2_7, EV_L2_FRMR, l2_got_FRMR},
1820	{ST_L2_8, EV_L2_FRMR, l2_got_FRMR},
1821	{ST_L2_7, EV_L2_SUPER, l2_st7_got_super},
1822	{ST_L2_8, EV_L2_SUPER, l2_st8_got_super},
1823	{ST_L2_7, EV_L2_I, l2_got_iframe},
1824	{ST_L2_8, EV_L2_I, l2_got_iframe},
1825	{ST_L2_5, EV_L2_T200, l2_timeout},
1826	{ST_L2_6, EV_L2_T200, l2_timeout},
1827	{ST_L2_7, EV_L2_T200, l2_timeout},
1828	{ST_L2_8, EV_L2_T200, l2_timeout},
1829	{ST_L2_7, EV_L2_T203, l2_timeout},
1830	{ST_L2_5, EV_L2_T200I, l2_st5_tout_200},
1831	{ST_L2_6, EV_L2_T200I, l2_st6_tout_200},
1832	{ST_L2_7, EV_L2_T200I, l2_st7_tout_200},
1833	{ST_L2_8, EV_L2_T200I, l2_st8_tout_200},
1834	{ST_L2_7, EV_L2_T203I, l2_st7_tout_203},
1835	{ST_L2_7, EV_L2_ACK_PULL, l2_pull_iqueue},
1836	{ST_L2_7, EV_L2_SET_OWN_BUSY, l2_set_own_busy},
1837	{ST_L2_8, EV_L2_SET_OWN_BUSY, l2_set_own_busy},
1838	{ST_L2_7, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy},
1839	{ST_L2_8, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy},
1840	{ST_L2_4, EV_L2_FRAME_ERROR, l2_frame_error},
1841	{ST_L2_5, EV_L2_FRAME_ERROR, l2_frame_error},
1842	{ST_L2_6, EV_L2_FRAME_ERROR, l2_frame_error},
1843	{ST_L2_7, EV_L2_FRAME_ERROR, l2_frame_error_reest},
1844	{ST_L2_8, EV_L2_FRAME_ERROR, l2_frame_error_reest},
1845	{ST_L2_1, EV_L1_DEACTIVATE, l2_st14_persistent_da},
1846	{ST_L2_2, EV_L1_DEACTIVATE, l2_st24_tei_remove},
1847	{ST_L2_3, EV_L1_DEACTIVATE, l2_st3_tei_remove},
1848	{ST_L2_4, EV_L1_DEACTIVATE, l2_st14_persistent_da},
1849	{ST_L2_5, EV_L1_DEACTIVATE, l2_st5_persistent_da},
1850	{ST_L2_6, EV_L1_DEACTIVATE, l2_st6_persistent_da},
1851	{ST_L2_7, EV_L1_DEACTIVATE, l2_persistent_da},
1852	{ST_L2_8, EV_L1_DEACTIVATE, l2_persistent_da},
1853	};
1854
1855	static int
1856	ph_data_indication(struct layer2 *l2, struct mISDNhead *hh, struct sk_buff *skb)
1857	{
1858	u_char *datap = skb->data;
1859	int ret = -EINVAL;
1860	int psapi, ptei;
1861	u_int l;
1862	int c = 0;
1863
1864	l = l2addrsize(l2);
1865	if (skb->len <= l) {
1866	mISDN_FsmEvent(&l2->l2m, EV_L2_FRAME_ERROR, (void *) 'N');
1867	return ret;
1868	}
1869	if (test_bit(FLG_LAPD, &l2->flag)) { /* Maybe not needed */
1870	psapi = *datap++;
1871	ptei = *datap++;
1872	if ((psapi & 1) || !(ptei & 1)) {
1873	printk(KERN_WARNING
1874	"%s l2 D-channel frame wrong EA0/EA1\n",
1875	mISDNDevName4ch(&l2->ch));
1876	return ret;
1877	}
1878	psapi >>= 2;
1879	ptei >>= 1;
1880	if (psapi != l2->sapi) {
1881	/* not our business */
1882	if (*debug & DEBUG_L2)
1883	printk(KERN_DEBUG "%s: sapi %d/%d mismatch\n",
1884	mISDNDevName4ch(&l2->ch), psapi,
1885	l2->sapi);
1886	dev_kfree_skb(skb);
1887	return 0;
1888	}
1889	if ((ptei != l2->tei) && (ptei != GROUP_TEI)) {
1890	/* not our business */
1891	if (*debug & DEBUG_L2)
1892	printk(KERN_DEBUG "%s: tei %d/%d mismatch\n",
1893	mISDNDevName4ch(&l2->ch), ptei, l2->tei);
1894	dev_kfree_skb(skb);
1895	return 0;
1896	}
1897	} else
1898	datap += l;
1899	if (!(*datap & 1)) { /* I-Frame */
1900	c = iframe_error(l2, skb);
1901	if (!c)
1902	ret = mISDN_FsmEvent(&l2->l2m, EV_L2_I, skb);
1903	} else if (IsSFrame(data: datap, l2)) { /* S-Frame */
1904	c = super_error(l2, skb);
1905	if (!c)
1906	ret = mISDN_FsmEvent(&l2->l2m, EV_L2_SUPER, skb);
1907	} else if (IsUI(data: datap)) {
1908	c = UI_error(l2, skb);
1909	if (!c)
1910	ret = mISDN_FsmEvent(&l2->l2m, EV_L2_UI, skb);
1911	} else if (IsSABME(data: datap, l2)) {
1912	c = unnum_error(l2, skb, CMD);
1913	if (!c)
1914	ret = mISDN_FsmEvent(&l2->l2m, EV_L2_SABME, skb);
1915	} else if (IsUA(data: datap)) {
1916	c = unnum_error(l2, skb, RSP);
1917	if (!c)
1918	ret = mISDN_FsmEvent(&l2->l2m, EV_L2_UA, skb);
1919	} else if (IsDISC(data: datap)) {
1920	c = unnum_error(l2, skb, CMD);
1921	if (!c)
1922	ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DISC, skb);
1923	} else if (IsDM(data: datap)) {
1924	c = unnum_error(l2, skb, RSP);
1925	if (!c)
1926	ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DM, skb);
1927	} else if (IsFRMR(data: datap)) {
1928	c = FRMR_error(l2, skb);
1929	if (!c)
1930	ret = mISDN_FsmEvent(&l2->l2m, EV_L2_FRMR, skb);
1931	} else
1932	c = 'L';
1933	if (c) {
1934	printk(KERN_WARNING "%s:l2 D-channel frame error %c\n",
1935	mISDNDevName4ch(&l2->ch), c);
1936	mISDN_FsmEvent(&l2->l2m, EV_L2_FRAME_ERROR, (void *)(long)c);
1937	}
1938	return ret;
1939	}
1940
1941	static int
1942	l2_send(struct mISDNchannel *ch, struct sk_buff *skb)
1943	{
1944	struct layer2 *l2 = container_of(ch, struct layer2, ch);
1945	struct mISDNhead *hh = mISDN_HEAD_P(skb);
1946	int ret = -EINVAL;
1947
1948	if (*debug & DEBUG_L2_RECV)
1949	printk(KERN_DEBUG "%s: %s prim(%x) id(%x) sapi(%d) tei(%d)\n",
1950	__func__, mISDNDevName4ch(&l2->ch), hh->prim, hh->id,
1951	l2->sapi, l2->tei);
1952	if (hh->prim == DL_INTERN_MSG) {
1953	struct mISDNhead *chh = hh + 1; /* saved copy */
1954
1955	*hh = *chh;
1956	if (*debug & DEBUG_L2_RECV)
1957	printk(KERN_DEBUG "%s: prim(%x) id(%x) internal msg\n",
1958	mISDNDevName4ch(&l2->ch), hh->prim, hh->id);
1959	}
1960	switch (hh->prim) {
1961	case PH_DATA_IND:
1962	ret = ph_data_indication(l2, hh, skb);
1963	break;
1964	case PH_DATA_CNF:
1965	ret = ph_data_confirm(l2, hh, skb);
1966	break;
1967	case PH_ACTIVATE_IND:
1968	test_and_set_bit(FLG_L1_ACTIV, addr: &l2->flag);
1969	l2up_create(l2, MPH_ACTIVATE_IND, len: 0, NULL);
1970	if (test_and_clear_bit(FLG_ESTAB_PEND, addr: &l2->flag))
1971	ret = mISDN_FsmEvent(&l2->l2m,
1972	EV_L2_DL_ESTABLISH_REQ, skb);
1973	break;
1974	case PH_DEACTIVATE_IND:
1975	test_and_clear_bit(FLG_L1_ACTIV, addr: &l2->flag);
1976	l2up_create(l2, MPH_DEACTIVATE_IND, len: 0, NULL);
1977	ret = mISDN_FsmEvent(&l2->l2m, EV_L1_DEACTIVATE, skb);
1978	break;
1979	case MPH_INFORMATION_IND:
1980	if (!l2->up)
1981	break;
1982	ret = l2->up->send(l2->up, skb);
1983	break;
1984	case DL_DATA_REQ:
1985	ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_DATA, skb);
1986	break;
1987	case DL_UNITDATA_REQ:
1988	ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_UNITDATA, skb);
1989	break;
1990	case DL_ESTABLISH_REQ:
1991	if (test_bit(FLG_LAPB, &l2->flag))
1992	test_and_set_bit(FLG_ORIG, addr: &l2->flag);
1993	if (test_bit(FLG_L1_ACTIV, &l2->flag)) {
1994	if (test_bit(FLG_LAPD, &l2->flag) ||
1995	test_bit(FLG_ORIG, &l2->flag))
1996	ret = mISDN_FsmEvent(&l2->l2m,
1997	EV_L2_DL_ESTABLISH_REQ, skb);
1998	} else {
1999	if (test_bit(FLG_LAPD, &l2->flag) ||
2000	test_bit(FLG_ORIG, &l2->flag)) {
2001	test_and_set_bit(FLG_ESTAB_PEND,
2002	addr: &l2->flag);
2003	}
2004	ret = l2down(l2, PH_ACTIVATE_REQ, id: l2_newid(l2),
2005	skb);
2006	}
2007	break;
2008	case DL_RELEASE_REQ:
2009	if (test_bit(FLG_LAPB, &l2->flag))
2010	l2down_create(l2, PH_DEACTIVATE_REQ,
2011	id: l2_newid(l2), len: 0, NULL);
2012	ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_RELEASE_REQ,
2013	skb);
2014	break;
2015	case DL_TIMER200_IND:
2016	mISDN_FsmEvent(&l2->l2m, EV_L2_T200I, NULL);
2017	break;
2018	case DL_TIMER203_IND:
2019	mISDN_FsmEvent(&l2->l2m, EV_L2_T203I, NULL);
2020	break;
2021	default:
2022	if (*debug & DEBUG_L2)
2023	l2m_debug(fi: &l2->l2m, fmt: "l2 unknown pr %04x",
2024	hh->prim);
2025	}
2026	if (ret) {
2027	dev_kfree_skb(skb);
2028	ret = 0;
2029	}
2030	return ret;
2031	}
2032
2033	int
2034	tei_l2(struct layer2 *l2, u_int cmd, u_long arg)
2035	{
2036	int ret = -EINVAL;
2037
2038	if (*debug & DEBUG_L2_TEI)
2039	printk(KERN_DEBUG "%s: cmd(%x) in %s\n",
2040	mISDNDevName4ch(&l2->ch), cmd, __func__);
2041	switch (cmd) {
2042	case (MDL_ASSIGN_REQ):
2043	ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ASSIGN, (void *)arg);
2044	break;
2045	case (MDL_REMOVE_REQ):
2046	ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_REMOVE, NULL);
2047	break;
2048	case (MDL_ERROR_IND):
2049	ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ERROR, NULL);
2050	break;
2051	case (MDL_ERROR_RSP):
2052	/* ETS 300-125 5.3.2.1 Test: TC13010 */
2053	printk(KERN_NOTICE "%s: MDL_ERROR|REQ (tei_l2)\n",
2054	mISDNDevName4ch(&l2->ch));
2055	ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ERROR, NULL);
2056	break;
2057	}
2058	return ret;
2059	}
2060
2061	static void
2062	release_l2(struct layer2 *l2)
2063	{
2064	mISDN_FsmDelTimer(&l2->t200, 21);
2065	mISDN_FsmDelTimer(&l2->t203, 16);
2066	skb_queue_purge(list: &l2->i_queue);
2067	skb_queue_purge(list: &l2->ui_queue);
2068	skb_queue_purge(list: &l2->down_queue);
2069	ReleaseWin(l2);
2070	if (test_bit(FLG_LAPD, &l2->flag)) {
2071	TEIrelease(l2);
2072	if (l2->ch.st)
2073	l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D,
2074	CLOSE_CHANNEL, NULL);
2075	}
2076	kfree(objp: l2);
2077	}
2078
2079	static int
2080	l2_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
2081	{
2082	struct layer2 *l2 = container_of(ch, struct layer2, ch);
2083	u_int info;
2084
2085	if (*debug & DEBUG_L2_CTRL)
2086	printk(KERN_DEBUG "%s: %s cmd(%x)\n",
2087	mISDNDevName4ch(ch), __func__, cmd);
2088
2089	switch (cmd) {
2090	case OPEN_CHANNEL:
2091	if (test_bit(FLG_LAPD, &l2->flag)) {
2092	set_channel_address(&l2->ch, l2->sapi, l2->tei);
2093	info = DL_INFO_L2_CONNECT;
2094	l2up_create(l2, DL_INFORMATION_IND,
2095	len: sizeof(info), arg: &info);
2096	}
2097	break;
2098	case CLOSE_CHANNEL:
2099	if (l2->ch.peer)
2100	l2->ch.peer->ctrl(l2->ch.peer, CLOSE_CHANNEL, NULL);
2101	release_l2(l2);
2102	break;
2103	}
2104	return 0;
2105	}
2106
2107	struct layer2 *
2108	create_l2(struct mISDNchannel *ch, u_int protocol, u_long options, int tei,
2109	int sapi)
2110	{
2111	struct layer2 *l2;
2112	struct channel_req rq;
2113
2114	l2 = kzalloc(size: sizeof(struct layer2), GFP_KERNEL);
2115	if (!l2) {
2116	printk(KERN_ERR "kzalloc layer2 failed\n");
2117	return NULL;
2118	}
2119	l2->next_id = 1;
2120	l2->down_id = MISDN_ID_NONE;
2121	l2->up = ch;
2122	l2->ch.st = ch->st;
2123	l2->ch.send = l2_send;
2124	l2->ch.ctrl = l2_ctrl;
2125	switch (protocol) {
2126	case ISDN_P_LAPD_NT:
2127	test_and_set_bit(FLG_LAPD, addr: &l2->flag);
2128	test_and_set_bit(FLG_LAPD_NET, addr: &l2->flag);
2129	test_and_set_bit(FLG_MOD128, addr: &l2->flag);
2130	l2->sapi = sapi;
2131	l2->maxlen = MAX_DFRAME_LEN;
2132	if (test_bit(OPTION_L2_PMX, &options))
2133	l2->window = 7;
2134	else
2135	l2->window = 1;
2136	if (test_bit(OPTION_L2_PTP, &options))
2137	test_and_set_bit(FLG_PTP, addr: &l2->flag);
2138	if (test_bit(OPTION_L2_FIXEDTEI, &options))
2139	test_and_set_bit(FLG_FIXED_TEI, addr: &l2->flag);
2140	l2->tei = tei;
2141	l2->T200 = 1000;
2142	l2->N200 = 3;
2143	l2->T203 = 10000;
2144	if (test_bit(OPTION_L2_PMX, &options))
2145	rq.protocol = ISDN_P_NT_E1;
2146	else
2147	rq.protocol = ISDN_P_NT_S0;
2148	rq.adr.channel = 0;
2149	l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D, OPEN_CHANNEL, &rq);
2150	break;
2151	case ISDN_P_LAPD_TE:
2152	test_and_set_bit(FLG_LAPD, addr: &l2->flag);
2153	test_and_set_bit(FLG_MOD128, addr: &l2->flag);
2154	test_and_set_bit(FLG_ORIG, addr: &l2->flag);
2155	l2->sapi = sapi;
2156	l2->maxlen = MAX_DFRAME_LEN;
2157	if (test_bit(OPTION_L2_PMX, &options))
2158	l2->window = 7;
2159	else
2160	l2->window = 1;
2161	if (test_bit(OPTION_L2_PTP, &options))
2162	test_and_set_bit(FLG_PTP, addr: &l2->flag);
2163	if (test_bit(OPTION_L2_FIXEDTEI, &options))
2164	test_and_set_bit(FLG_FIXED_TEI, addr: &l2->flag);
2165	l2->tei = tei;
2166	l2->T200 = 1000;
2167	l2->N200 = 3;
2168	l2->T203 = 10000;
2169	if (test_bit(OPTION_L2_PMX, &options))
2170	rq.protocol = ISDN_P_TE_E1;
2171	else
2172	rq.protocol = ISDN_P_TE_S0;
2173	rq.adr.channel = 0;
2174	l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D, OPEN_CHANNEL, &rq);
2175	break;
2176	case ISDN_P_B_X75SLP:
2177	test_and_set_bit(FLG_LAPB, addr: &l2->flag);
2178	l2->window = 7;
2179	l2->maxlen = MAX_DATA_SIZE;
2180	l2->T200 = 1000;
2181	l2->N200 = 4;
2182	l2->T203 = 5000;
2183	l2->addr.A = 3;
2184	l2->addr.B = 1;
2185	break;
2186	default:
2187	printk(KERN_ERR "layer2 create failed prt %x\n",
2188	protocol);
2189	kfree(objp: l2);
2190	return NULL;
2191	}
2192	skb_queue_head_init(list: &l2->i_queue);
2193	skb_queue_head_init(list: &l2->ui_queue);
2194	skb_queue_head_init(list: &l2->down_queue);
2195	skb_queue_head_init(list: &l2->tmp_queue);
2196	InitWin(l2);
2197	l2->l2m.fsm = &l2fsm;
2198	if (test_bit(FLG_LAPB, &l2->flag) ||
2199	test_bit(FLG_FIXED_TEI, &l2->flag) ||
2200	test_bit(FLG_LAPD_NET, &l2->flag))
2201	l2->l2m.state = ST_L2_4;
2202	else
2203	l2->l2m.state = ST_L2_1;
2204	l2->l2m.debug = *debug;
2205	l2->l2m.userdata = l2;
2206	l2->l2m.userint = 0;
2207	l2->l2m.printdebug = l2m_debug;
2208
2209	mISDN_FsmInitTimer(&l2->l2m, &l2->t200);
2210	mISDN_FsmInitTimer(&l2->l2m, &l2->t203);
2211	return l2;
2212	}
2213
2214	static int
2215	x75create(struct channel_req *crq)
2216	{
2217	struct layer2 *l2;
2218
2219	if (crq->protocol != ISDN_P_B_X75SLP)
2220	return -EPROTONOSUPPORT;
2221	l2 = create_l2(ch: crq->ch, protocol: crq->protocol, options: 0, tei: 0, sapi: 0);
2222	if (!l2)
2223	return -ENOMEM;
2224	crq->ch = &l2->ch;
2225	crq->protocol = ISDN_P_B_HDLC;
2226	return 0;
2227	}
2228
2229	static struct Bprotocol X75SLP = {
2230	.Bprotocols = (1 << (ISDN_P_B_X75SLP & ISDN_P_B_MASK)),
2231	.name = "X75SLP",
2232	.create = x75create
2233	};
2234
2235	int
2236	Isdnl2_Init(u_int *deb)
2237	{
2238	int res;
2239	debug = deb;
2240	mISDN_register_Bprotocol(&X75SLP);
2241	l2fsm.state_count = L2_STATE_COUNT;
2242	l2fsm.event_count = L2_EVENT_COUNT;
2243	l2fsm.strEvent = strL2Event;
2244	l2fsm.strState = strL2State;
2245	res = mISDN_FsmNew(&l2fsm, L2FnList, ARRAY_SIZE(L2FnList));
2246	if (res)
2247	goto error;
2248	res = TEIInit(deb);
2249	if (res)
2250	goto error_fsm;
2251	return 0;
2252
2253	error_fsm:
2254	mISDN_FsmFree(&l2fsm);
2255	error:
2256	mISDN_unregister_Bprotocol(&X75SLP);
2257	return res;
2258	}
2259
2260	void
2261	Isdnl2_cleanup(void)
2262	{
2263	mISDN_unregister_Bprotocol(&X75SLP);
2264	TEIFree();
2265	mISDN_FsmFree(&l2fsm);
2266	}
2267