drivers/isdn/mISDN/layer1.c

   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 }