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