drivers/isdn/hisax/isdnl1.c

   1 /* $Id: isdnl1.c,v 1.1.4.1 2001/11/20 14:19:36 kai Exp $
   2  *
   3  * common low level stuff for Siemens Chipsetbased isdn cards
   4  *
   5  * Author       Karsten Keil
   6  *              based on the teles driver from Jan den Ouden
   7  * Copyright    by Karsten Keil      <keil@isdn4linux.de>
   8  *
   9  * This software may be used and distributed according to the terms
  10  * of the GNU General Public License, incorporated herein by reference.
  11  *
  12  * For changes and modifications please read
  13  * ../../../Documentation/isdn/HiSax.cert
  14  *
  15  * Thanks to    Jan den Ouden
  16  *              Fritz Elfert
  17  *              Beat Doebeli
  18  *
  19  */
  20
  21 const char *l1_revision = "$Revision: 1.1.4.1 $";
  22
  23 #define __NO_VERSION__
  24 #include <linux/init.h>
  25 #include "hisax.h"
  26 #include "isdnl1.h"
  27
  28 #define TIMER3_VALUE 7000
  29
  30 static struct Fsm l1fsm_b;
  31 static struct Fsm l1fsm_s;
  32
  33 enum {
  34         ST_L1_F2,
  35         ST_L1_F3,
  36         ST_L1_F4,
  37         ST_L1_F5,
  38         ST_L1_F6,
  39         ST_L1_F7,
  40         ST_L1_F8,
  41 };
  42
  43 #define L1S_STATE_COUNT (ST_L1_F8+1)
  44
  45 static char *strL1SState[] =
  46 {
  47         "ST_L1_F2",
  48         "ST_L1_F3",
  49         "ST_L1_F4",
  50         "ST_L1_F5",
  51         "ST_L1_F6",
  52         "ST_L1_F7",
  53         "ST_L1_F8",
  54 };
  55
  56 #ifdef HISAX_UINTERFACE
  57 static
  58 struct Fsm l1fsm_u =
  59 {NULL, 0, 0, NULL, NULL};
  60
  61 enum {
  62         ST_L1_RESET,
  63         ST_L1_DEACT,
  64         ST_L1_SYNC2,
  65         ST_L1_TRANS,
  66 };
  67
  68 #define L1U_STATE_COUNT (ST_L1_TRANS+1)
  69
  70 static char *strL1UState[] =
  71 {
  72         "ST_L1_RESET",
  73         "ST_L1_DEACT",
  74         "ST_L1_SYNC2",
  75         "ST_L1_TRANS",
  76 };
  77 #endif
  78
  79 enum {
  80         ST_L1_NULL,
  81         ST_L1_WAIT_ACT,
  82         ST_L1_WAIT_DEACT,
  83         ST_L1_ACTIV,
  84 };
  85
  86 #define L1B_STATE_COUNT (ST_L1_ACTIV+1)
  87
  88 static char *strL1BState[] =
  89 {
  90         "ST_L1_NULL",
  91         "ST_L1_WAIT_ACT",
  92         "ST_L1_WAIT_DEACT",
  93         "ST_L1_ACTIV",
  94 };
  95
  96 enum {
  97         EV_PH_ACTIVATE,
  98         EV_PH_DEACTIVATE,
  99         EV_RESET_IND,
 100         EV_DEACT_CNF,
 101         EV_DEACT_IND,
 102         EV_POWER_UP,
 103         EV_RSYNC_IND,
 104         EV_INFO2_IND,
 105         EV_INFO4_IND,
 106         EV_TIMER_DEACT,
 107         EV_TIMER_ACT,
 108         EV_TIMER3,
 109 };
 110
 111 #define L1_EVENT_COUNT (EV_TIMER3 + 1)
 112
 113 static char *strL1Event[] =
 114 {
 115         "EV_PH_ACTIVATE",
 116         "EV_PH_DEACTIVATE",
 117         "EV_RESET_IND",
 118         "EV_DEACT_CNF",
 119         "EV_DEACT_IND",
 120         "EV_POWER_UP",
 121         "EV_RSYNC_IND",
 122         "EV_INFO2_IND",
 123         "EV_INFO4_IND",
 124         "EV_TIMER_DEACT",
 125         "EV_TIMER_ACT",
 126         "EV_TIMER3",
 127 };
 128
 129 void
 130 debugl1(struct IsdnCardState *cs, char *fmt, ...)
 131 {
 132         va_list args;
 133         char tmp[8];
 134
 135         va_start(args, fmt);
 136         sprintf(tmp, "Card%d ", cs->cardnr + 1);
 137         VHiSax_putstatus(cs, tmp, fmt, args);
 138         va_end(args);
 139 }
 140
 141 static void
 142 l1m_debug(struct FsmInst *fi, char *fmt, ...)
 143 {
 144         va_list args;
 145         struct PStack *st = fi->userdata;
 146         struct IsdnCardState *cs = st->l1.hardware;
 147         char tmp[8];
 148
 149         va_start(args, fmt);
 150         sprintf(tmp, "Card%d ", cs->cardnr + 1);
 151         VHiSax_putstatus(cs, tmp, fmt, args);
 152         va_end(args);
 153 }
 154
 155 void
 156 L1activated(struct IsdnCardState *cs)
 157 {
 158         struct PStack *st;
 159
 160         st = cs->stlist;
 161         while (st) {
 162                 if (test_and_clear_bit(FLG_L1_ACTIVATING, &st->l1.Flags))
 163                         st->l1.l1l2(st, PH_ACTIVATE | CONFIRM, NULL);
 164                 else
 165                         st->l1.l1l2(st, PH_ACTIVATE | INDICATION, NULL);
 166                 st = st->next;
 167         }
 168 }
 169
 170 void
 171 L1deactivated(struct IsdnCardState *cs)
 172 {
 173         struct PStack *st;
 174
 175         st = cs->stlist;
 176         while (st) {
 177                 if (test_bit(FLG_L1_DBUSY, &cs->HW_Flags))
 178                         st->l1.l1l2(st, PH_PAUSE | CONFIRM, NULL);
 179                 st->l1.l1l2(st, PH_DEACTIVATE | INDICATION, NULL);
 180                 st = st->next;
 181         }
 182         test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags);
 183 }
 184
 185 void
 186 DChannel_proc_xmt(struct IsdnCardState *cs)
 187 {
 188         struct PStack *stptr;
 189
 190         if (cs->tx_skb)
 191                 return;
 192
 193         stptr = cs->stlist;
 194         while (stptr != NULL)
 195                 if (test_and_clear_bit(FLG_L1_PULL_REQ, &stptr->l1.Flags)) {
 196                         stptr->l1.l1l2(stptr, PH_PULL | CONFIRM, NULL);
 197                         break;
 198                 } else
 199                         stptr = stptr->next;
 200 }
 201
 202 void
 203 DChannel_proc_rcv(struct IsdnCardState *cs)
 204 {
 205         struct sk_buff *skb, *nskb;
 206         struct PStack *stptr = cs->stlist;
 207         int found, tei, sapi;
 208
 209         if (stptr)
 210                 if (test_bit(FLG_L1_ACTTIMER, &stptr->l1.Flags))
 211                         FsmEvent(&stptr->l1.l1m, EV_TIMER_ACT, NULL);
 212         while ((skb = skb_dequeue(&cs->rq))) {
 213 #ifdef L2FRAME_DEBUG            /* psa */
 214                 if (cs->debug & L1_DEB_LAPD)
 215                         Logl2Frame(cs, skb, "PH_DATA", 1);
 216 #endif
 217                 stptr = cs->stlist;
 218                 if (skb->len<3) {
 219                         debugl1(cs, "D-channel frame too short(%d)",skb->len);
 220                         dev_kfree_skb(skb);
 221                         return;
 222                 }
 223                 if ((skb->data[0] & 1) || !(skb->data[1] &1)) {
 224                         debugl1(cs, "D-channel frame wrong EA0/EA1");
 225                         dev_kfree_skb(skb);
 226                         return;
 227                 }
 228                 sapi = skb->data[0] >> 2;
 229                 tei = skb->data[1] >> 1;
 230                 if (cs->debug & DEB_DLOG_HEX)
 231                         LogFrame(cs, skb->data, skb->len);
 232                 if (cs->debug & DEB_DLOG_VERBOSE)
 233                         dlogframe(cs, skb, 1);
 234                 if (tei == GROUP_TEI) {
 235                         if (sapi == CTRL_SAPI) { /* sapi 0 */
 236                                 while (stptr != NULL) {
 237                                         if ((nskb = skb_clone(skb, GFP_ATOMIC)))
 238                                                 stptr->l1.l1l2(stptr, PH_DATA | INDICATION, nskb);
 239                                         else
 240                                                 printk(KERN_WARNING "HiSax: isdn broadcast buffer shortage\n");
 241                                         stptr = stptr->next;
 242                                 }
 243                         } else if (sapi == TEI_SAPI) {
 244                                 while (stptr != NULL) {
 245                                         if ((nskb = skb_clone(skb, GFP_ATOMIC)))
 246                                                 stptr->l1.l1tei(stptr, PH_DATA | INDICATION, nskb);
 247                                         else
 248                                                 printk(KERN_WARNING "HiSax: tei broadcast buffer shortage\n");
 249                                         stptr = stptr->next;
 250                                 }
 251                         }
 252                         dev_kfree_skb(skb);
 253                 } else if (sapi == CTRL_SAPI) { /* sapi 0 */
 254                         found = 0;
 255                         while (stptr != NULL)
 256                                 if (tei == stptr->l2.tei) {
 257                                         stptr->l1.l1l2(stptr, PH_DATA | INDICATION, skb);
 258                                         found = !0;
 259                                         break;
 260                                 } else
 261                                         stptr = stptr->next;
 262                         if (!found)
 263                                 dev_kfree_skb(skb);
 264                 } else
 265                         dev_kfree_skb(skb);
 266         }
 267 }
 268
 269 static void
 270 BChannel_proc_xmt(struct BCState *bcs)
 271 {
 272         struct PStack *st = bcs->st;
 273
 274         if (test_bit(BC_FLG_BUSY, &bcs->Flag)) {
 275                 debugl1(bcs->cs, "BC_BUSY Error");
 276                 return;
 277         }
 278
 279         if (test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags))
 280                 st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
 281         if (!test_bit(BC_FLG_ACTIV, &bcs->Flag)) {
 282                 if (!test_bit(BC_FLG_BUSY, &bcs->Flag) && (!skb_queue_len(&bcs->squeue))) {
 283                         st->l2.l2l1(st, PH_DEACTIVATE | CONFIRM, NULL);
 284                 }
 285         }
 286 }
 287
 288 static void
 289 BChannel_proc_rcv(struct BCState *bcs)
 290 {
 291         struct sk_buff *skb;
 292
 293         if (bcs->st->l1.l1m.state == ST_L1_WAIT_ACT) {
 294                 FsmDelTimer(&bcs->st->l1.timer, 4);
 295                 FsmEvent(&bcs->st->l1.l1m, EV_TIMER_ACT, NULL);
 296         }
 297         while ((skb = skb_dequeue(&bcs->rqueue))) {
 298                 bcs->st->l1.l1l2(bcs->st, PH_DATA | INDICATION, skb);
 299         }
 300 }
 301
 302 void
 303 BChannel_bh(struct BCState *bcs)
 304 {
 305         if (!bcs)
 306                 return;
 307         if (test_and_clear_bit(B_RCVBUFREADY, &bcs->event))
 308                 BChannel_proc_rcv(bcs);
 309         if (test_and_clear_bit(B_XMTBUFREADY, &bcs->event))
 310                 BChannel_proc_xmt(bcs);
 311 }
 312
 313 void
 314 HiSax_addlist(struct IsdnCardState *cs,
 315               struct PStack *st)
 316 {
 317         st->next = cs->stlist;
 318         cs->stlist = st;
 319 }
 320
 321 void
 322 HiSax_rmlist(struct IsdnCardState *cs,
 323              struct PStack *st)
 324 {
 325         struct PStack *p;
 326
 327         FsmDelTimer(&st->l1.timer, 0);
 328         if (cs->stlist == st)
 329                 cs->stlist = st->next;
 330         else {
 331                 p = cs->stlist;
 332                 while (p)
 333                         if (p->next == st) {
 334                                 p->next = st->next;
 335                                 return;
 336                         } else
 337                                 p = p->next;
 338         }
 339 }
 340
 341 void
 342 init_bcstate(struct IsdnCardState *cs,
 343              int bc)
 344 {
 345         struct BCState *bcs = cs->bcs + bc;
 346
 347         bcs->cs = cs;
 348         bcs->channel = bc;
 349         bcs->tqueue.sync = 0;
 350         bcs->tqueue.routine = (void *) (void *) BChannel_bh;
 351         bcs->tqueue.data = bcs;
 352         bcs->BC_SetStack = NULL;
 353         bcs->BC_Close = NULL;
 354         bcs->Flag = 0;
 355 }
 356
 357 #ifdef L2FRAME_DEBUG            /* psa */
 358
 359 char *
 360 l2cmd(u_char cmd)
 361 {
 362         switch (cmd & ~0x10) {
 363                 case 1:
 364                         return "RR";
 365                 case 5:
 366                         return "RNR";
 367                 case 9:
 368                         return "REJ";
 369                 case 0x6f:
 370                         return "SABME";
 371                 case 0x0f:
 372                         return "DM";
 373                 case 3:
 374                         return "UI";
 375                 case 0x43:
 376                         return "DISC";
 377                 case 0x63:
 378                         return "UA";
 379                 case 0x87:
 380                         return "FRMR";
 381                 case 0xaf:
 382                         return "XID";
 383                 default:
 384                         if (!(cmd & 1))
 385                                 return "I";
 386                         else
 387                                 return "invalid command";
 388         }
 389 }
 390
 391 static char tmpdeb[32];
 392
 393 char *
 394 l2frames(u_char * ptr)
 395 {
 396         switch (ptr[2] & ~0x10) {
 397                 case 1:
 398                 case 5:
 399                 case 9:
 400                         sprintf(tmpdeb, "%s[%d](nr %d)", l2cmd(ptr[2]), ptr[3] & 1, ptr[3] >> 1);
 401                         break;
 402                 case 0x6f:
 403                 case 0x0f:
 404                 case 3:
 405                 case 0x43:
 406                 case 0x63:
 407                 case 0x87:
 408                 case 0xaf:
 409                         sprintf(tmpdeb, "%s[%d]", l2cmd(ptr[2]), (ptr[2] & 0x10) >> 4);
 410                         break;
 411                 default:
 412                         if (!(ptr[2] & 1)) {
 413                                 sprintf(tmpdeb, "I[%d](ns %d, nr %d)", ptr[3] & 1, ptr[2] >> 1, ptr[3] >> 1);
 414                                 break;
 415                         } else
 416                                 return "invalid command";
 417         }
 418
 419
 420         return tmpdeb;
 421 }
 422
 423 void
 424 Logl2Frame(struct IsdnCardState *cs, struct sk_buff *skb, char *buf, int dir)
 425 {
 426         u_char *ptr;
 427
 428         ptr = skb->data;
 429
 430         if (ptr[0] & 1 || !(ptr[1] & 1))
 431                 debugl1(cs, "Address not LAPD");
 432         else
 433                 debugl1(cs, "%s %s: %s%c (sapi %d, tei %d)",
 434                         (dir ? "<-" : "->"), buf, l2frames(ptr),
 435                         ((ptr[0] & 2) >> 1) == dir ? 'C' : 'R', ptr[0] >> 2, ptr[1] >> 1);
 436 }
 437 #endif
 438
 439 static void
 440 l1_reset(struct FsmInst *fi, int event, void *arg)
 441 {
 442         FsmChangeState(fi, ST_L1_F3);
 443 }
 444
 445 static void
 446 l1_deact_cnf(struct FsmInst *fi, int event, void *arg)
 447 {
 448         struct PStack *st = fi->userdata;
 449
 450         FsmChangeState(fi, ST_L1_F3);
 451         if (test_bit(FLG_L1_ACTIVATING, &st->l1.Flags))
 452                 st->l1.l1hw(st, HW_ENABLE | REQUEST, NULL);
 453 }
 454
 455 static void
 456 l1_deact_req_s(struct FsmInst *fi, int event, void *arg)
 457 {
 458         struct PStack *st = fi->userdata;
 459
 460         FsmChangeState(fi, ST_L1_F3);
 461         FsmRestartTimer(&st->l1.timer, 550, EV_TIMER_DEACT, NULL, 2);
 462         test_and_set_bit(FLG_L1_DEACTTIMER, &st->l1.Flags);
 463 }
 464
 465 static void
 466 l1_power_up_s(struct FsmInst *fi, int event, void *arg)
 467 {
 468         struct PStack *st = fi->userdata;
 469
 470         if (test_bit(FLG_L1_ACTIVATING, &st->l1.Flags)) {
 471                 FsmChangeState(fi, ST_L1_F4);
 472                 st->l1.l1hw(st, HW_INFO3 | REQUEST, NULL);
 473                 FsmRestartTimer(&st->l1.timer, TIMER3_VALUE, EV_TIMER3, NULL, 2);
 474                 test_and_set_bit(FLG_L1_T3RUN, &st->l1.Flags);
 475         } else
 476                 FsmChangeState(fi, ST_L1_F3);
 477 }
 478
 479 static void
 480 l1_go_F5(struct FsmInst *fi, int event, void *arg)
 481 {
 482         FsmChangeState(fi, ST_L1_F5);
 483 }
 484
 485 static void
 486 l1_go_F8(struct FsmInst *fi, int event, void *arg)
 487 {
 488         FsmChangeState(fi, ST_L1_F8);
 489 }
 490
 491 static void
 492 l1_info2_ind(struct FsmInst *fi, int event, void *arg)
 493 {
 494         struct PStack *st = fi->userdata;
 495
 496 #ifdef HISAX_UINTERFACE
 497         if (test_bit(FLG_L1_UINT, &st->l1.Flags))
 498                 FsmChangeState(fi, ST_L1_SYNC2);
 499         else
 500 #endif
 501                 FsmChangeState(fi, ST_L1_F6);
 502         st->l1.l1hw(st, HW_INFO3 | REQUEST, NULL);
 503 }
 504
 505 static void
 506 l1_info4_ind(struct FsmInst *fi, int event, void *arg)
 507 {
 508         struct PStack *st = fi->userdata;
 509
 510 #ifdef HISAX_UINTERFACE
 511         if (test_bit(FLG_L1_UINT, &st->l1.Flags))
 512                 FsmChangeState(fi, ST_L1_TRANS);
 513         else
 514 #endif
 515                 FsmChangeState(fi, ST_L1_F7);
 516         st->l1.l1hw(st, HW_INFO3 | REQUEST, NULL);
 517         if (test_and_clear_bit(FLG_L1_DEACTTIMER, &st->l1.Flags))
 518                 FsmDelTimer(&st->l1.timer, 4);
 519         if (!test_bit(FLG_L1_ACTIVATED, &st->l1.Flags)) {
 520                 if (test_and_clear_bit(FLG_L1_T3RUN, &st->l1.Flags))
 521                         FsmDelTimer(&st->l1.timer, 3);
 522                 FsmRestartTimer(&st->l1.timer, 110, EV_TIMER_ACT, NULL, 2);
 523                 test_and_set_bit(FLG_L1_ACTTIMER, &st->l1.Flags);
 524         }
 525 }
 526
 527 static void
 528 l1_timer3(struct FsmInst *fi, int event, void *arg)
 529 {
 530         struct PStack *st = fi->userdata;
 531
 532         test_and_clear_bit(FLG_L1_T3RUN, &st->l1.Flags);
 533         if (test_and_clear_bit(FLG_L1_ACTIVATING, &st->l1.Flags))
 534                 L1deactivated(st->l1.hardware);
 535
 536 #ifdef HISAX_UINTERFACE
 537         if (!test_bit(FLG_L1_UINT, &st->l1.Flags))
 538 #endif
 539         if (st->l1.l1m.state != ST_L1_F6) {
 540                 FsmChangeState(fi, ST_L1_F3);
 541                 st->l1.l1hw(st, HW_ENABLE | REQUEST, NULL);
 542         }
 543 }
 544
 545 static void
 546 l1_timer_act(struct FsmInst *fi, int event, void *arg)
 547 {
 548         struct PStack *st = fi->userdata;
 549
 550         test_and_clear_bit(FLG_L1_ACTTIMER, &st->l1.Flags);
 551         test_and_set_bit(FLG_L1_ACTIVATED, &st->l1.Flags);
 552         L1activated(st->l1.hardware);
 553 }
 554
 555 static void
 556 l1_timer_deact(struct FsmInst *fi, int event, void *arg)
 557 {
 558         struct PStack *st = fi->userdata;
 559
 560         test_and_clear_bit(FLG_L1_DEACTTIMER, &st->l1.Flags);
 561         test_and_clear_bit(FLG_L1_ACTIVATED, &st->l1.Flags);
 562         L1deactivated(st->l1.hardware);
 563         st->l1.l1hw(st, HW_DEACTIVATE | RESPONSE, NULL);
 564 }
 565
 566 static void
 567 l1_activate_s(struct FsmInst *fi, int event, void *arg)
 568 {
 569         struct PStack *st = fi->userdata;
 570
 571         st->l1.l1hw(st, HW_RESET | REQUEST, NULL);
 572 }
 573
 574 static void
 575 l1_activate_no(struct FsmInst *fi, int event, void *arg)
 576 {
 577         struct PStack *st = fi->userdata;
 578
 579         if ((!test_bit(FLG_L1_DEACTTIMER, &st->l1.Flags)) && (!test_bit(FLG_L1_T3RUN, &st->l1.Flags))) {
 580                 test_and_clear_bit(FLG_L1_ACTIVATING, &st->l1.Flags);
 581                 L1deactivated(st->l1.hardware);
 582         }
 583 }
 584
 585 static struct FsmNode L1SFnList[] __initdata =
 586 {
 587         {ST_L1_F3, EV_PH_ACTIVATE, l1_activate_s},
 588         {ST_L1_F6, EV_PH_ACTIVATE, l1_activate_no},
 589         {ST_L1_F8, EV_PH_ACTIVATE, l1_activate_no},
 590         {ST_L1_F3, EV_RESET_IND, l1_reset},
 591         {ST_L1_F4, EV_RESET_IND, l1_reset},
 592         {ST_L1_F5, EV_RESET_IND, l1_reset},
 593         {ST_L1_F6, EV_RESET_IND, l1_reset},
 594         {ST_L1_F7, EV_RESET_IND, l1_reset},
 595         {ST_L1_F8, EV_RESET_IND, l1_reset},
 596         {ST_L1_F3, EV_DEACT_CNF, l1_deact_cnf},
 597         {ST_L1_F4, EV_DEACT_CNF, l1_deact_cnf},
 598         {ST_L1_F5, EV_DEACT_CNF, l1_deact_cnf},
 599         {ST_L1_F6, EV_DEACT_CNF, l1_deact_cnf},
 600         {ST_L1_F7, EV_DEACT_CNF, l1_deact_cnf},
 601         {ST_L1_F8, EV_DEACT_CNF, l1_deact_cnf},
 602         {ST_L1_F6, EV_DEACT_IND, l1_deact_req_s},
 603         {ST_L1_F7, EV_DEACT_IND, l1_deact_req_s},
 604         {ST_L1_F8, EV_DEACT_IND, l1_deact_req_s},
 605         {ST_L1_F3, EV_POWER_UP, l1_power_up_s},
 606         {ST_L1_F4, EV_RSYNC_IND, l1_go_F5},
 607         {ST_L1_F6, EV_RSYNC_IND, l1_go_F8},
 608         {ST_L1_F7, EV_RSYNC_IND, l1_go_F8},
 609         {ST_L1_F3, EV_INFO2_IND, l1_info2_ind},
 610         {ST_L1_F4, EV_INFO2_IND, l1_info2_ind},
 611         {ST_L1_F5, EV_INFO2_IND, l1_info2_ind},
 612         {ST_L1_F7, EV_INFO2_IND, l1_info2_ind},
 613         {ST_L1_F8, EV_INFO2_IND, l1_info2_ind},
 614         {ST_L1_F3, EV_INFO4_IND, l1_info4_ind},
 615         {ST_L1_F4, EV_INFO4_IND, l1_info4_ind},
 616         {ST_L1_F5, EV_INFO4_IND, l1_info4_ind},
 617         {ST_L1_F6, EV_INFO4_IND, l1_info4_ind},
 618         {ST_L1_F8, EV_INFO4_IND, l1_info4_ind},
 619         {ST_L1_F3, EV_TIMER3, l1_timer3},
 620         {ST_L1_F4, EV_TIMER3, l1_timer3},
 621         {ST_L1_F5, EV_TIMER3, l1_timer3},
 622         {ST_L1_F6, EV_TIMER3, l1_timer3},
 623         {ST_L1_F8, EV_TIMER3, l1_timer3},
 624         {ST_L1_F7, EV_TIMER_ACT, l1_timer_act},
 625         {ST_L1_F3, EV_TIMER_DEACT, l1_timer_deact},
 626         {ST_L1_F4, EV_TIMER_DEACT, l1_timer_deact},
 627         {ST_L1_F5, EV_TIMER_DEACT, l1_timer_deact},
 628         {ST_L1_F6, EV_TIMER_DEACT, l1_timer_deact},
 629         {ST_L1_F7, EV_TIMER_DEACT, l1_timer_deact},
 630         {ST_L1_F8, EV_TIMER_DEACT, l1_timer_deact},
 631 };
 632
 633 #define L1S_FN_COUNT (sizeof(L1SFnList)/sizeof(struct FsmNode))
 634
 635 #ifdef HISAX_UINTERFACE
 636 static void
 637 l1_deact_req_u(struct FsmInst *fi, int event, void *arg)
 638 {
 639         struct PStack *st = fi->userdata;
 640
 641         FsmChangeState(fi, ST_L1_RESET);
 642         FsmRestartTimer(&st->l1.timer, 550, EV_TIMER_DEACT, NULL, 2);
 643         test_and_set_bit(FLG_L1_DEACTTIMER, &st->l1.Flags);
 644         st->l1.l1hw(st, HW_ENABLE | REQUEST, NULL);
 645 }
 646
 647 static void
 648 l1_power_up_u(struct FsmInst *fi, int event, void *arg)
 649 {
 650         struct PStack *st = fi->userdata;
 651
 652         FsmRestartTimer(&st->l1.timer, TIMER3_VALUE, EV_TIMER3, NULL, 2);
 653         test_and_set_bit(FLG_L1_T3RUN, &st->l1.Flags);
 654 }
 655
 656 static void
 657 l1_info0_ind(struct FsmInst *fi, int event, void *arg)
 658 {
 659         FsmChangeState(fi, ST_L1_DEACT);
 660 }
 661
 662 static void
 663 l1_activate_u(struct FsmInst *fi, int event, void *arg)
 664 {
 665         struct PStack *st = fi->userdata;
 666
 667         st->l1.l1hw(st, HW_INFO1 | REQUEST, NULL);
 668 }
 669
 670 static struct FsmNode L1UFnList[] __initdata =
 671 {
 672         {ST_L1_RESET, EV_DEACT_IND, l1_deact_req_u},
 673         {ST_L1_DEACT, EV_DEACT_IND, l1_deact_req_u},
 674         {ST_L1_SYNC2, EV_DEACT_IND, l1_deact_req_u},
 675         {ST_L1_TRANS, EV_DEACT_IND, l1_deact_req_u},
 676         {ST_L1_DEACT, EV_PH_ACTIVATE, l1_activate_u},
 677         {ST_L1_DEACT, EV_POWER_UP, l1_power_up_u},
 678         {ST_L1_DEACT, EV_INFO2_IND, l1_info2_ind},
 679         {ST_L1_TRANS, EV_INFO2_IND, l1_info2_ind},
 680         {ST_L1_RESET, EV_DEACT_CNF, l1_info0_ind},
 681         {ST_L1_DEACT, EV_INFO4_IND, l1_info4_ind},
 682         {ST_L1_SYNC2, EV_INFO4_IND, l1_info4_ind},
 683         {ST_L1_RESET, EV_INFO4_IND, l1_info4_ind},
 684         {ST_L1_DEACT, EV_TIMER3, l1_timer3},
 685         {ST_L1_SYNC2, EV_TIMER3, l1_timer3},
 686         {ST_L1_TRANS, EV_TIMER_ACT, l1_timer_act},
 687         {ST_L1_DEACT, EV_TIMER_DEACT, l1_timer_deact},
 688         {ST_L1_SYNC2, EV_TIMER_DEACT, l1_timer_deact},
 689         {ST_L1_RESET, EV_TIMER_DEACT, l1_timer_deact},
 690 };
 691
 692 #define L1U_FN_COUNT (sizeof(L1UFnList)/sizeof(struct FsmNode))
 693
 694 #endif
 695
 696 static void
 697 l1b_activate(struct FsmInst *fi, int event, void *arg)
 698 {
 699         struct PStack *st = fi->userdata;
 700
 701         FsmChangeState(fi, ST_L1_WAIT_ACT);
 702         FsmRestartTimer(&st->l1.timer, st->l1.delay, EV_TIMER_ACT, NULL, 2);
 703 }
 704
 705 static void
 706 l1b_deactivate(struct FsmInst *fi, int event, void *arg)
 707 {
 708         struct PStack *st = fi->userdata;
 709
 710         FsmChangeState(fi, ST_L1_WAIT_DEACT);
 711         FsmRestartTimer(&st->l1.timer, 10, EV_TIMER_DEACT, NULL, 2);
 712 }
 713
 714 static void
 715 l1b_timer_act(struct FsmInst *fi, int event, void *arg)
 716 {
 717         struct PStack *st = fi->userdata;
 718
 719         FsmChangeState(fi, ST_L1_ACTIV);
 720         st->l1.l1l2(st, PH_ACTIVATE | CONFIRM, NULL);
 721 }
 722
 723 static void
 724 l1b_timer_deact(struct FsmInst *fi, int event, void *arg)
 725 {
 726         struct PStack *st = fi->userdata;
 727
 728         FsmChangeState(fi, ST_L1_NULL);
 729         st->l2.l2l1(st, PH_DEACTIVATE | CONFIRM, NULL);
 730 }
 731
 732 static struct FsmNode L1BFnList[] __initdata =
 733 {
 734         {ST_L1_NULL, EV_PH_ACTIVATE, l1b_activate},
 735         {ST_L1_WAIT_ACT, EV_TIMER_ACT, l1b_timer_act},
 736         {ST_L1_ACTIV, EV_PH_DEACTIVATE, l1b_deactivate},
 737         {ST_L1_WAIT_DEACT, EV_TIMER_DEACT, l1b_timer_deact},
 738 };
 739
 740 #define L1B_FN_COUNT (sizeof(L1BFnList)/sizeof(struct FsmNode))
 741
 742 int __init
 743 Isdnl1New(void)
 744 {
 745         int retval;
 746
 747         l1fsm_s.state_count = L1S_STATE_COUNT;
 748         l1fsm_s.event_count = L1_EVENT_COUNT;
 749         l1fsm_s.strEvent = strL1Event;
 750         l1fsm_s.strState = strL1SState;
 751         retval = FsmNew(&l1fsm_s, L1SFnList, L1S_FN_COUNT);
 752         if (retval)
 753                 return retval;
 754
 755         l1fsm_b.state_count = L1B_STATE_COUNT;
 756         l1fsm_b.event_count = L1_EVENT_COUNT;
 757         l1fsm_b.strEvent = strL1Event;
 758         l1fsm_b.strState = strL1BState;
 759         retval = FsmNew(&l1fsm_b, L1BFnList, L1B_FN_COUNT);
 760         if (retval) {
 761                 FsmFree(&l1fsm_s);
 762                 return retval;
 763         }
 764 #ifdef HISAX_UINTERFACE
 765         l1fsm_u.state_count = L1U_STATE_COUNT;
 766         l1fsm_u.event_count = L1_EVENT_COUNT;
 767         l1fsm_u.strEvent = strL1Event;
 768         l1fsm_u.strState = strL1UState;
 769         retval = FsmNew(&l1fsm_u, L1UFnList, L1U_FN_COUNT);
 770         if (retval) {
 771                 FsmFree(&l1fsm_s);
 772                 FsmFree(&l1fsm_b);
 773                 return retval;
 774         }
 775 #endif
 776         return 0;
 777 }
 778
 779 void Isdnl1Free(void)
 780 {
 781 #ifdef HISAX_UINTERFACE
 782         FsmFree(&l1fsm_u);
 783 #endif
 784         FsmFree(&l1fsm_s);
 785         FsmFree(&l1fsm_b);
 786 }
 787
 788 static void
 789 dch_l2l1(struct PStack *st, int pr, void *arg)
 790 {
 791         struct IsdnCardState *cs = (struct IsdnCardState *) st->l1.hardware;
 792
 793         switch (pr) {
 794                 case (PH_DATA | REQUEST):
 795                 case (PH_PULL | REQUEST):
 796                 case (PH_PULL |INDICATION):
 797                         st->l1.l1hw(st, pr, arg);
 798                         break;
 799                 case (PH_ACTIVATE | REQUEST):
 800                         if (cs->debug)
 801                                 debugl1(cs, "PH_ACTIVATE_REQ %s",
 802                                         st->l1.l1m.fsm->strState[st->l1.l1m.state]);
 803                         if (test_bit(FLG_L1_ACTIVATED, &st->l1.Flags))
 804                                 st->l1.l1l2(st, PH_ACTIVATE | CONFIRM, NULL);
 805                         else {
 806                                 test_and_set_bit(FLG_L1_ACTIVATING, &st->l1.Flags);
 807                                 FsmEvent(&st->l1.l1m, EV_PH_ACTIVATE, arg);
 808                         }
 809                         break;
 810                 case (PH_TESTLOOP | REQUEST):
 811                         if (1 & (long) arg)
 812                                 debugl1(cs, "PH_TEST_LOOP B1");
 813                         if (2 & (long) arg)
 814                                 debugl1(cs, "PH_TEST_LOOP B2");
 815                         if (!(3 & (long) arg))
 816                                 debugl1(cs, "PH_TEST_LOOP DISABLED");
 817                         st->l1.l1hw(st, HW_TESTLOOP | REQUEST, arg);
 818                         break;
 819                 default:
 820                         if (cs->debug)
 821                                 debugl1(cs, "dch_l2l1 msg %04X unhandled", pr);
 822                         break;
 823         }
 824 }
 825
 826 void
 827 l1_msg(struct IsdnCardState *cs, int pr, void *arg) {
 828         struct PStack *st;
 829
 830         st = cs->stlist;
 831
 832         while (st) {
 833                 switch(pr) {
 834                         case (HW_RESET | INDICATION):
 835                                 FsmEvent(&st->l1.l1m, EV_RESET_IND, arg);
 836                                 break;
 837                         case (HW_DEACTIVATE | CONFIRM):
 838                                 FsmEvent(&st->l1.l1m, EV_DEACT_CNF, arg);
 839                                 break;
 840                         case (HW_DEACTIVATE | INDICATION):
 841                                 FsmEvent(&st->l1.l1m, EV_DEACT_IND, arg);
 842                                 break;
 843                         case (HW_POWERUP | CONFIRM):
 844                                 FsmEvent(&st->l1.l1m, EV_POWER_UP, arg);
 845                                 break;
 846                         case (HW_RSYNC | INDICATION):
 847                                 FsmEvent(&st->l1.l1m, EV_RSYNC_IND, arg);
 848                                 break;
 849                         case (HW_INFO2 | INDICATION):
 850                                 FsmEvent(&st->l1.l1m, EV_INFO2_IND, arg);
 851                                 break;
 852                         case (HW_INFO4_P8 | INDICATION):
 853                         case (HW_INFO4_P10 | INDICATION):
 854                                 FsmEvent(&st->l1.l1m, EV_INFO4_IND, arg);
 855                                 break;
 856                         default:
 857                                 if (cs->debug)
 858                                         debugl1(cs, "l1msg %04X unhandled", pr);
 859                                 break;
 860                 }
 861                 st = st->next;
 862         }
 863 }
 864
 865 void
 866 l1_msg_b(struct PStack *st, int pr, void *arg) {
 867         switch(pr) {
 868                 case (PH_ACTIVATE | REQUEST):
 869                         FsmEvent(&st->l1.l1m, EV_PH_ACTIVATE, NULL);
 870                         break;
 871                 case (PH_DEACTIVATE | REQUEST):
 872                         FsmEvent(&st->l1.l1m, EV_PH_DEACTIVATE, NULL);
 873                         break;
 874         }
 875 }
 876
 877 void
 878 setstack_HiSax(struct PStack *st, struct IsdnCardState *cs)
 879 {
 880         st->l1.hardware = cs;
 881         st->protocol = cs->protocol;
 882         st->l1.l1m.fsm = &l1fsm_s;
 883         st->l1.l1m.state = ST_L1_F3;
 884         st->l1.Flags = 0;
 885 #ifdef HISAX_UINTERFACE
 886         if (test_bit(FLG_HW_L1_UINT, &cs->HW_Flags)) {
 887                 st->l1.l1m.fsm = &l1fsm_u;
 888                 st->l1.l1m.state = ST_L1_RESET;
 889                 st->l1.Flags = FLG_L1_UINT;
 890         }
 891 #endif
 892         st->l1.l1m.debug = cs->debug;
 893         st->l1.l1m.userdata = st;
 894         st->l1.l1m.userint = 0;
 895         st->l1.l1m.printdebug = l1m_debug;
 896         FsmInitTimer(&st->l1.l1m, &st->l1.timer);
 897         setstack_tei(st);
 898         setstack_manager(st);
 899         st->l1.stlistp = &(cs->stlist);
 900         st->l2.l2l1  = dch_l2l1;
 901         if (cs->setstack_d)
 902                 cs->setstack_d(st, cs);
 903 }
 904
 905 void
 906 setstack_l1_B(struct PStack *st)
 907 {
 908         struct IsdnCardState *cs = st->l1.hardware;
 909
 910         st->l1.l1m.fsm = &l1fsm_b;
 911         st->l1.l1m.state = ST_L1_NULL;
 912         st->l1.l1m.debug = cs->debug;
 913         st->l1.l1m.userdata = st;
 914         st->l1.l1m.userint = 0;
 915         st->l1.l1m.printdebug = l1m_debug;
 916         st->l1.Flags = 0;
 917         FsmInitTimer(&st->l1.l1m, &st->l1.timer);
 918 }