?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 5.1.15
[linux/fpc-iii.git] / drivers / isdn / hisax / isdnl3.c
blobbb3f9ec62749ebc57a4a79a0f960b96326c6e213
1 /* $Id: isdnl3.c,v 2.22.2.3 2004/01/13 14:31:25 keil Exp $
2 *
3 * Author Karsten Keil
4 * based on the teles driver from Jan den Ouden
5 * Copyright by Karsten Keil <keil@isdn4linux.de>
6 *
7 * This software may be used and distributed according to the terms
8 * of the GNU General Public License, incorporated herein by reference.
9 *
10 * For changes and modifications please read
11 * Documentation/isdn/HiSax.cert
12 *
13 * Thanks to Jan den Ouden
14 * Fritz Elfert
15 *
16 */
17
18 #include <linux/init.h>
19 #include <linux/slab.h>
20 #include "hisax.h"
21 #include "isdnl3.h"
22
23 const char *l3_revision = "$Revision: 2.22.2.3 $";
24
25 static struct Fsm l3fsm;
26
27 enum {
28 ST_L3_LC_REL,
29 ST_L3_LC_ESTAB_WAIT,
30 ST_L3_LC_REL_DELAY,
31 ST_L3_LC_REL_WAIT,
32 ST_L3_LC_ESTAB,
33 };
34
35 #define L3_STATE_COUNT (ST_L3_LC_ESTAB + 1)
36
37 static char *strL3State[] =
38 {
39 "ST_L3_LC_REL",
40 "ST_L3_LC_ESTAB_WAIT",
41 "ST_L3_LC_REL_DELAY",
42 "ST_L3_LC_REL_WAIT",
43 "ST_L3_LC_ESTAB",
44 };
45
46 enum {
47 EV_ESTABLISH_REQ,
48 EV_ESTABLISH_IND,
49 EV_ESTABLISH_CNF,
50 EV_RELEASE_REQ,
51 EV_RELEASE_CNF,
52 EV_RELEASE_IND,
53 EV_TIMEOUT,
54 };
55
56 #define L3_EVENT_COUNT (EV_TIMEOUT + 1)
57
58 static char *strL3Event[] =
59 {
60 "EV_ESTABLISH_REQ",
61 "EV_ESTABLISH_IND",
62 "EV_ESTABLISH_CNF",
63 "EV_RELEASE_REQ",
64 "EV_RELEASE_CNF",
65 "EV_RELEASE_IND",
66 "EV_TIMEOUT",
67 };
68
69 static __printf(2, 3) void
70 l3m_debug(struct FsmInst *fi, char *fmt, ...)
71 {
72 va_list args;
73 struct PStack *st = fi->userdata;
74
75 va_start(args, fmt);
76 VHiSax_putstatus(st->l1.hardware, st->l3.debug_id, fmt, args);
77 va_end(args);
78 }
79
80 u_char *
81 findie(u_char *p, int size, u_char ie, int wanted_set)
82 {
83 int l, codeset, maincodeset;
84 u_char *pend = p + size;
85
86 /* skip protocol discriminator, callref and message type */
87 p++;
88 l = (*p++) & 0xf;
89 p += l;
90 p++;
91 codeset = 0;
92 maincodeset = 0;
93 /* while there are bytes left... */
94 while (p < pend) {
95 if ((*p & 0xf0) == 0x90) {
96 codeset = *p & 0x07;
97 if (!(*p & 0x08))
98 maincodeset = codeset;
99 }
100 if (*p & 0x80)
101 p++;
102 else {
103 if (codeset == wanted_set) {
104 if (*p == ie)
105 { /* improved length check (Werner Cornelius) */
106 if ((pend - p) < 2)
107 return (NULL);
108 if (*(p + 1) > (pend - (p + 2)))
109 return (NULL);
110 return (p);
111 }
112
113 if (*p > ie)
114 return (NULL);
115 }
116 p++;
117 l = *p++;
118 p += l;
119 codeset = maincodeset;
120 }
121 }
122 return (NULL);
123 }
124
125 int
126 getcallref(u_char *p)
127 {
128 int l, cr = 0;
129
130 p++; /* prot discr */
131 if (*p & 0xfe) /* wrong callref BRI only 1 octet*/
132 return (-2);
133 l = 0xf & *p++; /* callref length */
134 if (!l) /* dummy CallRef */
135 return (-1);
136 cr = *p++;
137 return (cr);
138 }
139
140 static int OrigCallRef = 0;
141
142 int
143 newcallref(void)
144 {
145 if (OrigCallRef == 127)
146 OrigCallRef = 1;
147 else
148 OrigCallRef++;
149 return (OrigCallRef);
150 }
151
152 void
153 newl3state(struct l3_process *pc, int state)
154 {
155 if (pc->debug & L3_DEB_STATE)
156 l3_debug(pc->st, "%s cr %d %d --> %d", __func__,
157 pc->callref & 0x7F,
158 pc->state, state);
159 pc->state = state;
160 }
161
162 static void
163 L3ExpireTimer(struct timer_list *timer)
164 {
165 struct L3Timer *t = from_timer(t, timer, tl);
166 t->pc->st->lli.l4l3(t->pc->st, t->event, t->pc);
167 }
168
169 void
170 L3InitTimer(struct l3_process *pc, struct L3Timer *t)
171 {
172 t->pc = pc;
173 timer_setup(&t->tl, L3ExpireTimer, 0);
174 }
175
176 void
177 L3DelTimer(struct L3Timer *t)
178 {
179 del_timer(&t->tl);
180 }
181
182 int
183 L3AddTimer(struct L3Timer *t,
184 int millisec, int event)
185 {
186 if (timer_pending(&t->tl)) {
187 printk(KERN_WARNING "L3AddTimer: timer already active!\n");
188 return -1;
189 }
190 t->event = event;
191 t->tl.expires = jiffies + (millisec * HZ) / 1000;
192 add_timer(&t->tl);
193 return 0;
194 }
195
196 void
197 StopAllL3Timer(struct l3_process *pc)
198 {
199 L3DelTimer(&pc->timer);
200 }
201
202 struct sk_buff *
203 l3_alloc_skb(int len)
204 {
205 struct sk_buff *skb;
206
207 if (!(skb = alloc_skb(len + MAX_HEADER_LEN, GFP_ATOMIC))) {
208 printk(KERN_WARNING "HiSax: No skb for D-channel\n");
209 return (NULL);
210 }
211 skb_reserve(skb, MAX_HEADER_LEN);
212 return (skb);
213 }
214
215 static void
216 no_l3_proto(struct PStack *st, int pr, void *arg)
217 {
218 struct sk_buff *skb = arg;
219
220 HiSax_putstatus(st->l1.hardware, "L3", "no D protocol");
221 if (skb) {
222 dev_kfree_skb(skb);
223 }
224 }
225
226 static int
227 no_l3_proto_spec(struct PStack *st, isdn_ctrl *ic)
228 {
229 printk(KERN_WARNING "HiSax: no specific protocol handler for proto %lu\n", ic->arg & 0xFF);
230 return (-1);
231 }
232
233 struct l3_process
234 *getl3proc(struct PStack *st, int cr)
235 {
236 struct l3_process *p = st->l3.proc;
237
238 while (p)
239 if (p->callref == cr)
240 return (p);
241 else
242 p = p->next;
243 return (NULL);
244 }
245
246 struct l3_process
247 *new_l3_process(struct PStack *st, int cr)
248 {
249 struct l3_process *p, *np;
250
251 if (!(p = kmalloc(sizeof(struct l3_process), GFP_ATOMIC))) {
252 printk(KERN_ERR "HiSax can't get memory for cr %d\n", cr);
253 return (NULL);
254 }
255 if (!st->l3.proc)
256 st->l3.proc = p;
257 else {
258 np = st->l3.proc;
259 while (np->next)
260 np = np->next;
261 np->next = p;
262 }
263 p->next = NULL;
264 p->debug = st->l3.debug;
265 p->callref = cr;
266 p->state = 0;
267 p->chan = NULL;
268 p->st = st;
269 p->N303 = st->l3.N303;
270 L3InitTimer(p, &p->timer);
271 return (p);
272 };
273
274 void
275 release_l3_process(struct l3_process *p)
276 {
277 struct l3_process *np, *pp = NULL;
278
279 if (!p)
280 return;
281 np = p->st->l3.proc;
282 while (np) {
283 if (np == p) {
284 StopAllL3Timer(p);
285 if (pp)
286 pp->next = np->next;
287 else if (!(p->st->l3.proc = np->next) &&
288 !test_bit(FLG_PTP, &p->st->l2.flag)) {
289 if (p->debug)
290 l3_debug(p->st, "release_l3_process: last process");
291 if (skb_queue_empty(&p->st->l3.squeue)) {
292 if (p->debug)
293 l3_debug(p->st, "release_l3_process: release link");
294 if (p->st->protocol != ISDN_PTYPE_NI1)
295 FsmEvent(&p->st->l3.l3m, EV_RELEASE_REQ, NULL);
296 else
297 FsmEvent(&p->st->l3.l3m, EV_RELEASE_IND, NULL);
298 } else {
299 if (p->debug)
300 l3_debug(p->st, "release_l3_process: not release link");
301 }
302 }
303 kfree(p);
304 return;
305 }
306 pp = np;
307 np = np->next;
308 }
309 printk(KERN_ERR "HiSax internal L3 error CR(%d) not in list\n", p->callref);
310 l3_debug(p->st, "HiSax internal L3 error CR(%d) not in list", p->callref);
311 };
312
313 static void
314 l3ml3p(struct PStack *st, int pr)
315 {
316 struct l3_process *p = st->l3.proc;
317 struct l3_process *np;
318
319 while (p) {
320 /* p might be kfreed under us, so we need to save where we want to go on */
321 np = p->next;
322 st->l3.l3ml3(st, pr, p);
323 p = np;
324 }
325 }
326
327 void
328 setstack_l3dc(struct PStack *st, struct Channel *chanp)
329 {
330 char tmp[64];
331
332 st->l3.proc = NULL;
333 st->l3.global = NULL;
334 skb_queue_head_init(&st->l3.squeue);
335 st->l3.l3m.fsm = &l3fsm;
336 st->l3.l3m.state = ST_L3_LC_REL;
337 st->l3.l3m.debug = 1;
338 st->l3.l3m.userdata = st;
339 st->l3.l3m.userint = 0;
340 st->l3.l3m.printdebug = l3m_debug;
341 FsmInitTimer(&st->l3.l3m, &st->l3.l3m_timer);
342 strcpy(st->l3.debug_id, "L3DC ");
343 st->lli.l4l3_proto = no_l3_proto_spec;
344
345 #ifdef CONFIG_HISAX_EURO
346 if (st->protocol == ISDN_PTYPE_EURO) {
347 setstack_dss1(st);
348 } else
349 #endif
350 #ifdef CONFIG_HISAX_NI1
351 if (st->protocol == ISDN_PTYPE_NI1) {
352 setstack_ni1(st);
353 } else
354 #endif
355 #ifdef CONFIG_HISAX_1TR6
356 if (st->protocol == ISDN_PTYPE_1TR6) {
357 setstack_1tr6(st);
358 } else
359 #endif
360 if (st->protocol == ISDN_PTYPE_LEASED) {
361 st->lli.l4l3 = no_l3_proto;
362 st->l2.l2l3 = no_l3_proto;
363 st->l3.l3ml3 = no_l3_proto;
364 printk(KERN_INFO "HiSax: Leased line mode\n");
365 } else {
366 st->lli.l4l3 = no_l3_proto;
367 st->l2.l2l3 = no_l3_proto;
368 st->l3.l3ml3 = no_l3_proto;
369 sprintf(tmp, "protocol %s not supported",
370 (st->protocol == ISDN_PTYPE_1TR6) ? "1tr6" :
371 (st->protocol == ISDN_PTYPE_EURO) ? "euro" :
372 (st->protocol == ISDN_PTYPE_NI1) ? "ni1" :
373 "unknown");
374 printk(KERN_WARNING "HiSax: %s\n", tmp);
375 st->protocol = -1;
376 }
377 }
378
379 static void
380 isdnl3_trans(struct PStack *st, int pr, void *arg) {
381 st->l3.l3l2(st, pr, arg);
382 }
383
384 void
385 releasestack_isdnl3(struct PStack *st)
386 {
387 while (st->l3.proc)
388 release_l3_process(st->l3.proc);
389 if (st->l3.global) {
390 StopAllL3Timer(st->l3.global);
391 kfree(st->l3.global);
392 st->l3.global = NULL;
393 }
394 FsmDelTimer(&st->l3.l3m_timer, 54);
395 skb_queue_purge(&st->l3.squeue);
396 }
397
398 void
399 setstack_l3bc(struct PStack *st, struct Channel *chanp)
400 {
401
402 st->l3.proc = NULL;
403 st->l3.global = NULL;
404 skb_queue_head_init(&st->l3.squeue);
405 st->l3.l3m.fsm = &l3fsm;
406 st->l3.l3m.state = ST_L3_LC_REL;
407 st->l3.l3m.debug = 1;
408 st->l3.l3m.userdata = st;
409 st->l3.l3m.userint = 0;
410 st->l3.l3m.printdebug = l3m_debug;
411 strcpy(st->l3.debug_id, "L3BC ");
412 st->lli.l4l3 = isdnl3_trans;
413 }
414
415 #define DREL_TIMER_VALUE 40000
416
417 static void
418 lc_activate(struct FsmInst *fi, int event, void *arg)
419 {
420 struct PStack *st = fi->userdata;
421
422 FsmChangeState(fi, ST_L3_LC_ESTAB_WAIT);
423 st->l3.l3l2(st, DL_ESTABLISH | REQUEST, NULL);
424 }
425
426 static void
427 lc_connect(struct FsmInst *fi, int event, void *arg)
428 {
429 struct PStack *st = fi->userdata;
430 struct sk_buff *skb = arg;
431 int dequeued = 0;
432
433 FsmChangeState(fi, ST_L3_LC_ESTAB);
434 while ((skb = skb_dequeue(&st->l3.squeue))) {
435 st->l3.l3l2(st, DL_DATA | REQUEST, skb);
436 dequeued++;
437 }
438 if ((!st->l3.proc) && dequeued) {
439 if (st->l3.debug)
440 l3_debug(st, "lc_connect: release link");
441 FsmEvent(&st->l3.l3m, EV_RELEASE_REQ, NULL);
442 } else
443 l3ml3p(st, DL_ESTABLISH | INDICATION);
444 }
445
446 static void
447 lc_connected(struct FsmInst *fi, int event, void *arg)
448 {
449 struct PStack *st = fi->userdata;
450 struct sk_buff *skb = arg;
451 int dequeued = 0;
452
453 FsmDelTimer(&st->l3.l3m_timer, 51);
454 FsmChangeState(fi, ST_L3_LC_ESTAB);
455 while ((skb = skb_dequeue(&st->l3.squeue))) {
456 st->l3.l3l2(st, DL_DATA | REQUEST, skb);
457 dequeued++;
458 }
459 if ((!st->l3.proc) && dequeued) {
460 if (st->l3.debug)
461 l3_debug(st, "lc_connected: release link");
462 FsmEvent(&st->l3.l3m, EV_RELEASE_REQ, NULL);
463 } else
464 l3ml3p(st, DL_ESTABLISH | CONFIRM);
465 }
466
467 static void
468 lc_start_delay(struct FsmInst *fi, int event, void *arg)
469 {
470 struct PStack *st = fi->userdata;
471
472 FsmChangeState(fi, ST_L3_LC_REL_DELAY);
473 FsmAddTimer(&st->l3.l3m_timer, DREL_TIMER_VALUE, EV_TIMEOUT, NULL, 50);
474 }
475
476 static void
477 lc_start_delay_check(struct FsmInst *fi, int event, void *arg)
478 /* 20/09/00 - GE timer not user for NI-1 as layer 2 should stay up */
479 {
480 struct PStack *st = fi->userdata;
481
482 FsmChangeState(fi, ST_L3_LC_REL_DELAY);
483 /* 19/09/00 - GE timer not user for NI-1 */
484 if (st->protocol != ISDN_PTYPE_NI1)
485 FsmAddTimer(&st->l3.l3m_timer, DREL_TIMER_VALUE, EV_TIMEOUT, NULL, 50);
486 }
487
488 static void
489 lc_release_req(struct FsmInst *fi, int event, void *arg)
490 {
491 struct PStack *st = fi->userdata;
492
493 if (test_bit(FLG_L2BLOCK, &st->l2.flag)) {
494 if (st->l3.debug)
495 l3_debug(st, "lc_release_req: l2 blocked");
496 /* restart release timer */
497 FsmAddTimer(&st->l3.l3m_timer, DREL_TIMER_VALUE, EV_TIMEOUT, NULL, 51);
498 } else {
499 FsmChangeState(fi, ST_L3_LC_REL_WAIT);
500 st->l3.l3l2(st, DL_RELEASE | REQUEST, NULL);
501 }
502 }
503
504 static void
505 lc_release_ind(struct FsmInst *fi, int event, void *arg)
506 {
507 struct PStack *st = fi->userdata;
508
509 FsmDelTimer(&st->l3.l3m_timer, 52);
510 FsmChangeState(fi, ST_L3_LC_REL);
511 skb_queue_purge(&st->l3.squeue);
512 l3ml3p(st, DL_RELEASE | INDICATION);
513 }
514
515 static void
516 lc_release_cnf(struct FsmInst *fi, int event, void *arg)
517 {
518 struct PStack *st = fi->userdata;
519
520 FsmChangeState(fi, ST_L3_LC_REL);
521 skb_queue_purge(&st->l3.squeue);
522 l3ml3p(st, DL_RELEASE | CONFIRM);
523 }
524
525
526 /* *INDENT-OFF* */
527 static struct FsmNode L3FnList[] __initdata =
528 {
529 {ST_L3_LC_REL, EV_ESTABLISH_REQ, lc_activate},
530 {ST_L3_LC_REL, EV_ESTABLISH_IND, lc_connect},
531 {ST_L3_LC_REL, EV_ESTABLISH_CNF, lc_connect},
532 {ST_L3_LC_ESTAB_WAIT, EV_ESTABLISH_CNF, lc_connected},
533 {ST_L3_LC_ESTAB_WAIT, EV_RELEASE_REQ, lc_start_delay},
534 {ST_L3_LC_ESTAB_WAIT, EV_RELEASE_IND, lc_release_ind},
535 {ST_L3_LC_ESTAB, EV_RELEASE_IND, lc_release_ind},
536 {ST_L3_LC_ESTAB, EV_RELEASE_REQ, lc_start_delay_check},
537 {ST_L3_LC_REL_DELAY, EV_RELEASE_IND, lc_release_ind},
538 {ST_L3_LC_REL_DELAY, EV_ESTABLISH_REQ, lc_connected},
539 {ST_L3_LC_REL_DELAY, EV_TIMEOUT, lc_release_req},
540 {ST_L3_LC_REL_WAIT, EV_RELEASE_CNF, lc_release_cnf},
541 {ST_L3_LC_REL_WAIT, EV_ESTABLISH_REQ, lc_activate},
542 };
543 /* *INDENT-ON* */
544
545 void
546 l3_msg(struct PStack *st, int pr, void *arg)
547 {
548 switch (pr) {
549 case (DL_DATA | REQUEST):
550 if (st->l3.l3m.state == ST_L3_LC_ESTAB) {
551 st->l3.l3l2(st, pr, arg);
552 } else {
553 struct sk_buff *skb = arg;
554
555 skb_queue_tail(&st->l3.squeue, skb);
556 FsmEvent(&st->l3.l3m, EV_ESTABLISH_REQ, NULL);
557 }
558 break;
559 case (DL_ESTABLISH | REQUEST):
560 FsmEvent(&st->l3.l3m, EV_ESTABLISH_REQ, NULL);
561 break;
562 case (DL_ESTABLISH | CONFIRM):
563 FsmEvent(&st->l3.l3m, EV_ESTABLISH_CNF, NULL);
564 break;
565 case (DL_ESTABLISH | INDICATION):
566 FsmEvent(&st->l3.l3m, EV_ESTABLISH_IND, NULL);
567 break;
568 case (DL_RELEASE | INDICATION):
569 FsmEvent(&st->l3.l3m, EV_RELEASE_IND, NULL);
570 break;
571 case (DL_RELEASE | CONFIRM):
572 FsmEvent(&st->l3.l3m, EV_RELEASE_CNF, NULL);
573 break;
574 case (DL_RELEASE | REQUEST):
575 FsmEvent(&st->l3.l3m, EV_RELEASE_REQ, NULL);
576 break;
577 }
578 }
579
580 int __init
581 Isdnl3New(void)
582 {
583 l3fsm.state_count = L3_STATE_COUNT;
584 l3fsm.event_count = L3_EVENT_COUNT;
585 l3fsm.strEvent = strL3Event;
586 l3fsm.strState = strL3State;
587 return FsmNew(&l3fsm, L3FnList, ARRAY_SIZE(L3FnList));
588 }
589
590 void
591 Isdnl3Free(void)
592 {
593 FsmFree(&l3fsm);
594 }
Linux with added FPC-III support