1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/slab.h>
20#include <linux/module.h>
21#include <linux/mISDNhw.h>
22#include "core.h"
23#include "layer1.h"
24#include "fsm.h"
25
26static u_int *debug;
27
28struct layer1 {
29 u_long Flags;
30 struct FsmInst l1m;
31 struct FsmTimer timer3;
32 struct FsmTimer timerX;
33 int delay;
34 int t3_value;
35 struct dchannel *dch;
36 dchannel_l1callback *dcb;
37};
38
39#define TIMER3_DEFAULT_VALUE 7000
40
41static
42struct Fsm l1fsm_s = {NULL, 0, 0, NULL, NULL};
43
44enum {
45 ST_L1_F2,
46 ST_L1_F3,
47 ST_L1_F4,
48 ST_L1_F5,
49 ST_L1_F6,
50 ST_L1_F7,
51 ST_L1_F8,
52};
53
54#define L1S_STATE_COUNT (ST_L1_F8 + 1)
55
56static char *strL1SState[] =
57{
58 "ST_L1_F2",
59 "ST_L1_F3",
60 "ST_L1_F4",
61 "ST_L1_F5",
62 "ST_L1_F6",
63 "ST_L1_F7",
64 "ST_L1_F8",
65};
66
67enum {
68 EV_PH_ACTIVATE,
69 EV_PH_DEACTIVATE,
70 EV_RESET_IND,
71 EV_DEACT_CNF,
72 EV_DEACT_IND,
73 EV_POWER_UP,
74 EV_ANYSIG_IND,
75 EV_INFO2_IND,
76 EV_INFO4_IND,
77 EV_TIMER_DEACT,
78 EV_TIMER_ACT,
79 EV_TIMER3,
80};
81
82#define L1_EVENT_COUNT (EV_TIMER3 + 1)
83
84static char *strL1Event[] =
85{
86 "EV_PH_ACTIVATE",
87 "EV_PH_DEACTIVATE",
88 "EV_RESET_IND",
89 "EV_DEACT_CNF",
90 "EV_DEACT_IND",
91 "EV_POWER_UP",
92 "EV_ANYSIG_IND",
93 "EV_INFO2_IND",
94 "EV_INFO4_IND",
95 "EV_TIMER_DEACT",
96 "EV_TIMER_ACT",
97 "EV_TIMER3",
98};
99
100static void
101l1m_debug(struct FsmInst *fi, char *fmt, ...)
102{
103 struct layer1 *l1 = fi->userdata;
104 struct va_format vaf;
105 va_list va;
106
107 va_start(va, fmt);
108
109 vaf.fmt = fmt;
110 vaf.va = &va;
111
112 printk(KERN_DEBUG "%s: %pV\n", dev_name(&l1->dch->dev.dev), &vaf);
113
114 va_end(va);
115}
116
117static void
118l1_reset(struct FsmInst *fi, int event, void *arg)
119{
120 mISDN_FsmChangeState(fi, ST_L1_F3);
121}
122
123static void
124l1_deact_cnf(struct FsmInst *fi, int event, void *arg)
125{
126 struct layer1 *l1 = fi->userdata;
127
128 mISDN_FsmChangeState(fi, ST_L1_F3);
129 if (test_bit(FLG_L1_ACTIVATING, &l1->Flags))
130 l1->dcb(l1->dch, HW_POWERUP_REQ);
131}
132
133static void
134l1_deact_req_s(struct FsmInst *fi, int event, void *arg)
135{
136 struct layer1 *l1 = fi->userdata;
137
138 mISDN_FsmChangeState(fi, ST_L1_F3);
139 mISDN_FsmRestartTimer(&l1->timerX, 550, EV_TIMER_DEACT, NULL, 2);
140 test_and_set_bit(FLG_L1_DEACTTIMER, &l1->Flags);
141}
142
143static void
144l1_power_up_s(struct FsmInst *fi, int event, void *arg)
145{
146 struct layer1 *l1 = fi->userdata;
147
148 if (test_bit(FLG_L1_ACTIVATING, &l1->Flags)) {
149 mISDN_FsmChangeState(fi, ST_L1_F4);
150 l1->dcb(l1->dch, INFO3_P8);
151 } else
152 mISDN_FsmChangeState(fi, ST_L1_F3);
153}
154
155static void
156l1_go_F5(struct FsmInst *fi, int event, void *arg)
157{
158 mISDN_FsmChangeState(fi, ST_L1_F5);
159}
160
161static void
162l1_go_F8(struct FsmInst *fi, int event, void *arg)
163{
164 mISDN_FsmChangeState(fi, ST_L1_F8);
165}
166
167static void
168l1_info2_ind(struct FsmInst *fi, int event, void *arg)
169{
170 struct layer1 *l1 = fi->userdata;
171
172 mISDN_FsmChangeState(fi, ST_L1_F6);
173 l1->dcb(l1->dch, INFO3_P8);
174}
175
176static void
177l1_info4_ind(struct FsmInst *fi, int event, void *arg)
178{
179 struct layer1 *l1 = fi->userdata;
180
181 mISDN_FsmChangeState(fi, ST_L1_F7);
182 l1->dcb(l1->dch, INFO3_P8);
183 if (test_and_clear_bit(FLG_L1_DEACTTIMER, &l1->Flags))
184 mISDN_FsmDelTimer(&l1->timerX, 4);
185 if (!test_bit(FLG_L1_ACTIVATED, &l1->Flags)) {
186 if (test_and_clear_bit(FLG_L1_T3RUN, &l1->Flags))
187 mISDN_FsmDelTimer(&l1->timer3, 3);
188 mISDN_FsmRestartTimer(&l1->timerX, 110, EV_TIMER_ACT, NULL, 2);
189 test_and_set_bit(FLG_L1_ACTTIMER, &l1->Flags);
190 }
191}
192
193static void
194l1_timer3(struct FsmInst *fi, int event, void *arg)
195{
196 struct layer1 *l1 = fi->userdata;
197
198 test_and_clear_bit(FLG_L1_T3RUN, &l1->Flags);
199 if (test_and_clear_bit(FLG_L1_ACTIVATING, &l1->Flags)) {
200 if (test_and_clear_bit(FLG_L1_DBLOCKED, &l1->Flags))
201 l1->dcb(l1->dch, HW_D_NOBLOCKED);
202 l1->dcb(l1->dch, PH_DEACTIVATE_IND);
203 }
204 if (l1->l1m.state != ST_L1_F6) {
205 mISDN_FsmChangeState(fi, ST_L1_F3);
206
207 }
208}
209
210static void
211l1_timer_act(struct FsmInst *fi, int event, void *arg)
212{
213 struct layer1 *l1 = fi->userdata;
214
215 test_and_clear_bit(FLG_L1_ACTTIMER, &l1->Flags);
216 test_and_set_bit(FLG_L1_ACTIVATED, &l1->Flags);
217 l1->dcb(l1->dch, PH_ACTIVATE_IND);
218}
219
220static void
221l1_timer_deact(struct FsmInst *fi, int event, void *arg)
222{
223 struct layer1 *l1 = fi->userdata;
224
225 test_and_clear_bit(FLG_L1_DEACTTIMER, &l1->Flags);
226 test_and_clear_bit(FLG_L1_ACTIVATED, &l1->Flags);
227 if (test_and_clear_bit(FLG_L1_DBLOCKED, &l1->Flags))
228 l1->dcb(l1->dch, HW_D_NOBLOCKED);
229 l1->dcb(l1->dch, PH_DEACTIVATE_IND);
230 l1->dcb(l1->dch, HW_DEACT_REQ);
231}
232
233static void
234l1_activate_s(struct FsmInst *fi, int event, void *arg)
235{
236 struct layer1 *l1 = fi->userdata;
237
238 mISDN_FsmRestartTimer(&l1->timer3, l1->t3_value, EV_TIMER3, NULL, 2);
239 test_and_set_bit(FLG_L1_T3RUN, &l1->Flags);
240
241 l1->dcb(l1->dch, HW_RESET_REQ);
242}
243
244static void
245l1_activate_no(struct FsmInst *fi, int event, void *arg)
246{
247 struct layer1 *l1 = fi->userdata;
248
249 if ((!test_bit(FLG_L1_DEACTTIMER, &l1->Flags)) &&
250 (!test_bit(FLG_L1_T3RUN, &l1->Flags))) {
251 test_and_clear_bit(FLG_L1_ACTIVATING, &l1->Flags);
252 if (test_and_clear_bit(FLG_L1_DBLOCKED, &l1->Flags))
253 l1->dcb(l1->dch, HW_D_NOBLOCKED);
254 l1->dcb(l1->dch, PH_DEACTIVATE_IND);
255 }
256}
257
258static struct FsmNode L1SFnList[] =
259{
260 {ST_L1_F3, EV_PH_ACTIVATE, l1_activate_s},
261 {ST_L1_F6, EV_PH_ACTIVATE, l1_activate_no},
262 {ST_L1_F8, EV_PH_ACTIVATE, l1_activate_no},
263 {ST_L1_F3, EV_RESET_IND, l1_reset},
264 {ST_L1_F4, EV_RESET_IND, l1_reset},
265 {ST_L1_F5, EV_RESET_IND, l1_reset},
266 {ST_L1_F6, EV_RESET_IND, l1_reset},
267 {ST_L1_F7, EV_RESET_IND, l1_reset},
268 {ST_L1_F8, EV_RESET_IND, l1_reset},
269 {ST_L1_F3, EV_DEACT_CNF, l1_deact_cnf},
270 {ST_L1_F4, EV_DEACT_CNF, l1_deact_cnf},
271 {ST_L1_F5, EV_DEACT_CNF, l1_deact_cnf},
272 {ST_L1_F6, EV_DEACT_CNF, l1_deact_cnf},
273 {ST_L1_F7, EV_DEACT_CNF, l1_deact_cnf},
274 {ST_L1_F8, EV_DEACT_CNF, l1_deact_cnf},
275 {ST_L1_F6, EV_DEACT_IND, l1_deact_req_s},
276 {ST_L1_F7, EV_DEACT_IND, l1_deact_req_s},
277 {ST_L1_F8, EV_DEACT_IND, l1_deact_req_s},
278 {ST_L1_F3, EV_POWER_UP, l1_power_up_s},
279 {ST_L1_F4, EV_ANYSIG_IND, l1_go_F5},
280 {ST_L1_F6, EV_ANYSIG_IND, l1_go_F8},
281 {ST_L1_F7, EV_ANYSIG_IND, l1_go_F8},
282 {ST_L1_F3, EV_INFO2_IND, l1_info2_ind},
283 {ST_L1_F4, EV_INFO2_IND, l1_info2_ind},
284 {ST_L1_F5, EV_INFO2_IND, l1_info2_ind},
285 {ST_L1_F7, EV_INFO2_IND, l1_info2_ind},
286 {ST_L1_F8, EV_INFO2_IND, l1_info2_ind},
287 {ST_L1_F3, EV_INFO4_IND, l1_info4_ind},
288 {ST_L1_F4, EV_INFO4_IND, l1_info4_ind},
289 {ST_L1_F5, EV_INFO4_IND, l1_info4_ind},
290 {ST_L1_F6, EV_INFO4_IND, l1_info4_ind},
291 {ST_L1_F8, EV_INFO4_IND, l1_info4_ind},
292 {ST_L1_F3, EV_TIMER3, l1_timer3},
293 {ST_L1_F4, EV_TIMER3, l1_timer3},
294 {ST_L1_F5, EV_TIMER3, l1_timer3},
295 {ST_L1_F6, EV_TIMER3, l1_timer3},
296 {ST_L1_F8, EV_TIMER3, l1_timer3},
297 {ST_L1_F7, EV_TIMER_ACT, l1_timer_act},
298 {ST_L1_F3, EV_TIMER_DEACT, l1_timer_deact},
299 {ST_L1_F4, EV_TIMER_DEACT, l1_timer_deact},
300 {ST_L1_F5, EV_TIMER_DEACT, l1_timer_deact},
301 {ST_L1_F6, EV_TIMER_DEACT, l1_timer_deact},
302 {ST_L1_F7, EV_TIMER_DEACT, l1_timer_deact},
303 {ST_L1_F8, EV_TIMER_DEACT, l1_timer_deact},
304};
305
306static void
307release_l1(struct layer1 *l1) {
308 mISDN_FsmDelTimer(&l1->timerX, 0);
309 mISDN_FsmDelTimer(&l1->timer3, 0);
310 if (l1->dch)
311 l1->dch->l1 = NULL;
312 module_put(THIS_MODULE);
313 kfree(l1);
314}
315
316int
317l1_event(struct layer1 *l1, u_int event)
318{
319 int err = 0;
320
321 if (!l1)
322 return -EINVAL;
323 switch (event) {
324 case HW_RESET_IND:
325 mISDN_FsmEvent(&l1->l1m, EV_RESET_IND, NULL);
326 break;
327 case HW_DEACT_IND:
328 mISDN_FsmEvent(&l1->l1m, EV_DEACT_IND, NULL);
329 break;
330 case HW_POWERUP_IND:
331 mISDN_FsmEvent(&l1->l1m, EV_POWER_UP, NULL);
332 break;
333 case HW_DEACT_CNF:
334 mISDN_FsmEvent(&l1->l1m, EV_DEACT_CNF, NULL);
335 break;
336 case ANYSIGNAL:
337 mISDN_FsmEvent(&l1->l1m, EV_ANYSIG_IND, NULL);
338 break;
339 case LOSTFRAMING:
340 mISDN_FsmEvent(&l1->l1m, EV_ANYSIG_IND, NULL);
341 break;
342 case INFO2:
343 mISDN_FsmEvent(&l1->l1m, EV_INFO2_IND, NULL);
344 break;
345 case INFO4_P8:
346 mISDN_FsmEvent(&l1->l1m, EV_INFO4_IND, NULL);
347 break;
348 case INFO4_P10:
349 mISDN_FsmEvent(&l1->l1m, EV_INFO4_IND, NULL);
350 break;
351 case PH_ACTIVATE_REQ:
352 if (test_bit(FLG_L1_ACTIVATED, &l1->Flags))
353 l1->dcb(l1->dch, PH_ACTIVATE_IND);
354 else {
355 test_and_set_bit(FLG_L1_ACTIVATING, &l1->Flags);
356 mISDN_FsmEvent(&l1->l1m, EV_PH_ACTIVATE, NULL);
357 }
358 break;
359 case CLOSE_CHANNEL:
360 release_l1(l1);
361 break;
362 default:
363 if ((event & ~HW_TIMER3_VMASK) == HW_TIMER3_VALUE) {
364 int val = event & HW_TIMER3_VMASK;
365
366 if (val < 5)
367 val = 5;
368 if (val > 30)
369 val = 30;
370 l1->t3_value = val;
371 break;
372 }
373 if (*debug & DEBUG_L1)
374 printk(KERN_DEBUG "%s %x unhandled\n",
375 __func__, event);
376 err = -EINVAL;
377 }
378 return err;
379}
380EXPORT_SYMBOL(l1_event);
381
382int
383create_l1(struct dchannel *dch, dchannel_l1callback *dcb) {
384 struct layer1 *nl1;
385
386 nl1 = kzalloc(sizeof(struct layer1), GFP_ATOMIC);
387 if (!nl1) {
388 printk(KERN_ERR "kmalloc struct layer1 failed\n");
389 return -ENOMEM;
390 }
391 nl1->l1m.fsm = &l1fsm_s;
392 nl1->l1m.state = ST_L1_F3;
393 nl1->Flags = 0;
394 nl1->t3_value = TIMER3_DEFAULT_VALUE;
395 nl1->l1m.debug = *debug & DEBUG_L1_FSM;
396 nl1->l1m.userdata = nl1;
397 nl1->l1m.userint = 0;
398 nl1->l1m.printdebug = l1m_debug;
399 nl1->dch = dch;
400 nl1->dcb = dcb;
401 mISDN_FsmInitTimer(&nl1->l1m, &nl1->timer3);
402 mISDN_FsmInitTimer(&nl1->l1m, &nl1->timerX);
403 __module_get(THIS_MODULE);
404 dch->l1 = nl1;
405 return 0;
406}
407EXPORT_SYMBOL(create_l1);
408
409int
410l1_init(u_int *deb)
411{
412 debug = deb;
413 l1fsm_s.state_count = L1S_STATE_COUNT;
414 l1fsm_s.event_count = L1_EVENT_COUNT;
415 l1fsm_s.strEvent = strL1Event;
416 l1fsm_s.strState = strL1SState;
417 return mISDN_FsmNew(&l1fsm_s, L1SFnList, ARRAY_SIZE(L1SFnList));
418}
419
420void
421l1_cleanup(void)
422{
423 mISDN_FsmFree(&l1fsm_s);
424}
425
