1 /* 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 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 26 static u_int *debug; 27 28 struct 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 41 static 42 struct Fsm l1fsm_s = {NULL, 0, 0, NULL, NULL}; 43 44 enum { 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 56 static 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 67 enum { 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 84 static 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 100 static void 101 l1m_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 117 static void 118 l1_reset(struct FsmInst *fi, int event, void *arg) 119 { 120 mISDN_FsmChangeState(fi, ST_L1_F3); 121 } 122 123 static void 124 l1_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 133 static void 134 l1_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 143 static void 144 l1_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 155 static void 156 l1_go_F5(struct FsmInst *fi, int event, void *arg) 157 { 158 mISDN_FsmChangeState(fi, ST_L1_F5); 159 } 160 161 static void 162 l1_go_F8(struct FsmInst *fi, int event, void *arg) 163 { 164 mISDN_FsmChangeState(fi, ST_L1_F8); 165 } 166 167 static void 168 l1_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 176 static void 177 l1_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 193 static void 194 l1_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 /* do not force anything here, we need send INFO 0 */ 207 } 208 } 209 210 static void 211 l1_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 220 static void 221 l1_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 233 static void 234 l1_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 /* Tell HW to send INFO 1 */ 241 l1->dcb(l1->dch, HW_RESET_REQ); 242 } 243 244 static void 245 l1_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 258 static 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 306 static void 307 release_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 316 int 317 l1_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 } 380 EXPORT_SYMBOL(l1_event); 381 382 int 383 create_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 } 407 EXPORT_SYMBOL(create_l1); 408 409 int 410 l1_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 420 void 421 l1_cleanup(void) 422 { 423 mISDN_FsmFree(&l1fsm_s); 424 } 425