src/mt/ss_timer.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 \f
  19 /********************************************************************20**
  20
  21      Name:     System Services -- Timing
  22
  23      Type:     C source file
  24
  25      Desc:     Source code for System Services related to timing.
  26
  27      File:     ss_timer.c
  28
  29 *********************************************************************21*/
  30
  31 \f
  32 /* header include files (.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 layer */
  39 #include "ssi.h"           /* system services */
  40
  41 #include "ss_err.h"        /* errors */
  42 #include "ss_dep.h"        /* implementation-specific */
  43 #include "ss_queue.h"      /* queues */
  44 #include "ss_msg.h"        /* messaging */
  45 #include "ss_mem.h"        /* memory management interface */
  46 #include "ss_gen.h"        /* general */
  47 #include "cm_mem.h"        /* memory management */
  48
  49
  50
  51 /* header/extern include files (.x) */
  52
  53 #include "gen.x"           /* general layer */
  54 #include "ssi.x"           /* system services */
  55
  56 #include "ss_dep.x"        /* implementation-specific */
  57 #include "ss_queue.x"      /* queues */
  58 #include "ss_task.x"       /* tasking */
  59 #include "ss_timer.x"      /* timers */
  60 #include "ss_strm.x"       /* STREAMS */
  61 #include "ss_msg.x"        /* messaging */
  62 #include "ss_mem.x"        /* memory management interface */
  63 #include "ss_drvr.x"       /* driver tasks */
  64 #ifdef SS_LOCKLESS_MEMORY
  65 #include "cm_llist.x"
  66 #include "cm_hash.x"
  67 #include "cm_mem_wl.x"        /* common memory manager */
  68 #else
  69 #include "cm_mem.x"        /* common memory manager */
  70 #endif /* SS_LOCKLESS_MEMORY */
  71 #include "ss_gen.x"        /* general */
  72
  73
  74 /* Forward declarations */
  75
  76 /* ss041.103 Declaration for STmrRegHndlr */
  77 /* ss015.301 Changed the timer activation function type as all timer activation
  78  * functions are enclosed in a union.
  79  */
  80 #ifndef SS_MULTIPLE_PROCS
  81 static S16 STmrRegHndlr ARGS((
  82          Ent ent,
  83          Inst inst,
  84          S16 period,
  85          S16 units,
  86          SsTmrActvFn ssTmrActvFn
  87       ));
  88 /* ss015.301: Removed the timer handler prototypes guarded under SS_MT_TMR and
  89  * handled mtFlag in existing timer handlers.
  90  */
  91 #else /* SS_MULTIPLE_PROCS */
  92 static S16 STmrRegHndlr ARGS((
  93          ProcId proc,
  94          Ent ent,
  95          Inst inst,
  96          S16 period,
  97          S16 units,
  98          SsTmrActvFn ssTmrActvFn
  99       ));
 100 #endif /* SS_MULTIPLE_PROCS */
 101
 102 /* ss041.103 Declaration for STmrDeregHndlr */
 103 #ifndef SS_MULTIPLE_PROCS
 104 static S16 STmrDeregHndlr ARGS((
 105          Ent ent,
 106          Inst inst,
 107          S16 period,
 108          S16 units,
 109          SsTmrActvFn ssTmrActvFn
 110       ));
 111 /* ss015.301 Removed the timer handler prototypes guarded under SS_MT_TMR and
 112  * handled mtFlag in existing timer handlers.
 113  */
 114 #else /* SS_MULTIPLE_PROCS */
 115 static S16 STmrDeregHndlr ARGS((
 116          ProcId proc,
 117          Ent ent,
 118          Inst inst,
 119          S16 period,
 120          S16 units,
 121          SsTmrActvFn ssTmrActvFn
 122       ));
 123 #endif /* SS_MULTIPLE_PROCS */
 124
 125
 126 \f
 127 /* ss028.103 - Modification for SRegCfgTmr Support */
 128 /*
 129 *
 130 *       Fun:   Register Configurable Timer Task - timer
 131 *
 132 *       Desc:  This function is used to register a timer function for the
 133 *              layer. The system services will periodically invoke the
 134 *              function passed to it. The timer function will be used by the
 135 *              layer to manage the layers internal protocol timers.
 136 *
 137 *       Ret:   ROK      - ok
 138 *              RFAILED  - failed, general (optional)
 139 *              ROUTRES  - failed, out of resources (optional)
 140 *
 141 *       Notes:
 142 *
 143 *       File:  ss_timer.c
 144 *
 145 */
 146 /* ss029.103: addition: procId added and timer function type modified */
 147 #ifndef SS_MULTIPLE_PROCS
 148 S16 SRegCfgTmr
 149 (
 150 Ent ent,                    /* entity */
 151 Inst inst,                  /* instance */
 152 S16 period,                 /* period */
 153 S16 units,                  /* period units */
 154 PFS16 tmrFnct               /* timer function, typically SActvTmr */
 155 )
 156 {
 157    S16 ret;
 158    /* ss015.301 - Enclosed all timer activation functions in a union. */
 159    SsTmrActvFn ssTmrActvFn;
 160    /* ss041.103 - Moved handling to STmrRegHndlr */
 161
 162    ssTmrActvFn.mtFlag = FALSE;
 163    ssTmrActvFn.actvFnc.tmrActvFn = tmrFnct;
 164    ret = STmrRegHndlr(ent, inst, period, units, ssTmrActvFn);
 165
 166    return (ret);
 167 }
 168
 169 #else /* SS_MULTIPLE_PROCS */
 170
 171 S16 SRegCfgTmr
 172 (
 173 ProcId proc,                /* processor */
 174 Ent ent,                    /* entity */
 175 Inst inst,                  /* instance */
 176 S16 period,                 /* period */
 177 S16 units,                  /* period units */
 178 PAIFTMRS16 tmrFnct               /* timer function, typically SActvTmr */
 179 )
 180 {
 181    S16 ret;
 182    /* ss015.301 - Enclosed all timer activation functions in a union. */
 183    SsTmrActvFn ssTmrActvFn;
 184    /* ss041.103 - Moved handling to STmrRegHndlr */
 185
 186    ssTmrActvFn.mtFlag = FALSE;
 187    ssTmrActvFn.actvFnc.tmrActvFn = tmrFnct;
 188    ret = STmrRegHndlr(proc, ent, inst, period, units, ssTmrActvFn);
 189
 190    return (ret);
 191 }
 192
 193 #endif /* SS_MULTIPLE_PROCS */
 194
 195 \f
 196 #ifndef SS_MULTIPLE_PROCS
 197 /* ss041.103 - New function for MT timer reg */
 198 #ifdef SS_MT_TMR
 199 /*
 200 *
 201 *       Fun:   Register Configurable Timer Task - timer
 202 *
 203 *       Desc:  This function is used to register a timer function for the
 204 *              layer. The system services will periodically invoke the
 205 *              function passed to it. The timer function will be used by the
 206 *              layer to manage the layers internal protocol timers.
 207 *
 208 *       Ret:   ROK      - ok
 209 *              RFAILED  - failed, general (optional)
 210 *              ROUTRES  - failed, out of resources (optional)
 211 *
 212 *       Notes: By invoking this function, Ent and Inst are passed in the
 213 *              timer activation function.
 214 *
 215 *       File:  ss_timer.c
 216 *
 217 */
 218 S16 SRegCfgTmrMt
 219 (
 220 Ent ent,                    /* entity */
 221 Inst inst,                  /* instance */
 222 S16 period,                 /* period */
 223 S16 units,                  /* period units */
 224 PAIFTMRS16 tmrFnctMt        /* timer function, typically SActvTmr */
 225 )
 226 {
 227    S16 ret;
 228    /* ss015.301 - Enclosed all timer activation functions in a union. */
 229    SsTmrActvFn ssTmrActvFn;
 230
 231    ssTmrActvFn.actvFnc.tmrActvFnMt = tmrFnctMt;
 232    ssTmrActvFn.mtFlag = TRUE;
 233    ret = STmrRegHndlr(ent, inst, period, units, ssTmrActvFn);
 234
 235    return (ret);
 236 }
 237 #endif /* SS_MT_TMR */
 238 #endif /* not SS_MULTIPLE_PROCS */
 239
 240 /* ss041.103 - Function for timer registration handling */
 241 /*
 242 *
 243 *       Fun:   Timer registration handler function
 244 *
 245 *       Desc:  This function is called by the timer registration interface
 246 *              functions, and does the actual handling for timer
 247 *              registration.
 248 *
 249 *       Ret:   ROK      - ok
 250 *              RFAILED  - failed, general (optional)
 251 *              ROUTRES  - failed, out of resources (optional)
 252 *
 253 *       Notes:
 254 *
 255 *       File:  ss_timer.c
 256 *
 257 */
 258
 259 /* ss015.301 Changed the timer activation function type as all timer activation
 260  * functions are enclosed in a union.
 261  */
 262
 263 #ifndef SS_MULTIPLE_PROCS
 264
 265 static S16 STmrRegHndlr
 266 (
 267 Ent ent,                    /* entity */
 268 Inst inst,                  /* instance */
 269 S16 period,                 /* period */
 270 S16 units,                  /* period units */
 271 SsTmrActvFn ssTmrActvFn               /* timer function, typically SActvTmr */
 272 )
 273 /* ss015.301: Removed the timer handler prototypes guarded
 274  * under SS_MT_TMR and handled mtFlag in existing timer handlers.
 275  */
 276
 277 #else /* SS_MULTIPLE_PROCS */
 278
 279 static S16 STmrRegHndlr
 280 (
 281 ProcId proc,                /* processor */
 282 Ent ent,                    /* entity */
 283 Inst inst,                  /* instance */
 284 S16 period,                 /* period */
 285 S16 units,                  /* period units */
 286 SsTmrActvFn ssTmrActvFn     /* timer function */
 287 )
 288 #endif /* SS_MULTIPLE_PROCS */
 289 {
 290 #if (ERRCLASS & ERRCLS_INT_PAR)
 291    uint8_t i;
 292 #endif
 293    S16 ret;
 294    SsTmrEntry *tmr;
 295 #ifdef SS_MULTIPLE_PROCS
 296 #if (ERRCLASS & ERRCLS_INT_PAR)
 297    uint16_t procIdIdx;
 298 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 299 #endif /* SS_MULTPLE_PROCS */
 300
 301 #if (ERRCLASS & ERRCLS_INT_PAR)
 302
 303 #ifdef SS_MULTIPLE_PROCS
 304    if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) ||  (inst >= SS_MAX_INST))
 305    {
 306       SSLOGERROR(ERRCLS_INT_PAR, ESS528, ERRZERO, "Invalid processor/entity/instance");
 307       return RFAILED;
 308    }
 309 #else /* SS_MULTIPLE_PROCS */
 310    if (ent >= SS_MAX_ENT ||  inst >= SS_MAX_INST)
 311    {
 312       SSLOGERROR(ERRCLS_INT_PAR, ESS529, ERRZERO, "Invalid entity/instance");
 313       return RFAILED;
 314    }
 315 #endif /* SS_MULTIPLE_PROCS */
 316
 317    /* check period */
 318    if (period <= 0)
 319    {
 320       SSLOGERROR(ERRCLS_INT_PAR, ESS530, ERRZERO, "Invalid period");
 321       return RFAILED;
 322    }
 323
 324    /* check period units*/
 325    if ((units < 1) || (units > SS_TICKS_SEC))
 326    {
 327       SSLOGERROR(ERRCLS_INT_PAR, ESS531, ERRZERO, "Invalid period units");
 328       return RFAILED;
 329    }
 330
 331    if(ssTmrActvFn.mtFlag == TRUE)
 332    {
 333    /* ss015.301 Enclosed all timer activation functions in a union. */
 334 #ifndef SS_MULTIPLE_PROCS
 335 #ifdef SS_MT_TMR
 336       if (ssTmrActvFn.actvFnc.tmrActvFnMt == NULLP)
 337       {
 338          SSLOGERROR(ERRCLS_INT_PAR, ESS532, ERRZERO, "Null pointer");
 339          return RFAILED;
 340       }
 341 #else
 342       return RFAILED;
 343 #endif
 344 #else
 345       return RFAILED;
 346 #endif
 347    }
 348    else
 349    {
 350       if (ssTmrActvFn.actvFnc.tmrActvFn == NULLP)
 351       {
 352           SSLOGERROR(ERRCLS_INT_PAR, ESS532, ERRZERO, "Null pointer");
 353           return RFAILED;
 354       }
 355    }
 356
 357 #ifdef SS_MULTIPLE_PROCS
 358    /* check if the procId has been registered with SSI */
 359    procIdIdx = SGetProcIdIdx(proc);
 360
 361    if (procIdIdx == SS_INV_PROCID_IDX)
 362    {
 363       SSLOGERROR(ERRCLS_INT_PAR, ESS533, ERRZERO,
 364                      "Could not find proc id index");
 365       return RFAILED;
 366    }
 367 #endif /* SS_MULTIPLE_PROCS */
 368
 369
 370    /* check task ID */
 371    /* lock TAPA task table */
 372    SS_ACQUIRE_SEMA(&osCp.tTskTblSem, ret);
 373    if (ret != ROK)
 374    {
 375       SSLOGERROR(ERRCLS_DEBUG, ESS534, ERRZERO,
 376                      "Could not lock TAPA task table");
 377       return RFAILED;
 378    }
 379
 380 #ifdef SS_MULTIPLE_PROCS
 381    if (osCp.tTskIds[procIdIdx][ent][inst] == SS_TSKNC)
 382 #else /* SS_MULTIPLE_PROCS */
 383    if (osCp.tTskIds[ent][inst] == SS_TSKNC)
 384 #endif /* SS_MULTIPLE_PROCS */
 385    {
 386       if ( SS_RELEASE_SEMA(&osCp.tTskTblSem) != ROK)
 387       {
 388 #if (ERRCLASS & ERRCLS_DEBUG)
 389       SSLOGERROR(ERRCLS_DEBUG, ESS535, ERRZERO,
 390                      "Could not release the semaphore");
 391       return RFAILED;
 392 #endif
 393       }
 394       SSLOGERROR(ERRCLS_INT_PAR, ESS536, ERRZERO, "Unknown task");
 395       return RFAILED;
 396    }
 397    if ( SS_RELEASE_SEMA(&osCp.tTskTblSem) != ROK)
 398    {
 399 #if (ERRCLASS & ERRCLS_DEBUG)
 400       SSLOGERROR(ERRCLS_DEBUG, ESS537, ERRZERO,
 401                      "Could not release the semaphore");
 402    return RFAILED;
 403 #endif
 404    }
 405
 406 #endif
 407
 408    /* lock the timer table */
 409    ret = SLock(&osCp.tmrTblLock);
 410    if (ret != ROK)
 411    {
 412
 413 #if (ERRCLASS & ERRCLS_DEBUG)
 414       SSLOGERROR(ERRCLS_DEBUG, ESS538, (ErrVal) ret,
 415                      "Could not lock timer table");
 416 #endif
 417       return (ret);
 418    }
 419
 420
 421    /* check if we've got room for another timer */
 422    if (osCp.numTmrs == SS_MAX_TMRS)
 423    {
 424       if ( SUnlock(&osCp.tmrTblLock) != ROK)
 425       {
 426 #if (ERRCLASS & ERRCLS_DEBUG)
 427          SSLOGERROR(ERRCLS_DEBUG, ESS539, ERRZERO,
 428                      "Could not unlock the semaphore");
 429          return RFAILED;
 430 #endif
 431       }
 432
 433 #if (ERRCLASS & ERRCLS_DEBUG)
 434       SSLOGERROR(ERRCLS_DEBUG, ESS540, ERRZERO, "Too many timers");
 435 #endif
 436
 437       return (ROUTRES);
 438    }
 439
 440 #if (ERRCLASS & ERRCLS_INT_PAR)
 441    /* check through the timer table for a matching timer entry */
 442    for (i = 0; i < SS_MAX_TMRS; i++)
 443    {
 444       if ((osCp.tmrTbl[i].ownerEnt == ent)
 445 #ifdef SS_MULTIPLE_PROCS
 446             &&  (osCp.tmrTbl[i].ownerProc == proc)
 447 #endif /* SS_MULTIPLE_PROCS */
 448             && (osCp.tmrTbl[i].ownerInst == inst)
 449             /* ss041.103 - Added mtFlag check */
 450             /* ss015.301 Enclosed all timer activation functions in a union. */
 451 #ifndef SS_MULTIPLE_PROCS
 452 #ifdef SS_MT_TMR
 453             && (osCp.tmrTbl[i].ssTmrActvFn.mtFlag == ssTmrActvFn.mtFlag)
 454             && ((ssTmrActvFn.mtFlag == FALSE
 455                   && osCp.tmrTbl[i].ssTmrActvFn.actvFnc.tmrActvFn == ssTmrActvFn.actvFnc.tmrActvFn)
 456                || osCp.tmrTbl[i].ssTmrActvFn.actvFnc.tmrActvFnMt == ssTmrActvFn.actvFnc.tmrActvFnMt)
 457 #else
 458             && (osCp.tmrTbl[i].ssTmrActvFn.actvFnc.tmrActvFn == ssTmrActvFn.actvFnc.tmrActvFn)
 459 #endif
 460 #else
 461             && (osCp.tmrTbl[i].ssTmrActvFn.actvFnc.tmrActvFn == ssTmrActvFn.actvFnc.tmrActvFn)
 462 #endif
 463             && (osCp.tmrTbl[i].interval == (uint32_t) ((period * SS_TICKS_SEC) / units)))
 464       {
 465          /* is this timer in use ? (unexpired) */
 466          if (osCp.tmrTbl[i].used == TRUE)
 467          {
 468             /* to prevent the same timer to be registered with SS  UNLOCK and */
 469             /* then RFAIL */
 470             if (SUnlock(&osCp.tmrTblLock) != ROK)
 471             {
 472 #if (ERRCLASS & ERRCLS_DEBUG)
 473    SSLOGERROR(ERRCLS_DEBUG, ESS541, ERRZERO, "Could not unlock the semaphore");
 474    return RFAILED;
 475 #endif
 476             }
 477             return RFAILED;
 478          }
 479       }
 480    }
 481 #endif
 482
 483    /* fill in the information we have into the timer entry */
 484    tmr = &osCp.tmrTbl[osCp.nxtTmrEntry];
 485    tmr->tmrId     = osCp.nxtTmrEntry;
 486 #ifdef SS_MULTIPLE_PROCS
 487    tmr->ownerProc = proc;
 488 #endif /* SS_MULTIPLE_PROCS */
 489    tmr->ownerEnt  = ent;
 490    tmr->ownerInst = inst;
 491    tmr->interval  = (uint32_t) ((period * SS_TICKS_SEC) / units);
 492    tmr->ssTmrActvFn.mtFlag = ssTmrActvFn.mtFlag;
 493
 494    /* ss041.103 */
 495    /* ss015.301 Enclosed all timer activation functions in a union. */
 496 #ifndef SS_MULTIPLE_PROCS
 497 #ifdef SS_MT_TMR
 498    if (ssTmrActvFn.mtFlag == TRUE)
 499    {
 500       tmr->ssTmrActvFn.actvFnc.tmrActvFnMt = ssTmrActvFn.actvFnc.tmrActvFnMt;
 501    }
 502    else
 503 #endif
 504 #endif
 505    {
 506       tmr->ssTmrActvFn.actvFnc.tmrActvFn = ssTmrActvFn.actvFnc.tmrActvFn;
 507    }
 508
 509
 510    /* ask the implementation to start the timer */
 511    ret = ssdRegTmr(tmr);
 512    if (ret != ROK)
 513    {
 514       tmr->tmrId = 0;
 515 #ifdef SS_MULTIPLE_PROCS
 516       tmr->ownerProc = PROCNC;
 517 #endif /* SS_MULTIPLE_PROCS */
 518       tmr->ownerEnt = ENTNC;
 519       tmr->ownerInst = INSTNC;
 520       tmr->interval = 0;
 521       /* ss015.301 Enclosed all timer activation functions in a union. */
 522       tmr->ssTmrActvFn.mtFlag = FALSE;
 523       tmr->ssTmrActvFn.actvFnc.tmrActvFn = NULLP;
 524 #ifndef SS_MULTIPLE_PROCS
 525 #ifdef SS_MT_TMR
 526       tmr->ssTmrActvFn.actvFnc.tmrActvFnMt = NULLP;
 527 #endif
 528 #endif
 529    }
 530    else
 531    {
 532       tmr->used = TRUE;
 533       osCp.nxtTmrEntry = tmr->nxt;
 534       osCp.numTmrs++;
 535    }
 536
 537
 538    /* unlock the timer table */
 539    if ( SUnlock(&osCp.tmrTblLock) != ROK)
 540    {
 541 #if (ERRCLASS & ERRCLS_DEBUG)
 542       SSLOGERROR(ERRCLS_DEBUG, ESS542, ERRZERO,
 543                      "Could not unlock the semaphore");
 544       return RFAILED;
 545 #endif
 546    }
 547
 548    return (ret);
 549 }
 550
 551
 552 \f
 553 /*
 554 *
 555 *       Fun:   SDeregCfgTmr
 556 *
 557 *       Desc:  This function is used to deregister a timer function.
 558 *
 559 *       Ret:   ROK      - ok
 560 *              RFAILED  - failed, general (optional)
 561 *
 562 *       Notes:
 563 *
 564 *       File:  ss_timer.c
 565 *
 566 */
 567 /* ss029.103: addition: procId added and timer function type modified */
 568 #ifndef SS_MULTIPLE_PROCS
 569
 570 S16 SDeregCfgTmr
 571 (
 572 Ent ent,                    /* entity */
 573 Inst inst,                  /* instance */
 574 S16 period,                 /* period */
 575 S16 units,                  /* period units */
 576 PFS16 tmrFnct               /* timer function */
 577 )
 578 {
 579    S16 ret;
 580    /* ss015.301 Enclosed all timer activation functions in a union. */
 581    SsTmrActvFn ssTmrActvFn;
 582    /* ss041.103 - Moved handling to STmrDeregHndlr */
 583
 584    ssTmrActvFn.mtFlag = FALSE;
 585    ssTmrActvFn.actvFnc.tmrActvFn = tmrFnct;
 586    ret = STmrDeregHndlr(ent, inst, period, units, ssTmrActvFn);
 587
 588    return (ret);
 589 }
 590
 591 #else /* SS_MULTIPLE_PROCS */
 592
 593 S16 SDeregCfgTmr
 594 (
 595 ProcId proc,                /* processor */
 596 Ent ent,                    /* entity */
 597 Inst inst,                  /* instance */
 598 S16 period,                 /* period */
 599 S16 units,                  /* period units */
 600 PAIFTMRS16 tmrFnct               /* timer function */
 601 )
 602 {
 603    S16 ret;
 604    /* ss015.301 Enclosed all timer activation functions in a union. */
 605    SsTmrActvFn ssTmrActvFn;
 606
 607    /* ss041.103 - Moved handling to STmrDeregHndlr */
 608
 609    ssTmrActvFn.mtFlag = FALSE;
 610    ssTmrActvFn.actvFnc.tmrActvFn = tmrFnct;
 611    ret = STmrDeregHndlr(proc, ent, inst, period, units, ssTmrActvFn);
 612
 613    return (ret);
 614 }
 615
 616 #endif /* SS_MULTIPLE_PROCS */
 617
 618 \f
 619 /* ss041.103 - Addition to support MT timer dereg */
 620 #ifndef SS_MULTIPLE_PROCS
 621 #ifdef SS_MT_TMR
 622 /*
 623 *
 624 *       Fun:   SDeregCfgTmrMt
 625 *
 626 *       Desc:  This function is used to deregister an MT timer function.
 627 *
 628 *       Ret:   ROK      - ok
 629 *              RFAILED  - failed, general (optional)
 630 *
 631 *       Notes:
 632 *
 633 *       File:  ss_timer.c
 634 *
 635 */
 636 S16 SDeregCfgTmrMt
 637 (
 638 Ent ent,                    /* entity */
 639 Inst inst,                  /* instance */
 640 S16 period,                 /* period */
 641 S16 units,                  /* period units */
 642 PAIFTMRS16 tmrFnctMt               /* timer function */
 643 )
 644 {
 645    S16 ret;
 646    /* ss015.301 Enclosed all timer activation functions in a union. */
 647    SsTmrActvFn ssTmrActvFn;
 648
 649    ssTmrActvFn.actvFnc.tmrActvFnMt = tmrFnctMt;
 650    ssTmrActvFn.mtFlag = TRUE;
 651
 652    ret = STmrDeregHndlr(ent, inst, period, units, ssTmrActvFn);
 653
 654    return (ret);
 655 }
 656 #endif /* SS_MT_TMR */
 657 #endif /* not SS_MULTIPLE_PROCS */
 658
 659
 660 /* ss041.103 - Addition of STmrDeregHndlr */
 661 /*
 662 *
 663 *       Fun:   STmrDeregHndlr
 664 *
 665 *       Desc:  This function is used to deregister a timer function.
 666 *
 667 *       Ret:   ROK      - ok
 668 *              RFAILED  - failed, general (optional)
 669 *
 670 *       Notes:
 671 *
 672 *       File:  ss_timer.c
 673 *
 674 */
 675 /* ss029.103: addition: procId added and timer function type modified */
 676
 677 /* ss015.301 Changed the timer activation function type as all timer activation
 678  * functions are enclosed in a union.
 679  */
 680 #ifndef SS_MULTIPLE_PROCS
 681 static S16 STmrDeregHndlr
 682 (
 683 Ent ent,                    /* entity */
 684 Inst inst,                  /* instance */
 685 S16 period,                 /* period */
 686 S16 units,                  /* period units */
 687 SsTmrActvFn ssTmrActvFn           /* timer function */
 688 )
 689 /* ss015.301: Removed the timer handler prototypes guarded under SS_MT_TMR
 690  * and handled mtFlag in existing timer handlers.
 691  */
 692
 693 #else /* SS_MULTIPLE_PROCS */
 694
 695 static S16 STmrDeregHndlr
 696 (
 697 ProcId proc,                /* processor */
 698 Ent ent,                    /* entity */
 699 Inst inst,                  /* instance */
 700 S16 period,                 /* period */
 701 S16 units,                  /* period units */
 702 SsTmrActvFn ssTmrActvFn          /* timer function */
 703 )
 704
 705 #endif /* SS_MULTIPLE_PROCS */
 706 {
 707    S16 ret;
 708    S16 idx;
 709    SsTmrEntry *tmr;
 710 #ifdef SS_MULTIPLE_PROCS
 711 #if (ERRCLASS & ERRCLS_INT_PAR)
 712    uint16_t procIdIdx;
 713 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 714 #endif /* SS_MULTIPLE_PROCS */
 715
 716
 717 #if (ERRCLASS & ERRCLS_INT_PAR)
 718
 719 #ifdef SS_MULTIPLE_PROCS
 720    if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) ||  (inst >= SS_MAX_INST))
 721    {
 722       SSLOGERROR(ERRCLS_INT_PAR, ESS543, ERRZERO, "Invalid processor/entity/instance");
 723       return RFAILED;
 724    }
 725
 726 #else /* SS_MULTIPLE_PROCS */
 727    if (ent >= SS_MAX_ENT ||  inst >= SS_MAX_INST)
 728    {
 729       SSLOGERROR(ERRCLS_INT_PAR, ESS544, ERRZERO, "Invalid entity/instance");
 730       return RFAILED;
 731    }
 732 #endif /* SS_MULTIPLE_PROCS */
 733    /* check period */
 734    if (period <= 0)
 735    {
 736       SSLOGERROR(ERRCLS_INT_PAR, ESS545, ERRZERO, "Invalid period");
 737       return RFAILED;
 738    }
 739
 740    /* check period units */
 741    if ((units < 1) || (units > SS_TICKS_SEC))
 742    {
 743       SSLOGERROR(ERRCLS_INT_PAR, ESS546, ERRZERO, "Invalid period units");
 744       return RFAILED;
 745    }
 746
 747    /* check timer function */
 748    if(ssTmrActvFn.mtFlag == TRUE)
 749    {
 750 #ifndef SS_MULTIPLE_PROCS
 751 #ifdef SS_MT_TMR
 752    if (ssTmrActvFn.actvFnc.tmrActvFnMt == NULLP)
 753    {
 754       SSLOGERROR(ERRCLS_INT_PAR, ESS547, ERRZERO, "Null pointer");
 755       return RFAILED;
 756    }
 757 #else
 758     return RFAILED;
 759 #endif
 760 #else
 761     return RFAILED;
 762 #endif
 763
 764    }
 765    else
 766    {
 767    if (ssTmrActvFn.actvFnc.tmrActvFn == NULLP)
 768    {
 769       SSLOGERROR(ERRCLS_INT_PAR, ESS547, ERRZERO, "Null pointer");
 770       return RFAILED;
 771    }
 772   }
 773
 774 #ifdef SS_MULTIPLE_PROCS
 775    /* check if the procId has been registered with SSI */
 776    procIdIdx = SGetProcIdIdx(proc);
 777
 778    if (procIdIdx == SS_INV_PROCID_IDX)
 779    {
 780       SSLOGERROR(ERRCLS_INT_PAR, ESS548, ERRZERO,
 781                      "Could not find proc id index");
 782       return RFAILED;
 783    }
 784 #endif /* SS_MULTIPLE_PROCS */
 785
 786    /* check task ID */
 787    /* lock TAPA task table */
 788    SS_ACQUIRE_SEMA(&osCp.tTskTblSem, ret);
 789    if (ret != ROK)
 790    {
 791       SSLOGERROR(ERRCLS_DEBUG, ESS549, ERRZERO,
 792                      "Could not lock TAPA task table");
 793       return RFAILED;
 794    }
 795
 796 #ifdef SS_MULTIPLE_PROCS
 797    if (osCp.tTskIds[procIdIdx][ent][inst] == SS_TSKNC)
 798 #else /* SS_MULTIPLE_PROCS */
 799    if (osCp.tTskIds[ent][inst] == SS_TSKNC)
 800 #endif /* SS_MULTIPLE_PROCS */
 801    {
 802       if ( SS_RELEASE_SEMA(&osCp.tTskTblSem) != ROK)
 803       {
 804 #if (ERRCLASS & ERRCLS_DEBUG)
 805          SSLOGERROR(ERRCLS_DEBUG, ESS550, ERRZERO,
 806                      "Could not release the semaphore");
 807          return RFAILED;
 808 #endif
 809       }
 810       SSLOGERROR(ERRCLS_INT_PAR, ESS551, ERRZERO, "Unknown task");
 811       return RFAILED;
 812    }
 813    if ( SS_RELEASE_SEMA(&osCp.tTskTblSem) != ROK)
 814    {
 815 #if (ERRCLASS & ERRCLS_DEBUG)
 816       SSLOGERROR(ERRCLS_DEBUG, ESS552, ERRZERO,
 817                      "Could not release the semaphore");
 818       return RFAILED;
 819 #endif
 820     }
 821
 822 #endif
 823
 824    /* lock the timer table */
 825    ret = SLock(&osCp.tmrTblLock);
 826    if (ret != ROK)
 827    {
 828
 829 #if (ERRCLASS & ERRCLS_DEBUG)
 830       SSLOGERROR(ERRCLS_DEBUG, ESS553, (ErrVal) ret,
 831                      "Could not lock timer table");
 832 #endif
 833       return (ret);
 834    }
 835
 836
 837    /* Note: Right now, we're using ent, inst and tmrActvFn to locate
 838     *       the timer,, this will change to using tmrId, some day.
 839     */
 840
 841    /* locate the timer to delete in the timer table */
 842    for (idx = 0;  idx < SS_MAX_TMRS;  idx++)
 843    {
 844       /* ss021.103 - Modification find timer by ent, inst, func, and period */
 845       /* ss029.103: addition: multiple procId related changes */
 846       if (osCp.tmrTbl[idx].ownerEnt == ent
 847 #ifdef SS_MULTIPLE_PROCS
 848             &&  osCp.tmrTbl[idx].ownerProc == proc
 849 #endif /* SS_MULTIPLE_PROCS */
 850             &&  osCp.tmrTbl[idx].ownerInst == inst
 851 #ifndef SS_MULTIPLE_PROCS
 852 #ifdef SS_MT_TMR
 853            /*
 854             *  ss015.301 - Modifed as timer activation functions
 855             *  enclosed in a union.
 856             */
 857             &&  osCp.tmrTbl[idx].ssTmrActvFn.mtFlag == ssTmrActvFn.mtFlag
 858             && ((ssTmrActvFn.mtFlag == FALSE
 859                   &&  osCp.tmrTbl[idx].ssTmrActvFn.actvFnc.tmrActvFn == ssTmrActvFn.actvFnc.tmrActvFn)
 860                || osCp.tmrTbl[idx].ssTmrActvFn.actvFnc.tmrActvFnMt == ssTmrActvFn.actvFnc.tmrActvFnMt)
 861 #else
 862             &&  osCp.tmrTbl[idx].ssTmrActvFn.actvFnc.tmrActvFn == ssTmrActvFn.actvFnc.tmrActvFn
 863 #endif
 864 #else
 865             &&  osCp.tmrTbl[idx].ssTmrActvFn.actvFnc.tmrActvFn == ssTmrActvFn.actvFnc.tmrActvFn
 866 #endif
 867             &&  osCp.tmrTbl[idx].interval == (uint32_t) ((period * SS_TICKS_SEC) / units))
 868       {
 869          break;
 870       }
 871    }
 872
 873    if (idx == SS_MAX_TMRS)
 874    {
 875       if ( SUnlock(&osCp.tmrTblLock) != ROK)
 876       {
 877 #if (ERRCLASS & ERRCLS_DEBUG)
 878          SSLOGERROR(ERRCLS_DEBUG, ESS554, ERRZERO,
 879                      "Could not unlock the semaphore");
 880          return RFAILED;
 881 #endif
 882       }
 883
 884 #if (ERRCLASS & ERRCLS_DEBUG)
 885       SSLOGERROR(ERRCLS_DEBUG, ESS555, ERRZERO, "Could not locate timer");
 886 #endif
 887
 888       return RFAILED;
 889    }
 890
 891
 892    /* ask the implementation to shut down this timer */
 893    tmr = &osCp.tmrTbl[idx];
 894    ret = ssdDeregTmr(tmr);
 895    if (ret == ROK)
 896    {
 897       tmr->used = FALSE;
 898       tmr->tmrId = 0;
 899 #ifdef SS_MULTIPLE_PROCS
 900       tmr->ownerProc = PROCNC;
 901 #endif /* SS_MULTIPLE_PROCS */
 902       tmr->ownerEnt = ENTNC;
 903       tmr->ownerInst = INSTNC;
 904       tmr->interval = 0;
 905       /*
 906        *  ss015.301: Modifed as timer activation functions enclosed in a union.
 907        */
 908       tmr->ssTmrActvFn.mtFlag = FALSE;
 909       tmr->ssTmrActvFn.actvFnc.tmrActvFn = NULLP;
 910 #ifndef SS_MULTIPLE_PROCS
 911 #ifdef SS_MT_TMR
 912       tmr->ssTmrActvFn.actvFnc.tmrActvFnMt = NULLP;
 913 #endif
 914 #endif
 915
 916       tmr->nxt = osCp.nxtTmrEntry;
 917       osCp.nxtTmrEntry = (SsIdx)idx;
 918       osCp.numTmrs--;
 919    }
 920
 921
 922    /* unlock the timer table */
 923    if ( SUnlock(&osCp.tmrTblLock) != ROK)
 924    {
 925 #if (ERRCLASS & ERRCLS_DEBUG)
 926       SSLOGERROR(ERRCLS_DEBUG, ESS556, ERRZERO,
 927                      "Could not unlock the semaphore");
 928       return RFAILED;
 929 #endif
 930    }
 931
 932
 933    return (ret);
 934 }
 935
 936 /**********************************************************************
 937          End of file
 938 **********************************************************************/