src/mt/ss_drvr.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 -- Driver
  22
  23      Type:     C source file
  24
  25      Desc:     Source code for those functions in System Services
  26                that exist for driver support.
  27
  28      File:     ss_drvr.c
  29
  30 *********************************************************************21*/
  31
  32
  33 \f
  34 /* header include files (.h) */
  35
  36 #include "envopt.h"        /* environment options */
  37 #include "envdep.h"        /* environment dependent */
  38 #include "envind.h"        /* environment independent */
  39
  40 #include "gen.h"           /* general layer */
  41 #include "ssi.h"           /* system services */
  42
  43 #include "ss_err.h"        /* errors */
  44 #include "ss_dep.h"        /* implementation-specific */
  45 #include "ss_queue.h"      /* queues */
  46 #include "ss_msg.h"        /* messaging */
  47 #include "ss_mem.h"        /* memory management interface */
  48 #include "ss_gen.h"        /* general */
  49 #include "cm_mem.h"        /* memory management */
  50
  51
  52
  53 /* header/extern include files (.x) */
  54
  55 #include "gen.x"           /* general layer */
  56 #include "ssi.x"           /* system services */
  57
  58
  59 #include "ss_dep.x"        /* implementation-specific */
  60 #include "ss_queue.x"      /* queues */
  61 #include "ss_task.x"       /* tasking */
  62 #include "ss_timer.x"      /* timers */
  63 #include "ss_strm.x"       /* STREAMS */
  64 #include "ss_msg.x"        /* messaging */
  65 #include "ss_mem.x"        /* memory management interface */
  66 #include "ss_drvr.x"       /* driver tasks */
  67 #ifdef SS_LOCKLESS_MEMORY
  68 #include "cm_llist.x"
  69 #include "cm_hash.x"
  70 #include "cm_mem_wl.x"        /* common memory manager */
  71 #else
  72 #include "cm_mem.x"        /* common memory manager */
  73 #endif /* SS_LOCKLESS_MEMORY */
  74 #include "ss_gen.x"        /* general */
  75
  76
  77 #ifdef SS_DRVR_SUPPORT
  78
  79
  80 \f
  81 /*
  82 *
  83 *       Fun:   SRegDrvrTsk
  84 *
  85 *       Desc:  This function is used to register a driver task.
  86 *
  87 *       Ret:   ROK      - ok
  88 *              RFAILED  - failed, general (optional)
  89 *              ROUTRES  - failed, out of resources (optional)
  90 *
  91 *       Notes:
  92 *
  93 *       File:  ss_drvr.c
  94 *
  95 */
  96 #ifdef ANSI
  97 PUBLIC S16 SRegDrvrTsk
  98 (
  99 Inst channel,                   /* channel instance */
 100 ProcId low,                     /* processor ID -- low */
 101 ProcId high,                    /* processor ID -- high */
 102 ActvTsk actvTsk,                /* activation function */
 103 ISTsk isTsk                     /* interrupt service function */
 104 )
 105 #else
 106 PUBLIC S16 SRegDrvrTsk(channel, low, high, actvTsk, isTsk)
 107 Inst channel;                   /* channel instance */
 108 ProcId low;                     /* processor ID -- low */
 109 ProcId high;                    /* processor ID -- high */
 110 ActvTsk actvTsk;                /* activation function */
 111 ISTsk isTsk;                    /* interrupt service function */
 112 #endif
 113 {
 114    S16 ret;
 115 #if (ERRCLASS & ERRCLS_INT_PAR)
 116
 117 /* ss029.103: modification: multiple procId related changes */
 118 #ifndef SS_MULTIPLE_PROCS
 119    ProcId thisProcId;
 120 #endif
 121
 122 /* ss029.103: modification: multiple procId related changes */
 123 #ifdef SS_MULTIPLE_PROCS
 124    U16 count;
 125    U16 i;
 126    ProcId procIdLst[SS_MAX_PROCS];
 127 #endif /* SS_MULTIPLE_PROCS */
 128
 129 #endif
 130
 131    TRC1(SRegDrvrTsk);
 132
 133 #if (ERRCLASS & ERRCLS_INT_PAR)
 134
 135 /* ss029.103: modification: multiple procId related changes */
 136 #ifdef SS_MULTIPLE_PROCS
 137    if (SGetProcIdLst(&count, procIdLst) != ROK)
 138    {
 139       SSLOGERROR(ERRCLS_INT_PAR, ESS001, ERRZERO, "Null procId list");
 140       RETVALUE(RFAILED);
 141    }
 142
 143    for (i = 0; i < count; i++)
 144    {
 145       if (procIdLst[i] >= low  &&  procIdLst[i] <= high)
 146       {
 147        SSLOGERROR(ERRCLS_INT_PAR, ESS002, ERRZERO, "Invalid procId range");
 148        RETVALUE(RFAILED);
 149       }
 150    }
 151 #else /* SS_MULTIPLE_PROCS */
 152    thisProcId = SFndProcId();
 153    if (thisProcId >= low  &&  thisProcId <= high)
 154    {
 155       SSLOGERROR(ERRCLS_INT_PAR, ESS003, ERRZERO, "Invalid procId range");
 156       RETVALUE(RFAILED);
 157    }
 158 #endif /* SS_MULTIPLE_PROCS */
 159
 160    if (channel >= SS_MAX_DRVRTSKS)
 161    {
 162       SSLOGERROR(ERRCLS_INT_PAR, ESS004, channel, "Invalid channel");
 163       RETVALUE(RFAILED);
 164    }
 165
 166    /* check activation functions */
 167    if (actvTsk == NULLP  ||  isTsk == NULLP)
 168    {
 169       SSLOGERROR(ERRCLS_INT_PAR, ESS005, ERRZERO, "Null pointer");
 170       RETVALUE(RFAILED);
 171    }
 172
 173    /* check if already registered */
 174    if (osCp.drvrTskTbl[channel].used == TRUE)
 175    {
 176       SSLOGERROR(ERRCLS_INT_PAR, ESS006, ERRZERO,
 177                   "Driver task already registered");
 178       RETVALUE(RFAILED);
 179    }
 180 #endif
 181
 182
 183 #if (ERRCLASS & ERRCLS_DEBUG)
 184    /* check count of tasks */
 185    if (osCp.numDrvrTsks == SS_MAX_DRVRTSKS)
 186    {
 187       SSLOGERROR(ERRCLS_DEBUG, ESS007, ERRZERO, "Too many tasks");
 188       RETVALUE(ROUTRES);
 189    }
 190 #endif
 191
 192
 193    if (SInitLock(&osCp.drvrTskTbl[channel].lock, SS_DRVRENTRY_LOCK) != ROK)
 194    {
 195
 196 #if (ERRCLASS & ERRCLS_DEBUG)
 197       SSLOGERROR(ERRCLS_DEBUG, ESS008, ERRZERO, "Could not initialize lock");
 198 #endif
 199
 200       RETVALUE(RFAILED);
 201    }
 202
 203    osCp.drvrTskTbl[channel].channel = channel;
 204    osCp.drvrTskTbl[channel].actvTsk = actvTsk;
 205    osCp.drvrTskTbl[channel].isTsk = isTsk;
 206    osCp.drvrTskTbl[channel].low = low;
 207    osCp.drvrTskTbl[channel].high = high;
 208
 209    ret = ssdRegDrvrTsk(&osCp.drvrTskTbl[channel]);
 210    if (ret != ROK)
 211    {
 212       osCp.drvrTskTbl[channel].channel = 0;
 213       osCp.drvrTskTbl[channel].actvTsk = NULLP;
 214       osCp.drvrTskTbl[channel].isTsk = NULLP;
 215       osCp.drvrTskTbl[channel].low = 0;
 216       osCp.drvrTskTbl[channel].high = 0;
 217       SDestroyLock(&osCp.drvrTskTbl[channel].lock);
 218    }
 219    else
 220    {
 221       osCp.drvrTskTbl[channel].used = TRUE;
 222       osCp.numDrvrTsks++;
 223    }
 224
 225
 226    RETVALUE(ret);
 227 }
 228
 229 /*  ss001.301: Additions */
 230 /*
 231 *
 232 *       Fun:   SDeregDrvrTsk
 233 *
 234 *       Desc:  This function is used to de-register a driver task.
 235 *
 236 *       Ret:   ROK      - ok
 237 *              RFAILED  - failed, general (optional)
 238 *              ROUTRES  - failed, out of resources (optional)
 239 *
 240 *       Notes:
 241 *
 242 *       File:  ss_drvr.c
 243 *
 244 */
 245 #ifdef ANSI
 246 PUBLIC S16 SDeregDrvrTsk
 247 (
 248 Inst channel                   /* channel instance */
 249 )
 250 #else
 251 PUBLIC S16 SDeregDrvrTsk(channel)
 252 Inst channel;
 253 #endif
 254 {
 255         /* ss002.301 Modifications */
 256    TRC1(SRegDrvrTsk);
 257
 258 #if (ERRCLASS & ERRCLS_INT_PAR)
 259    if (channel >= SS_MAX_DRVRTSKS)
 260    {
 261       SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, channel, "Invalid channel");
 262       RETVALUE(RFAILED);
 263    }
 264
 265    /* check if already registered */
 266    if (osCp.drvrTskTbl[channel].used != TRUE)
 267    {
 268       SSLOGERROR(ERRCLS_INT_PAR, ESS477, ERRZERO,
 269                   "Driver task is not registered");
 270       RETVALUE(RFAILED);
 271    }
 272 #endif
 273
 274
 275    if(SLock(&osCp.drvrTskTbl[channel].lock) != ROK)
 276    {
 277 #if (ERRCLASS & ERRCLS_DEBUG)
 278          SSLOGERROR(ERRCLS_DEBUG, ESS477, ERRZERO,
 279                      "Could not lock driver task lock");
 280 #endif
 281       RETVALUE(RFAILED);
 282    }
 283    ssdDeregDrvrTsk(&osCp.drvrTskTbl[channel]);
 284
 285    osCp.drvrTskTbl[channel].channel = 0;
 286    osCp.drvrTskTbl[channel].actvTsk = NULLP;
 287    osCp.drvrTskTbl[channel].isTsk = NULLP;
 288    osCp.drvrTskTbl[channel].low = 0;
 289    osCp.drvrTskTbl[channel].high = 0;
 290
 291    osCp.drvrTskTbl[channel].used = FALSE;
 292    osCp.numDrvrTsks--;
 293    if(SUnlock(&osCp.drvrTskTbl[channel].lock) != ROK)
 294    {
 295 #if (ERRCLASS & ERRCLS_DEBUG)
 296          SSLOGERROR(ERRCLS_DEBUG, ESS477, ERRZERO,
 297                      "Could not unlock driver task lock");
 298 #endif
 299       RETVALUE(RFAILED);
 300    }
 301    SDestroyLock(&osCp.drvrTskTbl[channel].lock);
 302    /* ss002.301 Modifications */
 303    RETVALUE(ROK);
 304 }
 305 #endif /* SS_DRVR_SUPPORT */
 306 /**********************************************************************
 307          End of file
 308 **********************************************************************/