src/5gnrrlc/kw_ptli.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-RLC Layer - Lower Interface
  22
  23         Type:    C file
  24
  25         Desc:    C source code for the lower interface of LTE-RLC
  26
  27         File:    kw_ptli.c
  28
  29 *********************************************************************21*/
  30 static const char* RLOG_MODULE_NAME="LIM";
  31 static int RLOG_MODULE_ID=2048;
  32 static int RLOG_FILE_ID=238;
  33 /** @file kw_ptli.c
  34 @brief RLC Lower Interface
  35 */
  36
  37 \f
  38 /* header (.h) include files */
  39 #include "envopt.h"        /* environment options */
  40 #include "envdep.h"        /* environment dependent */
  41 #include "envind.h"        /* environment independent */
  42
  43 #include "gen.h"           /* general */
  44 #include "ssi.h"           /* system services */
  45 #include "cm5.h"           /* common timer defines */
  46 #include "cm_tkns.h"       /* common tokens defines */
  47 #include "cm_mblk.h"       /* common memory allocation library defines */
  48 #include "cm_llist.h"      /* common link list  defines  */
  49 #include "cm_hash.h"       /* common hash list  defines */
  50 #include "cm_lte.h"        /* common LTE defines */
  51 #include "lkw.h"           /* LKW defines */
  52 #include "ckw.h"           /* CKW defines */
  53 #include "kwu.h"           /* KWU defines */
  54 #include "rgu.h"           /* RGU defines */
  55 #ifdef KW_PDCP
  56 #include "cpj.h"           /* CPJ defines */
  57 #include "pju.h"           /* PJU defines */
  58 #include "lpj.h"           /* LPJ defines */
  59 #endif
  60 #include "kw_err.h"
  61 #include "kw_env.h"        /* RLC environment options */
  62 #include "kw.h"            /* RLC defines */
  63
  64 /* extern (.x) include files */
  65 #include "gen.x"           /* general */
  66 #include "ssi.x"           /* system services */
  67
  68 #include "cm5.x"           /* common timer library */
  69 #include "cm_tkns.x"       /* common tokens */
  70 #include "cm_mblk.x"       /* common memory allocation */
  71 #include "cm_llist.x"      /* common link list */
  72 #include "cm_hash.x"       /* common hash list */
  73 #include "cm_lte.x"        /* common LTE includes */
  74 #include "cm_lib.x"        /* common memory allocation library */
  75 #include "lkw.x"           /* LKW */
  76 #include "ckw.x"           /* CKW */
  77 #include "kwu.x"           /* KWU */
  78 #include "rgu.x"           /* RGU */
  79 #ifdef KW_PDCP
  80 #include "cpj.x"           /* CPJ defines */
  81 #include "pju.x"           /* PJU defines */
  82 #include "lpj.x"           /* LPJ defines */
  83 #endif
  84 #include "kw.x"
  85 #include "ss_rbuf.h"
  86 #include "ss_rbuf.x"
  87
  88 #ifndef LCKWLIRGU
  89 #define PTKWRGU
  90 #endif
  91
  92 #ifndef RG
  93 #define PTKWRGU
  94 #endif
  95
  96 #ifdef __cplusplus
  97 EXTERN "C" {
  98 #endif /* __cplusplus */
  99
 100
 101
 102 #ifdef RLC_MAC_DAT_REQ_RBUF
 103 PUBLIC S16 kwLiRguDatReqRbuf(Pst *Post,SpId spId,Void *datReq);
 104 #endif
 105
 106 #ifdef RLC_MAC_STA_RSP_RBUF
 107 PUBLIC S16 kwLiRguStaRspRbuf(Pst *Post,SpId spId,Void  *staRsp);
 108 #endif
 109 #if defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS)
 110 EXTERN S16 KwDlHarqStaBatchProc (Void);
 111 #endif
 112
 113 \f
 114 /*********************************************************************
 115  *             Primitives for RGU interface
 116  ********************************************************************/
 117
 118 /* RGU Bind Request primitive */
 119
 120 PUBLIC RguBndReq kwLiRguBndReqMt[] =
 121 {
 122 #ifdef LCKWLIRGU
 123    cmPkRguBndReq,            /* 0 - loosely coupled */
 124 #endif /* LCRGUIRGU */
 125 #ifdef RG
 126    RgUiRguBndReq,            /* 1 - tightly coupled, MAC  */
 127 #endif /* RG */
 128 #ifdef LCKWLIRGU
 129    cmPkRguBndReq,            /* 0 - loosely coupled */
 130 #endif /* LCRGUIRGU */
 131 };
 132
 133 /* RGU Unbind Request primitive */
 134
 135 PUBLIC RguBndReq kwLiRguUbndReqMt[] =
 136 {
 137 #ifdef LCKWLIRGU
 138    cmPkRguUbndReq,            /* 0 - loosely coupled */
 139 #endif /* LCRGUIRGU */
 140 #ifdef RG
 141    RgUiRguUbndReq,            /* 1 - tightly coupled, MAC  */
 142 #endif /* RG */
 143 #ifdef LCKWLIRGU
 144    cmPkRguUbndReq,            /* 0 - loosely coupled */
 145 #endif /* LCRGUIRGU */
 146 };
 147
 148 /* RGU Dedicated Channel Data Request primitive */
 149
 150 PUBLIC RguDDatReq rlcMacSendDlDataOpts[] =
 151 {
 152 #ifdef LCKWLIRGU
 153    packDlData,            /* 0 - loosely coupled */
 154 #endif /* LCRGUIRGU */
 155 #ifdef RG
 156    RgUiRguDDatReq,            /* 1 - tightly coupled, MAC  */
 157 #endif /* RG */
 158 #ifdef LCKWLIRGU
 159    packDlData,            /* 0 - loosely coupled */
 160 #endif /* LCRGUIRGU */
 161 };
 162
 163
 164 /* RLC logical Channel Status primitive */
 165
 166 PUBLIC RguDStaRsp rlcMacSendBOStatusOpts[] =
 167 {
 168 #ifdef LCKWLIRGU
 169    packBOStatus,            /* 0 - loosely coupled */
 170 #endif /* LCRGUIRGU */
 171 #ifdef RG
 172    RgUiRguDStaRsp,            /* 1 - tightly coupled, MAC  */
 173 #endif /* RG */
 174 #ifdef LCKWLIRGU
 175    packBOStatus,            /* 0 - LWLC loosely coupled */
 176 #endif /* LCRGUIRGU */
 177 };
 178
 179 /* kw005.201 added support for L2 Measurement */
 180 #ifdef LTE_L2_MEAS
 181 #ifdef LTE_RLC_R9
 182 /* RGU L2 Measurement Ul Ip Throughput Measurement Request primitive */
 183
 184 PUBLIC RguL2MUlThrpMeasReq kwLiRguL2MUlThrpMeasReqMt[] =
 185 {
 186 #ifdef LCKWLIRGU
 187    cmPkRguL2MUlThrpMeasReq,            /* 0 - loosely coupled */
 188 #endif /* LCRGUIRGU */
 189 #ifdef RG
 190    RgUiRguL2MUlThrpMeasReq,            /* 1 - tightly coupled, MAC  */
 191 #endif /* RG */
 192 };
 193 #endif /* LTE_RLC_R9 */
 194 #endif /*  LTE_L2_MEAS */
 195 \f
 196 /****************************************************************************
 197  *                         RGU Interface Mt functions
 198  ***************************************************************************/
 199 /**
 200  *
 201  * @brief
 202  *
 203  *        Handler for RGU SAP bind Request.
 204  *
 205  * @b Description:
 206  *
 207  *        This function is used by RLC to request for binding to
 208  *        MAC for accessing MAC services.This function binds MAC's
 209  *        SAP (identified by spId) with the service user's SAP
 210  *        (identified by suId).
 211  *
 212  *  @param[in] pst   Post structure
 213  *  @param[in] suId  Service user SAP ID
 214  *  @param[in] spId  Service provider ID
 215  *
 216  *  @return  S16
 217  *      -# ROK
 218  */
 219
 220 #ifdef ANSI
 221 PUBLIC S16 KwLiRguBndReq
 222 (
 223 Pst  *post,                       /* post structure */
 224 SuId suId,                      /* Service User Id */
 225 SpId spId                       /* Service Provider Id */
 226 )
 227 #else
 228 PUBLIC S16 KwLiRguBndReq(post, suId, spId)
 229 Pst  *post;                       /* post structure */
 230 SuId suId;                      /* Service User Id */
 231 SpId spId;                      /* Service Provider Id */
 232 #endif
 233 {
 234    TRC3(KwLiRguBndReq)
 235
 236    /* jump to specific primitive depending on configured selector */
 237    (*kwLiRguBndReqMt[post->selector])(post, suId, spId);
 238
 239    RETVALUE(ROK);
 240
 241 } /* end of KwLiRguBndReq */
 242
 243 \f
 244 /**
 245  *
 246  * @brief
 247  *
 248  *        Handler for bind confirmation from MAC.
 249  *
 250  * @b Description:
 251  *
 252  *        This function handles the bind confirmation received
 253  *        from MAC.
 254  *
 255  *  @param[in] post     - Post structure
 256  *  @param[in] suId    - Service provider SAP ID
 257  *  @param[in] reason  - Reason of confirmation
 258  *
 259  *  @return  S16
 260  *      -# ROK
 261  */
 262
 263 #ifdef ANSI
 264 PUBLIC S16 KwLiRguUbndReq
 265 (
 266 Pst         *post,
 267 SpId        spId,
 268 Reason      reason
 269 )
 270 #else
 271 PUBLIC S16 KwLiRguUbndReq(post, spId, reason)
 272 Pst         *post;
 273 SpId        spId;
 274 Reason      reason;
 275 #endif
 276 {
 277    TRC3(KwLiRguUbndReq)
 278
 279    /* jump to specific primitive depending on configured selector */
 280    (*kwLiRguUbndReqMt[post->selector])(post, spId, reason);
 281
 282    RETVALUE(ROK);
 283
 284 } /* end of KwLiRguUbndReq */
 285
 286 \f
 287 /**
 288  *
 289  * @brief
 290  *
 291  *        Handler for sending PDU(s) from RLC to MAC for dedicated logical channels.
 292  *
 293  * @b Description:
 294  *
 295  *        This function sends PDU(s) to MAC via one or more dedicated
 296  *        logical channels along with the Buffer Occupancy of these
 297  *        channels.
 298  *
 299  *  @param[in] post         Post structure
 300  *  @param[in] spId        Service Provider ID
 301  *  @param[in] datIndInfo  Data Request Information
 302  *
 303  *  @return  S16
 304  *      -# ROK
 305  *      -# RFAILED
 306  *
 307  */
 308 #ifdef ANSI
 309 PUBLIC S16 RlcMacSendDlData
 310 (
 311 Pst               *post,
 312 SpId              spId,
 313 RlcMacData       *dlData
 314 )
 315 #else
 316 PUBLIC S16 RlcMacSendDlData(post, spId, dlData)
 317 Pst               *post;
 318 SpId              spId;
 319 RlcMacData        *dlData;
 320 #endif
 321 {
 322    TRC3(RlcMacSendDlData)
 323 #ifdef RLC_MAC_DAT_REQ_RBUF
 324         post->event=EVTRGUDDATREQ;
 325       if((kwLiRguDatReqRbuf(post, spId, datReq)) != ROK)
 326       {
 327
 328       SPutStaticBuffer(post->region, post->pool,
 329                       (Data *) datReq, sizeof(RguDDatReqInfo), 0);
 330          RETVALUE(RFAILED);
 331       }
 332 #else
 333    /* jump to specific primitive depending on configured selector */
 334    (*rlcMacSendDlDataOpts[post->selector])(post, spId, dlData);
 335 #endif
 336    RETVALUE(ROK);
 337
 338 } /* end of KwLiRguDDatReq */
 339
 340
 341 \f
 342 /**
 343  *
 344  * @brief
 345  *
 346  *        Handler for reporting the Buffer Occupancy to MAC
 347  *        for logical channels.
 348  *
 349  * @b Description:
 350  *
 351  *        This function reports the Buffer Occupancy of one or more
 352  *         logical channels to MAC.
 353  *
 354  *  @param[in] post         Post structure
 355  *  @param[in] spId        Service Provider ID
 356  *  @param[in] boSta       BO Status Information
 357  *
 358  *  @return  S16
 359  *      -# ROK
 360  *      -# RFAILED
 361  *
 362  */
 363 #ifdef ANSI
 364 PUBLIC S16 RlcMacSendBOStatus
 365 (
 366 Pst               *post,
 367 SpId              spId,
 368 RlcMacBOStatus    *boSta
 369 )
 370 #else
 371 PUBLIC S16 RlcMacSendBOStatus(post, spId, staRsp)
 372 Pst               *post;
 373 SpId              spId;
 374 RlcMacBOStatus    *boSta;
 375 #endif
 376 {
 377    TRC3(RlcMacSendBOStatus)
 378 #if defined(SPLIT_RLC_DL_TASK) && defined(RLC_MAC_STA_RSP_RBUF)
 379        post->event= EVTRGUDSTARSP;
 380       if((kwLiRguStaRspRbuf(post, spId, staRsp)) != ROK)
 381       {
 382          RETVALUE(RFAILED);
 383       }
 384 #endif
 385    /* jump to specific primitive depending on configured selector */
 386    (*rlcMacSendBOStatusOpts[post->selector])(post, spId, boSta);
 387
 388    RETVALUE(ROK);
 389
 390 } /* end of RlcMacSendBOStatus */
 391
 392
 393 /* kw005.201 added support for L2 Measurement */
 394 #ifdef LTE_L2_MEAS
 395 #ifdef LTE_RLC_R9
 396 \f
 397 /**
 398  *
 399  * @brief
 400  *
 401  *        Handler for sending ulThrpMeasReqInfo from RLC to MAC for UL ip throughput measurement.
 402  *
 403  * @b Description:
 404  *
 405  *        This function sends ulThrpMeasReqInfo from RLC to MAC whenver UL ip throughput
 406  * measurement is ON for a single or multiple qci in a UE. This is an indication for MAC
 407  * to start the T2/T1 time stamps for the coresponding LCHs in the UE.
 408  *
 409  *  @param[in] post                    Post structure
 410  *  @param[in] spId                   Service Provider ID
 411  *  @param[in] ulThrpMeasReqInfo      Ul ip measurement request info
 412  *
 413  *  @return  S16
 414  *      -# ROK
 415  *      -# RFAILED
 416  *
 417  */
 418 #ifdef ANSI
 419 PUBLIC S16 KwLiRguL2MUlThrpMeasReq
 420 (
 421 Pst                     *post,
 422 SpId                    spId,
 423 RguL2MUlThrpMeasReqInfo *l2mUlThrpMeasReq
 424 )
 425 #else
 426 PUBLIC S16 KwLiRguL2MUlThrpMeasReq(post, spId, l2mUlThrpMeasReq)
 427 Pst                     *post;
 428 SpId                    spId;
 429 RguL2MUlThrpMeasReqInfo *l2mUlThrpMeasReq;
 430 #endif
 431 {
 432    TRC3(KwLiRguL2MUlThrpMeasReq)
 433
 434    /* jump to specific primitive depending on configured selector */
 435    (*kwLiRguL2MUlThrpMeasReqMt[post->selector])(post, spId, l2mUlThrpMeasReq);
 436
 437    RETVALUE(ROK);
 438
 439 } /* end of KwLiRguL2MUlThrpMeasReq */
 440
 441 #endif /* LTE_RLC_R9 */
 442 #endif /* LTE_L2_MEAS */
 443
 444
 445 #ifdef MAC_RLC_UL_RBUF
 446 PUBLIC S16 kwUlBatchProc ARGS ((Void));
 447 EXTERN Void kwUtlFreeUlRBuf ARGS((void));
 448
 449 #ifdef ANSI
 450 PUBLIC S16 kwUlBatchProc
 451 (
 452 Void
 453 )
 454 #else
 455 PUBLIC S16 kwUlBatchProc()
 456 Void;
 457 #endif
 458 {
 459 /* Read from Ring Buffer and process PDCP packets */
 460    RguDDatIndInfo   *datInd;
 461    Void *elmIndx = NULLP;
 462    PRIVATE Pst rlcUlRbfuPst={1,1,ENTKW,0,ENTRG,0,PRIOR0,RTESPEC,EVTRLCULDAT,0,0,0,0};
 463 /* Read from Ring Buffer and process PDCP packets */
 464
 465 #ifndef SS_RBUF
 466    RguDedDatInd1 *rguDatInd = NULLP;
 467    U8 rngBufDeqIndx = 0;
 468
 469    elmIndx = SRngGetRIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
 470    while(NULLP != elmIndx)
 471    {
 472       rguDatInd = (RguDedDatInd1 *)elmIndx;
 473       datInd = (RguDDatIndInfo*) rguDatInd->msg;
 474       SsRngInfoTbl[SS_RNG_BUF_ULMAC_TO_ULRLC].nPktProc++;;//Number of pkt processed in tti
 475       if(datInd != NULLP)
 476       {
 477          KwLiRguDDatInd(&rlcUlRbfuPst, 0, datInd);
 478       }
 479       else
 480       {
 481          RLOG0(L_ERROR,"Received NULL buffer");
 482       }
 483       rguDatInd->msg=NULLP;
 484       SRngIncrRIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
 485       elmIndx = NULLP;
 486       rguDatInd = NULLP;
 487
 488       rngBufDeqIndx++;
 489
 490       //if(rngBufDeqIndx >= SS_RNG_MAX_ULMAC_TO_ULRLC_DQ_CNT)
 491        // break;
 492
 493       if((elmIndx = SRngGetRIndx(SS_RNG_BUF_ULMAC_TO_ULRLC)) == NULLP)
 494       break;
 495    }
 496 #else
 497    elmIndx = SRngGetRIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
 498    while(NULLP != elmIndx)
 499    {
 500       datInd = (RguDDatIndInfo *)elmIndx;
 501       KwLiRguDDatInd(&rlcUlRbfuPst, 0, datInd);
 502
 503       elmIndx = NULLP;
 504       datInd = NULLP;
 505       SRngIncrRIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
 506
 507       if((elmIndx = SRngGetRIndx(SS_RNG_BUF_ULMAC_TO_ULRLC)) == NULLP)
 508         break;
 509    }
 510 #endif
 511    RETVALUE(ROK);
 512
 513 }
 514
 515 /**
 516  *
 517  * @brief
 518  *        Handler to clear Ring buffer from UL RLC
 519  *
 520  * @details
 521  *         This function clears all the ring buffer content from  UL RLC
 522  *
 523  * @return  S16
 524  *      -# ROK
 525  *      -# RFAILED
 526  *
 527  */
 528 #ifdef ANSI
 529 PUBLIC Void kwUtlFreeUlRBuf(void)
 530 #else
 531 PUBLIC Void kwUtlFreeUlRBuf()
 532 #endif
 533 {
 534    RguDDatIndInfo *datInd;
 535    PTR            elem;
 536    U8             numLch;
 537    U8             numPdu;
 538
 539    TRC2(kwUtlFreeUlRBuf)
 540    /* Free SS_RNG_BUF_ULMAC_TO_ULRLC  */
 541    while((SDeqSRngBuf (SS_RNG_BUF_ULMAC_TO_ULRLC, &elem) == ROK))
 542    {
 543       datInd = (RguDDatIndInfo *)elem;
 544       for(numLch = 0; numLch< datInd->numLch; numLch++)
 545       {
 546          for(numPdu = 0; numPdu < datInd->lchData[numLch].pdu.numPdu; numPdu++)
 547          {
 548             if(datInd->lchData[numLch].pdu.mBuf[numPdu])
 549             {
 550                KW_FREE_BUF_WC(datInd->lchData[numLch].pdu.mBuf[numPdu]);
 551             }
 552          }
 553       }
 554       KW_PST_FREE(0, 0, datInd, sizeof(RguDDatIndInfo));
 555    }
 556 }
 557 #endif
 558 #ifdef RLC_MAC_STA_RSP_RBUF
 559 #ifdef ANSI
 560 PUBLIC S16 kwLiRguStaRspRbuf
 561 (
 562 Pst               *post,
 563 SpId              spId,
 564 Void             *staRsp
 565 )
 566 #else
 567 PUBLIC S16 kwLiRguStaRspRbuf(post, spId, staRsp)
 568 Pst               *post;
 569 SpId              spId;
 570 Void              *staRsp;
 571 #endif /* ANSI */
 572 {
 573    S16 ret1 = ROK;
 574
 575    Void *elem = NULLP;
 576
 577    RguDStaRspInfo  *staRspInfo = NULL;
 578    elem = SRngGetWIndx(SS_RNG_BUF_DLRLC_TO_DLMAC);
 579    if (NULLP != elem)
 580    {
 581       staRspInfo = (RguDStaRspInfo *)elem;
 582       cmMemcpy((U8 *)staRspInfo, (U8 *)staRsp, sizeof(RguDStaRspInfo));
 583       staRspInfo->post = *post;
 584       SRngIncrWIndx(SS_RNG_BUF_DLRLC_TO_DLMAC);
 585       SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC].pktRate++;
 586    }
 587    else
 588    {
 589       RLOG0(L_ERROR,"RLC DL STA RSP RBUF is FULL!!! ");
 590       SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC].pktDrop++;
 591       ret1 = RFAILED;
 592    }
 593    RETVALUE(ret1);
 594 } /* cmPkKwuDatReq */
 595
 596 #endif
 597 #ifdef RLC_MAC_DAT_REQ_RBUF
 598 #ifdef ANSI
 599 PUBLIC S16 kwLiRguDatReqRbuf
 600 (
 601 Pst               *post,
 602 SpId              spId,
 603 Void             *datReq
 604 )
 605 #else
 606 PUBLIC S16 kwLiRguDatReqRbuf(post, spId, datReq)
 607 Pst               *post;
 608 SpId              spId;
 609 Void             *datReq;
 610 #endif /* ANSI */
 611 {
 612    S16 ret1 = ROK;
 613
 614    Void *elem = NULLP;
 615    RguInfoRingElem *datReqRing=NULLP;
 616    elem = SRngGetWIndx(SS_RNG_BUF_DLRLC_TO_DLMAC_DAT_REQ);
 617    if (NULLP != elem)
 618    {
 619       datReqRing = (RguInfoRingElem *) elem;
 620       datReqRing->spId = spId;
 621       datReqRing->event = post->event;
 622       datReqRing->msg =datReq;
 623       SRngIncrWIndx(SS_RNG_BUF_DLRLC_TO_DLMAC_DAT_REQ);
 624       SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC_DAT_REQ].pktRate++;
 625    }
 626    else
 627    {
 628       printf("RLC DL DAT REQ RBUF is FULL!!! \n");
 629       SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC_DAT_REQ].pktDrop++;
 630       ret1 = RFAILED;
 631    }
 632    RETVALUE(ret1);
 633 } /* cmPkKwuDatReq */
 634
 635 #endif
 636
 637 #ifdef __cplusplus
 638 }
 639 #endif /* __cplusplus */
 640 \f
 641 /********************************************************************30**
 642          End of file
 643 **********************************************************************/