src/cm/cm_bdy5.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /********************************************************************20**
  20
  21      Name:     common functions - 5
  22
  23      Type:     C source file
  24
  25      Desc:     C source code for common timer routines;
  26
  27      File:     cm_bdy5.c
  28
  29 *********************************************************************21*/
  30
  31 \f
  32 /* header include files -- defines (.h) */
  33
  34 #include "envopt.h"        /* environment options */
  35 #include "envdep.h"        /* environment dependent */
  36 #include "envind.h"        /* environment independent */
  37
  38 #include "gen.h"           /* general */
  39 #include "ssi.h"           /* system services */
  40 #include "cm5.h"           /* common functions */
  41
  42 /* header/extern include files (.x) */
  43
  44 #include "gen.x"           /* general */
  45 #include "ssi.x"           /* system services */
  46 #include "cm5.x"           /* common functions */
  47
  48 \f
  49 /* local defines */
  50
  51 #define CM_RMV_TQCP(tqEnt, tgt)                            \
  52 {                                                          \
  53    ((tgt)->prev) ? ((tgt)->prev->next = (tgt)->next):      \
  54                   ((tqEnt)->first = (tgt)->next);          \
  55    ((tgt)->next) ? ((tgt)->next->prev = (tgt)->prev):      \
  56                   ((tqEnt)->tail = (tgt)->prev);           \
  57    (tgt)->prev = NULLP;                                    \
  58    (tgt)->next = NULLP;                                    \
  59    (tgt)->ent2bUpd = FALSE;                                \
  60 }
  61
  62 #define CM_PLC_TQCP(tqEnt, tgt)                            \
  63 {                                                          \
  64    if ((tqEnt)->tail)                                      \
  65    {                                                       \
  66       (tqEnt)->tail->next = tgt;                           \
  67       (tgt)->prev = (tqEnt)->tail;                         \
  68       (tqEnt)->tail = tgt;                                 \
  69    }                                                       \
  70    else                                                    \
  71    {                                                       \
  72       (tqEnt)->first = (tqEnt)->tail = tgt;                \
  73    }                                                       \
  74 }
  75
  76 /* local externs */
  77
  78 /* forward references */
  79
  80 /* functions in other modules */
  81
  82 \f
  83 /*
  84 *
  85 *       Fun:   cmPrcTmr
  86 *
  87 *       Desc:  Handle a timer entry
  88 *
  89 *       Ret:   RETVOID
  90 *
  91 *       Notes:
  92 *
  93 *       File:  cm_bdy5.c
  94 *
  95 */
  96
  97 #ifdef SS_FAP
  98 #ifdef ANSI
  99 PUBLIC Void cmPrcTmr
 100 (
 101 CmTqCp   *tqCp,          /* timing que control point */
 102 CmTqType *tq,            /* timing queue */
 103 PFV      func            /* function */
 104 )
 105 #else
 106 PUBLIC Void cmPrcTmr(tqCp, tq, func)
 107 CmTqCp   *tqCp;          /* connection control block */
 108 CmTqType *tq;            /* message buffer */
 109 PFV      func;           /* function */
 110 #endif
 111 {
 112 /**/
 113    U32 expire;
 114    U32 entry;
 115    S16 event;
 116    PTR cb;
 117    CmTimer *tmp1;
 118    CmTimer **tmp2;
 119
 120    TRC2(cmPrcTmr)
 121
 122 #ifdef CMDBG
 123 {
 124    DateTime dt;
 125    Txt prntBuf[PRNTSZE];
 126
 127    SGetDateTime(&dt);
 128    /* Here the year was being printed as 2 letter value and hence did
 129     * not represent accurate information.  It has been modified as
 130     * recommended to include the offset of year 1900 used in all Trillium
 131     * SSI implementations. Patch cmbdy5c_001.113
 132     */
 133    sprintf(prntBuf,"%s: date: %02d/%02d/%04d time: %02d:%02d:%02d\n",
 134            msArgv[0],dt.month,dt.day,(int)(dt.year + 1900), dt.hour,
 135            dt.min, dt.sec);
 136    SPrint(prntBuf);
 137 }
 138 #endif
 139
 140    ++tqCp->nxtEnt;
 141    expire = tqCp->nxtEnt;
 142    /* cm_bdy5_c_002.113 - Modification for SRegCfgTmr support */
 143    entry = (U32) (expire % (U32)(tqCp->tmrLen));
 144
 145    tmp2 = &tq[entry].first;
 146    while ((tmp1 = *tmp2) != NULLP)
 147    {
 148       if (tmp1->tqExpire == expire)
 149       {
 150          event = tmp1->tmrEvnt;
 151          cb = tmp1->cb;
 152          /* remove and reset this timer control block */
 153          (*tmp2) = tmp1->next;
 154          tmp1->tmrEvnt = TMR_NONE;
 155          tmp1->tqExpire = 0;
 156          tmp1->cb = NULLP;
 157          tmp1->next = NULLP;
 158          func(cb, event);
 159       }
 160       else
 161          tmp2 = &tmp1->next;
 162    }
 163    RETVOID;
 164 } /* end of cmPrcTmr */
 165
 166 #else /* not defined SS_FAP */
 167
 168 #ifdef ANSI
 169 PUBLIC Void cmPrcTmr
 170 (
 171 CmTqCp   *tqCp,          /* timing que control point */
 172 CmTqType *tq,            /* timing queue */
 173 PFV      func            /* function */
 174 )
 175 #else
 176 PUBLIC Void cmPrcTmr(tqCp, tq, func)
 177 CmTqCp   *tqCp;          /* connection control block */
 178 CmTqType *tq;            /* message buffer */
 179 PFV      func;           /* function */
 180 #endif
 181 {
 182 /**/
 183    U32 expire;
 184    U32 entry, entry1;
 185    S16 event;
 186    CmTqType *tqEnt, *tqEnt1;
 187    PTR cb;
 188    CmTimer *tmp1;
 189    VOLATILE U32     startTime = 0;
 190
 191    TRC2(cmPrcTmr)
 192
 193    /*starting Task*/
 194    SStartTask(&startTime, PID_CM_PRC_TMR);
 195
 196 #ifdef CMDBG
 197 {
 198    DateTime dt;
 199    Txt prntBuf[PRNTSZE];
 200
 201    SGetDateTime(&dt);
 202    /* Here the year was being printed as 2 letter value and hence did
 203     * not represent accurate information.  It has been modified as
 204     * recommended to include the offset of year 1900 used in all Trillium
 205     * SSI implementations.
 206     */
 207    sprintf(prntBuf,"%s: date: %02d/%02d/%04d time: %02d:%02d:%02d\n",
 208            msArgv[0],dt.month,dt.day,(int)(dt.year + 1900), dt.hour,
 209            dt.min, dt.sec);
 210    SPrint(prntBuf);
 211 }
 212 #endif
 213
 214    ++tqCp->nxtEnt;
 215    expire = tqCp->nxtEnt;
 216         tqCp->tmrLen = 1;
 217    entry = (U32) (expire % (U32)(tqCp->tmrLen));
 218
 219    tqCp->tmp = (tqEnt = &tq[entry])->first;
 220    while ((tmp1 = tqCp->tmp) != NULLP)
 221    {
 222       tqCp->tmp = tmp1->next;
 223       /* SRIKY - Temp Fix to overcome timer not firing. Need to take */
 224           /* care of wrap around case                                                    */
 225       if ((tmp1->tqExpire <= expire) || (tmp1->ent2bUpd))
 226       {
 227          event = tmp1->tmrEvnt;
 228          cb = tmp1->cb;
 229
 230          if (!(tmp1->ent2bUpd))
 231          {
 232             CM_RMV_TQCP(tqEnt, tmp1);
 233             tmp1->tmrEvnt = TMR_NONE;
 234             tmp1->tqExpire = 0;
 235             tmp1->cb = NULLP;
 236
 237             func(cb, event);
 238          }
 239          else
 240          {
 241             entry1 = (U32) (tmp1->tqExpire % (U32)(tqCp->tmrLen));
 242             tqEnt1 = &tq[entry1];
 243             CM_RMV_TQCP(tqEnt, tmp1);
 244             tmp1->entIdx = entry1;
 245             CM_PLC_TQCP(tqEnt1, tmp1);
 246          }
 247       }
 248    }
 249
 250    /*stoping Task*/
 251    SStopTask(startTime, PID_CM_PRC_TMR);
 252    RETVOID;
 253 } /* end of cmPrcTmr */
 254 #endif /* SS_FAP */
 255
 256
 257 \f
 258 /*
 259 *
 260 *       Fun:   cmInitTimers
 261 *
 262 *       Desc:  initialize timers
 263 *
 264 *       Ret:   RETVOID
 265 *
 266 *       Notes: Connection Oriented Control
 267 *
 268 *       File:  cm_bdy5.c
 269 *
 270 */
 271 #ifdef ANSI
 272 PUBLIC Void cmInitTimers
 273 (
 274 CmTimer *timers,     /* timer list */
 275 U8 max               /* maximum tmrs */
 276 )
 277 #else
 278 PUBLIC Void cmInitTimers(timers, max)
 279 CmTimer *timers;     /* timer list */
 280 U8 max;              /* maximum tmrs */
 281 #endif
 282 {
 283    CmTimer *tPtr;
 284    REG1 U8 i;
 285
 286    TRC2(cmInitTimers)
 287
 288    for (i = 0, tPtr = timers; i < max; i++, tPtr++)
 289    {
 290       tPtr->tmrEvnt = TMR_NONE;
 291       tPtr->tqExpire = 0;
 292       tPtr->cb = 0;
 293       tPtr->next = (struct cmTimer *)NULLP;
 294       tPtr->prev = (struct cmTimer *)NULLP;
 295       tPtr->ent2bUpd = FALSE;
 296    }
 297    RETVOID;
 298 } /* end of cmInitTimers */
 299
 300 /*
 301 *
 302 *       Fun:    cmPlcCbTq
 303 *
 304 *       Desc:   Places Control Block on Timing Queue
 305 *
 306 *       Ret:    RETVOID
 307 *
 308 *       Notes:  None
 309 *
 310 *       File:   cm_bdy5.c
 311 *
 312 */
 313
 314 #ifdef ANSI
 315 PUBLIC Void cmPlcCbTq
 316 (
 317 CmTmrArg *arg
 318 )
 319 #else
 320 PUBLIC Void cmPlcCbTq(arg)
 321 CmTmrArg *arg;
 322 #endif
 323 {
 324 /*added FAP modifications*/
 325 #ifdef SS_FAP
 326    REG1 U8 tmrNum;
 327    /* cm_bdy5_c_001.main_20 - Modification for SRegCfgTmr support */
 328    U32 ent;
 329    U32 expire;
 330    CmTimer **tmp;
 331
 332    TRC2(cmPlcCbTq)
 333
 334    expire = (arg->tqCp->nxtEnt + arg->wait);
 335    /* cm_bdy5_c_002.113 - Modification for SRegCfgTmr support */
 336    ent = (U32)(expire % (U32)(arg->tqCp->tmrLen));
 337
 338    for (tmrNum = 0; tmrNum < arg->max; tmrNum++)
 339    {
 340       if (arg->timers[tmrNum].tmrEvnt == TMR_NONE)
 341       {
 342          arg->timers[tmrNum].tmrEvnt = arg->evnt;
 343          arg->timers[tmrNum].tqExpire = expire;
 344          arg->timers[tmrNum].cb = arg->cb;
 345          arg->timers[tmrNum].next = NULLP;
 346
 347          tmp = &(arg->tq[ent].first);
 348          while (*tmp)
 349             tmp = &((*tmp)->next);
 350          *tmp = &arg->timers[tmrNum];
 351
 352          RETVOID;
 353       }
 354    }
 355    RETVOID;
 356 #else
 357    REG1 U8 tmrNum;
 358    U32 ent;
 359    CmTqType *tq;
 360    CmTimer  *target;
 361    U32 expire;
 362    TRC2(cmPlcCbTq)
 363
 364    expire = (arg->tqCp->nxtEnt + arg->wait);
 365    ent = (U32)(expire % (U32)(arg->tqCp->tmrLen));
 366
 367    for (tmrNum = 0; tmrNum < arg->max; tmrNum++)
 368    {
 369       if (arg->timers[tmrNum].tmrEvnt == TMR_NONE)
 370       {
 371          target = &arg->timers[tmrNum];
 372          tq = &arg->tq[ent];
 373
 374          target->tmrEvnt = arg->evnt;
 375          target->tqExpire = expire;
 376          target->cb = arg->cb;
 377          target->ent2bUpd = FALSE;
 378          target->entIdx   = ent;
 379
 380          /* Place the timer block in the timer list */
 381          CM_PLC_TQCP(tq, target);
 382
 383          RETVOID;
 384       }
 385    }
 386    RETVOID;
 387 #endif
 388 } /* end of cmPlcCbTq */
 389
 390 /*
 391 *
 392 *       Fun:    cmRstCbTq
 393 *
 394 *       Desc:   Places Control Block on Timing Queue
 395 *
 396 *       Ret:    RETVOID
 397 *
 398 *       Notes:  None
 399 *
 400 *       File:   cm_bdy5.c
 401 *
 402 */
 403
 404 #ifdef ANSI
 405 PUBLIC Void cmRstCbTq
 406 (
 407 CmTmrArg *arg
 408 )
 409 #else
 410 PUBLIC Void cmRstCbTq(arg)
 411 CmTmrArg *arg;
 412 #endif
 413 {
 414    TRC2(cmRstCbTq)
 415
 416    arg->timers[arg->tNum].tqExpire = arg->tqCp->nxtEnt + arg->wait;
 417    arg->timers[arg->tNum].ent2bUpd = TRUE;
 418
 419    RETVOID;
 420 } /* end of cmRstCbTq */
 421
 422 /*
 423 *
 424 *       Fun:    cmRmvCbTq
 425 *
 426 *       Desc:   Removes control block from Timing Queue
 427 *
 428 *       Ret:    RETVOID
 429 *
 430 *       Notes:  None
 431 *
 432 *       File:   cm_bdy5.c
 433 *
 434 */
 435
 436 #ifdef ANSI
 437 PUBLIC Void cmRmvCbTq
 438 (
 439 CmTmrArg *arg
 440 )
 441 #else
 442 PUBLIC Void cmRmvCbTq(arg)
 443 CmTmrArg *arg;
 444 #endif
 445 {
 446 /*Added FAP modifications*/
 447 #ifdef SS_FAP
 448 /* cm_bdy5_c_002.113 - Modification for SRegCfgTmr support */
 449    U32 ent;
 450    CmTimer *target;
 451    CmTimer *tmp1;
 452    CmTimer **tmp2;
 453
 454    TRC2(cmRmvCbTq)
 455
 456    target = &arg->timers[arg->tNum];
 457    if (target->tmrEvnt != TMR_NONE)
 458    {
 459       /* cm_bdy5_c_002.113 - Modification for SRegCfgTmr support */
 460       ent = (U32) (target->tqExpire % (U32)(arg->tqCp->tmrLen));
 461       tmp2 = &arg->tq[ent].first;
 462
 463       while ((tmp1 = *tmp2) != NULLP)
 464       {
 465          if (tmp1 == target)
 466          {
 467             /* find the timer control block to be removed */
 468             (*tmp2) = tmp1->next;
 469             tmp1->tmrEvnt = TMR_NONE;
 470             tmp1->tqExpire = 0;
 471             tmp1->cb = NULLP;
 472             tmp1->next = NULLP;
 473             break;
 474          }
 475          else
 476             /* find the next timer control block */
 477             tmp2 = &tmp1->next;
 478       }
 479    }
 480    RETVOID;
 481 #else
 482    U32 ent;
 483    CmTimer  *target;
 484    CmTqType *tq;
 485
 486
 487    TRC2(cmRmvCbTq)
 488
 489    target = &arg->timers[arg->tNum];
 490    if (target->tmrEvnt != TMR_NONE)
 491    {
 492       ent = (U32) (target->entIdx);
 493       tq = &arg->tq[ent];
 494
 495       /*
 496        * Update the timer pointer in the for correct processing in
 497        * CmPrcTmr.
 498        */
 499       if (target == arg->tqCp->tmp)
 500          arg->tqCp->tmp = target->next;
 501
 502       /* Remove the entru from the list */
 503       CM_RMV_TQCP( tq , target);
 504       target->tmrEvnt = TMR_NONE;
 505       target->tqExpire = 0;
 506       target->cb = NULLP;
 507
 508    }
 509    RETVOID;
 510 #endif
 511 } /* end of cmRmvCbTq */
 512
 513 /**********************************************************************
 514          End of file
 515 **********************************************************************/