]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/isdn/hisax/isdnl1.c
1 /* $Id: isdnl1.c,v 2.46.2.5 2004/02/11 13:21:34 keil Exp $
3 * common low level stuff for Siemens Chipsetbased isdn cards
6 * based on the teles driver from Jan den Ouden
7 * Copyright by Karsten Keil <keil@isdn4linux.de>
9 * This software may be used and distributed according to the terms
10 * of the GNU General Public License, incorporated herein by reference.
12 * For changes and modifications please read
13 * Documentation/isdn/HiSax.cert
15 * Thanks to Jan den Ouden
21 #include <linux/init.h>
22 #include <linux/gfp.h>
26 const char *l1_revision
= "$Revision: 2.46.2.5 $";
28 #define TIMER3_VALUE 7000
30 static struct Fsm l1fsm_b
;
31 static struct Fsm l1fsm_s
;
43 #define L1S_STATE_COUNT (ST_L1_F8 + 1)
45 static char *strL1SState
[] =
56 #ifdef HISAX_UINTERFACE
59 {NULL
, 0, 0, NULL
, NULL
};
68 #define L1U_STATE_COUNT (ST_L1_TRANS + 1)
70 static char *strL1UState
[] =
86 #define L1B_STATE_COUNT (ST_L1_ACTIV + 1)
88 static char *strL1BState
[] =
111 #define L1_EVENT_COUNT (EV_TIMER3 + 1)
113 static char *strL1Event
[] =
130 debugl1(struct IsdnCardState
*cs
, char *fmt
, ...)
136 sprintf(tmp
, "Card%d ", cs
->cardnr
+ 1);
137 VHiSax_putstatus(cs
, tmp
, fmt
, args
);
142 l1m_debug(struct FsmInst
*fi
, char *fmt
, ...)
145 struct PStack
*st
= fi
->userdata
;
146 struct IsdnCardState
*cs
= st
->l1
.hardware
;
150 sprintf(tmp
, "Card%d ", cs
->cardnr
+ 1);
151 VHiSax_putstatus(cs
, tmp
, fmt
, args
);
156 L1activated(struct IsdnCardState
*cs
)
162 if (test_and_clear_bit(FLG_L1_ACTIVATING
, &st
->l1
.Flags
))
163 st
->l1
.l1l2(st
, PH_ACTIVATE
| CONFIRM
, NULL
);
165 st
->l1
.l1l2(st
, PH_ACTIVATE
| INDICATION
, NULL
);
171 L1deactivated(struct IsdnCardState
*cs
)
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
);
182 test_and_clear_bit(FLG_L1_DBUSY
, &cs
->HW_Flags
);
186 DChannel_proc_xmt(struct IsdnCardState
*cs
)
188 struct PStack
*stptr
;
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
);
204 DChannel_proc_rcv(struct IsdnCardState
*cs
)
206 struct sk_buff
*skb
, *nskb
;
207 struct PStack
*stptr
= cs
->stlist
;
208 int found
, tei
, sapi
;
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);
220 debugl1(cs
, "D-channel frame too short(%d)", skb
->len
);
224 if ((skb
->data
[0] & 1) || !(skb
->data
[1] & 1)) {
225 debugl1(cs
, "D-channel frame wrong EA0/EA1");
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
);
241 printk(KERN_WARNING
"HiSax: isdn broadcast buffer shortage\n");
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
);
249 printk(KERN_WARNING
"HiSax: tei broadcast buffer shortage\n");
254 } else if (sapi
== CTRL_SAPI
) { /* sapi 0 */
256 while (stptr
!= NULL
)
257 if (tei
== stptr
->l2
.tei
) {
258 stptr
->l1
.l1l2(stptr
, PH_DATA
| INDICATION
, skb
);
271 BChannel_proc_xmt(struct BCState
*bcs
)
273 struct PStack
*st
= bcs
->st
;
275 if (test_bit(BC_FLG_BUSY
, &bcs
->Flag
)) {
276 debugl1(bcs
->cs
, "BC_BUSY Error");
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
);
291 BChannel_proc_rcv(struct BCState
*bcs
)
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
);
299 while ((skb
= skb_dequeue(&bcs
->rqueue
))) {
300 bcs
->st
->l1
.l1l2(bcs
->st
, PH_DATA
| INDICATION
, skb
);
305 BChannel_proc_ack(struct BCState
*bcs
)
310 spin_lock_irqsave(&bcs
->aclock
, flags
);
313 spin_unlock_irqrestore(&bcs
->aclock
, flags
);
315 lli_writewakeup(bcs
->st
, ack
);
319 BChannel_bh(struct work_struct
*work
)
321 struct BCState
*bcs
= container_of(work
, struct BCState
, tqueue
);
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
);
334 HiSax_addlist(struct IsdnCardState
*cs
,
337 st
->next
= cs
->stlist
;
342 HiSax_rmlist(struct IsdnCardState
*cs
,
347 FsmDelTimer(&st
->l1
.timer
, 0);
348 if (cs
->stlist
== st
)
349 cs
->stlist
= st
->next
;
362 init_bcstate(struct IsdnCardState
*cs
, int bc
)
364 struct BCState
*bcs
= cs
->bcs
+ bc
;
368 INIT_WORK(&bcs
->tqueue
, BChannel_bh
);
369 spin_lock_init(&bcs
->aclock
);
370 bcs
->BC_SetStack
= NULL
;
371 bcs
->BC_Close
= NULL
;
375 #ifdef L2FRAME_DEBUG /* psa */
380 switch (cmd
& ~0x10) {
405 return "invalid command";
409 static char tmpdeb
[32];
412 l2frames(u_char
*ptr
)
414 switch (ptr
[2] & ~0x10) {
418 sprintf(tmpdeb
, "%s[%d](nr %d)", l2cmd(ptr
[2]), ptr
[3] & 1, ptr
[3] >> 1);
427 sprintf(tmpdeb
, "%s[%d]", l2cmd(ptr
[2]), (ptr
[2] & 0x10) >> 4);
431 sprintf(tmpdeb
, "I[%d](ns %d, nr %d)", ptr
[3] & 1, ptr
[2] >> 1, ptr
[3] >> 1);
434 return "invalid command";
442 Logl2Frame(struct IsdnCardState
*cs
, struct sk_buff
*skb
, char *buf
, int dir
)
448 if (ptr
[0] & 1 || !(ptr
[1] & 1))
449 debugl1(cs
, "Address not LAPD");
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);
458 l1_reset(struct FsmInst
*fi
, int event
, void *arg
)
460 FsmChangeState(fi
, ST_L1_F3
);
464 l1_deact_cnf(struct FsmInst
*fi
, int event
, void *arg
)
466 struct PStack
*st
= fi
->userdata
;
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
);
474 l1_deact_req_s(struct FsmInst
*fi
, int event
, void *arg
)
476 struct PStack
*st
= fi
->userdata
;
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
);
484 l1_power_up_s(struct FsmInst
*fi
, int event
, void *arg
)
486 struct PStack
*st
= fi
->userdata
;
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
);
494 FsmChangeState(fi
, ST_L1_F3
);
498 l1_go_F5(struct FsmInst
*fi
, int event
, void *arg
)
500 FsmChangeState(fi
, ST_L1_F5
);
504 l1_go_F8(struct FsmInst
*fi
, int event
, void *arg
)
506 FsmChangeState(fi
, ST_L1_F8
);
510 l1_info2_ind(struct FsmInst
*fi
, int event
, void *arg
)
512 struct PStack
*st
= fi
->userdata
;
514 #ifdef HISAX_UINTERFACE
515 if (test_bit(FLG_L1_UINT
, &st
->l1
.Flags
))
516 FsmChangeState(fi
, ST_L1_SYNC2
);
519 FsmChangeState(fi
, ST_L1_F6
);
520 st
->l1
.l1hw(st
, HW_INFO3
| REQUEST
, NULL
);
524 l1_info4_ind(struct FsmInst
*fi
, int event
, void *arg
)
526 struct PStack
*st
= fi
->userdata
;
528 #ifdef HISAX_UINTERFACE
529 if (test_bit(FLG_L1_UINT
, &st
->l1
.Flags
))
530 FsmChangeState(fi
, ST_L1_TRANS
);
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
);
546 l1_timer3(struct FsmInst
*fi
, int event
, void *arg
)
548 struct PStack
*st
= fi
->userdata
;
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
);
554 #ifdef HISAX_UINTERFACE
555 if (!test_bit(FLG_L1_UINT
, &st
->l1
.Flags
))
557 if (st
->l1
.l1m
.state
!= ST_L1_F6
) {
558 FsmChangeState(fi
, ST_L1_F3
);
559 st
->l1
.l1hw(st
, HW_ENABLE
| REQUEST
, NULL
);
564 l1_timer_act(struct FsmInst
*fi
, int event
, void *arg
)
566 struct PStack
*st
= fi
->userdata
;
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
);
574 l1_timer_deact(struct FsmInst
*fi
, int event
, void *arg
)
576 struct PStack
*st
= fi
->userdata
;
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
);
585 l1_activate_s(struct FsmInst
*fi
, int event
, void *arg
)
587 struct PStack
*st
= fi
->userdata
;
589 st
->l1
.l1hw(st
, HW_RESET
| REQUEST
, NULL
);
593 l1_activate_no(struct FsmInst
*fi
, int event
, void *arg
)
595 struct PStack
*st
= fi
->userdata
;
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
);
603 static struct FsmNode L1SFnList
[] __initdata
=
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
},
651 #ifdef HISAX_UINTERFACE
653 l1_deact_req_u(struct FsmInst
*fi
, int event
, void *arg
)
655 struct PStack
*st
= fi
->userdata
;
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
);
664 l1_power_up_u(struct FsmInst
*fi
, int event
, void *arg
)
666 struct PStack
*st
= fi
->userdata
;
668 FsmRestartTimer(&st
->l1
.timer
, TIMER3_VALUE
, EV_TIMER3
, NULL
, 2);
669 test_and_set_bit(FLG_L1_T3RUN
, &st
->l1
.Flags
);
673 l1_info0_ind(struct FsmInst
*fi
, int event
, void *arg
)
675 FsmChangeState(fi
, ST_L1_DEACT
);
679 l1_activate_u(struct FsmInst
*fi
, int event
, void *arg
)
681 struct PStack
*st
= fi
->userdata
;
683 st
->l1
.l1hw(st
, HW_INFO1
| REQUEST
, NULL
);
686 static struct FsmNode L1UFnList
[] __initdata
=
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
},
711 l1b_activate(struct FsmInst
*fi
, int event
, void *arg
)
713 struct PStack
*st
= fi
->userdata
;
715 FsmChangeState(fi
, ST_L1_WAIT_ACT
);
716 FsmRestartTimer(&st
->l1
.timer
, st
->l1
.delay
, EV_TIMER_ACT
, NULL
, 2);
720 l1b_deactivate(struct FsmInst
*fi
, int event
, void *arg
)
722 struct PStack
*st
= fi
->userdata
;
724 FsmChangeState(fi
, ST_L1_WAIT_DEACT
);
725 FsmRestartTimer(&st
->l1
.timer
, 10, EV_TIMER_DEACT
, NULL
, 2);
729 l1b_timer_act(struct FsmInst
*fi
, int event
, void *arg
)
731 struct PStack
*st
= fi
->userdata
;
733 FsmChangeState(fi
, ST_L1_ACTIV
);
734 st
->l1
.l1l2(st
, PH_ACTIVATE
| CONFIRM
, NULL
);
738 l1b_timer_deact(struct FsmInst
*fi
, int event
, void *arg
)
740 struct PStack
*st
= fi
->userdata
;
742 FsmChangeState(fi
, ST_L1_NULL
);
743 st
->l2
.l2l1(st
, PH_DEACTIVATE
| CONFIRM
, NULL
);
746 static struct FsmNode L1BFnList
[] __initdata
=
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
},
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
));
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
));
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
));
791 void Isdnl1Free(void)
793 #ifdef HISAX_UINTERFACE
801 dch_l2l1(struct PStack
*st
, int pr
, void *arg
)
803 struct IsdnCardState
*cs
= (struct IsdnCardState
*) st
->l1
.hardware
;
806 case (PH_DATA
| REQUEST
):
807 case (PH_PULL
| REQUEST
):
808 case (PH_PULL
| INDICATION
):
809 st
->l1
.l1hw(st
, pr
, arg
);
811 case (PH_ACTIVATE
| REQUEST
):
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
);
818 test_and_set_bit(FLG_L1_ACTIVATING
, &st
->l1
.Flags
);
819 FsmEvent(&st
->l1
.l1m
, EV_PH_ACTIVATE
, arg
);
822 case (PH_TESTLOOP
| REQUEST
):
824 debugl1(cs
, "PH_TEST_LOOP B1");
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
);
833 debugl1(cs
, "dch_l2l1 msg %04X unhandled", pr
);
839 l1_msg(struct IsdnCardState
*cs
, int pr
, void *arg
) {
846 case (HW_RESET
| INDICATION
):
847 FsmEvent(&st
->l1
.l1m
, EV_RESET_IND
, arg
);
849 case (HW_DEACTIVATE
| CONFIRM
):
850 FsmEvent(&st
->l1
.l1m
, EV_DEACT_CNF
, arg
);
852 case (HW_DEACTIVATE
| INDICATION
):
853 FsmEvent(&st
->l1
.l1m
, EV_DEACT_IND
, arg
);
855 case (HW_POWERUP
| CONFIRM
):
856 FsmEvent(&st
->l1
.l1m
, EV_POWER_UP
, arg
);
858 case (HW_RSYNC
| INDICATION
):
859 FsmEvent(&st
->l1
.l1m
, EV_RSYNC_IND
, arg
);
861 case (HW_INFO2
| INDICATION
):
862 FsmEvent(&st
->l1
.l1m
, EV_INFO2_IND
, arg
);
864 case (HW_INFO4_P8
| INDICATION
):
865 case (HW_INFO4_P10
| INDICATION
):
866 FsmEvent(&st
->l1
.l1m
, EV_INFO4_IND
, arg
);
870 debugl1(cs
, "%s %04X unhandled", __func__
, pr
);
878 l1_msg_b(struct PStack
*st
, int pr
, void *arg
) {
880 case (PH_ACTIVATE
| REQUEST
):
881 FsmEvent(&st
->l1
.l1m
, EV_PH_ACTIVATE
, NULL
);
883 case (PH_DEACTIVATE
| REQUEST
):
884 FsmEvent(&st
->l1
.l1m
, EV_PH_DEACTIVATE
, NULL
);
890 setstack_HiSax(struct PStack
*st
, struct IsdnCardState
*cs
)
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
;
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
;
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
);
910 setstack_manager(st
);
911 st
->l1
.stlistp
= &(cs
->stlist
);
912 st
->l2
.l2l1
= dch_l2l1
;
914 cs
->setstack_d(st
, cs
);
918 setstack_l1_B(struct PStack
*st
)
920 struct IsdnCardState
*cs
= st
->l1
.hardware
;
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
;
929 FsmInitTimer(&st
->l1
.l1m
, &st
->l1
.timer
);