src/5gnrrlc/kw_ptmi.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:     RLC Layer Management interface
  22
  23         Type:     C source file
  24
  25         Desc:     This file contains source code for RLC layer management
  26                   interface primitives. It includes the definition of the
  27                   following functions and their portable function
  28                   definitions.
  29                      -- PjMiLpjCfgCfm
  30                      -- PjMiLpjCntrlCfm
  31                      -- PjMiLpjStaInd
  32
  33
  34         File:     kw_ptmi.c
  35
  36 *********************************************************************21*/
  37
  38 \f
  39 /* header (.h) include files */
  40 #include "common_def.h"
  41 #include "lkw.h"           /* LKW defines */
  42 #include "ckw.h"           /* CKW defines */
  43 #include "kwu.h"           /* KWU defines */
  44 #include "rgu.h"           /* RGU defines */
  45
  46 #include "kw_env.h"        /* RLC environment options */
  47 #include "kw.h"            /* RLC defines */
  48
  49 /* extern (.x) include files */
  50 #include "lkw.x"           /* LKW */
  51 #include "ckw.x"           /* CKW */
  52 #include "kwu.x"           /* KWU */
  53 #include "rgu.x"           /* RGU */
  54
  55 #include "kw.x"
  56
  57 /* local defines */
  58 #define MAXKWMI 2               /* max. layer management interfaces */
  59
  60 \f
  61 /*********************************************************************
  62  *             Primitives for LKW interface
  63  ********************************************************************/
  64 /* Configuration confirmation primitive */
  65
  66 PRIVATE RlcConfigCfm rlcMiRlcConfigCfmMt[MAXKWMI] =
  67 {
  68 #ifdef LCKWMILKW
  69    packRlcConfigCfm,            /* 0 - loosely coupled - fc */
  70 #endif /* LCRLMILKW */
  71 #ifdef SM
  72    SmMiRlcConfigCfm,            /* 1 - tightly coupled layer management*/
  73 #endif /* SM */
  74 };
  75
  76 /* control confirmation primitives */
  77
  78 PRIVATE LkwCntrlCfm kwMiLkwCntrlCfmMt[MAXKWMI] =
  79 {
  80 #ifdef LCKWMILKW
  81    cmPkLkwCntrlCfm,          /* 0 - loosely coupled - fc */
  82 #endif /* LCRLMILKW */
  83 #ifdef SM
  84    SmMiLkwCntrlCfm,          /* 1 - tightly coupled layer management*/
  85 #endif /* SM */
  86 };
  87
  88 /* Status Indication primitive */
  89
  90 PRIVATE LkwStaInd kwMiLkwStaIndMt[MAXKWMI] =
  91 {
  92 #ifdef LCKWMILKW
  93    cmPkLkwStaInd,            /* 0 - loosely coupled  */
  94 #endif /* LCKWMILKW */
  95 #ifdef SM
  96    SmMiLkwStaInd,            /* 1 - tightly coupled, layer management */
  97 #endif /* SM */
  98 };
  99
 100 /* Status confirm primitive */
 101
 102 PRIVATE LkwStaCfm kwMiLkwStaCfmMt[MAXKWMI] =
 103 {
 104 #ifdef LCKWMILKW
 105    cmPkLkwStaCfm,            /* 0 - loosely coupled  */
 106 #endif /* LCKWMILKW */
 107 #ifdef SM
 108    SmMiLkwStaCfm,            /* 1 - tightly coupled, layer management */
 109 #endif /* SM */
 110 };
 111
 112 /* Statistics confirm primitive */
 113
 114 PRIVATE LkwStsCfm kwMiLkwStsCfmMt[MAXKWMI] =
 115 {
 116 #ifdef LCKWMILKW
 117    cmPkLkwStsCfm,            /* 0 - loosely coupled  */
 118 #endif /* LCRLMILKW */
 119 #ifdef SM
 120    SmMiLkwStsCfm,            /* 1 - tightly coupled, layer management */
 121 #endif /* SM */
 122 };
 123
 124 /* Trace indication primitive */
 125
 126 PRIVATE LkwTrcInd kwMiLkwTrcIndMt[MAXKWMI] =
 127 {
 128 #ifdef LCKWMILKW
 129    cmPkLkwTrcInd,            /* 0 - loosely coupled  */
 130 #endif /* LCKWMILKW */
 131 #ifdef SM
 132    SmMiLkwTrcInd,            /* 1 - tightly coupled, layer management */
 133 #endif /* SM */
 134 };
 135
 136 /* kw005.201 added support for L2 Measurement */
 137 #ifdef LTE_L2_MEAS
 138 PRIVATE CONSTANT LkwL2MeasCfm rlcMiLkwL2MeasCfmMt[] =
 139 {
 140 #ifdef LCKWMILKW
 141    cmPkLkwL2MeasCfm,
 142 #endif
 143 #ifdef SM
 144    SmMiLkwL2MeasCfm,
 145 #endif
 146 };
 147 PRIVATE CONSTANT LkwL2MeasStopCfm RlcMiLkwL2MeasStopCfmMt[] =
 148 {
 149 #ifdef LCKWMILKW
 150    cmPkLkwL2MeasStopCfm,
 151 #endif
 152 #ifdef SM
 153    SmMiLkwL2MeasStopCfm,
 154 #endif
 155 };
 156 #endif /*  LTE_L2_MEAS */
 157 \f
 158 /****************************************************************************
 159  *                         LKW Interface Mt functions
 160  ***************************************************************************/
 161 /**
 162    @brief
 163    This function is called by the RlcMiRlcConfigReq function for responding
 164    to configuration requests.The cfm field in the RlcMngmt  structure contains
 165  the response value.
 166
 167    - This function calls the mapping matrix for sending the configuration
 168      confirmation.
 169    - The actual function called depends on the coupling at the LKW interface.
 170    - For a loosely coupled interface, a common packing function is called.
 171    - The packing function packs the parameter in a message buffer and posts
 172      the message to the target task.
 173    - For a tightly coupled interface, the actual function called depends on
 174      the layer manager API provided.
 175
 176 */
 177 #ifdef ANSI
 178 S16 RlcMiRlcConfigCfm
 179 (
 180 Pst        *pst,                /* post structure */
 181 RlcMngmt    *cfm                 /* Layer Management structure */
 182 )
 183 #else
 184 S16 RlcMiRlcConfigCfm(pst, cfm)
 185 Pst        *pst;                /* post structure */
 186 RlcMngmt    *cfm;                /* Layer Management structure */
 187 #endif
 188 {
 189
 190    /* jump to specific primitive depending on configured selector */
 191    (*rlcMiRlcConfigCfmMt[pst->selector])(pst, cfm);
 192
 193    return ROK;
 194 }
 195
 196
 197 /**
 198    @brief
 199    This function is called by the RlcMiLkwCntrlReq function to send a control confirm to the layer management module.
 200
 201    - This function calls the mapping matrix for sending the control confirmation.
 202    - Actual function called depends on the coupling of the LKW interface.
 203    - For a loosely coupled interface, a common packing function is called.
 204    - The packing function packs the parameter in a message buffer and posts the
 205      message to the target task.
 206    - For a tightly coupled interface, the actual function called depends on the
 207      layer manager API provided.
 208
 209 */
 210 #ifdef ANSI
 211 S16 RlcMiLkwCntrlCfm
 212 (
 213 Pst *pst,                    /* post structure */
 214 RlcMngmt *cfm                 /* configure */
 215 )
 216 #else
 217 S16 RlcMiLkwCntrlCfm(pst, cfm)
 218 Pst *pst;                    /* post structure */
 219 RlcMngmt *cfm;                /* confirm */
 220 #endif
 221 {
 222
 223    /* jump to specific primitive depending on configured selector */
 224    (*kwMiLkwCntrlCfmMt[pst->selector])(pst, cfm);
 225
 226    return ROK;
 227
 228 } /* end of RlcMiLkwCntrlCfm */
 229
 230 /**
 231    @brief
 232    Description:
 233    - This function can be used by RLC to send unsolicited status information
 234      to the layer manager, when the unsolicited status flag is enabled by the
 235      layer manager through a previous control request.
 236
 237    - This function calls the mapping matrix for sending the unsolicited status
 238      indication.The actual function called depends on the coupling of the
 239      LKW interface.
 240
 241    - For a loosely coupled interface, a common packing function is called. The
 242      packing function packs the parameter in a message buffer and posts the
 243      message to the target task.
 244
 245    - For a tightly coupled interface, the actual function called depends on
 246      the layer manager API provided.
 247 */
 248 #ifdef ANSI
 249 S16 RlcMiLkwStaInd
 250 (
 251 Pst     *pst,                /* post structure */
 252 RlcMngmt *usta                /* unsolicited status */
 253 )
 254 #else
 255 S16 RlcMiLkwStaInd(pst, usta)
 256 Pst     *pst;                /* post structure */
 257 RlcMngmt *usta;               /* unsolicited status */
 258 #endif
 259 {
 260    /* jump to specific primitive depending on configured selector */
 261    (*kwMiLkwStaIndMt[pst->selector])(pst, usta);
 262
 263    return (ROK);
 264 } /* end of RlcMiLkwStaInd */
 265
 266
 267 /**
 268    @brief
 269    - This function is called by the RlcMiLkwStaReq function to send
 270       the requested status information to the layer manager.
 271
 272    - This function calls the mapping matrix for sending the status
 273       confirmation. The actual function called depends on the coupling
 274       of the LKW interface.
 275
 276    - For a loosely coupled interface, a common packing function is called.
 277       The packing function packs the parameter in a message buffer and
 278       posts the message to the target task.
 279
 280    - For a tightly coupled interface, the actual function called depends
 281       on the layer manager API provided.
 282
 283 */
 284 #ifdef ANSI
 285 S16 RlcMiLkwStaCfm
 286 (
 287 Pst *pst,                    /* post structure */
 288 RlcMngmt *cfm                 /* solicited status confirmation */
 289 )
 290 #else
 291 S16 RlcMiLkwStaCfm(pst, cfm)
 292 Pst *pst;                    /* post structure */
 293 RlcMngmt *cfm;                /* solicited status confirmation */
 294 #endif
 295 {
 296
 297    /* jump to specific primitive depending on configured selector */
 298    (*kwMiLkwStaCfmMt[pst->selector])(pst, cfm);
 299
 300    return ROK;
 301
 302 } /* end of RlcMiLkwStaCfm */
 303
 304
 305 /**
 306    @brief
 307    - This function is called by the RlcMiLkwStsReq function for responding
 308       to statistics requests.
 309
 310    - This function calls the mapping matrix for sending the statistics
 311       confirmation. The actual function called depends on the coupling
 312       of the LKW interface.
 313
 314    - For a loosely coupled interface, a common packing function is called.
 315       The packing function packs the parameter in a message buffer and
 316       posts the message to the target task.
 317
 318    - For a tightly coupled interface, the actual function called depends
 319       on the layer manager API provided.
 320
 321 */
 322 #ifdef ANSI
 323 S16 RlcMiLkwStsCfm
 324 (
 325 Pst *pst,                    /* post structure */
 326 Action action,               /* action */
 327 RlcMngmt *cfm                 /* statistics confirmation */
 328 )
 329 #else
 330 S16 RlcMiLkwStsCfm(pst, action, cfm)
 331 Pst *pst;                    /* post structure */
 332 Action action;               /* action */
 333 RlcMngmt *cfm;                /* statistics confirmation */
 334 #endif
 335 {
 336    /* jump to specific primitive depending on configured selector */
 337    (*kwMiLkwStsCfmMt[pst->selector])(pst, action, cfm);
 338
 339    return ROK;
 340
 341 } /* end of RlcMiLkwStsCfm */
 342
 343 /**
 344    @brief
 345    - This function can be used by RLC module to send unsolicited trace
 346       indications to the layer manager, when tracing is enabled by the
 347       layer manager through a previous control request.
 348
 349    - This function calls the mapping matrix for sending the trace indication.
 350       The actual function called depends on the coupling of the LKW interface.
 351
 352    - For a loosely coupled interface, a common packing function is called.
 353       The packing function packs the parameter in a message buffer and posts
 354       the message to the target task.
 355
 356    - For a tightly coupled interface, the actual function called depends on
 357       the layer manager API provided.
 358
 359 */
 360 #ifdef ANSI
 361 S16 RlcMiLkwTrcInd
 362 (
 363 Pst *pst,                    /* post structure */
 364 RlcMngmt *trc,                /* trace indication */
 365 Buffer *mBuf                 /* message buffer */
 366 )
 367 #else
 368 S16 RlcMiLkwTrcInd(pst, trc, mBuf)
 369 Pst *pst;                    /* post structure */
 370 RlcMngmt *trc;                /* trace indication */
 371 Buffer *mBuf;                /* message buffer */
 372 #endif
 373 {
 374    /* jump to specific primitive depending on configured selector */
 375    (*kwMiLkwTrcIndMt[pst->selector])(pst, trc, mBuf);
 376
 377    return ROK;
 378
 379 } /* end of RlcMiLkwTrcInd */
 380
 381
 382 /* kw005.201 added support for L2 Measurement */
 383 #ifdef LTE_L2_MEAS
 384 #ifdef ANSI
 385 S16 RlcMiLkwL2MeasCfm
 386 (
 387 Pst * pst,
 388 RlcL2MeasCfmEvt *measEvt
 389 )
 390 #else
 391 S16 RlcMiLkwL2MeasCfm(pst, measEvt)
 392 Pst * pst;
 393 RlcL2MeasCfmEvt *measEvt;
 394 #endif
 395 {
 396
 397    (*rlcMiLkwL2MeasCfmMt[pst->selector])(pst, measEvt);
 398
 399    return ROK;
 400
 401 }
 402 #ifdef ANSI
 403 S16 RlcMiLkwL2MeasStopCfm
 404 (
 405 Pst *pst,
 406 uint8_t  measType,
 407 uint8_t  status
 408 )
 409 #else
 410 S16 RlcMiLkwL2MeasStopCfm(pst, measType,status)
 411 Pst *pst;
 412 uint8_t  measType;
 413 uint8_t  status;
 414 #endif
 415 {
 416
 417    (*RlcMiLkwL2MeasStopCfmMt[pst->selector])(pst, measType,status);
 418
 419    return ROK;
 420
 421 }
 422 #endif /*  LTE_L2_MEAS */
 423
 424 /********************************************************************30**
 425
 426          End of file
 427 **********************************************************************/