drivers/isdn/hisax/isdnl1.c

   1 /* $Id: isdnl1.c,v 2.46.2.5 2004/02/11 13:21:34 keil 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 #include <linux/init.h>
  22 #include <linux/gfp.h>
  23 #include "hisax.h"
  24 #include "isdnl1.h"
  25
  26 const char *l1_revision = "$Revision: 2.46.2.5 $";
  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 static 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 static 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
 203 void
 204 DChannel_proc_rcv(struct IsdnCardState *cs)
 205 {
 206         struct sk_buff *skb, *nskb;
 207         struct PStack *stptr = cs->stlist;
 208         int found, tei, sapi;
 209
 210         if (stptr)
 211                 if (test_bit(FLG_L1_ACTTIMER, &stptr->l1.Flags))
 212                         FsmEvent(&stptr->l1.l1m, EV_TIMER_ACT, NULL);
 213         while ((skb = skb_dequeue(&cs->rq))) {
 214 #ifdef L2FRAME_DEBUG            /* psa */
 215                 if (cs->debug & L1_DEB_LAPD)
 216                         Logl2Frame(cs, skb, "PH_DATA", 1);
 217 #endif
 218                 stptr = cs->stlist;
 219                 if (skb->len<3) {
 220                         debugl1(cs, "D-channel frame too short(%d)",skb->len);
 221                         dev_kfree_skb(skb);
 222                         return;
 223                 }
 224                 if ((skb->data[0] & 1) || !(skb->data[1] &1)) {
 225                         debugl1(cs, "D-channel frame wrong EA0/EA1");
 226                         dev_kfree_skb(skb);
 227                         return;
 228                 }
 229                 sapi = skb->data[0] >> 2;
 230                 tei = skb->data[1] >> 1;
 231                 if (cs->debug & DEB_DLOG_HEX)
 232                         LogFrame(cs, skb->data, skb->len);
 233                 if (cs->debug & DEB_DLOG_VERBOSE)
 234                         dlogframe(cs, skb, 1);
 235                 if (tei == GROUP_TEI) {
 236                         if (sapi == CTRL_SAPI) { /* sapi 0 */
 237                                 while (stptr != NULL) {
 238                                         if ((nskb = skb_clone(skb, GFP_ATOMIC)))
 239                                                 stptr->l1.l1l2(stptr, PH_DATA | INDICATION, nskb);
 240                                         else
 241                                                 printk(KERN_WARNING "HiSax: isdn broadcast buffer shortage\n");
 242                                         stptr = stptr->next;
 243                                 }
 244                         } else if (sapi == TEI_SAPI) {
 245                                 while (stptr != NULL) {
 246                                         if ((nskb = skb_clone(skb, GFP_ATOMIC)))
 247                                                 stptr->l1.l1tei(stptr, PH_DATA | INDICATION, nskb);
 248                                         else
 249                                                 printk(KERN_WARNING "HiSax: tei broadcast buffer shortage\n");
 250                                         stptr = stptr->next;
 251                                 }
 252                         }
 253                         dev_kfree_skb(skb);
 254                 } else if (sapi == CTRL_SAPI) { /* sapi 0 */
 255                         found = 0;
 256                         while (stptr != NULL)
 257                                 if (tei == stptr->l2.tei) {
 258                                         stptr->l1.l1l2(stptr, PH_DATA | INDICATION, skb);
 259                                         found = !0;
 260                                         break;
 261                                 } else
 262                                         stptr = stptr->next;
 263                         if (!found)
 264                                 dev_kfree_skb(skb);
 265                 } else
 266                         dev_kfree_skb(skb);
 267         }
 268 }
 269
 270 static void
 271 BChannel_proc_xmt(struct BCState *bcs)
 272 {
 273         struct PStack *st = bcs->st;
 274
 275         if (test_bit(BC_FLG_BUSY, &bcs->Flag)) {
 276                 debugl1(bcs->cs, "BC_BUSY Error");
 277                 return;
 278         }
 279
 280         if (test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags))
 281                 st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
 282         if (!test_bit(BC_FLG_ACTIV, &bcs->Flag)) {
 283                 if (!test_bit(BC_FLG_BUSY, &bcs->Flag) &&
 284                     skb_queue_empty(&bcs->squeue)) {
 285                         st->l2.l2l1(st, PH_DEACTIVATE | CONFIRM, NULL);
 286                 }
 287         }
 288 }
 289
 290 static void
 291 BChannel_proc_rcv(struct BCState *bcs)
 292 {
 293         struct sk_buff *skb;
 294
 295         if (bcs->st->l1.l1m.state == ST_L1_WAIT_ACT) {
 296                 FsmDelTimer(&bcs->st->l1.timer, 4);
 297                 FsmEvent(&bcs->st->l1.l1m, EV_TIMER_ACT, NULL);
 298         }
 299         while ((skb = skb_dequeue(&bcs->rqueue))) {
 300                 bcs->st->l1.l1l2(bcs->st, PH_DATA | INDICATION, skb);
 301         }
 302 }
 303
 304 static void
 305 BChannel_proc_ack(struct BCState *bcs)
 306 {
 307         u_long  flags;
 308         int     ack;
 309
 310         spin_lock_irqsave(&bcs->aclock, flags);
 311         ack = bcs->ackcnt;
 312         bcs->ackcnt = 0;
 313         spin_unlock_irqrestore(&bcs->aclock, flags);
 314         if (ack)
 315                 lli_writewakeup(bcs->st, ack);
 316 }
 317
 318 void
 319 BChannel_bh(struct work_struct *work)
 320 {
 321         struct BCState *bcs = container_of(work, struct BCState, tqueue);
 322
 323         if (!bcs)
 324                 return;
 325         if (test_and_clear_bit(B_RCVBUFREADY, &bcs->event))
 326                 BChannel_proc_rcv(bcs);
 327         if (test_and_clear_bit(B_XMTBUFREADY, &bcs->event))
 328                 BChannel_proc_xmt(bcs);
 329         if (test_and_clear_bit(B_ACKPENDING, &bcs->event))
 330                 BChannel_proc_ack(bcs);
 331 }
 332
 333 void
 334 HiSax_addlist(struct IsdnCardState *cs,
 335               struct PStack *st)
 336 {
 337         st->next = cs->stlist;
 338         cs->stlist = st;
 339 }
 340
 341 void
 342 HiSax_rmlist(struct IsdnCardState *cs,
 343              struct PStack *st)
 344 {
 345         struct PStack *p;
 346
 347         FsmDelTimer(&st->l1.timer, 0);
 348         if (cs->stlist == st)
 349                 cs->stlist = st->next;
 350         else {
 351                 p = cs->stlist;
 352                 while (p)
 353                         if (p->next == st) {
 354                                 p->next = st->next;
 355                                 return;
 356                         } else
 357                                 p = p->next;
 358         }
 359 }
 360
 361 void
 362 init_bcstate(struct IsdnCardState *cs, int bc)
 363 {
 364         struct BCState *bcs = cs->bcs + bc;
 365
 366         bcs->cs = cs;
 367         bcs->channel = bc;
 368         INIT_WORK(&bcs->tqueue, BChannel_bh);
 369         spin_lock_init(&bcs->aclock);
 370         bcs->BC_SetStack = NULL;
 371         bcs->BC_Close = NULL;
 372         bcs->Flag = 0;
 373 }
 374
 375 #ifdef L2FRAME_DEBUG            /* psa */
 376
 377 static char *
 378 l2cmd(u_char cmd)
 379 {
 380         switch (cmd & ~0x10) {
 381                 case 1:
 382                         return "RR";
 383                 case 5:
 384                         return "RNR";
 385                 case 9:
 386                         return "REJ";
 387                 case 0x6f:
 388                         return "SABME";
 389                 case 0x0f:
 390                         return "DM";
 391                 case 3:
 392                         return "UI";
 393                 case 0x43:
 394                         return "DISC";
 395                 case 0x63:
 396                         return "UA";
 397                 case 0x87:
 398                         return "FRMR";
 399                 case 0xaf:
 400                         return "XID";
 401                 default:
 402                         if (!(cmd & 1))
 403                                 return "I";
 404                         else
 405                                 return "invalid command";
 406         }
 407 }
 408
 409 static char tmpdeb[32];
 410
 411 static char *
 412 l2frames(u_char * ptr)
 413 {
 414         switch (ptr[2] & ~0x10) {
 415                 case 1:
 416                 case 5:
 417                 case 9:
 418                         sprintf(tmpdeb, "%s[%d](nr %d)", l2cmd(ptr[2]), ptr[3] & 1, ptr[3] >> 1);
 419                         break;
 420                 case 0x6f:
 421                 case 0x0f:
 422                 case 3:
 423                 case 0x43:
 424                 case 0x63:
 425                 case 0x87:
 426                 case 0xaf:
 427                         sprintf(tmpdeb, "%s[%d]", l2cmd(ptr[2]), (ptr[2] & 0x10) >> 4);
 428                         break;
 429                 default:
 430                         if (!(ptr[2] & 1)) {
 431                                 sprintf(tmpdeb, "I[%d](ns %d, nr %d)", ptr[3] & 1, ptr[2] >> 1, ptr[3] >> 1);
 432                                 break;
 433                         } else
 434                                 return "invalid command";
 435         }
 436
 437
 438         return tmpdeb;
 439 }
 440
 441 void
 442 Logl2Frame(struct IsdnCardState *cs, struct sk_buff *skb, char *buf, int dir)
 443 {
 444         u_char *ptr;
 445
 446         ptr = skb->data;
 447
 448         if (ptr[0] & 1 || !(ptr[1] & 1))
 449                 debugl1(cs, "Address not LAPD");
 450         else
 451                 debugl1(cs, "%s %s: %s%c (sapi %d, tei %d)",
 452                         (dir ? "<-" : "->"), buf, l2frames(ptr),
 453                         ((ptr[0] & 2) >> 1) == dir ? 'C' : 'R', ptr[0] >> 2, ptr[1] >> 1);
 454 }
 455 #endif
 456
 457 static void
 458 l1_reset(struct FsmInst *fi, int event, void *arg)
 459 {
 460         FsmChangeState(fi, ST_L1_F3);
 461 }
 462
 463 static void
 464 l1_deact_cnf(struct FsmInst *fi, int event, void *arg)
 465 {
 466         struct PStack *st = fi->userdata;
 467
 468         FsmChangeState(fi, ST_L1_F3);
 469         if (test_bit(FLG_L1_ACTIVATING, &st->l1.Flags))
 470                 st->l1.l1hw(st, HW_ENABLE | REQUEST, NULL);
 471 }
 472
 473 static void
 474 l1_deact_req_s(struct FsmInst *fi, int event, void *arg)
 475 {
 476         struct PStack *st = fi->userdata;
 477
 478         FsmChangeState(fi, ST_L1_F3);
 479         FsmRestartTimer(&st->l1.timer, 550, EV_TIMER_DEACT, NULL, 2);
 480         test_and_set_bit(FLG_L1_DEACTTIMER, &st->l1.Flags);
 481 }
 482
 483 static void
 484 l1_power_up_s(struct FsmInst *fi, int event, void *arg)
 485 {
 486         struct PStack *st = fi->userdata;
 487
 488         if (test_bit(FLG_L1_ACTIVATING, &st->l1.Flags)) {
 489                 FsmChangeState(fi, ST_L1_F4);
 490                 st->l1.l1hw(st, HW_INFO3 | REQUEST, NULL);
 491                 FsmRestartTimer(&st->l1.timer, TIMER3_VALUE, EV_TIMER3, NULL, 2);
 492                 test_and_set_bit(FLG_L1_T3RUN, &st->l1.Flags);
 493         } else
 494                 FsmChangeState(fi, ST_L1_F3);
 495 }
 496
 497 static void
 498 l1_go_F5(struct FsmInst *fi, int event, void *arg)
 499 {
 500         FsmChangeState(fi, ST_L1_F5);
 501 }
 502
 503 static void
 504 l1_go_F8(struct FsmInst *fi, int event, void *arg)
 505 {
 506         FsmChangeState(fi, ST_L1_F8);
 507 }
 508
 509 static void
 510 l1_info2_ind(struct FsmInst *fi, int event, void *arg)
 511 {
 512         struct PStack *st = fi->userdata;
 513
 514 #ifdef HISAX_UINTERFACE
 515         if (test_bit(FLG_L1_UINT, &st->l1.Flags))
 516                 FsmChangeState(fi, ST_L1_SYNC2);
 517         else
 518 #endif
 519                 FsmChangeState(fi, ST_L1_F6);
 520         st->l1.l1hw(st, HW_INFO3 | REQUEST, NULL);
 521 }
 522
 523 static void
 524 l1_info4_ind(struct FsmInst *fi, int event, void *arg)
 525 {
 526         struct PStack *st = fi->userdata;
 527
 528 #ifdef HISAX_UINTERFACE
 529         if (test_bit(FLG_L1_UINT, &st->l1.Flags))
 530                 FsmChangeState(fi, ST_L1_TRANS);
 531         else
 532 #endif
 533                 FsmChangeState(fi, ST_L1_F7);
 534         st->l1.l1hw(st, HW_INFO3 | REQUEST, NULL);
 535         if (test_and_clear_bit(FLG_L1_DEACTTIMER, &st->l1.Flags))
 536                 FsmDelTimer(&st->l1.timer, 4);
 537         if (!test_bit(FLG_L1_ACTIVATED, &st->l1.Flags)) {
 538                 if (test_and_clear_bit(FLG_L1_T3RUN, &st->l1.Flags))
 539                         FsmDelTimer(&st->l1.timer, 3);
 540                 FsmRestartTimer(&st->l1.timer, 110, EV_TIMER_ACT, NULL, 2);
 541                 test_and_set_bit(FLG_L1_ACTTIMER, &st->l1.Flags);
 542         }
 543 }
 544
 545 static void
 546 l1_timer3(struct FsmInst *fi, int event, void *arg)
 547 {
 548         struct PStack *st = fi->userdata;
 549
 550         test_and_clear_bit(FLG_L1_T3RUN, &st->l1.Flags);
 551         if (test_and_clear_bit(FLG_L1_ACTIVATING, &st->l1.Flags))
 552                 L1deactivated(st->l1.hardware);
 553
 554 #ifdef HISAX_UINTERFACE
 555         if (!test_bit(FLG_L1_UINT, &st->l1.Flags))
 556 #endif
 557         if (st->l1.l1m.state != ST_L1_F6) {
 558                 FsmChangeState(fi, ST_L1_F3);
 559                 st->l1.l1hw(st, HW_ENABLE | REQUEST, NULL);
 560         }
 561 }
 562
 563 static void
 564 l1_timer_act(struct FsmInst *fi, int event, void *arg)
 565 {
 566         struct PStack *st = fi->userdata;
 567
 568         test_and_clear_bit(FLG_L1_ACTTIMER, &st->l1.Flags);
 569         test_and_set_bit(FLG_L1_ACTIVATED, &st->l1.Flags);
 570         L1activated(st->l1.hardware);
 571 }
 572
 573 static void
 574 l1_timer_deact(struct FsmInst *fi, int event, void *arg)
 575 {
 576         struct PStack *st = fi->userdata;
 577
 578         test_and_clear_bit(FLG_L1_DEACTTIMER, &st->l1.Flags);
 579         test_and_clear_bit(FLG_L1_ACTIVATED, &st->l1.Flags);
 580         L1deactivated(st->l1.hardware);
 581         st->l1.l1hw(st, HW_DEACTIVATE | RESPONSE, NULL);
 582 }
 583
 584 static void
 585 l1_activate_s(struct FsmInst *fi, int event, void *arg)
 586 {
 587         struct PStack *st = fi->userdata;
 588
 589         st->l1.l1hw(st, HW_RESET | REQUEST, NULL);
 590 }
 591
 592 static void
 593 l1_activate_no(struct FsmInst *fi, int event, void *arg)
 594 {
 595         struct PStack *st = fi->userdata;
 596
 597         if ((!test_bit(FLG_L1_DEACTTIMER, &st->l1.Flags)) && (!test_bit(FLG_L1_T3RUN, &st->l1.Flags))) {
 598                 test_and_clear_bit(FLG_L1_ACTIVATING, &st->l1.Flags);
 599                 L1deactivated(st->l1.hardware);
 600         }
 601 }
 602
 603 static struct FsmNode L1SFnList[] __initdata =
 604 {
 605         {ST_L1_F3, EV_PH_ACTIVATE, l1_activate_s},
 606         {ST_L1_F6, EV_PH_ACTIVATE, l1_activate_no},
 607         {ST_L1_F8, EV_PH_ACTIVATE, l1_activate_no},
 608         {ST_L1_F3, EV_RESET_IND, l1_reset},
 609         {ST_L1_F4, EV_RESET_IND, l1_reset},
 610         {ST_L1_F5, EV_RESET_IND, l1_reset},
 611         {ST_L1_F6, EV_RESET_IND, l1_reset},
 612         {ST_L1_F7, EV_RESET_IND, l1_reset},
 613         {ST_L1_F8, EV_RESET_IND, l1_reset},
 614         {ST_L1_F3, EV_DEACT_CNF, l1_deact_cnf},
 615         {ST_L1_F4, EV_DEACT_CNF, l1_deact_cnf},
 616         {ST_L1_F5, EV_DEACT_CNF, l1_deact_cnf},
 617         {ST_L1_F6, EV_DEACT_CNF, l1_deact_cnf},
 618         {ST_L1_F7, EV_DEACT_CNF, l1_deact_cnf},
 619         {ST_L1_F8, EV_DEACT_CNF, l1_deact_cnf},
 620         {ST_L1_F6, EV_DEACT_IND, l1_deact_req_s},
 621         {ST_L1_F7, EV_DEACT_IND, l1_deact_req_s},
 622         {ST_L1_F8, EV_DEACT_IND, l1_deact_req_s},
 623         {ST_L1_F3, EV_POWER_UP, l1_power_up_s},
 624         {ST_L1_F4, EV_RSYNC_IND, l1_go_F5},
 625         {ST_L1_F6, EV_RSYNC_IND, l1_go_F8},
 626         {ST_L1_F7, EV_RSYNC_IND, l1_go_F8},
 627         {ST_L1_F3, EV_INFO2_IND, l1_info2_ind},
 628         {ST_L1_F4, EV_INFO2_IND, l1_info2_ind},
 629         {ST_L1_F5, EV_INFO2_IND, l1_info2_ind},
 630         {ST_L1_F7, EV_INFO2_IND, l1_info2_ind},
 631         {ST_L1_F8, EV_INFO2_IND, l1_info2_ind},
 632         {ST_L1_F3, EV_INFO4_IND, l1_info4_ind},
 633         {ST_L1_F4, EV_INFO4_IND, l1_info4_ind},
 634         {ST_L1_F5, EV_INFO4_IND, l1_info4_ind},
 635         {ST_L1_F6, EV_INFO4_IND, l1_info4_ind},
 636         {ST_L1_F8, EV_INFO4_IND, l1_info4_ind},
 637         {ST_L1_F3, EV_TIMER3, l1_timer3},
 638         {ST_L1_F4, EV_TIMER3, l1_timer3},
 639         {ST_L1_F5, EV_TIMER3, l1_timer3},
 640         {ST_L1_F6, EV_TIMER3, l1_timer3},
 641         {ST_L1_F8, EV_TIMER3, l1_timer3},
 642         {ST_L1_F7, EV_TIMER_ACT, l1_timer_act},
 643         {ST_L1_F3, EV_TIMER_DEACT, l1_timer_deact},
 644         {ST_L1_F4, EV_TIMER_DEACT, l1_timer_deact},
 645         {ST_L1_F5, EV_TIMER_DEACT, l1_timer_deact},
 646         {ST_L1_F6, EV_TIMER_DEACT, l1_timer_deact},
 647         {ST_L1_F7, EV_TIMER_DEACT, l1_timer_deact},
 648         {ST_L1_F8, EV_TIMER_DEACT, l1_timer_deact},
 649 };
 650
 651 #ifdef HISAX_UINTERFACE
 652 static void
 653 l1_deact_req_u(struct FsmInst *fi, int event, void *arg)
 654 {
 655         struct PStack *st = fi->userdata;
 656
 657         FsmChangeState(fi, ST_L1_RESET);
 658         FsmRestartTimer(&st->l1.timer, 550, EV_TIMER_DEACT, NULL, 2);
 659         test_and_set_bit(FLG_L1_DEACTTIMER, &st->l1.Flags);
 660         st->l1.l1hw(st, HW_ENABLE | REQUEST, NULL);
 661 }
 662
 663 static void
 664 l1_power_up_u(struct FsmInst *fi, int event, void *arg)
 665 {
 666         struct PStack *st = fi->userdata;
 667
 668         FsmRestartTimer(&st->l1.timer, TIMER3_VALUE, EV_TIMER3, NULL, 2);
 669         test_and_set_bit(FLG_L1_T3RUN, &st->l1.Flags);
 670 }
 671
 672 static void
 673 l1_info0_ind(struct FsmInst *fi, int event, void *arg)
 674 {
 675         FsmChangeState(fi, ST_L1_DEACT);
 676 }
 677
 678 static void
 679 l1_activate_u(struct FsmInst *fi, int event, void *arg)
 680 {
 681         struct PStack *st = fi->userdata;
 682
 683         st->l1.l1hw(st, HW_INFO1 | REQUEST, NULL);
 684 }
 685
 686 static struct FsmNode L1UFnList[] __initdata =
 687 {
 688         {ST_L1_RESET, EV_DEACT_IND, l1_deact_req_u},
 689         {ST_L1_DEACT, EV_DEACT_IND, l1_deact_req_u},
 690         {ST_L1_SYNC2, EV_DEACT_IND, l1_deact_req_u},
 691         {ST_L1_TRANS, EV_DEACT_IND, l1_deact_req_u},
 692         {ST_L1_DEACT, EV_PH_ACTIVATE, l1_activate_u},
 693         {ST_L1_DEACT, EV_POWER_UP, l1_power_up_u},
 694         {ST_L1_DEACT, EV_INFO2_IND, l1_info2_ind},
 695         {ST_L1_TRANS, EV_INFO2_IND, l1_info2_ind},
 696         {ST_L1_RESET, EV_DEACT_CNF, l1_info0_ind},
 697         {ST_L1_DEACT, EV_INFO4_IND, l1_info4_ind},
 698         {ST_L1_SYNC2, EV_INFO4_IND, l1_info4_ind},
 699         {ST_L1_RESET, EV_INFO4_IND, l1_info4_ind},
 700         {ST_L1_DEACT, EV_TIMER3, l1_timer3},
 701         {ST_L1_SYNC2, EV_TIMER3, l1_timer3},
 702         {ST_L1_TRANS, EV_TIMER_ACT, l1_timer_act},
 703         {ST_L1_DEACT, EV_TIMER_DEACT, l1_timer_deact},
 704         {ST_L1_SYNC2, EV_TIMER_DEACT, l1_timer_deact},
 705         {ST_L1_RESET, EV_TIMER_DEACT, l1_timer_deact},
 706 };
 707
 708 #endif
 709
 710 static void
 711 l1b_activate(struct FsmInst *fi, int event, void *arg)
 712 {
 713         struct PStack *st = fi->userdata;
 714
 715         FsmChangeState(fi, ST_L1_WAIT_ACT);
 716         FsmRestartTimer(&st->l1.timer, st->l1.delay, EV_TIMER_ACT, NULL, 2);
 717 }
 718
 719 static void
 720 l1b_deactivate(struct FsmInst *fi, int event, void *arg)
 721 {
 722         struct PStack *st = fi->userdata;
 723
 724         FsmChangeState(fi, ST_L1_WAIT_DEACT);
 725         FsmRestartTimer(&st->l1.timer, 10, EV_TIMER_DEACT, NULL, 2);
 726 }
 727
 728 static void
 729 l1b_timer_act(struct FsmInst *fi, int event, void *arg)
 730 {
 731         struct PStack *st = fi->userdata;
 732
 733         FsmChangeState(fi, ST_L1_ACTIV);
 734         st->l1.l1l2(st, PH_ACTIVATE | CONFIRM, NULL);
 735 }
 736
 737 static void
 738 l1b_timer_deact(struct FsmInst *fi, int event, void *arg)
 739 {
 740         struct PStack *st = fi->userdata;
 741
 742         FsmChangeState(fi, ST_L1_NULL);
 743         st->l2.l2l1(st, PH_DEACTIVATE | CONFIRM, NULL);
 744 }
 745
 746 static struct FsmNode L1BFnList[] __initdata =
 747 {
 748         {ST_L1_NULL, EV_PH_ACTIVATE, l1b_activate},
 749         {ST_L1_WAIT_ACT, EV_TIMER_ACT, l1b_timer_act},
 750         {ST_L1_ACTIV, EV_PH_DEACTIVATE, l1b_deactivate},
 751         {ST_L1_WAIT_DEACT, EV_TIMER_DEACT, l1b_timer_deact},
 752 };
 753
 754 int __init
 755 Isdnl1New(void)
 756 {
 757         int retval;
 758
 759         l1fsm_s.state_count = L1S_STATE_COUNT;
 760         l1fsm_s.event_count = L1_EVENT_COUNT;
 761         l1fsm_s.strEvent = strL1Event;
 762         l1fsm_s.strState = strL1SState;
 763         retval = FsmNew(&l1fsm_s, L1SFnList, ARRAY_SIZE(L1SFnList));
 764         if (retval)
 765                 return retval;
 766
 767         l1fsm_b.state_count = L1B_STATE_COUNT;
 768         l1fsm_b.event_count = L1_EVENT_COUNT;
 769         l1fsm_b.strEvent = strL1Event;
 770         l1fsm_b.strState = strL1BState;
 771         retval = FsmNew(&l1fsm_b, L1BFnList, ARRAY_SIZE(L1BFnList));
 772         if (retval) {
 773                 FsmFree(&l1fsm_s);
 774                 return retval;
 775         }
 776 #ifdef HISAX_UINTERFACE
 777         l1fsm_u.state_count = L1U_STATE_COUNT;
 778         l1fsm_u.event_count = L1_EVENT_COUNT;
 779         l1fsm_u.strEvent = strL1Event;
 780         l1fsm_u.strState = strL1UState;
 781         retval = FsmNew(&l1fsm_u, L1UFnList, ARRAY_SIZE(L1UFnList));
 782         if (retval) {
 783                 FsmFree(&l1fsm_s);
 784                 FsmFree(&l1fsm_b);
 785                 return retval;
 786         }
 787 #endif
 788         return 0;
 789 }
 790
 791 void Isdnl1Free(void)
 792 {
 793 #ifdef HISAX_UINTERFACE
 794         FsmFree(&l1fsm_u);
 795 #endif
 796         FsmFree(&l1fsm_s);
 797         FsmFree(&l1fsm_b);
 798 }
 799
 800 static void
 801 dch_l2l1(struct PStack *st, int pr, void *arg)
 802 {
 803         struct IsdnCardState *cs = (struct IsdnCardState *) st->l1.hardware;
 804
 805         switch (pr) {
 806                 case (PH_DATA | REQUEST):
 807                 case (PH_PULL | REQUEST):
 808                 case (PH_PULL |INDICATION):
 809                         st->l1.l1hw(st, pr, arg);
 810                         break;
 811                 case (PH_ACTIVATE | REQUEST):
 812                         if (cs->debug)
 813                                 debugl1(cs, "PH_ACTIVATE_REQ %s",
 814                                         st->l1.l1m.fsm->strState[st->l1.l1m.state]);
 815                         if (test_bit(FLG_L1_ACTIVATED, &st->l1.Flags))
 816                                 st->l1.l1l2(st, PH_ACTIVATE | CONFIRM, NULL);
 817                         else {
 818                                 test_and_set_bit(FLG_L1_ACTIVATING, &st->l1.Flags);
 819                                 FsmEvent(&st->l1.l1m, EV_PH_ACTIVATE, arg);
 820                         }
 821                         break;
 822                 case (PH_TESTLOOP | REQUEST):
 823                         if (1 & (long) arg)
 824                                 debugl1(cs, "PH_TEST_LOOP B1");
 825                         if (2 & (long) arg)
 826                                 debugl1(cs, "PH_TEST_LOOP B2");
 827                         if (!(3 & (long) arg))
 828                                 debugl1(cs, "PH_TEST_LOOP DISABLED");
 829                         st->l1.l1hw(st, HW_TESTLOOP | REQUEST, arg);
 830                         break;
 831                 default:
 832                         if (cs->debug)
 833                                 debugl1(cs, "dch_l2l1 msg %04X unhandled", pr);
 834                         break;
 835         }
 836 }
 837
 838 void
 839 l1_msg(struct IsdnCardState *cs, int pr, void *arg) {
 840         struct PStack *st;
 841
 842         st = cs->stlist;
 843
 844         while (st) {
 845                 switch(pr) {
 846                         case (HW_RESET | INDICATION):
 847                                 FsmEvent(&st->l1.l1m, EV_RESET_IND, arg);
 848                                 break;
 849                         case (HW_DEACTIVATE | CONFIRM):
 850                                 FsmEvent(&st->l1.l1m, EV_DEACT_CNF, arg);
 851                                 break;
 852                         case (HW_DEACTIVATE | INDICATION):
 853                                 FsmEvent(&st->l1.l1m, EV_DEACT_IND, arg);
 854                                 break;
 855                         case (HW_POWERUP | CONFIRM):
 856                                 FsmEvent(&st->l1.l1m, EV_POWER_UP, arg);
 857                                 break;
 858                         case (HW_RSYNC | INDICATION):
 859                                 FsmEvent(&st->l1.l1m, EV_RSYNC_IND, arg);
 860                                 break;
 861                         case (HW_INFO2 | INDICATION):
 862                                 FsmEvent(&st->l1.l1m, EV_INFO2_IND, arg);
 863                                 break;
 864                         case (HW_INFO4_P8 | INDICATION):
 865                         case (HW_INFO4_P10 | INDICATION):
 866                                 FsmEvent(&st->l1.l1m, EV_INFO4_IND, arg);
 867                                 break;
 868                         default:
 869                                 if (cs->debug)
 870                                         debugl1(cs, "l1msg %04X unhandled", pr);
 871                                 break;
 872                 }
 873                 st = st->next;
 874         }
 875 }
 876
 877 void
 878 l1_msg_b(struct PStack *st, int pr, void *arg) {
 879         switch(pr) {
 880                 case (PH_ACTIVATE | REQUEST):
 881                         FsmEvent(&st->l1.l1m, EV_PH_ACTIVATE, NULL);
 882                         break;
 883                 case (PH_DEACTIVATE | REQUEST):
 884                         FsmEvent(&st->l1.l1m, EV_PH_DEACTIVATE, NULL);
 885                         break;
 886         }
 887 }
 888
 889 void
 890 setstack_HiSax(struct PStack *st, struct IsdnCardState *cs)
 891 {
 892         st->l1.hardware = cs;
 893         st->protocol = cs->protocol;
 894         st->l1.l1m.fsm = &l1fsm_s;
 895         st->l1.l1m.state = ST_L1_F3;
 896         st->l1.Flags = 0;
 897 #ifdef HISAX_UINTERFACE
 898         if (test_bit(FLG_HW_L1_UINT, &cs->HW_Flags)) {
 899                 st->l1.l1m.fsm = &l1fsm_u;
 900                 st->l1.l1m.state = ST_L1_RESET;
 901                 st->l1.Flags = FLG_L1_UINT;
 902         }
 903 #endif
 904         st->l1.l1m.debug = cs->debug;
 905         st->l1.l1m.userdata = st;
 906         st->l1.l1m.userint = 0;
 907         st->l1.l1m.printdebug = l1m_debug;
 908         FsmInitTimer(&st->l1.l1m, &st->l1.timer);
 909         setstack_tei(st);
 910         setstack_manager(st);
 911         st->l1.stlistp = &(cs->stlist);
 912         st->l2.l2l1  = dch_l2l1;
 913         if (cs->setstack_d)
 914                 cs->setstack_d(st, cs);
 915 }
 916
 917 void
 918 setstack_l1_B(struct PStack *st)
 919 {
 920         struct IsdnCardState *cs = st->l1.hardware;
 921
 922         st->l1.l1m.fsm = &l1fsm_b;
 923         st->l1.l1m.state = ST_L1_NULL;
 924         st->l1.l1m.debug = cs->debug;
 925         st->l1.l1m.userdata = st;
 926         st->l1.l1m.userint = 0;
 927         st->l1.l1m.printdebug = l1m_debug;
 928         st->l1.Flags = 0;
 929         FsmInitTimer(&st->l1.l1m, &st->l1.timer);
 930 }