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 #include "common_def.h"
20 #include "du_app_mac_inf.h"
22 /**************************************************************************
23 * @brief Function to pack Loose Coupled
24 * MAC cell config parameters required by MAC
28 * Function : packMacCellCfg
31 * packs the macCellCfg parameters
33 * @param[in] Pst *pst, Post structure of the primitive.
34 * @param[in] MacCellCfg *macCellCfg, mac cell config parameters.
35 * @return ROK - success
38 ***************************************************************************/
39 uint8_t packMacCellCfg(Pst *pst, MacCellCfg *macCellCfg)
41 if(pst->selector == ODU_SELECTOR_LC)
43 /* we are now implemented only light wieght lossely coupled interface */
46 else if(pst->selector == ODU_SELECTOR_LWLC)
50 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
55 /* pack the address of the structure */
56 CMCHKPK(oduPackPointer,(PTR)macCellCfg, mBuf);
58 DU_LOG("\nDEBUG --> DU-APP : MAC CELL config sent");
59 return ODU_POST_TASK(pst,mBuf);
64 /**************************************************************************
65 * @brief Function to pack Loose Coupled
66 * MAC cell config parameters required by MAC
70 * Function : unpackDuMacCellCfg
73 * packs the macCellCfg parameters
75 * @param[in] DuMacCellCfgReq func; function pointer
76 * @param[in] Pst *pst, Post structure of the primitive.
77 * @param[in] Buffer *mBuf
78 * @return ROK - success
81 ***************************************************************************/
82 uint8_t unpackDuMacCellCfg(DuMacCellCfgReq func, Pst *pst, Buffer *mBuf)
85 MacCellCfg *macCellCfg;
87 if(pst->selector == ODU_SELECTOR_LWLC)
89 /* unpack the address of the structure */
90 CMCHKUNPK(oduUnpackPointer, (PTR *)&macCellCfg, mBuf);
91 ret = (*func)(pst, macCellCfg);
95 /* only LWLC is implemented now */
102 /**************************************************************************
103 * @brief Function to pack Loose Coupled
104 * MAC cell config confirm message
108 * Function : packMacCellCfgCfm
111 * packs the transaction ID
113 * @param[in] Pst *pst, Post structure of the primitive.
114 * @param[in] MacCellCfgCfm *macCellCfgCfm, mac cell config confirm.
115 * @return ROK - success
118 ***************************************************************************/
119 uint8_t packMacCellCfgCfm(Pst *pst, MacCellCfgCfm *macCellCfgCfm)
121 if(pst->selector == ODU_SELECTOR_LC)
123 Buffer *mBuf = NULLP;
124 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
129 /* pack the transaction ID in CNF structure */
130 CMCHKPK(oduUnpackUInt16, macCellCfgCfm->cellId, mBuf);
131 CMCHKPK(oduUnpackUInt8, macCellCfgCfm->rsp, mBuf);
133 return ODU_POST_TASK(pst,mBuf);
135 else if(pst->selector == ODU_SELECTOR_LWLC)
137 /* only LC is supported */
143 /**************************************************************************
144 * @brief Function to pack MAC cell config confirm message
148 * Function : unpackMacCellCfgCfm
151 * packs the transaction ID
153 * @param[in] DuMacCellCfgCfm func; function pointer
154 * @param[in] Pst *pst, Post structure of the primitive.
155 * @param[in] Buffer *mBuf
156 * @return ROK - success
159 ***************************************************************************/
160 uint8_t unpackMacCellCfgCfm(DuMacCellCfgCfm func, Pst *pst, Buffer *mBuf)
162 MacCellCfgCfm macCellCfgCfm;
164 if(pst->selector == ODU_SELECTOR_LC)
166 /* unpack the transaction ID in CNF structure */
167 CMCHKUNPK(oduPackUInt8, &(macCellCfgCfm.rsp), mBuf);
168 CMCHKUNPK(oduPackUInt16, &(macCellCfgCfm.cellId), mBuf);
169 return (*func)(pst, &macCellCfgCfm);
173 /* only loose coupling is suported */
178 /*******************************************************************
180 * @brief Packs and Send Cell Start Request to MAC
184 * Function : packMacCellStart
187 * Packs and Sends Cell Start Request to MAC
189 * @params[in] Post structure pointer
191 * @return ROK - success
194 * ****************************************************************/
195 uint8_t packMacCellStart(Pst *pst, OduCellId *cellId)
197 Buffer *mBuf = NULLP;
199 if(pst->selector == ODU_SELECTOR_LC)
201 /* Loose coupling not supported */
204 else if(pst->selector == ODU_SELECTOR_LWLC)
207 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
209 DU_LOG("\nERROR --> DU APP : Memory allocation failed for cell start req pack");
213 /* pack the address of the structure */
214 CMCHKPK(oduPackPointer,(PTR)cellId, mBuf);
217 return ODU_POST_TASK(pst,mBuf);
220 /*******************************************************************
222 * @brief Unpacks MAC Cell Start Request from DU APP
226 * Function : unpackMaCellStart
229 * Unpacks MAC Cell Start Request from DU APP
231 * @params[in] Function pointer of cell start request handler
232 * Post structure pointer
234 * @return ROK - success
237 * ****************************************************************/
238 uint8_t unpackMacCellStart(DuMacCellStart func, Pst *pst, Buffer *mBuf)
242 if(pst->selector == ODU_SELECTOR_LWLC)
244 /* unpack the address of the structure */
245 CMCHKUNPK(oduUnpackPointer, (PTR *)&cellId, mBuf);
246 ODU_PUT_MSG_BUF(mBuf);
247 return (*func)(pst, cellId);
251 /* Nothing to do for loose coupling */
252 ODU_PUT_MSG_BUF(mBuf);
257 /*******************************************************************
259 * @brief Packs and Send cell stop request to MAC
263 * Function : packMacCellStop
266 * Packs and Send cell stop request to MAC
268 * @params[in] Post structure pointer
270 * @return ROK - success
273 * ****************************************************************/
274 uint8_t packMacCellStop(Pst *pst, OduCellId *cellId)
276 if(pst->selector == ODU_SELECTOR_LC)
278 /* Loose coupling not supported */
281 else if(pst->selector == ODU_SELECTOR_LWLC)
283 Buffer *mBuf = NULLP;
285 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
287 DU_LOG("\nERROR --> DU APP : Memory allocation failed for cell stop req pack");
291 /* pack the address of the structure */
292 CMCHKPK(oduPackPointer,(PTR)cellId, mBuf);
294 return ODU_POST_TASK(pst,mBuf);
299 /*******************************************************************
301 * @brief Unpacks cell stop request from DU APP
305 * Function : unpackMaCellStop
308 * Unpacks cell stop request from DU APP
310 * @params[in] Handler function pointer
311 * Post structure pointer
313 * @return ROK - success
316 * ****************************************************************/
317 uint8_t unpackMacCellStop(DuMacCellStop func, Pst *pst, Buffer *mBuf)
321 if(pst->selector == ODU_SELECTOR_LWLC)
323 /* unpack the address of the structure */
324 CMCHKUNPK(oduUnpackPointer, (PTR *)&cellId, mBuf);
325 ODU_PUT_MSG_BUF(mBuf);
326 return (*func)(pst, cellId);
330 /* Nothing to do for loose coupling */
331 ODU_PUT_MSG_BUF(mBuf);
336 /*******************************************************************
338 * @brief Packs and Sends cell up ind from MAC to DUAPP
342 * Function : packMacCellUpInd
345 * Packs and Sends cell up ind from MAC to DUAPP
347 * @params[in] Post structure pointer
349 * @return ROK - success
352 * ****************************************************************/
353 uint8_t packMacCellUpInd(Pst *pst, OduCellId *cellId)
355 Buffer *mBuf = NULLP;
357 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
359 DU_LOG("\nERROR --> DU APP : Memory allocation failed for packMacCellUpInd");
363 if(pst->selector == ODU_SELECTOR_LC)
365 CMCHKPK(oduUnpackUInt16, cellId->cellId, mBuf);
366 CM_FREE_SHRABL_BUF(pst->region, pst->pool, cellId, sizeof(OduCellId));
369 else if(pst->selector == ODU_SELECTOR_LWLC)
371 /* pack the address of the structure */
372 CMCHKPK(oduPackPointer,(PTR)cellId, mBuf);
376 ODU_PUT_MSG_BUF(mBuf);
379 return ODU_POST_TASK(pst, mBuf);
382 /*******************************************************************
384 * @brief Unpacks cell up indication from MAC
388 * Function : unpackMacCellUpInd
391 * Unpacks cell up indication from MAC
393 * @params[in] Pointer to Handler
394 * Post structure pointer
396 * @return ROK - success
399 * ****************************************************************/
400 uint8_t unpackMacCellUpInd(DuMacCellUpInd func, Pst *pst, Buffer *mBuf)
402 if(pst->selector == ODU_SELECTOR_LWLC)
406 /* unpack the address of the structure */
407 CMCHKUNPK(oduUnpackPointer, (PTR *)&cellId, mBuf);
408 ODU_PUT_MSG_BUF(mBuf);
409 return (*func)(pst, cellId);
411 else if(pst->selector == ODU_SELECTOR_LC)
414 CMCHKUNPK(oduPackUInt16, &cellId.cellId, mBuf);
415 ODU_PUT_MSG_BUF(mBuf);
416 return (*func)(pst, &cellId);
420 /* Nothing to do for loose coupling */
421 ODU_PUT_MSG_BUF(mBuf);
427 /*******************************************************************
429 * @brief Packs and Sends stop ind from MAC to DUAPP
433 * Function : packMacStopInd
436 * Packs and Sends stop ind from MAC to DUAPP
438 * @params[in] Post structure pointer
439 * @return ROK - success
442 * ****************************************************************/
443 uint8_t packMacStopInd(Pst *pst, OduCellId *cellId)
445 Buffer *mBuf = NULLP;
447 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
449 DU_LOG("\nERROR --> DU APP : Memory allocation failed for stop Ind pack");
453 if(pst->selector == ODU_SELECTOR_LC)
455 /*pack the payload here*/
456 CMCHKPK(oduUnpackUInt16, cellId->cellId, mBuf);
457 CM_FREE_SHRABL_BUF(pst->region, pst->pool, cellId, sizeof(OduCellId));
460 else if(pst->selector == ODU_SELECTOR_LWLC)
462 /* pack the address of the structure */
463 CMCHKPK(oduPackPointer,(PTR)cellId, mBuf);
467 ODU_PUT_MSG_BUF(mBuf);
470 return ODU_POST_TASK(pst,mBuf);
473 /*******************************************************************
475 * @brief Unpacks stop indication from MAC
479 * Function : unpackMacStopInd
482 * Unpacks stop indication from MAC
484 * @params[in] Pointer to Handler
485 * Post structure pointer
487 * @return ROK - success
490 * ****************************************************************/
491 uint8_t unpackMacStopInd(DuMacStopInd func, Pst *pst, Buffer *mBuf)
493 if(pst->selector == ODU_SELECTOR_LWLC)
495 OduCellId *cellId=NULLP;
496 /* unpack the address of the structure */
497 CMCHKUNPK(oduUnpackPointer, (PTR *)&cellId, mBuf);
498 ODU_PUT_MSG_BUF(mBuf);
499 return (*func)(pst, cellId);
501 else if(pst->selector == ODU_SELECTOR_LC)
504 CMCHKUNPK(oduPackUInt16, &(cellId.cellId), mBuf);
506 ODU_PUT_MSG_BUF(mBuf);
507 return (*func)(pst, &cellId);
512 /* Nothing to do for loose coupling */
513 ODU_PUT_MSG_BUF(mBuf);
519 /*******************************************************************
521 * @brief Packs and Sends UL CCCH Ind from MAC to DUAPP
525 * Function : packMacUlCcchInd
528 * Packs and Sends UL CCCH Ind from MAC to DUAPP
530 * @params[in] Post structure pointer
531 * UL CCCH Ind pointer
532 * @return ROK - success
535 * ****************************************************************/
536 uint8_t packMacUlCcchInd(Pst *pst, UlCcchIndInfo *ulCcchIndInfo)
538 Buffer *mBuf = NULLP;
540 if(pst->selector == ODU_SELECTOR_LWLC)
542 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
544 DU_LOG("\nERROR --> MAC : Memory allocation failed at packMacUlCcchInd");
547 /* pack the address of the structure */
548 CMCHKPK(oduPackPointer,(PTR)ulCcchIndInfo, mBuf);
552 DU_LOG("\nERROR --> MAC: Only LWLC supported for UL CCCH Ind ");
556 return ODU_POST_TASK(pst,mBuf);
559 /*******************************************************************
561 * @brief Unpacks UL CCCH indication from MAC
565 * Function : unpackMacUlCcchInd
568 * Unpacks UL CCCH indication from MAC
570 * @params[in] Pointer to Handler
571 * Post structure pointer
573 * @return ROK - success
576 * ****************************************************************/
577 uint8_t unpackMacUlCcchInd(DuMacUlCcchInd func, Pst *pst, Buffer *mBuf)
579 if(pst->selector == ODU_SELECTOR_LWLC)
581 UlCcchIndInfo *ulCcchIndInfo;
583 /* unpack the address of the structure */
584 CMCHKUNPK(oduUnpackPointer, (PTR *)&ulCcchIndInfo, mBuf);
585 ODU_PUT_MSG_BUF(mBuf);
586 return (*func)(pst, ulCcchIndInfo);
590 /* Nothing to do for other selectors */
591 DU_LOG("\nERROR --> MAC : Only LWLC supported for UL CCCH Ind ");
592 ODU_PUT_MSG_BUF(mBuf);
597 /*******************************************************************
599 * @brief Packs and Sends DL CCCH Ind from DUAPP to MAC
603 * Function : packMacDlCcchInd
606 * Packs and Sends DL CCCH Ind from DUAPP to MAC
609 * @params[in] Post structure pointer
610 * DL CCCH Ind pointer
611 * @return ROK - success
614 * ****************************************************************/
615 uint8_t packMacDlCcchInd(Pst *pst, DlCcchIndInfo *dlCcchIndInfo)
617 Buffer *mBuf = NULLP;
619 if(pst->selector == ODU_SELECTOR_LWLC)
621 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
623 DU_LOG("\nERROR --> MAC : Memory allocation failed at packMacDlCcchInd");
626 /* pack the address of the structure */
627 CMCHKPK(oduPackPointer,(PTR)dlCcchIndInfo, mBuf);
631 DU_LOG("\nERROR --> DU APP : Only LWLC supported for DL CCCH Ind ");
635 return ODU_POST_TASK(pst,mBuf);
638 /*******************************************************************
640 * @brief Unpacks DL CCCH indication from DU APP
644 * Function : unpackMacDlCcchInd
647 * Unpacks DL CCCH indication from DU APP
649 * @params[in] Pointer to Handler
650 * Post structure pointer
652 * @return ROK - success
655 * ****************************************************************/
656 uint8_t unpackMacDlCcchInd(DuMacDlCcchInd func, Pst *pst, Buffer *mBuf)
658 if(pst->selector == ODU_SELECTOR_LWLC)
660 DlCcchIndInfo *dlCcchIndInfo;
662 /* unpack the address of the structure */
663 CMCHKUNPK(oduUnpackPointer, (PTR *)&dlCcchIndInfo, mBuf);
664 ODU_PUT_MSG_BUF(mBuf);
665 return (*func)(pst, dlCcchIndInfo);
669 /* Nothing to do for other selectors */
670 DU_LOG("\nERROR --> DU APP : Only LWLC supported for DL CCCH Ind ");
671 ODU_PUT_MSG_BUF(mBuf);
677 /*******************************************************************
679 * @brief Packs and Sends UE create Request from DUAPP to MAC
683 * Function : packDuMacUeCreateReq
686 * Packs and Sends UE Create Request from DUAPP to MAC
689 * @params[in] Post structure pointer
691 * @return ROK - success
694 * ****************************************************************/
695 uint8_t packDuMacUeCreateReq(Pst *pst, MacUeCfg *ueCfg)
697 Buffer *mBuf = NULLP;
699 if(pst->selector == ODU_SELECTOR_LWLC)
701 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
703 DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacUeCreateReq");
706 /* pack the address of the structure */
707 CMCHKPK(oduPackPointer,(PTR)ueCfg, mBuf);
711 DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacUeCreateReq");
715 return ODU_POST_TASK(pst,mBuf);
718 /*******************************************************************
720 * @brief Unpacks UE Create Request received from DU APP
724 * Function : unpackMacUeCreateReq
727 * Unpacks UE Create Request received from DU APP
729 * @params[in] Pointer to Handler
730 * Post structure pointer
732 * @return ROK - success
735 * ****************************************************************/
736 uint8_t unpackMacUeCreateReq(DuMacUeCreateReq func, Pst *pst, Buffer *mBuf)
738 if(pst->selector == ODU_SELECTOR_LWLC)
742 /* unpack the address of the structure */
743 CMCHKUNPK(oduUnpackPointer, (PTR *)&ueCfg, mBuf);
744 ODU_PUT_MSG_BUF(mBuf);
745 return (*func)(pst, ueCfg);
749 /* Nothing to do for other selectors */
750 DU_LOG("\nERROR --> DU APP : Only LWLC supported for UE Create Request ");
751 ODU_PUT_MSG_BUF(mBuf);
757 /*******************************************************************
759 * @brief Pack and send UE config response from MAC to DU APP
763 * Function : packDuMacUeCfgRsp
766 * Pack and send UE config response from MAC to DU APP
769 * @return ROK - success
772 * ****************************************************************/
773 uint8_t packDuMacUeCfgRsp(Pst *pst, MacUeCfgRsp *cfgRsp)
775 Buffer *mBuf = NULLP;
777 if(pst->selector == ODU_SELECTOR_LWLC)
779 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
781 DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacUeCfgRsp");
784 /* pack the address of the structure */
785 CMCHKPK(oduPackPointer,(PTR)cfgRsp, mBuf);
789 DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacUeCfgRsp");
793 return ODU_POST_TASK(pst,mBuf);
795 /*******************************************************************
797 * @brief Unpack UE Config Response from MAC to DU APP
801 * Function :unpackDuMacUeCfgRsp
803 * Functionality: Unpack UE Config Response from MAC to DU APP
806 * @return ROK - success
809 * ****************************************************************/
810 uint8_t unpackDuMacUeCfgRsp(MacDuUeCfgRspFunc func, Pst *pst, Buffer *mBuf)
812 if(pst->selector == ODU_SELECTOR_LWLC)
814 MacUeCfgRsp *cfgRsp = NULLP;
816 /* unpack the address of the structure */
817 CMCHKUNPK(oduUnpackPointer, (PTR *)&cfgRsp, mBuf);
818 ODU_PUT_MSG_BUF(mBuf);
819 return (*func)(pst, cfgRsp);
822 ODU_PUT_MSG_BUF(mBuf);
826 /*******************************************************************
828 * @brief Packs and Sends UE Reconig Request from DUAPP to MAC
832 * Function : packDuMacUeReconfigReq
835 * Packs and Sends UE Reconfig Request from DUAPP to MAC
838 * @params[in] Post structure pointer
840 * @return ROK - success
843 * ****************************************************************/
844 uint8_t packDuMacUeReconfigReq(Pst *pst, MacUeCfg *ueCfg)
846 Buffer *mBuf = NULLP;
848 if(pst->selector == ODU_SELECTOR_LWLC)
850 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
852 DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacUeReconfigReq");
855 /* pack the address of the structure */
856 CMCHKPK(oduPackPointer,(PTR)ueCfg, mBuf);
860 DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacUeReconfigReq");
864 return ODU_POST_TASK(pst,mBuf);
866 /*******************************************************************
868 * @brief Unpacks UE Reconfig Request received from DU APP
872 * Function : unpackMacUeReconfigReq
875 * Unpacks UE Reconfig Request received from DU APP
877 * @params[in] Pointer to Handler
878 * Post structure pointer
880 * @return ROK - success
883 * ****************************************************************/
884 uint8_t unpackMacUeReconfigReq(DuMacUeReconfigReq func, Pst *pst, Buffer *mBuf)
886 if(pst->selector == ODU_SELECTOR_LWLC)
890 /* unpack the address of the structure */
891 CMCHKUNPK(oduUnpackPointer, (PTR *)&ueCfg, mBuf);
892 ODU_PUT_MSG_BUF(mBuf);
893 return (*func)(pst, ueCfg);
897 /* Nothing to do for other selectors */
898 DU_LOG("\nERROR --> DU APP : Only LWLC supported for UE Create Request ");
899 ODU_PUT_MSG_BUF(mBuf);
904 /*******************************************************************
906 * @brief Packs and Sends UE Delete Request from DUAPP to MAC
910 * Function : packDuMacUeDeleteReq
913 * Packs and Sends UE Delete Request from DUAPP to MAC
916 * @params[in] Post structure pointer
917 * MacUeDelete pointer
918 * @return ROK - success
921 * ****************************************************************/
922 uint8_t packDuMacUeDeleteReq(Pst *pst, MacUeDelete *ueDel)
924 Buffer *mBuf = NULLP;
926 if(pst->selector == ODU_SELECTOR_LWLC)
928 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
930 DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacUeDeleteReq");
933 /* pack the address of the structure */
934 CMCHKPK(oduPackPointer,(PTR)ueDel, mBuf);
938 DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacUeDeleteReq");
942 return ODU_POST_TASK(pst,mBuf);
944 /*******************************************************************
946 * @brief Unpacks UE Delete Request received from DU APP
950 * Function : unpackMacUeDeleteReq
953 * Unpacks UE Delete Request received from DU APP
955 * @params[in] Pointer to Handler
956 * Post structure pointer
958 * @return ROK - success
961 * ****************************************************************/
962 uint8_t unpackMacUeDeleteReq(DuMacUeDeleteReq func, Pst *pst, Buffer *mBuf)
964 if(pst->selector == ODU_SELECTOR_LWLC)
966 MacUeDelete *ueDelete;
968 /* unpack the address of the structure */
969 CMCHKUNPK(oduUnpackPointer, (PTR *)&ueDelete, mBuf);
970 ODU_PUT_MSG_BUF(mBuf);
971 return (*func)(pst, ueDelete);
975 /* Nothing to do for other selectors */
976 DU_LOG("\nERROR --> DU APP : Only LWLC supported for UE Delete Request ");
977 ODU_PUT_MSG_BUF(mBuf);
982 /*******************************************************************
984 * @brief Pack and send UE delete response from MAC to DU APP
988 * Function : packDuMacUeDeleteRsp
991 * Pack and send UE delete response from MAC to DU APP
994 * @return ROK - success
997 * ****************************************************************/
998 uint8_t packDuMacUeDeleteRsp(Pst *pst, MacUeDeleteRsp *deleteRsp)
1000 Buffer *mBuf = NULLP;
1002 if(pst->selector == ODU_SELECTOR_LWLC)
1004 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
1006 DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacUeDeleteRsp");
1009 /* pack the address of the structure */
1010 CMCHKPK(oduPackPointer,(PTR)deleteRsp, mBuf);
1014 DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacUeDeleteRsp");
1018 return ODU_POST_TASK(pst,mBuf);
1022 /*******************************************************************
1024 * @brief Unpack UE Config Response from MAC to DU APP
1028 * Function :unpackDuMacUeDeleteRsp
1030 * Functionality: Unpack UE Config Response from MAC to DU APP
1033 * @return ROK - success
1036 * ****************************************************************/
1037 uint8_t unpackDuMacUeDeleteRsp(MacDuUeDeleteRspFunc func, Pst *pst, Buffer *mBuf)
1039 if(pst->selector == ODU_SELECTOR_LWLC)
1041 MacUeDeleteRsp *ueDeleteRsp = NULLP;
1043 /* unpack the address of the structure */
1044 CMCHKUNPK(oduUnpackPointer, (PTR *)&ueDeleteRsp, mBuf);
1045 ODU_PUT_MSG_BUF(mBuf);
1046 return (*func)(pst, ueDeleteRsp);
1049 ODU_PUT_MSG_BUF(mBuf);
1053 /*******************************************************************
1055 * @brief Unpacks Cell Delete Request received from DU APP
1059 * Function : unpackMacCellDeleteReq
1062 * Unpacks Cell Delete Request received from DU APP
1064 * @params[in] Pointer to Handler
1065 * Post structure pointer
1067 * @return ROK - success
1070 * ****************************************************************/
1072 uint8_t unpackMacCellDeleteReq(DuMacCellDeleteReq func, Pst *pst, Buffer *mBuf)
1074 if(pst->selector == ODU_SELECTOR_LWLC)
1076 MacCellDelete *cellDelete=NULLP;
1078 /* unpack the address of the structure */
1079 CMCHKUNPK(oduUnpackPointer, (PTR *)&cellDelete, mBuf);
1080 ODU_PUT_MSG_BUF(mBuf);
1081 return (*func)(pst, cellDelete);
1085 /* Nothing to do for other
1087 DU_LOG("\nERROR --> DU APP : unpackMacCellDeleteReq(): Only LWLC supported for CELL Delete Request ");
1088 ODU_PUT_MSG_BUF(mBuf);
1094 /*******************************************************************
1096 * @brief Pack and send Cell delete request to MAC
1100 * Function : packDuMacCellDeleteReq
1103 * Pack and send Cell delete request to MAC
1105 * @params[in] Post structure
1106 * MacCellDelete *cellDelete;
1107 * @return ROK - success
1110 * ****************************************************************/
1112 uint8_t packDuMacCellDeleteReq(Pst *pst, MacCellDelete *cellDelete)
1114 Buffer *mBuf = NULLP;
1116 if(pst->selector == ODU_SELECTOR_LWLC)
1118 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
1120 DU_LOG("\nERROR --> MAC : packDuMacCellDeleteReq(): Memory allocation failed ");
1123 CMCHKPK(oduPackPointer,(PTR)cellDelete, mBuf);
1124 return ODU_POST_TASK(pst,mBuf);
1128 DU_LOG("\nERROR --> MAC: packDuMacCellDeleteReq(): Only LWLC supported ");
1133 /*******************************************************************
1135 * @brief Pack and send CELL delete response from MAC to DU APP
1139 * Function : packDuMacCellDeleteRsp
1142 * Pack and send CELL delete response from MAC to DU APP
1144 * @params[in] Pst *pst, MacCellDeleteRsp *deleteRsp
1145 * @return ROK - success
1148 * ****************************************************************/
1150 uint8_t packDuMacCellDeleteRsp(Pst *pst, MacCellDeleteRsp *cellDeleteRsp)
1152 Buffer *mBuf = NULLP;
1154 if(pst->selector == ODU_SELECTOR_LWLC)
1156 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
1158 DU_LOG("\nERROR --> MAC : packDuMacCellDeleteRsp(): Memory allocation failed ");
1161 CMCHKPK(oduPackPointer,(PTR)cellDeleteRsp, mBuf);
1165 DU_LOG("\nERROR --> MAC: packDuMacCellDeleteRsp(): Only LWLC supported ");
1169 return ODU_POST_TASK(pst,mBuf);
1173 /*******************************************************************
1175 * @brief Unpack cell delete response from MAC to DU APP
1179 * Function : unpackDuMacCellDeleteRsp
1181 * Functionality: Unpack cell delete response from MAC to DU APP
1183 * @params[in] MacDuCellDeleteRspFunc func, Pst *pst, Buffer *mBuf
1184 * @return ROK - success
1187 * ****************************************************************/
1189 uint8_t unpackDuMacCellDeleteRsp(MacDuCellDeleteRspFunc func, Pst *pst, Buffer *mBuf)
1191 if(pst->selector == ODU_SELECTOR_LWLC)
1193 MacCellDeleteRsp *cellDeleteRsp = NULLP;
1195 CMCHKUNPK(oduUnpackPointer, (PTR *)&cellDeleteRsp, mBuf);
1196 ODU_PUT_MSG_BUF(mBuf);
1197 return (*func)(pst, cellDeleteRsp);
1201 DU_LOG("\nERROR --> DU APP : unpackDuMacCellDeleteRsp(): Only LWLC supported ");
1202 ODU_PUT_MSG_BUF(mBuf);
1207 /*******************************************************************
1209 * @brief Pack and send Slice Cfg request from MAC to DU APP
1213 * Function : packDuMacSliceCfgReq
1216 * Pack and send Slice Cfg request from MAC to DU APP
1218 * @params[in] Pst *pst, MacSliceCfgReq *sliceCfgReq
1219 * @return ROK - success
1222 * ****************************************************************/
1224 uint8_t packDuMacSliceCfgReq(Pst *pst, MacSliceCfgReq *sliceCfgReq)
1226 Buffer *mBuf = NULLP;
1228 if(pst->selector == ODU_SELECTOR_LWLC)
1230 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
1232 DU_LOG("\nERROR --> MAC : Memory allocation failed in packDuMacSliceCfgReq");
1235 CMCHKPK(oduPackPointer,(PTR)sliceCfgReq, mBuf);
1239 DU_LOG("\nERROR --> MAC: Only LWLC supported in packDuMacSliceCfgReq");
1243 return ODU_POST_TASK(pst,mBuf);
1246 /*******************************************************************
1248 * @brief Unpacks Slice Cfg request received from DU APP
1252 * Function : unpackMacSliceCfgReq
1255 * Unpacks Slice Cfg Request received from DU APP
1257 * @params[in] Pointer to Handler
1258 * Post structure pointer
1260 * @return ROK - success
1263 * ****************************************************************/
1264 uint8_t unpackMacSliceCfgReq(DuMacSliceCfgReq func, Pst *pst, Buffer *mBuf)
1266 if(pst->selector == ODU_SELECTOR_LWLC)
1268 MacSliceCfgReq *sliceCfgReq;
1269 /* unpack the address of the structure */
1270 CMCHKUNPK(oduUnpackPointer, (PTR *)&sliceCfgReq, mBuf);
1271 ODU_PUT_MSG_BUF(mBuf);
1272 return (*func)(pst, sliceCfgReq);
1276 /* Nothing to do for other selectors */
1277 DU_LOG("\nERROR --> DU APP : Only LWLC supported for Slice Cfg Request ");
1278 ODU_PUT_MSG_BUF(mBuf);
1284 /*******************************************************************
1286 * @brief Pack and send Slice config response from MAC to DU APP
1290 * Function : packDuMacSliceCfgRsp
1293 * Pack and send Slice config response from MAC to DU APP
1296 * @return ROK - success
1299 * ****************************************************************/
1300 uint8_t packDuMacSliceCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp)
1302 Buffer *mBuf = NULLP;
1304 if(pst->selector == ODU_SELECTOR_LWLC)
1306 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
1308 DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacSliceCfgRsp");
1311 /* pack the address of the structure */
1312 CMCHKPK(oduPackPointer,(PTR)cfgRsp, mBuf);
1316 DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacSliceCfgRsp");
1320 return ODU_POST_TASK(pst,mBuf);
1323 /*******************************************************************
1325 * @brief Unpack Slice Config Response from MAC to DU APP
1329 * Function :unpackDuMacSliceCfgRsp
1331 * Functionality: Unpack Slice Config Response from MAC to DU APP
1334 * @return ROK - success
1337 * ****************************************************************/
1338 uint8_t unpackDuMacSliceCfgRsp(MacDuSliceCfgRspFunc func, Pst *pst, Buffer *mBuf)
1340 if(pst->selector == ODU_SELECTOR_LWLC)
1342 MacSliceCfgRsp *cfgRsp = NULLP;
1344 /* unpack the address of the structure */
1345 CMCHKUNPK(oduUnpackPointer, (PTR *)&cfgRsp, mBuf);
1346 ODU_PUT_MSG_BUF(mBuf);
1347 return (*func)(pst, cfgRsp);
1350 ODU_PUT_MSG_BUF(mBuf);
1355 /*******************************************************************
1357 * @brief Pack and send Slice ReCfg request from MAC to DU APP
1361 * Function : packDuMacSliceRecfgReq
1364 * Pack and send Slice ReCfg request from MAC to DU APP
1366 * @params[in] Pst *pst, MacSliceCfgReq *sliceReCfgReq
1367 * @return ROK - success
1370 * ****************************************************************/
1372 uint8_t packDuMacSliceRecfgReq(Pst *pst, MacSliceCfgReq *sliceReCfgReq)
1374 Buffer *mBuf = NULLP;
1376 if(pst->selector == ODU_SELECTOR_LWLC)
1378 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
1380 DU_LOG("\nERROR --> MAC : Memory allocation failed in packDuMacSliceRecfgReq");
1383 CMCHKPK(oduPackPointer,(PTR)sliceReCfgReq, mBuf);
1387 DU_LOG("\nERROR --> MAC: Only LWLC supported in packDuMacSliceRecfgReq");
1391 return ODU_POST_TASK(pst,mBuf);
1394 /*******************************************************************
1396 * @brief Unpacks Slice ReCfg request received from DU APP
1400 * Function : unpackMacSliceCfgReq
1403 * Unpacks Slice ReCfg Request received from DU APP
1405 * @params[in] Pointer to Handler
1406 * Post structure pointer
1408 * @return ROK - success
1411 * ****************************************************************/
1412 uint8_t unpackMacSliceReCfgReq(DuMacSliceRecfgReq func, Pst *pst, Buffer *mBuf)
1414 if(pst->selector == ODU_SELECTOR_LWLC)
1416 MacSliceCfgReq *sliceReCfgReq;
1417 /* unpack the address of the structure */
1418 CMCHKUNPK(oduUnpackPointer, (PTR *)&sliceReCfgReq, mBuf);
1419 ODU_PUT_MSG_BUF(mBuf);
1420 return (*func)(pst, sliceReCfgReq);
1424 /* Nothing to do for other selectors */
1425 DU_LOG("\nERROR --> DU APP : Only LWLC supported for Slice ReCfg Request ");
1426 ODU_PUT_MSG_BUF(mBuf);
1432 /*******************************************************************
1434 * @brief Pack and send Slice config response from MAC to DU APP
1438 * Function : packDuMacSliceReCfgRsp
1441 * Pack and send Slice config response from MAC to DU APP
1444 * @return ROK - success
1447 * ****************************************************************/
1448 uint8_t packDuMacSliceReCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp)
1450 Buffer *mBuf = NULLP;
1452 if(pst->selector == ODU_SELECTOR_LWLC)
1454 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
1456 DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacSliceReCfgRsp");
1459 /* pack the address of the structure */
1460 CMCHKPK(oduPackPointer,(PTR)cfgRsp, mBuf);
1464 DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacSliceReCfgRsp");
1468 return ODU_POST_TASK(pst,mBuf);
1471 /*******************************************************************
1473 * @brief Unpack Slice ReConfig Response from MAC to DU APP
1477 * Function :unpackDuMacSliceReCfgRsp
1479 * Functionality: Unpack Slice ReConfig Response from MAC to DU APP
1482 * @return ROK - success
1485 * ****************************************************************/
1486 uint8_t unpackDuMacSliceReCfgRsp(MacDuSliceReCfgRspFunc func, Pst *pst, Buffer *mBuf)
1488 if(pst->selector == ODU_SELECTOR_LWLC)
1490 MacSliceCfgRsp *cfgRsp = NULLP;
1492 /* unpack the address of the structure */
1493 CMCHKUNPK(oduUnpackPointer, (PTR *)&cfgRsp, mBuf);
1494 ODU_PUT_MSG_BUF(mBuf);
1495 return (*func)(pst, cfgRsp);
1498 ODU_PUT_MSG_BUF(mBuf);
1502 /*******************************************************************
1504 * @brief Pack and send Slot ind from MAC to DU APP
1508 * Function : packMacSlotInd
1511 * Pack and send Slot ind from MAC to DU APP
1513 * @params[in] Pst *pst, SlotTimingInfo *slotIndInfo
1514 * @return ROK - success
1517 * ****************************************************************/
1518 uint8_t packMacSlotInd(Pst *pst, SlotTimingInfo *slotIndInfo)
1520 Buffer *mBuf = NULLP;
1522 if(pst->selector == ODU_SELECTOR_LWLC)
1524 if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
1526 DU_LOG("\nERROR --> MAC : Memory allocation failed at packMacSlotInd");
1529 /* pack the address of the structure */
1530 CMCHKPK(oduPackPointer,(PTR)slotIndInfo, mBuf);
1534 DU_LOG("\nERROR --> MAC: Only LWLC supported for packMacSlotInd");
1538 return ODU_POST_TASK(pst,mBuf);
1541 /*******************************************************************
1543 * @brief Unpack Slot indication from MAC to DU APP
1547 * Function :unpackDuMacSlotInd
1549 * Functionality: Unpack Slot Indication from MAC to DU APP
1551 * @params[in] DuMacSlotInd func, Pst *pst, Buffer *mBuf
1552 * @return ROK - success
1555 * ****************************************************************/
1556 uint8_t unpackDuMacSlotInd(DuMacSlotInd func, Pst *pst, Buffer *mBuf)
1558 if(pst->selector == ODU_SELECTOR_LWLC)
1560 SlotTimingInfo *slotIndInfo;
1562 /* unpack the address of the structure */
1563 CMCHKUNPK(oduUnpackPointer, (PTR *)&slotIndInfo, mBuf);
1564 ODU_PUT_MSG_BUF(mBuf);
1565 return (*func)(pst, slotIndInfo);
1568 ODU_PUT_MSG_BUF(mBuf);
1572 /*******************************************************************
1574 * @brief Searches for first unset bit in ueBitMap
1578 * Function : getFreeBitFromUeBitMap
1580 * Functionality: Searches for first unset bit in ueBitMap of
1581 * a cell. Search starts from LSB to MSB. Returns index of the
1582 * free bit, considering LSB at index 0 and increasing index
1585 * @params[in] Cell Id
1586 * @return Index of free bit - success
1589 * ****************************************************************/
1590 int8_t getFreeBitFromUeBitMap(uint16_t cellId)
1592 uint8_t bitIdx = 0; /* bit position */
1593 uint16_t cellIdx = 0; /* Index to acces ueBitMapPerCell[] */
1594 uint64_t mask = 1; /* bit mask */
1596 GET_CELL_IDX(cellId, cellIdx);
1599 /* Find the first unset bit in Bit Map */
1600 if((ueBitMapPerCell[cellIdx] & (mask << bitIdx)) == 0)
1602 SET_ONE_BIT(bitIdx, ueBitMapPerCell[cellIdx]);
1611 /*******************************************************************
1613 * @brief Unset a previously set bit in UeBitMap
1617 * Function : unsetBitInUeBitMap
1619 * Functionality: Searches for bit at given index and unset it.
1621 * @params[in] Cell Id
1625 * ****************************************************************/
1626 void unsetBitInUeBitMap(uint16_t cellId, uint8_t bitPos)
1630 GET_CELL_IDX(cellId, cellIdx);
1631 UNSET_ONE_BIT(bitPos, ueBitMapPerCell[cellIdx]);
1634 /**********************************************************************
1636 **********************************************************************/