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 "envopt.h" /* environment options */
34 #include "envdep.h" /* environment dependent */
35 #include "envind.h" /* environment independent */
37 #include "gen.h" /* general */
38 #include "ssi.h" /* system services */
39 #include "cm5.h" /* common timer defines */
40 #include "cm_tkns.h" /* common tokens defines */
41 #include "cm_mblk.h" /* common memory allocation library defines */
42 #include "cm_llist.h" /* common link list defines */
43 #include "cm_hash.h" /* common hash list defines */
44 #include "cm_lte.h" /* common LTE defines */
45 #ifdef TENB_SPLIT_ARCH
50 #include "kwu.h" /* KWU defines */
52 /* extern (.x) include files */
53 #include "gen.x" /* general */
54 #include "ssi.x" /* system services */
56 #include "cm5.x" /* common timer library */
57 #include "cm_tkns.x" /* common tokens */
58 #include "cm_mblk.x" /* common memory allocation */
59 #include "cm_llist.x" /* common link list */
60 #include "cm_hash.x" /* common hash list */
61 #include "cm_lte.x" /* common LTE includes */
62 #include "cm_lib.x" /* common memory allocation library */
63 #ifdef TENB_SPLIT_ARCH
72 #include "kwu.x" /* KWU */
76 /****************************************************************************
78 ***************************************************************************/
80 PUBLIC S16 cmPkKwuBndReq
87 PUBLIC S16 cmPkKwuBndReq(pst, suId, spId)
100 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
102 #if (ERRCLASS & ERRCLS_ADD_RES)
105 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
106 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
107 (ErrVal)EKWU001, (ErrVal)0, "SGetMsg() failed");
109 #endif /* ERRCLASS & ERRCLS_ADD_RES */
112 CMCHKPKLOG(SPkS16, spId, mBuf, EKWU002, pst);
113 CMCHKPKLOG(SPkS16, suId, mBuf, EKWU003, pst);
114 pst->event = (Event) KWU_EVT_BND_REQ;
115 RETVALUE(SPstTsk(pst,mBuf));
120 PUBLIC S16 cmPkKwuBndCfm
127 PUBLIC S16 cmPkKwuBndCfm(pst, suId, status)
140 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
142 #if (ERRCLASS & ERRCLS_ADD_RES)
145 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
146 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
147 (ErrVal)EKWU004, (ErrVal)0, "SGetMsg() failed");
149 #endif /* ERRCLASS & ERRCLS_ADD_RES */
153 CMCHKPKLOG(SPkU8, status, mBuf, EKWU005, pst);
154 CMCHKPKLOG(SPkS16, suId, mBuf, EKWU006, pst);
155 pst->event = (Event) KWU_EVT_BND_CFM;
156 RETVALUE(SPstTsk(pst,mBuf));
161 PUBLIC S16 cmPkKwuUbndReq
168 PUBLIC S16 cmPkKwuUbndReq(pst, suId, reason)
181 if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
183 #if (ERRCLASS & ERRCLS_ADD_RES)
186 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
187 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
188 (ErrVal)EKWU007, (ErrVal)0, "SGetMsg() failed");
190 #endif /* ERRCLASS & ERRCLS_ADD_RES */
193 CMCHKPKLOG(SPkS16, reason, mBuf, EKWU008, pst);
194 CMCHKPKLOG(SPkS16, suId, mBuf, EKWU009, pst);
196 pst->event = (Event) KWU_EVT_UBND_REQ;
197 RETVALUE(SPstTsk(pst,mBuf));
198 } /* cmPkKwuUbndReq */
201 PUBLIC S16 cmPkKwuDatReqInfo
203 KwuDatReqInfo *param,
207 PUBLIC S16 cmPkKwuDatReqInfo(param, mBuf)
208 KwuDatReqInfo *param;
213 TRC3(cmPkKwuDatReqInfo);
216 switch(param->lcType) {
217 case CM_LTE_LCH_CCCH:
218 CMCHKPK(cmPkLteRnti, param->tm.rnti, mBuf);
220 case CM_LTE_LCH_BCCH:
221 case CM_LTE_LCH_PCCH:
222 CMCHKPK(cmPkLteTimingInfo, ¶m->tm.tmg, mBuf);
224 CMCHKPK(SPkU8, param->emtcDiReason,mBuf);
225 CMCHKPK(SPkU8, param->pnb,mBuf);
228 case CM_LTE_LCH_DTCH:
229 case CM_LTE_LCH_DCCH:
234 CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
237 CMCHKPK(SPkU32, param->sduId, mBuf);
238 CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
240 } /* cmPkKwuDatReqInfo */
244 PUBLIC S16 cmPkKwuDatReq
248 KwuDatReqInfo* datReq,
252 PUBLIC S16 cmPkKwuDatReq(pst, spId, datReq, mBuf)
255 KwuDatReqInfo* datReq;
260 #if (ERRCLASS & ERRCLS_ADD_RES)
265 KwuDatReqInfo* datReqInfo;
269 switch(pst->selector)
273 if(pst->srcEnt == ENTPJ)
275 /* When the Selector is LWLC, we need to allocate memory, copy
276 * the contents and pass the pointer of the allocated memory. The
277 * subsequent free would be done during the Unpack function of the
279 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datReqInfo,
280 sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY)) != ROK)
282 #if (ERRCLASS & ERRCLS_ADD_RES)
285 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
286 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
287 (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
289 #endif /* ERRCLASS & ERRCLS_ADD_RES */
292 cmMemcpy((U8*)datReqInfo,(U8*)datReq,sizeof(KwuDatReqInfo));
293 CMCHKPK(cmPkPtr,(PTR)datReqInfo, mBuf);
297 CMCHKPK(cmPkPtr,(PTR)datReq, mBuf);
303 #if (ERRCLASS & ERRCLS_ADD_RES)
304 ret1 = cmPkKwuDatReqInfo( (datReq), mBuf);
308 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
309 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
310 (ErrVal)EKWU010, (ErrVal)ret1, "Packing failure");
314 cmPkKwuDatReqInfo( (datReq), mBuf);
315 #endif /* ERRCLASS & ERRCLS_ADD_RES */
316 if(pst->srcEnt == ENTNH)
318 if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
319 sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
329 #if (ERRCLASS & ERRCLS_ADD_RES)
330 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
331 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
332 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
333 #endif /* ERRCLASS & ERRCLS_ADD_RES */
337 CMCHKPKLOG(SPkS16, spId, mBuf, EKWU011, pst);
339 if(datReq->rlcId.rbType == CM_LTE_SRB)
341 pst->event = (Event) KWU_EVT_CPLANE_DAT_REQ;
345 pst->event = (Event) KWU_EVT_UPLANE_DAT_REQ;
348 pst->event = (Event) KWU_EVT_DAT_REQ;
350 RETVALUE(SPstTsk(pst,mBuf));
352 if (pst->srcEnt == ENTPJ)
355 KwuDatReqDetl *kwuDatReqDetl = NULLP;
356 elem = SRngGetWIndx(SS_RNG_BUF_DLPDCP_TO_DLRLC);
359 kwuDatReqDetl = (KwuDatReqDetl *) elem;
360 kwuDatReqDetl->spId = spId;
361 kwuDatReqDetl->lcType = datReq->lcType;
362 kwuDatReqDetl->sduId = datReq->sduId;
363 kwuDatReqDetl->rlcId = datReq->rlcId;
364 kwuDatReqDetl->mBuf = mBuf;
365 SRngIncrWIndx(SS_RNG_BUF_DLPDCP_TO_DLRLC);
366 SsRngInfoTbl[SS_RNG_BUF_DLPDCP_TO_DLRLC].pktRate++;
371 SsRngInfoTbl[SS_RNG_BUF_DLPDCP_TO_DLRLC].pktDrop++;
378 switch(pst->selector)
383 ret1 = cmPkKwuDatReqInfo( (datReq), mBuf);
384 #if (ERRCLASS & ERRCLS_ADD_RES)
388 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
389 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
390 (ErrVal)EKWU010, (ErrVal)ret1, "Packing failure");
393 #endif /* ERRCLASS & ERRCLS_ADD_RES */
398 CMCHKPK(cmPkPtr,(PTR)datReq, mBuf);
404 CMCHKPKLOG(SPkS16, spId, mBuf, EKWU011, pst);
405 pst->event = (Event) KWU_EVT_DAT_REQ;
406 ret1 = SPstTsk(pst,mBuf);
407 if(pst->selector == KWU_SEL_LC)
409 if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
410 sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
419 } /* cmPkKwuDatReq */
423 PUBLIC S16 cmPkKwuDatIndInfo
425 KwuDatIndInfo *param,
429 PUBLIC S16 cmPkKwuDatIndInfo(param, mBuf)
430 KwuDatIndInfo *param;
434 TRC3(cmPkKwuDatIndInfo);
436 CMCHKPK(SPkU8, param->isOutOfSeq, mBuf);
438 CMCHKPK(cmPkLteRnti, param->tCrnti, mBuf);
440 CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
446 PUBLIC S16 cmPkKwuDatInd
450 KwuDatIndInfo* datInd,
454 PUBLIC S16 cmPkKwuDatInd(pst, suId, datInd, mBuf)
457 KwuDatIndInfo* datInd;
464 #ifdef TENB_SPLIT_ARCH
465 #ifdef SS_LOCKLESS_MEMORY
469 KwuDatIndInfo *datIndInfo = NULLP;
473 #ifdef TENB_SPLIT_ARCH
475 #ifdef SS_LOCKLESS_MEMORY
476 mInfo = (SsMsgInfo *)mBuf->b_rptr;
477 mInfo->region = pst->region;
478 #endif /* SS_LOCKLESS_MEMORY */
481 switch(pst->selector)
485 /* When the Selector is LWLC, we need to allocate memory, copy
486 * the contents and pass the pointer of the allocated memory. The
487 * subsequent free would be done during the Unpack function of the
489 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datIndInfo,
490 sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY)) != ROK)
492 #if (ERRCLASS & ERRCLS_ADD_RES)
495 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
496 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
497 (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
499 #endif /* ERRCLASS & ERRCLS_ADD_RES */
503 cmMemcpy((U8*)datIndInfo,(U8*)datInd,sizeof(KwuDatIndInfo));
504 CMCHKPK(cmPkPtr,(PTR)datIndInfo, mBuf);
509 #if (ERRCLASS & ERRCLS_ADD_RES)
510 ret1 = cmPkKwuDatIndInfo( (datInd), mBuf);
514 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
515 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
516 (ErrVal)EKWU012, (ErrVal)ret1, "Packing failure");
520 cmPkKwuDatIndInfo( (datInd), mBuf);
521 #endif /* ERRCLASS & ERRCLS_ADD_RES */
523 /*Commenting out the below block as no Memory Allocation happens
524 * in Protocol. This code will be removed once testing is done */
525 if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
526 sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY) != ROK)
536 #if (ERRCLASS & ERRCLS_ADD_RES)
537 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
538 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
539 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
540 #endif /* ERRCLASS & ERRCLS_ADD_RES */
544 CMCHKPKLOG(SPkS16, suId, mBuf, EKWU013, pst);
545 pst->event = (Event) KWU_EVT_DAT_IND;
547 RETVALUE(SPstTsk(pst,mBuf));
548 } /* cmPkKwuDatInd */
552 PUBLIC S16 cmPkKwuDatCfmInfo
554 KwuDatCfmInfo *param,
558 PUBLIC S16 cmPkKwuDatCfmInfo(param, mBuf)
559 KwuDatCfmInfo *param;
565 TRC3(cmPkKwuDatCfmInfo);
566 for(iter = 0; iter < param->numSduIds; iter++)
568 CMCHKPK(SPkU32, param->sduIds[iter], mBuf);
570 CMCHKPK(SPkU32, param->numSduIds, mBuf);
571 CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
573 } /* cmPkKwuDatCfmInfo */
577 PUBLIC S16 cmPkKwuDatCfm
581 KwuDatCfmInfo* datCfm
584 PUBLIC S16 cmPkKwuDatCfm(pst, suId, datCfm)
587 KwuDatCfmInfo* datCfm;
590 #if (ERRCLASS & ERRCLS_ADD_RES)
599 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
603 switch(pst->selector)
607 CMCHKPK(cmPkPtr,(PTR)datCfm, mBuf);
612 #if (ERRCLASS & ERRCLS_ADD_RES)
613 ret1 = cmPkKwuDatCfmInfo( (datCfm), mBuf);
617 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
618 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
619 (ErrVal)EKWU014, (ErrVal)ret1, "Packing failure");
623 cmPkKwuDatCfmInfo( (datCfm), mBuf);
624 #endif /* ERRCLASS & ERRCLS_ADD_RES */
625 if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datCfm,
626 sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY) != ROK)
635 #if (ERRCLASS & ERRCLS_ADD_RES)
636 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
637 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
638 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
639 #endif /* ERRCLASS & ERRCLS_ADD_RES */
643 CMCHKPKLOG(SPkS16, suId, mBuf, EKWU015, pst);
644 pst->event = (Event) KWU_EVT_DAT_CFM;
646 RETVALUE(SPstTsk(pst,mBuf));
647 } /* cmPkKwuDatCfm */
651 PUBLIC S16 cmPkKwuDiscSduReq
655 KwuDiscSduInfo* discSdu
658 PUBLIC S16 cmPkKwuDiscSduReq(pst, spId, discSdu)
661 KwuDiscSduInfo* discSdu;
668 KwuDiscSduInfo* discSduInfo = NULLP;
670 TRC3(cmPkKwuDiscSduReq)
673 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
677 switch(pst->selector)
681 /* When the Selector is LWLC, we need to allocate memory, copy
682 * the contents and pass the pointer of the allocated memory. The
683 * subsequent free would be done during the Unpack function of the
685 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSduInfo,
686 sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
688 #if (ERRCLASS & ERRCLS_ADD_RES)
691 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
692 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
693 (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
695 #endif /* ERRCLASS & ERRCLS_ADD_RES */
699 cmMemcpy((U8*)discSduInfo,(U8*)discSdu,sizeof(KwuDiscSduInfo));
700 CMCHKPK(cmPkPtr,(PTR)discSduInfo, mBuf);
705 #if (ERRCLASS & ERRCLS_ADD_RES)
706 ret1 = cmPkKwuDiscSduInfo( (discSdu), mBuf);
710 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
711 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
712 (ErrVal)EKWU016, (ErrVal)ret1, "Packing failure");
716 cmPkKwuDiscSduInfo( (discSdu), mBuf);
717 #endif /* ERRCLASS & ERRCLS_ADD_RES */
719 if (SPutSBuf(pst->region, pst->pool, (Data *)discSdu,
720 sizeof(KwuDiscSduInfo)) != ROK)
730 CMCHKPKLOG(SPkS16, spId, mBuf, EKWU017, pst);
731 pst->event = (Event) KWU_EVT_DISC_SDU_REQ;
733 RETVALUE(SPstTsk(pst,mBuf));
734 } /* cmPkKwuDiscSduReq */
738 PUBLIC S16 cmPkKwuStaIndInfo
740 KwuStaIndInfo *param,
744 PUBLIC S16 cmPkKwuStaIndInfo(param, mBuf)
745 KwuStaIndInfo *param;
751 TRC3(cmPkKwuStaIndInfo);
753 for (i = (param->numSdu - 1); i >= 0; i--)
755 CMCHKPK(SPkU32, param->sduId[(U16)i], mBuf);
757 CMCHKPK(SPkU32, param->numSdu, mBuf);
758 CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
763 PUBLIC S16 cmPkKwuFlowCntrlIndInfo
765 KwuFlowCntrlIndInfo *param,
769 PUBLIC S16 cmPkKwuFlowCntrlIndInfo(param, mBuf)
770 KwuFlowCntrlIndInfo *param;
774 TRC3(cmPkKwuFlowCntrlIndInfo);
776 CMCHKPK(SPkU32, param->pktAdmitCnt, mBuf);
777 CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
780 } /* cmPkKwuFlowCntrlIndInfo */
783 PUBLIC S16 cmUnpkKwuFlowCntrlIndInfo
785 KwuFlowCntrlIndInfo *param,
789 PUBLIC S16 cmUnpkKwuFlowCntrlIndInfo(param, mBuf)
790 KwuFlowCntrlIndInfo *param;
794 TRC3(cmUnpkKwuFlowCntrlIndInfo);
796 CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
797 CMCHKUNPK(SUnpkU32, ¶m->pktAdmitCnt, mBuf);
800 } /* cmUnpkKwuFlowCntrlIndInfo */
804 PUBLIC S16 cmPkKwuStaInd
808 KwuStaIndInfo* staInd
811 PUBLIC S16 cmPkKwuStaInd(pst, suId, staInd)
814 KwuStaIndInfo* staInd;
818 #if (ERRCLASS & ERRCLS_ADD_RES)
828 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
832 switch(pst->selector)
836 CMCHKPK(cmPkPtr,(PTR) staInd, mBuf);
841 #if (ERRCLASS & ERRCLS_ADD_RES)
842 ret1 = cmPkKwuStaIndInfo( (staInd), mBuf);
846 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
847 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
848 (ErrVal)EKWU018, (ErrVal)ret1, "Packing failure");
852 cmPkKwuStaIndInfo( (staInd), mBuf);
853 #endif /* ERRCLASS & ERRCLS_ADD_RES */
854 if (SPutStaticBuffer(pst->region, pst->pool, (Data *)staInd,
855 sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY) != ROK)
864 #if (ERRCLASS & ERRCLS_ADD_RES)
865 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
866 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
867 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
872 CMCHKPKLOG(SPkS16, suId, mBuf, EKWU019, pst);
873 pst->event = (Event) KWU_EVT_STA_IND;
875 RETVALUE(SPstTsk(pst,mBuf));
876 } /* cmPkKwuStaInd */
880 PUBLIC S16 cmPkKwuReEstCmpInd
887 PUBLIC S16 cmPkKwuReEstCmpInd(pst, suId, rlcId)
894 #if (ERRCLASS & ERRCLS_ADD_RES)
900 TRC3(cmPkKwuReEstCmpInd)
904 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
908 switch(pst->selector)
913 #if (ERRCLASS & ERRCLS_ADD_RES)
914 ret1 = cmPkLteRlcId( &rlcId, mBuf);
918 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
919 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
920 (ErrVal)EKWU018, (ErrVal)ret1, "Packing failure");
924 cmPkLteRlcId( &rlcId, mBuf);
925 #endif /* ERRCLASS & ERRCLS_ADD_RES */
931 CMCHKPKLOG(SPkS16, suId, mBuf, EKWU019, pst);
932 pst->event = (Event) KWU_EVT_REEST_CMP_IND;
934 RETVALUE(SPstTsk(pst,mBuf));
935 } /* cmPkKwuReEstCmpInd */
937 /* kwu_c_001.main_3 added support for L2 Measurement */
939 PUBLIC S16 cmPkKwuDiscSduCfm
943 KwuDiscSduInfo *discCfmSdu
946 PUBLIC S16 cmPkKwuDiscSduCfm(pst, spId, discCfmSdu)
949 KwuDiscSduInfo *discCfmSdu;
952 #if (ERRCLASS & ERRCLS_ADD_RES)
957 TRC3(cmPkKwuDiscSduCfm)
961 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
965 switch(pst->selector)
969 CMCHKPK(cmPkPtr,(PTR)discCfmSdu, mBuf);
974 #if (ERRCLASS & ERRCLS_ADD_RES)
975 ret1 = cmPkKwuDiscSduInfo((discCfmSdu), mBuf);
979 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
980 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
981 (ErrVal)ERRKWU, (ErrVal)ret1, "Packing failure");
985 cmPkKwuDiscSduInfo((discCfmSdu), mBuf);
986 #endif /* ERRCLASS & ERRCLS_ADD_RES */
987 if (SPutStaticBuffer(pst->region, pst->pool, (Data *)discCfmSdu,
988 sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY) != ROK)
997 #if (ERRCLASS & ERRCLS_ADD_RES)
998 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
999 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1000 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1005 CMCHKPKLOG(SPkS16, spId, mBuf, ERRKWU, pst);
1006 pst->event = (Event) KWU_EVT_DISC_SDU_CFM;
1008 RETVALUE(SPstTsk(pst,mBuf));
1009 } /* cmPkKwuDiscSduCfm */
1012 PUBLIC S16 cmPkKwuFlowCntrlInd
1016 KwuFlowCntrlIndInfo *flowCntrlIndInfo
1019 PUBLIC S16 cmPkKwuFlowCntrlInd(pst, suId, flowCntrlIndInfo)
1022 KwuFlowCntrlIndInfo *flowCntrlIndInfo;
1027 TRC3(cmPkKwuFlowCntrlInd)
1031 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
1033 SPutStaticBuffer(pst->region,
1035 (Data *)flowCntrlIndInfo,
1036 sizeof(KwuFlowCntrlIndInfo),0);
1040 switch(pst->selector)
1044 cmPkKwuFlowCntrlIndInfo((flowCntrlIndInfo), mBuf);
1046 if (SPutStaticBuffer(pst->region,
1048 (Data *)flowCntrlIndInfo,
1049 sizeof(KwuFlowCntrlIndInfo),0) != ROK)
1059 CMCHKPK(cmPkPtr,(PTR) flowCntrlIndInfo, mBuf);
1065 CMCHKPKLOG(SPkS16, suId, mBuf, ERRKWU, pst);
1066 pst->event = (Event) KWU_EVT_FLOW_CNTRL_IND;
1068 RETVALUE(SPstTsk(pst,mBuf));
1069 } /* cmPkKwuFlowCntrlInd */
1073 PUBLIC S16 cmPkKwuDatAckInfo
1075 KwuDatAckInfo *param,
1079 PUBLIC S16 cmPkKwuDatAckInfo(param, mBuf)
1080 KwuDatAckInfo *param;
1084 TRC3(cmPkKwuDatAckIndInfo);
1086 CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
1087 CMCHKPK(SPkU32, param->sduId, mBuf);
1092 PUBLIC S16 cmPkKwuDatAckInd
1096 KwuDatAckInfo* datInd
1099 PUBLIC S16 cmPkKwuDatAckInd(pst, suId, datInd)
1102 KwuDatAckInfo* datInd;
1109 TRC3(cmPkKwuDatAckInd);
1113 if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1117 ret1 = cmPkKwuDatAckInfo( (datInd), mBuf);
1118 #if (ERRCLASS & ERRCLS_ADD_RES)
1122 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1123 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1124 (ErrVal)ERRKWU, (ErrVal)ret1, "Packing failure");
1127 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1128 if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
1129 sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY) != ROK)
1135 CMCHKPKLOG(SPkS16, suId, mBuf, ERRKWU, pst);
1136 pst->event = (Event) KWU_EVT_DAT_ACK_IND;
1138 RETVALUE(SPstTsk(pst,mBuf));
1139 } /* cmPkKwuDatAckInd */
1140 #endif /* LTE_L2_MEAS */
1144 PUBLIC S16 cmUnpkKwuBndReq
1151 PUBLIC S16 cmUnpkKwuBndReq(func, pst, mBuf)
1160 TRC3(cmUnpkKwuBndReq)
1162 CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU020, pst);
1163 CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU021, pst);
1166 RETVALUE((*func)(pst, suId, spId));
1171 PUBLIC S16 cmUnpkKwuBndCfm
1178 PUBLIC S16 cmUnpkKwuBndCfm(func, pst, mBuf)
1187 TRC3(cmUnpkKwuBndCfm)
1189 CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU022, pst);
1190 CMCHKUNPKLOG(SUnpkU8, &status, mBuf, EKWU023, pst);
1193 RETVALUE((*func)(pst, suId, status));
1198 PUBLIC S16 cmUnpkKwuUbndReq
1205 PUBLIC S16 cmUnpkKwuUbndReq(func, pst, mBuf)
1214 TRC3(cmUnpkKwuUbndReq)
1216 CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU024, pst);
1217 CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, EKWU025, pst);
1220 RETVALUE((*func)(pst, spId, reason));
1221 } /* cmUnpkKwuUbndReq */
1225 PUBLIC S16 cmUnpkKwuDatReqInfo
1227 KwuDatReqInfo *param,
1231 PUBLIC S16 cmUnpkKwuDatReqInfo(param, mBuf)
1232 KwuDatReqInfo *param;
1237 TRC3(cmUnpkKwuDatReqInfo);
1239 CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
1240 CMCHKUNPK(SUnpkU32, ¶m->sduId, mBuf);
1243 CMCHKUNPK(cmUnpkLteLcType, ¶m->lcType, mBuf);
1244 switch(param->lcType) {
1245 case CM_LTE_LCH_BCCH:
1246 case CM_LTE_LCH_PCCH:
1248 CMCHKUNPK(SUnpkU8,¶m->pnb , mBuf);
1249 CMCHKUNPK(SUnpkU8,¶m->emtcDiReason , mBuf);
1251 CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->tm.tmg, mBuf);
1254 case CM_LTE_LCH_CCCH:
1255 CMCHKUNPK(cmUnpkLteRnti, ¶m->tm.rnti, mBuf);
1257 case CM_LTE_LCH_DTCH:
1258 case CM_LTE_LCH_DCCH:
1269 PUBLIC S16 cmUnpkKwuDatReq
1276 PUBLIC S16 cmUnpkKwuDatReq(func, pst, mBuf)
1282 #if(ERRCLASS & ERRCLS_DEBUG)
1287 KwuDatReqInfo *datReq = NULLP;
1288 KwuDatReqInfo datReqTmp;
1290 TRC3(cmUnpkKwuDatReq)
1293 CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1295 switch(pst->selector)
1299 CMCHKUNPK(cmUnpkPtr,(PTR *) &datReq, mBuf);
1305 /*This will be removed once the testing is done on all platforms */
1306 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datReq,\
1307 sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY)) != ROK)
1309 #if (ERRCLASS & ERRCLS_ADD_RES)
1311 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1312 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1313 (ErrVal)EKWU026, (ErrVal)0, "SGetMsg() failed");
1315 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1320 /* Allocate the memory statically as there is no free
1322 datReq = &datReqTmp;
1323 cmMemset((U8 *)datReq, 0, sizeof(KwuDatReqInfo));
1324 #if(ERRCLASS & ERRCLS_DEBUG)
1325 ret1 = cmUnpkKwuDatReqInfo( (datReq), mBuf);
1329 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1330 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1331 (ErrVal)EKWU027, (ErrVal)ret1, "Unpacking failure");
1335 cmUnpkKwuDatReqInfo( (datReq), mBuf);
1336 #endif /* ERRCLASS & ERRCLS_DEBUG */
1341 #if (ERRCLASS & ERRCLS_ADD_RES)
1342 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1343 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1344 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1349 retVal = (*func)(pst, spId, datReq, mBuf);
1350 /* If LWLC is configured, we need to
1351 * free the memory here. */
1352 if(pst->selector == KWU_SEL_LWLC)
1354 retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
1355 sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY);
1358 } /* cmUnpkKwuDatReq */
1362 PUBLIC S16 cmUnpkKwuDatIndInfo
1364 KwuDatIndInfo *param,
1368 PUBLIC S16 cmUnpkKwuDatIndInfo(param, mBuf)
1369 KwuDatIndInfo *param;
1373 TRC3(cmUnpkKwuDatIndInfo);
1375 CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
1378 CMCHKUNPK(cmUnpkLteRnti, ¶m->tCrnti, mBuf);
1380 CMCHKUNPK(SUnpkU8, ¶m->isOutOfSeq, mBuf);
1386 PUBLIC S16 cmUnpkKwuDatInd
1393 PUBLIC S16 cmUnpkKwuDatInd(func, pst, mBuf)
1399 S16 ret1 = ROK, retVal;
1401 KwuDatIndInfo *datInd = NULLP;
1402 KwuDatIndInfo datIndTmp;
1404 TRC3(cmUnpkKwuDatInd)
1406 CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1408 switch(pst->selector)
1412 CMCHKUNPK(cmUnpkPtr,(PTR *) &datInd, mBuf);
1417 /*SGetStaticBuffer used as RRC has an equivalent free but PDCP
1418 * doesn't free any memory */
1419 if(pst->dstEnt != ENTPJ)
1421 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datInd,
1422 sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY)) != ROK)
1424 #if (ERRCLASS & ERRCLS_ADD_RES)
1427 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1428 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1429 (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
1431 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1437 datInd = &datIndTmp;
1440 ret1 = cmUnpkKwuDatIndInfo( (datInd), mBuf);
1441 #if(ERRCLASS & ERRCLS_DEBUG)
1445 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1446 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1447 (ErrVal)EKWU029, (ErrVal)ret1, "Unpacking failure");
1450 #endif /* ERRCLASS & ERRCLS_DEBUG */
1455 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1456 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1457 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1460 retVal = (*func)(pst, suId, datInd, mBuf);
1461 /* If LWLC is configured and the destination entity is PDCP, we need to
1462 * free the memory here. */
1463 if((pst->selector == KWU_SEL_LWLC) && (pst->dstEnt == ENTPJ))
1465 retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
1466 sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY);
1469 } /* cmUnpkKwuDatInd */
1473 PUBLIC S16 cmUnpkKwuDatCfmInfo
1475 KwuDatCfmInfo *param,
1479 PUBLIC S16 cmUnpkKwuDatCfmInfo(param, mBuf)
1480 KwuDatCfmInfo *param;
1485 TRC3(cmUnpkKwuDatCfmInfo);
1487 CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
1488 CMCHKUNPK(SUnpkU32, ¶m->numSduIds, mBuf);
1490 #ifdef L2_L3_SPLIT /*Work Around */
1491 if (param->numSduIds >= KWU_MAX_DAT_CFM)
1492 param->numSduIds = KWU_MAX_DAT_CFM;
1494 for(iter = param->numSduIds -1; iter >= 0 ; iter--)
1496 CMCHKUNPK(SUnpkU32, ¶m->sduIds[iter], mBuf);
1502 PUBLIC S16 cmUnpkKwuDatCfm
1509 PUBLIC S16 cmUnpkKwuDatCfm(func, pst, mBuf)
1517 KwuDatCfmInfo *datCfm = NULLP;
1519 TRC3(cmUnpkKwuDatCfm)
1521 CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1523 switch(pst->selector)
1527 CMCHKUNPK(cmUnpkPtr,(PTR *) &datCfm, mBuf);
1532 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datCfm,\
1533 sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY)) != ROK)
1535 #if (ERRCLASS & ERRCLS_ADD_RES)
1538 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1539 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1540 (ErrVal)EKWU030, (ErrVal)0, "SGetMsg() failed");
1542 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1546 cmMemset((U8 *)datCfm, 0, sizeof(KwuDatCfmInfo));
1547 ret1 = cmUnpkKwuDatCfmInfo( (datCfm), mBuf);
1548 #if(ERRCLASS & ERRCLS_DEBUG)
1552 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1553 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1554 (ErrVal)EKWU031, (ErrVal)ret1, "Unpacking failure");
1557 #endif /* ERRCLASS & ERRCLS_DEBUG */
1561 #if (ERRCLASS & ERRCLS_ADD_RES)
1562 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1563 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1564 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1572 RETVALUE((*func)(pst, suId, datCfm));
1573 } /* cmUnpkKwuDatCfm */
1577 PUBLIC S16 cmUnpkKwuDiscSduReq
1584 PUBLIC S16 cmUnpkKwuDiscSduReq(func, pst, mBuf)
1592 KwuDiscSduInfo *discSdu = NULLP;
1595 CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1596 switch(pst->selector)
1600 CMCHKUNPK(cmUnpkPtr,(PTR *) &discSdu, mBuf);
1605 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSdu,\
1606 sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
1608 #if (ERRCLASS & ERRCLS_ADD_RES)
1610 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1611 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1612 (ErrVal)EKWU032, (ErrVal)0, "SGetMsg() failed");
1614 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1618 cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo));
1619 ret1 = cmUnpkKwuDiscSduInfo( (discSdu), mBuf);
1620 #if(ERRCLASS & ERRCLS_DEBUG)
1624 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1625 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1626 (ErrVal)EKWU033, (ErrVal)ret1, "Unpacking failure");
1629 #endif /* ERRCLASS & ERRCLS_DEBUG */
1633 #if (ERRCLASS & ERRCLS_ADD_RES)
1634 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1635 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1636 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1643 RETVALUE((*func)(pst, spId, discSdu));
1644 } /* cmUnpkKwuDiscSduReq */
1648 PUBLIC S16 cmUnpkKwuStaIndInfo
1650 KwuStaIndInfo *param,
1654 PUBLIC S16 cmUnpkKwuStaIndInfo(param, mBuf)
1655 KwuStaIndInfo *param;
1661 TRC3(cmUnpkKwuStaIndInfo);
1663 CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
1664 CMCHKUNPK(SUnpkU32, ¶m->numSdu, mBuf);
1665 for (i = 0; i < param->numSdu; i++)
1667 CMCHKUNPK(SUnpkU32, ¶m->sduId[i], mBuf);
1671 } /* cmUnpkKwuStaIndInfo */
1675 PUBLIC S16 cmUnpkKwuStaInd
1682 PUBLIC S16 cmUnpkKwuStaInd(func, pst, mBuf)
1690 KwuStaIndInfo *staInd = NULLP;
1692 TRC3(cmUnpkKwuStaInd)
1694 CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1696 switch(pst->selector)
1700 CMCHKUNPK(cmUnpkPtr,(PTR *)&staInd, mBuf);
1705 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&staInd,\
1706 sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY)) != ROK)
1708 #if (ERRCLASS & ERRCLS_ADD_RES)
1711 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1712 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1713 (ErrVal)EKWU034, (ErrVal)0, "SGetMsg() failed");
1715 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1719 cmMemset((U8 *)staInd, 0, sizeof(KwuStaIndInfo));
1721 ret1 = cmUnpkKwuStaIndInfo( (staInd), mBuf);
1722 #if(ERRCLASS & ERRCLS_DEBUG)
1726 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1727 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1728 (ErrVal)EKWU035, (ErrVal)ret1, "Unpacking failure");
1731 #endif /* ERRCLASS & ERRCLS_DEBUG */
1736 #if(ERRCLASS & ERRCLS_DEBUG)
1737 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1738 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1739 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1745 RETVALUE((*func)(pst, suId, staInd));
1746 } /* cmUnpkKwuStaInd */
1750 PUBLIC S16 cmUnpkKwuReEstCmpInd
1752 KwuReEstCmpInd func,
1757 PUBLIC S16 cmUnpkKwuReEstCmpInd(func, pst, mBuf)
1758 KwuReEstCmpInd func;
1763 #if(ERRCLASS & ERRCLS_DEBUG)
1769 TRC3(cmUnpkKwuReEstCmpInd)
1771 cmMemset((U8 *)&rlcId, 0, sizeof(CmLteRlcId));
1773 CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1774 switch(pst->selector)
1779 #if(ERRCLASS & ERRCLS_DEBUG)
1780 ret1 = cmUnpkLteRlcId( &rlcId, mBuf);
1784 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1785 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1786 (ErrVal)EKWU035, (ErrVal)ret1, "Unpacking failure");
1790 cmUnpkLteRlcId( &rlcId, mBuf);
1791 #endif /* ERRCLASS & ERRCLS_DEBUG */
1798 RETVALUE((*func)(pst, suId, rlcId));
1799 } /* cmUnpkKwuReEstCmpInd */
1801 /* kwu_c_001.main_3 added support for L2 Measurement */
1803 PUBLIC S16 cmUnpkKwuDiscSduCfm
1810 PUBLIC S16 cmUnpkKwuDiscSduCfm(func, pst, mBuf)
1818 KwuDiscSduInfo *discSdu = NULLP;
1820 TRC3(cmUnpkKwuDiscSduCfm);
1822 CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1824 switch(pst->selector)
1828 CMCHKUNPK(cmUnpkPtr,(PTR *) &discSdu, mBuf);
1833 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSdu,\
1834 sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
1836 #if (ERRCLASS & ERRCLS_ADD_RES)
1839 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1840 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1841 (ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
1843 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1846 cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo));
1848 ret1 = cmUnpkKwuDiscSduInfo( (discSdu), mBuf);
1849 #if(ERRCLASS & ERRCLS_DEBUG)
1853 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1854 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1855 (ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
1857 #endif /* ERRCLASS & ERRCLS_DEBUG */
1862 #if(ERRCLASS & ERRCLS_DEBUG)
1863 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1864 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1865 (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1871 RETVALUE((*func)(pst, spId, discSdu));
1872 } /* cmUnpkKwuDiscSduCfm */
1874 PUBLIC S16 cmUnpkKwuFlowCntrlInd
1876 KwuFlowCntrlInd func,
1881 PUBLIC S16 cmUnpkKwuFlowCntrlInd(func, pst, mBuf)
1882 KwuFlowCntrlInd func;
1888 KwuFlowCntrlIndInfo *flowCntrlInfo = NULLP;
1890 TRC3(cmUnpkKwuFlowCntrlInd);
1892 CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1893 switch(pst->selector)
1898 if(SGetStaticBuffer(pst->region,
1900 (Data **)&flowCntrlInfo,
1901 sizeof(KwuFlowCntrlIndInfo),0) != ROK)
1907 cmUnpkKwuFlowCntrlIndInfo(flowCntrlInfo, mBuf);
1913 CMCHKUNPK(cmUnpkPtr,(PTR *) &flowCntrlInfo, mBuf);
1921 RETVALUE((*func)(pst, suId, flowCntrlInfo));
1922 } /* cmUnpkKwuFlowCntrlInd */
1926 PUBLIC S16 cmUnpkKwuDatAckInfo
1928 KwuDatAckInfo *param,
1932 PUBLIC S16 cmUnpkKwuDatAckInfo(param, mBuf)
1933 KwuDatAckInfo *param;
1937 TRC3(cmUnpkKwuDatAckInfo);
1939 CMCHKUNPK(SUnpkU32, ¶m->sduId, mBuf);
1940 CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
1947 PUBLIC S16 cmUnpkKwuDatAckInd
1954 PUBLIC S16 cmUnpkKwuDatAckInd(func, pst, mBuf)
1962 KwuDatAckInfo *datInd = NULLP;
1964 TRC3(cmUnpkKwuDatAckInd);
1966 if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datInd,\
1967 sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY)) != ROK)
1969 #if (ERRCLASS & ERRCLS_ADD_RES)
1972 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1973 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1974 (ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
1976 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1980 cmMemset((U8 *)datInd, 0, sizeof(KwuDatAckInfo));
1982 CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1983 ret1 = cmUnpkKwuDatAckInfo( (datInd), mBuf);
1984 #if(ERRCLASS & ERRCLS_DEBUG)
1988 SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1989 __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1990 (ErrVal)ERRKWU, (ErrVal)ret1, "Unpacking failure");
1993 #endif /* ERRCLASS & ERRCLS_DEBUG */
1995 RETVALUE((*func)(pst, suId, datInd));
1996 } /* cmUnpkKwuDatAckInd */
1997 #endif /* LTE_L2_MEAS */
2000 /**********************************************************************
2002 **********************************************************************/