1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
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 #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
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 *******************************************************************************/
19 /********************************************************************20**
25 Desc: This file Contains the packing and unpacking functions for
30 *********************************************************************21*/
32 /* header include files (.h) */
33 #include "common_def.h"
34 #ifdef TENB_SPLIT_ARCH
39 #include "kwu.h" /* KWU defines */
41 /* extern (.x) include files */
42 #ifdef TENB_SPLIT_ARCH
51 #include "kwu.x" /* KWU */
55 /****************************************************************************
57 ***************************************************************************/
59 PUBLIC S16 cmPkKwuBndReq
66 PUBLIC S16 cmPkKwuBndReq(pst, suId, spId)
79 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
81 #if (ERRCLASS & ERRCLS_ADD_RES)
84 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
85 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
86 (ErrVal)EKWU001, (ErrVal)0, "SGetMsg() failed");
88 #endif /* ERRCLASS & ERRCLS_ADD_RES */
91 CMCHKPKLOG(SPkS16, spId, mBuf, EKWU002, pst);
92 CMCHKPKLOG(SPkS16, suId, mBuf, EKWU003, pst);
93 pst->event = (Event) KWU_EVT_BND_REQ;
94 RETVALUE(SPstTsk(pst,mBuf));
99 PUBLIC S16 cmPkKwuBndCfm
106 PUBLIC S16 cmPkKwuBndCfm(pst, suId, status)
119 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
121 #if (ERRCLASS & ERRCLS_ADD_RES)
124 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
125 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
126 (ErrVal)EKWU004, (ErrVal)0, "SGetMsg() failed");
128 #endif /* ERRCLASS & ERRCLS_ADD_RES */
132 CMCHKPKLOG(SPkU8, status, mBuf, EKWU005, pst);
133 CMCHKPKLOG(SPkS16, suId, mBuf, EKWU006, pst);
134 pst->event = (Event) KWU_EVT_BND_CFM;
135 RETVALUE(SPstTsk(pst,mBuf));
140 PUBLIC S16 cmPkKwuUbndReq
147 PUBLIC S16 cmPkKwuUbndReq(pst, suId, reason)
160 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
162 #if (ERRCLASS & ERRCLS_ADD_RES)
165 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
166 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
167 (ErrVal)EKWU007, (ErrVal)0, "SGetMsg() failed");
169 #endif /* ERRCLASS & ERRCLS_ADD_RES */
172 CMCHKPKLOG(SPkS16, reason, mBuf, EKWU008, pst);
173 CMCHKPKLOG(SPkS16, suId, mBuf, EKWU009, pst);
175 pst->event = (Event) KWU_EVT_UBND_REQ;
176 RETVALUE(SPstTsk(pst,mBuf));
177 } /* cmPkKwuUbndReq */
180 PUBLIC S16 cmPkKwuDatReqInfo
182 KwuDatReqInfo *param,
186 PUBLIC S16 cmPkKwuDatReqInfo(param, mBuf)
187 KwuDatReqInfo *param;
192 TRC3(cmPkKwuDatReqInfo);
195 switch(param->lcType) {
196 case CM_LTE_LCH_CCCH:
197 CMCHKPK(cmPkLteRnti, param->tm.rnti, mBuf);
199 case CM_LTE_LCH_BCCH:
200 case CM_LTE_LCH_PCCH:
201 CMCHKPK(cmPkLteTimingInfo, ¶m->tm.tmg, mBuf);
203 CMCHKPK(SPkU8, param->emtcDiReason,mBuf);
204 CMCHKPK(SPkU8, param->pnb,mBuf);
207 case CM_LTE_LCH_DTCH:
208 case CM_LTE_LCH_DCCH:
213 CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
216 CMCHKPK(SPkU32, param->sduId, mBuf);
217 CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
219 } /* cmPkKwuDatReqInfo */
223 PUBLIC S16 cmPkKwuDatReq
226 KwuDatReqInfo* datReq,
230 PUBLIC S16 cmPkKwuDatReq(pst, datReq, mBuf)
232 KwuDatReqInfo* datReq;
237 #if (ERRCLASS & ERRCLS_ADD_RES)
242 KwuDatReqInfo* datReqInfo;
246 switch(pst->selector)
248 case ODU_SELECTOR_LWLC:
250 if(pst->srcEnt == ENTDUAPP)
252 /* When the Selector is LWLC, we need to allocate memory, copy
253 * the contents and pass the pointer of the allocated memory. The
254 * subsequent free would be done during the Unpack function of the
256 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datReqInfo,
257 sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY)) != ROK)
259 #if (ERRCLASS & ERRCLS_ADD_RES)
262 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
263 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
264 (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
266 #endif /* ERRCLASS & ERRCLS_ADD_RES */
269 cmMemcpy((U8*)datReqInfo,(U8*)datReq,sizeof(KwuDatReqInfo));
270 CMCHKPK(cmPkPtr,(PTR)datReqInfo, mBuf);
274 CMCHKPK(cmPkPtr,(PTR)datReq, mBuf);
278 case ODU_SELECTOR_LC:
280 #if (ERRCLASS & ERRCLS_ADD_RES)
281 ret1 = cmPkKwuDatReqInfo( (datReq), mBuf);
285 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
286 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
287 (ErrVal)EKWU010, (ErrVal)ret1, "Packing failure");
291 cmPkKwuDatReqInfo( (datReq), mBuf);
292 #endif /* ERRCLASS & ERRCLS_ADD_RES */
293 if(pst->srcEnt == ENTNH)
295 if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
296 sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
306 #if (ERRCLASS & ERRCLS_ADD_RES)
307 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
308 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
309 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
310 #endif /* ERRCLASS & ERRCLS_ADD_RES */
315 if(datReq->rlcId.rbType == CM_LTE_SRB)
317 pst->event = (Event) KWU_EVT_CPLANE_DAT_REQ;
321 pst->event = (Event) KWU_EVT_UPLANE_DAT_REQ;
324 pst->event = (Event) KWU_EVT_DAT_REQ;
326 RETVALUE(SPstTsk(pst,mBuf));
328 if (pst->srcEnt == ENTPJ)
331 KwuDatReqDetl *kwuDatReqDetl = NULLP;
332 elem = SRngGetWIndx(SS_RNG_BUF_DLPDCP_TO_DLRLC);
335 kwuDatReqDetl = (KwuDatReqDetl *) elem;
336 kwuDatReqDetl->spId = spId;
337 kwuDatReqDetl->lcType = datReq->lcType;
338 kwuDatReqDetl->sduId = datReq->sduId;
339 kwuDatReqDetl->rlcId = datReq->rlcId;
340 kwuDatReqDetl->mBuf = mBuf;
341 SRngIncrWIndx(SS_RNG_BUF_DLPDCP_TO_DLRLC);
342 SsRngInfoTbl[SS_RNG_BUF_DLPDCP_TO_DLRLC].pktRate++;
347 SsRngInfoTbl[SS_RNG_BUF_DLPDCP_TO_DLRLC].pktDrop++;
354 switch(pst->selector)
357 case ODU_SELECTOR_LC:
359 ret1 = cmPkKwuDatReqInfo( (datReq), mBuf);
360 #if (ERRCLASS & ERRCLS_ADD_RES)
364 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
365 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
366 (ErrVal)EKWU010, (ErrVal)ret1, "Packing failure");
369 #endif /* ERRCLASS & ERRCLS_ADD_RES */
372 case ODU_SELECTOR_LWLC:
374 CMCHKPK(cmPkPtr,(PTR)datReq, mBuf);
380 CMCHKPKLOG(SPkS16, spId, mBuf, EKWU011, pst);
381 pst->event = (Event) KWU_EVT_DAT_REQ;
382 ret1 = SPstTsk(pst,mBuf);
383 if(pst->selector == ODU_SELECTOR_LC)
385 if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
386 sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
395 } /* cmPkKwuDatReq */
399 PUBLIC S16 cmPkKwuDatIndInfo
401 KwuDatIndInfo *param,
405 PUBLIC S16 cmPkKwuDatIndInfo(param, mBuf)
406 KwuDatIndInfo *param;
410 TRC3(cmPkKwuDatIndInfo);
412 CMCHKPK(SPkU8, param->isOutOfSeq, mBuf);
414 CMCHKPK(cmPkLteRnti, param->tCrnti, mBuf);
416 CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
422 PUBLIC S16 cmPkKwuDatInd
425 KwuDatIndInfo* datInd,
429 PUBLIC S16 cmPkKwuDatInd(pst, datInd, mBuf)
431 KwuDatIndInfo* datInd;
438 #ifdef TENB_SPLIT_ARCH
439 #ifdef SS_LOCKLESS_MEMORY
443 KwuDatIndInfo *datIndInfo = NULLP;
447 #ifdef TENB_SPLIT_ARCH
449 #ifdef SS_LOCKLESS_MEMORY
450 mInfo = (SsMsgInfo *)mBuf->b_rptr;
451 mInfo->region = pst->region;
452 #endif /* SS_LOCKLESS_MEMORY */
455 switch(pst->selector)
457 case ODU_SELECTOR_LWLC:
459 /* When the Selector is LWLC, we need to allocate memory, copy
460 * the contents and pass the pointer of the allocated memory. The
461 * subsequent free would be done during the Unpack function of the
463 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datIndInfo,
464 sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY)) != ROK)
466 #if (ERRCLASS & ERRCLS_ADD_RES)
469 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
470 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
471 (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
473 #endif /* ERRCLASS & ERRCLS_ADD_RES */
477 cmMemcpy((U8*)datIndInfo,(U8*)datInd,sizeof(KwuDatIndInfo));
478 CMCHKPK(cmPkPtr,(PTR)datIndInfo, mBuf);
481 case ODU_SELECTOR_LC:
483 #if (ERRCLASS & ERRCLS_ADD_RES)
484 ret1 = cmPkKwuDatIndInfo( (datInd), mBuf);
488 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
489 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
490 (ErrVal)EKWU012, (ErrVal)ret1, "Packing failure");
494 cmPkKwuDatIndInfo( (datInd), mBuf);
495 #endif /* ERRCLASS & ERRCLS_ADD_RES */
500 #if (ERRCLASS & ERRCLS_ADD_RES)
501 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
502 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
503 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
504 #endif /* ERRCLASS & ERRCLS_ADD_RES */
508 pst->event = (Event) KWU_EVT_DAT_IND;
510 RETVALUE(SPstTsk(pst,mBuf));
511 } /* cmPkKwuDatInd */
515 PUBLIC S16 cmPkKwuDatCfmInfo
517 KwuDatCfmInfo *param,
521 PUBLIC S16 cmPkKwuDatCfmInfo(param, mBuf)
522 KwuDatCfmInfo *param;
528 TRC3(cmPkKwuDatCfmInfo);
529 for(iter = 0; iter < param->numSduIds; iter++)
531 CMCHKPK(SPkU32, param->sduIds[iter], mBuf);
533 CMCHKPK(SPkU32, param->numSduIds, mBuf);
534 CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
536 } /* cmPkKwuDatCfmInfo */
540 PUBLIC S16 cmPkKwuDatCfm
544 KwuDatCfmInfo* datCfm
547 PUBLIC S16 cmPkKwuDatCfm(pst, suId, datCfm)
550 KwuDatCfmInfo* datCfm;
553 #if (ERRCLASS & ERRCLS_ADD_RES)
562 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
566 switch(pst->selector)
568 case ODU_SELECTOR_LWLC:
570 CMCHKPK(cmPkPtr,(PTR)datCfm, mBuf);
573 case ODU_SELECTOR_LC:
575 #if (ERRCLASS & ERRCLS_ADD_RES)
576 ret1 = cmPkKwuDatCfmInfo( (datCfm), mBuf);
580 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
581 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
582 (ErrVal)EKWU014, (ErrVal)ret1, "Packing failure");
586 cmPkKwuDatCfmInfo( (datCfm), mBuf);
587 #endif /* ERRCLASS & ERRCLS_ADD_RES */
588 if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datCfm,
589 sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY) != ROK)
598 #if (ERRCLASS & ERRCLS_ADD_RES)
599 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
600 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
601 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
602 #endif /* ERRCLASS & ERRCLS_ADD_RES */
606 CMCHKPKLOG(SPkS16, suId, mBuf, EKWU015, pst);
607 pst->event = (Event) KWU_EVT_DAT_CFM;
609 RETVALUE(SPstTsk(pst,mBuf));
610 } /* cmPkKwuDatCfm */
614 PUBLIC S16 cmPkKwuDiscSduReq
618 KwuDiscSduInfo* discSdu
621 PUBLIC S16 cmPkKwuDiscSduReq(pst, spId, discSdu)
624 KwuDiscSduInfo* discSdu;
631 KwuDiscSduInfo* discSduInfo = NULLP;
633 TRC3(cmPkKwuDiscSduReq)
636 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
640 switch(pst->selector)
642 case ODU_SELECTOR_LWLC:
644 /* When the Selector is LWLC, we need to allocate memory, copy
645 * the contents and pass the pointer of the allocated memory. The
646 * subsequent free would be done during the Unpack function of the
648 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSduInfo,
649 sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
651 #if (ERRCLASS & ERRCLS_ADD_RES)
654 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
655 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
656 (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
658 #endif /* ERRCLASS & ERRCLS_ADD_RES */
662 cmMemcpy((U8*)discSduInfo,(U8*)discSdu,sizeof(KwuDiscSduInfo));
663 CMCHKPK(cmPkPtr,(PTR)discSduInfo, mBuf);
666 case ODU_SELECTOR_LC:
668 #if (ERRCLASS & ERRCLS_ADD_RES)
669 ret1 = cmPkKwuDiscSduInfo( (discSdu), mBuf);
673 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
674 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
675 (ErrVal)EKWU016, (ErrVal)ret1, "Packing failure");
679 cmPkKwuDiscSduInfo( (discSdu), mBuf);
680 #endif /* ERRCLASS & ERRCLS_ADD_RES */
685 CMCHKPKLOG(SPkS16, spId, mBuf, EKWU017, pst);
686 pst->event = (Event) KWU_EVT_DISC_SDU_REQ;
688 RETVALUE(SPstTsk(pst,mBuf));
689 } /* cmPkKwuDiscSduReq */
693 PUBLIC S16 cmPkKwuStaIndInfo
695 KwuStaIndInfo *param,
699 PUBLIC S16 cmPkKwuStaIndInfo(param, mBuf)
700 KwuStaIndInfo *param;
706 TRC3(cmPkKwuStaIndInfo);
708 for (i = (param->numSdu - 1); i >= 0; i--)
710 CMCHKPK(SPkU32, param->sduId[(U16)i], mBuf);
712 CMCHKPK(SPkU32, param->numSdu, mBuf);
713 CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
718 PUBLIC S16 cmPkKwuFlowCntrlIndInfo
720 KwuFlowCntrlIndInfo *param,
724 PUBLIC S16 cmPkKwuFlowCntrlIndInfo(param, mBuf)
725 KwuFlowCntrlIndInfo *param;
729 TRC3(cmPkKwuFlowCntrlIndInfo);
731 CMCHKPK(SPkU32, param->pktAdmitCnt, mBuf);
732 CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
735 } /* cmPkKwuFlowCntrlIndInfo */
738 PUBLIC S16 cmUnpkKwuFlowCntrlIndInfo
740 KwuFlowCntrlIndInfo *param,
744 PUBLIC S16 cmUnpkKwuFlowCntrlIndInfo(param, mBuf)
745 KwuFlowCntrlIndInfo *param;
749 TRC3(cmUnpkKwuFlowCntrlIndInfo);
751 CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
752 CMCHKUNPK(SUnpkU32, ¶m->pktAdmitCnt, mBuf);
755 } /* cmUnpkKwuFlowCntrlIndInfo */
759 PUBLIC S16 cmPkKwuStaInd
763 KwuStaIndInfo* staInd
766 PUBLIC S16 cmPkKwuStaInd(pst, suId, staInd)
769 KwuStaIndInfo* staInd;
773 #if (ERRCLASS & ERRCLS_ADD_RES)
783 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
787 switch(pst->selector)
789 case ODU_SELECTOR_LWLC:
791 CMCHKPK(cmPkPtr,(PTR) staInd, mBuf);
794 case ODU_SELECTOR_LC:
796 #if (ERRCLASS & ERRCLS_ADD_RES)
797 ret1 = cmPkKwuStaIndInfo( (staInd), mBuf);
801 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
802 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
803 (ErrVal)EKWU018, (ErrVal)ret1, "Packing failure");
807 cmPkKwuStaIndInfo( (staInd), mBuf);
808 #endif /* ERRCLASS & ERRCLS_ADD_RES */
809 if (SPutStaticBuffer(pst->region, pst->pool, (Data *)staInd,
810 sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY) != ROK)
819 #if (ERRCLASS & ERRCLS_ADD_RES)
820 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
821 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
822 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
827 CMCHKPKLOG(SPkS16, suId, mBuf, EKWU019, pst);
828 pst->event = (Event) KWU_EVT_STA_IND;
830 RETVALUE(SPstTsk(pst,mBuf));
831 } /* cmPkKwuStaInd */
835 PUBLIC S16 cmPkKwuReEstCmpInd
842 PUBLIC S16 cmPkKwuReEstCmpInd(pst, suId, rlcId)
849 #if (ERRCLASS & ERRCLS_ADD_RES)
855 TRC3(cmPkKwuReEstCmpInd)
859 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
863 switch(pst->selector)
866 case ODU_SELECTOR_LC:
868 #if (ERRCLASS & ERRCLS_ADD_RES)
869 ret1 = cmPkLteRlcId( &rlcId, mBuf);
873 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
874 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
875 (ErrVal)EKWU018, (ErrVal)ret1, "Packing failure");
879 cmPkLteRlcId( &rlcId, mBuf);
880 #endif /* ERRCLASS & ERRCLS_ADD_RES */
886 CMCHKPKLOG(SPkS16, suId, mBuf, EKWU019, pst);
887 pst->event = (Event) KWU_EVT_REEST_CMP_IND;
889 RETVALUE(SPstTsk(pst,mBuf));
890 } /* cmPkKwuReEstCmpInd */
892 /* kwu_c_001.main_3 added support for L2 Measurement */
894 PUBLIC S16 cmPkKwuDiscSduCfm
898 KwuDiscSduInfo *discCfmSdu
901 PUBLIC S16 cmPkKwuDiscSduCfm(pst, spId, discCfmSdu)
904 KwuDiscSduInfo *discCfmSdu;
907 #if (ERRCLASS & ERRCLS_ADD_RES)
912 TRC3(cmPkKwuDiscSduCfm)
916 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
920 switch(pst->selector)
922 case ODU_SELECTOR_LWLC:
924 CMCHKPK(cmPkPtr,(PTR)discCfmSdu, mBuf);
927 case ODU_SELECTOR_LC:
929 #if (ERRCLASS & ERRCLS_ADD_RES)
930 ret1 = cmPkKwuDiscSduInfo((discCfmSdu), mBuf);
934 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
935 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
936 (ErrVal)ERRKWU, (ErrVal)ret1, "Packing failure");
940 cmPkKwuDiscSduInfo((discCfmSdu), mBuf);
941 #endif /* ERRCLASS & ERRCLS_ADD_RES */
942 if (SPutStaticBuffer(pst->region, pst->pool, (Data *)discCfmSdu,
943 sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY) != ROK)
952 #if (ERRCLASS & ERRCLS_ADD_RES)
953 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
954 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
955 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
960 CMCHKPKLOG(SPkS16, spId, mBuf, ERRKWU, pst);
961 pst->event = (Event) KWU_EVT_DISC_SDU_CFM;
963 RETVALUE(SPstTsk(pst,mBuf));
964 } /* cmPkKwuDiscSduCfm */
967 PUBLIC S16 cmPkKwuFlowCntrlInd
971 KwuFlowCntrlIndInfo *flowCntrlIndInfo
974 PUBLIC S16 cmPkKwuFlowCntrlInd(pst, suId, flowCntrlIndInfo)
977 KwuFlowCntrlIndInfo *flowCntrlIndInfo;
982 TRC3(cmPkKwuFlowCntrlInd)
986 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
988 SPutStaticBuffer(pst->region,
990 (Data *)flowCntrlIndInfo,
991 sizeof(KwuFlowCntrlIndInfo),0);
995 switch(pst->selector)
997 case ODU_SELECTOR_LC:
999 cmPkKwuFlowCntrlIndInfo((flowCntrlIndInfo), mBuf);
1001 if (SPutStaticBuffer(pst->region,
1003 (Data *)flowCntrlIndInfo,
1004 sizeof(KwuFlowCntrlIndInfo),0) != ROK)
1012 case ODU_SELECTOR_LWLC:
1014 CMCHKPK(cmPkPtr,(PTR) flowCntrlIndInfo, mBuf);
1020 CMCHKPKLOG(SPkS16, suId, mBuf, ERRKWU, pst);
1021 pst->event = (Event) KWU_EVT_FLOW_CNTRL_IND;
1023 RETVALUE(SPstTsk(pst,mBuf));
1024 } /* cmPkKwuFlowCntrlInd */
1028 PUBLIC S16 cmPkKwuDatAckInfo
1030 KwuDatAckInfo *param,
1034 PUBLIC S16 cmPkKwuDatAckInfo(param, mBuf)
1035 KwuDatAckInfo *param;
1039 TRC3(cmPkKwuDatAckIndInfo);
1041 CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
1042 CMCHKPK(SPkU32, param->sduId, mBuf);
1047 PUBLIC S16 cmPkKwuDatAckInd
1051 KwuDatAckInfo* datInd
1054 PUBLIC S16 cmPkKwuDatAckInd(pst, suId, datInd)
1057 KwuDatAckInfo* datInd;
1064 TRC3(cmPkKwuDatAckInd);
1068 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1072 ret1 = cmPkKwuDatAckInfo( (datInd), mBuf);
1073 #if (ERRCLASS & ERRCLS_ADD_RES)
1077 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1078 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1079 (ErrVal)ERRKWU, (ErrVal)ret1, "Packing failure");
1082 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1083 if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
1084 sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY) != ROK)
1090 CMCHKPKLOG(SPkS16, suId, mBuf, ERRKWU, pst);
1091 pst->event = (Event) KWU_EVT_DAT_ACK_IND;
1093 RETVALUE(SPstTsk(pst,mBuf));
1094 } /* cmPkKwuDatAckInd */
1095 #endif /* LTE_L2_MEAS */
1099 PUBLIC S16 cmUnpkKwuBndReq
1106 PUBLIC S16 cmUnpkKwuBndReq(func, pst, mBuf)
1115 TRC3(cmUnpkKwuBndReq)
1117 CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU020, pst);
1118 CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU021, pst);
1121 RETVALUE((*func)(pst, suId, spId));
1126 PUBLIC S16 cmUnpkKwuBndCfm
1133 PUBLIC S16 cmUnpkKwuBndCfm(func, pst, mBuf)
1142 TRC3(cmUnpkKwuBndCfm)
1144 CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU022, pst);
1145 CMCHKUNPKLOG(SUnpkU8, &status, mBuf, EKWU023, pst);
1148 RETVALUE((*func)(pst, suId, status));
1153 PUBLIC S16 cmUnpkKwuUbndReq
1160 PUBLIC S16 cmUnpkKwuUbndReq(func, pst, mBuf)
1169 TRC3(cmUnpkKwuUbndReq)
1171 CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU024, pst);
1172 CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, EKWU025, pst);
1175 RETVALUE((*func)(pst, spId, reason));
1176 } /* cmUnpkKwuUbndReq */
1180 PUBLIC S16 cmUnpkKwuDatReqInfo
1182 KwuDatReqInfo *param,
1186 PUBLIC S16 cmUnpkKwuDatReqInfo(param, mBuf)
1187 KwuDatReqInfo *param;
1192 TRC3(cmUnpkKwuDatReqInfo);
1194 CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
1195 CMCHKUNPK(SUnpkU32, ¶m->sduId, mBuf);
1198 CMCHKUNPK(cmUnpkLteLcType, ¶m->lcType, mBuf);
1199 switch(param->lcType) {
1200 case CM_LTE_LCH_BCCH:
1201 case CM_LTE_LCH_PCCH:
1203 CMCHKUNPK(SUnpkU8,¶m->pnb , mBuf);
1204 CMCHKUNPK(SUnpkU8,¶m->emtcDiReason , mBuf);
1206 CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->tm.tmg, mBuf);
1209 case CM_LTE_LCH_CCCH:
1210 CMCHKUNPK(cmUnpkLteRnti, ¶m->tm.rnti, mBuf);
1212 case CM_LTE_LCH_DTCH:
1213 case CM_LTE_LCH_DCCH:
1224 PUBLIC S16 cmUnpkKwuDatReq
1231 PUBLIC S16 cmUnpkKwuDatReq(func, pst, mBuf)
1237 #if(ERRCLASS & ERRCLS_DEBUG)
1241 KwuDatReqInfo *datReq = NULLP;
1242 KwuDatReqInfo datReqTmp;
1244 TRC3(cmUnpkKwuDatReq)
1246 switch(pst->selector)
1248 case ODU_SELECTOR_LWLC:
1250 CMCHKUNPK(cmUnpkPtr,(PTR *) &datReq, mBuf);
1253 case ODU_SELECTOR_LC:
1255 /* Allocate the memory statically as there is no free
1257 datReq = &datReqTmp;
1258 cmMemset((U8 *)datReq, 0, sizeof(KwuDatReqInfo));
1259 #if(ERRCLASS & ERRCLS_DEBUG)
1260 ret1 = cmUnpkKwuDatReqInfo( (datReq), mBuf);
1264 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1265 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1266 (ErrVal)EKWU027, (ErrVal)ret1, "Unpacking failure");
1270 cmUnpkKwuDatReqInfo( (datReq), mBuf);
1271 #endif /* ERRCLASS & ERRCLS_DEBUG */
1276 #if (ERRCLASS & ERRCLS_ADD_RES)
1277 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1278 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1279 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1284 retVal = (*func)(pst, datReq, mBuf);
1285 /* If LWLC is configured, we need to
1286 * free the memory here. */
1287 if(pst->selector == ODU_SELECTOR_LWLC)
1289 retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
1290 sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY);
1293 } /* cmUnpkKwuDatReq */
1297 PUBLIC S16 cmUnpkKwuDatIndInfo
1299 KwuDatIndInfo *param,
1303 PUBLIC S16 cmUnpkKwuDatIndInfo(param, mBuf)
1304 KwuDatIndInfo *param;
1308 TRC3(cmUnpkKwuDatIndInfo);
1310 CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
1313 CMCHKUNPK(cmUnpkLteRnti, ¶m->tCrnti, mBuf);
1315 CMCHKUNPK(SUnpkU8, ¶m->isOutOfSeq, mBuf);
1321 PUBLIC S16 cmUnpkKwuDatInd
1328 PUBLIC S16 cmUnpkKwuDatInd(func, pst, mBuf)
1334 S16 ret1 = ROK, retVal;
1335 KwuDatIndInfo *datInd = NULLP;
1336 KwuDatIndInfo datIndTmp;
1338 TRC3(cmUnpkKwuDatInd)
1340 switch(pst->selector)
1342 case ODU_SELECTOR_LWLC:
1344 CMCHKUNPK(cmUnpkPtr,(PTR *) &datInd, mBuf);
1347 case ODU_SELECTOR_LC:
1349 /*SGetStaticBuffer used as RRC has an equivalent free but PDCP
1350 * doesn't free any memory */
1351 if(pst->dstEnt != ENTPJ)
1353 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datInd,
1354 sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY)) != ROK)
1356 #if (ERRCLASS & ERRCLS_ADD_RES)
1359 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1360 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1361 (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
1363 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1369 datInd = &datIndTmp;
1372 ret1 = cmUnpkKwuDatIndInfo( (datInd), mBuf);
1373 #if(ERRCLASS & ERRCLS_DEBUG)
1377 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1378 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1379 (ErrVal)EKWU029, (ErrVal)ret1, "Unpacking failure");
1382 #endif /* ERRCLASS & ERRCLS_DEBUG */
1387 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1388 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1389 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1392 retVal = (*func)(pst, datInd, mBuf);
1393 /* If LWLC is configured and the destination entity is PDCP, we need to
1394 * free the memory here. */
1395 if((pst->selector == ODU_SELECTOR_LWLC) && (pst->dstEnt == ENTPJ))
1397 retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
1398 sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY);
1401 } /* cmUnpkKwuDatInd */
1405 PUBLIC S16 cmUnpkKwuDatCfmInfo
1407 KwuDatCfmInfo *param,
1411 PUBLIC S16 cmUnpkKwuDatCfmInfo(param, mBuf)
1412 KwuDatCfmInfo *param;
1417 TRC3(cmUnpkKwuDatCfmInfo);
1419 CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
1420 CMCHKUNPK(SUnpkU32, ¶m->numSduIds, mBuf);
1422 #ifdef L2_L3_SPLIT /*Work Around */
1423 if (param->numSduIds >= KWU_MAX_DAT_CFM)
1424 param->numSduIds = KWU_MAX_DAT_CFM;
1426 for(iter = param->numSduIds -1; iter >= 0 ; iter--)
1428 CMCHKUNPK(SUnpkU32, ¶m->sduIds[iter], mBuf);
1434 PUBLIC S16 cmUnpkKwuDatCfm
1441 PUBLIC S16 cmUnpkKwuDatCfm(func, pst, mBuf)
1449 KwuDatCfmInfo *datCfm = NULLP;
1451 TRC3(cmUnpkKwuDatCfm)
1453 CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1455 switch(pst->selector)
1457 case ODU_SELECTOR_LWLC:
1459 CMCHKUNPK(cmUnpkPtr,(PTR *) &datCfm, mBuf);
1462 case ODU_SELECTOR_LC:
1464 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datCfm,\
1465 sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY)) != ROK)
1467 #if (ERRCLASS & ERRCLS_ADD_RES)
1470 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1471 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1472 (ErrVal)EKWU030, (ErrVal)0, "SGetMsg() failed");
1474 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1478 cmMemset((U8 *)datCfm, 0, sizeof(KwuDatCfmInfo));
1479 ret1 = cmUnpkKwuDatCfmInfo( (datCfm), mBuf);
1480 #if(ERRCLASS & ERRCLS_DEBUG)
1484 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1485 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1486 (ErrVal)EKWU031, (ErrVal)ret1, "Unpacking failure");
1489 #endif /* ERRCLASS & ERRCLS_DEBUG */
1493 #if (ERRCLASS & ERRCLS_ADD_RES)
1494 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1495 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1496 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1504 RETVALUE((*func)(pst, suId, datCfm));
1505 } /* cmUnpkKwuDatCfm */
1509 PUBLIC S16 cmUnpkKwuDiscSduReq
1516 PUBLIC S16 cmUnpkKwuDiscSduReq(func, pst, mBuf)
1524 KwuDiscSduInfo *discSdu = NULLP;
1527 CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1528 switch(pst->selector)
1530 case ODU_SELECTOR_LWLC:
1532 CMCHKUNPK(cmUnpkPtr,(PTR *) &discSdu, mBuf);
1535 case ODU_SELECTOR_LC:
1537 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSdu,\
1538 sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
1540 #if (ERRCLASS & ERRCLS_ADD_RES)
1542 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1543 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1544 (ErrVal)EKWU032, (ErrVal)0, "SGetMsg() failed");
1546 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1550 cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo));
1551 ret1 = cmUnpkKwuDiscSduInfo( (discSdu), mBuf);
1552 #if(ERRCLASS & ERRCLS_DEBUG)
1556 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1557 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1558 (ErrVal)EKWU033, (ErrVal)ret1, "Unpacking failure");
1561 #endif /* ERRCLASS & ERRCLS_DEBUG */
1565 #if (ERRCLASS & ERRCLS_ADD_RES)
1566 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1567 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1568 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1575 RETVALUE((*func)(pst, spId, discSdu));
1576 } /* cmUnpkKwuDiscSduReq */
1580 PUBLIC S16 cmUnpkKwuStaIndInfo
1582 KwuStaIndInfo *param,
1586 PUBLIC S16 cmUnpkKwuStaIndInfo(param, mBuf)
1587 KwuStaIndInfo *param;
1593 TRC3(cmUnpkKwuStaIndInfo);
1595 CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
1596 CMCHKUNPK(SUnpkU32, ¶m->numSdu, mBuf);
1597 for (i = 0; i < param->numSdu; i++)
1599 CMCHKUNPK(SUnpkU32, ¶m->sduId[i], mBuf);
1603 } /* cmUnpkKwuStaIndInfo */
1607 PUBLIC S16 cmUnpkKwuStaInd
1614 PUBLIC S16 cmUnpkKwuStaInd(func, pst, mBuf)
1622 KwuStaIndInfo *staInd = NULLP;
1624 TRC3(cmUnpkKwuStaInd)
1626 CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1628 switch(pst->selector)
1630 case ODU_SELECTOR_LWLC:
1632 CMCHKUNPK(cmUnpkPtr,(PTR *)&staInd, mBuf);
1635 case ODU_SELECTOR_LC:
1637 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&staInd,\
1638 sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY)) != ROK)
1640 #if (ERRCLASS & ERRCLS_ADD_RES)
1643 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1644 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1645 (ErrVal)EKWU034, (ErrVal)0, "SGetMsg() failed");
1647 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1651 cmMemset((U8 *)staInd, 0, sizeof(KwuStaIndInfo));
1653 ret1 = cmUnpkKwuStaIndInfo( (staInd), mBuf);
1654 #if(ERRCLASS & ERRCLS_DEBUG)
1658 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1659 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1660 (ErrVal)EKWU035, (ErrVal)ret1, "Unpacking failure");
1663 #endif /* ERRCLASS & ERRCLS_DEBUG */
1668 #if(ERRCLASS & ERRCLS_DEBUG)
1669 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1670 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1671 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1677 RETVALUE((*func)(pst, suId, staInd));
1678 } /* cmUnpkKwuStaInd */
1682 PUBLIC S16 cmUnpkKwuReEstCmpInd
1684 KwuReEstCmpInd func,
1689 PUBLIC S16 cmUnpkKwuReEstCmpInd(func, pst, mBuf)
1690 KwuReEstCmpInd func;
1695 #if(ERRCLASS & ERRCLS_DEBUG)
1701 TRC3(cmUnpkKwuReEstCmpInd)
1703 cmMemset((U8 *)&rlcId, 0, sizeof(CmLteRlcId));
1705 CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1706 switch(pst->selector)
1709 case ODU_SELECTOR_LC:
1711 #if(ERRCLASS & ERRCLS_DEBUG)
1712 ret1 = cmUnpkLteRlcId( &rlcId, mBuf);
1716 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1717 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1718 (ErrVal)EKWU035, (ErrVal)ret1, "Unpacking failure");
1722 cmUnpkLteRlcId( &rlcId, mBuf);
1723 #endif /* ERRCLASS & ERRCLS_DEBUG */
1730 RETVALUE((*func)(pst, suId, rlcId));
1731 } /* cmUnpkKwuReEstCmpInd */
1733 /* kwu_c_001.main_3 added support for L2 Measurement */
1735 PUBLIC S16 cmUnpkKwuDiscSduCfm
1742 PUBLIC S16 cmUnpkKwuDiscSduCfm(func, pst, mBuf)
1750 KwuDiscSduInfo *discSdu = NULLP;
1752 TRC3(cmUnpkKwuDiscSduCfm);
1754 CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1756 switch(pst->selector)
1758 case ODU_SELECTOR_LWLC:
1760 CMCHKUNPK(cmUnpkPtr,(PTR *) &discSdu, mBuf);
1763 case ODU_SELECTOR_LC:
1765 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSdu,\
1766 sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
1768 #if (ERRCLASS & ERRCLS_ADD_RES)
1771 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1772 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1773 (ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
1775 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1778 cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo));
1780 ret1 = cmUnpkKwuDiscSduInfo( (discSdu), mBuf);
1781 #if(ERRCLASS & ERRCLS_DEBUG)
1785 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1786 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1787 (ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
1789 #endif /* ERRCLASS & ERRCLS_DEBUG */
1794 #if(ERRCLASS & ERRCLS_DEBUG)
1795 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1796 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1797 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1803 RETVALUE((*func)(pst, spId, discSdu));
1804 } /* cmUnpkKwuDiscSduCfm */
1806 PUBLIC S16 cmUnpkKwuFlowCntrlInd
1808 KwuFlowCntrlInd func,
1813 PUBLIC S16 cmUnpkKwuFlowCntrlInd(func, pst, mBuf)
1814 KwuFlowCntrlInd func;
1820 KwuFlowCntrlIndInfo *flowCntrlInfo = NULLP;
1822 TRC3(cmUnpkKwuFlowCntrlInd);
1824 CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1825 switch(pst->selector)
1828 case ODU_SELECTOR_LC:
1830 if(SGetStaticBuffer(pst->region,
1832 (Data **)&flowCntrlInfo,
1833 sizeof(KwuFlowCntrlIndInfo),0) != ROK)
1839 cmUnpkKwuFlowCntrlIndInfo(flowCntrlInfo, mBuf);
1843 case ODU_SELECTOR_LWLC:
1845 CMCHKUNPK(cmUnpkPtr,(PTR *) &flowCntrlInfo, mBuf);
1853 RETVALUE((*func)(pst, suId, flowCntrlInfo));
1854 } /* cmUnpkKwuFlowCntrlInd */
1858 PUBLIC S16 cmUnpkKwuDatAckInfo
1860 KwuDatAckInfo *param,
1864 PUBLIC S16 cmUnpkKwuDatAckInfo(param, mBuf)
1865 KwuDatAckInfo *param;
1869 TRC3(cmUnpkKwuDatAckInfo);
1871 CMCHKUNPK(SUnpkU32, ¶m->sduId, mBuf);
1872 CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
1879 PUBLIC S16 cmUnpkKwuDatAckInd
1886 PUBLIC S16 cmUnpkKwuDatAckInd(func, pst, mBuf)
1894 KwuDatAckInfo *datInd = NULLP;
1896 TRC3(cmUnpkKwuDatAckInd);
1898 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datInd,\
1899 sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY)) != ROK)
1901 #if (ERRCLASS & ERRCLS_ADD_RES)
1904 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1905 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1906 (ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
1908 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1912 cmMemset((U8 *)datInd, 0, sizeof(KwuDatAckInfo));
1914 CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1915 ret1 = cmUnpkKwuDatAckInfo( (datInd), mBuf);
1916 #if(ERRCLASS & ERRCLS_DEBUG)
1920 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1921 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1922 (ErrVal)ERRKWU, (ErrVal)ret1, "Unpacking failure");
1925 #endif /* ERRCLASS & ERRCLS_DEBUG */
1927 RETVALUE((*func)(pst, suId, datInd));
1928 } /* cmUnpkKwuDatAckInd */
1929 #endif /* LTE_L2_MEAS */
1932 /**********************************************************************
1934 **********************************************************************/