src/5gnrmac/rg_dhm.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
  21      Name:     LTE-MAC layer
  22
  23      Type:     C source file
  24
  25      Desc:     C source code for Entry point fucntions
  26
  27      File:     rg_dhm.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_dhm.c
  32 @brief APIs related to Downlink HARQ.
  33 */
  34
  35 static const char* RLOG_MODULE_NAME="MAC";
  36 static int RLOG_FILE_ID=279;
  37 static int RLOG_MODULE_ID=4096;
  38 /* header include files -- defines (.h) */
  39 #include "envopt.h"        /* environment options */
  40 #include "envdep.h"        /* environment dependent */
  41 #include "envind.h"        /* environment independent */
  42 #include "gen.h"           /* general layer */
  43 #include "ssi.h"           /* system service interface */
  44 #ifdef L2_OPTMZ
  45 #include "ss_strm.h"
  46 #endif
  47 #include "cm5.h"           /* common timers */
  48 #include "cm_hash.h"       /* common hash list */
  49 #include "cm_mblk.h"       /* common memory link list library */
  50 #include "cm_llist.h"      /* common linked list library */
  51 #include "cm_err.h"        /* common error */
  52 #include "cm_lte.h"        /* common LTE */
  53 #include "lrg.h"
  54 #include "crg.h"
  55 #include "rgu.h"
  56 #include "tfu.h"
  57 #include "rg_sch_inf.h"
  58 #include "rg_env.h"
  59 #include "rg_err.h"
  60 #include "rg.h"
  61
  62 /* header/extern include files (.x) */
  63 #include "gen.x"           /* general layer */
  64 #include "ssi.x"           /* system service interface */
  65 #ifdef L2_OPTMZ
  66 #include "ss_strm.x"
  67 #endif
  68 #include "cm5.x"           /* common timers */
  69 #include "cm_lib.x"        /* common library */
  70 #include "cm_hash.x"       /* common hash list */
  71 #include "cm_llist.x"      /* common linked list library */
  72 #include "cm_mblk.x"       /* memory management */
  73 #include "cm_tkns.x"       /* common tokens */
  74 #include "cm_lte.x"        /* common LTE */
  75 #include "lrg.x"
  76 #include "crg.x"
  77 #include "rgu.x"
  78 #include "tfu.x"
  79 #include "rg_sch_inf.x"
  80 #include "rg_prg.x"        /* PRG interface typedefs */
  81 #include "du_app_mac_inf.h"
  82 #include "rg.x"
  83
  84 #ifdef L2_OPTMZ
  85 #include "ss_queue.h"
  86 #include "ss_queue.x"
  87 #include "ss_task.x"
  88 #include "ss_msg.x"            /* MAC includes */
  89 /* local defines */
  90 //EXTERN  S16 ssGetDBufOfSize(Region region,Size size,Buffer **dBuf);
  91 //void prc_trace_format_string(UINT32 group_mask, UINT16 level, const char *format, ...);
  92 #endif
  93
  94 /* local typedefs */
  95
  96 /* local externs */
  97 EXTERN S16 SIncMsgRef(Buffer *srcBuf,Region dstRegion, Pool dstPool,Buffer **dstBuf);
  98
  99 PRIVATE Void rgDHMBldTfuDatReq ARGS((RgCellCb *cellCb, RgDlSf *dlSf, RgDlHqProcCb *hqP,
 100                            RgTfuDatReqPduInfo *datReq));
 101
 102 #ifdef L2_OPTMZ
 103 PUBLIC S16 rgDHMFreeHqProcTB
 104 (
 105 RgDlHqProcCb         *hqP,
 106 U8                   tbIndex
 107 );
 108
 109 #endif
 110
 111 /* forward references */
 112
 113 /**
 114  * @brief This function initializes the DL HARQ Entity of UE
 115  *
 116  * @details
 117  *
 118  *     Function: rgDHMHqEntInit
 119  *     Purpose:  This function initializes the DL HARQ entity of
 120  *               UE control block. This is performed at the time
 121  *               of creating UE control block.
 122  *
 123  *     Invoked by: configuration module
 124  *
 125  *  @param[in]  Inst        inst
 126  *  @param[in]  RgCellCb*  cell
 127  *  @param[in]  RgUeCb*    ue
 128  *  @return  S16
 129  *           -# ROK
 130  *           -# RFAILED
 131  *
 132  **/
 133 #ifdef ANSI
 134 PUBLIC S16 rgDHMHqEntInit
 135 (
 136 Inst               inst,
 137 RgDlHqEnt          *hqE,
 138 U8                 maxHqProcs
 139 )
 140 #else
 141 PUBLIC S16 rgDHMHqEntInit(inst,hqE, maxHqProcs)
 142 Inst               inst,
 143 RgDlHqEnt          *hqE;
 144 U8                 maxHqProcs;
 145 #endif
 146 {
 147    U8 idx1,idx2;
 148 #ifdef L2_OPTMZ
 149    Buffer  *hdrDBuf = NULLP;
 150    Buffer  *ceDBuf = NULLP;
 151 #endif
 152
 153    TRC2(rgDHMHqEntInit)
 154
 155    hqE->numHqProcs = maxHqProcs;
 156    /* for each harq process */
 157    for (idx1 = 0; idx1 < hqE->numHqProcs; idx1++)
 158    {
 159       if (rgAllocSBuf(inst,(Data **)&(hqE->procs[idx1]),sizeof(RgDlHqProcCb)) != ROK)
 160       {
 161          while(idx1--)
 162          {
 163             rgFreeSBuf(inst,(Data **)&(hqE->procs[idx1]), sizeof(RgDlHqProcCb));
 164          }
 165          RLOG0(L_ERROR, "Memory Alloc Failure for RgDlHqProcCb");
 166          RETVALUE(RFAILED);
 167       }
 168
 169       hqE->procs[idx1]->procId      = idx1;
 170       for(idx2 = 0; idx2 < RG_MAX_TB_PER_UE; idx2++)
 171       {
 172 #ifndef L2_OPTMZ
 173          hqE->procs[idx1]->tbInfo[idx2].tb = NULLP;
 174 #else
 175          Buffer *tmpMBuf;
 176          /* L2 optimization for mUe/Tti: Allocating buffers for macHdr, macCes
 177           * and macPadding. These buffers shall not be released by MAC/CL.
 178           * However, Only rPtr and wPtr will be reset while release of hq proc
 179           */
 180          tmpMBuf = hqE->procs[idx1]->tbInfo[idx2].tb.macHdr;
 181          rgGetMsg(inst, &tmpMBuf);
 182          RG_ADD_DBuf(hdrDBuf, RG_MAC_HDR_SIZE, tmpMBuf);
 183          hqE->procs[idx1]->tbInfo[idx2].tb.macHdr = tmpMBuf;
 184          macHeader[idx2] = MacPtrAddress;
 185
 186          tmpMBuf = hqE->procs[idx1]->tbInfo[idx2].tb.macCes;
 187          rgGetMsg(inst, &tmpMBuf);
 188          RG_ADD_DBuf(ceDBuf, RG_MAC_CE_SIZE, tmpMBuf);
 189          hqE->procs[idx1]->tbInfo[idx2].tb.macCes = tmpMBuf;
 190
 191          hqE->procs[idx1]->tbInfo[idx2].tb.padSize = 0;
 192 #endif
 193 #ifdef LTE_L2_MEAS
 194          hqE->procs[idx1]->tbId[idx2] = RGU_INVALID_TBID;
 195 #endif
 196       }
 197
 198       cmLListInit(&hqE->savedProcLst[idx1]);
 199    }
 200
 201
 202    RETVALUE(ROK);
 203 } /* rgDHMHqEntInit */
 204
 205 /**
 206  * @brief This function releases a HARQ process
 207  *
 208  * @details
 209  *
 210  *     Function: rgDHMUeReset
 211  *     Purpose:  This function resets TB in each HarqProc.
 212  *
 213  *     Invoked by: CFG UE Reset
 214  *
 215  *  @param[in]  RgDlHqProc    *hqP
 216  *  @return  Void
 217  *
 218  **/
 219 #ifdef ANSI
 220 PUBLIC Void rgDHMUeReset
 221 (
 222 RgCellCb *cell,
 223 RgDlHqEnt          *hqE
 224 )
 225 #else
 226 PUBLIC Void rgDHMUeReset(cell, hqE)
 227 RgCellCb *cell;
 228 RgDlHqEnt          *hqE;
 229 #endif
 230 {
 231    U8       i = 0;
 232
 233    TRC2(rgDHMUeReset)
 234
 235    if(hqE->procs[0])
 236    {
 237       /* Free all the TB memory associated with HARQ */
 238       for (i=0; i < hqE->numHqProcs; i++)
 239       {
 240          rgDHMRlsHqProcTB(cell, hqE->procs[i], 1);
 241          rgDHMRlsHqProcTB(cell, hqE->procs[i], 2);
 242
 243 #ifdef LTE_ADV
 244          rgDHMFreeSavedHqP((cell->macInst - RG_INST_START), hqE, i);
 245 #endif
 246       }
 247    }
 248    RETVOID;
 249 } /* rgDHMUeReset*/
 250
 251 /**
 252  * @brief This function defers shared memory buffer
 253  *        freeing out of the critical RT path.
 254  *
 255  * @details
 256  *
 257  *     Function: rgDHMHdlBufFree
 258  *     Purpose: To defer shared memory freeing post
 259  *              critical path. Defer as many if defer queue
 260  *              is full then release instantly.
 261  *
 262  *     Invoked by: HARQ TB Release.
 263  *
 264  *  @return  Void
 265  *
 266  **/
 267 #ifdef ANSI
 268 PUBLIC Void rgDHMHdlBufFree
 269 (
 270 Inst inst,
 271 Buffer **mBuf
 272 )
 273 #else
 274 PUBLIC Void rgDHMHdlBufFree(Inst inst, Buffer **mBuf)
 275 Inst inst;
 276 #endif
 277 {
 278    RgCb *rgCbP = &rgCb[inst];
 279    TRC2(rgDHMHdlBufFree)
 280
 281    if (rgCbP->bufCnt < RG_MAX_DFRD_FREE_BUFS)
 282    {
 283       if (*mBuf)
 284       {
 285          rgCbP->bufToFree[rgCbP->bufCnt] = *mBuf;
 286          rgCbP->bufCnt++;
 287          *mBuf = NULLP;
 288       }
 289    }
 290    else
 291    {
 292       RG_FREE_MSG(*mBuf);
 293    }
 294    RETVOID;
 295 }
 296 /**
 297  * @brief This function is called to release the
 298  *        shared memory of the HARQ TBs outside
 299  *        the critical RT path.
 300  *
 301  * @details
 302  *
 303  *     Function: rgDHMFreeTbBufs
 304  *     Purpose: This function is called to release the
 305  *        shared memory of the HARQ TBs outside
 306  *        the critical RT path.
 307  *
 308  *     1. Job of releasing TBs is shared across TTIs
 309  *     Invoked by: MAC every TTI
 310  *
 311  *  @return  Void
 312  *
 313  **/
 314 #ifdef ANSI
 315 PUBLIC Void rgDHMFreeTbBufs
 316 (
 317 Inst inst
 318 )
 319 #else
 320 PUBLIC Void rgDHMFreeTbBufs(inst)
 321 Inst inst;
 322 #endif
 323 {
 324    RgCb *rgCbP = &rgCb[inst];
 325    U8 start = rgCbP->bufCnt;
 326    U8 end = 0;
 327
 328    TRC2(rgDHMFreeTbBufs)
 329
 330    if (rgCbP->bufCnt < RG_MAX_FREE_BUFS_PERTTI)
 331    {
 332       end = 0;
 333    }
 334    else
 335    {
 336       end = rgCbP->bufCnt - RG_MAX_FREE_BUFS_PERTTI;
 337    }
 338    while (start != end)
 339    {
 340       start--;
 341       SPutMsg(rgCbP->bufToFree[start]);
 342    }
 343    rgCbP->bufCnt = end;
 344    RETVOID;
 345 } /* rgDHMFreeTbBufs */
 346
 347 #ifdef ANSI
 348 PUBLIC Void rgDHMFreeAllTbBufs
 349 (
 350 Inst inst
 351 )
 352 #else
 353 PUBLIC Void rgDHMFreeAllTbBufs(inst)
 354 Inst inst;
 355 #endif
 356 {
 357    RgCb *rgCbP = &rgCb[inst];
 358    U8 start = rgCbP->bufCnt;
 359    U8 end = 0;
 360
 361    TRC2(rgDHMFreeAllTbBufs)
 362
 363    while (start != end)
 364    {
 365       start--;
 366       SPutMsg(rgCbP->bufToFree[start]);
 367    }
 368    rgCbP->bufCnt = end;
 369    RETVOID;
 370 } /* rgDHMFreeTbBufs */
 371
 372
 373 /**
 374  * @brief This function releases a HARQ process
 375  *
 376  * @details
 377  *
 378  *     Function: rgDHMRlsHqProcTB
 379  *     Purpose:  This function returns a HARQ process to HARQ Entity
 380  *               in the DL direction.
 381  *
 382  *               1. Add the HARQ process to the free queue.
 383  *     Invoked by: scheduler and HARQ processing
 384  *
 385  *  @param[in]  RgDlHqProc    *hqP
 386  *  @return  Void
 387  *
 388  **/
 389 #ifdef ANSI
 390 PUBLIC S16 rgDHMRlsHqProcTB
 391 (
 392 RgCellCb             *cell,
 393 RgDlHqProcCb         *hqP,
 394 U8                   tbIndex
 395 )
 396 #else
 397 PUBLIC S16 rgDHMRlsHqProcTB(cell, hqP, tbIndex)
 398 RgCellCb             *cell;
 399 RgDlHqProcCb         *hqP;
 400 U8                   tbIndex;
 401 #endif
 402 {
 403     U8                    idx;
 404 #ifdef L2_OPTMZ
 405     RgTfuDatReqTbInfo     *tb;   /* TB to be sent to CL/PHY*/
 406    // U32 lchIdx, pduIdx;
 407 #endif
 408
 409    TRC2(rgDHMRlsHqProcTB)
 410
 411    if((tbIndex > RG_MAX_TB_PER_UE) ||
 412       (tbIndex == 0))
 413    {
 414       RETVALUE(RFAILED);
 415    }
 416
 417    hqP->tbInfo[tbIndex-1].numSchLch = 0;
 418 #ifndef L2_OPTMZ
 419    if (hqP->tbInfo[tbIndex-1].tb)
 420    {
 421       rgDHMHdlBufFree(cell->macInst - RG_INST_START, &hqP->tbInfo[tbIndex-1].tb);
 422    }
 423 #else
 424    /* L2 Optimization for mUe/Tti:  macHdr, macCes and macPad mBuf pointers
 425     * shall not be released. However, Inorder to release harq info/TB info,
 426     * just Resetting rPtr and wPtr of these mbufs to db_base
 427     */
 428    tb = &(hqP->tbInfo[tbIndex-1].tb);
 429    if (tb->tbPres == TRUE)
 430    {
 431       RG_FREE_TB(tb);
 432    }
 433 #endif
 434    hqP->tbInfo[tbIndex-1].schdTa.pres = FALSE;
 435 #ifdef LTE_ADV
 436    hqP->tbInfo[tbIndex -1].sCellActCe.pres = FALSE;
 437 #endif
 438
 439    /* Decrementing might lead to roundoff error in case of say UE reset
 440     * where all the HqProcs irrespective whether in use are called for rls.
 441     * Hence to avoid the same shift operator is being used. */
 442    hqP->numOfTBs = hqP->numOfTBs >> 1;
 443    for(idx = 0; idx < 2; idx++)
 444    {
 445       if (hqP->tbInfo[tbIndex-1].sfLnkInfo[idx].sfLnk.node != NULLP)
 446    {
 447          cmLListDelFrm(&hqP->tbInfo[tbIndex-1].sfLnkInfo[idx].sf->tbs,
 448                &(hqP->tbInfo[tbIndex-1].sfLnkInfo[idx].sfLnk));
 449          hqP->tbInfo[tbIndex-1].sfLnkInfo[idx].sfLnk.node  = (PTR)NULLP;
 450       printf("\nrgDHMRlsHqProcTB:: hqP %p \n", (Void *)hqP);
 451    }
 452       hqP->tbInfo[tbIndex-1].sfLnkInfo[idx].sf = NULLP;
 453    }
 454    /* Fix : syed It is better to reset these feilds
 455     * corruption avoidance */
 456    hqP->tbInfo[tbIndex-1].tbSz = 0;
 457    hqP->tbInfo[tbIndex-1].contResCe = NOTPRSNT;
 458    hqP->tbInfo[tbIndex-1].contResId = NULLP;
 459
 460    RETVALUE(ROK);
 461 } /* rgDHMRlsHqProc */
 462
 463 /**
 464  * @brief This function gets HARQ process with the given Id
 465  *
 466  * @details
 467  *
 468  *     Function: rgDHMGetHqProcFrmId
 469  *     Purpose:  This function returns the HARQ process with the given ID.
 470  *     Invoked by: ROM
 471  *
 472  *  @param[in]  RgUeCb        *ue
 473  *  @param[in]  U8            idx
 474  *  @param[in]  RgDlHqProc    **hqP
 475  *  @return  S16
 476  *         -#   ROK     if successful
 477  *         -#   RFAILED otherwise
 478  *
 479  **/
 480 #ifdef ANSI
 481 PUBLIC S16 rgDHMGetHqProcFrmId
 482 (
 483 RgUeCb               *ue,
 484 U8                   idx,
 485 RgDlHqProcCb         **hqP
 486 )
 487 #else
 488 PUBLIC S16 rgDHMGetHqProcFrmId(ue, idx, hqP)
 489 RgUeCb               *ue;
 490 U8                   idx;
 491 RgDlHqProcCb         **hqP;
 492 #endif
 493 {
 494    TRC2(rgDHMGetHqProcFrmId)
 495
 496    /* Pick the proc based on the index provided */
 497    *hqP = (ue->dl.hqEnt.procs[idx]);
 498
 499    RETVALUE(ROK);
 500 } /* rgDHMGetHqProcFrmId */
 501
 502 /*PRIVATE U32 dataAvl; */
 503 /**
 504  * @brief Handler for sending data to PHY
 505  *
 506  * @details
 507  *
 508  *     Function : rgDHMSndDatReq
 509  *
 510  *     This function shall send the MAC PDU built for the UE to TOM
 511  *     when invoked as part of TTI processing and keep track of the number of
 512  *     transmissions for this TB.
 513  *
 514  *
 515  *  @param[in]  RgCellCb      *cell
 516  *  @param[in]  RgDlHqProcCb  *hqE
 517  *  @param[out] RgErrInfo     *err
 518  *  @return     S16
 519  *      -#ROK
 520  *      -#RFAILED
 521  **/
 522 #ifdef ANSI
 523 PUBLIC S16 rgDHMSndDatReq
 524 (
 525 RgCellCb        *cellCb,
 526 RgDlSf          *dlSf,
 527 RgTfuDatReqInfo *datInfo,
 528 RgDlHqProcCb   *hqP,
 529 RgErrInfo      *err
 530 )
 531 #else
 532 PUBLIC S16 rgDHMSndDatReq(cellCb, dlSf, datInfo, hqP, err)
 533 RgCellCb        *cellCb;
 534 RgDlSf          *dlSf;
 535 RgTfuDatReqInfo *datInfo;
 536 RgDlHqProcCb    *hqP;
 537 RgErrInfo       *err;
 538 #endif
 539 {
 540    U8 i;
 541    Inst               inst = cellCb->macInst - RG_INST_START;
 542    RgTfuDatReqPduInfo   *datReq;
 543    RgBldPduInfo      bldPdu;
 544    /*Added this variable to figure out that whether this UE data
 545      has to be inclueded in the TFU Data request.*/
 546    Bool  dataAvlblUe;
 547
 548    TRC2(rgDHMSndDatReq)
 549
 550    dataAvlblUe = TRUE;
 551    for(i=0;i< RG_MAX_TB_PER_UE;i++)
 552    {
 553          /* printf("\nDHMSndDatReq1: Rnti %d dlSfSchdTime(sfn sf) : (%d %d)\n"
 554                 "macCell(sfn sf): (%d %d) tbTimingInfo(sfn sf): (%d %d)\n"
 555                 "dlSf %p dlSf->tbs.count %d hqp %p tb %p\n",
 556                              hqP->tbInfo[i].pdcch.rnti,
 557                              dlSf->schdTime.sfn, dlSf->schdTime.slot,
 558                              cellCb->crntTime.sfn, cellCb->crntTime.slot,
 559                              hqP->tbInfo[i].timingInfo.sfn,
 560                              hqP->tbInfo[i].timingInfo.slot,
 561                              (Void *)dlSf, dlSf->tbs.count,
 562                              (Void *)hqP,
 563                              (Void *)hqP->tbInfo[i].tb);*/
 564       /* Mukesh :: in case of rpepetiton this is not rerd*/
 565       if (hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sf == dlSf)
 566       {
 567          /* Check if data from RLC had been received and got muxed. */
 568 #ifndef L2_OPTMZ
 569          if (hqP->tbInfo[i].tb == NULLP)
 570 #else
 571          if (!(hqP->tbInfo[i].tb.tbPres))
 572 #endif
 573          {
 574 #ifndef LTE_ADV
 575             if (hqP->tbInfo[i].schdTa.pres == TRUE ||
 576                   hqP->tbInfo[i].contResCe == PRSNT_NODEF)
 577 #else
 578             if ((hqP->tbInfo[i].schdTa.pres == TRUE) ||
 579                  (hqP->tbInfo[i].contResCe == PRSNT_NODEF) ||
 580                  (hqP->tbInfo[i].sCellActCe.pres == TRUE))
 581 #endif
 582             {
 583                /* Data not received but ta needs to be sent. */
 584                /* MUX TA and send it */
 585                bldPdu.datReq    =  NULLP;
 586                bldPdu.reqType   =  EVENT_SLOT_IND_TO_MAC;
 587                bldPdu.schdTbSz  =  hqP->tbInfo[i].tbSz;
 588                bldPdu.ta        =  hqP->tbInfo[i].schdTa;
 589 #ifdef LTE_ADV
 590                bldPdu.sCellActCe= hqP->tbInfo[i].sCellActCe;
 591 #endif
 592                /* changes for CR timer implementation*/
 593                bldPdu.contResId =  hqP->tbInfo[i].contResId;
 594                if (ROK != rgMUXBldPdu(inst,&bldPdu, &(hqP->tbInfo[i].tb), err))
 595                {
 596                   RLOG1(L_ERROR, "MUXing failed for:  MacInst %d", inst);
 597                   RLOG4(L_ERROR, "MUXing failed for:  time: %d/%d\
 598                   procId %d ueId %d", hqP->tbInfo[i].timingInfo.sfn,
 599                   hqP->tbInfo[i].timingInfo.slot, hqP->procId,
 600                   hqP->tbInfo[i].pdcch.rnti);
 601
 602                   RETVALUE(RFAILED);
 603                }
 604             }
 605             else
 606             {
 607 #ifdef LTEMAC_RGU_PAD
 608                /* Data not received from RLC. Padding at MAC */
 609                bldPdu.datReq    =  NULLP;
 610                bldPdu.reqType   =  EVENT_SLOT_IND_TO_MAC;
 611                bldPdu.schdTbSz  =  hqP->tbInfo[i].tbSz;
 612                bldPdu.ta        =  hqP->tbInfo[i].schdTa;
 613 #ifdef LTE_ADV
 614                bldPdu.sCellActCe= hqP->tbInfo[i].sCellActCe;
 615 #endif
 616                bldPdu.ta.val    =  0;
 617                bldPdu.contResId =  NULLP;
 618
 619                if (ROK != rgMUXBldPdu(inst,&bldPdu, &(hqP->tbInfo[i].tb), err))
 620                {
 621                   RLOG1(L_ERROR, "MUXing failed for:  MacInst %d", inst);
 622                   RLOG4(L_ERROR, "MUXing failed for:  time: %d/%d\
 623                   procId %d ueId %d", hqP->tbInfo[i].timingInfo.sfn,
 624                   hqP->tbInfo[i].timingInfo.slot, hqP->procId,
 625                   hqP->tbInfo[i].pdcch.rnti);
 626
 627                   RETVALUE(RFAILED);
 628                }
 629 #else
 630                /*Padding is not done so data for this UE will not be
 631                  included.*/
 632                dataAvlblUe = FALSE;
 633 #endif
 634             }
 635          }
 636          else
 637          {
 638          }
 639       }
 640       //else
 641       {
 642       }
 643    }
 644
 645    /*If Data/Padding is not available for UE, then we can not include
 646      any Data for this UE in TFU Data Request.*/
 647    if(!dataAvlblUe)
 648    {
 649       /*Free up the HARQ process for this allocation.*/
 650       /* Release First TB, as this would be anyway there*/
 651       rgDHMRlsHqProcTB(cellCb, hqP, 1);
 652       if(2 == hqP->numOfTBs)
 653       {
 654          rgDHMRlsHqProcTB(cellCb, hqP, 2);
 655       }
 656
 657       RETVALUE(ROK);
 658    }
 659
 660    if (rgGetEventMem(inst,(Ptr *)&datReq, sizeof(TfuDatReqPduInfo),
 661             &(datInfo->memCp)) != ROK)
 662    {
 663       RETVALUE(RFAILED);
 664    }
 665    /* Fill the TFU Dat Req with information from Harq Proc */
 666
 667    rgDHMBldTfuDatReq(cellCb, dlSf, hqP, datReq);
 668
 669    /* MS_WORKAROUND for ccpu00122894 */
 670    for(i=0;i< RG_MAX_TB_PER_UE;i++)
 671    {
 672       if (hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sf == dlSf)
 673       {
 674          cmLListDelFrm(&dlSf->tbs, &(hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sfLnk));
 675          hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sfLnk.node = NULLP;
 676
 677
 678         hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sf = NULLP;
 679       }
 680    }
 681    cmLListAdd2Tail(&datInfo->pdus, &(datReq->lnk));
 682    datReq->lnk.node = (PTR)datReq;
 683
 684    RETVALUE(ROK);
 685 }  /* rgDHMSndDatReq */
 686
 687 /**
 688  * @brief Function to handle RGU datReq received from ROM
 689  *
 690  * @details
 691  *
 692  *     Function : rgDHMHndlDedDatReq
 693  *
 694  *     This function shall act on the datReq received on RGU. It shall
 695  *     store the data IDs for all the logical channels and get the MAC
 696  *     PDU built.
 697  *
 698  *
 699  *  @param[in]  Inst        inst
 700  *  @param[in]  RgDlHqProcCb   *hqProc
 701  *  @param[in]  RgRguDedDatReq *datReq
 702  *  @param[out] RgErrInfo      *err
 703  *  @return     S16
 704  *      -# ROK
 705  *      -# RFAILED
 706  **/
 707 #ifdef ANSI
 708 PUBLIC S16 rgDHMHndlDedDatReq
 709 (
 710 Inst           inst,
 711 RgDlHqProcCb   *hqProc,
 712 RgRguDDatReqPerUe *datReq,
 713 RgDlSf            *dlSf,
 714 RgErrInfo      *err
 715 )
 716 #else
 717 PUBLIC S16 rgDHMHndlDedDatReq(inst,hqProc, datReq, dlSf, err)
 718 Inst           inst;
 719 RgDlHqProcCb   *hqProc;
 720 RgRguDDatReqPerUe *datReq;
 721 RgDlSf            *dlSf;
 722 RgErrInfo      *err;
 723 #endif
 724 {
 725 //   U32            len;
 726    U8             i;
 727    U8             j;
 728    RgBldPduInfo   bldPdu;
 729    U8             tbIndex;
 730 #ifdef L2_OPTMZ
 731    RgTfuDatReqTbInfo     *tb;
 732 #endif
 733
 734    TRC2(rgDHMHndlDedDatReq);
 735
 736    tbIndex = (U8)(datReq->transId & 0x03);
 737    /* Accept all the data requests even if delayed in case nothing
 738     * has been sent earlier on the harq proc.
 739     */
 740    if((datReq->nmbOfTbs > RG_MAX_TB_PER_UE) ||
 741          (tbIndex == 0))
 742    {
 743       /* release corresponding TBs from SF tbs List */
 744       for(j=0;j<datReq->nmbOfTbs;j++)
 745       {
 746          if (!(tbIndex & (j+1)))
 747          {
 748             j++;
 749          }
 750          rgDHMRlsHqProcTB(rgCb[inst].cell, hqProc, (U8)(j+1));
 751       }
 752       RETVALUE(RFAILED);
 753    }
 754
 755    for(i=0;i<datReq->nmbOfTbs;i++)
 756    {
 757       /* tbIndex 01 corresponds to presence of 1st TB
 758        * 10 corresponds 2nd TB
 759        * 11 corresponds two TBs of UE */
 760       if (!(tbIndex & (i+1)))
 761       {
 762           continue;
 763       }
 764       if (hqProc->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sfLnk.node == NULLP)
 765       {
 766          /* release corresponding TBs from SF tbs List */
 767          for(j=0;j<datReq->nmbOfTbs;j++)
 768          {
 769             if (!(tbIndex & (j+1)))
 770             {
 771                j++;
 772             }
 773             rgDHMRlsHqProcTB(rgCb[inst].cell, hqProc, (U8)(j+1));
 774             printf("\nrgDHMHndlDedDatReq:: hqP %p \n", (Void *)hqProc);
 775          }
 776          RETVALUE(RFAILED);
 777
 778       }
 779 #ifndef L2_OPTMZ
 780       RG_FREE_MSG(hqProc->tbInfo[i].tb);
 781       /* L2 optimization for mUe/Tti: Pre-allocated mBuf pointers(macHdr,
 782        * macCes and MacPad) of harq TB need to be reset to db_base
 783        */
 784 #else
 785       tb = &hqProc->tbInfo[i].tb;
 786       if (tb->tbPres == TRUE)
 787       {
 788          RG_FREE_TB(tb);
 789       }
 790 #endif
 791       bldPdu.datReq    =  datReq;
 792       bldPdu.reqType   =  EVTRGUDDATREQ;
 793       bldPdu.schdTbSz  =  hqProc->tbInfo[i].tbSz;
 794       bldPdu.tbIndex   =  i+1;
 795       bldPdu.ta        =  hqProc->tbInfo[i].schdTa;
 796 #ifdef LTE_ADV
 797       bldPdu.sCellActCe= hqProc->tbInfo[i].sCellActCe;
 798 #endif
 799       bldPdu.contResId =  NULLP;
 800 #ifdef LTE_L2_MEAS
 801       /* Store tbId from RLC in DDatRequest */
 802       hqProc->tbId[i] = datReq->datReqTb[i].tbId;
 803
 804
 805       hqProc->status[i] =  FALSE;
 806 #endif
 807       if(rgMUXBldPdu(inst,&bldPdu, &(hqProc->tbInfo[i].tb), err) != ROK)
 808       {
 809          RLOG1(L_ERROR, "MUXing failed for:  MacInst %d", inst);
 810          RLOG4(L_ERROR, "MUXing failed for:  time: %d/%d\
 811                procId %d ueId %d", hqProc->tbInfo[i].timingInfo.sfn,
 812                hqProc->tbInfo[i].timingInfo.slot, hqProc->procId,
 813                hqProc->tbInfo[i].pdcch.rnti);
 814
 815          /* release corresponding TBs from SF tbs List */
 816          for(j=0;j<datReq->nmbOfTbs;j++)
 817          {
 818             if (!(tbIndex & (j+1)))
 819             {
 820                j++;
 821             }
 822             rgDHMRlsHqProcTB(rgCb[inst].cell, hqProc, (U8)(j+1));
 823          }
 824          RETVALUE(RFAILED);
 825       }
 826       /*
 827       SFndLenMsg(hqProc->tbInfo[i].tb, &len);
 828       */
 829    }
 830    RETVALUE(ROK);
 831 }  /* rgDHMHndlDedDatReq */
 832
 833 /**
 834  * @brief Function to handle RGU datReq received from ROM
 835  *
 836  * @details
 837  *
 838  *     Function : rgDHMHndlCmnDatReq
 839  *
 840  *     This function shall act on the datReq received on RGU. It shall
 841  *     store the data IDs for all the logical channels and get the MAC
 842  *     PDU built.
 843  *
 844  *
 845  *  @param[in]  Inst        inst
 846  *  @param[in]  RgDlHqProcCb   *hqProc
 847  *  @param[in]  RgRguCmnDatReq *datReq
 848  *  @param[out] RgErrInfo      *err
 849  *  @return     S16
 850  *      -# ROK
 851  *      -# RFAILED
 852  **/
 853 #ifdef ANSI
 854 PUBLIC S16 rgDHMHndlCmnDatReq
 855 (
 856 Inst           inst,
 857 RgDlHqProcCb   *hqProc,
 858 RgRguCmnDatReq *datReq,
 859 RgErrInfo      *err
 860 )
 861 #else
 862 PUBLIC S16 rgDHMHndlCmnDatReq(inst,hqProc, datReq, err)
 863 Inst           inst;
 864 RgDlHqProcCb   *hqProc;
 865 RgRguCmnDatReq *datReq;
 866 RgErrInfo      *err;
 867 #endif
 868 {
 869    RgUstaDgn      dgn;
 870    RgBldPduInfo   bldPdu;
 871
 872    TRC2(rgDHMHndlCmnDatReq)
 873
 874 #ifndef L2_OPTMZ
 875       if (hqProc->tbInfo[0].tb != NULLP)
 876 #else
 877       /* If numLch is non zero means HQ Proc is busy*/
 878       if (hqProc->tbInfo[0].tb.tbPres)
 879 #endif
 880       {
 881          /* datReq discarded. Generate an alarm */
 882          rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_HARQ);
 883          rgLMMStaInd(inst,LCM_CATEGORY_PROTOCOL, LCM_EVENT_UI_INV_EVT,
 884                LRG_CAUSE_HQ_PROC_BUSY, &dgn);
 885          RETVALUE(RFAILED);
 886       }
 887
 888    bldPdu.datReq    =  datReq;
 889    bldPdu.reqType   =  EVTRGUCDATREQ;
 890    bldPdu.schdTbSz  =  hqProc->tbInfo[0].tbSz;
 891    bldPdu.ta        =  hqProc->tbInfo[0].schdTa;
 892 #ifdef LTE_ADV
 893    bldPdu.sCellActCe= hqProc->tbInfo[0].sCellActCe;
 894 #endif
 895
 896    bldPdu.contResId  =  hqProc->tbInfo[0].contResId;
 897
 898    if(rgMUXBldPdu(inst,&bldPdu, &(hqProc->tbInfo[0].tb), err) != ROK)
 899    {
 900       RLOG1(L_ERROR, "MUXing failed for:  MacInst %d", inst);
 901       RLOG4(L_ERROR, "MUXing failed for: time: %d/%d\
 902                procId %d ueId %d", hqProc->tbInfo[0].timingInfo.sfn,
 903             hqProc->tbInfo[0].timingInfo.slot, hqProc->procId,
 904             hqProc->tbInfo[0].pdcch.rnti);
 905
 906       RG_FREE_MSG(datReq->pdu);
 907       RETVALUE(RFAILED);
 908    }
 909
 910    RETVALUE(ROK);
 911 }  /* rgDHMHndlCmnDatReq */
 912
 913 /**
 914  * @brief Function to get consolidate grants and send consolidated grant to RLC
 915  *
 916  * @details
 917  *
 918  *     Function : rgDHMSndConsolidatedStaInd
 919  *
 920  *     This function shall be invoked by Scheduler to trigger DHM to send a
 921  *     consolidated status indication of all UE scheduled in a TTI as well as
 922  *     send consolidated CStaInd for MSG4 and for all common channels(PCCH,
 923  *     if RGR_SI_SCH is not defined then it includes BCH and BCCH also)
 924  *
 925  *
 926  *  @param[in]  RgCellCb       *cell
 927  *  @param[in]  RgInfUeInfo   *ueInfo,
 928  *  @param[in]  CmLteTimingInfo timingInfo,
 929  *  @param[out] RgErrInfo      err
 930  *  @param[in]  RguCStaIndInfo   *cStaInd
 931  *  @return     S16
 932  *      -# ROK
 933  *      -# RFAILED
 934  **/
 935  RgUeCb  *gUe =NULLP;
 936 #ifdef ANSI
 937 PUBLIC S16 rgDHMSndConsolidatedStaInd
 938 (
 939 RgCellCb        *cell,
 940 RgInfUeInfo     *ueInfo,
 941 CmLteTimingInfo timingInfo,
 942 RgErrInfo       *err
 943 )
 944 #else
 945 PUBLIC S16 rgDHMSndConsolidatedStaInd(cell, ueInfo, timingInfo, err)
 946 RgCellCb        *cell;
 947 RgInfUeInfo     *ueInfo;
 948 CmLteTimingInfo timingInfo;
 949 RgErrInfo       *err;
 950 #endif
 951 {
 952    SuId            rguDlSpId;/*need to use spID instead of suID*/
 953    U8              idx;
 954    U8              ueIdx;
 955    U8              lcIdx;
 956    U8              tbIndex=0,idx1;
 957    RgDlSf          *dlSf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
 958    Inst            inst = cell->macInst - RG_INST_START;
 959 //   Bool            isDStaReqrd = FALSE;
 960    RgRguDedStaInd  *dStaInd[rgCb[inst].numRguSaps] ;
 961    RgUpSapCb      *rguDlSap[rgCb[inst].numRguSaps];
 962
 963    int lchBufSize =0;
 964    RgUeCb         *ue;
 965    RgDlHqProcCb   *hqP;
 966    RgInfUeAlloc   *allocInfo;
 967    U8             activeSapCnt = 0;
 968    U8             staIndCnt    = 0;
 969 #ifdef LTE_ADV
 970    Bool           hqPAdded     = FALSE;
 971 #endif
 972 #ifdef L2_OPTMZ
 973    RgTfuDatReqTbInfo     *tb;   /* TB to be sent to CL/PHY*/
 974 #endif
 975
 976    TRC2(rgDHMSndConsolidatedStaInd)
 977    cmMemset ((U8 *)dStaInd, 0, (sizeof(RgRguDedStaInd *) * rgCb[inst].numRguSaps));
 978    cmMemset ((U8 *)rguDlSap, 0, (sizeof(RgUpSapCb  *) * rgCb[inst].numRguSaps));
 979
 980    /* Send StaInd for the scheduled UEs */
 981    for(ueIdx = 0; ueIdx < ueInfo->numUes; ueIdx++)
 982    {
 983 #ifdef LTE_ADV
 984       hqPAdded = FALSE;
 985 #endif
 986       if((ue=rgDBMGetUeCb (cell, ueInfo->allocInfo[ueIdx].rnti)) == NULLP)
 987       {
 988          /* Check in RachLst */
 989          if((ue=rgDBMGetUeCbFromRachLst (cell,
 990                      ueInfo->allocInfo[ueIdx].rnti)) == NULLP)
 991          {
 992             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"CRNTI:%d No ueCb found",
 993                       ueInfo->allocInfo[ueIdx].rnti);
 994             /*Fix: If one UE is not present dont return, look for the next.*/
 995             continue;
 996          }
 997       }
 998
 999
1000       rgDHMGetHqProcFrmId(ue,ueInfo->allocInfo[ueIdx].hqProcId,&hqP);
1001       allocInfo = &ueInfo->allocInfo[ueIdx];
1002       gUe = ue;
1003
1004       /* Fix : syed Avoid sending data for a RETX
1005        * if initial TX data processing was unsuccessful */
1006       if((allocInfo->tbInfo[0].isReTx == TRUE) &&
1007             (hqP->tbInfo[0].tbSz == 0))
1008       {
1009          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
1010                "CRNTI:%d RETX hqP(%d) tb(0) for a failed New Tx",
1011                   allocInfo->rnti, hqP->procId);
1012          continue;
1013       }
1014       if((allocInfo->tbInfo[1].isReTx == TRUE) &&
1015             (hqP->tbInfo[1].tbSz == 0))
1016       {
1017          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
1018                    "CRNTI:%d RETX hqP(%d) tb(1) for a failed New Tx",
1019                   allocInfo->rnti, hqP->procId);
1020          continue;
1021       }
1022
1023       if(ue->rguDlSap != NULLP)
1024       {
1025           rguDlSpId = ue->rguDlSap->sapCfg.spId;
1026       }else
1027       {/* UeCb is from rachList */
1028           rguDlSpId = cell->rguDlSap->sapCfg.spId;
1029       }
1030
1031
1032       for(idx=allocInfo->tbStrtIdx;((idx-allocInfo->tbStrtIdx) <\
1033                allocInfo->nmbOfTBs); idx++)
1034       {
1035          RguCStaIndInfo  *cStaInd;
1036 #ifdef TFU_UPGRADE
1037          /* LTE_ADV_FLAG_REMOVED_START */
1038          hqP->tbInfo[idx].isEnbSFR = allocInfo->isEnbSFR;
1039          /* update pA value */
1040          hqP->tbInfo[idx].pa = allocInfo->pa;
1041          /* LTE_ADV_FLAG_REMOVED_END */
1042 #endif
1043
1044          hqP->numOfTBs =  allocInfo->nmbOfTBs;
1045          hqP->tbInfo[idx].sfLnkInfo[dlSf->schdTime.slot % 2].sfLnk.node = (PTR)hqP;
1046          hqP->tbInfo[idx].sfLnkInfo[dlSf->schdTime.slot % 2].sf = dlSf;
1047          cmLListAdd2Tail(&dlSf->tbs,&(hqP->tbInfo[idx].sfLnkInfo[dlSf->schdTime.slot % 2].sfLnk));
1048          /* Changes as part of performance testing*/
1049          /*   hqP->numOfTBs++;*/
1050          hqP->tbInfo[idx].doa = allocInfo->doa;
1051          hqP->tbInfo[idx].txMode = allocInfo->txMode;
1052          hqP->tbInfo[idx].puschRptUsd = allocInfo->puschRptUsd;
1053          hqP->tbInfo[idx].puschPmiInfo = allocInfo->puschPmiInfo;
1054 #ifdef LTEMAC_SPS
1055          hqP->tbInfo[idx].pdcch.rnti = allocInfo->pdcchRnti;
1056 #else
1057          hqP->tbInfo[idx].pdcch.rnti = allocInfo->rnti;
1058 #endif
1059          if(allocInfo->tbInfo[idx].isReTx == TRUE)
1060          {
1061             hqP->tbInfo[idx].pdcch.dci = allocInfo->dciInfo;
1062             continue;
1063          }
1064
1065          hqP->tbInfo[idx].timingInfo = timingInfo;
1066          hqP->tbInfo[idx].pdcch.dci = allocInfo->dciInfo;
1067 #ifndef L2_OPTMZ
1068          RG_FREE_MSG(hqP->tbInfo[idx].tb);
1069 #else
1070          /* L2 optimization for mUe/Tti: Pre-allocated mBuf pointers(macHdr,
1071           * macCes and MacPad) of harq TB need to be reset to db_base
1072           */
1073          tb = &(hqP->tbInfo[idx].tb);
1074          if (tb->tbPres == TRUE)
1075          {
1076             RG_FREE_TB(tb);
1077          }
1078 #endif
1079          hqP->tbInfo[idx].tbSz = allocInfo->tbInfo[idx].schdTbSz;
1080
1081          hqP->tbInfo[idx].schdTa.pres = allocInfo->tbInfo[idx].ta.pres;
1082          hqP->tbInfo[idx].schdTa.val  = allocInfo->tbInfo[idx].ta.val;
1083
1084 #ifdef LTE_ADV
1085          hqP->tbInfo[idx].sCellActCe.pres = allocInfo->tbInfo[idx].sCellActCe.pres;
1086          hqP->tbInfo[idx].sCellActCe.val  = allocInfo->tbInfo[idx].sCellActCe.val;
1087 #endif
1088
1089 #ifdef LTE_ADV
1090          if(( hqPAdded == TRUE) || (ROK == rgLaaPushHqPToScellLst(allocInfo,cell,timingInfo)))
1091          {
1092             hqPAdded = TRUE;
1093             continue;
1094          }
1095 #endif
1096          if (allocInfo->tbInfo[idx].schdDat[0].lcId == RG_CCCH_LCID)
1097          {
1098 #ifndef L2_OPTMZ
1099             RG_FREE_MSG(hqP->tbInfo[idx].tb);
1100 #else
1101            /* L2 optimization for mUe/Tti: Pre-allocated mBuf pointers(macHdr,
1102             * macCes and MacPad) of harq TB need to be reset to db_base
1103             */
1104            tb = &(hqP->tbInfo[idx].tb);
1105
1106            if (tb->tbPres == TRUE)
1107            {
1108               RG_FREE_TB(tb);
1109            }
1110 #endif
1111             hqP->tbInfo[0].contResCe  = allocInfo->tbInfo[0].contResCe;
1112             if(allocInfo->tbInfo[0].contResCe)
1113             {
1114                hqP->tbInfo[0].contResId = &ue->contResId;
1115             }
1116
1117
1118             if(allocInfo->tbInfo[idx].numSchLch == 0)
1119             {
1120                RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
1121                         "UEID:%d MSG4 with only contResId hqP(%d)",
1122                                 allocInfo->rnti,
1123                         hqP->procId);
1124                hqP->tbInfo[idx].numSchLch = 0;
1125                continue;
1126             }
1127
1128             /* Increamenting the tbIndex instead of
1129                assigning it to constant */
1130             tbIndex++;
1131
1132
1133             hqP->tbInfo[idx].numSchLch = 1;
1134             hqP->tbInfo[idx].schdData[0].lcId =
1135                allocInfo->tbInfo[idx].schdDat[0].lcId;
1136             hqP->tbInfo[idx].schdData[0].schdSz =
1137                allocInfo->tbInfo[idx].schdDat[0].numBytes;
1138
1139            // if(cStaInd == NULLP)
1140             {
1141                if ((rgAllocShrablSBuf(inst,(Data**)&cStaInd, sizeof(RguCStaIndInfo))) != ROK)
1142                {
1143                   err->errType  = RGERR_DHM_SND_STA_IND;
1144                   err->errCause = RG_DHM_MEM_ALLOC_FAIL;
1145                   RETVALUE(RFAILED);
1146                }
1147             }
1148
1149             idx1 = (hqP->procId << 2) | tbIndex;
1150
1151             cStaInd->cellId    = cell->cellId;
1152             cStaInd->rnti      = allocInfo->rnti;
1153             cStaInd->lcId      = cell->dlCcchId;
1154             cStaInd->transId   = (timingInfo.sfn << 16) |
1155                                  (timingInfo.slot << 8) | idx1;
1156                /* ADD Changes for Downlink UE Timing Optimization */
1157 #ifdef LTEMAC_DLUE_TMGOPTMZ
1158             dlSf->remDatReqCnt++;
1159 #endif
1160             RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId,
1161                                "RNTI:%d UE:MSG4 grant for CCCH hqP(%d) LCID:%d",
1162                      allocInfo->rnti,
1163                      hqP->procId,
1164                                cStaInd->lcId);
1165             /* Fix : syed Avoid return param for interface prim and
1166              * proceed for other UEs. For the failed UE, MAC shall
1167              * do padding. */
1168             rgUIMSndCmnStaInd(cell->macInst,cell->rguDlSap,cStaInd);
1169             break;
1170          }
1171          else
1172          {
1173             tbIndex+=idx+1;
1174 #ifndef L2_OPTMZ
1175             RG_FREE_MSG(hqP->tbInfo[idx].tb);
1176 #else
1177             /* L2 optimization for mUe/Tti: Pre-allocated mBuf pointers(macHdr,
1178              * macCes and MacPad) of harq TB need to be reset to db_base
1179              */
1180             tb = &(hqP->tbInfo[idx].tb);
1181             if (tb->tbPres == TRUE)
1182             {
1183                RG_FREE_TB(tb);
1184             }
1185 #endif
1186
1187             if((NULLP == dStaInd[rguDlSpId]) && (allocInfo->tbInfo[idx].numSchLch))
1188             {
1189                if ((rgAllocShrablSBuf (inst,(Data**)&dStaInd[rguDlSpId], sizeof(RguDStaIndInfo))) != ROK)
1190                {
1191                   err->errType  = RGERR_DHM_SND_STA_IND;
1192                   err->errCause = RG_DHM_MEM_ALLOC_FAIL;
1193                   /* Need to return as memory allocation will fail for other UEs also*/
1194                   RETVALUE(RFAILED);
1195                }
1196                dStaInd[rguDlSpId]->nmbOfUeGrantPerTti = 0;
1197                rguDlSap[rguDlSpId] = ue->rguDlSap;
1198                activeSapCnt++;
1199             }
1200
1201             for (lcIdx = 0;
1202                   lcIdx < allocInfo->tbInfo[idx].numSchLch; lcIdx++)
1203             {
1204                hqP->tbInfo[idx].schdData[lcIdx].lcId =
1205                   allocInfo->tbInfo[idx].schdDat[lcIdx].lcId;
1206                if (hqP->tbInfo[idx].schdData[lcIdx].lcId == 0)
1207                {
1208                   RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
1209                         "CCCH grant in DStaInd for LCID:%d CRNTI:%d",
1210                         hqP->tbInfo[idx].schdData[lcIdx].lcId,allocInfo->rnti);
1211                }
1212                hqP->tbInfo[idx].schdData[lcIdx].schdSz =
1213                   allocInfo->tbInfo[idx].schdDat[lcIdx].numBytes;
1214                if(dStaInd[rguDlSpId])
1215                {
1216                   dStaInd[rguDlSpId]->staInd[dStaInd[rguDlSpId]->nmbOfUeGrantPerTti].staIndTb[idx].\
1217                   lchStaInd[lcIdx].lcId = allocInfo->tbInfo[idx].\
1218                   schdDat[lcIdx].lcId;
1219                   dStaInd[rguDlSpId]->staInd[dStaInd[rguDlSpId]->nmbOfUeGrantPerTti].staIndTb[idx].\
1220                   lchStaInd[lcIdx].totBufSize = allocInfo->tbInfo[idx].\
1221                   schdDat[lcIdx].numBytes;
1222                }
1223
1224                lchBufSize+=allocInfo->tbInfo[idx].schdDat[lcIdx].numBytes;
1225             }
1226             hqP->tbInfo[idx].numSchLch =
1227                allocInfo->tbInfo[idx].numSchLch;
1228             if(dStaInd[rguDlSpId])
1229             {
1230                dStaInd[rguDlSpId]->staInd[dStaInd[rguDlSpId]->nmbOfUeGrantPerTti].staIndTb[idx].nmbLch =
1231                   allocInfo->tbInfo[idx].numSchLch;
1232 #ifdef LTE_L2_MEAS
1233                dStaInd[rguDlSpId]->staInd[dStaInd[rguDlSpId]->nmbOfUeGrantPerTti].staIndTb[idx].tbId =
1234                   hqP->tbId[idx];
1235 #endif
1236             }
1237             lchBufSize=0;
1238          }
1239       }
1240       //if((dStaInd) && (tbIndex) && (isDStaReqrd == TRUE))
1241       if((dStaInd[rguDlSpId]) && (tbIndex))
1242       {
1243          idx1 = (hqP->procId << 2) | tbIndex;
1244          /* Create RguDStaInd struct and send to UIM */
1245          dStaInd[rguDlSpId]->staInd[dStaInd[rguDlSpId]->nmbOfUeGrantPerTti].rnti    = allocInfo->rnti;
1246          /*
1247             dStaInd->transId = (hqP->timingInfo.sfn << 16) |
1248             (hqP->timingInfo.slot << 8) | hqP->procId;
1249           */
1250          dStaInd[rguDlSpId]->staInd[dStaInd[rguDlSpId]->nmbOfUeGrantPerTti].transId = (timingInfo.sfn << 16) |
1251             (timingInfo.slot << 8) | idx1;
1252          dStaInd[rguDlSpId]->staInd[dStaInd[rguDlSpId]->nmbOfUeGrantPerTti].nmbOfTbs = hqP->numOfTBs;
1253 #ifdef LTE_ADV
1254          dStaInd[rguDlSpId]->staInd[dStaInd[rguDlSpId]->nmbOfUeGrantPerTti].fillCtrlPdu = allocInfo->fillCtrlPdu;
1255 #endif
1256          /*increment num of UE as staInd is prepared for it */
1257          dStaInd[rguDlSpId]->nmbOfUeGrantPerTti++;
1258          /* ADD Changes for Downlink UE Timing Optimization */
1259 #ifdef LTEMAC_DLUE_TMGOPTMZ
1260          dlSf->remDatReqCnt++;
1261 #endif
1262       }
1263       //isDStaReqrd = FALSE;
1264       tbIndex = 0;
1265    }
1266
1267    for(idx = 0; idx < rgCb[inst].numRguSaps ; idx++)
1268    {
1269       if(dStaInd[idx] != NULLP)
1270       {
1271          dStaInd[idx]->cellId  = cell->cellId;
1272          /* Fix : syed Avoid return param for interface prim and
1273           * proceed for other UEs. For the failed UE, MAC shall
1274           * do padding. */
1275          rgUIMSndDedStaInd(inst,rguDlSap[idx],dStaInd[idx]);
1276
1277          staIndCnt++;
1278          if(staIndCnt == activeSapCnt)
1279             break;/* all valid staind are considered */
1280       }
1281
1282    }
1283    RETVALUE(ROK);
1284 }  /* rgDHMSndConsolidatedStaInd */
1285
1286
1287 /**
1288  * @brief Function to handle building the TFU Data Request
1289  *
1290  * @details
1291  *
1292  *     Function : rgDHMBldTfuDatReq
1293  *
1294  *     This function builds the TFU Data Request with the details
1295  *     present in HARQ Process.
1296  *
1297  *  @param[in]  RgDlHqProcCb     *hqP
1298  *  @param[out] TfuDatReqPduInfo  *datReq
1299  *  @return     Void
1300  *              None
1301  **/
1302 //U8 crashFlag = 0;
1303 #ifdef ANSI
1304 PRIVATE Void rgDHMBldTfuDatReq
1305 (
1306 RgCellCb           *cellCb,
1307 RgDlSf             *dlSf,
1308 RgDlHqProcCb       *hqP,
1309 RgTfuDatReqPduInfo *datReq
1310 )
1311 #else
1312 PRIVATE Void rgDHMBldTfuDatReq(cellCb, dlSf, hqP, datReq)
1313 RgCellCb           *cellCb;
1314 RgDlSf             *dlSf;
1315 RgDlHqProcCb       *hqP;
1316 RgTfuDatReqPduInfo *datReq;
1317 #endif
1318 {
1319
1320 #ifndef L2_OPTMZ
1321 #if !(!(defined TENB_ACC) && !(defined LTE_PAL_ENB))
1322    Inst inst;
1323 #elif defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD)
1324    Inst inst;
1325 #endif
1326 #endif
1327
1328    U8 i;
1329
1330 #ifdef L2_OPTMZ
1331    U32 lchIdx, pduIdx;
1332 #endif
1333    TRC2(rgDHMBldTfuDatReq)
1334
1335    datReq->nmbOfTBs = 0;
1336 #ifndef L2_OPTMZ
1337 #if !(!(defined TENB_ACC) && !(defined LTE_PAL_ENB))
1338    inst = cellCb->macInst - RG_INST_START;
1339 #elif defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD)
1340    inst = cellCb->macInst - RG_INST_START;
1341 #endif
1342 #endif
1343    /*MS_WORKAROUND  for ccpu00123904*/
1344    datReq->isTApres = FALSE;
1345 #ifdef TFU_ALLOC_EVENT_NO_INIT
1346 #ifndef L2_OPTMZ
1347    datReq->mBuf[0] = 0;
1348    datReq->mBuf[1] = 0;
1349 #endif
1350 #endif
1351
1352    for(i=0;i<RG_MAX_TB_PER_UE;i++)
1353    {
1354 #ifndef L2_OPTMZ
1355       if ((hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sf == dlSf) &&
1356           (hqP->tbInfo[i].tb != NULLP))
1357 #else
1358       if ((hqP->tbInfo[i].sfLnkInfo[dlSf->schdTime.slot % 2].sf == dlSf) &&
1359            RgUtlIsTbMuxed(&(hqP->tbInfo[i].tb)))
1360 #endif
1361       {
1362
1363          datReq->rnti           =  hqP->tbInfo[i].pdcch.rnti;
1364          datReq->dciInfo        =  hqP->tbInfo[i].pdcch.dci;
1365          datReq->doa            =  hqP->tbInfo[i].doa;
1366          datReq->transMode      =  hqP->tbInfo[i].txMode;
1367          datReq->puschRptUsd    =  hqP->tbInfo[i].puschRptUsd;
1368          datReq->puschPmiInfo   =  hqP->tbInfo[i].puschPmiInfo;
1369          /*MS_WORKAROUND  for ccpu00123904*/
1370          if (hqP->tbInfo[i].schdTa.pres)
1371          {
1372             datReq->isTApres       =  TRUE;
1373          }
1374 #ifdef   TFU_UPGRADE
1375          /* update pA value */
1376          datReq->pa             =  hqP->tbInfo[i].pa;
1377 #endif
1378          /* LTE_ADV_FLAG_REMOVED_START */
1379          datReq->isEnbSFR       =  hqP->tbInfo[i].isEnbSFR;
1380          /* LTE_ADV_FLAG_REMOVED_END */
1381 #ifndef L2_OPTMZ
1382 #if (!(defined TENB_ACC) && !(defined LTE_PAL_ENB))  /* ABHI */ /* This is only temp fix. It needs to be removed
1383                                 after rebasing to MAC CCB */
1384 #ifdef BRDCM
1385          datReq->mBuf[i] = hqP->tbInfo[i].tb;
1386 #else
1387          /* Intel Tdd- Commenting out the Optimization for direct Access of
1388           * mBuf Index */
1389          /*Proper clean-up needed as this needs long stability tests
1390           * in all SoCs*/
1391 #if defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD)
1392          SIncMsgRef(hqP->tbInfo[i].tb, RG_GET_MEM_REGION(rgCb[inst]),
1393                RG_GET_MEM_POOL(rgCb[inst]), &datReq->mBuf[i]);
1394 #else
1395          datReq->mBuf[i] = hqP->tbInfo[i].tb;
1396 #endif
1397 #endif/*BRDCM*/
1398 #else
1399          SIncMsgRef(hqP->tbInfo[i].tb, RG_GET_MEM_REGION(rgCb[inst]),
1400                RG_GET_MEM_POOL(rgCb[inst]), &datReq->mBuf[i]);
1401 #endif
1402          {
1403             MsgLen   dbgBufLen;
1404             if(SFndLenMsg(datReq->mBuf[i], &dbgBufLen))
1405             {
1406                if(dbgBufLen == 0)
1407                {
1408                   RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
1409                                           "RNTI:%d SFN:%d slot:%d tbIdx:%d Sdu Length 0 ",
1410                               datReq->rnti,
1411                                       hqP->tbInfo[i].timingInfo.sfn,
1412                                           hqP->tbInfo[i].timingInfo.slot,i);
1413                   RLOG_ARG3(L_ERROR,DBG_CELLID,cellCb->cellId,
1414                               "taPres [%d] numOfTbs [%d] format[%d]",
1415                               datReq->isTApres,
1416                            hqP->numOfTBs,
1417                            datReq->dciInfo.format);
1418                }
1419             }
1420          }
1421 #else
1422          /* L2 optimization for mUe/Tti: Removing SIncMsgRef to avoid additional
1423           * mBuf allocation. MAC header, MAC Ces, MAC PDU per LCH per TB Per UE
1424           * and MAC padding Mbufs are being sent to CL. Populating these Ptrs
1425           * From TB Info to TfuDatReq
1426           */
1427          datReq->tbInfo[i].tbPres =  TRUE;
1428          datReq->tbInfo[i].tbSize =  hqP->tbInfo[i].tbSz;
1429          datReq->tbInfo[i].macHdr =  hqP->tbInfo[i].tb.macHdr;
1430          datReq->tbInfo[i].macCes =  hqP->tbInfo[i].tb.macCes;
1431          datReq->tbInfo[i].numLch =  hqP->tbInfo[i].tb.numLch;
1432          for(lchIdx = 0; lchIdx < hqP->tbInfo[i].tb.numLch; lchIdx++)
1433          {
1434             datReq->tbInfo[i].lchInfo[lchIdx].numPdu = hqP->tbInfo[i].tb.\
1435                                                        lchInfo[lchIdx].numPdu;
1436             for(pduIdx = 0; pduIdx < hqP->tbInfo[i].tb.lchInfo[lchIdx].numPdu;\
1437                   pduIdx++)
1438             {
1439                datReq->tbInfo[i].lchInfo[lchIdx].mBuf[pduIdx] =
1440                   hqP->tbInfo[i].tb.lchInfo[lchIdx].mBuf[pduIdx];
1441             }
1442          }
1443         // datReq->tbInfo[i].macPad  =  hqP->tbInfo[i].tb.macPad;
1444          datReq->tbInfo[i].padSize =  hqP->tbInfo[i].tb.padSize;
1445         // prc_trace_format_string(0x40,3,"TfuDatReq:RNTI=%d TbIdx=%d TbSize=%d PdSz=(%d) macHdraddr: (%p) macCEAddr: (%p) noLch=(%d)",datReq->rnti, i,
1446           //     hqP->tbInfo[i].tbSz, datReq->tbInfo[i].padSize, datReq->tbInfo[i].macHdr, datReq->tbInfo[i].macCes, datReq->tbInfo[i].numLch);
1447
1448 #endif
1449          datReq->nmbOfTBs++;
1450       }
1451    }
1452    RETVOID;
1453 }  /* rgDHMBldTfuDatReq */
1454
1455
1456 #ifdef L2_OPTMZ
1457 /**
1458  * @brief This function releases a HARQ process
1459  *
1460  * @details
1461  *
1462  *     Function: rgDHMFreeHqProcTB
1463  *     Purpose:  This function returns a HARQ process to HARQ Entity
1464  *               in the DL direction.
1465  *
1466  *               1. Add the HARQ process to the free queue.
1467  *     Invoked by: scheduler and HARQ processing
1468  *
1469  *  @param[in]  RgDlHqProc    *hqP
1470  *  @return  Void
1471  *
1472  **/
1473 #ifdef ANSI
1474 PUBLIC S16 rgDHMFreeHqProcTB
1475 (
1476 RgDlHqProcCb         *hqP,
1477 U8                   tbIndex
1478 )
1479 #else
1480 PUBLIC S16 rgDHMFreeHqProcTB(hqP, tbIndex)
1481 RgDlHqProcCb         *hqP;
1482 U8                   tbIndex;
1483 #endif
1484 {
1485    RgTfuDatReqTbInfo     *tb;   /* TB to be sent to CL/PHY*/
1486    U8                    idx;
1487
1488    TRC2(rgDHMFreeHqProcTB)
1489
1490    if((tbIndex > RG_MAX_TB_PER_UE) ||
1491       (tbIndex == 0))
1492    {
1493       RETVALUE(RFAILED);
1494    }
1495
1496    tb = &(hqP->tbInfo[tbIndex-1].tb);
1497    RG_FREE_MSG(tb->macHdr);
1498    RG_FREE_MSG(tb->macCes);
1499
1500    for(idx = 0; idx < 2; idx++)
1501    {
1502       if (hqP->tbInfo[tbIndex-1].sfLnkInfo[idx].sfLnk.node != NULLP)
1503    {
1504          cmLListDelFrm(&hqP->tbInfo[tbIndex-1].sfLnkInfo[idx].sf->tbs,
1505                &(hqP->tbInfo[tbIndex-1].sfLnkInfo[idx].sfLnk));
1506          hqP->tbInfo[tbIndex-1].sfLnkInfo[idx].sfLnk.node  = (PTR)NULLP;
1507       printf("\nrgDHMFreeHqProcTB:: hqP %p \n", (Void *)hqP);
1508    }
1509       hqP->tbInfo[tbIndex-1].sfLnkInfo[idx].sf = NULLP;
1510    }
1511    RETVALUE(ROK);
1512 }
1513 #endif
1514
1515
1516
1517 /**
1518  * @brief Handler for freeing up the harq related information from ueCb
1519  *
1520  * @details
1521  *
1522  *     Function : rgDHMFreeUe
1523  *
1524  *     This function shall free up the HARQ specific information from ueCb.
1525  *
1526  *  @param[in]  Inst        inst
1527  *  @param[in]  RgDlHqEnt     *hqE
1528  *
1529  *  @return     None.
1530  *
1531  **/
1532 #ifdef ANSI
1533 PUBLIC Void rgDHMFreeUe
1534 (
1535 Inst               inst,
1536 RgDlHqEnt          *hqE
1537 )
1538 #else
1539 PUBLIC Void rgDHMFreeUe(inst,hqE)
1540 Inst               inst;
1541 RgDlHqEnt          *hqE;
1542 #endif
1543 {
1544    U8             i;
1545    TRC2(rgDHMFreeUe)
1546
1547    if(hqE->procs)
1548    {
1549       /* Free all the memory associated with HARQ */
1550       for (i=0; i < hqE->numHqProcs; i++)
1551       {
1552 #ifndef L2_OPTMZ
1553          rgDHMRlsHqProcTB(rgCb[inst].cell, hqE->procs[i], 1);
1554          rgDHMRlsHqProcTB(rgCb[inst].cell, hqE->procs[i], 2);
1555 #else
1556          rgDHMFreeHqProcTB(hqE->procs[i], 1);
1557          rgDHMFreeHqProcTB(hqE->procs[i], 2);
1558 #endif
1559
1560          rgFreeSBuf(inst,(Data **)&(hqE->procs[i]), sizeof(RgDlHqProcCb));
1561 #ifdef LTE_ADV
1562          rgDHMFreeSavedHqP(inst,hqE,i);
1563 #endif
1564       }
1565
1566       /*ccpu00117052 - MOD - Passing double pointer for proper NULLP
1567                             assignment */
1568    }
1569
1570    RETVOID;
1571
1572 }  /* rgDHMFreeUe */
1573 /**
1574  * @brief Function for handling RaResp request received from scheduler to MAC
1575  *
1576  * @details
1577  *
1578  *     Function : RgSchMacRstHqEntReq
1579  *
1580  *     This function shall be invoked whenever a sec cell of an ue
1581  *     is deactivated. MAC needs to reset the harqentity associated
1582  *     with the deactivated scell of the ue
1583  *
1584  *
1585  *  @param[in] Pst             *pst
1586  *  @param[in] RgInfResetHqEnt *hqEntInfo
1587  *  @return  S16
1588  *      -# ROK
1589  **/
1590 #ifdef ANSI
1591 PUBLIC S16 RgSchMacRstHqEntReq
1592 (
1593 Pst*                 pst,
1594 RgInfResetHqEnt*     hqEntInfo
1595 )
1596 #else
1597 PUBLIC S16 RgSchMacRstHqEntReq(pst, hqEntInfo)
1598 Pst*                 pst;
1599 RgInfResetHqEnt*     hqEntInfo;
1600 #endif
1601 {
1602    Inst      inst;
1603    RgCellCb  *cell;
1604    RgUeCb    *ue;
1605
1606    inst = pst->dstInst - RG_INST_START;
1607
1608    if (((cell = rgCb[inst].cell) == NULLP) ||
1609        (rgCb[inst].cell->cellId != hqEntInfo->cellId))
1610    {
1611       RGDBGERRNEW(inst,(rgPBuf(inst), "For user [%d]Cell does not exist %d\n",
1612                 hqEntInfo->crnti,hqEntInfo->cellId));
1613       RETVALUE(RFAILED);
1614    }
1615
1616    if ((ue = rgDBMGetUeCb(cell, hqEntInfo->crnti)) == NULLP)
1617    {
1618       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE does not exist for this hqEntInfo\n",
1619                        hqEntInfo->crnti));
1620       RETVALUE(RFAILED);
1621    }
1622
1623    rgDHMUeReset(cell, &ue->dl.hqEnt);
1624
1625    RETVALUE(ROK);
1626 }
1627 U32 gSaveVal;
1628 \f
1629 /**
1630  * @brief Function for handling RaResp request received from scheduler to MAC
1631  *
1632  * @details
1633  *
1634  *     Function : RgSchMacRlsHqReq
1635  *
1636  *     This function shall be invoked whenever scheduler is done with the
1637  *     allocations of random access responses for a slot.
1638  *     This shall invoke RAM to create ueCbs for all the rapIds allocated and
1639  *     shall invoke MUX to create RAR PDUs for raRntis allocated.
1640  *
1641  *
1642  *  @param[in] CmLteCellId         cellId,
1643  *  @param[in] CmLteTimingInfo     timingInfo,
1644  *  @param[in] RaRespInfo          *rarInfo
1645  *  @return  S16
1646  *      -# ROK
1647  **/
1648 #ifdef ANSI
1649 PUBLIC S16 RgSchMacRlsHqReq
1650 (
1651 Pst                 *pst,
1652 RgInfRlsHqInfo      *rlshqUeInfo
1653 )
1654 #else
1655 PUBLIC S16 RgSchMacRlsHqReq(pst, rlshqUeInfo)
1656 Pst                 *pst;
1657 RgInfRlsHqInfo      *rlshqUeInfo;
1658 #endif
1659 {
1660    Inst           inst;
1661    RgCellCb       *cell = NULLP;
1662    RgUeCb         *ue;
1663    RgDlHqProcCb   *hqP;
1664    U8             idx1,idx2;
1665 #ifdef LTE_L2_MEAS
1666    U8                tbId;
1667    RguHarqStatusInd  hqStaInd;
1668    Bool              isValidTbId = FALSE;
1669 #endif
1670    U32        startTime=0;
1671
1672    TRC2(RgSchMacRlsHqReq)
1673
1674    RG_IS_INST_VALID(pst->dstInst);
1675    inst = pst->dstInst - RG_INST_START;
1676    cell  = rgCb[inst].cell;
1677    /*starting Task*/
1678    SStartTask(&startTime, PID_MAC_AM_HARQ_RLS);
1679
1680    if(NULLP == rlshqUeInfo)
1681    {
1682       RETVALUE(RFAILED);
1683    }
1684
1685    if((cell  == NULLP)
1686       ||( cell->cellId != rlshqUeInfo->cellId))
1687    {
1688
1689       RLOG_ARG0(L_ERROR,DBG_CELLID,rlshqUeInfo->cellId,
1690                 "No cellCb found with cellId");
1691       RETVALUE(RFAILED);
1692    }
1693
1694    if(NULLP == rlshqUeInfo->ueHqInfo)
1695    {
1696       RETVALUE(RFAILED);
1697    }
1698
1699    for(idx1 = 0; idx1 < rlshqUeInfo->numUes; idx1++)
1700    {
1701       if((ue=rgDBMGetUeCb (cell, rlshqUeInfo->ueHqInfo[idx1].rnti)) == NULLP)
1702       {
1703          /* Check in RachLst */
1704          if((ue=rgDBMGetUeCbFromRachLst (cell,
1705                      rlshqUeInfo->ueHqInfo[idx1].rnti)) == NULLP)
1706          {
1707             RLOG_ARG1(L_ERROR,DBG_CELLID,rlshqUeInfo->cellId, "CRNTI:%d No ueCb found",
1708                      rlshqUeInfo->ueHqInfo[idx1].rnti);
1709             continue;
1710          }
1711       }
1712 #ifdef LTE_ADV
1713 #ifdef LAA_DBG
1714      if ((rlshqUeInfo->ueHqInfo[idx1].rlsOperationType && !gSaveVal) || (rlshqUeInfo->ueHqInfo[idx1].hqProcId > 8))
1715       {
1716          int *p = NULL;
1717          RLOG_ARG1(L_INFO," SPURIOUS CALLL !!!! procId %d \n", rlshqUeInfo->ueHqInfo[idx1].hqProcId);
1718
1719
1720        printf ("RgSchMacRlsHqReq cell %d : numUes %d idx %d rnti %d hqProc %d numTbs %d tbid[0] %d tbid[1] %d rlsopr %d \n",
1721       cell->cellId,
1722        rlshqUeInfo->numUes,
1723        idx1,
1724        rlshqUeInfo->ueHqInfo[idx1].rnti,
1725        rlshqUeInfo->ueHqInfo[idx1].hqProcId,
1726        rlshqUeInfo->ueHqInfo[idx1].numOfTBs,
1727        rlshqUeInfo->ueHqInfo[idx1].tbId[0],
1728        rlshqUeInfo->ueHqInfo[idx1].tbId[1],
1729        rlshqUeInfo->ueHqInfo[idx1].rlsOperationType);
1730
1731          *p = 10;
1732       }
1733 #endif
1734       gSaveVal = 0;
1735
1736
1737       RgSchMacHndlRelReq(cell, ue, &rlshqUeInfo->ueHqInfo[idx1]);
1738
1739       if (RGINF_RLS_HQ_DEL_TB == rlshqUeInfo->ueHqInfo[idx1].rlsOperationType)
1740       {
1741          /* If REQ is to DEL the saved TBs no need to free the HqP as it's already
1742             freed up earlier */
1743          continue;
1744       }
1745 #endif /* LTE_ADV */
1746       rgDHMGetHqProcFrmId(ue,rlshqUeInfo->ueHqInfo[idx1].hqProcId,&hqP);
1747       if(rlshqUeInfo->ueHqInfo[idx1].status[0] != TRUE)
1748       {
1749          rgCb[inst].genSts.numHarqFail++;
1750       }
1751
1752 #ifdef LTE_L2_MEAS
1753       hqStaInd.cellId = cell->cellId;
1754       hqStaInd.ueId = rlshqUeInfo->ueHqInfo[idx1].rnti;
1755       hqStaInd.numTbs = rlshqUeInfo->ueHqInfo[idx1].numOfTBs;
1756 #endif
1757
1758       for(idx2=0; idx2 < rlshqUeInfo->ueHqInfo[idx1].numOfTBs; idx2++)
1759       {
1760 #ifdef LTE_L2_MEAS
1761          /* Fill the hq sta Ind stucture. Need to send the Status Ind for only
1762           those TBID's reported by Scheduler*/
1763             tbId = rlshqUeInfo->ueHqInfo[idx1].tbId[idx2];
1764             if (hqP->tbId[tbId-1] != RGU_INVALID_TBID)
1765             {
1766             /* Fill the correct Sn Map corresponding to the TBID */
1767             hqStaInd.tbId[idx2] = hqP->tbId[tbId-1];
1768             hqStaInd.status[idx2] = rlshqUeInfo->ueHqInfo[idx1].status[idx2];
1769                isValidTbId = TRUE;
1770             }
1771 #endif
1772          if(rgDHMRlsHqProcTB(cell, hqP,
1773                rlshqUeInfo->ueHqInfo[idx1].tbId[idx2]) != ROK)
1774          {
1775             RLOG_ARG1(L_ERROR,DBG_CELLID,rlshqUeInfo->cellId,
1776                   "CRNTI:%d Failure in releasing hq TB",
1777                   rlshqUeInfo->ueHqInfo[idx1].rnti);
1778             continue;
1779          }
1780       }
1781
1782 #ifdef LTE_L2_MEAS
1783
1784          if (isValidTbId)
1785          {
1786             if(ue->rguDlSap)
1787             {
1788                RgUiRguHqStaInd(&(ue->rguDlSap->sapCfg.sapPst),
1789                      ue->rguDlSap->sapCfg.suId,
1790                      &hqStaInd);
1791             }
1792             else
1793             {/* Ue is from rach list*/
1794                RgUiRguHqStaInd(&(cell->rguDlSap->sapCfg.sapPst),
1795                      cell->rguDlSap->sapCfg.suId,
1796                      &hqStaInd);
1797             }
1798          }
1799 #endif
1800    } /* end of ues loop */
1801
1802    /*starting Task*/
1803    SStopTask(startTime,PID_MAC_AM_HARQ_RLS);
1804
1805    RETVALUE(ROK);
1806 } /* end of RgSchMacRlsHqReq */
1807
1808
1809 /**********************************************************************
1810
1811          End of file
1812 **********************************************************************/