#include "SRS-Resource.h"
#include "SRS-ResourceSet.h"
#include "SRS-Config.h"
+#include "PUCCH-Config.h"
#include "BWP-UplinkDedicated.h"
#include "PUSCH-ServingCellConfig.h"
#include "UplinkConfig.h"
#define PDSCH_MAPPING_TYPE_B 1
/* MACRO Define for PUSCH Configuration */
-#define PUSCH_K2 3
+#define PUSCH_K2_CFG1 3
+#define PUSCH_K2_CFG2 4
#define PUSCH_MSG3_DELTA_PREAMBLE 0
#define PUSCH_P0_NOMINAL_WITH_GRANT -70
#define RES_ALLOC_TYPE 1 /* Resource allocation type */
#define FIVE_QI_VALUE 9 /*spec 23.501, Table 5.7.4-1*/
/*******************************************************************
-*
-* @brief Sends F1 msg over SCTP
-*
-* @details
-*
-* Function : SendF1APMsg
-*
-* Functionality: Sends F1 msg over SCTP
-*
-* @params[in] Region region
-* Pool pool
-* @return ROK - success
-* RFAILED - failure
-*
-* ****************************************************************/
+ *
+ * @brief Sends F1 msg over SCTP
+ *
+ * @details
+ *
+ * Function : SendF1APMsg
+ *
+ * Functionality: Sends F1 msg over SCTP
+ *
+ * @params[in] Region region
+ * Pool pool
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
S16 SendF1APMsg(Region region, Pool pool)
{
Buffer *mBuf = NULLP;
{
if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
{
- ODU_PRINT_MSG(mBuf, 0,0);
+ ODU_PRINT_MSG(mBuf, 0,0);
- if(sctpSend(mBuf) != ROK)
- {
- DU_LOG("\nERROR --> F1AP : SCTP Send failed");
- ODU_PUT_MSG_BUF(mBuf);
- return RFAILED;
- }
+ if(sctpSend(mBuf) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : SCTP Send failed");
+ ODU_PUT_MSG_BUF(mBuf);
+ return RFAILED;
+ }
}
else
{
- DU_LOG("\nERROR --> F1AP : ODU_ADD_POST_MSG_MULT failed");
- ODU_PUT_MSG_BUF(mBuf);
- return RFAILED;
+ DU_LOG("\nERROR --> F1AP : ODU_ADD_POST_MSG_MULT failed");
+ ODU_PUT_MSG_BUF(mBuf);
+ return RFAILED;
}
ODU_PUT_MSG_BUF(mBuf);
}
f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
f1apMsg->choice.successfulOutcome->value.present = \
- SuccessfulOutcome__value_PR_F1SetupResponse;
+ SuccessfulOutcome__value_PR_F1SetupResponse;
f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
elementCnt = 4;
f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
- elementCnt * sizeof(F1SetupResponseIEs_t *));
+ elementCnt * sizeof(F1SetupResponseIEs_t *));
if(f1SetupRsp->protocolIEs.list.array == NULLP)
{
DU_LOG("\nERROR --> F1AP : Memory allocation for F1ResponseIEs failed");
for(idx=0; idx<elementCnt; idx++)
{
CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
- sizeof(F1SetupResponseIEs_t));
+ sizeof(F1SetupResponseIEs_t));
if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
{
- CU_FREE(f1SetupRsp->protocolIEs.list.array,\
- elementCnt * sizeof(F1SetupResponseIEs_t *));
- CU_FREE(f1apMsg->choice.successfulOutcome, \
- sizeof(SuccessfulOutcome_t));
- CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- return RFAILED;
+ CU_FREE(f1SetupRsp->protocolIEs.list.array,\
+ elementCnt * sizeof(F1SetupResponseIEs_t *));
+ CU_FREE(f1apMsg->choice.successfulOutcome, \
+ sizeof(SuccessfulOutcome_t));
+ CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
+ return RFAILED;
}
}
f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
- F1SetupResponseIEs__value_PR_TransactionID;
+ F1SetupResponseIEs__value_PR_TransactionID;
f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
- TRANS_ID;
+ TRANS_ID;
/*CU Name*/
idx++;
f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
- F1SetupResponseIEs__value_PR_GNB_CU_Name;
+ F1SetupResponseIEs__value_PR_GNB_CU_Name;
cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
cuName->size = sizeof(cuCfgParams.cuName);
{
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
- CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
- sizeof(F1SetupResponseIEs_t));
+ CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
+ sizeof(F1SetupResponseIEs_t));
}
CU_FREE(f1SetupRsp->protocolIEs.list.array,\
- elementCnt * sizeof(F1SetupResponseIEs_t *));
+ elementCnt * sizeof(F1SetupResponseIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome,\
- sizeof(SuccessfulOutcome_t));
+ sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
}
/*Cells to be activated list*/
idx++;
f1SetupRsp->protocolIEs.list.array[idx]->id = \
- ProtocolIE_ID_id_Cells_to_be_Activated_List ;
+ ProtocolIE_ID_id_Cells_to_be_Activated_List ;
f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
- F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
+ F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.\
- Cells_to_be_Activated_List;
+ Cells_to_be_Activated_List;
cellCnt=1;
cellToActivate->list.count = cellCnt;
cellToActivate->list.size = \
- cellCnt*sizeof(struct Cells_to_be_Activated_List_ItemIEs *);
+ cellCnt*sizeof(struct Cells_to_be_Activated_List_ItemIEs *);
CU_ALLOC(cellToActivate->list.array,\
- sizeof(struct Cells_to_be_Activated_List_ItemIEs *));
+ sizeof(struct Cells_to_be_Activated_List_ItemIEs *));
if(cellToActivate->list.array == NULLP)
{
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
- CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
- sizeof(F1SetupResponseIEs_t));
+ CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
+ sizeof(F1SetupResponseIEs_t));
}
CU_FREE(f1SetupRsp->protocolIEs.list.array,\
- elementCnt * sizeof(F1SetupResponseIEs_t *));
+ elementCnt * sizeof(F1SetupResponseIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
CU_ALLOC(cellToActivate->list.array[ieIdx],sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
if(cellToActivate->list.array[ieIdx] == NULLP)
{
- CU_FREE(cellToActivate->list.array,\
- sizeof(struct Cells_to_be_Activated_List_ItemIEs *));
- CU_FREE(cuName->buf, sizeof(cuName->size));
- for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
- {
- CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
- sizeof(F1SetupResponseIEs_t));
- }
- CU_FREE(f1SetupRsp->protocolIEs.list.array, \
- elementCnt * sizeof(F1SetupResponseIEs_t *));
- CU_FREE(f1apMsg->choice.successfulOutcome, \
- sizeof(SuccessfulOutcome_t));
- CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- return RFAILED;
+ CU_FREE(cellToActivate->list.array,\
+ sizeof(struct Cells_to_be_Activated_List_ItemIEs *));
+ CU_FREE(cuName->buf, sizeof(cuName->size));
+ for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
+ {
+ CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
+ sizeof(F1SetupResponseIEs_t));
+ }
+ CU_FREE(f1SetupRsp->protocolIEs.list.array, \
+ elementCnt * sizeof(F1SetupResponseIEs_t *));
+ CU_FREE(f1apMsg->choice.successfulOutcome, \
+ sizeof(SuccessfulOutcome_t));
+ CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
+ return RFAILED;
}
}
cellToActivate->list.array[0]->id = \
- ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
+ ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
cellToActivate->list.array[0]->criticality = Criticality_ignore;
cellToActivate->list.array[0]->value.present = \
- Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
+ Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
CU_ALLOC(cellToActivate->list.array[0]->\
- value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
- 3*sizeof(uint8_t));
+ value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
+ 3*sizeof(uint8_t));
if(cellToActivate->list.array[0]->value.choice.\
- Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
+ Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
{
for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
{
- CU_FREE(cellToActivate->list.array[ieIdx],\
- sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
+ CU_FREE(cellToActivate->list.array[ieIdx],\
+ sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
}
CU_FREE(cellToActivate->list.array,\
- sizeof(struct Cells_to_be_Activated_List_ItemIEs *));
+ sizeof(struct Cells_to_be_Activated_List_ItemIEs *));
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
- CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
- sizeof(F1SetupResponseIEs_t));
+ CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
+ sizeof(F1SetupResponseIEs_t));
}
CU_FREE(f1SetupRsp->protocolIEs.list.array, \
- elementCnt * sizeof(F1SetupResponseIEs_t *));
+ elementCnt * sizeof(F1SetupResponseIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome, \
- sizeof(SuccessfulOutcome_t));
+ sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
}
buildPlmnId(cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
- Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
+ Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
nRCGI.nRCellIdentity.size = 5;
CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
- Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
- 5*sizeof(uint8_t));
+ Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
+ 5*sizeof(uint8_t));
if(cellToActivate->list.array[0]->value.choice.\
- Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
+ Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
{
CU_FREE(cellToActivate->list.array[0]->\
- value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
- 3*sizeof(uint8_t));
+ value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
+ 3*sizeof(uint8_t));
for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
{
- CU_FREE(cellToActivate->list.array[ieIdx],\
- sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
+ CU_FREE(cellToActivate->list.array[ieIdx],\
+ sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
}
CU_FREE(cellToActivate->list.array,\
- sizeof(struct Cells_to_be_Activated_List_ItemIEs *));
+ sizeof(struct Cells_to_be_Activated_List_ItemIEs *));
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
- CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
- sizeof(F1SetupResponseIEs_t));
+ CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
+ sizeof(F1SetupResponseIEs_t));
}
CU_FREE(f1SetupRsp->protocolIEs.list.array, \
- elementCnt * sizeof(F1SetupResponseIEs_t *));
+ elementCnt * sizeof(F1SetupResponseIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome, \
- sizeof(SuccessfulOutcome_t));
+ sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
}
/* RRC Version */
idx++;
f1SetupRsp->protocolIEs.list.array[idx]->id = \
- ProtocolIE_ID_id_GNB_CU_RRC_Version;
+ ProtocolIE_ID_id_GNB_CU_RRC_Version;
f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
- F1SetupResponseIEs__value_PR_RRC_Version;
+ F1SetupResponseIEs__value_PR_RRC_Version;
rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
rrcVer->latest_RRC_Version.size = RRC_SIZE;
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; idx++)
{
- CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
- sizeof(F1SetupResponseIEs_t));
+ CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
+ sizeof(F1SetupResponseIEs_t));
}
CU_FREE(f1SetupRsp->protocolIEs.list.array,\
- elementCnt * sizeof(F1SetupResponseIEs_t *));
+ elementCnt * sizeof(F1SetupResponseIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
- CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
- sizeof(F1SetupResponseIEs_t));
+ CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
+ sizeof(F1SetupResponseIEs_t));
}
CU_FREE(f1SetupRsp->protocolIEs.list.array,\
- elementCnt * sizeof(F1SetupResponseIEs_t *));
+ elementCnt * sizeof(F1SetupResponseIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
rrcVer->iE_Extensions->list.count = 1;
rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
CU_ALLOC(rrcVer->iE_Extensions->list.array,\
- sizeof(struct RRC_Version_ExtIEs *));
+ sizeof(struct RRC_Version_ExtIEs *));
if(rrcVer->iE_Extensions->list.array == NULLP)
{
CU_FREE(rrcVer->iE_Extensions,\
- sizeof(ProtocolExtensionContainer_4624P81_t));
+ sizeof(ProtocolExtensionContainer_4624P81_t));
CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
- CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
- sizeof(F1SetupResponseIEs_t));
+ CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
+ sizeof(F1SetupResponseIEs_t));
}
CU_FREE(f1SetupRsp->protocolIEs.list.array,\
- elementCnt * sizeof(F1SetupResponseIEs_t *));
+ elementCnt * sizeof(F1SetupResponseIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
}
CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
- sizeof(struct RRC_Version_ExtIEs));
+ sizeof(struct RRC_Version_ExtIEs));
if(rrcVer->iE_Extensions->list.array[0] == NULLP)
{
CU_FREE(rrcVer->iE_Extensions->list.array,\
- sizeof(struct RRC_Version_ExtIEs *));
+ sizeof(struct RRC_Version_ExtIEs *));
CU_FREE(rrcVer->iE_Extensions,\
- sizeof(ProtocolExtensionContainer_4624P81_t));
+ sizeof(ProtocolExtensionContainer_4624P81_t));
CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
- CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
- sizeof(F1SetupResponseIEs_t));
+ CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
+ sizeof(F1SetupResponseIEs_t));
}
CU_FREE(f1SetupRsp->protocolIEs.list.array,\
- elementCnt * sizeof(F1SetupResponseIEs_t *));
+ elementCnt * sizeof(F1SetupResponseIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
}
rrcVer->iE_Extensions->list.array[0]->id = \
- ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
+ ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
- RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
+ RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
CU_ALLOC(rrcVer->iE_Extensions->list.\
- array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
- 3*sizeof(uint8_t));
+ array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
+ 3*sizeof(uint8_t));
if(rrcVer->iE_Extensions->list.\
- array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
+ array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
{
CU_FREE(rrcVer->iE_Extensions->list.array[0],\
- sizeof(struct RRC_Version_ExtIEs));
+ sizeof(struct RRC_Version_ExtIEs));
CU_FREE(rrcVer->iE_Extensions->list.array,\
- sizeof(struct RRC_Version_ExtIEs *));
+ sizeof(struct RRC_Version_ExtIEs *));
CU_FREE(rrcVer->iE_Extensions,\
- sizeof(ProtocolExtensionContainer_4624P81_t));
+ sizeof(ProtocolExtensionContainer_4624P81_t));
CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
- CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
- sizeof(F1SetupResponseIEs_t));
+ CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
+ sizeof(F1SetupResponseIEs_t));
}
CU_FREE(f1SetupRsp->protocolIEs.list.array,\
- elementCnt * sizeof(F1SetupResponseIEs_t *));
+ elementCnt * sizeof(F1SetupResponseIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
return RFAILED;
if(encRetVal.encoded == ENCODE_FAIL)
{
DU_LOG("\nERROR --> F1AP : Could not encode F1SetupResponse structure (at %s)\n",\
- encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
return RFAILED;
}
else
DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for F1SetupResponse\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ DU_LOG("%x",encBuf[i]);
}
}
* Functionality: Constructs the DU Update Acknowledge message and sends
* it to the DU through SCTP.
*
- * @params[in] void **buf,Buffer to which encoded pattern is written into
- * @params[in] int *size,size of buffer
+ * @params[in]
*
* @return ROK - success
* RFAILED - failure
CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
{
- CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
- CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
- CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- return RFAILED;
+ CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
+ CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
+ CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
+ return RFAILED;
}
}
idx = 0;
gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
- gNBDuCfgAck->protocolIEs.list.array[idx]->value.present = GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
+ gNBDuCfgAck->protocolIEs.list.array[idx]->value.present =\
+ GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Checking encode results */
if(enRetVal.encoded == ENCODE_FAIL)
{
- DU_LOG("\nERROR --> F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
+ DU_LOG("\nERROR --> F1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",\
+ enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
return RFAILED;
}
else
DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
for(int i=0; i< encBufSize; i++)
{
- DU_LOG("%x",encBuf[i]);
+ DU_LOG("%x",encBuf[i]);
}
}
*
* ****************************************************************/
-uint8_t fillMasterCellGroup(OCTET_STRING_t *masterCellGroup)
+uint8_t fillMasterCellGroup(uint8_t ueId, OCTET_STRING_t *masterCellGroup)
{
uint8_t ret = ROK;
masterCellGroup->buf = NULLP;
- if(f1apMsgDb.duToCuContainer.buf)
+ if(ueCb[ueId-1].f1apMsgDb.duToCuContainer.buf)
{
- masterCellGroup->size = f1apMsgDb.duToCuContainer.size;
+ masterCellGroup->size = ueCb[ueId-1].f1apMsgDb.duToCuContainer.size;
CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
if(masterCellGroup->buf != NULLP)
{
- memcpy(masterCellGroup->buf, f1apMsgDb.duToCuContainer.buf,\
- masterCellGroup->size);
+ memcpy(masterCellGroup->buf, ueCb[ueId-1].f1apMsgDb.duToCuContainer.buf,\
+ masterCellGroup->size);
}
else
{
*
* ****************************************************************/
-uint8_t fillRRCSetupIE(RRCSetup_IEs_t *rrcSetupIE)
+uint8_t fillRRCSetupIE(uint8_t ueId, RRCSetup_IEs_t *rrcSetupIE)
{
uint8_t ret = ROK;
if(rrcSetupIE)
}
if(ret == ROK)
{
- ret = fillMasterCellGroup(&rrcSetupIE->masterCellGroup);
+ ret = fillMasterCellGroup(ueId, &rrcSetupIE->masterCellGroup);
}
else
{
*
* ****************************************************************/
-uint8_t fillDlCcchRrcMsg(RRCContainer_t *rrcContainer)
+uint8_t fillDlCcchRrcMsg(uint8_t ueId, RRCContainer_t *rrcContainer)
{
uint8_t ret = ROK;
uint16_t idx2;
CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
if(dl_CCCH_Msg.message.choice.c1 != NULLP)
{
- dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
- CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
- if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
- {
- dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
- dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.\
- present = RRCSetup__criticalExtensions_PR_rrcSetup;
- /* Fill RRC Setup IE */
- CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
- criticalExtensions.choice.rrcSetup, sizeof(RRCSetup_IEs_t));
- if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
- criticalExtensions.choice.rrcSetup != NULLP)
- {
- ret = fillRRCSetupIE(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
- criticalExtensions.choice.rrcSetup);
+ dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
+ CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
+ if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
+ {
+ dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
+ dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.\
+ present = RRCSetup__criticalExtensions_PR_rrcSetup;
+ /* Fill RRC Setup IE */
+ CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
+ criticalExtensions.choice.rrcSetup, sizeof(RRCSetup_IEs_t));
+ if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
+ criticalExtensions.choice.rrcSetup != NULLP)
+ {
+ ret = fillRRCSetupIE(ueId, dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
+ criticalExtensions.choice.rrcSetup);
- if(ret == ROK)
- {
- /* encode DL-CCCH message into RRC Container */
- xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
- memset(encBuf, 0, ENC_BUF_MAX_LEN);
- encBufSize = 0;
- encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
- /* Encode results */
- if(encRetVal.encoded == ENCODE_FAIL)
- {
- DU_LOG( "\nERROR --> F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
- encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
- return RFAILED;
- }
- else
- {
- DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
- for(int i = 0; i< encBufSize; i++)
- {
- DU_LOG("%x",encBuf[i]);
- }
- rrcContainer->size = encBufSize;
- CU_ALLOC(rrcContainer->buf, rrcContainer->size);
- if(rrcContainer->buf != NULLP)
- {
- memset(rrcContainer->buf, 0, encBufSize);
- for(idx2 = 0; idx2 < encBufSize; idx2++)
- {
- rrcContainer->buf[idx2] = encBuf[idx2];
- }
- }
- }
- }
- else
- {
- ret = RFAILED;
- }
- }
- else
- {
- DU_LOG("\nERROR --> F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
- ret = RFAILED;
- }
- }
- else
- {
- DU_LOG("\nERROR --> F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
- ret = RFAILED;
- }
+ if(ret == ROK)
+ {
+ /* encode DL-CCCH message into RRC Container */
+ xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG( "\nERROR --> F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ return RFAILED;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
+ for(int i = 0; i< encBufSize; i++)
+ {
+ DU_LOG("%x",encBuf[i]);
+ }
+ rrcContainer->size = encBufSize;
+ CU_ALLOC(rrcContainer->buf, rrcContainer->size);
+ if(rrcContainer->buf != NULLP)
+ {
+ memset(rrcContainer->buf, 0, encBufSize);
+ for(idx2 = 0; idx2 < encBufSize; idx2++)
+ {
+ rrcContainer->buf[idx2] = encBuf[idx2];
+ }
+ }
+ }
+ }
+ else
+ {
+ ret = RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> F1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
+ ret = RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> F1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
+ ret = RFAILED;
+ }
}
else
{
*
* ****************************************************************/
-uint8_t BuildDLRRCContainer(uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
+uint8_t BuildDLRRCContainer(uint8_t ueId, uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
{
uint8_t ret, bufLen;
ret =ROK;
if(rrcMsgType == RRC_SETUP)
{
- ret = fillDlCcchRrcMsg(rrcContainer);
+ ret = fillDlCcchRrcMsg(ueId, rrcContainer);
if(ret == RFAILED)
DU_LOG("\nERROR --> F1AP: Failed to fill DL-CCCH Msg at RRC SETUP");
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildAndSendDLRRCMessageTransfer(uint8_t srbId, uint8_t rrcMsgType)
+uint8_t BuildAndSendDLRRCMessageTransfer(uint8_t ueId, uint8_t srbId, uint8_t rrcMsgType)
{
uint8_t elementCnt = 0;
uint8_t ieId;
dlRRCMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
- DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
- dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
+ DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
+ dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = ueId;
/* GNB DU UE F1AP ID */
idx++;
ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
- DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
- dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
+ DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
+ dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = ueId;
/* SRBID */
idx++;
dlRRCMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCContainer;
dlRRCMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
- DLRRCMessageTransferIEs__value_PR_RRCContainer;
- BuildDLRRCContainer(rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
+ DLRRCMessageTransferIEs__value_PR_RRCContainer;
+ BuildDLRRCContainer(ueId, rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
*
* ****************************************************************/
-uint8_t setDlRRCMsgType()
+uint8_t setDlRRCMsgType(uint8_t ueId)
{
uint8_t rrcMsgType = 0;
- switch(f1apMsgDb.dlRrcMsgCount)
+ switch(ueCb[ueId -1].f1apMsgDb.dlRrcMsgCount)
{
case RRC_SETUP:
rrcMsgType = RRC_SETUP;
uint8_t procInitULRRCMsg(F1AP_PDU_t *f1apMsg)
{
- uint8_t idx, rrcMsgType;
+ uint8_t idx, rrcMsgType, gnbDuUeF1apId;
uint8_t ret =ROK;
InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
DU_LOG("\nINFO --> F1AP : filling the required values in DB in procInitULRRCMsg");
{
switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
{
- case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
- break;
- case ProtocolIE_ID_id_NRCGI:
- break;
- case ProtocolIE_ID_id_C_RNTI:
- break;
- case ProtocolIE_ID_id_RRCContainer:
- break;
- case ProtocolIE_ID_id_DUtoCURRCContainer:
- {
- if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice\
- .DUtoCURRCContainer.size > 0) && (initULRRCMsg->protocolIEs\
- .list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
- {
- DU_LOG("\nINFO --> Received Du to Cu RRC Container ");
- f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs\
- .list.array[idx]->value.choice.DUtoCURRCContainer.size;
- CU_ALLOC(f1apMsgDb.duToCuContainer.buf, \
- f1apMsgDb.duToCuContainer.size);
- if(f1apMsgDb.duToCuContainer.buf != NULLP)
- {
- memcpy(f1apMsgDb.duToCuContainer.buf, initULRRCMsg->protocolIEs\
- .list.array[idx]->value.choice.DUtoCURRCContainer.buf, f1apMsgDb\
- .duToCuContainer.size);
- }
- }
- else
- {
- DU_LOG("\nERROR --> Failed to receive Du to Cu RRC Container ");
- ret = RFAILED;
- }
- break;
- }
- default:
- DU_LOG("\nERROR --> Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
- break;
+ case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
+ gnbDuUeF1apId = initULRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
+ break;
+ case ProtocolIE_ID_id_NRCGI:
+ break;
+ case ProtocolIE_ID_id_C_RNTI:
+ break;
+ case ProtocolIE_ID_id_RRCContainer:
+ break;
+ case ProtocolIE_ID_id_DUtoCURRCContainer:
+ {
+ if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice\
+ .DUtoCURRCContainer.size > 0) && (initULRRCMsg->protocolIEs\
+ .list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
+ {
+ DU_LOG("\nINFO --> Received Du to Cu RRC Container ");
+ ueCb[gnbDuUeF1apId-1].ueId = gnbDuUeF1apId;
+ ueCb[gnbDuUeF1apId-1].f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs\
+ .list.array[idx]->value.choice.DUtoCURRCContainer.size;
+ CU_ALLOC(ueCb[gnbDuUeF1apId-1].f1apMsgDb.duToCuContainer.buf, \
+ ueCb[gnbDuUeF1apId-1].f1apMsgDb.duToCuContainer.size);
+ if(ueCb[gnbDuUeF1apId-1].f1apMsgDb.duToCuContainer.buf != NULLP)
+ {
+ memcpy(ueCb[gnbDuUeF1apId-1].f1apMsgDb.duToCuContainer.buf, initULRRCMsg->protocolIEs\
+ .list.array[idx]->value.choice.DUtoCURRCContainer.buf, ueCb[gnbDuUeF1apId-1].f1apMsgDb\
+ .duToCuContainer.size);
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> Failed to receive Du to Cu RRC Container ");
+ ret = RFAILED;
+ }
+ break;
+ }
+ default:
+ DU_LOG("\nERROR --> Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
+ break;
}
}
if(ret == ROK)
{
- f1apMsgDb.dlRrcMsgCount++;
- rrcMsgType = setDlRRCMsgType();
- ret = BuildAndSendDLRRCMessageTransfer(SRB0, rrcMsgType);
+ ueCb[gnbDuUeF1apId-1].f1apMsgDb.dlRrcMsgCount++;
+ rrcMsgType = setDlRRCMsgType(gnbDuUeF1apId);
+ ret = BuildAndSendDLRRCMessageTransfer(gnbDuUeF1apId, SRB0, rrcMsgType);
}
return ret;
}
ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
gTP_TEID.buf[2] = 0;
ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
- gTP_TEID.buf[3] = 1;
+ gTP_TEID.buf[3] = cuCfgParams.egtpParams.currTunnelId++;
return ROK;
}/*End of BuildULTnlInfo*/
return RFAILED;
}
- elementCnt = 1;
+ elementCnt = 2;
timeDomAllocList->choice.setup->list.count = elementCnt;
timeDomAllocList->choice.setup->list.size = \
elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
idx = 0;
timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ CU_ALLOC(timeDomAlloc->k0, sizeof(long));
+ if(!timeDomAlloc->k0)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ return RFAILED;
+ }
+ *(timeDomAlloc->k0) = 0;
+ timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
+ timeDomAlloc->startSymbolAndLength = 66;
- timeDomAlloc->k0 = NULLP;
+ idx++;
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ CU_ALLOC(timeDomAlloc->k0, sizeof(long));
+ if(!timeDomAlloc->k0)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
+ return RFAILED;
+ }
+ *(timeDomAlloc->k0) = 1;
timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
timeDomAlloc->startSymbolAndLength = 66;
return RFAILED;
}
- elementCnt = 1;
+ elementCnt = 2;
timeDomAllocList->choice.setup->list.count = elementCnt;
timeDomAllocList->choice.setup->list.size = \
elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
return RFAILED;
}
- *(timeDomAlloc->k2) = PUSCH_K2;
+ *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
timeDomAlloc->startSymbolAndLength = 66;
+
+ idx++;
+ timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
+ CU_ALLOC(timeDomAlloc->k2, sizeof(long));
+ if(!timeDomAlloc->k2)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
+ return RFAILED;
+ }
+ *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
+ timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
+ timeDomAlloc->startSymbolAndLength = 66;
+
return ROK;
}
return ROK;
}
+/*******************************************************************
+ *
+ * @brief Builds BWP UL dedicated PUCCH Config
+ *
+ * @details
+ *
+ * Function : BuildBWPUlDedPucchCfg
+ *
+ * Functionality:
+ * Builds BWP UL dedicated PUCCH Config
+ *
+ * @params[in] : PUCCH_Config_t *pucchCfg
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
+{
+ uint8_t arrIdx, elementCnt;
+
+ CU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
+ if(pucchCfg->dl_DataToUL_ACK == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ elementCnt = 2;
+ pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
+ pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
+ CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
+ if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+
+ for(arrIdx = 0; arrIdx < pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
+ {
+ CU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
+ if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
+ return RFAILED;
+ }
+ }
+
+ arrIdx = 0;
+ *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
+ *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
+
+ return ROK;
+}
+
/*******************************************************************
*
* @brief Fills SRS resource to add/modify list
uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
{
ulBwp->pucch_Config = NULLP;
+ ulBwp->pucch_Config = NULLP;
+ CU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
+ if(!ulBwp->pucch_Config)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ return RFAILED;
+ }
+
+ ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
+ ulBwp->pucch_Config->choice.setup = NULLP;
+ CU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
+ if(!ulBwp->pucch_Config->choice.setup)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed in BuildInitialUlBWP");
+ return RFAILED;
+ }
+
+ if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
+ {
+ return RFAILED;
+ }
/* Fill BWP UL dedicated PUSCH config */
ulBwp->pusch_Config = NULLP;
return ret;
}/* End of BuildAndSendUeContextSetupReq*/
+
+uint8_t procUeContextSetupResponse(F1AP_PDU_t *f1apMsg)
+{
+ uint8_t idx, duUeF1apId;
+ UEContextSetupResponse_t *ueCtxtSetupRsp;
+ ueCtxtSetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
+
+ for(idx=0; idx < ueCtxtSetupRsp->protocolIEs.list.count; idx++)
+ {
+ switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
+ {
+ case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
+ {
+ duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
+ break;
+ }
+ }
+ }
+ ueCb[duUeF1apId-1].f1apMsgDb.dlRrcMsgCount++; /* keeping DL RRC Msg Count */
+}
+
/****************************************************************
* @brief Function to process Ul Rrc Msg received from DU
*
}
if(srbId == 1)
{
- f1apMsgDb.dlRrcMsgCount++;
- rrcMsgType = setDlRRCMsgType();
+ ueCb[duUeF1apId-1].f1apMsgDb.dlRrcMsgCount++;
+ rrcMsgType = setDlRRCMsgType(duUeF1apId);
if(rrcMsgType == REGISTRATION_ACCEPT)
{
- DU_LOG("\nINFO --> F1AP: Sending DL RRC MSG for RRC Registration Accept");
- ret = BuildAndSendDLRRCMessageTransfer(srbId, rrcMsgType);
+ DU_LOG("\nINFO --> F1AP: Sending DL RRC MSG for RRC Registration Accept");
+ ret = BuildAndSendDLRRCMessageTransfer(duUeF1apId, srbId, rrcMsgType);
}
if(rrcMsgType == UE_CONTEXT_SETUP_REQ)
{
}
if(rrcMsgType == SECURITY_MODE_COMPLETE)
{
- /* To trigger the DL RRC Msg for RRC Reconfig */
- f1apMsgDb.dlRrcMsgCount++;
- rrcMsgType = setDlRRCMsgType();
- if(rrcMsgType == RRC_RECONFIG)
- {
- DU_LOG("\nINFO --> F1AP: Sending DL RRC MSG for RRC Reconfig");
- BuildAndSendDLRRCMessageTransfer(srbId, rrcMsgType);
- }
+ /* To trigger the DL RRC Msg for RRC Reconfig */
+ ueCb[duUeF1apId-1].f1apMsgDb.dlRrcMsgCount++;
+ rrcMsgType = setDlRRCMsgType(duUeF1apId);
+ if(rrcMsgType == RRC_RECONFIG)
+ {
+ DU_LOG("\nINFO --> F1AP: Sending DL RRC MSG for RRC Reconfig");
+ BuildAndSendDLRRCMessageTransfer(duUeF1apId, srbId, rrcMsgType);
+ }
}
if(rrcMsgType == UE_CONTEXT_MOD_REQ)
{
DU_LOG("\nINFO --> F1AP: Sending UE Context Modification Request");
- BuildAndSendUeContextModificationReq();
+ BuildAndSendUeContextModificationReq(duUeF1apId);
}
}
return ret;
ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
gTP_TEID.buf[2] = 0;
ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
- gTP_TEID.buf[3] = 2;
+ gTP_TEID.buf[3] = cuCfgParams.egtpParams.currTunnelId++;
return ROK;
}/*End of BuildULTnlInfo*/
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildAndSendUeContextModificationReq()
+uint8_t BuildAndSendUeContextModificationReq(uint8_t ueId)
{
uint8_t ieIdx = 0;
uint8_t elementCnt = 0;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present = \
- UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
- ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =CU_ID;
+ UEContextModificationRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueId;
ieIdx++;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present=\
- UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
- ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =DU_ID;
-
+ UEContextModificationRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
+ ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueId;
+
ieIdx++;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_List;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
}
return ROK;
}
+/*******************************************************************
+*
+* @brief processing of Gnb-DU config update
+*
+* @details
+*
+* Function : procGnbDuUpdate
+*
+* Functionality:
+* - processing of Gnb-DU config update
+*
+* @params[in] F1AP_PDU_t *f1apMsg
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t procGnbDuUpdate(F1AP_PDU_t *f1apMsg)
+{
+ bool cellToBeDelete = false;
+ uint8_t ieIdx = 0, ueIdx = 0;
+ GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
+
+ duCfgUpdate = &f1apMsg->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
+
+ for(ieIdx=0; ieIdx < duCfgUpdate->protocolIEs.list.count; ieIdx++)
+ {
+ switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_ID_id_TransactionID:
+ break;
+ case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
+ break;
+ case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
+ {
+ cellToBeDelete = true;
+ break;
+ }
+ case ProtocolIE_ID_id_gNB_DU_ID:
+ break;
+ }
+ }
+ if(BuildAndSendDUUpdateAck() != ROK)
+ {
+ DU_LOG("ERROR --> F1AP : Failed to build and send DUUpdateAck");
+ return RFAILED;
+ }
+
+ if(cellToBeDelete == false)
+ {
+ DU_LOG("\nINFO --> F1AP : Sending F1 reset request");
+ if(BuildAndSendF1ResetReq() != ROK)
+ {
+ DU_LOG("ERROR --> F1AP : Failed to build and send F1 reset request");
+ return RFAILED;
+ }
+ }
+ else
+ {
+ for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
+ {
+ CU_FREE(ueCb[ueIdx].f1apMsgDb.duToCuContainer.buf, ueCb[ueIdx].f1apMsgDb.duToCuContainer.size);
+ memset(&ueCb[ueIdx], 0, sizeof(UeCb));
+ }
+ }
+
+ return ROK;
+}
/*******************************************************************
*
* @brief Handles received F1AP message and sends back response
case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
{
DU_LOG("\nINFO --> F1AP : GNB-DU config update received");
- BuildAndSendDUUpdateAck();
- DU_LOG("\nINFO --> F1AP : Sending F1 reset request");
- BuildAndSendF1ResetReq();
+ procGnbDuUpdate(f1apMsg);
break;
}
case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
case SuccessfulOutcome__value_PR_UEContextSetupResponse:
{
DU_LOG("\nINFO --> F1AP : UE ContextSetupResponse received");
- f1apMsgDb.dlRrcMsgCount++; /* keeping DL RRC Msg Count */
+ procUeContextSetupResponse(f1apMsg);
break;
}
case SuccessfulOutcome__value_PR_UEContextModificationResponse:
Code Review / o-du / l2.git / blobdiff