X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fcm%2Fdu_app_rlc_inf.c;h=ff556a56c463c3f386bbf411f0ec4d9af7064096;hb=8acc76461815f24218fab9cfdc35f11f72aab36d;hp=b2ec5813e6a486c4fde5112df0daff7720827176;hpb=6d01b1cb797bb2b47115eee21ad7d1a6ff3fcfe7;p=o-du%2Fl2.git diff --git a/src/cm/du_app_rlc_inf.c b/src/cm/du_app_rlc_inf.c index b2ec5813e..ff556a56c 100644 --- a/src/cm/du_app_rlc_inf.c +++ b/src/cm/du_app_rlc_inf.c @@ -19,6 +19,88 @@ #include "common_def.h" #include "du_app_rlc_inf.h" +/******************************************************************* +* +* @brief Packs and Sends Max Retransmission Reached Info from RLC to DUAPP +* +* @details +* +* Function : packRlcDuMaxRetransInd +* +* Functionality: +* Packs and Sends Max Retransmission Reached Info from RLC to DUAPP +* +* +* @params[in] Post structure pointer +* RlcMaxRetransInfo *maxRetransInfo +* +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t packRlcDuMaxRetransInd(Pst *pst, RlcMaxRetransInfo *maxRetransInfo) +{ + Buffer *mBuf = NULLP; + + if(pst->selector == ODU_SELECTOR_LWLC) + { + if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) + { + DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDuMaxRetransInd"); + return RFAILED; + } + /* pack the address of the structure */ + CMCHKPK(oduPackPointer,(PTR)maxRetransInfo, mBuf); + } + else + { + DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcDuMaxRetransInd"); + return RFAILED; + } + + return ODU_POST_TASK(pst,mBuf); +} + +/******************************************************************* +* +* @brief Unpacks Max Retransmission Reached Info received from DU APP +* +* @details +* +* Function : unpackRlcMaxRetransInd +* +* Functionality: +* Unpacks Max Retransmission Reached Info received from DU APP +* +* @params[in] Pointer to Handler +* Post structure pointer +* Message Buffer +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t unpackRlcMaxRetransInd(RlcDuMaxRetransInd func, Pst *pst, Buffer *mBuf) +{ + if(pst->selector == ODU_SELECTOR_LWLC) + { + RlcMaxRetransInfo *maxRetransInfo = NULLP; + /* unpack the address of the structure */ + CMCHKUNPK(oduUnpackPointer, (PTR *)&maxRetransInfo, mBuf); + ODU_PUT_MSG_BUF(mBuf); + return (*func)(pst, maxRetransInfo); + } + else + { + /* Nothing to do for other selectors */ + DU_LOG("\nERROR --> RLC: Only LWLC supported for Max Retransmission Reached Info "); + ODU_PUT_MSG_BUF(mBuf); + } + + return RFAILED; +} + /******************************************************************* * * @brief Packs and Sends UE create Request from DUAPP to RLC @@ -32,12 +114,12 @@ * * * @params[in] Post structure pointer - * RlcUeCfg pointer + * RlcUeCreate pointer * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint8_t packDuRlcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg) +uint8_t packDuRlcUeCreateReq(Pst *pst, RlcUeCreate *ueCfg) { Buffer *mBuf = NULLP; @@ -45,7 +127,7 @@ uint8_t packDuRlcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg) { if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) { - DU_LOG("\nRLC : Memory allocation failed at packDuRlcUeCreateReq"); + DU_LOG("\nERROR --> RLC : Memory allocation failed at packDuRlcUeCreateReq"); return RFAILED; } /* pack the address of the structure */ @@ -53,7 +135,7 @@ uint8_t packDuRlcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg) } else { - DU_LOG("\nRLC: Only LWLC supported for packDuRlcUeCreateReq"); + DU_LOG("\nERROR --> RLC: Only LWLC supported for packDuRlcUeCreateReq"); return RFAILED; } @@ -82,7 +164,7 @@ uint8_t unpackRlcUeCreateReq(DuRlcUeCreateReq func, Pst *pst, Buffer *mBuf) { if(pst->selector == ODU_SELECTOR_LWLC) { - RlcUeCfg *ueCfg; + RlcUeCreate *ueCfg; /* unpack the address of the structure */ CMCHKUNPK(oduUnpackPointer, (PTR *)&ueCfg, mBuf); ODU_PUT_MSG_BUF(mBuf); @@ -91,7 +173,7 @@ uint8_t unpackRlcUeCreateReq(DuRlcUeCreateReq func, Pst *pst, Buffer *mBuf) else { /* Nothing to do for other selectors */ - DU_LOG("\nRLC: Only LWLC supported for UE Create Request "); + DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Create Request "); ODU_PUT_MSG_BUF(mBuf); } @@ -100,11 +182,11 @@ uint8_t unpackRlcUeCreateReq(DuRlcUeCreateReq func, Pst *pst, Buffer *mBuf) /******************************************************************* * - * @brief Packs and Sends UE Cfg Response from RLC to DUAPP + * @brief Packs and Sends UE Create Response from RLC to DUAPP * * @details * - * Function : packRlcDuUeCfgRsp + * Function : packRlcDuUeCreateRsp * * Functionality: * Packs and Sends UE Cfg Rrsponse from RLC to DUAPP @@ -116,7 +198,7 @@ uint8_t unpackRlcUeCreateReq(DuRlcUeCreateReq func, Pst *pst, Buffer *mBuf) * RFAILED - failure * * ****************************************************************/ -uint8_t packRlcDuUeCfgRsp(Pst *pst, RlcUeCfgRsp *ueCfg) +uint8_t packRlcDuUeCreateRsp(Pst *pst, RlcUeCreateRsp *ueCfg) { Buffer *mBuf = NULLP; @@ -124,7 +206,7 @@ uint8_t packRlcDuUeCfgRsp(Pst *pst, RlcUeCfgRsp *ueCfg) { if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) { - DU_LOG("\nRLC : Memory allocation failed at packRlcDuUeCfgRsp"); + DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDuUeCreateRsp"); return RFAILED; } /* pack the address of the structure */ @@ -132,7 +214,7 @@ uint8_t packRlcDuUeCfgRsp(Pst *pst, RlcUeCfgRsp *ueCfg) } else { - DU_LOG("\nRLC: Only LWLC supported for packRlcDuUeCfgRsp"); + DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcDuUeCreateRsp"); return RFAILED; } @@ -141,11 +223,11 @@ uint8_t packRlcDuUeCfgRsp(Pst *pst, RlcUeCfgRsp *ueCfg) /******************************************************************* * - * @brief Unpacks UE Cfg Response received from DU APP + * @brief Unpacks UE Create Response received from DU APP * * @details * - * Function : unpackRlcUeCfgRsp + * Function : unpackRlcUeCreateRsp * * Functionality: * Unpacks UE Cfg Response received from DU APP @@ -157,11 +239,90 @@ uint8_t packRlcDuUeCfgRsp(Pst *pst, RlcUeCfgRsp *ueCfg) * RFAILED - failure * * ****************************************************************/ -uint8_t unpackRlcUeCfgRsp(RlcDuUeCfgRsp func, Pst *pst, Buffer *mBuf) +uint8_t unpackRlcUeCreateRsp(RlcDuUeCreateRsp func, Pst *pst, Buffer *mBuf) +{ + if(pst->selector == ODU_SELECTOR_LWLC) + { + RlcUeCreateRsp *cfgRsp = NULLP; + /* unpack the address of the structure */ + CMCHKUNPK(oduUnpackPointer, (PTR *)&cfgRsp, mBuf); + ODU_PUT_MSG_BUF(mBuf); + return (*func)(pst, cfgRsp); + } + else + { + /* Nothing to do for other selectors */ + DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Cfg Response "); + ODU_PUT_MSG_BUF(mBuf); + } + + return RFAILED; +} + +/******************************************************************* + * + * @brief Packs and Sends UE Reconfig Response from RLC to DUAPP + * + * @details + * + * Function : packRlcDuUeReconfigRsp + * + * Functionality: + * Packs and Sends UE Reconfig Rrsponse from RLC to DUAPP + * + * + * @params[in] Post structure pointer + * RlcUeRecfgRsp pointer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t packRlcDuUeReconfigRsp(Pst *pst, RlcUeReconfigRsp *ueCfg) +{ + Buffer *mBuf = NULLP; + + if(pst->selector == ODU_SELECTOR_LWLC) + { + if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) + { + DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDuUeReconfigRsp"); + return RFAILED; + } + /* pack the address of the structure */ + CMCHKPK(oduPackPointer,(PTR)ueCfg, mBuf); + } + else + { + DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcDuUeReconfigRsp"); + return RFAILED; + } + + return ODU_POST_TASK(pst,mBuf); +} + +/******************************************************************* + * + * @brief Unpacks UE Reconfig Response received from DU APP + * + * @details + * + * Function : unpackRlcUeReconfigRsp + * + * Functionality: + * Unpacks UE Reconfig Response received from DU APP + * + * @params[in] Pointer to Handler + * Post structure pointer + * Message Buffer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t unpackRlcUeReconfigRsp(RlcDuUeReconfigRsp func, Pst *pst, Buffer *mBuf) { if(pst->selector == ODU_SELECTOR_LWLC) { - RlcUeCfgRsp *cfgRsp = NULLP; + RlcUeReconfigRsp *cfgRsp = NULLP; /* unpack the address of the structure */ CMCHKUNPK(oduUnpackPointer, (PTR *)&cfgRsp, mBuf); ODU_PUT_MSG_BUF(mBuf); @@ -170,7 +331,7 @@ uint8_t unpackRlcUeCfgRsp(RlcDuUeCfgRsp func, Pst *pst, Buffer *mBuf) else { /* Nothing to do for other selectors */ - DU_LOG("\nRLC: Only LWLC supported for UE Cfg Response "); + DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Re-Cfg Response "); ODU_PUT_MSG_BUF(mBuf); } @@ -202,7 +363,7 @@ uint8_t packRlcUlRrcMsgToDu(Pst *pst, RlcUlRrcMsgInfo *ulRrcMsgInfo) { if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) { - DU_LOG("\nRLC : Memory allocation failed at packRlcUlRrcMsgToDu"); + DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcUlRrcMsgToDu"); return RFAILED; } /* pack the address of the structure */ @@ -211,7 +372,7 @@ uint8_t packRlcUlRrcMsgToDu(Pst *pst, RlcUlRrcMsgInfo *ulRrcMsgInfo) } else { - DU_LOG("\nRLC: Only LWLC supported for packRlcUlRrcMsgToDu"); + DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcUlRrcMsgToDu"); } return RFAILED; } @@ -245,7 +406,7 @@ uint8_t unpackRlcUlRrcMsgToDu(RlcUlRrcMsgToDuFunc func, Pst *pst, Buffer *mBuf) else { /* Nothing to do for other selectors */ - DU_LOG("\nRLC: Only LWLC supported for UL RRC Message transfer "); + DU_LOG("\nERROR --> RLC: Only LWLC supported for UL RRC Message transfer "); ODU_PUT_MSG_BUF(mBuf); } @@ -276,7 +437,7 @@ uint8_t packDlRrcMsgToRlc(Pst *pst, RlcDlRrcMsgInfo *dlRrcMsgInfo) { if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) { - DU_LOG("\nRLC : Memory allocation failed at packRlcDlRrcMsgToRlc"); + DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDlRrcMsgToRlc"); return RFAILED; } /* pack the address of the structure */ @@ -285,7 +446,7 @@ uint8_t packDlRrcMsgToRlc(Pst *pst, RlcDlRrcMsgInfo *dlRrcMsgInfo) } else { - DU_LOG("\nRLC: Only LWLC supported for packDlRrcMsgToRlc"); + DU_LOG("\nERROR --> RLC: Only LWLC supported for packDlRrcMsgToRlc"); } return RFAILED; } @@ -321,7 +482,7 @@ uint8_t unpackDlRrcMsgToRlc(DuDlRrcMsgToRlcFunc func, Pst *pst, Buffer *mBuf) else { /* Nothing to do for other selectors */ - DU_LOG("\nRLC: Only LWLC supported for UL RRC Message transfer "); + DU_LOG("\nERROR --> RLC: Only LWLC supported for UL RRC Message transfer "); ODU_PUT_MSG_BUF(mBuf); } return RFAILED; @@ -353,7 +514,7 @@ uint8_t packRrcDeliveryReportToDu(Pst *pst, RrcDeliveryReport *rrcDeliveryReport { if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) { - DU_LOG("\nRLC : Memory allocation failed at packRrcDeliveryReportToDu"); + DU_LOG("\nERROR --> RLC : Memory allocation failed at packRrcDeliveryReportToDu"); return RFAILED; } /* pack the address of the structure */ @@ -362,7 +523,7 @@ uint8_t packRrcDeliveryReportToDu(Pst *pst, RrcDeliveryReport *rrcDeliveryReport } else { - DU_LOG("\nRLC: Only LWLC supported for packRrcDeliveryReportToDu"); + DU_LOG("\nERROR --> RLC: Only LWLC supported for packRrcDeliveryReportToDu"); } return RFAILED; } @@ -398,7 +559,7 @@ uint8_t unpackRrcDeliveryReportToDu(RlcRrcDeliveryReportToDuFunc func, Pst *pst, else { /* Nothing to do for other selectors */ - DU_LOG("\nRLC: Only LWLC supported for RRC delivery Message transfer "); + DU_LOG("\nERROR --> RLC: Only LWLC supported for RRC delivery Message transfer "); ODU_PUT_MSG_BUF(mBuf); } @@ -423,7 +584,7 @@ uint8_t unpackRrcDeliveryReportToDu(RlcRrcDeliveryReportToDuFunc func, Pst *pst, * RFAILED - failure * * ****************************************************************/ -uint8_t packDuRlcUeReconfigReq(Pst *pst, RlcUeCfg *ueCfg) +uint8_t packDuRlcUeReconfigReq(Pst *pst, RlcUeRecfg *ueRecfg) { Buffer *mBuf = NULLP; @@ -431,15 +592,15 @@ uint8_t packDuRlcUeReconfigReq(Pst *pst, RlcUeCfg *ueCfg) { if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) { - DU_LOG("\nRLC : Memory allocation failed at packDuRlcUeReconfigReq"); + DU_LOG("\nERROR --> RLC : Memory allocation failed at packDuRlcUeReconfigReq"); return RFAILED; } /* pack the address of the structure */ - CMCHKPK(oduPackPointer,(PTR)ueCfg, mBuf); + CMCHKPK(oduPackPointer,(PTR)ueRecfg, mBuf); } else { - DU_LOG("\nRLC: Only LWLC supported for packDuRlcUeReconfigReq"); + DU_LOG("\nERROR --> RLC: Only LWLC supported for packDuRlcUeReconfigReq"); return RFAILED; } @@ -467,16 +628,16 @@ uint8_t unpackRlcUeReconfigReq(DuRlcUeReconfigReq func, Pst *pst, Buffer *mBuf) { if(pst->selector == ODU_SELECTOR_LWLC) { - RlcUeCfg *ueCfg; + RlcUeRecfg *ueRecfg; /* unpack the address of the structure */ - CMCHKUNPK(oduUnpackPointer, (PTR *)&ueCfg, mBuf); + CMCHKUNPK(oduUnpackPointer, (PTR *)&ueRecfg, mBuf); ODU_PUT_MSG_BUF(mBuf); - return (*func)(pst, ueCfg); + return (*func)(pst, ueRecfg); } else { /* Nothing to do for other selectors */ - DU_LOG("\nRLC: Only LWLC supported for UE Create Request "); + DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Create Request "); ODU_PUT_MSG_BUF(mBuf); } return RFAILED; @@ -507,7 +668,7 @@ uint8_t packRlcDlRrcMsgRspToDu(Pst *pst, RlcDlRrcMsgRsp *dlRrcMsgRsp) { if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) { - DU_LOG("\nRLC : Memory allocation failed at packRlcDlRrcMsgRspToDu"); + DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDlRrcMsgRspToDu"); return RFAILED; } /* pack the address of the structure */ @@ -516,7 +677,7 @@ uint8_t packRlcDlRrcMsgRspToDu(Pst *pst, RlcDlRrcMsgRsp *dlRrcMsgRsp) } else { - DU_LOG("\nRLC: Only LWLC supported for packRlcDlRrcMsgRspToDu"); + DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcDlRrcMsgRspToDu"); } return RFAILED; } @@ -550,7 +711,7 @@ uint8_t unpackRlcDlRrcMsgRspToDu(RlcDlRrcMsgRspToDuFunc func, Pst *pst, Buffer * else { /* Nothing to do for other selectors */ - DU_LOG("\nRLC: Only LWLC supported for DL RRC Message transfer "); + DU_LOG("\nERROR --> RLC: Only LWLC supported for DL RRC Message transfer "); ODU_PUT_MSG_BUF(mBuf); } return RFAILED; @@ -624,13 +785,483 @@ uint8_t unpackRlcUlUserDataToDu(RlcUlUserDataToDuFunc func, Pst *pst, Buffer *mB else { /* Nothing to do for other selectors */ - DU_LOG("\nERROR --> DU APP: Only LWLC supported for UL User data transfer "); + DU_LOG("\nERROR --> RLC UL: Only LWLC supported for UL User data transfer "); + ODU_PUT_MSG_BUF(mBuf); + } + + return RFAILED; +} + +/******************************************************************* + * + * @brief Pack and send DL user data from DUAPP to RLC + * + * @details + * + * Function : packRlcDlUserDataToRlc + * + * Functionality: + * Pack and send DL User Data from DUAPP to RLC + * + * @params[in] Post structure + * DL user data + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t packRlcDlUserDataToRlc(Pst *pst, RlcDlUserDataInfo *dlUserData) +{ + if(pst->selector == ODU_SELECTOR_LWLC) + { + /* pack the address of the structure */ + CMCHKPK(oduPackPointer,(PTR)dlUserData, dlUserData->dlMsg); + return ODU_POST_TASK(pst,dlUserData->dlMsg); + } + else + { + DU_LOG("\nERROR --> RLC DL: Only LWLC supported for packRlcUlUserDataToDu"); + } + return RFAILED; +} + +/******************************************************************* + * + * @brief Unpack DL user data received at RLC from DUAPP + * + * @details + * + * Function : unpackRlcDlUserDataToRlc + * + * Functionality: + * Unpack DL user data received at RLC from DUAPP + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t unpackRlcDlUserDataToRlc(DuRlcDlUserDataToRlcFunc func, Pst *pst, Buffer *mBuf) +{ + if(pst->selector == ODU_SELECTOR_LWLC) + { + RlcDlUserDataInfo *dlUserData; + /* unpack the address of the structure */ + CMCHKUNPK(oduUnpackPointer, (PTR *)&dlUserData, mBuf); + return (*func)(pst, dlUserData); + } + else + { + /* Nothing to do for other selectors */ + DU_LOG("\nERROR --> RLC DL: Only LWLC supported for UL User data transfer "); ODU_PUT_MSG_BUF(mBuf); } return RFAILED; } +/******************************************************************* +* +* @brief Packs and Sends UE Delete Request from DUAPP to RLC +* +* @details +* +* Function : packDuRlcUeDeleteReq +* +* Functionality: +* Packs and Sends UE Delete Request from DUAPP to RLC +* +* +* @params[in] Post structure pointer +* RlcUeDelete pointer +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t packDuRlcUeDeleteReq(Pst *pst, RlcUeDelete *ueDelete) +{ + Buffer *mBuf = NULLP; + + if(pst->selector == ODU_SELECTOR_LWLC) + { + if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) + { + DU_LOG("\nERROR --> RLC : Memory allocation failed at packDuRlcUeDeleteReq"); + return RFAILED; + } + /* pack the address of the structure */ + CMCHKPK(oduPackPointer,(PTR)ueDelete, mBuf); + } + else + { + DU_LOG("\nERROR --> RLC: Only LWLC supported for packDuRlcUeDeleteReq"); + return RFAILED; + } + + return ODU_POST_TASK(pst,mBuf); +} + +/******************************************************************* +* @brief Unpacks UE Delete Request received from DU APP +* +* @details +* +* Function : unpackRlcUeDeleteReq +* +* Functionality: +* Unpacks UE Delete Request received from DU APP +* +* @params[in] Pointer to Handler +* Post structure pointer +* Message Buffer +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t unpackRlcUeDeleteReq(DuRlcUeDeleteReq func, Pst *pst, Buffer *mBuf) +{ + if(pst->selector == ODU_SELECTOR_LWLC) + { + RlcUeDelete *ueDelete; + /* unpack the address of the structure */ + CMCHKUNPK(oduUnpackPointer, (PTR *)&ueDelete, mBuf); + ODU_PUT_MSG_BUF(mBuf); + return (*func)(pst, ueDelete); + } + else + { + /* Nothing to do for other selectors */ + DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Delete Request "); + ODU_PUT_MSG_BUF(mBuf); + } + return RFAILED; +} + +/******************************************************************* +* +* @brief Packs and Sends UE Del Response from RLC to DUAPP +* +* @details +* +* Function : packRlcDuUeDeleteRsp +* +* Functionality: +* Packs and Sends UE Del Response from RLC to DUAPP +* +* +* @params[in] Post structure pointer +* RlcUeDeleteRsp *ueDelRsp +* +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t packRlcDuUeDeleteRsp(Pst *pst, RlcUeDeleteRsp *ueDelRsp) +{ + Buffer *mBuf = NULLP; + + if(pst->selector == ODU_SELECTOR_LWLC) + { + if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) + { + DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDuUeDeleteRsp"); + return RFAILED; + } + /* pack the address of the structure */ + CMCHKPK(oduPackPointer,(PTR)ueDelRsp, mBuf); + } + else + { + DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcDuUeDeleteRsp"); + return RFAILED; + } + + return ODU_POST_TASK(pst,mBuf); +} + +/******************************************************************* +* +* @brief Unpacks UE Del Response received from DU APP +* +* @details +* +* Function : unpackRlcUeDeleteRsp +* +* Functionality: +* Unpacks UE Del Response received from DU APP +* +* @params[in] Pointer to Handler +* Post structure pointer +* Message Buffer +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t unpackRlcUeDeleteRsp(RlcDuUeDeleteRsp func, Pst *pst, Buffer *mBuf) +{ + if(pst->selector == ODU_SELECTOR_LWLC) + { + RlcUeDeleteRsp *ueDeleteRsp = NULLP; + /* unpack the address of the structure */ + CMCHKUNPK(oduUnpackPointer, (PTR *)&ueDeleteRsp, mBuf); + ODU_PUT_MSG_BUF(mBuf); + return (*func)(pst, ueDeleteRsp); + } + else + { + /* Nothing to do for other selectors */ + DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Del Response "); + ODU_PUT_MSG_BUF(mBuf); + } + + return RFAILED; +} + +/******************************************************************* +* +* @brief Packs and Sends Slice PM from RLC to DUAPP +* +* @details +* +* Function : packRlcDuSlicePm +* +* Functionality: +* Packs and Sends Slice Performance Metrics from RLC to DUAPP +* +* +* @params[in] Post structure pointer +* SlicePmList *sliceStats +* +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t packRlcDuSlicePm(Pst *pst, SlicePmList *sliceStats) +{ + Buffer *mBuf = NULLP; + + if(pst->selector == ODU_SELECTOR_LWLC) + { + if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) + { + DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDuSlicePm"); + return RFAILED; + } + /* pack the address of the structure */ + CMCHKPK(oduPackPointer,(PTR)sliceStats, mBuf); + } + else + { + DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcDuSlicePm"); + return RFAILED; + } + + return ODU_POST_TASK(pst,mBuf); +} + +/******************************************************************* +* +* @brief Unpacks Slice PM received from RLC +* +* @details +* +* Function : unpackRlcSlicePm +* +* Functionality: +* Unpacks Slice Performance Metrics received from RLC +* +* @params[in] Pointer to Handler +* Post structure pointer +* Message Buffer +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t unpackRlcSlicePm(RlcSlicePmToDuFunc func, Pst *pst, Buffer *mBuf) +{ + if(pst->selector == ODU_SELECTOR_LWLC) + { + SlicePmList *sliceStats = NULLP; + /* unpack the address of the structure */ + CMCHKUNPK(oduUnpackPointer, (PTR *)&sliceStats, mBuf); + ODU_PUT_MSG_BUF(mBuf); + return (*func)(pst, sliceStats); + } + else + { + /* Nothing to do for other selectors */ + DU_LOG("\nERROR --> RLC: Only LWLC supported for Slice Metrics "); + ODU_PUT_MSG_BUF(mBuf); + } + + return RFAILED; +} + +/******************************************************************* +* +* @brief Packs and Sends UE Reestablishment Req from DUAPP to RLC +* +* @details +* +* Function : packDuRlcUeReestablishReq +* +* Functionality: +* Packs and Sends UE Reestablishment Req from DUAPP to RLC +* +* +* @params[in] Post structure pointer +* RlcUeReestablishReq pointer +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t packDuRlcUeReestablishReq(Pst *pst, RlcUeReestablishReq *ueDelete) +{ + Buffer *mBuf = NULLP; + + if(pst->selector == ODU_SELECTOR_LWLC) + { + if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) + { + DU_LOG("\nERROR --> RLC : Memory allocation failed at packDuRlcUeReestablishReq"); + return RFAILED; + } + /* pack the address of the structure */ + CMCHKPK(oduPackPointer,(PTR)ueDelete, mBuf); + } + else + { + DU_LOG("\nERROR --> RLC: Only LWLC supported for packDuRlcUeReestablishReq"); + return RFAILED; + } + + return ODU_POST_TASK(pst,mBuf); +} + +/******************************************************************* +* @brief Unpacks UE Reestablishment Req received from DU APP +* +* @details +* +* Function : unpackRlcUeReestablishReq +* +* Functionality: +* Unpacks UE Reestablishment Req received from DU APP +* +* @params[in] Pointer to Handler +* Post structure pointer +* Message Buffer +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t unpackRlcUeReestablishReq(DuRlcUeReestablishReq func, Pst *pst, Buffer *mBuf) +{ + if(pst->selector == ODU_SELECTOR_LWLC) + { + RlcUeReestablishReq *ueDelete; + /* unpack the address of the structure */ + CMCHKUNPK(oduUnpackPointer, (PTR *)&ueDelete, mBuf); + ODU_PUT_MSG_BUF(mBuf); + return (*func)(pst, ueDelete); + } + else + { + /* Nothing to do for other selectors */ + DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Reestablishment Req "); + ODU_PUT_MSG_BUF(mBuf); + } + return RFAILED; +} + +/******************************************************************* +* +* @brief Packs and Sends UE Reestablishment Response from RLC to DUAPP +* +* @details +* +* Function : packRlcDuUeReestablishRsp +* +* Functionality: +* Packs and Sends UE Reestablishment Response from RLC to DUAPP +* +* +* @params[in] Post structure pointer +* RlcUeReestablishRsp *ueReestablish +* +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t packRlcDuUeReestablishRsp(Pst *pst, RlcUeReestablishRsp *ueReestablish) +{ + Buffer *mBuf = NULLP; + + if(pst->selector == ODU_SELECTOR_LWLC) + { + if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK) + { + DU_LOG("\nERROR --> RLC : Memory allocation failed at packRlcDuUeReestablishRsp"); + return RFAILED; + } + /* pack the address of the structure */ + CMCHKPK(oduPackPointer,(PTR)ueReestablish, mBuf); + } + else + { + DU_LOG("\nERROR --> RLC: Only LWLC supported for packRlcDuUeReestablishRsp"); + return RFAILED; + } + + return ODU_POST_TASK(pst,mBuf); +} + +/******************************************************************* +* +* @brief Unpacks UE Reestablishment Response received from DU APP +* +* @details +* +* Function : unpackRlcUeReestablishRsp +* +* Functionality: +* Unpacks UE Reestablishment Response received from DU APP +* +* @params[in] Pointer to Handler +* Post structure pointer +* Message Buffer +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t unpackRlcUeReestablishRsp(RlcDuUeReestablishRsp func, Pst *pst, Buffer *mBuf) +{ + if(pst->selector == ODU_SELECTOR_LWLC) + { + RlcUeReestablishRsp *ueReestablishRsp = NULLP; + /* unpack the address of the structure */ + CMCHKUNPK(oduUnpackPointer, (PTR *)&ueReestablishRsp, mBuf); + ODU_PUT_MSG_BUF(mBuf); + return (*func)(pst, ueReestablishRsp); + } + else + { + /* Nothing to do for other selectors */ + DU_LOG("\nERROR --> RLC: Only LWLC supported for UE Reestablishment Response "); + ODU_PUT_MSG_BUF(mBuf); + } + + return RFAILED; +} /********************************************************************** End of file ***********************************************************************/