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