?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import 2.4.0-test6pre6
[davej-history.git] / drivers / isdn / hisax / isdnl1.c
blobd0e7343572ae0754f037adaffd946c4de4c89ca8
1 /* $Id: isdnl1.c,v 2.39 2000/06/26 08:59:13 keil Exp $
2 *
3 * isdnl1.c common low level stuff for Siemens Chipsetbased isdn cards
4 * based on the teles driver from Jan den Ouden
5 *
6 * Author Karsten Keil (keil@isdn4linux.de)
7 *
8 * This file is (c) under GNU PUBLIC LICENSE
9 * For changes and modifications please read
10 * ../../../Documentation/isdn/HiSax.cert
11 *
12 * Thanks to Jan den Ouden
13 * Fritz Elfert
14 * Beat Doebeli
15 *
16 */
17
18 const char *l1_revision = "$Revision: 2.39 $";
19
20 #define __NO_VERSION__
21 #include "hisax.h"
22 #include "isdnl1.h"
23
24 #define TIMER3_VALUE 7000
25
26 static
27 struct Fsm l1fsm_b =
28 {NULL, 0, 0, NULL, NULL};
29
30 static
31 struct Fsm l1fsm_d =
32 {NULL, 0, 0, NULL, NULL};
33
34 enum {
35 ST_L1_F2,
36 ST_L1_F3,
37 ST_L1_F4,
38 ST_L1_F5,
39 ST_L1_F6,
40 ST_L1_F7,
41 ST_L1_F8,
42 };
43
44 #define L1D_STATE_COUNT (ST_L1_F8+1)
45
46 static char *strL1DState[] =
47 {
48 "ST_L1_F2",
49 "ST_L1_F3",
50 "ST_L1_F4",
51 "ST_L1_F5",
52 "ST_L1_F6",
53 "ST_L1_F7",
54 "ST_L1_F8",
55 };
56
57 enum {
58 ST_L1_NULL,
59 ST_L1_WAIT_ACT,
60 ST_L1_WAIT_DEACT,
61 ST_L1_ACTIV,
62 };
63
64 #define L1B_STATE_COUNT (ST_L1_ACTIV+1)
65
66 static char *strL1BState[] =
67 {
68 "ST_L1_NULL",
69 "ST_L1_WAIT_ACT",
70 "ST_L1_WAIT_DEACT",
71 "ST_L1_ACTIV",
72 };
73
74 enum {
75 EV_PH_ACTIVATE,
76 EV_PH_DEACTIVATE,
77 EV_RESET_IND,
78 EV_DEACT_CNF,
79 EV_DEACT_IND,
80 EV_POWER_UP,
81 EV_RSYNC_IND,
82 EV_INFO2_IND,
83 EV_INFO4_IND,
84 EV_TIMER_DEACT,
85 EV_TIMER_ACT,
86 EV_TIMER3,
87 };
88
89 #define L1_EVENT_COUNT (EV_TIMER3 + 1)
90
91 static char *strL1Event[] =
92 {
93 "EV_PH_ACTIVATE",
94 "EV_PH_DEACTIVATE",
95 "EV_RESET_IND",
96 "EV_DEACT_CNF",
97 "EV_DEACT_IND",
98 "EV_POWER_UP",
99 "EV_RSYNC_IND",
100 "EV_INFO2_IND",
101 "EV_INFO4_IND",
102 "EV_TIMER_DEACT",
103 "EV_TIMER_ACT",
104 "EV_TIMER3",
105 };
106
107 void
108 debugl1(struct IsdnCardState *cs, char *fmt, ...)
109 {
110 va_list args;
111 char tmp[8];
112
113 va_start(args, fmt);
114 sprintf(tmp, "Card%d ", cs->cardnr + 1);
115 VHiSax_putstatus(cs, tmp, fmt, args);
116 va_end(args);
117 }
118
119 static void
120 l1m_debug(struct FsmInst *fi, char *fmt, ...)
121 {
122 va_list args;
123 struct PStack *st = fi->userdata;
124 struct IsdnCardState *cs = st->l1.hardware;
125 char tmp[8];
126
127 va_start(args, fmt);
128 sprintf(tmp, "Card%d ", cs->cardnr + 1);
129 VHiSax_putstatus(cs, tmp, fmt, args);
130 va_end(args);
131 }
132
133 void
134 L1activated(struct IsdnCardState *cs)
135 {
136 struct PStack *st;
137
138 st = cs->stlist;
139 while (st) {
140 if (test_and_clear_bit(FLG_L1_ACTIVATING, &st->l1.Flags))
141 st->l1.l1l2(st, PH_ACTIVATE | CONFIRM, NULL);
142 else
143 st->l1.l1l2(st, PH_ACTIVATE | INDICATION, NULL);
144 st = st->next;
145 }
146 }
147
148 void
149 L1deactivated(struct IsdnCardState *cs)
150 {
151 struct PStack *st;
152
153 st = cs->stlist;
154 while (st) {
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);
158 st = st->next;
159 }
160 test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags);
161 }
162
163 void
164 DChannel_proc_xmt(struct IsdnCardState *cs)
165 {
166 struct PStack *stptr;
167
168 if (cs->tx_skb)
169 return;
170
171 stptr = cs->stlist;
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);
175 break;
176 } else
177 stptr = stptr->next;
178 }
179
180 void
181 DChannel_proc_rcv(struct IsdnCardState *cs)
182 {
183 struct sk_buff *skb, *nskb;
184 struct PStack *stptr = cs->stlist;
185 int found, tei, sapi;
186
187 if (stptr)
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);
194 #endif
195 stptr = cs->stlist;
196 if (skb->len<3) {
197 debugl1(cs, "D-channel frame too short(%d)",skb->len);
198 dev_kfree_skb(skb);
199 return;
200 }
201 if ((skb->data[0] & 1) || !(skb->data[1] &1)) {
202 debugl1(cs, "D-channel frame wrong EA0/EA1");
203 dev_kfree_skb(skb);
204 return;
205 }
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);
217 else
218 printk(KERN_WARNING "HiSax: isdn broadcast buffer shortage\n");
219 stptr = stptr->next;
220 }
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);
225 else
226 printk(KERN_WARNING "HiSax: tei broadcast buffer shortage\n");
227 stptr = stptr->next;
228 }
229 }
230 dev_kfree_skb(skb);
231 } else if (sapi == CTRL_SAPI) { /* sapi 0 */
232 found = 0;
233 while (stptr != NULL)
234 if (tei == stptr->l2.tei) {
235 stptr->l1.l1l2(stptr, PH_DATA | INDICATION, skb);
236 found = !0;
237 break;
238 } else
239 stptr = stptr->next;
240 if (!found)
241 dev_kfree_skb(skb);
242 } else
243 dev_kfree_skb(skb);
244 }
245 }
246
247 static void
248 BChannel_proc_xmt(struct BCState *bcs)
249 {
250 struct PStack *st = bcs->st;
251
252 if (test_bit(BC_FLG_BUSY, &bcs->Flag)) {
253 debugl1(bcs->cs, "BC_BUSY Error");
254 return;
255 }
256
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);
262 }
263 }
264 }
265
266 static void
267 BChannel_proc_rcv(struct BCState *bcs)
268 {
269 struct sk_buff *skb;
270
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);
274 }
275 while ((skb = skb_dequeue(&bcs->rqueue))) {
276 bcs->st->l1.l1l2(bcs->st, PH_DATA | INDICATION, skb);
277 }
278 }
279
280 void
281 BChannel_bh(struct BCState *bcs)
282 {
283 if (!bcs)
284 return;
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);
289 }
290
291 void
292 HiSax_addlist(struct IsdnCardState *cs,
293 struct PStack *st)
294 {
295 st->next = cs->stlist;
296 cs->stlist = st;
297 }
298
299 void
300 HiSax_rmlist(struct IsdnCardState *cs,
301 struct PStack *st)
302 {
303 struct PStack *p;
304
305 FsmDelTimer(&st->l1.timer, 0);
306 if (cs->stlist == st)
307 cs->stlist = st->next;
308 else {
309 p = cs->stlist;
310 while (p)
311 if (p->next == st) {
312 p->next = st->next;
313 return;
314 } else
315 p = p->next;
316 }
317 }
318
319 void
320 init_bcstate(struct IsdnCardState *cs,
321 int bc)
322 {
323 struct BCState *bcs = cs->bcs + bc;
324
325 bcs->cs = cs;
326 bcs->channel = 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;
333 bcs->Flag = 0;
334 }
335
336 #ifdef L2FRAME_DEBUG /* psa */
337
338 char *
339 l2cmd(u_char cmd)
340 {
341 switch (cmd & ~0x10) {
342 case 1:
343 return "RR";
344 case 5:
345 return "RNR";
346 case 9:
347 return "REJ";
348 case 0x6f:
349 return "SABME";
350 case 0x0f:
351 return "DM";
352 case 3:
353 return "UI";
354 case 0x43:
355 return "DISC";
356 case 0x63:
357 return "UA";
358 case 0x87:
359 return "FRMR";
360 case 0xaf:
361 return "XID";
362 default:
363 if (!(cmd & 1))
364 return "I";
365 else
366 return "invalid command";
367 }
368 }
369
370 static char tmpdeb[32];
371
372 char *
373 l2frames(u_char * ptr)
374 {
375 switch (ptr[2] & ~0x10) {
376 case 1:
377 case 5:
378 case 9:
379 sprintf(tmpdeb, "%s[%d](nr %d)", l2cmd(ptr[2]), ptr[3] & 1, ptr[3] >> 1);
380 break;
381 case 0x6f:
382 case 0x0f:
383 case 3:
384 case 0x43:
385 case 0x63:
386 case 0x87:
387 case 0xaf:
388 sprintf(tmpdeb, "%s[%d]", l2cmd(ptr[2]), (ptr[2] & 0x10) >> 4);
389 break;
390 default:
391 if (!(ptr[2] & 1)) {
392 sprintf(tmpdeb, "I[%d](ns %d, nr %d)", ptr[3] & 1, ptr[2] >> 1, ptr[3] >> 1);
393 break;
394 } else
395 return "invalid command";
396 }
397
398
399 return tmpdeb;
400 }
401
402 void
403 Logl2Frame(struct IsdnCardState *cs, struct sk_buff *skb, char *buf, int dir)
404 {
405 u_char *ptr;
406
407 ptr = skb->data;
408
409 if (ptr[0] & 1 || !(ptr[1] & 1))
410 debugl1(cs, "Address not LAPD");
411 else
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);
415 }
416 #endif
417
418 static void
419 l1_reset(struct FsmInst *fi, int event, void *arg)
420 {
421 FsmChangeState(fi, ST_L1_F3);
422 }
423
424 static void
425 l1_deact_cnf(struct FsmInst *fi, int event, void *arg)
426 {
427 struct PStack *st = fi->userdata;
428
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);
432 }
433
434 static void
435 l1_deact_req(struct FsmInst *fi, int event, void *arg)
436 {
437 struct PStack *st = fi->userdata;
438
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);
442 }
443
444 static void
445 l1_power_up(struct FsmInst *fi, int event, void *arg)
446 {
447 struct PStack *st = fi->userdata;
448
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);
454 } else
455 FsmChangeState(fi, ST_L1_F3);
456 }
457
458 static void
459 l1_go_F5(struct FsmInst *fi, int event, void *arg)
460 {
461 FsmChangeState(fi, ST_L1_F5);
462 }
463
464 static void
465 l1_go_F8(struct FsmInst *fi, int event, void *arg)
466 {
467 FsmChangeState(fi, ST_L1_F8);
468 }
469
470 static void
471 l1_info2_ind(struct FsmInst *fi, int event, void *arg)
472 {
473 struct PStack *st = fi->userdata;
474
475 FsmChangeState(fi, ST_L1_F6);
476 st->l1.l1hw(st, HW_INFO3 | REQUEST, NULL);
477 }
478
479 static void
480 l1_info4_ind(struct FsmInst *fi, int event, void *arg)
481 {
482 struct PStack *st = fi->userdata;
483
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);
493 }
494 }
495
496 static void
497 l1_timer3(struct FsmInst *fi, int event, void *arg)
498 {
499 struct PStack *st = fi->userdata;
500
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);
507 }
508 }
509
510 static void
511 l1_timer_act(struct FsmInst *fi, int event, void *arg)
512 {
513 struct PStack *st = fi->userdata;
514
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);
518 }
519
520 static void
521 l1_timer_deact(struct FsmInst *fi, int event, void *arg)
522 {
523 struct PStack *st = fi->userdata;
524
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);
529 }
530
531 static void
532 l1_activate(struct FsmInst *fi, int event, void *arg)
533 {
534 struct PStack *st = fi->userdata;
535
536 st->l1.l1hw(st, HW_RESET | REQUEST, NULL);
537 }
538
539 static void
540 l1_activate_no(struct FsmInst *fi, int event, void *arg)
541 {
542 struct PStack *st = fi->userdata;
543
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);
547 }
548 }
549
550 static struct FsmNode L1DFnList[] HISAX_INITDATA =
551 {
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},
596 };
597
598 #define L1D_FN_COUNT (sizeof(L1DFnList)/sizeof(struct FsmNode))
599
600 static void
601 l1b_activate(struct FsmInst *fi, int event, void *arg)
602 {
603 struct PStack *st = fi->userdata;
604
605 FsmChangeState(fi, ST_L1_WAIT_ACT);
606 FsmRestartTimer(&st->l1.timer, st->l1.delay, EV_TIMER_ACT, NULL, 2);
607 }
608
609 static void
610 l1b_deactivate(struct FsmInst *fi, int event, void *arg)
611 {
612 struct PStack *st = fi->userdata;
613
614 FsmChangeState(fi, ST_L1_WAIT_DEACT);
615 FsmRestartTimer(&st->l1.timer, 10, EV_TIMER_DEACT, NULL, 2);
616 }
617
618 static void
619 l1b_timer_act(struct FsmInst *fi, int event, void *arg)
620 {
621 struct PStack *st = fi->userdata;
622
623 FsmChangeState(fi, ST_L1_ACTIV);
624 st->l1.l1l2(st, PH_ACTIVATE | CONFIRM, NULL);
625 }
626
627 static void
628 l1b_timer_deact(struct FsmInst *fi, int event, void *arg)
629 {
630 struct PStack *st = fi->userdata;
631
632 FsmChangeState(fi, ST_L1_NULL);
633 st->l2.l2l1(st, PH_DEACTIVATE | CONFIRM, NULL);
634 }
635
636 static struct FsmNode L1BFnList[] HISAX_INITDATA =
637 {
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},
642 };
643
644 #define L1B_FN_COUNT (sizeof(L1BFnList)/sizeof(struct FsmNode))
645
646 HISAX_INITFUNC(void Isdnl1New(void))
647 {
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);
658 }
659
660 void Isdnl1Free(void)
661 {
662 FsmFree(&l1fsm_d);
663 FsmFree(&l1fsm_b);
664 }
665
666 static void
667 dch_l2l1(struct PStack *st, int pr, void *arg)
668 {
669 struct IsdnCardState *cs = (struct IsdnCardState *) st->l1.hardware;
670
671 switch (pr) {
672 case (PH_DATA | REQUEST):
673 case (PH_PULL | REQUEST):
674 case (PH_PULL |INDICATION):
675 st->l1.l1hw(st, pr, arg);
676 break;
677 case (PH_ACTIVATE | REQUEST):
678 if (cs->debug)
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);
683 else {
684 test_and_set_bit(FLG_L1_ACTIVATING, &st->l1.Flags);
685 FsmEvent(&st->l1.l1m, EV_PH_ACTIVATE, arg);
686 }
687 break;
688 case (PH_TESTLOOP | REQUEST):
689 if (1 & (long) arg)
690 debugl1(cs, "PH_TEST_LOOP B1");
691 if (2 & (long) arg)
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);
696 break;
697 default:
698 if (cs->debug)
699 debugl1(cs, "dch_l2l1 msg %04X unhandled", pr);
700 break;
701 }
702 }
703
704 void
705 l1_msg(struct IsdnCardState *cs, int pr, void *arg) {
706 struct PStack *st;
707
708 st = cs->stlist;
709
710 while (st) {
711 switch(pr) {
712 case (HW_RESET | INDICATION):
713 FsmEvent(&st->l1.l1m, EV_RESET_IND, arg);
714 break;
715 case (HW_DEACTIVATE | CONFIRM):
716 FsmEvent(&st->l1.l1m, EV_DEACT_CNF, arg);
717 break;
718 case (HW_DEACTIVATE | INDICATION):
719 FsmEvent(&st->l1.l1m, EV_DEACT_IND, arg);
720 break;
721 case (HW_POWERUP | CONFIRM):
722 FsmEvent(&st->l1.l1m, EV_POWER_UP, arg);
723 break;
724 case (HW_RSYNC | INDICATION):
725 FsmEvent(&st->l1.l1m, EV_RSYNC_IND, arg);
726 break;
727 case (HW_INFO2 | INDICATION):
728 FsmEvent(&st->l1.l1m, EV_INFO2_IND, arg);
729 break;
730 case (HW_INFO4_P8 | INDICATION):
731 case (HW_INFO4_P10 | INDICATION):
732 FsmEvent(&st->l1.l1m, EV_INFO4_IND, arg);
733 break;
734 default:
735 if (cs->debug)
736 debugl1(cs, "l1msg %04X unhandled", pr);
737 break;
738 }
739 st = st->next;
740 }
741 }
742
743 void
744 l1_msg_b(struct PStack *st, int pr, void *arg) {
745 switch(pr) {
746 case (PH_ACTIVATE | REQUEST):
747 FsmEvent(&st->l1.l1m, EV_PH_ACTIVATE, NULL);
748 break;
749 case (PH_DEACTIVATE | REQUEST):
750 FsmEvent(&st->l1.l1m, EV_PH_DEACTIVATE, NULL);
751 break;
752 }
753 }
754
755 void
756 setstack_HiSax(struct PStack *st, struct IsdnCardState *cs)
757 {
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);
767 setstack_tei(st);
768 setstack_manager(st);
769 st->l1.stlistp = &(cs->stlist);
770 st->l2.l2l1 = dch_l2l1;
771 st->l1.Flags = 0;
772 cs->setstack_d(st, cs);
773 }
774
775 void
776 setstack_l1_B(struct PStack *st)
777 {
778 struct IsdnCardState *cs = st->l1.hardware;
779
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;
786 st->l1.Flags = 0;
787 FsmInitTimer(&st->l1.l1m, &st->l1.timer);
788 }
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux