drivers/isdn/mISDN/layer2.c

   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, 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, &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
 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, 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(&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
 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(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, (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, &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
 329 static void
 330 clear_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
 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, &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
 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, 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, 0);
 425         if (l2down(l2, PH_DATA_REQ, 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(&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
 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(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
 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, 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
 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, &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, &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, &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, &l2->flag))
 682                 pr = DL_RELEASE_CNF;
 683         else
 684                 pr = DL_RELEASE_IND;
 685         l2up_create(l2, pr, 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, l2_newid(l2), 0, NULL);
 693         l2up_create(l2, f, 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, 1);
 708         test_and_clear_bit(FLG_PEND_REL, &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, (void *) 'C');
 721         else
 722                 l2mgr(l2, MDL_ERROR_IND, (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, (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
 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, (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
 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, 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(&l2->ui_queue, skb);
 779         mISDN_FsmChangeState(fi, ST_L2_2);
 780         l2_tei(l2, MDL_ASSIGN_IND, 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(&l2->ui_queue, 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(&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(&l2->ui_queue, 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, 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
 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, &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(&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
 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(&l2->i_queue);
 865         establishlink(fi);
 866         test_and_set_bit(FLG_L3_INIT, &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, 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, &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(&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
 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, 0);
 921         l2up(l2, DL_ESTABLISH_IND, skb);
 922         if (l2->tm)
 923                 l2_tei(l2, MDL_STATUS_UP_IND, 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, (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
 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, 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
 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, &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
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, 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
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, &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, 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
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, 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
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, 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
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, 1);
1127         else
1128                 enquiry_cr(l2, RR, RSP, 1);
1129         test_and_clear_bit(FLG_ACK_PEND, &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, 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
1144 static void
1145 nrerrorrecovery(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
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(&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
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, 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
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(&l2->i_queue, 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(&l2->i_queue, 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(&l2->i_queue, 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, &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
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, 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
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, &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
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, &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
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, &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, &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
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(&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
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, 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
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, 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
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(&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(&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
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(&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
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(&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
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(&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
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(&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
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(&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
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(&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
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(&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
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, &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
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, &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
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, &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(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
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, &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
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(&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
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                                     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
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(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
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(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
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 }