RAR_message
[o-du/l2.git] / src / 5gnrmac / rg_dux.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_dux.c 
28   
29 **********************************************************************/
30
31 /** @file rg_dux.c
32 @brief This module handles de-multiplexing of the data recieved at MAC.
33 */
34
35 static const char* RLOG_MODULE_NAME="MAC";
36 static int RLOG_FILE_ID=176;
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   
43 #include "gen.h"           /* general */
44 #include "ssi.h"           /* system services */
45
46 #include "cm_lte.h"        /* Common LTE */
47 #include "cm_tkns.h"       /* Common Token Defines */
48 #include "cm_llist.h"      /* Common Link List Defines */
49 #include "cm_hash.h"       /* Common Hash List Defines */
50 #include "cm_mblk.h"       /* common memory link list library */
51
52 #include "rg_env.h"        /* MAC Environment Defines */
53 #include "tfu.h"           /* CRG Interface defines */
54 #include "crg.h"           /* CRG Interface defines */
55 #include "rg_sch_inf.h"           /* RGR Interface defines */
56 #include "rgu.h"           /* RGU Interface defines */
57 #include "lrg.h"           /* LRG Interface defines */
58
59 #include "rg.h"            /* MAC defines */
60 #include "rg_err.h"        /* MAC error defines */
61
62 /* header/extern include files (.x) */
63 #include "gen.x"           /* general */
64 #include "ssi.x"           /* system services */
65 #include "cm5.x"           /* common timers */
66 #include "cm_lib.x"        /* common library */
67 #include "cm_lte.x"        /* Common LTE */
68 #include "cm_tkns.x"       /* Common Token Definitions */
69 #include "cm_llist.x"      /* Common Link List Definitions */
70 #include "cm_lib.x"        /* Common Library Definitions */
71 #include "cm_hash.x"       /* Common Hash List Definitions */
72 #include "cm_mblk.x"       /* common memory link list library */
73
74 #include "rgu.x"           /* RGU types */
75 #include "tfu.x"           /* CRG Interface includes */
76 #include "crg.x"           /* CRG Interface includes */
77 #include "rg_sch_inf.x"    /* SCH Interface includes */
78 #include "rg_prg.x"        /* PRG interface includes */
79 #include "rgu.x"           /* RGU Interface includes */
80 #include "lrg.x"           /* LRG Interface includes */
81
82 #include "du_app_mac_inf.h"
83 #include "rg.x"            /* MAC includes */
84
85 /* local defines */
86
87 /* local typedefs */
88  
89 /* local externs */
90  
91 /* forward references */
92
93 #define RG_DUX_ALLOC(_pdu, _size, _dataPtr, _ret) {\
94    _ret = cmGetMem((Ptr)&_pdu->memCp, _size, (Ptr *)&_dataPtr); \
95 }
96
97 #define RG_INIT_SDU(_sdu, _lcId, _len) {\
98    (_sdu)->lcId = (_lcId); \
99    (_sdu)->len = (_len); \
100    (_sdu)->mBuf = NULLP; \
101    (_sdu)->sduLstEnt.next = NULLP; \
102    (_sdu)->sduLstEnt.prev = NULLP; \
103    (_sdu)->sduLstEnt.node = (PTR)(_sdu); \
104 }
105
106 #define RG_EXT_BS(_bsr, _bs1, _bs2, _bs3, _bs4)  {\
107    _bs1 = _bsr[0] >> 2; \
108    _bs2 = (((_bsr[0] & 0x3) << 4) | (_bsr[1] >> 4)); \
109    _bs3 = (((_bsr[1] & 0x0F) << 2) | (_bsr[2] >> 6)); \
110    _bs4 = _bsr[2] & 0x3F; \
111 }
112
113 #define RG_UNPACK_LONG_BSR(_bsr, _mBuf, _ret) {\
114    _ret = SRemPreMsgMult((_bsr), 3, (_mBuf)); \
115 }
116
117 #define RG_UNPACK_SHORT_BSR(_bsr, _mBuf, _ret) {\
118    _ret = SUnpkU8((_bsr), (_mBuf)); \
119 }
120
121 #define RG_UNPACK_TRUNC_BSR(_bsr, _mBuf, _ret) {\
122    _ret = SUnpkU8((_bsr), (_mBuf)); \
123 }
124
125 #define RG_UNPACK_PHR(_phr, _mBuf, _ret) {\
126    _ret = SUnpkU8((_phr), (_mBuf)); \
127 }
128
129 #define RG_UNPACK_CRNTI(_rnti, _mBuf, _ret) {\
130    Data _unpkArray[2];\
131    *_rnti = 0;\
132    _ret = SRemPreMsgMult(_unpkArray, (MsgLen) 2, _mBuf);\
133    if (_ret == ROK)\
134    {\
135       *_rnti = (U16) PutHiByte(*_rnti, (U8) _unpkArray[0]);\
136       *_rnti = (U16) PutLoByte(*_rnti, (U8) _unpkArray[1]);\
137    }\
138 }
139
140 /* For EXT PHR DEMUX */
141 #define RG_UNPACK_EXT_PHR_CI(_ci, _mBuf, _ret) {\
142    _ret = SUnpkU8((_ci), (_mBuf)); \
143 }
144
145 #define RG_UNPACK_EXT_PHR(_extPhr, _mBuf, _ret) {\
146    _ret = SUnpkU8((_extPhr), (_mBuf)); \
147 }
148
149
150
151 /**
152  * @brief Handles the insertion of SDU in to PDU.
153  *
154  * @details
155  *
156  *     Function: rgDUXInsSdu
157  *     
158  *     This API handles the insertion of SDU in to PDU.
159  *     
160  *     Processing Steps: 
161  *      - Append the sdu to the sduLst of pdu.
162  *
163  *  @param[in]  Inst        inst
164  *  @param[out] *pdu
165  *  @param[in]  lcId
166  *  @param[in]  sduLen
167  *  @param[out] *err
168  *  @return  S16
169  *      -# ROK 
170  *      -# RFAILED 
171  **/
172 #ifdef ANSI
173 PRIVATE S16 rgDUXInsSdu
174 (
175 Inst        inst,
176 RgMacPdu    *pdu,
177 RgMacSdu    **sdu,
178 U8          lcId,
179 U16         sduLen,
180 RgErrInfo   *err
181 )
182 #else
183 PRIVATE S16 rgDUXInsSdu(inst,pdu, sdu, lcId, sduLen, err)
184 Inst        inst;
185 RgMacPdu    *pdu;
186 RgMacSdu    **sdu,
187 U8          lcId;
188 U16         sduLen;
189 RgErrInfo   *err;
190 #endif
191 {
192    S16         ret;
193    RgMacSdu    *sduAloc = NULLP;
194
195    TRC2(rgDUXInsSdu)
196
197    RG_DUX_ALLOC(pdu, sizeof(RgMacSdu), sduAloc, ret);
198    if(ret != ROK)
199    {
200       RLOG1(L_ERROR, "Allocation of RgSubHdr failed for LCID:%d",lcId);
201       err->errCause = RGERR_DUX_MEM_EXHAUST;
202       RETVALUE(RFAILED);
203    }
204    *sdu = sduAloc; 
205    RG_INIT_SDU(sduAloc, lcId, sduLen);
206    cmLListAdd2Tail(&pdu->sduLst, &sduAloc->sduLstEnt);
207    RETVALUE(ROK);
208 }
209
210 /**
211  * @brief Handles extracting the CE sub headers from the MAC PDU.
212  *
213  * @details
214  *
215  *     Function: rgDUXExtSubHdr
216  *     
217  *     This API handles extracting the  sub headers from the MAC PDU.
218  *     
219  *     Processing Steps: 
220  *      - Extract the each sub header.
221  *
222  *  @param[in]  Inst        inst
223  *  @param[out]  *pdu
224  *  @param[in]  *mBuf
225  *  @param[out] *lcId
226  *  @param[out] *len
227  *  @param[out] *err
228  *  @return  S16
229  *      -# ROK 
230  *      -# RFAILED 
231  **/
232 #ifdef ANSI
233 PRIVATE S16 rgDUXExtSubHdr
234 (
235 Inst        inst,
236 RgMacPdu    *pdu,
237 Buffer      *mBuf,
238 U8          *lcId,
239 U16         *len,
240 RgErrInfo   *err
241 )
242 #else
243 PRIVATE S16 rgDUXExtSubHdr(inst,pdu, mBuf, lcId,
244 len, err)
245 Inst        inst;
246 RgMacPdu    *pdu;
247 Buffer      *mBuf;
248 U8          *lcId;
249 U16         *len;
250 RgErrInfo   *err;
251 #endif
252 {
253    U8             byte;
254    U8             fmt=0;
255  
256    TRC2(rgDUXExtSubHdr)
257
258    *len = 0;   
259    if(SUnpkU8(&byte,mBuf) != ROK)
260    {
261       RLOG0(L_ERROR, "SUnpkU8 failed");
262       err->errCause = RGERR_DUX_UNPACK_FAILURE;
263       RETVALUE(RFAILED);
264    }
265    /* Extract the lcid */
266    RG_EXT_LCID(*lcId, byte);
267
268    /*note: RG_EXT_PHR_LCID currently not considered */
269    if(*lcId <= RG_DEDLC_MAX_LCID)
270    {  /* variable size MAC Sub PDU */
271       RG_EXT_FORMT_BIT(fmt,byte);
272       if(SUnpkU8(&byte, mBuf) != ROK)
273       {
274          RLOG0(L_ERROR, "SUnpkU8 failed");
275          err->errCause = RGERR_DUX_UNPACK_FAILURE;
276          RETVALUE(RFAILED);
277       }
278       *len = byte;
279       if(fmt)
280       {
281          if(SUnpkU8(&byte,mBuf) != ROK)
282          {
283             RLOG0(L_ERROR, "SUnpkU8 failed");
284             err->errCause = RGERR_DUX_UNPACK_FAILURE;
285             RETVALUE(RFAILED);
286          }
287          *len = (*len << 8) | byte;
288       }
289    }
290    RETVALUE(ROK);
291 } /* rgDUXExtSubHdr */
292
293 /**
294  * @brief Handles extracting the CEs from the MAC PDU.
295  *
296  * @details
297  *
298  *     Function: rgDUXExtCe
299  *     
300  *     This API handles extracting the CEs from the MAC PDU.
301  *     
302  *     Processing Steps: 
303  *      - Based on the ce sub header extract the ce.
304  *
305  *  @param[in]  Inst        inst
306  *  @param[in,out]  *pdu
307  *  @param[out] *ceInfo
308  *  @param[in]  *mBuf
309  *  @param[in] lcId
310  *  @param[in] subPduLen
311  *  @param[out] *err
312  *  @return  S16
313  *      -# ROK 
314  *      -# RFAILED 
315  **/
316 #ifdef ANSI
317 PRIVATE S16 rgDUXExtCe
318 (
319 Inst        inst,
320 RgMacPdu    *pdu,
321 RgInfCeInfo  *ceInfo,
322 Buffer       *mBuf,
323 U8          lcId,
324 U16         subPduLen,
325 RgErrInfo    *err
326 )
327 #else
328 PRIVATE S16 rgDUXExtCe(inst,pdu, ceInfo, mBuf,lcId,subPduLen, err)
329 Inst        inst;
330 RgMacPdu    *pdu;
331 RgInfCeInfo  *ceInfo;
332 Buffer       *mBuf;
333 U8          lcId;
334 U16         subPduLen;
335 RgErrInfo    *err;
336 #endif
337 {
338    S16            ret;
339
340    TRC2(rgDUXExtCe);
341
342    switch(lcId)
343    {
344       case RG_EXT_PHR_LCID:
345          {
346             U8 Ci;
347             U8 sCellIdx;
348             U8 extPhrOctet;
349             U8 extPhrPCmax;
350             RgInfExtPhrCEInfo *extPhr;
351
352             RG_UNPACK_EXT_PHR_CI(&Ci,mBuf,ret);
353             if(ret != ROK)
354             {
355                RLOG1(L_ERROR,"Unpacking of EXT PHR failed LCID:%d",lcId);
356                err->errCause = RGERR_DUX_UNPACK_FAILURE;
357                RETVALUE(RFAILED);
358             }
359
360             /* Not handling Type 2 PHR report as simultaneous PUSCH/PUCCH
361                is not supported as of now */
362             extPhr = &ceInfo->ces.extPhr;
363             extPhr->numServCells = 0;
364
365             /* Setting first BIT as PCELL field even though reserved is always
366                reported by UE */
367             Ci |= 0x1;
368             for (sCellIdx = 0; (Ci && sCellIdx < CM_LTE_MAX_CELLS); sCellIdx++)
369             {
370                if (Ci & 0x1)
371                {
372                   extPhr->servCellPhr[extPhr->numServCells].sCellIdx = sCellIdx;
373                   RG_UNPACK_EXT_PHR(&extPhrOctet,mBuf,ret);
374                   if(ret != ROK)
375                   {
376                      RLOG1(L_ERROR,"Unpacking of EXT PHR failed LCID:%d",lcId);
377                      err->errCause = RGERR_DUX_UNPACK_FAILURE;
378                      RETVALUE(RFAILED);
379                   }
380
381                   /* extPhrOctet: Bits : 7 6 5 4 3 2 1 0
382                    *                     P V x x x x x x
383                    *                         <6x Bit phr>
384                    */
385                   /* P : P Back off applied or not */
386                   extPhr->servCellPhr[extPhr->numServCells].phr = (extPhrOctet & 0x3F);
387                   extPhr->servCellPhr[extPhr->numServCells].pBackOff = 
388                      ((extPhrOctet >> 7) & 0x01);
389
390                   /* V: Virtual PCMAX or Real Tx PCMAX */
391                   if (extPhrOctet & 0x40)
392                   {
393                      extPhr->servCellPhr[extPhr->numServCells].pCmax = RG_REF_PCMAX;
394                   }
395                   else
396                   {
397                      RG_UNPACK_EXT_PHR(&extPhrPCmax,mBuf,ret);
398                      if(ret != ROK)
399                      {
400                         RLOG1(L_ERROR,"Unpacking of EXT PHR failed LCID:%d",lcId);
401                         err->errCause = RGERR_DUX_UNPACK_FAILURE;
402                         RETVALUE(RFAILED);
403                      }
404                      extPhr->servCellPhr[extPhr->numServCells].pCmax = (extPhrPCmax & 0x3F);
405                   }
406                   extPhr->numServCells++;
407                }
408                Ci >>= 1;
409             }
410
411             ceInfo->bitMask |= RG_EXT_PHR_CE_PRSNT;
412          }
413          break;
414
415       case RG_PHR_LCID:
416          {
417             RG_UNPACK_PHR(&ceInfo->ces.phr,mBuf,ret);
418             if(ret != ROK)
419             {
420                RLOG1(L_ERROR,"Unpacking of PHR failed LCID:%d",lcId);
421                err->errCause = RGERR_DUX_UNPACK_FAILURE;
422                RETVALUE(RFAILED);
423             }
424             ceInfo->bitMask |= RG_PHR_CE_PRSNT;
425          }
426          break;
427       case RG_TRUNC_BSR_LCID:
428          {
429             RG_UNPACK_TRUNC_BSR(&ceInfo->ces.bsr.truncBsr,mBuf,ret);
430             if(ret != ROK)
431             {
432                RLOG1(L_ERROR,"Unpacking of Trunc BSR failed LCID:%d",lcId);
433                err->errCause = RGERR_DUX_UNPACK_FAILURE;
434                RETVALUE(RFAILED);
435             }
436             ceInfo->bitMask |= RG_TRUNC_BSR_CE_PRSNT;
437          }
438          break;
439       case RG_SHORT_BSR_LCID:
440          {
441             RG_UNPACK_SHORT_BSR(&ceInfo->ces.bsr.shortBsr,mBuf,ret);
442             if(ret != ROK)
443             {
444                RLOG1(L_ERROR,"Unpacking of Short BSR failed LCID:%d",lcId);
445                err->errCause = RGERR_DUX_UNPACK_FAILURE;
446                RETVALUE(RFAILED);
447             }
448             ceInfo->bitMask |= RG_SHORT_BSR_CE_PRSNT;
449          }
450          break;
451       case RG_LONG_BSR_LCID:
452          {
453             U8 longBsr[3] = {0}; /* KW_FIXX */
454             RG_UNPACK_LONG_BSR(longBsr,mBuf,ret);
455             if(ret != ROK)
456             {
457                RLOG1(L_ERROR,"Unpacking of Long BSR failed LCID:%d",lcId);
458                err->errCause = RGERR_DUX_UNPACK_FAILURE;
459                RETVALUE(RFAILED);
460             }
461             RG_EXT_BS(longBsr, 
462                   ceInfo->ces.bsr.longBsr.bs1, 
463                   ceInfo->ces.bsr.longBsr.bs2, 
464                   ceInfo->ces.bsr.longBsr.bs3, 
465                   ceInfo->ces.bsr.longBsr.bs4);
466             ceInfo->bitMask |= RG_LONG_BSR_CE_PRSNT;
467          }
468          break;
469       case RG_CRNTI_LCID:
470          {
471             RG_UNPACK_CRNTI(&ceInfo->ces.cRnti,mBuf,ret);
472             if(ret != ROK)
473             {
474                RLOG1(L_ERROR,"Unpacking of C-RNTI failed LCID:%d",lcId);
475                err->errCause = RGERR_DUX_UNPACK_FAILURE;
476                RETVALUE(RFAILED);
477             }
478             ceInfo->bitMask |= RG_CRNTI_CE_PRSNT;
479          }
480          break;
481       default:
482          RLOG1(L_ERROR, "Invalid LCID:%u received",lcId); 
483          err->errCause = RGERR_DUX_INV_LCID_RX;
484          RETVALUE(RFAILED);
485    }
486    RETVALUE(ROK);
487 } /* rgDUXExtCe  */
488
489
490 /**
491  * @brief Handles extracting the SDU from the MAC PDU.
492  *
493  * @details
494  *
495  *     Function: rgDUXExtSdu
496  *     
497  *     This API handles extracting the SDU corresponding to a logical channel.
498  *     
499  *     Processing Steps: 
500  *      - Based on the length stored in the sub header extract the SDU.
501  *
502  *  @param[in]  Inst        inst
503  *  @param[in,out]  *pdu
504  *  @param[out] *ceInfo
505  *  @param[in]  *mBuf
506  *  @param[in] lcId
507  *  @param[in] subPduLen
508  *  @param[out] *err
509  *  @return  S16
510  *      -# ROK 
511  *      -# RFAILED 
512  **/
513 #ifdef ANSI
514 PRIVATE S16 rgDUXExtSdu
515 (
516 Inst        inst,
517 RgMacPdu    *pdu,
518 RgInfCeInfo  *ceInfo,
519 Buffer      **mBuf,
520 U8          lcId,
521 U16         subPduLen,
522 RgErrInfo   *err
523 )
524 #else
525 PRIVATE S16 rgDUXExtSdu(inst,pdu, ceInfo,mBuf,lcId,subPduLen,err)
526 Inst        inst;
527 RgMacPdu    *pdu;
528 RgInfCeInfo  *ceInfo;
529 Buffer      **mBuf;
530 U8          lcId;
531 U16         subPduLen;
532 RgErrInfo   *err;
533 #endif
534 {
535    S16         ret;
536    Buffer      *tmpBuf1;
537    Buffer      *tmpBuf2 = NULLP;
538    RgMacSdu    *sdu;
539
540    TRC2(rgDUXExtSdu)
541
542    if(lcId == RG_CCCH_LCID)
543    {
544       ceInfo->bitMask |= RG_CCCH_SDU_PRSNT;
545    }
546
547    if(rgDUXInsSdu(inst,pdu, &sdu,lcId, subPduLen, err) != ROK)
548    {
549       RG_FREE_MSG(*mBuf);
550       RETVALUE(RFAILED);
551    }
552
553    tmpBuf1 = *mBuf;
554    {
555       ret = SSegMsg(tmpBuf1,subPduLen,&tmpBuf2);
556       if((ret != ROK) && (!((ret == ROKDNA) )))
557       {
558          RG_FREE_MSG(tmpBuf1);
559          RLOG0(L_ERROR,"SSegMsg failed");
560          err->errCause = RGERR_DUX_RLC_PDU_CREAT_FAIL;
561          RETVALUE(RFAILED);
562       }
563       sdu->mBuf = tmpBuf1;
564       *mBuf = tmpBuf2;
565    }
566    RETVALUE(ROK);
567 }   /* rgDUXExtSdu */
568
569 /**
570  * @brief Handles de-multiplexing of the data recieved at MAC.
571  *
572  * @details
573  *
574  *     Function: rgDUXDemuxData
575  *     
576  *     This API handles de-multiplexing of the data recieved at MAC.
577  *     
578  *     Invoked by: rgTOMTfuDatInd of TOM 
579  *     
580  *     Processing Steps: 
581  *      - De-multiplex the mBuf
582  *
583  *  @param[in]  Inst        inst
584  *  @param[in]  *pdu 
585  *  @param[in]  *mBuf 
586  *  @param[out] *err 
587  *  @return  S16
588  *      -# ROK 
589  *      -# RFAILED 
590  **/
591 #ifdef ANSI
592 PUBLIC S16 rgDUXDemuxData
593 (
594 Inst          inst,
595 RgMacPdu      *pdu,
596 RgInfCeInfo   *ceInfo,
597 Buffer        **mBuf,
598 RgErrInfo     *err
599 )
600 #else
601 PUBLIC S16 rgDUXDemuxData(inst,pdu, ceInfo, mBuf, err)
602 Inst          inst;
603 RgMacPdu      *pdu;
604 RgInfCeInfo   *ceInfo;
605 Buffer        **mBuf;
606 RgErrInfo     *err;
607 #endif
608 {
609    U8          lcId;
610    U16          subPduLen;
611    MsgLen      len;  
612    TRC2(rgDUXDemuxData)
613
614    ceInfo->bitMask = 0x0000;
615
616    /* Initialize the sdu list */
617    cmLListInit(&pdu->sduLst);
618
619    if(*mBuf == NULLP) 
620    {
621       RLOG0(L_ERROR, "Null Buffer Recevived");
622       RETVALUE(RFAILED);
623    }
624    do
625    {
626       /* UL Message format  order : 
627            PduSubHdr+SubPDU,PduSubHdr+SubPDU,...CeSubHdr+Ce,CeSubPdu+Ce,...,PADSubHdr+PAD */
628       /* Extract the Sub headers */
629       if(rgDUXExtSubHdr(inst,pdu, *mBuf, &lcId, 
630                &subPduLen, err) != ROK)
631       {
632          RG_FREE_MSG(*mBuf);          
633          RLOG0(L_ERROR, "Failed to extract pad sub headers");
634          RETVALUE(RFAILED);
635       }
636       if(lcId == RG_PAD_LCID)
637       { /*at end of MAC PDU,  Padding started */ 
638          RG_FREE_MSG(*mBuf);          
639          RETVALUE(ROK);
640       }
641       if(lcId <= RG_DEDLC_MAX_LCID)
642       {
643          /* Extract the sdus */
644          if(rgDUXExtSdu(inst,pdu,ceInfo, mBuf,lcId,subPduLen, err) != ROK)
645          {
646             /* Fix : syed rgDUXExtSdu would have segmented mBuf and hence
647              * will be responsible for freeing mBuf */
648             *mBuf = NULLP;
649             RLOG0(L_ERROR, "failed to Extract the sdus");
650             RETVALUE(RFAILED);
651          }
652          if(*mBuf == NULLP) /* if message read completes then return */
653          {
654             RETVALUE(ROK);
655          }
656       }
657       else
658       {
659          /* Extract the ces */
660          if(rgDUXExtCe(inst,pdu,ceInfo,*mBuf, lcId,subPduLen, err) != ROK)
661          {
662             RG_FREE_MSG(*mBuf);       
663             RLOG0(L_ERROR, " failed to Extract the ces");
664             RETVALUE(RFAILED);
665          }
666       }
667       if(SFndLenMsg(*mBuf,&len) != ROK)
668       {
669          RG_FREE_MSG(*mBuf);
670          RLOG0(L_ERROR,"mBuf length check failed");
671          err->errCause = RGERR_DUX_UNPACK_FAILURE;
672          RETVALUE(RFAILED);
673       }
674    }while(len);
675
676    RG_FREE_MSG(*mBuf);
677    RETVALUE(ROK);
678 }  /* rgDUXDemuxData */
679
680 /**********************************************************************
681  
682          End of file
683 **********************************************************************/