1 /* $Id: isdnl1.c,v 2.39 2000/06/26 08:59:13 keil Exp $
3 * isdnl1.c common low level stuff for Siemens Chipsetbased isdn cards
4 * based on the teles driver from Jan den Ouden
6 * Author Karsten Keil (keil@isdn4linux.de)
8 * This file is (c) under GNU PUBLIC LICENSE
9 * For changes and modifications please read
10 * ../../../Documentation/isdn/HiSax.cert
12 * Thanks to Jan den Ouden
18 const char *l1_revision
= "$Revision: 2.39 $";
20 #define __NO_VERSION__
24 #define TIMER3_VALUE 7000
28 {NULL
, 0, 0, NULL
, NULL
};
32 {NULL
, 0, 0, NULL
, NULL
};
44 #define L1D_STATE_COUNT (ST_L1_F8+1)
46 static char *strL1DState
[] =
64 #define L1B_STATE_COUNT (ST_L1_ACTIV+1)
66 static char *strL1BState
[] =
89 #define L1_EVENT_COUNT (EV_TIMER3 + 1)
91 static char *strL1Event
[] =
108 debugl1(struct IsdnCardState
*cs
, char *fmt
, ...)
114 sprintf(tmp
, "Card%d ", cs
->cardnr
+ 1);
115 VHiSax_putstatus(cs
, tmp
, fmt
, args
);
120 l1m_debug(struct FsmInst
*fi
, char *fmt
, ...)
123 struct PStack
*st
= fi
->userdata
;
124 struct IsdnCardState
*cs
= st
->l1
.hardware
;
128 sprintf(tmp
, "Card%d ", cs
->cardnr
+ 1);
129 VHiSax_putstatus(cs
, tmp
, fmt
, args
);
134 L1activated(struct IsdnCardState
*cs
)
140 if (test_and_clear_bit(FLG_L1_ACTIVATING
, &st
->l1
.Flags
))
141 st
->l1
.l1l2(st
, PH_ACTIVATE
| CONFIRM
, NULL
);
143 st
->l1
.l1l2(st
, PH_ACTIVATE
| INDICATION
, NULL
);
149 L1deactivated(struct IsdnCardState
*cs
)
155 if (test_bit(FLG_L1_DBUSY
, &cs
->HW_Flags
))
156 st
->l1
.l1l2(st
, PH_PAUSE
| CONFIRM
, NULL
);
157 st
->l1
.l1l2(st
, PH_DEACTIVATE
| INDICATION
, NULL
);
160 test_and_clear_bit(FLG_L1_DBUSY
, &cs
->HW_Flags
);
164 DChannel_proc_xmt(struct IsdnCardState
*cs
)
166 struct PStack
*stptr
;
172 while (stptr
!= NULL
)
173 if (test_and_clear_bit(FLG_L1_PULL_REQ
, &stptr
->l1
.Flags
)) {
174 stptr
->l1
.l1l2(stptr
, PH_PULL
| CONFIRM
, NULL
);
181 DChannel_proc_rcv(struct IsdnCardState
*cs
)
183 struct sk_buff
*skb
, *nskb
;
184 struct PStack
*stptr
= cs
->stlist
;
185 int found
, tei
, sapi
;
188 if (test_bit(FLG_L1_ACTTIMER
, &stptr
->l1
.Flags
))
189 FsmEvent(&stptr
->l1
.l1m
, EV_TIMER_ACT
, NULL
);
190 while ((skb
= skb_dequeue(&cs
->rq
))) {
191 #ifdef L2FRAME_DEBUG /* psa */
192 if (cs
->debug
& L1_DEB_LAPD
)
193 Logl2Frame(cs
, skb
, "PH_DATA", 1);
197 debugl1(cs
, "D-channel frame too short(%d)",skb
->len
);
201 if ((skb
->data
[0] & 1) || !(skb
->data
[1] &1)) {
202 debugl1(cs
, "D-channel frame wrong EA0/EA1");
206 sapi
= skb
->data
[0] >> 2;
207 tei
= skb
->data
[1] >> 1;
208 if (cs
->debug
& DEB_DLOG_HEX
)
209 LogFrame(cs
, skb
->data
, skb
->len
);
210 if (cs
->debug
& DEB_DLOG_VERBOSE
)
211 dlogframe(cs
, skb
, 1);
212 if (tei
== GROUP_TEI
) {
213 if (sapi
== CTRL_SAPI
) { /* sapi 0 */
214 while (stptr
!= NULL
) {
215 if ((nskb
= skb_clone(skb
, GFP_ATOMIC
)))
216 stptr
->l1
.l1l2(stptr
, PH_DATA
| INDICATION
, nskb
);
218 printk(KERN_WARNING
"HiSax: isdn broadcast buffer shortage\n");
221 } else if (sapi
== TEI_SAPI
) {
222 while (stptr
!= NULL
) {
223 if ((nskb
= skb_clone(skb
, GFP_ATOMIC
)))
224 stptr
->l1
.l1tei(stptr
, PH_DATA
| INDICATION
, nskb
);
226 printk(KERN_WARNING
"HiSax: tei broadcast buffer shortage\n");
231 } else if (sapi
== CTRL_SAPI
) { /* sapi 0 */
233 while (stptr
!= NULL
)
234 if (tei
== stptr
->l2
.tei
) {
235 stptr
->l1
.l1l2(stptr
, PH_DATA
| INDICATION
, skb
);
248 BChannel_proc_xmt(struct BCState
*bcs
)
250 struct PStack
*st
= bcs
->st
;
252 if (test_bit(BC_FLG_BUSY
, &bcs
->Flag
)) {
253 debugl1(bcs
->cs
, "BC_BUSY Error");
257 if (test_and_clear_bit(FLG_L1_PULL_REQ
, &st
->l1
.Flags
))
258 st
->l1
.l1l2(st
, PH_PULL
| CONFIRM
, NULL
);
259 if (!test_bit(BC_FLG_ACTIV
, &bcs
->Flag
)) {
260 if (!test_bit(BC_FLG_BUSY
, &bcs
->Flag
) && (!skb_queue_len(&bcs
->squeue
))) {
261 st
->l2
.l2l1(st
, PH_DEACTIVATE
| CONFIRM
, NULL
);
267 BChannel_proc_rcv(struct BCState
*bcs
)
271 if (bcs
->st
->l1
.l1m
.state
== ST_L1_WAIT_ACT
) {
272 FsmDelTimer(&bcs
->st
->l1
.timer
, 4);
273 FsmEvent(&bcs
->st
->l1
.l1m
, EV_TIMER_ACT
, NULL
);
275 while ((skb
= skb_dequeue(&bcs
->rqueue
))) {
276 bcs
->st
->l1
.l1l2(bcs
->st
, PH_DATA
| INDICATION
, skb
);
281 BChannel_bh(struct BCState
*bcs
)
285 if (test_and_clear_bit(B_RCVBUFREADY
, &bcs
->event
))
286 BChannel_proc_rcv(bcs
);
287 if (test_and_clear_bit(B_XMTBUFREADY
, &bcs
->event
))
288 BChannel_proc_xmt(bcs
);
292 HiSax_addlist(struct IsdnCardState
*cs
,
295 st
->next
= cs
->stlist
;
300 HiSax_rmlist(struct IsdnCardState
*cs
,
305 FsmDelTimer(&st
->l1
.timer
, 0);
306 if (cs
->stlist
== st
)
307 cs
->stlist
= st
->next
;
320 init_bcstate(struct IsdnCardState
*cs
,
323 struct BCState
*bcs
= cs
->bcs
+ bc
;
327 bcs
->tqueue
.next
= 0;
328 bcs
->tqueue
.sync
= 0;
329 bcs
->tqueue
.routine
= (void *) (void *) BChannel_bh
;
330 bcs
->tqueue
.data
= bcs
;
331 bcs
->BC_SetStack
= NULL
;
332 bcs
->BC_Close
= NULL
;
336 #ifdef L2FRAME_DEBUG /* psa */
341 switch (cmd
& ~0x10) {
366 return "invalid command";
370 static char tmpdeb
[32];
373 l2frames(u_char
* ptr
)
375 switch (ptr
[2] & ~0x10) {
379 sprintf(tmpdeb
, "%s[%d](nr %d)", l2cmd(ptr
[2]), ptr
[3] & 1, ptr
[3] >> 1);
388 sprintf(tmpdeb
, "%s[%d]", l2cmd(ptr
[2]), (ptr
[2] & 0x10) >> 4);
392 sprintf(tmpdeb
, "I[%d](ns %d, nr %d)", ptr
[3] & 1, ptr
[2] >> 1, ptr
[3] >> 1);
395 return "invalid command";
403 Logl2Frame(struct IsdnCardState
*cs
, struct sk_buff
*skb
, char *buf
, int dir
)
409 if (ptr
[0] & 1 || !(ptr
[1] & 1))
410 debugl1(cs
, "Address not LAPD");
412 debugl1(cs
, "%s %s: %s%c (sapi %d, tei %d)",
413 (dir
? "<-" : "->"), buf
, l2frames(ptr
),
414 ((ptr
[0] & 2) >> 1) == dir
? 'C' : 'R', ptr
[0] >> 2, ptr
[1] >> 1);
419 l1_reset(struct FsmInst
*fi
, int event
, void *arg
)
421 FsmChangeState(fi
, ST_L1_F3
);
425 l1_deact_cnf(struct FsmInst
*fi
, int event
, void *arg
)
427 struct PStack
*st
= fi
->userdata
;
429 FsmChangeState(fi
, ST_L1_F3
);
430 if (test_bit(FLG_L1_ACTIVATING
, &st
->l1
.Flags
))
431 st
->l1
.l1hw(st
, HW_ENABLE
| REQUEST
, NULL
);
435 l1_deact_req(struct FsmInst
*fi
, int event
, void *arg
)
437 struct PStack
*st
= fi
->userdata
;
439 FsmChangeState(fi
, ST_L1_F3
);
440 FsmRestartTimer(&st
->l1
.timer
, 550, EV_TIMER_DEACT
, NULL
, 2);
441 test_and_set_bit(FLG_L1_DEACTTIMER
, &st
->l1
.Flags
);
445 l1_power_up(struct FsmInst
*fi
, int event
, void *arg
)
447 struct PStack
*st
= fi
->userdata
;
449 if (test_bit(FLG_L1_ACTIVATING
, &st
->l1
.Flags
)) {
450 FsmChangeState(fi
, ST_L1_F4
);
451 st
->l1
.l1hw(st
, HW_INFO3
| REQUEST
, NULL
);
452 FsmRestartTimer(&st
->l1
.timer
, TIMER3_VALUE
, EV_TIMER3
, NULL
, 2);
453 test_and_set_bit(FLG_L1_T3RUN
, &st
->l1
.Flags
);
455 FsmChangeState(fi
, ST_L1_F3
);
459 l1_go_F5(struct FsmInst
*fi
, int event
, void *arg
)
461 FsmChangeState(fi
, ST_L1_F5
);
465 l1_go_F8(struct FsmInst
*fi
, int event
, void *arg
)
467 FsmChangeState(fi
, ST_L1_F8
);
471 l1_info2_ind(struct FsmInst
*fi
, int event
, void *arg
)
473 struct PStack
*st
= fi
->userdata
;
475 FsmChangeState(fi
, ST_L1_F6
);
476 st
->l1
.l1hw(st
, HW_INFO3
| REQUEST
, NULL
);
480 l1_info4_ind(struct FsmInst
*fi
, int event
, void *arg
)
482 struct PStack
*st
= fi
->userdata
;
484 FsmChangeState(fi
, ST_L1_F7
);
485 st
->l1
.l1hw(st
, HW_INFO3
| REQUEST
, NULL
);
486 if (test_and_clear_bit(FLG_L1_DEACTTIMER
, &st
->l1
.Flags
))
487 FsmDelTimer(&st
->l1
.timer
, 4);
488 if (!test_bit(FLG_L1_ACTIVATED
, &st
->l1
.Flags
)) {
489 if (test_and_clear_bit(FLG_L1_T3RUN
, &st
->l1
.Flags
))
490 FsmDelTimer(&st
->l1
.timer
, 3);
491 FsmRestartTimer(&st
->l1
.timer
, 110, EV_TIMER_ACT
, NULL
, 2);
492 test_and_set_bit(FLG_L1_ACTTIMER
, &st
->l1
.Flags
);
497 l1_timer3(struct FsmInst
*fi
, int event
, void *arg
)
499 struct PStack
*st
= fi
->userdata
;
501 test_and_clear_bit(FLG_L1_T3RUN
, &st
->l1
.Flags
);
502 if (test_and_clear_bit(FLG_L1_ACTIVATING
, &st
->l1
.Flags
))
503 L1deactivated(st
->l1
.hardware
);
504 if (st
->l1
.l1m
.state
!= ST_L1_F6
) {
505 FsmChangeState(fi
, ST_L1_F3
);
506 st
->l1
.l1hw(st
, HW_ENABLE
| REQUEST
, NULL
);
511 l1_timer_act(struct FsmInst
*fi
, int event
, void *arg
)
513 struct PStack
*st
= fi
->userdata
;
515 test_and_clear_bit(FLG_L1_ACTTIMER
, &st
->l1
.Flags
);
516 test_and_set_bit(FLG_L1_ACTIVATED
, &st
->l1
.Flags
);
517 L1activated(st
->l1
.hardware
);
521 l1_timer_deact(struct FsmInst
*fi
, int event
, void *arg
)
523 struct PStack
*st
= fi
->userdata
;
525 test_and_clear_bit(FLG_L1_DEACTTIMER
, &st
->l1
.Flags
);
526 test_and_clear_bit(FLG_L1_ACTIVATED
, &st
->l1
.Flags
);
527 L1deactivated(st
->l1
.hardware
);
528 st
->l1
.l1hw(st
, HW_DEACTIVATE
| RESPONSE
, NULL
);
532 l1_activate(struct FsmInst
*fi
, int event
, void *arg
)
534 struct PStack
*st
= fi
->userdata
;
536 st
->l1
.l1hw(st
, HW_RESET
| REQUEST
, NULL
);
540 l1_activate_no(struct FsmInst
*fi
, int event
, void *arg
)
542 struct PStack
*st
= fi
->userdata
;
544 if ((!test_bit(FLG_L1_DEACTTIMER
, &st
->l1
.Flags
)) && (!test_bit(FLG_L1_T3RUN
, &st
->l1
.Flags
))) {
545 test_and_clear_bit(FLG_L1_ACTIVATING
, &st
->l1
.Flags
);
546 L1deactivated(st
->l1
.hardware
);
550 static struct FsmNode L1DFnList
[] HISAX_INITDATA
=
552 {ST_L1_F3
, EV_PH_ACTIVATE
, l1_activate
},
553 {ST_L1_F6
, EV_PH_ACTIVATE
, l1_activate_no
},
554 {ST_L1_F8
, EV_PH_ACTIVATE
, l1_activate_no
},
555 {ST_L1_F3
, EV_RESET_IND
, l1_reset
},
556 {ST_L1_F4
, EV_RESET_IND
, l1_reset
},
557 {ST_L1_F5
, EV_RESET_IND
, l1_reset
},
558 {ST_L1_F6
, EV_RESET_IND
, l1_reset
},
559 {ST_L1_F7
, EV_RESET_IND
, l1_reset
},
560 {ST_L1_F8
, EV_RESET_IND
, l1_reset
},
561 {ST_L1_F3
, EV_DEACT_CNF
, l1_deact_cnf
},
562 {ST_L1_F4
, EV_DEACT_CNF
, l1_deact_cnf
},
563 {ST_L1_F5
, EV_DEACT_CNF
, l1_deact_cnf
},
564 {ST_L1_F6
, EV_DEACT_CNF
, l1_deact_cnf
},
565 {ST_L1_F7
, EV_DEACT_CNF
, l1_deact_cnf
},
566 {ST_L1_F8
, EV_DEACT_CNF
, l1_deact_cnf
},
567 {ST_L1_F6
, EV_DEACT_IND
, l1_deact_req
},
568 {ST_L1_F7
, EV_DEACT_IND
, l1_deact_req
},
569 {ST_L1_F8
, EV_DEACT_IND
, l1_deact_req
},
570 {ST_L1_F3
, EV_POWER_UP
, l1_power_up
},
571 {ST_L1_F4
, EV_RSYNC_IND
, l1_go_F5
},
572 {ST_L1_F6
, EV_RSYNC_IND
, l1_go_F8
},
573 {ST_L1_F7
, EV_RSYNC_IND
, l1_go_F8
},
574 {ST_L1_F3
, EV_INFO2_IND
, l1_info2_ind
},
575 {ST_L1_F4
, EV_INFO2_IND
, l1_info2_ind
},
576 {ST_L1_F5
, EV_INFO2_IND
, l1_info2_ind
},
577 {ST_L1_F7
, EV_INFO2_IND
, l1_info2_ind
},
578 {ST_L1_F8
, EV_INFO2_IND
, l1_info2_ind
},
579 {ST_L1_F3
, EV_INFO4_IND
, l1_info4_ind
},
580 {ST_L1_F4
, EV_INFO4_IND
, l1_info4_ind
},
581 {ST_L1_F5
, EV_INFO4_IND
, l1_info4_ind
},
582 {ST_L1_F6
, EV_INFO4_IND
, l1_info4_ind
},
583 {ST_L1_F8
, EV_INFO4_IND
, l1_info4_ind
},
584 {ST_L1_F3
, EV_TIMER3
, l1_timer3
},
585 {ST_L1_F4
, EV_TIMER3
, l1_timer3
},
586 {ST_L1_F5
, EV_TIMER3
, l1_timer3
},
587 {ST_L1_F6
, EV_TIMER3
, l1_timer3
},
588 {ST_L1_F8
, EV_TIMER3
, l1_timer3
},
589 {ST_L1_F7
, EV_TIMER_ACT
, l1_timer_act
},
590 {ST_L1_F3
, EV_TIMER_DEACT
, l1_timer_deact
},
591 {ST_L1_F4
, EV_TIMER_DEACT
, l1_timer_deact
},
592 {ST_L1_F5
, EV_TIMER_DEACT
, l1_timer_deact
},
593 {ST_L1_F6
, EV_TIMER_DEACT
, l1_timer_deact
},
594 {ST_L1_F7
, EV_TIMER_DEACT
, l1_timer_deact
},
595 {ST_L1_F8
, EV_TIMER_DEACT
, l1_timer_deact
},
598 #define L1D_FN_COUNT (sizeof(L1DFnList)/sizeof(struct FsmNode))
601 l1b_activate(struct FsmInst
*fi
, int event
, void *arg
)
603 struct PStack
*st
= fi
->userdata
;
605 FsmChangeState(fi
, ST_L1_WAIT_ACT
);
606 FsmRestartTimer(&st
->l1
.timer
, st
->l1
.delay
, EV_TIMER_ACT
, NULL
, 2);
610 l1b_deactivate(struct FsmInst
*fi
, int event
, void *arg
)
612 struct PStack
*st
= fi
->userdata
;
614 FsmChangeState(fi
, ST_L1_WAIT_DEACT
);
615 FsmRestartTimer(&st
->l1
.timer
, 10, EV_TIMER_DEACT
, NULL
, 2);
619 l1b_timer_act(struct FsmInst
*fi
, int event
, void *arg
)
621 struct PStack
*st
= fi
->userdata
;
623 FsmChangeState(fi
, ST_L1_ACTIV
);
624 st
->l1
.l1l2(st
, PH_ACTIVATE
| CONFIRM
, NULL
);
628 l1b_timer_deact(struct FsmInst
*fi
, int event
, void *arg
)
630 struct PStack
*st
= fi
->userdata
;
632 FsmChangeState(fi
, ST_L1_NULL
);
633 st
->l2
.l2l1(st
, PH_DEACTIVATE
| CONFIRM
, NULL
);
636 static struct FsmNode L1BFnList
[] HISAX_INITDATA
=
638 {ST_L1_NULL
, EV_PH_ACTIVATE
, l1b_activate
},
639 {ST_L1_WAIT_ACT
, EV_TIMER_ACT
, l1b_timer_act
},
640 {ST_L1_ACTIV
, EV_PH_DEACTIVATE
, l1b_deactivate
},
641 {ST_L1_WAIT_DEACT
, EV_TIMER_DEACT
, l1b_timer_deact
},
644 #define L1B_FN_COUNT (sizeof(L1BFnList)/sizeof(struct FsmNode))
646 HISAX_INITFUNC(void Isdnl1New(void))
648 l1fsm_d
.state_count
= L1D_STATE_COUNT
;
649 l1fsm_d
.event_count
= L1_EVENT_COUNT
;
650 l1fsm_d
.strEvent
= strL1Event
;
651 l1fsm_d
.strState
= strL1DState
;
652 FsmNew(&l1fsm_d
, L1DFnList
, L1D_FN_COUNT
);
653 l1fsm_b
.state_count
= L1B_STATE_COUNT
;
654 l1fsm_b
.event_count
= L1_EVENT_COUNT
;
655 l1fsm_b
.strEvent
= strL1Event
;
656 l1fsm_b
.strState
= strL1BState
;
657 FsmNew(&l1fsm_b
, L1BFnList
, L1B_FN_COUNT
);
660 void Isdnl1Free(void)
667 dch_l2l1(struct PStack
*st
, int pr
, void *arg
)
669 struct IsdnCardState
*cs
= (struct IsdnCardState
*) st
->l1
.hardware
;
672 case (PH_DATA
| REQUEST
):
673 case (PH_PULL
| REQUEST
):
674 case (PH_PULL
|INDICATION
):
675 st
->l1
.l1hw(st
, pr
, arg
);
677 case (PH_ACTIVATE
| REQUEST
):
679 debugl1(cs
, "PH_ACTIVATE_REQ %s",
680 strL1DState
[st
->l1
.l1m
.state
]);
681 if (test_bit(FLG_L1_ACTIVATED
, &st
->l1
.Flags
))
682 st
->l1
.l1l2(st
, PH_ACTIVATE
| CONFIRM
, NULL
);
684 test_and_set_bit(FLG_L1_ACTIVATING
, &st
->l1
.Flags
);
685 FsmEvent(&st
->l1
.l1m
, EV_PH_ACTIVATE
, arg
);
688 case (PH_TESTLOOP
| REQUEST
):
690 debugl1(cs
, "PH_TEST_LOOP B1");
692 debugl1(cs
, "PH_TEST_LOOP B2");
693 if (!(3 & (long) arg
))
694 debugl1(cs
, "PH_TEST_LOOP DISABLED");
695 st
->l1
.l1hw(st
, HW_TESTLOOP
| REQUEST
, arg
);
699 debugl1(cs
, "dch_l2l1 msg %04X unhandled", pr
);
705 l1_msg(struct IsdnCardState
*cs
, int pr
, void *arg
) {
712 case (HW_RESET
| INDICATION
):
713 FsmEvent(&st
->l1
.l1m
, EV_RESET_IND
, arg
);
715 case (HW_DEACTIVATE
| CONFIRM
):
716 FsmEvent(&st
->l1
.l1m
, EV_DEACT_CNF
, arg
);
718 case (HW_DEACTIVATE
| INDICATION
):
719 FsmEvent(&st
->l1
.l1m
, EV_DEACT_IND
, arg
);
721 case (HW_POWERUP
| CONFIRM
):
722 FsmEvent(&st
->l1
.l1m
, EV_POWER_UP
, arg
);
724 case (HW_RSYNC
| INDICATION
):
725 FsmEvent(&st
->l1
.l1m
, EV_RSYNC_IND
, arg
);
727 case (HW_INFO2
| INDICATION
):
728 FsmEvent(&st
->l1
.l1m
, EV_INFO2_IND
, arg
);
730 case (HW_INFO4_P8
| INDICATION
):
731 case (HW_INFO4_P10
| INDICATION
):
732 FsmEvent(&st
->l1
.l1m
, EV_INFO4_IND
, arg
);
736 debugl1(cs
, "l1msg %04X unhandled", pr
);
744 l1_msg_b(struct PStack
*st
, int pr
, void *arg
) {
746 case (PH_ACTIVATE
| REQUEST
):
747 FsmEvent(&st
->l1
.l1m
, EV_PH_ACTIVATE
, NULL
);
749 case (PH_DEACTIVATE
| REQUEST
):
750 FsmEvent(&st
->l1
.l1m
, EV_PH_DEACTIVATE
, NULL
);
756 setstack_HiSax(struct PStack
*st
, struct IsdnCardState
*cs
)
758 st
->l1
.hardware
= cs
;
759 st
->protocol
= cs
->protocol
;
760 st
->l1
.l1m
.fsm
= &l1fsm_d
;
761 st
->l1
.l1m
.state
= ST_L1_F3
;
762 st
->l1
.l1m
.debug
= cs
->debug
;
763 st
->l1
.l1m
.userdata
= st
;
764 st
->l1
.l1m
.userint
= 0;
765 st
->l1
.l1m
.printdebug
= l1m_debug
;
766 FsmInitTimer(&st
->l1
.l1m
, &st
->l1
.timer
);
768 setstack_manager(st
);
769 st
->l1
.stlistp
= &(cs
->stlist
);
770 st
->l2
.l2l1
= dch_l2l1
;
772 cs
->setstack_d(st
, cs
);
776 setstack_l1_B(struct PStack
*st
)
778 struct IsdnCardState
*cs
= st
->l1
.hardware
;
780 st
->l1
.l1m
.fsm
= &l1fsm_b
;
781 st
->l1
.l1m
.state
= ST_L1_NULL
;
782 st
->l1
.l1m
.debug
= cs
->debug
;
783 st
->l1
.l1m
.userdata
= st
;
784 st
->l1
.l1m
.userint
= 0;
785 st
->l1
.l1m
.printdebug
= l1m_debug
;
787 FsmInitTimer(&st
->l1
.l1m
, &st
->l1
.timer
);