src/5gnrpdcp/pj_udx_ptul.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:    LTE-PDCP Layer - Upper Interface
  22
  23         Type:    C file
  24
  25         Desc:    C source code for the upper interface of LTE-PDCP
  26
  27         File:    pj_udx_ptul.c
  28
  29 *********************************************************************21*/
  30
  31 /** @file pj_udx_ptul.c
  32 @brief PDCP Upper Interface
  33 */
  34
  35 \f
  36 /* header (.h) include files */
  37 #include "envopt.h"        /* environment options */
  38 #include "envdep.h"        /* environment dependent */
  39 #include "envind.h"        /* environment independent */
  40
  41 #include "gen.h"           /* general */
  42 #include "ssi.h"           /* system services */
  43 #include "cm5.h"           /* common timer defines */
  44 #include "cm_tkns.h"       /* common tokens defines */
  45 #include "cm_mblk.h"       /* common memory allocation library defines */
  46 #include "cm_llist.h"      /* common link list  defines  */
  47 #include "cm_hash.h"       /* common hash list  defines */
  48 #include "cm_lte.h"        /* common LTE defines */
  49 #include "cpj.h"           /* UDX defines */
  50 #include "pju.h"           /* PJU defines */
  51 #include "lpj.h"
  52 #include "pj_udx.h"
  53
  54 #include "pj_err.h"
  55 #include "pj_env.h"        /* RLC environment options */
  56
  57 /* extern (.x) include files */
  58 #include "gen.x"           /* general */
  59 #include "ssi.x"           /* system services */
  60
  61 #include "cm5.x"           /* common timer library */
  62 #include "cm_tkns.x"       /* common tokens */
  63 #include "cm_mblk.x"       /* common memory allocation */
  64 #include "cm_llist.x"      /* common link list */
  65 #include "cm_hash.x"       /* common hash list */
  66 #include "cm_lte.x"        /* common LTE includes */
  67 #include "cm_lib.x"        /* common memory allocation library */
  68 #include "cpj.x"           /* UDX defines */
  69 #include "pju.x"           /* PJU defines */
  70 #include "lpj.x"           /* LPJ defines */
  71 #include "pj.h"
  72 #include "pj.x"
  73 #include "pj_udx.x"
  74 #include "pj_ul.x"
  75
  76
  77 #if !(defined(LCPJULUDX)  && defined(PJ) && defined(LWLCPJULUDX))
  78 #define PTPJULUDX
  79 #endif
  80
  81 #ifdef __cplusplus
  82 EXTERN "C" {
  83 #endif /* __cplusplus */
  84
  85 #ifdef PTPJULUDX
  86 PRIVATE S16 PtUlUdxBndReq ARGS((Pst *post, SuId suId, SpId spId));
  87 PRIVATE S16 PtUlUdxUbndReq ARGS((Pst *post, SpId spId, Reason reason));
  88 PRIVATE S16 PtUlUdxCfgReq ARGS((Pst *post, SpId spId, UdxCfgReqInfo *pdCfgReq));
  89 PRIVATE S16 PtUlUdxUeIdChgReq ARGS((Pst *post, SpId spId,U32 transId,
  90                                     UdxUeInfo *oldUeInfo,
  91                                     UdxUeInfo *newUeInfo));
  92
  93 PRIVATE S16 PtUlUdxSecCfgReq ARGS((Pst *post, SpId spId,
  94                                    UdxSecCfgReqInfo *pdcpSecCfgReq));
  95 PRIVATE S16 PtUlUdxCountReq ARGS((Pst *post, SpId spId,
  96                                    UdxCountReqInfo *pdcpCountReq));
  97 PRIVATE S16 PtUlUdxReEstReq ARGS(( Pst *post, SpId spId,
  98                                    UdxReEstReqInfo *restbInfo));
  99 PRIVATE S16 PtUlUdxSduStaReq ARGS(( Pst *post, SpId spId,
 100                                    UdxSduStaReqInfo *statReqInfo));
 101
 102 PRIVATE S16 PtUlUdxUlStaRep ARGS ((
 103          Pst *post,                      /* Post structure */
 104          SpId spId,                      /* Service provider ID */
 105          UdxUlStaRepInfo *pdStaRep         /* PDCP UL ot PDCP DL Reestablishment trigger */
 106          ));
 107 PRIVATE S16 PtUlUdxDlStaRep ARGS ((
 108          Pst *post,                      /* Post structure */
 109          SpId spId,                      /* Service provider ID */
 110          UdxDlStaRepInfo *pdStaRep       /* Status report from PDCP UL to PDCP DL */
 111          ));
 112
 113 PRIVATE S16 PtUlUdxUlFdbkPktInfo ARGS ((
 114          Pst *post,                      /* Post structure */
 115          SpId spId,                      /* Service provider ID */
 116          UdxUlFdbkPktInfo  *fdbkPktInfo    /* feedback Packet Info */
 117             ));
 118
 119 PRIVATE S16 PtUlUdxDlFdbkPktInfo ARGS ((
 120          Pst *post,                      /* Post structure */
 121          SpId spId,                      /* Service provider ID */
 122          UdxDlFdbkPktInfo  *fdbkPktInfo    /* feedback Packet Info */
 123             ));
 124 #ifdef LTE_L2_MEAS
 125 PRIVATE S16  PtUlUdxL2MeasReq ARGS ((
 126          Pst *pst,
 127          PjL2MeasReqEvt *measReqEvt
 128          ));
 129 PRIVATE S16  PtUlUdxL2MeasSendReq ARGS((
 130          Pst *pst,
 131          U8 status
 132          ));
 133 PRIVATE S16  PtUlUdxL2MeasStopReq ARGS((
 134          Pst *pst,
 135          U8  status
 136          ));
 137 #endif
 138 PRIVATE S16  PtUlUdxDatResumeReq ARGS((
 139          Pst           *pst,
 140          UdxDatResumeInfo  *udxDatResumeInfo
 141          ));
 142 PRIVATE S16  PtUlUdxDatForwardReq ARGS((
 143          Pst           *pst,
 144          UdxDatForwardInfo  *udxDatForwardInfo
 145          ));
 146 #endif /* PTPJULUDX */
 147
 148 \f
 149 /**************************************************************************
 150  * UDX Interface Matrices
 151  *************************************************************************/
 152
 153 /* UDX Interface Bind Request primitive */
 154 PRIVATE CONSTANT UdxBndReq PjUlUdxBndReqMt [PJ_MAX_UDX] =
 155 {
 156 #ifdef LCPJULUDX
 157    cmPkPjUdxBndReq,          /* 0 - loosely coupled */
 158 #else /* LCPJULUDX */
 159    PtUlUdxBndReq,          /* 0 - loosely coupled, portable */
 160 #endif /* LCPJULUDX */
 161 #ifdef LWLCPJULUDX
 162    cmPkPjUdxBndReq,          /* 1 - loosely coupled */
 163 #else /* LCPJULUDX */
 164    PtUlUdxBndReq,          /* 1 - loosely coupled, portable */
 165 #endif /* LCPJULUDX */
 166 #ifdef PJ
 167    PjDlUdxBndReq,          /* 2 - tightly coupled, CTC */
 168 #else /* PJ */
 169    PtUlUdxBndReq,          /* 2 - tightly coupled, portable */
 170 #endif /* PJ */
 171 };
 172
 173 /* UDX Interface Unbind Request primitive */
 174 PRIVATE CONSTANT UdxUbndReq PjUlUdxUbndReqMt [PJ_MAX_UDX] =
 175 {
 176 #ifdef LCPJULUDX
 177  cmPkPjUdxUbndReq,          /* 0 - loosely coupled */
 178 #else /* LCPJULUDX */
 179  PtUlUdxUbndReq,          /* 0 - loosely coupled, portable */
 180 #endif /* LCPJULUDX */
 181 #ifdef LWLCPJULUDX
 182  cmPkPjUdxUbndReq,          /* 1 - loosely coupled */
 183 #else /* LCPJULUDX */
 184  PtUlUdxUbndReq,          /* 1 - loosely coupled, portable */
 185 #endif /* LCPJULUDX */
 186 #ifdef PJ
 187  PjDlUdxUbndReq,          /* 2 - tightly coupled, UDX */
 188 #else /* PJ */
 189  PtUlUdxUbndReq,          /* 2 - tightly coupled, portable */
 190 #endif /* PJ */
 191 };
 192
 193 /* UDX Interface Config Request primitive */
 194 PRIVATE CONSTANT UdxCfgReq PjUlUdxCfgReqMt [PJ_MAX_UDX] =
 195 {
 196 #ifdef LCPJULUDX
 197  cmPkPjUdxCfgReq,          /* 0 - loosely coupled */
 198 #else /* LCPJULUDX */
 199  PtUlUdxCfgReq,          /* 0 - loosely coupled, portable */
 200 #endif /* LCPJULUDX */
 201 #ifdef LWLCPJULUDX
 202  cmPkPjUdxCfgReq,          /* 1 - loosely coupled */
 203 #else /* LCPJULUDX */
 204  PtUlUdxCfgReq,          /* 1 - loosely coupled, portable */
 205 #endif /* LCPJULUDX */
 206 #ifdef PJ
 207  PjDlUdxCfgReq,          /* 2 - tightly coupled, UDX */
 208 #else /* PJ */
 209  PtUlUdxCfgReq,          /* 2 - tightly coupled, portable */
 210 #endif /* PJ */
 211 };
 212
 213 /* UDX Interface Status Report from PDCP-UL to PDCP-DL primitive */
 214 PRIVATE CONSTANT UdxUlStaRep PjUlUdxUlStaRepMt [PJ_MAX_UDX] =
 215 {
 216 #ifdef LCPJULUDX
 217  cmPkPjUdxUlStaRep,          /* 0 - loosely coupled */
 218 #else /* LCPJULUDX */
 219  PtUlUdxUlStaRep,          /* 0 - loosely coupled, portable */
 220 #endif /* LCPJULUDX */
 221 #ifdef LWLCPJULUDX
 222  cmPkPjUdxUlStaRep,          /* 1 - loosely coupled */
 223 #else /* LCPJULUDX */
 224  PtUlUdxUlStaRep,          /* 1 - loosely coupled, portable */
 225 #endif /* LCPJULUDX */
 226 #ifdef PJ
 227  PjDlUdxUlStaRep,          /* 2 - tightly coupled, UDX */
 228 #else /* PJ */
 229  PtUlUdxUlStaRep,          /* 2 - tightly coupled, portable */
 230 #endif /* PJ */
 231 };
 232
 233 /* UDX Interface Status Report from PDCP-UL to PDCP-DL primitive */
 234 PRIVATE CONSTANT UdxDlStaRep PjUlUdxDlStaRepMt [PJ_MAX_UDX] =
 235 {
 236 #ifdef LCPJULUDX
 237  cmPkPjUdxDlStaRep,          /* 0 - loosely coupled */
 238 #else /* LCPJULUDX */
 239  PtUlUdxDlStaRep,          /* 0 - loosely coupled, portable */
 240 #endif /* LCPJULUDX */
 241 #ifdef LWLCPJULUDX
 242  cmPkPjUdxDlStaRep,          /* 1 - loosely coupled */
 243 #else /* LCPJULUDX */
 244  PtUlUdxDlStaRep,          /* 1 - loosely coupled, portable */
 245 #endif /* LCPJULUDX */
 246 #ifdef PJ
 247  PjDlUdxDlStaRep,          /* 2 - tightly coupled, UDX */
 248 #else /* PJ */
 249  PtUlUdxDlStaRep,          /* 2 - tightly coupled, portable */
 250 #endif /* PJ */
 251 };
 252
 253 /* UDX Interface Status Report from PDCP-UL to PDCP-DL primitive */
 254 PRIVATE CONSTANT UdxDlFdbkPkt PjUlUdxDlFdbkPktInfoMt [PJ_MAX_UDX] =
 255 {
 256 #ifdef LCPJULUDX
 257  cmPkPjUdxDlFdbkPkt,          /* 0 - loosely coupled */
 258 #else /* LCPJULUDX */
 259  PtUlUdxDlFdbkPktInfo,          /* 0 - loosely coupled, portable */
 260 #endif /* LCPJULUDX */
 261 #ifdef LWLCPJULUDX
 262  cmPkPjUdxDlFdbkPkt,          /* 1 - loosely coupled */
 263 #else /* LCPJULUDX */
 264  PtUlUdxDlFdbkPktInfo,          /* 1 - loosely coupled, portable */
 265 #endif /* LCPJULUDX */
 266 #ifdef PJ
 267  PjDlUdxDlFdbkPktInfo,          /* 2 - tightly coupled, UDX */
 268 #else /* PJ */
 269  PtUlUdxDlFdbkPktInfo,          /* 2 - tightly coupled, portable */
 270 #endif /* PJ */
 271 };
 272
 273
 274 /* UDX Interface Feedback Pkt Info from PDCP-UL to PDCP-DL primitive */
 275 PRIVATE CONSTANT UdxUlFdbkPkt PjUlUdxUlFdbkPktInfoMt [3] =
 276 {
 277 #ifdef LCPJULUDX
 278     cmPkPjUdxUlFdbkPkt,          /* 0 - loosely coupled */
 279 #else /* LCPJULUDX */
 280     PtUlUdxUlFdbkPktInfo,      /* 0 - loosely coupled, portable */
 281 #endif /* LCPJULUDX */
 282 #ifdef LWLCPJULUDX
 283     cmPkPjUdxUlFdbkPkt,          /* 1 - loosely coupled */
 284 #else /* LCPJULUDX */
 285     PtUlUdxUlFdbkPktInfo,      /* 1 - loosely coupled, portable */
 286 #endif /* LCPJULUDX */
 287 #ifdef PJ
 288     PjDlUdxUlFdbkPktInfo,        /* 2 - tightly coupled, UDX */
 289 #else /* PJ */
 290     PtUlUdxUlFdbkPktInfo,      /* 2 - tightly coupled, portable */
 291 #endif /* PJ */
 292 };
 293
 294 /* UDX Interface UE Id Change Request primitive */
 295 PRIVATE CONSTANT UdxUeIdChgReq PjUlUdxUeIdChgReqMt [PJ_MAX_UDX] =
 296 {
 297 #ifdef LCPJULUDX
 298    cmPkPjUdxUeIdChgReq,          /* 0 - loosely coupled */
 299 #else /* LCPJULUDX */
 300    PtUlUdxUeIdChgReq,          /* 0 - loosely coupled, portable */
 301 #endif /* LCPJULUDX */
 302 #ifdef LWLCPJULUDX
 303    cmPkPjUdxUeIdChgReq,          /* 1 - loosely coupled */
 304 #else /* LCPJULUDX */
 305    PtUlUdxUeIdChgReq,          /* 1 - loosely coupled, portable */
 306 #endif /* LCPJULUDX */
 307 #ifdef PJ
 308    PjDlUdxUeIdChgReq,          /* 2 - tightly coupled, UDX */
 309 #else /* PJ */
 310    PtUlUdxUeIdChgReq,          /* 2 - tightly coupled, portable */
 311 #endif /* PJ */
 312 };
 313
 314 /* UDX Interface Security Config Request primitive */
 315 PRIVATE CONSTANT UdxSecCfgReq PjUlUdxSecCfgReqMt [PJ_MAX_UDX] =
 316 {
 317 #ifdef LCPJULUDX
 318    cmPkPjUdxSecCfgReq,          /* 0 - loosely coupled */
 319 #else /* LCPJULUDX */
 320    PtUlUdxSecCfgReq,          /* 0 - loosely coupled, portable */
 321 #endif /* LCPJULUDX */
 322 #ifdef LWLCPJULUDX
 323    cmPkPjUdxSecCfgReq,          /* 1 - loosely coupled */
 324 #else /* LCPJULUDX */
 325    PtUlUdxSecCfgReq,          /* 1 - loosely coupled, portable */
 326 #endif /* LCPJULUDX */
 327 #ifdef PJ
 328    PjDlUdxSecCfgReq,          /* 2 - tightly coupled, UDX */
 329 #else /* PJ */
 330    PtUlUdxSecCfgReq,          /* 2 - tightly coupled, portable */
 331 #endif/* PJ */
 332 };
 333
 334 /* UDX Interface COUNT Request primitive */
 335 PRIVATE CONSTANT UdxCountReq PjUlUdxCountReqMt [PJ_MAX_UDX] =
 336 {
 337 #ifdef LCPJULUDX
 338    cmPkPjUdxCountReq,          /* 0 - loosely coupled */
 339 #else /* LCPJULUDX */
 340    PtUlUdxCountReq,          /* 0 - loosely coupled, portable */
 341 #endif /* LCPJULUDX */
 342 #ifdef LWLCPJULUDX
 343    cmPkPjUdxCountReq,          /* 1 - loosely coupled */
 344 #else /* LCPJULUDX */
 345    PtUlUdxCountReq,          /* 1 - loosely coupled, portable */
 346 #endif /* LCPJULUDX */
 347 #ifdef PJ
 348    PjDlUdxCountReq,          /* 2 - tightly coupled, UDX */
 349 #else /* PJ */
 350    PtUlUdxCountReq,          /* 2 - tightly coupled, portable */
 351 #endif /* PJ */
 352 };
 353
 354 /* UDX Interface PDCP Status Request primitive */
 355 PRIVATE CONSTANT UdxSduStaReq PjUlUdxSduStaReqMt [PJ_MAX_UDX] =
 356 {
 357 #ifdef LCPJULUDX
 358    cmPkPjUdxSduStaReq,          /* 0 - loosely coupled */
 359 #else /* LCPJULUDX */
 360    PtUlUdxSduStaReq,          /* 0 - loosely coupled, portable */
 361 #endif /* LCPJULUDX */
 362 #ifdef LWLCPJULUDX
 363    cmPkPjUdxSduStaReq,          /* 1 - loosely coupled */
 364 #else /* LCPJULUDX */
 365    PtUlUdxSduStaReq,          /* 1 - loosely coupled, portable */
 366 #endif /* LCPJULUDX */
 367 #ifdef PJ
 368    PjDlUdxSduStaReq,          /* 2 - tightly coupled, UDX */
 369 #else /* PJ */
 370    PtUlUdxSduStaReq,          /* 2 - tightly coupled, portable */
 371 #endif /* PJ */
 372 };
 373
 374 /* UDX Interface Re-Establishment Request primitive */
 375 PRIVATE CONSTANT UdxReEstReq PjUlUdxReEstReqMt [PJ_MAX_UDX] =
 376 {
 377 #ifdef LCPJULUDX
 378    cmPkPjUdxReEstReq,          /* 0 - loosely coupled */
 379 #else /* LCPJULUDX */
 380    PtUlUdxReEstReq,          /* 0 - loosely coupled, portable */
 381 #endif /* LCPJULUDX */
 382 #ifdef LWLCPJULUDX
 383    cmPkPjUdxReEstReq,          /* 1 - loosely coupled */
 384 #else /* LCPJULUDX */
 385    PtUlUdxReEstReq,          /* 1 - loosely coupled, portable */
 386 #endif /* LCPJULUDX */
 387 #ifdef PJ
 388    PjDlUdxReEstReq,          /* 2 - tightly coupled, UDX */
 389 #else /* PJ */
 390    PtUlUdxReEstReq,          /* 2 - tightly coupled, portable */
 391 #endif /* PJ */
 392 };
 393
 394 #ifdef LTE_L2_MEAS
 395 PRIVATE CONSTANT UdxL2MeasReq pjUlUdxL2MeasReqMt[PJ_MAX_UDX] =
 396 {
 397 #ifdef LCPJULUDX
 398    cmPkPjUdxL2MeasReq,            /* 0 - loosely coupled */
 399 #else
 400    PtUlUdxL2MeasReq,            /* 0 - loosely coupled, portable  */
 401 #endif /* LCKWUIKWU */
 402 #ifdef LWLCPJULUDX
 403    cmPkPjUdxL2MeasReq,            /* 1 - loosely coupled */
 404 #else
 405    PtUlUdxL2MeasReq,            /* 1 - loosely coupled, portable  */
 406 #endif /* LCKWUIKWU */
 407 #ifdef PJ
 408    PjDlUdxL2MeasReq,            /* 2 - tightly coupled, RRC  */
 409 #else
 410    PtUlUdxL2MeasReq,            /* 2 - tightly coupled, portable */
 411 #endif /* KW */
 412 };
 413
 414 PRIVATE CONSTANT UdxL2MeasSendReq pjUlUdxL2MeasSendReqMt[PJ_MAX_UDX] =
 415 {
 416 #ifdef LCPJULUDX
 417    cmPkPjUdxL2MeasSendReq,            /* 0 - loosely coupled */
 418 #else
 419    PtUlUdxL2MeasSendReq,            /* 0 - loosely coupled, portable  */
 420 #endif /* LCKWUIKWU */
 421 #ifdef LWLCPJULUDX
 422    cmPkPjUdxL2MeasSendReq,            /* 1 - loosely coupled */
 423 #else
 424    PtUlUdxL2MeasSendReq,            /* 1 - loosely coupled, portable  */
 425 #endif /* LCKWUIKWU */
 426 #ifdef PJ
 427    PjDlUdxL2MeasSendReq,            /* 2 - tightly coupled, RRC  */
 428 #else
 429    PtUlUdxL2MeasSendReq,            /* 2 - tightly coupled, portable */
 430 #endif /* PJ */
 431 };
 432
 433 PRIVATE CONSTANT UdxL2MeasStopReq pjUlUdxL2MeasStopReqMt[PJ_MAX_UDX] =
 434 {
 435 #ifdef LCPJULUDX
 436    cmPkPjUdxL2MeasStopReq,            /* 0 - loosely coupled */
 437 #else
 438    PtUlUdxL2MeasStopReq,            /* 0 - loosely coupled, portable  */
 439 #endif /* LCKWUIKWU */
 440 #ifdef LWLCPJULUDX
 441    cmPkPjUdxL2MeasStopReq,            /* 1 - loosely coupled */
 442 #else
 443    PtUlUdxL2MeasStopReq,            /* 1 - loosely coupled, portable  */
 444 #endif /* LCKWUIKWU */
 445 #ifdef PJ
 446    PjDlUdxL2MeasStopReq,            /* 2 - tightly coupled, RRC  */
 447 #else
 448    PtUlUdxL2MeasStopReq,            /* 2 - tightly coupled, portable */
 449 #endif /* PJ */
 450 };
 451 #endif
 452
 453
 454 /* UDX Interface PDCP Status Request primitive */
 455 PRIVATE CONSTANT UdxDatResumeReq pjUlUdxDatResumeReqMt [PJ_MAX_UDX] =
 456 {
 457 #ifdef LCPJULUDX
 458    cmPkPjUdxDatResumeReq,          /* 0 - loosely coupled */
 459 #else /* LCPJULUDX */
 460    PtUlUdxDatResumeReq,          /* 0 - loosely coupled, portable */
 461 #endif /* LCPJULUDX */
 462 #ifdef LWLCPJULUDX
 463    cmPkPjUdxDatResumeReq,          /* 1 - loosely coupled */
 464 #else /* LCPJULUDX */
 465    PtUlUdxDatResumeReq,          /* 1 - loosely coupled, portable */
 466 #endif /* LCPJULUDX */
 467 #ifdef PJ
 468    PjDlUdxDatResumeReq,          /* 2 - tightly coupled, UDX */
 469 #else /* PJ */
 470    PtUlUdxDatResumeReq,          /* 2 - tightly coupled, portable */
 471 #endif /* PJ */
 472 };
 473
 474
 475 /* UDX Interface PDCP Start Data Forward primitive */
 476 PRIVATE CONSTANT UdxDatForwardReq pjUlUdxDatForwardReqMt [PJ_MAX_UDX] =
 477 {
 478 #ifdef LCPJULUDX
 479    cmPkPjUdxDatForwardReq,          /* 0 - loosely coupled */
 480 #else /* LCPJULUDX */
 481    PtUlUdxDatForwardReq,          /* 0 - loosely coupled, portable */
 482 #endif /* LCPJULUDX */
 483 #ifdef LWLCPJULUDX
 484    cmPkPjUdxDatForwardReq,          /* 1 - loosely coupled */
 485 #else /* LCPJULUDX */
 486    PtUlUdxDatForwardReq,          /* 1 - loosely coupled, portable */
 487 #endif /* LCPJULUDX */
 488 #ifdef PJ
 489    PjDlUdxDatForwardReq,          /* 2 - tightly coupled, UDX */
 490 #else /* PJ */
 491    PtUlUdxDatForwardReq,          /* 2 - tightly coupled, portable */
 492 #endif /* PJ */
 493 };
 494 \f
 495 /**************************************************************************
 496  * The UDX Interface
 497  *************************************************************************/
 498 /**
 499  *
 500  *   @brief  This function binds the RRC service user with the PDCP
 501  *             service provider.
 502  *
 503  *   @details  This function binds the RRC service user with the PDCP
 504  *             service provider. The PDCP registers this new service
 505  *             user and allocates a Service Access Point (SAP) for
 506  *             this bind. The service user specifies the reference
 507  *             number that is used for the duration of this bind.
 508  */
 509 #ifdef ANSI
 510 PUBLIC S16 PjUlUdxBndReq
 511 (
 512 Pst *post,                       /* Post structure */
 513 SuId suId,                      /* Service user ID */
 514 SpId spId                       /* Service provider ID */
 515 )
 516 #else /* ANSI */
 517 PUBLIC S16 PjUlUdxBndReq(post, suId, spId)
 518 Pst *post;                       /* Post structure */
 519 SuId suId;                      /* Service user ID */
 520 SpId spId;                      /* Service provider ID */
 521 #endif /* ANSI */
 522 {
 523
 524    TRC3(PjUlUdxBndReq);
 525
 526    RETVALUE((*PjUlUdxBndReqMt[post->selector])(post, suId, spId));
 527
 528 } /* end of function PjUlUdxBndReq */
 529
 530 \f
 531 /*
 532 *      @brief  This function unbinds the RRC service user with the PDCP
 533 *             service provider.
 534 *
 535 *      @details This function unbinds the RRC service user with the PDCP
 536 *             service provider.
 537 *
 538 */
 539 #ifdef ANSI
 540 PUBLIC S16 PjUlUdxUbndReq
 541 (
 542 Pst *post,                       /* Post structure */
 543 SpId spId,                      /* Service provider ID */
 544 Reason reason                   /* Reason */
 545 )
 546 #else /* ANSI */
 547 PUBLIC S16 PjUlUdxUbndReq(post, spId, reason)
 548 Pst *post;                       /* Post structure */
 549 SpId spId;                      /* Service provider ID */
 550 Reason reason;                  /* Reason */
 551 #endif /* ANSI */
 552 {
 553
 554    TRC3(PjUlUdxUbndReq);
 555
 556    RETVALUE((*PjUlUdxUbndReqMt[post->selector])(post, spId, reason));
 557
 558 } /* end of function PjUlUdxUbndReq */
 559
 560 \f
 561 /**
 562 *
 563 *      @brief  This function is used to pass Signalling Info to PDCP related
 564 *             to PDCP configuration.
 565 *
 566 *      @details This function is used to pass signaling Info to PDCP related
 567 *             to PDCP configuration.
 568 *
 569 */
 570 #ifdef ANSI
 571 PUBLIC S16 PjUlUdxCfgReq
 572 (
 573 Pst *post,                       /* Post structure */
 574 SpId spId,                      /* Service provider ID */
 575 UdxCfgReqInfo *pdCfgReq              /* PDCP Config parameters */
 576 )
 577 #else /* ANSI */
 578 PUBLIC S16 PjUlUdxCfgReq(post, spId, pdCfgReq)
 579 Pst *post;                       /* Post structure */
 580 SpId spId;                      /* Service provider ID */
 581 UdxCfgReqInfo *pdCfgReq;             /* PDCP Config parameters */
 582 #endif /* ANSI */
 583 {
 584
 585   TRC3(PjUlUdxCfgReq);
 586
 587
 588   RETVALUE((*PjUlUdxCfgReqMt[post->selector])(post, spId, pdCfgReq));
 589
 590 } /* end of function PjUlUdxCfgReq */
 591
 592
 593 /**
 594 *
 595 *      @brief  This function is used to sent the PDCP STATUS report to PDCP-DL during the Reestablishment.
 596 *      @details This function is used to sent the PDCP STATUS report to PDCP-DL during the Reestablishment
 597 *
 598 */
 599 #ifdef ANSI
 600 PUBLIC S16 PjUlUdxUlStaRep
 601 (
 602 Pst *pst,                       /* Post structure */
 603 SpId spId,                      /* Service provider ID */
 604 UdxUlStaRepInfo *staRep           /*PDCP Status Report*/
 605 )
 606 #else /* ANSI */
 607 PUBLIC S16 PjUlUdxUlStaRep (pst, spId, staRep)
 608 Pst *pst;                       /* Post structure */
 609 SpId spId;                      /* Service provider ID */
 610 UdxUlStaRepInfo *staRep;          /* PDCP Status Report*/
 611 #endif /* ANSI */
 612 {
 613
 614   TRC3(PjUlUdxUlStaRep);
 615
 616   RETVALUE((*PjUlUdxUlStaRepMt[pst->selector])(pst, spId, staRep));
 617
 618 } /* end of function PjUlUdxUlStaRep */
 619
 620 /**
 621 *
 622 *      @brief  This function is used to sent the PDCP STATUS report received from peer RLC to PDCP-DL.
 623 *      @details This function is used to sent the PDCP STATUS report received from peer RLC to PDCP-DL
 624 *
 625 */
 626 #ifdef ANSI
 627 PUBLIC S16 PjUlUdxDlStaRep
 628 (
 629 Pst *pst,                       /* Post structure */
 630 SpId spId,                      /* Service provider ID */
 631 UdxDlStaRepInfo *staRep           /*PDCP Status Report*/
 632 )
 633 #else /* ANSI */
 634 PUBLIC S16 PjUlUdxDlStaRep (pst, spId, staRep)
 635 Pst *pst;                       /* Post structure */
 636 SpId spId;                      /* Service provider ID */
 637 UdxDlStaRepInfo *staRep;          /* PDCP Status Report*/
 638 #endif /* ANSI */
 639 {
 640
 641   TRC3(PjUlUdxDlStaRep);
 642
 643   RETVALUE((*PjUlUdxDlStaRepMt[pst->selector])(pst, spId, staRep));
 644
 645 } /* end of function PjUlUdxUlStaRep */
 646
 647 /**
 648 *
 649 *      @brief  This function is used to sent the ROHC feedback report received from peer PDCP to PDCP-DL
 650 *      @details This function is used to sent the ROHC feedback report received from peer PDCP to PDCP-DL
 651 *
 652 */
 653 #ifdef ANSI
 654 PUBLIC S16 PjUlUdxDlFdbkPktInfo
 655 (
 656 Pst *pst,                       /* Post structure */
 657 SpId spId,                      /* Service provider ID */
 658 UdxDlFdbkPktInfo *fdbk           /*ROHC feedback*/
 659 )
 660 #else /* ANSI */
 661 PUBLIC S16 PjUlUdxDlFdbkPktInfo (pst, spId, fdbk)
 662 Pst *pst;                       /* Post structure */
 663 SpId spId;                      /* Service provider ID */
 664 UdxDlFdbkPktInfo *fdbk;          /* ROHC feedback*/
 665 #endif /* ANSI */
 666 {
 667
 668   TRC3(PjUlUdxDlFdbkPktInfo);
 669
 670   RETVALUE((*PjUlUdxDlFdbkPktInfoMt[pst->selector])(pst, spId, fdbk));
 671
 672 } /* end of function PjUlUdxDlFdbkPktInfo */
 673
 674 /**
 675  *
 676  *      @brief  This function is used to sent the Feedback pkt info to DL-PDCP.
 677  *      @details This function is used to sent the Feedback pkt info to DL-PDCP.
 678  *
 679  */
 680 #ifdef ANSI
 681 PUBLIC S16 PjUlUdxUlFdbkPktInfo
 682 (
 683 Pst *pst,                       /* Post structure */
 684 SpId spId,                      /* Service provider ID */
 685 UdxUlFdbkPktInfo *fdbkPktInfo           /*Feedback Packet Info*/
 686 )
 687 #else /* ANSI */
 688 PUBLIC S16 PjUlUdxUlFdbkPktInfo (pst, spId, staRep)
 689 Pst *pst;                       /* Post structure */
 690 SpId spId;                      /* Service provider ID */
 691 UdxUlFdbkPktInfo *fdbkPktInfo;          /* Feedback Packet Info*/
 692 #endif /* ANSI */
 693 {
 694
 695     TRC3(PjUlUdxUlFdbkPktInfo);
 696
 697     RETVALUE((*PjUlUdxUlFdbkPktInfoMt[pst->selector])(pst, spId, fdbkPktInfo));
 698
 699 } /* end of function PjUlUdxUlFdbkPktInfo */
 700
 701
 702 /**
 703  *
 704  *      @brief  Sends an UE Id Change Indication to PDCP on Ckw interface
 705  *      @details Sends an UE Id Change Indication to PDCP on Ckw interface
 706  *
 707  */
 708 #ifdef ANSI
 709 PUBLIC S16 PjUlUdxUeIdChgReq
 710 (
 711 Pst       *post,          /* post structure */
 712 SpId       spId,         /* service provider */
 713 U32        transId,      /* RRC Transaction Id */
 714 UdxUeInfo *oldUeInfo,    /* current UE Id */
 715 UdxUeInfo *newUeInfo     /* new UE Id */
 716 )
 717 #else /* ANSI */
 718 PUBLIC S16 PjUlUdxUeIdChgReq(post, spId, transId, oldUeInfo, newUeInfo)
 719 Pst       *post;              /* post structure */
 720 SpId       spId;             /* service provider */
 721 U32        transId;          /* RRC Transaction Id */
 722 UdxUeInfo *oldUeInfo;        /* current UE Id */
 723 UdxUeInfo *newUeInfo;        /* new UE Id */
 724 #endif /* ANSI */
 725 {
 726   TRC3(PjUlUdxUeIdChgReq);
 727
 728   RETVALUE((*PjUlUdxUeIdChgReqMt[post->selector])(post, spId, transId,
 729             (UdxUeInfo *)oldUeInfo, (UdxUeInfo *)newUeInfo ));
 730
 731 } /* end of function PjUlUdxUeIdChgReq */
 732
 733 /**
 734 *
 735 *      @brief  This function is used to configure PDCP security parameters
 736 *              (parametrs of Integrity protection and ciphering)
 737 *
 738 *      @details  This function is used to configure PDCP security parameters
 739 *              (parametrs of Integrity protection and ciphering)
 740 *
 741 */
 742 #ifdef ANSI
 743 PUBLIC S16 PjUlUdxSecCfgReq
 744 (
 745 Pst *post,                                /* Post structure */
 746 SpId spId,                               /* Service provider ID */
 747 UdxSecCfgReqInfo *cpjSecConfigReqInfo    /* PDCP Security Config parameters */
 748 )
 749 #else /* ANSI */
 750 PUBLIC S16 PjUlUdxSecCfgReq(post, spId, cpjSecConfigReqInfo)
 751 Pst *post;                                /* Post structure */
 752 SpId spId;                               /* Service provider ID */
 753 UdxSecCfgReqInfo *cpjSecConfigReqInfo;   /* PDCP Security Config parameters */
 754 #endif /* ANSI */
 755 {
 756
 757   TRC3(PjUlUdxSecCfgReq);
 758
 759   RETVALUE((*PjUlUdxSecCfgReqMt[post->selector])(post, spId,
 760                             cpjSecConfigReqInfo));
 761
 762 } /* end of function PjUlUdxSecCfgReq */
 763
 764 /**
 765 *
 766 *      @brief  This function is used to get COUNT values of each established DRB
 767 *
 768 *      @details  This function is used to get COUNT values of each established DRB
 769 *
 770 */
 771 #ifdef ANSI
 772 PUBLIC S16 PjUlUdxCountReq
 773 (
 774 Pst *post,                       /* Post structure */
 775 SpId spId,                      /* Service provider ID */
 776 UdxCountReqInfo *pdcpCountReq              /* PDCP COUNT request paramters */
 777 )
 778 #else /* ANSI */
 779 PUBLIC S16 PjUlUdxCountReq(post, spId, pdcpCountReq)
 780 Pst *post;                       /* Post structure */
 781 SpId spId;                      /* Service provider ID */
 782 UdxCountReqInfo *pdcpCountReq;              /* PDCP COUNT request paramters */
 783 #endif /* ANSI */
 784 {
 785
 786   TRC3(PjUlUdxCountReq);
 787
 788   RETVALUE((*PjUlUdxCountReqMt[post->selector])(post, spId, pdcpCountReq));
 789
 790 } /* end of function PjUlUdxCountReq */
 791
 792 /**
 793 *
 794 *      @brief  This function is used to get PDCP Sdu Status for all DRBs.
 795 *
 796 *      @details  This function is used to get PDCP Sdu Status for all DRBs
 797 *                from PDCP at source during HO.
 798 *
 799 */
 800 #ifdef ANSI
 801 PUBLIC S16 PjUlUdxSduStaReq
 802 (
 803 Pst *post,                       /* Post structure */
 804 SpId spId,                      /* Service provider ID */
 805 UdxSduStaReqInfo *pdcpSduStaReq     /* PDCP SDU status request parameters */
 806 )
 807 #else /* ANSI */
 808 PUBLIC S16 PjUlUdxSduStaReq(post, spId, pdcpSduStaReq)
 809 Pst *post;                       /* Post structure */
 810 SpId spId;                      /* Service provider ID */
 811 UdxSduStaReqInfo *pdcpSduStaReq;    /* PDCP SDU status request parameters */
 812 #endif /* ANSI */
 813 {
 814
 815   TRC3(PjUlUdxSduStaReq);
 816
 817   RETVALUE((*PjUlUdxSduStaReqMt[post->selector])(post, spId, pdcpSduStaReq));
 818
 819 } /* end of function PjUlUdxSduStaReq */
 820 \f
 821
 822 /**
 823  *
 824  *      @brief  Sends a Re-establish request to PDCP on UDX interface
 825  *      @details Sends a Re-establish request to PDCP on UDX interface
 826  *
 827  */
 828 #ifdef ANSI
 829 PUBLIC S16 PjUlUdxReEstReq
 830 (
 831 Pst       *post,          /* post structure */
 832 SpId       spId,         /* service provider */
 833 UdxReEstReqInfo *restbInfo     /* Re-establishment Info */
 834 )
 835 #else /* ANSI */
 836 PUBLIC S16 PjUlUdxReEstReq(post, spId, restbInfo)
 837 Pst       *post;              /* post structure */
 838 SpId       spId;             /* service provider */
 839 UdxReEstReqInfo *restbInfo;        /* new UE Id */
 840 #endif /* ANSI */
 841 {
 842   TRC3(PjUlUdxReEstReq);
 843
 844   RETVALUE((*PjUlUdxReEstReqMt[post->selector])(post, spId, restbInfo));
 845
 846 } /* end of function PjUlUdxReEstReq */
 847
 848 #ifdef LTE_L2_MEAS
 849 /**
 850 * @brief Request from ULM to DLM for MeasReq
 851 *
 852 * @details
 853 *
 854 *     Function : PjUlUdxL2MeasReq
 855 *
 856 *  @param[in]   Pst*           pst
 857
 858 *  @return   S16
 859 *      -# ROK
 860 **/
 861 #ifdef ANSI
 862 PUBLIC S16  PjUlUdxL2MeasReq
 863 (
 864 Pst*                pst,
 865 PjL2MeasReqEvt      *measReqEvt
 866 )
 867 #else
 868 PUBLIC S16 PjUlUdxL2MeasReq(pst,measReqEvt)
 869 Pst*                pst;
 870 PjL2MeasReqEvt      *measReqEvt;
 871 #endif
 872 {
 873
 874    TRC3(PjUlUdxStaUpdReq);
 875
 876    RETVALUE((*pjUlUdxL2MeasReqMt[pst->selector])(pst,measReqEvt));
 877 } /* end of PjUlUdxMesReq*/
 878
 879 /**
 880 * @brief Request from ULM to DLM for MeasSendReq
 881 *
 882 * @details
 883 *
 884 *     Function : PjUlUdxMeasSendReq
 885 *
 886 *  @param[in]   Pst*           pst
 887
 888 *  @return   S16
 889 *      -# ROK
 890 **/
 891 #ifdef ANSI
 892 PUBLIC S16  PjUlUdxL2MeasSendReq
 893 (
 894 Pst*                pst,
 895 U8                  measType
 896 )
 897 #else
 898 PUBLIC S16 PjUlUdxL2MeasSendReq(pst,measReqEvt)
 899 Pst*                pst;
 900 U8                  measType;
 901 #endif
 902 {
 903
 904    TRC3(PjUlUdxL2MeasSendReq);
 905
 906    RETVALUE((*pjUlUdxL2MeasSendReqMt[pst->selector])(pst,measType));
 907 } /* end of PjUlUdxMesReq*/
 908
 909 /**
 910 * @brief Request from ULM to DLM for MeasStopReq
 911 *
 912 * @details
 913 *
 914 *     Function : PjUlUdxL2MeasStopReq
 915 *
 916 *  @param[in]   Pst*           pst
 917
 918 *  @return   S16
 919 *      -# ROK
 920 **/
 921 #ifdef ANSI
 922 PUBLIC S16  PjUlUdxL2MeasStopReq
 923 (
 924 Pst*                pst,
 925 U8                  measType
 926 )
 927 #else
 928 PUBLIC S16 PjUlUdxL2MeasStopReq(pst,measReqEvt)
 929 Pst*                pst;
 930 U8                  measType;
 931 #endif
 932 {
 933
 934    TRC3(PjUlUdxL2MeasStopReq);
 935
 936    RETVALUE((*pjUlUdxL2MeasStopReqMt[pst->selector])(pst,measType));
 937 } /* end of PjUlUdxMesReq*/
 938 #endif
 939
 940
 941
 942 /**
 943 * @brief Request from ULM to DLM for MeasStopReq
 944 *
 945 * @details
 946 *
 947 *     Function : PjUlUdxDatResumeReq
 948 *
 949 *  @param[in]   Pst*           pst
 950
 951 *  @return   S16
 952 *      -# ROK
 953 **/
 954 #ifdef ANSI
 955 PUBLIC S16  PjUlUdxDatResumeReq
 956 (
 957 Pst*          pst,
 958 UdxDatResumeInfo  *udxDatResumeInfo
 959 )
 960 #else
 961 PUBLIC S16 PjUlUdxDatResumeReq(pst, udxDatResumeInfo)
 962 Pst*          pst;
 963 UdxDatResumeInfo  *udxDatResumeInfo;
 964 #endif
 965 {
 966
 967    TRC3(PjUlUdxDatResumeReq);
 968
 969    RETVALUE((*pjUlUdxDatResumeReqMt[pst->selector])(pst, udxDatResumeInfo));
 970 } /* end of PjUlUdxMesReq*/
 971
 972
 973 /**
 974 * @brief
 975 *
 976 * @details
 977 *
 978 *     Function : PjUlUdxDatForwardReq
 979 *
 980 *  @param[in]   Pst*           pst
 981
 982 *  @return   S16
 983 *      -# ROK
 984 **/
 985 #ifdef ANSI
 986 PUBLIC S16  PjUlUdxDatForwardReq
 987 (
 988 Pst*          pst,
 989 UdxDatForwardInfo  *udxDatForwardInfo
 990 )
 991 #else
 992 PUBLIC S16 PjUlUdxDatForwardReq(pst, udxDatForwardInfo)
 993 Pst*          pst;
 994 UdxDatForwardInfo  *udxDatForwardInfo;
 995 #endif
 996 {
 997
 998    TRC3(PjUlUdxDatForwardReq);
 999
1000    RETVALUE((*pjUlUdxDatForwardReqMt[pst->selector])(pst, udxDatForwardInfo));
1001 } /* end of PjUlUdxMesReq*/
1002 /**************************************************************************
1003  * The UDX (Portable) Interface
1004  *************************************************************************/
1005 #ifdef PTPJULUDX
1006 /**************************************************************************
1007  *
1008  *      Fun:   PtUlUdxBndReq
1009  *
1010  *      Desc:  Portable UdxBndReq primitive
1011  *
1012  *      Ret:   ROK
1013  *
1014  *      Notes:
1015  *
1016  *      File:  nh_ptli.c
1017  *
1018  *************************************************************************/
1019 #ifdef ANSI
1020 PRIVATE S16 PtUlUdxBndReq
1021 (
1022 Pst *post,                      /* Post structure */
1023 SuId suId,                      /* Service user ID */
1024 SpId spId                       /* Service provider ID */
1025 )
1026 #else /* ANSI */
1027 PRIVATE S16 PtUlUdxBndReq(post, suId, spId)
1028 Pst *post;                      /* Post structure */
1029 SuId suId;                      /* Service user ID */
1030 SpId spId;                      /* Service provider ID */
1031 #endif /* ANSI */
1032 {
1033
1034    TRC3(PtUlUdxBndReq);
1035
1036    UNUSED(post);
1037    UNUSED(suId);
1038    UNUSED(spId);
1039
1040    RETVALUE(ROK);
1041
1042 } /* end of function PtUlUdxBndReq */
1043
1044 \f
1045 /**************************************************************************
1046 *
1047 *      Fun:   PtUlUdxUbndReq
1048 *
1049 *      Desc:  Portable UdxUbndReq primitive
1050 *
1051 *      Ret:   ROK
1052 *
1053 *      Notes:
1054 *
1055 *      File:  nh_ptli.c
1056 *
1057 *************************************************************************/
1058 #ifdef ANSI
1059 PRIVATE S16 PtUlUdxUbndReq
1060 (
1061 Pst *post,                      /* Post structure */
1062 SpId spId,                      /* Service provider ID */
1063 Reason reason                   /* Reason */
1064 )
1065 #else /* ANSI */
1066 PRIVATE S16 PtUlUdxUbndReq(post, spId, reason)
1067 Pst *post;                      /* Post structure */
1068 SpId spId;                      /* Service provider ID */
1069 Reason reason;                  /* Reason */
1070 #endif /* ANSI */
1071 {
1072
1073    TRC3(PtUlUdxUbndReq);
1074
1075    UNUSED(post);
1076    UNUSED(spId);
1077    UNUSED(reason);
1078
1079    RETVALUE(ROK);
1080
1081 } /* end of function PtUlUdxUbndReq */
1082
1083 \f
1084 /**************************************************************************
1085 *
1086 *      Fun:   PtUlUdxCfgReq
1087 *
1088 *      Desc:  Portable UdxCfgReq primitive
1089 *
1090 *      Ret:   ROK
1091 *
1092 *      Notes:
1093 *
1094 *      File:  nh_ptli.c
1095 *
1096 *************************************************************************/
1097 #ifdef ANSI
1098 PRIVATE S16 PtUlUdxCfgReq
1099 (
1100 Pst *post,                      /* Post structure */
1101 SpId spId,                      /* Service provider ID */
1102 UdxCfgReqInfo *pdCfgReq         /* PDCP Config parameters */
1103 )
1104 #else /* ANSI */
1105 PRIVATE S16 PtUlUdxCfgReq(post, spId, pdCfgReq)
1106 Pst *post;                      /* Post structure */
1107 SpId spId;                      /* Service provider ID */
1108 UdxCfgReqInfo *pdCfgReq;        /* PDCP Config parameters */
1109 #endif /* ANSI */
1110 {
1111
1112    TRC3(PtUlUdxCfgReq);
1113
1114    UNUSED(post);
1115    UNUSED(spId);
1116    UNUSED(pdCfgReq);
1117
1118
1119    RETVALUE(ROK);
1120
1121 } /* end of function PtUlUdxCfgReq */
1122
1123 /**************************************************************************
1124 *
1125 *      Fun:   PtUlUdxUlStaRep
1126 *
1127 *      Desc:  Portable UdxUlStaRep primitive
1128 *
1129 *      Ret:   ROK
1130 *
1131 *      Notes:
1132 *
1133 *      File:  pj_udx_ptul.c
1134 *
1135 *************************************************************************/
1136 #ifdef ANSI
1137 PRIVATE S16 PtUlUdxUlStaRep
1138 (
1139 Pst *post,                      /* Post structure */
1140 SpId spId,                      /* Service provider ID */
1141 UdxUlStaRepInfo *pdStaRep         /* PDCP UL ot PDCP DL Reestablishment trigger */
1142 )
1143 #else /* ANSI */
1144 PRIVATE S16 PtUlUdxUlStaRep(post, spId, pdStaRep)
1145 Pst *post;                      /* Post structure */
1146 SpId spId;                      /* Service provider ID */
1147 UdxUlStaRepInfo *pdStaRep;        /* PDCP UL ot PDCP DL Reestablishment trigger */
1148 #endif /* ANSI */
1149 {
1150
1151    TRC3(PtUlUdxUlStaRep);
1152
1153    UNUSED(post);
1154    UNUSED(spId);
1155    UNUSED(pdStaRep);
1156
1157
1158    RETVALUE(ROK);
1159
1160 } /* end of function  */
1161
1162 /**************************************************************************
1163 *
1164 *      Fun:   PtUlUdxUlStaRep
1165 *
1166 *      Desc:  Portable UdxUlStaRep primitive
1167 *
1168 *      Ret:   ROK
1169 *
1170 *      Notes:
1171 *
1172 *      File:  pj_udx_ptul.c
1173 *
1174 *************************************************************************/
1175 #ifdef ANSI
1176 PRIVATE S16 PtUlUdxDlStaRep
1177 (
1178 Pst *post,                      /* Post structure */
1179 SpId spId,                      /* Service provider ID */
1180 UdxDlStaRepInfo *pdStaRep       /* Status report from PDCP UL to PDCP DL */
1181 )
1182 #else /* ANSI */
1183 PRIVATE S16 PtUlUdxDlStaRep(post, spId, pdStaRep)
1184 Pst *post;                      /* Post structure */
1185 SpId spId;                      /* Service provider ID */
1186 UdxDlStaRepInfo *pdStaRep;      /* Status report from PDCP UL to PDCP DL */
1187 #endif /* ANSI */
1188 {
1189
1190    TRC3(PtUlUdxDlStaRep);
1191
1192    UNUSED(post);
1193    UNUSED(spId);
1194    UNUSED(pdStaRep);
1195
1196
1197    RETVALUE(ROK);
1198
1199 } /* end of function  */
1200
1201
1202 /**************************************************************************
1203  *
1204  *      Fun:   PtUlUdxUeIdChgReq
1205  *
1206  *      Desc:  Portable UdxUeIdChgReq primitive
1207  *
1208  *      Ret:   ROK
1209  *
1210  *      Notes:
1211  *
1212  *      File:  nh_ptli.c
1213  *
1214  *************************************************************************/
1215 #ifdef ANSI
1216 PRIVATE S16 PtUlUdxUeIdChgReq
1217 (
1218 Pst       *post,           /* post structure */
1219 SpId      spId,            /* service provider */
1220 U32       transId,         /* TransId */
1221 UdxUeInfo *oldUeInfo,      /* current UE Id */
1222 UdxUeInfo *newUeInfo       /* new UE Id */
1223 )
1224 #else /* ANSI */
1225 PRIVATE S16 PtUlUdxUeIdChgReq(post, spId, transId, oldUeInfo, newUeInfo)
1226 Pst       *post;           /* post structure */
1227 SpId       spId;           /* service provider */
1228 U32        transId;        /* TransId */
1229 UdxUeInfo *oldUeInfo;      /* current UE Id */
1230 UdxUeInfo *newUeInfo;      /* new UE Id */
1231 #endif /* ANSI */
1232 {
1233   TRC3(PtUlUdxUeIdChgReq);
1234
1235   UNUSED(post);
1236   UNUSED(spId);
1237   UNUSED(transId);
1238   UNUSED(oldUeInfo);
1239   UNUSED(newUeInfo);
1240
1241   RETVALUE(ROK);
1242
1243 } /* end of function PtUlCkwUeIdChgReq */
1244
1245 /**************************************************************************
1246  *
1247  *      Fun:   PtUlUdxSecCfgReq
1248  *
1249  *      Desc:  Portable UdxSecCfgReq primitive
1250  *
1251  *      Ret:   ROK
1252  *
1253  *      Notes:
1254  *
1255  *      File:  nh_ptli.c
1256  *
1257  *************************************************************************/
1258 #ifdef ANSI
1259 PRIVATE S16 PtUlUdxSecCfgReq
1260 (
1261 Pst       *post,                  /* post structure */
1262 SpId      spId,                   /* service provider */
1263 UdxSecCfgReqInfo *secCfgReq       /* PDCP Security Config paramters */
1264 )
1265 #else /* ANSI */
1266 PRIVATE S16 PtUlUdxSecCfgReq(post, spId, secCfgReq)
1267 Pst       *post;                  /* post structure */
1268 SpId       spId;                  /* service provider */
1269 UdxSecCfgReqInfo *secCfgReq;      /* PDCP Security Config paramters */
1270 #endif /* ANSI */
1271 {
1272   TRC3(PtUlUdxSecCfgReq);
1273
1274   UNUSED(post);
1275   UNUSED(spId);
1276   UNUSED(secCfgReq);
1277
1278   RETVALUE(ROK);
1279
1280 } /* end of function PtUlUdxSecCfgReq */
1281
1282 /**************************************************************************
1283  *
1284  *      Fun:   PtUlUdxCountReq
1285  *
1286  *      Desc:  Portable UdxCountReq primitive
1287  *
1288  *      Ret:   ROK
1289  *
1290  *      Notes:
1291  *
1292  *      File:  nh_ptli.c
1293  *
1294  *************************************************************************/
1295 #ifdef ANSI
1296 PRIVATE S16 PtUlUdxCountReq
1297 (
1298 Pst       *post,                /* post structure */
1299 SpId      spId,                 /* service provider */
1300 UdxCountReqInfo *countReq       /* PDCP Security Config paramters */
1301 )
1302 #else /* ANSI */
1303 PRIVATE S16 PtUlUdxCountReq(post, spId, countReq)
1304 Pst       *post;                /* post structure */
1305 SpId       spId;                /* service provider */
1306 UdxCountReqInfo *countReq;      /* Count value paramters */
1307 #endif /* ANSI */
1308 {
1309   TRC3(PtUlUdxCountReq);
1310
1311   UNUSED(post);
1312   UNUSED(spId);
1313   UNUSED(countReq);
1314
1315   RETVALUE(ROK);
1316
1317 } /* end of function PtUlUdxCountReq */
1318
1319 /**************************************************************************
1320  *
1321  *      Fun:   PtUlUdxSduStaReq
1322  *
1323  *      Desc:  Portable UdxSduStaReq primitive
1324  *
1325  *      Ret:   ROK
1326  *
1327  *      Notes:
1328  *
1329  *      File:  nh_ptli.c
1330  *
1331  *************************************************************************/
1332 #ifdef ANSI
1333 PRIVATE S16 PtUlUdxSduStaReq
1334 (
1335 Pst          *post,               /* post structure */
1336 SpId         spId,                /* service provider */
1337 UdxSduStaReqInfo *sduStaReq       /* PDCP SDU status parameters */
1338 )
1339 #else /* ANSI */
1340 PRIVATE S16 PtUlUdxSduStaReq(post, spId, sduStaReq)
1341 Pst          *post;               /* post structure */
1342 SpId         spId;                /* service provider */
1343 UdxSduStaReqInfo *sduStaReq;      /* PDCP SDU status parameters */
1344 #endif /* ANSI */
1345 {
1346   TRC3(PtUlUdxSduStaReq);
1347
1348   UNUSED(post);
1349   UNUSED(spId);
1350   UNUSED(sduStaReq);
1351
1352
1353   RETVALUE(ROK);
1354
1355 } /* end of function PtUlUdxSduStaReq */
1356 \f
1357
1358 /**************************************************************************
1359  *
1360  *      Fun:   PtUlUdxReEstReq
1361  *
1362  *      Desc:  Portable UdxReEstReq primitive
1363  *
1364  *      Ret:   ROK
1365  *
1366  *      Notes:
1367  *
1368  *      File:  nh_ptli.c
1369  *
1370  *************************************************************************/
1371 #ifdef ANSI
1372 PRIVATE S16 PtUlUdxReEstReq
1373 (
1374 Pst       *post,                 /* post structure */
1375 SpId      spId,                  /* service provider */
1376 UdxReEstReqInfo *restbInfo       /* PDCP Re-establishment Config paramters */
1377 )
1378 #else /* ANSI */
1379 PRIVATE S16 PtUlUdxReEstReq(post, spId, restbInfo)
1380 Pst       *post;                 /* post structure */
1381 SpId       spId;                 /* service provider */
1382 UdxReEstReqInfo *restbInfo;      /* PDCP Re-establishment Config paramters */
1383 #endif /* ANSI */
1384 {
1385   TRC3(PtUlUdxReEstReq);
1386
1387   UNUSED(post);
1388   UNUSED(spId);
1389   UNUSED(restbInfo);
1390
1391   RETVALUE(ROK);
1392
1393 } /* end of function PtUlUdxReEstReq */
1394 /**************************************************************************
1395  *
1396  *      Fun:   PtUlUdxUlFdbkPktInfo
1397  *
1398  *      Desc:  Portable PtUlUdxUlFdbkPktInfo primitive
1399  *
1400  *      Ret:   ROK
1401  *
1402  *      Notes:
1403   *
1404  *      File :  nh_ptli.c
1405  *
1406  *************************************************************************/
1407 #ifdef ANSI
1408 PRIVATE S16 PtUlUdxUlFdbkPktInfo
1409 (
1410 Pst          *post,               /* post structure */
1411 SpId         spId,                /* service provider */
1412 UdxUlFdbkPktInfo  *fdbkPktInfo    /* feedback Packet Info */
1413 )
1414 #else /* ANSI */
1415 PRIVATE S16 PtUlUdxUlFdbkPktInfo(post, spId, fdbkPktInfo)
1416 Pst          *post;               /* post structure */
1417 SpId         spId;                /* service provider */
1418 UdxUlFdbkPktInfo  *fdbkPktInfo    /* feedback Packet Info */
1419 #endif /* ANSI */
1420 {
1421     TRC3(PtUlUdxUlFdbkPktInfo);
1422
1423     UNUSED(post);
1424     UNUSED(spId);
1425     UNUSED(fdbkPktInfo);
1426
1427
1428     RETVALUE(ROK);
1429
1430 } /* end of function PtUlUdxUlFdbkPktInfo */
1431
1432
1433 /**************************************************************************
1434  *
1435  *      Fun:   PtUlUdxDlFdbkPktInfo
1436  *
1437  *      Desc:  Portable PtUlUdxDlFdbkPktInfo primitive
1438  *
1439  *      Ret:   ROK
1440  *
1441  *      Notes:
1442   *
1443  *      File :  nh_ptli.c
1444  *
1445  *************************************************************************/
1446 #ifdef ANSI
1447 PRIVATE S16 PtUlUdxDlFdbkPktInfo
1448 (
1449 Pst          *post,               /* post structure */
1450 SpId         spId,                /* service provider */
1451 UdxDlFdbkPktInfo  *fdbkPktInfo    /* feedback Packet Info */
1452 )
1453 #else /* ANSI */
1454 PRIVATE S16 PtUlUdxDlFdbkPktInfo(post, spId, fdbkPktInfo)
1455 Pst          *post;               /* post structure */
1456 SpId         spId;                /* service provider */
1457 UdxDlFdbkPktInfo  *fdbkPktInfo    /* feedback Packet Info */
1458 #endif /* ANSI */
1459 {
1460     TRC3(PtUlUdxDlFdbkPktInfo);
1461
1462     UNUSED(post);
1463     UNUSED(spId);
1464     UNUSED(fdbkPktInfo);
1465
1466
1467     RETVALUE(ROK);
1468
1469 } /* end of function PtUlUdxDlFdbkPktInfo */
1470
1471
1472
1473
1474 #ifdef LTE_L2_MEAS
1475 /**
1476 * @brief Request from ULM to DLM for Measurement
1477 *
1478 * @details
1479 *
1480 *     Function : PjUdxUdxL2MeasReq
1481 *
1482 *  @param[in]   Pst*           pst
1483
1484 *  @return   S16
1485 *      -# ROK
1486 **/
1487 #ifdef ANSI
1488 PRIVATE S16  PtUlUdxL2MeasReq
1489 (
1490 Pst*                pst,
1491 PjL2MeasReqEvt      *measReqEvt
1492 )
1493 #else
1494 PRIVATE S16 PtUlUdxL2MeasReq(pst, measReqEvt )
1495 Pst*                pst;
1496 PjL2MeasReqEvt      *measReqEvt;
1497 #endif
1498 {
1499
1500    TRC3(PtUlUdxL2MeasReq);
1501
1502    RETVALUE(ROK);
1503 }
1504
1505 /**
1506 * @brief Request from ULM to DLM for Measurement
1507 *
1508 * @details
1509 *
1510 *     Function : PjUdxUdxL2MeasSendReq
1511 *
1512 *  @param[in]   Pst*           pst
1513
1514 *  @return   S16
1515 *      -# ROK
1516 **/
1517 #ifdef ANSI
1518 PRIVATE S16  PtUlUdxL2MeasSendReq
1519 (
1520 Pst*                pst,
1521 U8                  status
1522 )
1523 #else
1524 PRIVATE S16 PtUlUdxL2MeasSendReq(pst, status )
1525 Pst*                pst;
1526 U8                  status
1527 #endif
1528 {
1529
1530    TRC3(PtUlUdxL2MeasSendReq);
1531
1532    RETVALUE(ROK);
1533 }
1534
1535 /**
1536 * @brief Request from ULM to DLM for Measurement
1537 *
1538 * @details
1539 *
1540 *     Function : PjUdxUdxL2MeasStopReq
1541 *
1542 *  @param[in]   Pst*           pst
1543
1544 *  @return   S16
1545 *      -# ROK
1546 **/
1547 #ifdef ANSI
1548 PRIVATE S16  PtUlUdxL2MeasStopReq
1549 (
1550 Pst*                pst,
1551 U8                  status
1552 )
1553 #else
1554 PRIVATE S16 PtUlUdxL2MeasStopReq(pst, status )
1555 Pst*                pst;
1556 U8                  status
1557 #endif
1558 {
1559
1560    TRC3(PtUlUdxL2MeasStopReq);
1561
1562    RETVALUE(ROK);
1563 }
1564 #endif
1565 /**
1566 * @brief Request from ULM to DLM for ResumeReq
1567 *
1568 * @details
1569 *
1570 *     Function : PtUlUdxDatResumeReq
1571 *
1572 *  @param[in]   Pst*           pst
1573
1574 *  @return   S16
1575 *      -# ROK
1576 **/
1577 #ifdef ANSI
1578 PRIVATE S16  PtUlUdxDatResumeReq
1579 (
1580 Pst*          pst,
1581 UdxDatResumeInfo  *udxDatResumeInfo
1582 )
1583 #else
1584 PRIVATE S16 PtUlUdxDatResumeReq(pst, udxDatResumeInfo )
1585 Pst*          pst;
1586 UdxDatResumeInfo  *udxDatResumeInfo;
1587 #endif
1588 {
1589
1590    TRC3(PtUlUdxDatResumeReq);
1591
1592    RETVALUE(ROK);
1593 }
1594
1595 /**
1596 * @brief
1597 *
1598 * @details
1599 *
1600 *     Function : PtUlUdxDatForwardReq
1601 *
1602 *  @param[in]   Pst*           pst
1603
1604 *  @return   S16
1605 *      -# ROK
1606 **/
1607 #ifdef ANSI
1608 PRIVATE S16  PtUlUdxDatForwardReq
1609 (
1610 Pst*          pst,
1611 UdxDatForwardInfo  *udxDatForwardInfo
1612 )
1613 #else
1614 PRIVATE S16 PtUlUdxDatForwardReq(pst, udxDatForwardInfo )
1615 Pst*          pst;
1616 UdxDatForwardInfo  *udxDatForwardInfo;
1617 #endif
1618 {
1619
1620    TRC3(PtUlUdxDatForwardReq);
1621
1622    RETVALUE(ROK);
1623 }
1624
1625 #endif /* #ifdef PTPJULUDX */
1626
1627 #ifdef __cplusplus
1628 }
1629 #endif /* __cplusplus */
1630 /********************************************************************30**
1631          End of file
1632 **********************************************************************/