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
  15static u_int *debug;
  16
  17static
  18struct Fsm l2fsm = {NULL, 0, 0, NULL, NULL};
  19
  20static 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
  32enum {
  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
  61static 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
  89static void
  90l2m_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
 110inline u_int
 111l2headersize(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
 117inline u_int
 118l2addrsize(struct layer2 *l2)
 119{
 120	return test_bit(FLG_LAPD, &l2->flag) ? 2 : 1;
 121}
 122
 123static u_int
 124l2_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
 137static void
 138l2up(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
 154static void
 155l2up_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, 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
 179static int
 180l2down_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
 190static int
 191l2down_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, &l2->flag)) {
 197			skb_queue_tail(&l2->down_queue, skb);
 198			return 0;
 199		}
 200		l2->down_id = mISDN_HEAD_ID(skb);
 201	}
 202	return l2down_skb(l2, skb);
 203}
 204
 205static int
 206l2down(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
 215static int
 216l2down_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, arg, len);
 230	err = l2down_raw(l2, skb);
 231	if (err)
 232		dev_kfree_skb(skb);
 233	return err;
 234}
 235
 236static int
 237ph_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(&l2->down_queue);
 244			if (nskb) {
 245				l2->down_id = mISDN_HEAD_ID(nskb);
 246				if (l2down_skb(l2, 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, &l2->flag);
 258				mISDN_FsmEvent(&l2->l2m, EV_L2_ACK_PULL, NULL);
 259			}
 260		}
 261	}
 262	if (!test_and_set_bit(FLG_L1_NOTREADY, &l2->flag)) {
 263		nskb = skb_dequeue(&l2->down_queue);
 264		if (nskb) {
 265			l2->down_id = mISDN_HEAD_ID(nskb);
 266			if (l2down_skb(l2, nskb)) {
 267				dev_kfree_skb(nskb);
 268				l2->down_id = MISDN_ID_NONE;
 269				test_and_clear_bit(FLG_L1_NOTREADY, &l2->flag);
 270			}
 271		} else
 272			test_and_clear_bit(FLG_L1_NOTREADY, &l2->flag);
 273	}
 274	return ret;
 275}
 276
 277static void
 278l2_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(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
 302static int
 303l2mgr(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, (u_long)arg);
 316			break;
 317		}
 318	}
 319	return 0;
 320}
 321
 322static void
 323set_peer_busy(struct layer2 *l2) {
 324	test_and_set_bit(FLG_PEER_BUSY, &l2->flag);
 325	if (skb_queue_len(&l2->i_queue) || skb_queue_len(&l2->ui_queue))
 326		test_and_set_bit(FLG_L2BLOCK, &l2->flag);
 327}
 328
 329static void
 330clear_peer_busy(struct layer2 *l2) {
 331	if (test_and_clear_bit(FLG_PEER_BUSY, &l2->flag))
 332		test_and_clear_bit(FLG_L2BLOCK, &l2->flag);
 333}
 334
 335static void
 336InitWin(struct layer2 *l2)
 337{
 338	int i;
 339
 340	for (i = 0; i < MAX_WINDOW; i++)
 341		l2->windowar[i] = NULL;
 342}
 343
 344static int
 345freewin(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
 359static void
 360ReleaseWin(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
 369inline unsigned int
 370cansend(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
 381inline void
 382clear_exception(struct layer2 *l2)
 383{
 384	test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
 385	test_and_clear_bit(FLG_REJEXC, &l2->flag);
 386	test_and_clear_bit(FLG_OWN_BUSY, &l2->flag);
 387	clear_peer_busy(l2);
 388}
 389
 390static int
 391sethdraddr(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
 413static inline void
 414enqueue_super(struct layer2 *l2, struct sk_buff *skb)
 415{
 416	if (l2down(l2, PH_DATA_REQ, l2_newid(l2), skb))
 417		dev_kfree_skb(skb);
 418}
 419
 420static inline void
 421enqueue_ui(struct layer2 *l2, struct sk_buff *skb)
 422{
 423	if (l2->tm)
 424		l2_tei(l2, MDL_STATUS_UI_IND, 0);
 425	if (l2down(l2, PH_DATA_REQ, l2_newid(l2), skb))
 426		dev_kfree_skb(skb);
 427}
 428
 429inline int
 430IsUI(u_char *data)
 431{
 432	return (data[0] & 0xef) == UI;
 433}
 434
 435inline int
 436IsUA(u_char *data)
 437{
 438	return (data[0] & 0xef) == UA;
 439}
 440
 441inline int
 442IsDM(u_char *data)
 443{
 444	return (data[0] & 0xef) == DM;
 445}
 446
 447inline int
 448IsDISC(u_char *data)
 449{
 450	return (data[0] & 0xef) == DISC;
 451}
 452
 453inline int
 454IsRR(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
 462inline int
 463IsSFrame(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
 472inline int
 473IsSABME(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
 480inline int
 481IsREJ(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
 487inline int
 488IsFRMR(u_char *data)
 489{
 490	return (data[0] & 0xef) == FRMR;
 491}
 492
 493inline int
 494IsRNR(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
 500static int
 501iframe_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
 518static int
 519super_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
 527static int
 528unnum_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
 540static int
 541UI_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
 553static int
 554FRMR_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(&l2->l2m,
 569				  "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(&l2->l2m,
 576				  "FRMR information %2x %2x %2x",
 577				  datap[0], datap[1], datap[2]);
 578	}
 579	return 0;
 580}
 581
 582static unsigned int
 583legalnr(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
 591static void
 592setva(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(l2->windowar[l2->sow], 0);
 604			skb_queue_tail(&l2->tmp_queue, l2->windowar[l2->sow]);
 605			l2->windowar[l2->sow] = NULL;
 606		}
 607		l2->sow = (l2->sow + 1) % l2->window;
 608	}
 609	skb = skb_dequeue(&l2->tmp_queue);
 610	while (skb) {
 611		dev_kfree_skb(skb);
 612		skb = skb_dequeue(&l2->tmp_queue);
 613	}
 614}
 615
 616static void
 617send_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, tmp, cr);
 623	tmp[i++] = cmd;
 624	if (skb)
 625		skb_trim(skb, 0);
 626	else {
 627		skb = mI_alloc_skb(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, tmp, i);
 635	enqueue_super(l2, skb);
 636}
 637
 638
 639inline u_char
 640get_PollFlag(struct layer2 *l2, struct sk_buff *skb)
 641{
 642	return skb->data[l2addrsize(l2)] & 0x10;
 643}
 644
 645inline u_char
 646get_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
 655inline void
 656start_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, &l2->flag);
 660}
 661
 662inline void
 663restart_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, &l2->flag);
 667}
 668
 669inline void
 670stop_t200(struct layer2 *l2, int i)
 671{
 672	if (test_and_clear_bit(FLG_T200_RUN, &l2->flag))
 673		mISDN_FsmDelTimer(&l2->t200, i);
 674}
 675
 676inline void
 677st5_dl_release_l2l3(struct layer2 *l2)
 678{
 679	int pr;
 680
 681	if (test_and_clear_bit(FLG_PEND_REL, &l2->flag))
 682		pr = DL_RELEASE_CNF;
 683	else
 684		pr = DL_RELEASE_IND;
 685	l2up_create(l2, pr, 0, NULL);
 686}
 687
 688inline void
 689lapb_dl_release_l2l3(struct layer2 *l2, int f)
 690{
 691	if (test_bit(FLG_LAPB, &l2->flag))
 692		l2down_create(l2, PH_DEACTIVATE_REQ, l2_newid(l2), 0, NULL);
 693	l2up_create(l2, f, 0, NULL);
 694}
 695
 696static void
 697establishlink(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, 1);
 708	test_and_clear_bit(FLG_PEND_REL, &l2->flag);
 709	freewin(l2);
 710	mISDN_FsmChangeState(fi, ST_L2_5);
 711}
 712
 713static void
 714l2_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, (void *) 'C');
 721	else
 722		l2mgr(l2, MDL_ERROR_IND, (void *) 'D');
 723
 724}
 725
 726static void
 727l2_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, (void *) 'B');
 734	else {
 735		l2mgr(l2, MDL_ERROR_IND, (void *) 'E');
 736		establishlink(fi);
 737		test_and_clear_bit(FLG_L3_INIT, &l2->flag);
 738	}
 739}
 740
 741static void
 742l2_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, (void *) 'B');
 749	else
 750		l2mgr(l2, MDL_ERROR_IND, (void *) 'E');
 751	establishlink(fi);
 752	test_and_clear_bit(FLG_L3_INIT, &l2->flag);
 753}
 754
 755static void
 756l2_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
 762static void
 763l2_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, 0);
 770}
 771
 772static void
 773l2_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(&l2->ui_queue, skb);
 779	mISDN_FsmChangeState(fi, ST_L2_2);
 780	l2_tei(l2, MDL_ASSIGN_IND, 0);
 781}
 782
 783static void
 784l2_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(&l2->ui_queue, skb);
 790}
 791
 792static void
 793tx_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(&l2->ui_queue))) {
 804		memcpy(skb_push(skb, i), header, i);
 805		enqueue_ui(l2, skb);
 806	}
 807}
 808
 809static void
 810l2_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(&l2->ui_queue, skb);
 816	tx_ui(l2);
 817}
 818
 819static void
 820l2_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, l2headersize(l2, 1));
 826/*
 827 *		in states 1-3 for broadcast
 828 */
 829
 830	if (l2->tm)
 831		l2_tei(l2, MDL_STATUS_UI_IND, 0);
 832	l2up(l2, DL_UNITDATA_IND, skb);
 833}
 834
 835static void
 836l2_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, &l2->flag);
 843	dev_kfree_skb(skb);
 844}
 845
 846static void
 847l2_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(&l2->i_queue);
 853	test_and_set_bit(FLG_L3_INIT, &l2->flag);
 854	test_and_clear_bit(FLG_PEND_REL, &l2->flag);
 855	dev_kfree_skb(skb);
 856}
 857
 858static void
 859l2_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(&l2->i_queue);
 865	establishlink(fi);
 866	test_and_set_bit(FLG_L3_INIT, &l2->flag);
 867	dev_kfree_skb(skb);
 868}
 869
 870static void
 871l2_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, 0);
 877	l2up(l2, DL_RELEASE_CNF, skb);
 878}
 879
 880static void
 881l2_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, &l2->flag);
 887	dev_kfree_skb(skb);
 888}
 889
 890static void
 891l2_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(&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, 2);
 903	dev_kfree_skb(skb);
 904}
 905
 906static void
 907l2_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, 0);
 921	l2up(l2, DL_ESTABLISH_IND, skb);
 922	if (l2->tm)
 923		l2_tei(l2, MDL_STATUS_UP_IND, 0);
 924}
 925
 926static void
 927l2_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
 935static void
 936l2_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
 944static void
 945l2_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, (void *) 'F');
 954
 955	if (l2->vs != l2->va) {
 956		skb_queue_purge(&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, 3);
 967	mISDN_FsmRestartTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 3);
 968
 969	if (est)
 970		l2up_create(l2, DL_ESTABLISH_IND, 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(&l2->i_queue) && cansend(l2))
 976		mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
 977}
 978
 979static void
 980l2_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, 4);
 988
 989	send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
 990	skb_queue_purge(&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, 0);
 995}
 996
 997static void
 998l2_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, &l2->flag))
1010		l2_disconnect(fi, event, NULL);
1011	if (test_and_clear_bit(FLG_L3_INIT, &l2->flag)) {
1012		pr = DL_ESTABLISH_CNF;
1013	} else if (l2->vs != l2->va) {
1014		skb_queue_purge(&l2->i_queue);
1015		pr = DL_ESTABLISH_IND;
1016	}
1017	stop_t200(l2, 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, pr, 0, NULL);
1026
1027	if (skb_queue_len(&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, 0);
1032}
1033
1034static void
1035l2_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, 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, 0);
1050}
1051
1052static void
1053l2_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, &l2->flag);
1061	}
1062}
1063
1064static void
1065l2_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, 7);
1072		if (!test_bit(FLG_L3_INIT, &l2->flag))
1073			skb_queue_purge(&l2->i_queue);
1074		if (test_bit(FLG_LAPB, &l2->flag))
1075			l2down_create(l2, PH_DEACTIVATE_REQ,
1076				      l2_newid(l2), 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, 0);
1081	}
1082}
1083
1084static void
1085l2_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, 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, 0);
1096	}
1097}
1098
1099static void
1100enquiry_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, tmp, 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(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, tmp, i);
1119	enqueue_super(l2, skb);
1120}
1121
1122inline void
1123enquiry_response(struct layer2 *l2)
1124{
1125	if (test_bit(FLG_OWN_BUSY, &l2->flag))
1126		enquiry_cr(l2, RNR, RSP, 1);
1127	else
1128		enquiry_cr(l2, RR, RSP, 1);
1129	test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1130}
1131
1132inline void
1133transmit_enquiry(struct layer2 *l2)
1134{
1135	if (test_bit(FLG_OWN_BUSY, &l2->flag))
1136		enquiry_cr(l2, RNR, CMD, 1);
1137	else
1138		enquiry_cr(l2, RR, CMD, 1);
1139	test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1140	start_t200(l2, 9);
1141}
1142
1143
1144static void
1145nrerrorrecovery(struct FsmInst *fi)
1146{
1147	struct layer2 *l2 = fi->userdata;
1148
1149	l2mgr(l2, MDL_ERROR_IND, (void *) 'J');
1150	establishlink(fi);
1151	test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1152}
1153
1154static void
1155invoke_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(&l2->i_queue, 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
1182static void
1183l2_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, l2addrsize(l2));
1195	if (IsRNR(skb->data, l2)) {
1196		set_peer_busy(l2);
1197		typ = RNR;
1198	} else
1199		clear_peer_busy(l2);
1200	if (IsREJ(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, (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, 10);
1223			if (mISDN_FsmAddTimer(&l2->t203, l2->T203,
1224					      EV_L2_T203, NULL, 6))
1225				l2m_debug(&l2->l2m, "Restart T203 ST7 REJ");
1226		} else if ((nr == l2->vs) && (typ == RR)) {
1227			setva(l2, nr);
1228			stop_t200(l2, 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, 12);
1236		}
1237		if (skb_queue_len(&l2->i_queue) && (typ == RR))
1238			mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1239	} else
1240		nrerrorrecovery(fi);
1241}
1242
1243static void
1244l2_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(&l2->i_queue, skb);
1251	else
1252		dev_kfree_skb(skb);
1253}
1254
1255static void
1256l2_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(&l2->i_queue, skb);
1262	mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1263}
1264
1265static void
1266l2_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(&l2->i_queue, skb);
1272}
1273
1274static void
1275l2_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, &l2->flag);
1304			if (PollFlag)
1305				enquiry_response(l2);
1306			else
1307				test_and_set_bit(FLG_ACK_PEND, &l2->flag);
1308			skb_pull(skb, l2headersize(l2, 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, &l2->flag)) {
1314				if (PollFlag)
1315					enquiry_response(l2);
1316			} else {
1317				enquiry_cr(l2, REJ, RSP, PollFlag);
1318				test_and_clear_bit(FLG_ACK_PEND, &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, 13);
1327				mISDN_FsmRestartTimer(&l2->t203, l2->T203,
1328						      EV_L2_T203, NULL, 7);
1329			} else if (nr != l2->va)
1330				restart_t200(l2, 14);
1331		}
1332		setva(l2, nr);
1333	} else {
1334		nrerrorrecovery(fi);
1335		return;
1336	}
1337	if (skb_queue_len(&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, &l2->flag))
1340		enquiry_cr(l2, RR, RSP, 0);
1341}
1342
1343static void
1344l2_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, sizeof(info), &info);
1353	if (fi->state == ST_L2_3) {
1354		establishlink(fi);
1355		test_and_set_bit(FLG_L3_INIT, &l2->flag);
1356	} else
1357		mISDN_FsmChangeState(fi, ST_L2_4);
1358	if (skb_queue_len(&l2->ui_queue))
1359		tx_ui(l2);
1360}
1361
1362static void
1363l2_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, &l2->flag);
1373		skb_queue_purge(&l2->i_queue);
1374		l2mgr(l2, MDL_ERROR_IND, (void *) 'G');
1375		if (test_bit(FLG_LAPB, &l2->flag))
1376			l2down_create(l2, PH_DEACTIVATE_REQ,
1377				      l2_newid(l2), 0, NULL);
1378		st5_dl_release_l2l3(l2);
1379		if (l2->tm)
1380			l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1381	} else {
1382		l2->rc++;
1383		mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1384		send_uframe(l2, NULL, (test_bit(FLG_MOD128, &l2->flag) ?
1385				       SABME : SABM) | 0x10, CMD);
1386	}
1387}
1388
1389static void
1390l2_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, &l2->flag);
1400		l2mgr(l2, MDL_ERROR_IND, (void *) 'H');
1401		lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1402		if (l2->tm)
1403			l2_tei(l2, MDL_STATUS_DOWN_IND, 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
1412static void
1413l2_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, &l2->flag);
1423	l2->rc = 0;
1424	mISDN_FsmChangeState(fi, ST_L2_8);
1425	transmit_enquiry(l2);
1426	l2->rc++;
1427}
1428
1429static void
1430l2_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, &l2->flag);
1440	if (l2->rc == l2->N200) {
1441		l2mgr(l2, MDL_ERROR_IND, (void *) 'I');
1442		establishlink(fi);
1443		test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1444	} else {
1445		transmit_enquiry(l2);
1446		l2->rc++;
1447	}
1448}
1449
1450static void
1451l2_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
1465static void
1466l2_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(&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, 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(&l2->i_queue, 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, l2_newid(l2), nskb);
1508	test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1509	if (!test_and_set_bit(FLG_T200_RUN, &l2->flag)) {
1510		mISDN_FsmDelTimer(&l2->t203, 13);
1511		mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 11);
1512	}
1513}
1514
1515static void
1516l2_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, l2addrsize(l2));
1528
1529	if (IsRNR(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, 15);
1547			} else {
1548				stop_t200(l2, 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(&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
1569static void
1570l2_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, l2addrsize(l2) + 1);
1576
1577	if (!(skb->data[0] & 1) || ((skb->data[0] & 3) == 1) || /* I or S */
1578	    (IsUA(skb->data) && (fi->state == ST_L2_7))) {
1579		l2mgr(l2, MDL_ERROR_IND, (void *) 'K');
1580		establishlink(fi);
1581		test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1582	}
1583	dev_kfree_skb(skb);
1584}
1585
1586static void
1587l2_st24_tei_remove(struct FsmInst *fi, int event, void *arg)
1588{
1589	struct layer2 *l2 = fi->userdata;
1590
1591	skb_queue_purge(&l2->ui_queue);
1592	l2->tei = GROUP_TEI;
1593	mISDN_FsmChangeState(fi, ST_L2_1);
1594}
1595
1596static void
1597l2_st3_tei_remove(struct FsmInst *fi, int event, void *arg)
1598{
1599	struct layer2 *l2 = fi->userdata;
1600
1601	skb_queue_purge(&l2->ui_queue);
1602	l2->tei = GROUP_TEI;
1603	l2up_create(l2, DL_RELEASE_IND, 0, NULL);
1604	mISDN_FsmChangeState(fi, ST_L2_1);
1605}
1606
1607static void
1608l2_st5_tei_remove(struct FsmInst *fi, int event, void *arg)
1609{
1610	struct layer2 *l2 = fi->userdata;
1611
1612	skb_queue_purge(&l2->i_queue);
1613	skb_queue_purge(&l2->ui_queue);
1614	freewin(l2);
1615	l2->tei = GROUP_TEI;
1616	stop_t200(l2, 17);
1617	st5_dl_release_l2l3(l2);
1618	mISDN_FsmChangeState(fi, ST_L2_1);
1619}
1620
1621static void
1622l2_st6_tei_remove(struct FsmInst *fi, int event, void *arg)
1623{
1624	struct layer2 *l2 = fi->userdata;
1625
1626	skb_queue_purge(&l2->ui_queue);
1627	l2->tei = GROUP_TEI;
1628	stop_t200(l2, 18);
1629	l2up_create(l2, DL_RELEASE_IND, 0, NULL);
1630	mISDN_FsmChangeState(fi, ST_L2_1);
1631}
1632
1633static void
1634l2_tei_remove(struct FsmInst *fi, int event, void *arg)
1635{
1636	struct layer2 *l2 = fi->userdata;
1637
1638	skb_queue_purge(&l2->i_queue);
1639	skb_queue_purge(&l2->ui_queue);
1640	freewin(l2);
1641	l2->tei = GROUP_TEI;
1642	stop_t200(l2, 17);
1643	mISDN_FsmDelTimer(&l2->t203, 19);
1644	l2up_create(l2, DL_RELEASE_IND, 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
1652static void
1653l2_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(&l2->i_queue);
1659	skb_queue_purge(&l2->ui_queue);
1660	if (test_and_clear_bit(FLG_ESTAB_PEND, &l2->flag))
1661		l2up(l2, DL_RELEASE_IND, skb);
1662	else
1663		dev_kfree_skb(skb);
1664}
1665
1666static void
1667l2_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(&l2->i_queue);
1673	skb_queue_purge(&l2->ui_queue);
1674	freewin(l2);
1675	stop_t200(l2, 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, 0);
1680	dev_kfree_skb(skb);
1681}
1682
1683static void
1684l2_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(&l2->ui_queue);
1690	stop_t200(l2, 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, 0);
1695}
1696
1697static void
1698l2_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(&l2->i_queue);
1704	skb_queue_purge(&l2->ui_queue);
1705	freewin(l2);
1706	stop_t200(l2, 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, 0);
1712}
1713
1714static void
1715l2_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, &l2->flag)) {
1721		enquiry_cr(l2, RNR, RSP, 0);
1722		test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1723	}
1724	dev_kfree_skb(skb);
1725}
1726
1727static void
1728l2_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, &l2->flag)) {
1734		enquiry_cr(l2, RR, RSP, 0);
1735		test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1736	}
1737	dev_kfree_skb(skb);
1738}
1739
1740static void
1741l2_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
1748static void
1749l2_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, &l2->flag);
1756}
1757
1758static 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
1855static int
1856ph_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(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(datap)) {
1908		c = UI_error(l2, skb);
1909		if (!c)
1910			ret = mISDN_FsmEvent(&l2->l2m, EV_L2_UI, skb);
1911	} else if (IsSABME(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(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(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(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(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
1941static int
1942l2_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, &l2->flag);
1969		l2up_create(l2, MPH_ACTIVATE_IND, 0, NULL);
1970		if (test_and_clear_bit(FLG_ESTAB_PEND, &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, &l2->flag);
1976		l2up_create(l2, MPH_DEACTIVATE_IND, 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, &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						 &l2->flag);
2003			}
2004			ret = l2down(l2, PH_ACTIVATE_REQ, 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				      l2_newid(l2), 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(&l2->l2m, "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
2033int
2034tei_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
2061static void
2062release_l2(struct layer2 *l2)
2063{
2064	mISDN_FsmDelTimer(&l2->t200, 21);
2065	mISDN_FsmDelTimer(&l2->t203, 16);
2066	skb_queue_purge(&l2->i_queue);
2067	skb_queue_purge(&l2->ui_queue);
2068	skb_queue_purge(&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(l2);
2077}
2078
2079static int
2080l2_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				    sizeof(info), &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
2107struct layer2 *
2108create_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(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, &l2->flag);
2128		test_and_set_bit(FLG_LAPD_NET, &l2->flag);
2129		test_and_set_bit(FLG_MOD128, &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, &l2->flag);
2138		if (test_bit(OPTION_L2_FIXEDTEI, &options))
2139			test_and_set_bit(FLG_FIXED_TEI, &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, &l2->flag);
2153		test_and_set_bit(FLG_MOD128, &l2->flag);
2154		test_and_set_bit(FLG_ORIG, &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, &l2->flag);
2163		if (test_bit(OPTION_L2_FIXEDTEI, &options))
2164			test_and_set_bit(FLG_FIXED_TEI, &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, &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(l2);
2190		return NULL;
2191	}
2192	skb_queue_head_init(&l2->i_queue);
2193	skb_queue_head_init(&l2->ui_queue);
2194	skb_queue_head_init(&l2->down_queue);
2195	skb_queue_head_init(&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
2214static int
2215x75create(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(crq->ch, crq->protocol, 0, 0, 0);
2222	if (!l2)
2223		return -ENOMEM;
2224	crq->ch = &l2->ch;
2225	crq->protocol = ISDN_P_B_HDLC;
2226	return 0;
2227}
2228
2229static struct Bprotocol X75SLP = {
2230	.Bprotocols = (1 << (ISDN_P_B_X75SLP & ISDN_P_B_MASK)),
2231	.name = "X75SLP",
2232	.create = x75create
2233};
2234
2235int
2236Isdnl2_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
2253error_fsm:
2254	mISDN_FsmFree(&l2fsm);
2255error:
2256	mISDN_unregister_Bprotocol(&X75SLP);
2257	return res;
2258}
2259
2260void
2261Isdnl2_cleanup(void)
2262{
2263	mISDN_unregister_Bprotocol(&X75SLP);
2264	TEIFree();
2265	mISDN_FsmFree(&l2fsm);
2266}