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         if (skb)
 904                 dev_kfree_skb(skb);
 905 }
 906
 907 static void
 908 l2_start_multi(struct FsmInst *fi, int event, void *arg)
 909 {
 910         struct layer2   *l2 = fi->userdata;
 911         struct sk_buff  *skb = arg;
 912
 913         l2->vs = 0;
 914         l2->va = 0;
 915         l2->vr = 0;
 916         l2->sow = 0;
 917         clear_exception(l2);
 918         send_uframe(l2, NULL, UA | get_PollFlag(l2, skb), RSP);
 919         mISDN_FsmChangeState(fi, ST_L2_7);
 920         mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 3);
 921         skb_trim(skb, 0);
 922         l2up(l2, DL_ESTABLISH_IND, skb);
 923         if (l2->tm)
 924                 l2_tei(l2, MDL_STATUS_UP_IND, 0);
 925 }
 926
 927 static void
 928 l2_send_UA(struct FsmInst *fi, int event, void *arg)
 929 {
 930         struct layer2 *l2 = fi->userdata;
 931         struct sk_buff *skb = arg;
 932
 933         send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
 934 }
 935
 936 static void
 937 l2_send_DM(struct FsmInst *fi, int event, void *arg)
 938 {
 939         struct layer2 *l2 = fi->userdata;
 940         struct sk_buff *skb = arg;
 941
 942         send_uframe(l2, skb, DM | get_PollFlag(l2, skb), RSP);
 943 }
 944
 945 static void
 946 l2_restart_multi(struct FsmInst *fi, int event, void *arg)
 947 {
 948         struct layer2   *l2 = fi->userdata;
 949         struct sk_buff  *skb = arg;
 950         int             est = 0;
 951
 952         send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
 953
 954         l2mgr(l2, MDL_ERROR_IND, (void *) 'F');
 955
 956         if (l2->vs != l2->va) {
 957                 skb_queue_purge(&l2->i_queue);
 958                 est = 1;
 959         }
 960
 961         clear_exception(l2);
 962         l2->vs = 0;
 963         l2->va = 0;
 964         l2->vr = 0;
 965         l2->sow = 0;
 966         mISDN_FsmChangeState(fi, ST_L2_7);
 967         stop_t200(l2, 3);
 968         mISDN_FsmRestartTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 3);
 969
 970         if (est)
 971                 l2up_create(l2, DL_ESTABLISH_IND, 0, NULL);
 972 /*              mISDN_queue_data(&l2->inst, l2->inst.id | MSG_BROADCAST,
 973  *                  MGR_SHORTSTATUS | INDICATION, SSTATUS_L2_ESTABLISHED,
 974  *                  0, NULL, 0);
 975  */
 976         if (skb_queue_len(&l2->i_queue) && cansend(l2))
 977                 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
 978 }
 979
 980 static void
 981 l2_stop_multi(struct FsmInst *fi, int event, void *arg)
 982 {
 983         struct layer2   *l2 = fi->userdata;
 984         struct sk_buff  *skb = arg;
 985
 986         mISDN_FsmChangeState(fi, ST_L2_4);
 987         mISDN_FsmDelTimer(&l2->t203, 3);
 988         stop_t200(l2, 4);
 989
 990         send_uframe(l2, skb, UA | get_PollFlag(l2, skb), RSP);
 991         skb_queue_purge(&l2->i_queue);
 992         freewin(l2);
 993         lapb_dl_release_l2l3(l2, DL_RELEASE_IND);
 994         if (l2->tm)
 995                 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
 996 }
 997
 998 static void
 999 l2_connected(struct FsmInst *fi, int event, void *arg)
1000 {
1001         struct layer2   *l2 = fi->userdata;
1002         struct sk_buff  *skb = arg;
1003         int pr = -1;
1004
1005         if (!get_PollFlag(l2, skb)) {
1006                 l2_mdl_error_ua(fi, event, arg);
1007                 return;
1008         }
1009         dev_kfree_skb(skb);
1010         if (test_and_clear_bit(FLG_PEND_REL, &l2->flag))
1011                 l2_disconnect(fi, event, NULL);
1012         if (test_and_clear_bit(FLG_L3_INIT, &l2->flag)) {
1013                 pr = DL_ESTABLISH_CNF;
1014         } else if (l2->vs != l2->va) {
1015                 skb_queue_purge(&l2->i_queue);
1016                 pr = DL_ESTABLISH_IND;
1017         }
1018         stop_t200(l2, 5);
1019         l2->vr = 0;
1020         l2->vs = 0;
1021         l2->va = 0;
1022         l2->sow = 0;
1023         mISDN_FsmChangeState(fi, ST_L2_7);
1024         mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 4);
1025         if (pr != -1)
1026                 l2up_create(l2, pr, 0, NULL);
1027
1028         if (skb_queue_len(&l2->i_queue) && cansend(l2))
1029                 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1030
1031         if (l2->tm)
1032                 l2_tei(l2, MDL_STATUS_UP_IND, 0);
1033 }
1034
1035 static void
1036 l2_released(struct FsmInst *fi, int event, void *arg)
1037 {
1038         struct layer2 *l2 = fi->userdata;
1039         struct sk_buff *skb = arg;
1040
1041         if (!get_PollFlag(l2, skb)) {
1042                 l2_mdl_error_ua(fi, event, arg);
1043                 return;
1044         }
1045         dev_kfree_skb(skb);
1046         stop_t200(l2, 6);
1047         lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1048         mISDN_FsmChangeState(fi, ST_L2_4);
1049         if (l2->tm)
1050                 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1051 }
1052
1053 static void
1054 l2_reestablish(struct FsmInst *fi, int event, void *arg)
1055 {
1056         struct layer2 *l2 = fi->userdata;
1057         struct sk_buff *skb = arg;
1058
1059         if (!get_PollFlagFree(l2, skb)) {
1060                 establishlink(fi);
1061                 test_and_set_bit(FLG_L3_INIT, &l2->flag);
1062         }
1063 }
1064
1065 static void
1066 l2_st5_dm_release(struct FsmInst *fi, int event, void *arg)
1067 {
1068         struct layer2 *l2 = fi->userdata;
1069         struct sk_buff *skb = arg;
1070
1071         if (get_PollFlagFree(l2, skb)) {
1072                 stop_t200(l2, 7);
1073                 if (!test_bit(FLG_L3_INIT, &l2->flag))
1074                         skb_queue_purge(&l2->i_queue);
1075                 if (test_bit(FLG_LAPB, &l2->flag))
1076                         l2down_create(l2, PH_DEACTIVATE_REQ,
1077                                       l2_newid(l2), 0, NULL);
1078                 st5_dl_release_l2l3(l2);
1079                 mISDN_FsmChangeState(fi, ST_L2_4);
1080                 if (l2->tm)
1081                         l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1082         }
1083 }
1084
1085 static void
1086 l2_st6_dm_release(struct FsmInst *fi, int event, void *arg)
1087 {
1088         struct layer2 *l2 = fi->userdata;
1089         struct sk_buff *skb = arg;
1090
1091         if (get_PollFlagFree(l2, skb)) {
1092                 stop_t200(l2, 8);
1093                 lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1094                 mISDN_FsmChangeState(fi, ST_L2_4);
1095                 if (l2->tm)
1096                         l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1097         }
1098 }
1099
1100 static void
1101 enquiry_cr(struct layer2 *l2, u_char typ, u_char cr, u_char pf)
1102 {
1103         struct sk_buff *skb;
1104         u_char tmp[MAX_L2HEADER_LEN];
1105         int i;
1106
1107         i = sethdraddr(l2, tmp, cr);
1108         if (test_bit(FLG_MOD128, &l2->flag)) {
1109                 tmp[i++] = typ;
1110                 tmp[i++] = (l2->vr << 1) | (pf ? 1 : 0);
1111         } else
1112                 tmp[i++] = (l2->vr << 5) | typ | (pf ? 0x10 : 0);
1113         skb = mI_alloc_skb(i, GFP_ATOMIC);
1114         if (!skb) {
1115                 printk(KERN_WARNING "%s: isdnl2 can't alloc sbbuff in %s\n",
1116                        mISDNDevName4ch(&l2->ch), __func__);
1117                 return;
1118         }
1119         skb_put_data(skb, tmp, i);
1120         enqueue_super(l2, skb);
1121 }
1122
1123 inline void
1124 enquiry_response(struct layer2 *l2)
1125 {
1126         if (test_bit(FLG_OWN_BUSY, &l2->flag))
1127                 enquiry_cr(l2, RNR, RSP, 1);
1128         else
1129                 enquiry_cr(l2, RR, RSP, 1);
1130         test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1131 }
1132
1133 inline void
1134 transmit_enquiry(struct layer2 *l2)
1135 {
1136         if (test_bit(FLG_OWN_BUSY, &l2->flag))
1137                 enquiry_cr(l2, RNR, CMD, 1);
1138         else
1139                 enquiry_cr(l2, RR, CMD, 1);
1140         test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1141         start_t200(l2, 9);
1142 }
1143
1144
1145 static void
1146 nrerrorrecovery(struct FsmInst *fi)
1147 {
1148         struct layer2 *l2 = fi->userdata;
1149
1150         l2mgr(l2, MDL_ERROR_IND, (void *) 'J');
1151         establishlink(fi);
1152         test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1153 }
1154
1155 static void
1156 invoke_retransmission(struct layer2 *l2, unsigned int nr)
1157 {
1158         u_int   p1;
1159
1160         if (l2->vs != nr) {
1161                 while (l2->vs != nr) {
1162                         (l2->vs)--;
1163                         if (test_bit(FLG_MOD128, &l2->flag)) {
1164                                 l2->vs %= 128;
1165                                 p1 = (l2->vs - l2->va) % 128;
1166                         } else {
1167                                 l2->vs %= 8;
1168                                 p1 = (l2->vs - l2->va) % 8;
1169                         }
1170                         p1 = (p1 + l2->sow) % l2->window;
1171                         if (l2->windowar[p1])
1172                                 skb_queue_head(&l2->i_queue, l2->windowar[p1]);
1173                         else
1174                                 printk(KERN_WARNING
1175                                        "%s: windowar[%d] is NULL\n",
1176                                        mISDNDevName4ch(&l2->ch), p1);
1177                         l2->windowar[p1] = NULL;
1178                 }
1179                 mISDN_FsmEvent(&l2->l2m, EV_L2_ACK_PULL, NULL);
1180         }
1181 }
1182
1183 static void
1184 l2_st7_got_super(struct FsmInst *fi, int event, void *arg)
1185 {
1186         struct layer2 *l2 = fi->userdata;
1187         struct sk_buff *skb = arg;
1188         int PollFlag, rsp, typ = RR;
1189         unsigned int nr;
1190
1191         rsp = *skb->data & 0x2;
1192         if (test_bit(FLG_ORIG, &l2->flag))
1193                 rsp = !rsp;
1194
1195         skb_pull(skb, l2addrsize(l2));
1196         if (IsRNR(skb->data, l2)) {
1197                 set_peer_busy(l2);
1198                 typ = RNR;
1199         } else
1200                 clear_peer_busy(l2);
1201         if (IsREJ(skb->data, l2))
1202                 typ = REJ;
1203
1204         if (test_bit(FLG_MOD128, &l2->flag)) {
1205                 PollFlag = (skb->data[1] & 0x1) == 0x1;
1206                 nr = skb->data[1] >> 1;
1207         } else {
1208                 PollFlag = (skb->data[0] & 0x10);
1209                 nr = (skb->data[0] >> 5) & 0x7;
1210         }
1211         dev_kfree_skb(skb);
1212
1213         if (PollFlag) {
1214                 if (rsp)
1215                         l2mgr(l2, MDL_ERROR_IND, (void *) 'A');
1216                 else
1217                         enquiry_response(l2);
1218         }
1219         if (legalnr(l2, nr)) {
1220                 if (typ == REJ) {
1221                         setva(l2, nr);
1222                         invoke_retransmission(l2, nr);
1223                         stop_t200(l2, 10);
1224                         if (mISDN_FsmAddTimer(&l2->t203, l2->T203,
1225                                               EV_L2_T203, NULL, 6))
1226                                 l2m_debug(&l2->l2m, "Restart T203 ST7 REJ");
1227                 } else if ((nr == l2->vs) && (typ == RR)) {
1228                         setva(l2, nr);
1229                         stop_t200(l2, 11);
1230                         mISDN_FsmRestartTimer(&l2->t203, l2->T203,
1231                                               EV_L2_T203, NULL, 7);
1232                 } else if ((l2->va != nr) || (typ == RNR)) {
1233                         setva(l2, nr);
1234                         if (typ != RR)
1235                                 mISDN_FsmDelTimer(&l2->t203, 9);
1236                         restart_t200(l2, 12);
1237                 }
1238                 if (skb_queue_len(&l2->i_queue) && (typ == RR))
1239                         mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1240         } else
1241                 nrerrorrecovery(fi);
1242 }
1243
1244 static void
1245 l2_feed_i_if_reest(struct FsmInst *fi, int event, void *arg)
1246 {
1247         struct layer2 *l2 = fi->userdata;
1248         struct sk_buff *skb = arg;
1249
1250         if (!test_bit(FLG_L3_INIT, &l2->flag))
1251                 skb_queue_tail(&l2->i_queue, skb);
1252         else
1253                 dev_kfree_skb(skb);
1254 }
1255
1256 static void
1257 l2_feed_i_pull(struct FsmInst *fi, int event, void *arg)
1258 {
1259         struct layer2 *l2 = fi->userdata;
1260         struct sk_buff *skb = arg;
1261
1262         skb_queue_tail(&l2->i_queue, skb);
1263         mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1264 }
1265
1266 static void
1267 l2_feed_iqueue(struct FsmInst *fi, int event, void *arg)
1268 {
1269         struct layer2 *l2 = fi->userdata;
1270         struct sk_buff *skb = arg;
1271
1272         skb_queue_tail(&l2->i_queue, skb);
1273 }
1274
1275 static void
1276 l2_got_iframe(struct FsmInst *fi, int event, void *arg)
1277 {
1278         struct layer2   *l2 = fi->userdata;
1279         struct sk_buff  *skb = arg;
1280         int             PollFlag, i;
1281         u_int           ns, nr;
1282
1283         i = l2addrsize(l2);
1284         if (test_bit(FLG_MOD128, &l2->flag)) {
1285                 PollFlag = ((skb->data[i + 1] & 0x1) == 0x1);
1286                 ns = skb->data[i] >> 1;
1287                 nr = (skb->data[i + 1] >> 1) & 0x7f;
1288         } else {
1289                 PollFlag = (skb->data[i] & 0x10);
1290                 ns = (skb->data[i] >> 1) & 0x7;
1291                 nr = (skb->data[i] >> 5) & 0x7;
1292         }
1293         if (test_bit(FLG_OWN_BUSY, &l2->flag)) {
1294                 dev_kfree_skb(skb);
1295                 if (PollFlag)
1296                         enquiry_response(l2);
1297         } else {
1298                 if (l2->vr == ns) {
1299                         l2->vr++;
1300                         if (test_bit(FLG_MOD128, &l2->flag))
1301                                 l2->vr %= 128;
1302                         else
1303                                 l2->vr %= 8;
1304                         test_and_clear_bit(FLG_REJEXC, &l2->flag);
1305                         if (PollFlag)
1306                                 enquiry_response(l2);
1307                         else
1308                                 test_and_set_bit(FLG_ACK_PEND, &l2->flag);
1309                         skb_pull(skb, l2headersize(l2, 0));
1310                         l2up(l2, DL_DATA_IND, skb);
1311                 } else {
1312                         /* n(s)!=v(r) */
1313                         dev_kfree_skb(skb);
1314                         if (test_and_set_bit(FLG_REJEXC, &l2->flag)) {
1315                                 if (PollFlag)
1316                                         enquiry_response(l2);
1317                         } else {
1318                                 enquiry_cr(l2, REJ, RSP, PollFlag);
1319                                 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1320                         }
1321                 }
1322         }
1323         if (legalnr(l2, nr)) {
1324                 if (!test_bit(FLG_PEER_BUSY, &l2->flag) &&
1325                     (fi->state == ST_L2_7)) {
1326                         if (nr == l2->vs) {
1327                                 stop_t200(l2, 13);
1328                                 mISDN_FsmRestartTimer(&l2->t203, l2->T203,
1329                                                       EV_L2_T203, NULL, 7);
1330                         } else if (nr != l2->va)
1331                                 restart_t200(l2, 14);
1332                 }
1333                 setva(l2, nr);
1334         } else {
1335                 nrerrorrecovery(fi);
1336                 return;
1337         }
1338         if (skb_queue_len(&l2->i_queue) && (fi->state == ST_L2_7))
1339                 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1340         if (test_and_clear_bit(FLG_ACK_PEND, &l2->flag))
1341                 enquiry_cr(l2, RR, RSP, 0);
1342 }
1343
1344 static void
1345 l2_got_tei(struct FsmInst *fi, int event, void *arg)
1346 {
1347         struct layer2   *l2 = fi->userdata;
1348         u_int           info;
1349
1350         l2->tei = (signed char)(long)arg;
1351         set_channel_address(&l2->ch, l2->sapi, l2->tei);
1352         info = DL_INFO_L2_CONNECT;
1353         l2up_create(l2, DL_INFORMATION_IND, sizeof(info), &info);
1354         if (fi->state == ST_L2_3) {
1355                 establishlink(fi);
1356                 test_and_set_bit(FLG_L3_INIT, &l2->flag);
1357         } else
1358                 mISDN_FsmChangeState(fi, ST_L2_4);
1359         if (skb_queue_len(&l2->ui_queue))
1360                 tx_ui(l2);
1361 }
1362
1363 static void
1364 l2_st5_tout_200(struct FsmInst *fi, int event, void *arg)
1365 {
1366         struct layer2 *l2 = fi->userdata;
1367
1368         if (test_bit(FLG_LAPD, &l2->flag) &&
1369             test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1370                 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1371         } else if (l2->rc == l2->N200) {
1372                 mISDN_FsmChangeState(fi, ST_L2_4);
1373                 test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1374                 skb_queue_purge(&l2->i_queue);
1375                 l2mgr(l2, MDL_ERROR_IND, (void *) 'G');
1376                 if (test_bit(FLG_LAPB, &l2->flag))
1377                         l2down_create(l2, PH_DEACTIVATE_REQ,
1378                                       l2_newid(l2), 0, NULL);
1379                 st5_dl_release_l2l3(l2);
1380                 if (l2->tm)
1381                         l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1382         } else {
1383                 l2->rc++;
1384                 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1385                 send_uframe(l2, NULL, (test_bit(FLG_MOD128, &l2->flag) ?
1386                                        SABME : SABM) | 0x10, CMD);
1387         }
1388 }
1389
1390 static void
1391 l2_st6_tout_200(struct FsmInst *fi, int event, void *arg)
1392 {
1393         struct layer2 *l2 = fi->userdata;
1394
1395         if (test_bit(FLG_LAPD, &l2->flag) &&
1396             test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1397                 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1398         } else if (l2->rc == l2->N200) {
1399                 mISDN_FsmChangeState(fi, ST_L2_4);
1400                 test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1401                 l2mgr(l2, MDL_ERROR_IND, (void *) 'H');
1402                 lapb_dl_release_l2l3(l2, DL_RELEASE_CNF);
1403                 if (l2->tm)
1404                         l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1405         } else {
1406                 l2->rc++;
1407                 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200,
1408                                   NULL, 9);
1409                 send_uframe(l2, NULL, DISC | 0x10, CMD);
1410         }
1411 }
1412
1413 static void
1414 l2_st7_tout_200(struct FsmInst *fi, int event, void *arg)
1415 {
1416         struct layer2 *l2 = fi->userdata;
1417
1418         if (test_bit(FLG_LAPD, &l2->flag) &&
1419             test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1420                 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1421                 return;
1422         }
1423         test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1424         l2->rc = 0;
1425         mISDN_FsmChangeState(fi, ST_L2_8);
1426         transmit_enquiry(l2);
1427         l2->rc++;
1428 }
1429
1430 static void
1431 l2_st8_tout_200(struct FsmInst *fi, int event, void *arg)
1432 {
1433         struct layer2 *l2 = fi->userdata;
1434
1435         if (test_bit(FLG_LAPD, &l2->flag) &&
1436             test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1437                 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 9);
1438                 return;
1439         }
1440         test_and_clear_bit(FLG_T200_RUN, &l2->flag);
1441         if (l2->rc == l2->N200) {
1442                 l2mgr(l2, MDL_ERROR_IND, (void *) 'I');
1443                 establishlink(fi);
1444                 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1445         } else {
1446                 transmit_enquiry(l2);
1447                 l2->rc++;
1448         }
1449 }
1450
1451 static void
1452 l2_st7_tout_203(struct FsmInst *fi, int event, void *arg)
1453 {
1454         struct layer2 *l2 = fi->userdata;
1455
1456         if (test_bit(FLG_LAPD, &l2->flag) &&
1457             test_bit(FLG_DCHAN_BUSY, &l2->flag)) {
1458                 mISDN_FsmAddTimer(&l2->t203, l2->T203, EV_L2_T203, NULL, 9);
1459                 return;
1460         }
1461         mISDN_FsmChangeState(fi, ST_L2_8);
1462         transmit_enquiry(l2);
1463         l2->rc = 0;
1464 }
1465
1466 static void
1467 l2_pull_iqueue(struct FsmInst *fi, int event, void *arg)
1468 {
1469         struct layer2   *l2 = fi->userdata;
1470         struct sk_buff  *skb, *nskb;
1471         u_char          header[MAX_L2HEADER_LEN];
1472         u_int           i, p1;
1473
1474         if (!cansend(l2))
1475                 return;
1476
1477         skb = skb_dequeue(&l2->i_queue);
1478         if (!skb)
1479                 return;
1480         i = sethdraddr(l2, header, CMD);
1481         if (test_bit(FLG_MOD128, &l2->flag)) {
1482                 header[i++] = l2->vs << 1;
1483                 header[i++] = l2->vr << 1;
1484         } else
1485                 header[i++] = (l2->vr << 5) | (l2->vs << 1);
1486         nskb = skb_realloc_headroom(skb, i);
1487         if (!nskb) {
1488                 printk(KERN_WARNING "%s: no headroom(%d) copy for IFrame\n",
1489                        mISDNDevName4ch(&l2->ch), i);
1490                 skb_queue_head(&l2->i_queue, skb);
1491                 return;
1492         }
1493         if (test_bit(FLG_MOD128, &l2->flag)) {
1494                 p1 = (l2->vs - l2->va) % 128;
1495                 l2->vs = (l2->vs + 1) % 128;
1496         } else {
1497                 p1 = (l2->vs - l2->va) % 8;
1498                 l2->vs = (l2->vs + 1) % 8;
1499         }
1500         p1 = (p1 + l2->sow) % l2->window;
1501         if (l2->windowar[p1]) {
1502                 printk(KERN_WARNING "%s: l2 try overwrite ack queue entry %d\n",
1503                        mISDNDevName4ch(&l2->ch), p1);
1504                 dev_kfree_skb(l2->windowar[p1]);
1505         }
1506         l2->windowar[p1] = skb;
1507         memcpy(skb_push(nskb, i), header, i);
1508         l2down(l2, PH_DATA_REQ, l2_newid(l2), nskb);
1509         test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1510         if (!test_and_set_bit(FLG_T200_RUN, &l2->flag)) {
1511                 mISDN_FsmDelTimer(&l2->t203, 13);
1512                 mISDN_FsmAddTimer(&l2->t200, l2->T200, EV_L2_T200, NULL, 11);
1513         }
1514 }
1515
1516 static void
1517 l2_st8_got_super(struct FsmInst *fi, int event, void *arg)
1518 {
1519         struct layer2 *l2 = fi->userdata;
1520         struct sk_buff *skb = arg;
1521         int PollFlag, rsp, rnr = 0;
1522         unsigned int nr;
1523
1524         rsp = *skb->data & 0x2;
1525         if (test_bit(FLG_ORIG, &l2->flag))
1526                 rsp = !rsp;
1527
1528         skb_pull(skb, l2addrsize(l2));
1529
1530         if (IsRNR(skb->data, l2)) {
1531                 set_peer_busy(l2);
1532                 rnr = 1;
1533         } else
1534                 clear_peer_busy(l2);
1535
1536         if (test_bit(FLG_MOD128, &l2->flag)) {
1537                 PollFlag = (skb->data[1] & 0x1) == 0x1;
1538                 nr = skb->data[1] >> 1;
1539         } else {
1540                 PollFlag = (skb->data[0] & 0x10);
1541                 nr = (skb->data[0] >> 5) & 0x7;
1542         }
1543         dev_kfree_skb(skb);
1544         if (rsp && PollFlag) {
1545                 if (legalnr(l2, nr)) {
1546                         if (rnr) {
1547                                 restart_t200(l2, 15);
1548                         } else {
1549                                 stop_t200(l2, 16);
1550                                 mISDN_FsmAddTimer(&l2->t203, l2->T203,
1551                                                   EV_L2_T203, NULL, 5);
1552                                 setva(l2, nr);
1553                         }
1554                         invoke_retransmission(l2, nr);
1555                         mISDN_FsmChangeState(fi, ST_L2_7);
1556                         if (skb_queue_len(&l2->i_queue) && cansend(l2))
1557                                 mISDN_FsmEvent(fi, EV_L2_ACK_PULL, NULL);
1558                 } else
1559                         nrerrorrecovery(fi);
1560         } else {
1561                 if (!rsp && PollFlag)
1562                         enquiry_response(l2);
1563                 if (legalnr(l2, nr))
1564                         setva(l2, nr);
1565                 else
1566                         nrerrorrecovery(fi);
1567         }
1568 }
1569
1570 static void
1571 l2_got_FRMR(struct FsmInst *fi, int event, void *arg)
1572 {
1573         struct layer2 *l2 = fi->userdata;
1574         struct sk_buff *skb = arg;
1575
1576         skb_pull(skb, l2addrsize(l2) + 1);
1577
1578         if (!(skb->data[0] & 1) || ((skb->data[0] & 3) == 1) || /* I or S */
1579             (IsUA(skb->data) && (fi->state == ST_L2_7))) {
1580                 l2mgr(l2, MDL_ERROR_IND, (void *) 'K');
1581                 establishlink(fi);
1582                 test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1583         }
1584         dev_kfree_skb(skb);
1585 }
1586
1587 static void
1588 l2_st24_tei_remove(struct FsmInst *fi, int event, void *arg)
1589 {
1590         struct layer2 *l2 = fi->userdata;
1591
1592         skb_queue_purge(&l2->ui_queue);
1593         l2->tei = GROUP_TEI;
1594         mISDN_FsmChangeState(fi, ST_L2_1);
1595 }
1596
1597 static void
1598 l2_st3_tei_remove(struct FsmInst *fi, int event, void *arg)
1599 {
1600         struct layer2 *l2 = fi->userdata;
1601
1602         skb_queue_purge(&l2->ui_queue);
1603         l2->tei = GROUP_TEI;
1604         l2up_create(l2, DL_RELEASE_IND, 0, NULL);
1605         mISDN_FsmChangeState(fi, ST_L2_1);
1606 }
1607
1608 static void
1609 l2_st5_tei_remove(struct FsmInst *fi, int event, void *arg)
1610 {
1611         struct layer2 *l2 = fi->userdata;
1612
1613         skb_queue_purge(&l2->i_queue);
1614         skb_queue_purge(&l2->ui_queue);
1615         freewin(l2);
1616         l2->tei = GROUP_TEI;
1617         stop_t200(l2, 17);
1618         st5_dl_release_l2l3(l2);
1619         mISDN_FsmChangeState(fi, ST_L2_1);
1620 }
1621
1622 static void
1623 l2_st6_tei_remove(struct FsmInst *fi, int event, void *arg)
1624 {
1625         struct layer2 *l2 = fi->userdata;
1626
1627         skb_queue_purge(&l2->ui_queue);
1628         l2->tei = GROUP_TEI;
1629         stop_t200(l2, 18);
1630         l2up_create(l2, DL_RELEASE_IND, 0, NULL);
1631         mISDN_FsmChangeState(fi, ST_L2_1);
1632 }
1633
1634 static void
1635 l2_tei_remove(struct FsmInst *fi, int event, void *arg)
1636 {
1637         struct layer2 *l2 = fi->userdata;
1638
1639         skb_queue_purge(&l2->i_queue);
1640         skb_queue_purge(&l2->ui_queue);
1641         freewin(l2);
1642         l2->tei = GROUP_TEI;
1643         stop_t200(l2, 17);
1644         mISDN_FsmDelTimer(&l2->t203, 19);
1645         l2up_create(l2, DL_RELEASE_IND, 0, NULL);
1646 /*      mISDN_queue_data(&l2->inst, l2->inst.id | MSG_BROADCAST,
1647  *              MGR_SHORTSTATUS_IND, SSTATUS_L2_RELEASED,
1648  *              0, NULL, 0);
1649  */
1650         mISDN_FsmChangeState(fi, ST_L2_1);
1651 }
1652
1653 static void
1654 l2_st14_persistent_da(struct FsmInst *fi, int event, void *arg)
1655 {
1656         struct layer2 *l2 = fi->userdata;
1657         struct sk_buff *skb = arg;
1658
1659         skb_queue_purge(&l2->i_queue);
1660         skb_queue_purge(&l2->ui_queue);
1661         if (test_and_clear_bit(FLG_ESTAB_PEND, &l2->flag))
1662                 l2up(l2, DL_RELEASE_IND, skb);
1663         else
1664                 dev_kfree_skb(skb);
1665 }
1666
1667 static void
1668 l2_st5_persistent_da(struct FsmInst *fi, int event, void *arg)
1669 {
1670         struct layer2 *l2 = fi->userdata;
1671         struct sk_buff *skb = arg;
1672
1673         skb_queue_purge(&l2->i_queue);
1674         skb_queue_purge(&l2->ui_queue);
1675         freewin(l2);
1676         stop_t200(l2, 19);
1677         st5_dl_release_l2l3(l2);
1678         mISDN_FsmChangeState(fi, ST_L2_4);
1679         if (l2->tm)
1680                 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1681         dev_kfree_skb(skb);
1682 }
1683
1684 static void
1685 l2_st6_persistent_da(struct FsmInst *fi, int event, void *arg)
1686 {
1687         struct layer2 *l2 = fi->userdata;
1688         struct sk_buff *skb = arg;
1689
1690         skb_queue_purge(&l2->ui_queue);
1691         stop_t200(l2, 20);
1692         l2up(l2, DL_RELEASE_CNF, skb);
1693         mISDN_FsmChangeState(fi, ST_L2_4);
1694         if (l2->tm)
1695                 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1696 }
1697
1698 static void
1699 l2_persistent_da(struct FsmInst *fi, int event, void *arg)
1700 {
1701         struct layer2 *l2 = fi->userdata;
1702         struct sk_buff *skb = arg;
1703
1704         skb_queue_purge(&l2->i_queue);
1705         skb_queue_purge(&l2->ui_queue);
1706         freewin(l2);
1707         stop_t200(l2, 19);
1708         mISDN_FsmDelTimer(&l2->t203, 19);
1709         l2up(l2, DL_RELEASE_IND, skb);
1710         mISDN_FsmChangeState(fi, ST_L2_4);
1711         if (l2->tm)
1712                 l2_tei(l2, MDL_STATUS_DOWN_IND, 0);
1713 }
1714
1715 static void
1716 l2_set_own_busy(struct FsmInst *fi, int event, void *arg)
1717 {
1718         struct layer2 *l2 = fi->userdata;
1719         struct sk_buff *skb = arg;
1720
1721         if (!test_and_set_bit(FLG_OWN_BUSY, &l2->flag)) {
1722                 enquiry_cr(l2, RNR, RSP, 0);
1723                 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1724         }
1725         if (skb)
1726                 dev_kfree_skb(skb);
1727 }
1728
1729 static void
1730 l2_clear_own_busy(struct FsmInst *fi, int event, void *arg)
1731 {
1732         struct layer2 *l2 = fi->userdata;
1733         struct sk_buff *skb = arg;
1734
1735         if (!test_and_clear_bit(FLG_OWN_BUSY, &l2->flag)) {
1736                 enquiry_cr(l2, RR, RSP, 0);
1737                 test_and_clear_bit(FLG_ACK_PEND, &l2->flag);
1738         }
1739         if (skb)
1740                 dev_kfree_skb(skb);
1741 }
1742
1743 static void
1744 l2_frame_error(struct FsmInst *fi, int event, void *arg)
1745 {
1746         struct layer2 *l2 = fi->userdata;
1747
1748         l2mgr(l2, MDL_ERROR_IND, arg);
1749 }
1750
1751 static void
1752 l2_frame_error_reest(struct FsmInst *fi, int event, void *arg)
1753 {
1754         struct layer2 *l2 = fi->userdata;
1755
1756         l2mgr(l2, MDL_ERROR_IND, arg);
1757         establishlink(fi);
1758         test_and_clear_bit(FLG_L3_INIT, &l2->flag);
1759 }
1760
1761 static struct FsmNode L2FnList[] =
1762 {
1763         {ST_L2_1, EV_L2_DL_ESTABLISH_REQ, l2_mdl_assign},
1764         {ST_L2_2, EV_L2_DL_ESTABLISH_REQ, l2_go_st3},
1765         {ST_L2_4, EV_L2_DL_ESTABLISH_REQ, l2_establish},
1766         {ST_L2_5, EV_L2_DL_ESTABLISH_REQ, l2_discard_i_setl3},
1767         {ST_L2_7, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish},
1768         {ST_L2_8, EV_L2_DL_ESTABLISH_REQ, l2_l3_reestablish},
1769         {ST_L2_4, EV_L2_DL_RELEASE_REQ, l2_release},
1770         {ST_L2_5, EV_L2_DL_RELEASE_REQ, l2_pend_rel},
1771         {ST_L2_7, EV_L2_DL_RELEASE_REQ, l2_disconnect},
1772         {ST_L2_8, EV_L2_DL_RELEASE_REQ, l2_disconnect},
1773         {ST_L2_5, EV_L2_DL_DATA, l2_feed_i_if_reest},
1774         {ST_L2_7, EV_L2_DL_DATA, l2_feed_i_pull},
1775         {ST_L2_8, EV_L2_DL_DATA, l2_feed_iqueue},
1776         {ST_L2_1, EV_L2_DL_UNITDATA, l2_queue_ui_assign},
1777         {ST_L2_2, EV_L2_DL_UNITDATA, l2_queue_ui},
1778         {ST_L2_3, EV_L2_DL_UNITDATA, l2_queue_ui},
1779         {ST_L2_4, EV_L2_DL_UNITDATA, l2_send_ui},
1780         {ST_L2_5, EV_L2_DL_UNITDATA, l2_send_ui},
1781         {ST_L2_6, EV_L2_DL_UNITDATA, l2_send_ui},
1782         {ST_L2_7, EV_L2_DL_UNITDATA, l2_send_ui},
1783         {ST_L2_8, EV_L2_DL_UNITDATA, l2_send_ui},
1784         {ST_L2_1, EV_L2_MDL_ASSIGN, l2_got_tei},
1785         {ST_L2_2, EV_L2_MDL_ASSIGN, l2_got_tei},
1786         {ST_L2_3, EV_L2_MDL_ASSIGN, l2_got_tei},
1787         {ST_L2_2, EV_L2_MDL_ERROR, l2_st24_tei_remove},
1788         {ST_L2_3, EV_L2_MDL_ERROR, l2_st3_tei_remove},
1789         {ST_L2_4, EV_L2_MDL_REMOVE, l2_st24_tei_remove},
1790         {ST_L2_5, EV_L2_MDL_REMOVE, l2_st5_tei_remove},
1791         {ST_L2_6, EV_L2_MDL_REMOVE, l2_st6_tei_remove},
1792         {ST_L2_7, EV_L2_MDL_REMOVE, l2_tei_remove},
1793         {ST_L2_8, EV_L2_MDL_REMOVE, l2_tei_remove},
1794         {ST_L2_4, EV_L2_SABME, l2_start_multi},
1795         {ST_L2_5, EV_L2_SABME, l2_send_UA},
1796         {ST_L2_6, EV_L2_SABME, l2_send_DM},
1797         {ST_L2_7, EV_L2_SABME, l2_restart_multi},
1798         {ST_L2_8, EV_L2_SABME, l2_restart_multi},
1799         {ST_L2_4, EV_L2_DISC, l2_send_DM},
1800         {ST_L2_5, EV_L2_DISC, l2_send_DM},
1801         {ST_L2_6, EV_L2_DISC, l2_send_UA},
1802         {ST_L2_7, EV_L2_DISC, l2_stop_multi},
1803         {ST_L2_8, EV_L2_DISC, l2_stop_multi},
1804         {ST_L2_4, EV_L2_UA, l2_mdl_error_ua},
1805         {ST_L2_5, EV_L2_UA, l2_connected},
1806         {ST_L2_6, EV_L2_UA, l2_released},
1807         {ST_L2_7, EV_L2_UA, l2_mdl_error_ua},
1808         {ST_L2_8, EV_L2_UA, l2_mdl_error_ua},
1809         {ST_L2_4, EV_L2_DM, l2_reestablish},
1810         {ST_L2_5, EV_L2_DM, l2_st5_dm_release},
1811         {ST_L2_6, EV_L2_DM, l2_st6_dm_release},
1812         {ST_L2_7, EV_L2_DM, l2_mdl_error_dm},
1813         {ST_L2_8, EV_L2_DM, l2_st8_mdl_error_dm},
1814         {ST_L2_1, EV_L2_UI, l2_got_ui},
1815         {ST_L2_2, EV_L2_UI, l2_got_ui},
1816         {ST_L2_3, EV_L2_UI, l2_got_ui},
1817         {ST_L2_4, EV_L2_UI, l2_got_ui},
1818         {ST_L2_5, EV_L2_UI, l2_got_ui},
1819         {ST_L2_6, EV_L2_UI, l2_got_ui},
1820         {ST_L2_7, EV_L2_UI, l2_got_ui},
1821         {ST_L2_8, EV_L2_UI, l2_got_ui},
1822         {ST_L2_7, EV_L2_FRMR, l2_got_FRMR},
1823         {ST_L2_8, EV_L2_FRMR, l2_got_FRMR},
1824         {ST_L2_7, EV_L2_SUPER, l2_st7_got_super},
1825         {ST_L2_8, EV_L2_SUPER, l2_st8_got_super},
1826         {ST_L2_7, EV_L2_I, l2_got_iframe},
1827         {ST_L2_8, EV_L2_I, l2_got_iframe},
1828         {ST_L2_5, EV_L2_T200, l2_timeout},
1829         {ST_L2_6, EV_L2_T200, l2_timeout},
1830         {ST_L2_7, EV_L2_T200, l2_timeout},
1831         {ST_L2_8, EV_L2_T200, l2_timeout},
1832         {ST_L2_7, EV_L2_T203, l2_timeout},
1833         {ST_L2_5, EV_L2_T200I, l2_st5_tout_200},
1834         {ST_L2_6, EV_L2_T200I, l2_st6_tout_200},
1835         {ST_L2_7, EV_L2_T200I, l2_st7_tout_200},
1836         {ST_L2_8, EV_L2_T200I, l2_st8_tout_200},
1837         {ST_L2_7, EV_L2_T203I, l2_st7_tout_203},
1838         {ST_L2_7, EV_L2_ACK_PULL, l2_pull_iqueue},
1839         {ST_L2_7, EV_L2_SET_OWN_BUSY, l2_set_own_busy},
1840         {ST_L2_8, EV_L2_SET_OWN_BUSY, l2_set_own_busy},
1841         {ST_L2_7, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy},
1842         {ST_L2_8, EV_L2_CLEAR_OWN_BUSY, l2_clear_own_busy},
1843         {ST_L2_4, EV_L2_FRAME_ERROR, l2_frame_error},
1844         {ST_L2_5, EV_L2_FRAME_ERROR, l2_frame_error},
1845         {ST_L2_6, EV_L2_FRAME_ERROR, l2_frame_error},
1846         {ST_L2_7, EV_L2_FRAME_ERROR, l2_frame_error_reest},
1847         {ST_L2_8, EV_L2_FRAME_ERROR, l2_frame_error_reest},
1848         {ST_L2_1, EV_L1_DEACTIVATE, l2_st14_persistent_da},
1849         {ST_L2_2, EV_L1_DEACTIVATE, l2_st24_tei_remove},
1850         {ST_L2_3, EV_L1_DEACTIVATE, l2_st3_tei_remove},
1851         {ST_L2_4, EV_L1_DEACTIVATE, l2_st14_persistent_da},
1852         {ST_L2_5, EV_L1_DEACTIVATE, l2_st5_persistent_da},
1853         {ST_L2_6, EV_L1_DEACTIVATE, l2_st6_persistent_da},
1854         {ST_L2_7, EV_L1_DEACTIVATE, l2_persistent_da},
1855         {ST_L2_8, EV_L1_DEACTIVATE, l2_persistent_da},
1856 };
1857
1858 static int
1859 ph_data_indication(struct layer2 *l2, struct mISDNhead *hh, struct sk_buff *skb)
1860 {
1861         u_char  *datap = skb->data;
1862         int     ret = -EINVAL;
1863         int     psapi, ptei;
1864         u_int   l;
1865         int     c = 0;
1866
1867         l = l2addrsize(l2);
1868         if (skb->len <= l) {
1869                 mISDN_FsmEvent(&l2->l2m, EV_L2_FRAME_ERROR, (void *) 'N');
1870                 return ret;
1871         }
1872         if (test_bit(FLG_LAPD, &l2->flag)) { /* Maybe not needed */
1873                 psapi = *datap++;
1874                 ptei = *datap++;
1875                 if ((psapi & 1) || !(ptei & 1)) {
1876                         printk(KERN_WARNING
1877                                "%s l2 D-channel frame wrong EA0/EA1\n",
1878                                mISDNDevName4ch(&l2->ch));
1879                         return ret;
1880                 }
1881                 psapi >>= 2;
1882                 ptei >>= 1;
1883                 if (psapi != l2->sapi) {
1884                         /* not our business */
1885                         if (*debug & DEBUG_L2)
1886                                 printk(KERN_DEBUG "%s: sapi %d/%d mismatch\n",
1887                                        mISDNDevName4ch(&l2->ch), psapi,
1888                                        l2->sapi);
1889                         dev_kfree_skb(skb);
1890                         return 0;
1891                 }
1892                 if ((ptei != l2->tei) && (ptei != GROUP_TEI)) {
1893                         /* not our business */
1894                         if (*debug & DEBUG_L2)
1895                                 printk(KERN_DEBUG "%s: tei %d/%d mismatch\n",
1896                                        mISDNDevName4ch(&l2->ch), ptei, l2->tei);
1897                         dev_kfree_skb(skb);
1898                         return 0;
1899                 }
1900         } else
1901                 datap += l;
1902         if (!(*datap & 1)) {    /* I-Frame */
1903                 c = iframe_error(l2, skb);
1904                 if (!c)
1905                         ret = mISDN_FsmEvent(&l2->l2m, EV_L2_I, skb);
1906         } else if (IsSFrame(datap, l2)) {       /* S-Frame */
1907                 c = super_error(l2, skb);
1908                 if (!c)
1909                         ret = mISDN_FsmEvent(&l2->l2m, EV_L2_SUPER, skb);
1910         } else if (IsUI(datap)) {
1911                 c = UI_error(l2, skb);
1912                 if (!c)
1913                         ret = mISDN_FsmEvent(&l2->l2m, EV_L2_UI, skb);
1914         } else if (IsSABME(datap, l2)) {
1915                 c = unnum_error(l2, skb, CMD);
1916                 if (!c)
1917                         ret = mISDN_FsmEvent(&l2->l2m, EV_L2_SABME, skb);
1918         } else if (IsUA(datap)) {
1919                 c = unnum_error(l2, skb, RSP);
1920                 if (!c)
1921                         ret = mISDN_FsmEvent(&l2->l2m, EV_L2_UA, skb);
1922         } else if (IsDISC(datap)) {
1923                 c = unnum_error(l2, skb, CMD);
1924                 if (!c)
1925                         ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DISC, skb);
1926         } else if (IsDM(datap)) {
1927                 c = unnum_error(l2, skb, RSP);
1928                 if (!c)
1929                         ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DM, skb);
1930         } else if (IsFRMR(datap)) {
1931                 c = FRMR_error(l2, skb);
1932                 if (!c)
1933                         ret = mISDN_FsmEvent(&l2->l2m, EV_L2_FRMR, skb);
1934         } else
1935                 c = 'L';
1936         if (c) {
1937                 printk(KERN_WARNING "%s:l2 D-channel frame error %c\n",
1938                        mISDNDevName4ch(&l2->ch), c);
1939                 mISDN_FsmEvent(&l2->l2m, EV_L2_FRAME_ERROR, (void *)(long)c);
1940         }
1941         return ret;
1942 }
1943
1944 static int
1945 l2_send(struct mISDNchannel *ch, struct sk_buff *skb)
1946 {
1947         struct layer2           *l2 = container_of(ch, struct layer2, ch);
1948         struct mISDNhead        *hh =  mISDN_HEAD_P(skb);
1949         int                     ret = -EINVAL;
1950
1951         if (*debug & DEBUG_L2_RECV)
1952                 printk(KERN_DEBUG "%s: %s prim(%x) id(%x) sapi(%d) tei(%d)\n",
1953                        __func__, mISDNDevName4ch(&l2->ch), hh->prim, hh->id,
1954                        l2->sapi, l2->tei);
1955         if (hh->prim == DL_INTERN_MSG) {
1956                 struct mISDNhead *chh = hh + 1; /* saved copy */
1957
1958                 *hh = *chh;
1959                 if (*debug & DEBUG_L2_RECV)
1960                         printk(KERN_DEBUG "%s: prim(%x) id(%x) internal msg\n",
1961                                 mISDNDevName4ch(&l2->ch), hh->prim, hh->id);
1962         }
1963         switch (hh->prim) {
1964         case PH_DATA_IND:
1965                 ret = ph_data_indication(l2, hh, skb);
1966                 break;
1967         case PH_DATA_CNF:
1968                 ret = ph_data_confirm(l2, hh, skb);
1969                 break;
1970         case PH_ACTIVATE_IND:
1971                 test_and_set_bit(FLG_L1_ACTIV, &l2->flag);
1972                 l2up_create(l2, MPH_ACTIVATE_IND, 0, NULL);
1973                 if (test_and_clear_bit(FLG_ESTAB_PEND, &l2->flag))
1974                         ret = mISDN_FsmEvent(&l2->l2m,
1975                                              EV_L2_DL_ESTABLISH_REQ, skb);
1976                 break;
1977         case PH_DEACTIVATE_IND:
1978                 test_and_clear_bit(FLG_L1_ACTIV, &l2->flag);
1979                 l2up_create(l2, MPH_DEACTIVATE_IND, 0, NULL);
1980                 ret = mISDN_FsmEvent(&l2->l2m, EV_L1_DEACTIVATE, skb);
1981                 break;
1982         case MPH_INFORMATION_IND:
1983                 if (!l2->up)
1984                         break;
1985                 ret = l2->up->send(l2->up, skb);
1986                 break;
1987         case DL_DATA_REQ:
1988                 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_DATA, skb);
1989                 break;
1990         case DL_UNITDATA_REQ:
1991                 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_UNITDATA, skb);
1992                 break;
1993         case DL_ESTABLISH_REQ:
1994                 if (test_bit(FLG_LAPB, &l2->flag))
1995                         test_and_set_bit(FLG_ORIG, &l2->flag);
1996                 if (test_bit(FLG_L1_ACTIV, &l2->flag)) {
1997                         if (test_bit(FLG_LAPD, &l2->flag) ||
1998                             test_bit(FLG_ORIG, &l2->flag))
1999                                 ret = mISDN_FsmEvent(&l2->l2m,
2000                                                      EV_L2_DL_ESTABLISH_REQ, skb);
2001                 } else {
2002                         if (test_bit(FLG_LAPD, &l2->flag) ||
2003                             test_bit(FLG_ORIG, &l2->flag)) {
2004                                 test_and_set_bit(FLG_ESTAB_PEND,
2005                                                  &l2->flag);
2006                         }
2007                         ret = l2down(l2, PH_ACTIVATE_REQ, l2_newid(l2),
2008                                      skb);
2009                 }
2010                 break;
2011         case DL_RELEASE_REQ:
2012                 if (test_bit(FLG_LAPB, &l2->flag))
2013                         l2down_create(l2, PH_DEACTIVATE_REQ,
2014                                       l2_newid(l2), 0, NULL);
2015                 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_DL_RELEASE_REQ,
2016                                      skb);
2017                 break;
2018         case DL_TIMER200_IND:
2019                 mISDN_FsmEvent(&l2->l2m, EV_L2_T200I, NULL);
2020                 break;
2021         case DL_TIMER203_IND:
2022                 mISDN_FsmEvent(&l2->l2m, EV_L2_T203I, NULL);
2023                 break;
2024         default:
2025                 if (*debug & DEBUG_L2)
2026                         l2m_debug(&l2->l2m, "l2 unknown pr %04x",
2027                                   hh->prim);
2028         }
2029         if (ret) {
2030                 dev_kfree_skb(skb);
2031                 ret = 0;
2032         }
2033         return ret;
2034 }
2035
2036 int
2037 tei_l2(struct layer2 *l2, u_int cmd, u_long arg)
2038 {
2039         int             ret = -EINVAL;
2040
2041         if (*debug & DEBUG_L2_TEI)
2042                 printk(KERN_DEBUG "%s: cmd(%x) in %s\n",
2043                        mISDNDevName4ch(&l2->ch), cmd, __func__);
2044         switch (cmd) {
2045         case (MDL_ASSIGN_REQ):
2046                 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ASSIGN, (void *)arg);
2047                 break;
2048         case (MDL_REMOVE_REQ):
2049                 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_REMOVE, NULL);
2050                 break;
2051         case (MDL_ERROR_IND):
2052                 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ERROR, NULL);
2053                 break;
2054         case (MDL_ERROR_RSP):
2055                 /* ETS 300-125 5.3.2.1 Test: TC13010 */
2056                 printk(KERN_NOTICE "%s: MDL_ERROR|REQ (tei_l2)\n",
2057                        mISDNDevName4ch(&l2->ch));
2058                 ret = mISDN_FsmEvent(&l2->l2m, EV_L2_MDL_ERROR, NULL);
2059                 break;
2060         }
2061         return ret;
2062 }
2063
2064 static void
2065 release_l2(struct layer2 *l2)
2066 {
2067         mISDN_FsmDelTimer(&l2->t200, 21);
2068         mISDN_FsmDelTimer(&l2->t203, 16);
2069         skb_queue_purge(&l2->i_queue);
2070         skb_queue_purge(&l2->ui_queue);
2071         skb_queue_purge(&l2->down_queue);
2072         ReleaseWin(l2);
2073         if (test_bit(FLG_LAPD, &l2->flag)) {
2074                 TEIrelease(l2);
2075                 if (l2->ch.st)
2076                         l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D,
2077                                                CLOSE_CHANNEL, NULL);
2078         }
2079         kfree(l2);
2080 }
2081
2082 static int
2083 l2_ctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
2084 {
2085         struct layer2           *l2 = container_of(ch, struct layer2, ch);
2086         u_int                   info;
2087
2088         if (*debug & DEBUG_L2_CTRL)
2089                 printk(KERN_DEBUG "%s: %s cmd(%x)\n",
2090                        mISDNDevName4ch(ch), __func__, cmd);
2091
2092         switch (cmd) {
2093         case OPEN_CHANNEL:
2094                 if (test_bit(FLG_LAPD, &l2->flag)) {
2095                         set_channel_address(&l2->ch, l2->sapi, l2->tei);
2096                         info = DL_INFO_L2_CONNECT;
2097                         l2up_create(l2, DL_INFORMATION_IND,
2098                                     sizeof(info), &info);
2099                 }
2100                 break;
2101         case CLOSE_CHANNEL:
2102                 if (l2->ch.peer)
2103                         l2->ch.peer->ctrl(l2->ch.peer, CLOSE_CHANNEL, NULL);
2104                 release_l2(l2);
2105                 break;
2106         }
2107         return 0;
2108 }
2109
2110 struct layer2 *
2111 create_l2(struct mISDNchannel *ch, u_int protocol, u_long options, int tei,
2112           int sapi)
2113 {
2114         struct layer2           *l2;
2115         struct channel_req      rq;
2116
2117         l2 = kzalloc(sizeof(struct layer2), GFP_KERNEL);
2118         if (!l2) {
2119                 printk(KERN_ERR "kzalloc layer2 failed\n");
2120                 return NULL;
2121         }
2122         l2->next_id = 1;
2123         l2->down_id = MISDN_ID_NONE;
2124         l2->up = ch;
2125         l2->ch.st = ch->st;
2126         l2->ch.send = l2_send;
2127         l2->ch.ctrl = l2_ctrl;
2128         switch (protocol) {
2129         case ISDN_P_LAPD_NT:
2130                 test_and_set_bit(FLG_LAPD, &l2->flag);
2131                 test_and_set_bit(FLG_LAPD_NET, &l2->flag);
2132                 test_and_set_bit(FLG_MOD128, &l2->flag);
2133                 l2->sapi = sapi;
2134                 l2->maxlen = MAX_DFRAME_LEN;
2135                 if (test_bit(OPTION_L2_PMX, &options))
2136                         l2->window = 7;
2137                 else
2138                         l2->window = 1;
2139                 if (test_bit(OPTION_L2_PTP, &options))
2140                         test_and_set_bit(FLG_PTP, &l2->flag);
2141                 if (test_bit(OPTION_L2_FIXEDTEI, &options))
2142                         test_and_set_bit(FLG_FIXED_TEI, &l2->flag);
2143                 l2->tei = tei;
2144                 l2->T200 = 1000;
2145                 l2->N200 = 3;
2146                 l2->T203 = 10000;
2147                 if (test_bit(OPTION_L2_PMX, &options))
2148                         rq.protocol = ISDN_P_NT_E1;
2149                 else
2150                         rq.protocol = ISDN_P_NT_S0;
2151                 rq.adr.channel = 0;
2152                 l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D, OPEN_CHANNEL, &rq);
2153                 break;
2154         case ISDN_P_LAPD_TE:
2155                 test_and_set_bit(FLG_LAPD, &l2->flag);
2156                 test_and_set_bit(FLG_MOD128, &l2->flag);
2157                 test_and_set_bit(FLG_ORIG, &l2->flag);
2158                 l2->sapi = sapi;
2159                 l2->maxlen = MAX_DFRAME_LEN;
2160                 if (test_bit(OPTION_L2_PMX, &options))
2161                         l2->window = 7;
2162                 else
2163                         l2->window = 1;
2164                 if (test_bit(OPTION_L2_PTP, &options))
2165                         test_and_set_bit(FLG_PTP, &l2->flag);
2166                 if (test_bit(OPTION_L2_FIXEDTEI, &options))
2167                         test_and_set_bit(FLG_FIXED_TEI, &l2->flag);
2168                 l2->tei = tei;
2169                 l2->T200 = 1000;
2170                 l2->N200 = 3;
2171                 l2->T203 = 10000;
2172                 if (test_bit(OPTION_L2_PMX, &options))
2173                         rq.protocol = ISDN_P_TE_E1;
2174                 else
2175                         rq.protocol = ISDN_P_TE_S0;
2176                 rq.adr.channel = 0;
2177                 l2->ch.st->dev->D.ctrl(&l2->ch.st->dev->D, OPEN_CHANNEL, &rq);
2178                 break;
2179         case ISDN_P_B_X75SLP:
2180                 test_and_set_bit(FLG_LAPB, &l2->flag);
2181                 l2->window = 7;
2182                 l2->maxlen = MAX_DATA_SIZE;
2183                 l2->T200 = 1000;
2184                 l2->N200 = 4;
2185                 l2->T203 = 5000;
2186                 l2->addr.A = 3;
2187                 l2->addr.B = 1;
2188                 break;
2189         default:
2190                 printk(KERN_ERR "layer2 create failed prt %x\n",
2191                        protocol);
2192                 kfree(l2);
2193                 return NULL;
2194         }
2195         skb_queue_head_init(&l2->i_queue);
2196         skb_queue_head_init(&l2->ui_queue);
2197         skb_queue_head_init(&l2->down_queue);
2198         skb_queue_head_init(&l2->tmp_queue);
2199         InitWin(l2);
2200         l2->l2m.fsm = &l2fsm;
2201         if (test_bit(FLG_LAPB, &l2->flag) ||
2202             test_bit(FLG_FIXED_TEI, &l2->flag) ||
2203             test_bit(FLG_LAPD_NET, &l2->flag))
2204                 l2->l2m.state = ST_L2_4;
2205         else
2206                 l2->l2m.state = ST_L2_1;
2207         l2->l2m.debug = *debug;
2208         l2->l2m.userdata = l2;
2209         l2->l2m.userint = 0;
2210         l2->l2m.printdebug = l2m_debug;
2211
2212         mISDN_FsmInitTimer(&l2->l2m, &l2->t200);
2213         mISDN_FsmInitTimer(&l2->l2m, &l2->t203);
2214         return l2;
2215 }
2216
2217 static int
2218 x75create(struct channel_req *crq)
2219 {
2220         struct layer2   *l2;
2221
2222         if (crq->protocol != ISDN_P_B_X75SLP)
2223                 return -EPROTONOSUPPORT;
2224         l2 = create_l2(crq->ch, crq->protocol, 0, 0, 0);
2225         if (!l2)
2226                 return -ENOMEM;
2227         crq->ch = &l2->ch;
2228         crq->protocol = ISDN_P_B_HDLC;
2229         return 0;
2230 }
2231
2232 static struct Bprotocol X75SLP = {
2233         .Bprotocols = (1 << (ISDN_P_B_X75SLP & ISDN_P_B_MASK)),
2234         .name = "X75SLP",
2235         .create = x75create
2236 };
2237
2238 int
2239 Isdnl2_Init(u_int *deb)
2240 {
2241         int res;
2242         debug = deb;
2243         mISDN_register_Bprotocol(&X75SLP);
2244         l2fsm.state_count = L2_STATE_COUNT;
2245         l2fsm.event_count = L2_EVENT_COUNT;
2246         l2fsm.strEvent = strL2Event;
2247         l2fsm.strState = strL2State;
2248         res = mISDN_FsmNew(&l2fsm, L2FnList, ARRAY_SIZE(L2FnList));
2249         if (res)
2250                 goto error;
2251         res = TEIInit(deb);
2252         if (res)
2253                 goto error_fsm;
2254         return 0;
2255
2256 error_fsm:
2257         mISDN_FsmFree(&l2fsm);
2258 error:
2259         mISDN_unregister_Bprotocol(&X75SLP);
2260         return res;
2261 }
2262
2263 void
2264 Isdnl2_cleanup(void)
2265 {
2266         mISDN_unregister_Bprotocol(&X75SLP);
2267         TEIFree();
2268         mISDN_FsmFree(&l2fsm);
2269 }