git.oblomov.eu Git - linux-2.6/blob - drivers/isdn/mISDN/layer2.c

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