Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
isdnl1.c
Go to the documentation of this file.
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 <[email protected]>
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 {
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 {
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 {
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 {
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
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 {
461 }
462 
463 static void
464 l1_deact_cnf(struct FsmInst *fi, int event, void *arg)
465 {
466  struct PStack *st = fi->userdata;
467 
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 
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)) {
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
495 }
496 
497 static void
498 l1_go_F5(struct FsmInst *fi, int event, void *arg)
499 {
501 }
502 
503 static void
504 l1_go_F8(struct FsmInst *fi, int event, void *arg)
505 {
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
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
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) {
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 
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 {
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 
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 
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 
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 
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
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 }