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 /*This file contains stub for PHY to handle messages to/from MAC CL */
21 #include "common_def.h"
24 #include "du_app_mac_inf.h"
25 #include "mac_sch_interface.h"
27 #include "lwr_mac_fsm.h"
28 #include "lwr_mac_phy.h"
30 #include "nr5g_fapi_internal.h"
31 #include "fapi_vendor_extension.h"
33 #include "lwr_mac_upr_inf.h"
34 #include "mac_utils.h"
36 #include "phy_stub_utils.h"
37 #include "lwr_mac_phy_stub_inf.h"
39 /*******************************************************************
41 * @brief Builds and sends param response to MAC CL
45 * Function : l1BldAndSndParamRsp
48 * - Builds and sends param response to MAC
50 * @params[in] Config request message pointer
51 * @return ROK - success
54 * ****************************************************************/
55 S16 l1BldAndSndParamRsp(void *msg)
60 fapi_param_resp_t *fapiParamRsp;
62 MAC_ALLOC(fapiParamRsp, sizeof(fapi_param_resp_t));
65 DU_LOG("\nERROR --> PHY STUB: Memory allocation failed");
70 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_RELEASE_CAPABILITY_TAG, sizeof(uint16_t), 1, &msgLen);
71 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PHY_STATE_TAG, sizeof(uint16_t), 0, &msgLen);
72 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SKIP_BLANK_DL_CONFIG_TAG, sizeof(uint8_t), 0, &msgLen);
73 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SKIP_BLANK_UL_CONFIG_TAG, sizeof(uint8_t), 0, &msgLen);
74 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG, sizeof(uint8_t), 0, &msgLen);
77 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_CYCLIC_PREFIX_TAG, sizeof(uint8_t), 1, &msgLen);
78 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG, sizeof(uint8_t), 1, &msgLen);
79 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_BANDWIDTH_DL_TAG, sizeof(uint16_t), 1, &msgLen);
80 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG, sizeof(uint8_t), 0, &msgLen);
81 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_BANDWIDTH_UL_TAG, sizeof(uint16_t), 0, &msgLen);
84 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_CCE_MAPPING_TYPE_TAG, sizeof(uint8_t), 0, &msgLen);
85 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG, sizeof(uint8_t), 0, &msgLen);
86 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRECODER_GRANULARITY_CORESET_TAG, sizeof(uint8_t), 0, &msgLen);
87 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDCCH_MU_MIMO_TAG, sizeof(uint8_t), 0, &msgLen);
88 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDCCH_PRECODER_CYCLING_TAG, sizeof(uint8_t), 0, &msgLen);
89 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PDCCHS_PER_SLOT_TAG, sizeof(uint8_t), 0, &msgLen);
92 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUCCH_FORMATS_TAG, sizeof(uint8_t), 0, &msgLen);
93 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PUCCHS_PER_SLOT_TAG, sizeof(uint8_t), 0, &msgLen);
96 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_MAPPING_TYPE_TAG, sizeof(uint8_t), 0, &msgLen);
97 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_ALLOCATION_TYPES_TAG, sizeof(uint8_t), 0, &msgLen);
98 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG, sizeof(uint8_t), 0, &msgLen);
99 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_CBG_TAG, sizeof(uint8_t), 0, &msgLen);
100 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG, sizeof(uint8_t), 0, &msgLen);
101 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DMRS_MAX_LENGTH_TAG, sizeof(uint8_t), 0, &msgLen);
102 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG, sizeof(uint8_t), 0, &msgLen);
103 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG, sizeof(uint8_t), 0, &msgLen);
104 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG, sizeof(uint8_t), 0, &msgLen);
105 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG, sizeof(uint8_t), 0, &msgLen);
106 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_MU_MIMO_USERS_DL_TAG, sizeof(uint8_t), 0, &msgLen);
107 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG, sizeof(uint8_t), 0, &msgLen);
108 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PREMPTIONSUPPORT_TAG, sizeof(uint8_t), 0, &msgLen);
109 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_NON_SLOT_SUPPORT_TAG, sizeof(uint8_t), 0, &msgLen);
112 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG, sizeof(uint8_t), 0, &msgLen);
113 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_UCI_ONLY_PUSCH_TAG, sizeof(uint8_t), 0, &msgLen);
114 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_FREQUENCY_HOPPING_TAG, sizeof(uint8_t), 0, &msgLen);
115 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG, sizeof(uint8_t), 0, &msgLen);
116 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_DMRS_MAX_LEN_TAG, sizeof(uint8_t), 0, &msgLen);
117 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG, sizeof(uint8_t), 0, &msgLen);
118 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_CBG_TAG, sizeof(uint8_t), 0, &msgLen);
119 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_MAPPING_TYPE_TAG, sizeof(uint8_t), 0, &msgLen);
120 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_ALLOCATION_TYPES_TAG, sizeof(uint8_t), 0, &msgLen);
121 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG, sizeof(uint8_t), 0, &msgLen);
122 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_MAX_PTRS_PORTS_TAG, sizeof(uint8_t), 0, &msgLen);
123 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG, sizeof(uint8_t), 0, &msgLen);
124 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG, sizeof(uint8_t), 0, &msgLen);
125 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG, sizeof(uint8_t), 0, &msgLen);
126 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_MU_MIMO_USERS_UL_TAG, sizeof(uint8_t), 0, &msgLen);
127 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_DFTS_OFDM_SUPPORT_TAG, sizeof(uint8_t), 0, &msgLen);
128 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_AGGREGATION_FACTOR_TAG, sizeof(uint8_t), 0, &msgLen);
131 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRACH_LONG_FORMATS_TAG, sizeof(uint8_t), 0, &msgLen);
132 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRACH_SHORT_FORMATS_TAG, sizeof(uint8_t), 0, &msgLen);
133 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRACH_RESTRICTED_SETS_TAG, sizeof(uint8_t), 0, &msgLen);
134 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG, sizeof(uint8_t), 0, &msgLen);
136 /* MEASUREMENT TAG */
137 fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_RSSI_MEASUREMENT_SUPPORT_TAG, sizeof(uint8_t), 0, &msgLen);
139 fapiParamRsp->number_of_tlvs = index;
140 msgLen += sizeof(fapi_param_resp_t) - sizeof(fapi_msg_t);
141 fillMsgHeader(&fapiParamRsp->header, FAPI_PARAM_RESPONSE, msgLen);
142 fapiParamRsp->error_code = MSG_OK;
144 DU_LOG("\nINFO --> PHY_STUB: Sending Param Request to Lower Mac");
145 procPhyMessages(fapiParamRsp->header.msg_id, sizeof(fapi_param_resp_t), (void *)fapiParamRsp);
146 MAC_FREE(fapiParamRsp, sizeof(fapi_param_resp_t));
151 /*******************************************************************
153 * @brief Builds and sends config response to lower mac
157 * Function : l1BldAndSndConfigRsp
160 * - Builds and sends config response to MAC
162 * @params[in] Config request message pointer
163 * @return ROK - success
166 * ****************************************************************/
168 S16 l1BldAndSndConfigRsp(void *msg)
172 fapi_config_resp_t *fapiConfigRsp;
174 MAC_ALLOC(fapiConfigRsp, sizeof(fapi_config_resp_t));
177 DU_LOG("\nERROR --> PHY STUB: Memory allocation failed");
180 memset(fapiConfigRsp, 0, sizeof(fapi_config_resp_t));
181 fapiConfigRsp->number_of_invalid_tlvs = NULLP;
182 fapiConfigRsp->number_of_inv_tlvs_idle_only = NULLP;
183 fapiConfigRsp->number_of_missing_tlvs = NULLP;
184 fapiConfigRsp->error_code = MSG_OK;
185 msgLen = sizeof(fapi_config_resp_t) - sizeof(fapi_msg_t);
186 fillMsgHeader(&fapiConfigRsp->header, FAPI_CONFIG_RESPONSE, msgLen);
188 DU_LOG("\nINFO --> PHY_STUB: Sending Config Response to Lower Mac");
190 procPhyMessages(fapiConfigRsp->header.msg_id, \
191 sizeof(fapi_config_resp_t), (void *)fapiConfigRsp);
192 MAC_FREE(fapiConfigRsp, sizeof(fapi_config_resp_t));
196 /*******************************************************************
198 * @brief Handles param request received from MAC
202 * Function : l1HdlParamReq
205 * -Handles param request received from MAC
207 * @params[in] Message length
208 * Param request message pointer
212 * ****************************************************************/
214 void l1HdlParamReq(uint32_t msgLen, void *msg)
217 DU_LOG("\nINFO --> PHY_STUB: Received Param Request in PHY");
219 /* Build and send PARAM RESPONSE */
220 if(l1BldAndSndParamRsp(msg)!= ROK)
222 DU_LOG("\nERROR --> PHY_STUB: Failed Sending Param Response");
224 MAC_FREE(msg, sizeof(fapi_param_req_t));
228 /*******************************************************************
230 * @brief Handles config request received from MAC
234 * Function : l1HdlConfigReq
237 * -Handles config request received from MAC
239 * @params[in] Message length
240 * config request message pointer
244 * ****************************************************************/
246 void l1HdlConfigReq(uint32_t msgLen, void *msg)
248 memset(&phyDb.ueDb, 0, sizeof(UeDb));
249 cmInetAddr((char *)SOURCE_DU_IPV4_ADDR, &phyDb.ipCfgInfo.sourceDu);
250 cmInetAddr((char *)DESTINATION_DU_IPV4_ADDR, &phyDb.ipCfgInfo.destinationDu);
251 phyDb.ipCfgInfo.portNumber = PORT_NUMBER;
252 phyDb.isServer = true;
255 p_fapi_api_queue_elem_t configReqElem = (p_fapi_api_queue_elem_t)msg;
256 fapi_config_req_t *configReq = (fapi_config_req_t *)(configReqElem +1);
258 DU_LOG("\nINFO --> PHY_STUB: Received Config Request in PHY");
260 /* Handling CONFIG RESPONSE */
261 if(l1BldAndSndConfigRsp(configReq)!= ROK)
263 DU_LOG("\nERROR --> PHY_STUB: Failed Sending config Response");
266 MAC_FREE(msg, msgLen);
271 /*******************************************************************
273 * @brief Build and Send CRC Indication
277 * Function : l1BuildAndSendCrcInd
280 * Build and Send CRC Indication
284 * @return ROK - success
287 * ****************************************************************/
288 uint16_t l1BuildAndSendCrcInd(uint16_t slot, uint16_t sfn, fapi_ul_pusch_pdu_t puschPdu)
290 uint8_t result[]={0,//MSG3
292 0,//MSG5 RRC Setup Complete
293 0,//Security Mode Complete
294 0,//Registraion Complete
295 0,//RRC Reconfiguration Complete
312 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
316 static uint8_t ind=0;
318 fapi_crc_ind_t *crcInd;
320 MAC_ALLOC(crcInd, sizeof(fapi_crc_ind_t));
323 DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for CRC Indication Message");
326 memset(crcInd, 0, sizeof(fapi_crc_ind_t));
328 /* TODO: Fill the required values. As of now only 1 CRC status PASS is filled */
333 crcInd->crc[idx].handle = puschPdu.handle;
334 crcInd->crc[idx].rnti = puschPdu.rnti;
335 crcInd->crc[idx].harqId = puschPdu.puschData.harqProcessId;
336 crcInd->crc[idx].tbCrcStatus = 0;
337 crcInd->crc[idx].numCb = 1;
338 crcInd->crc[idx].cbCrcStatus[0] = result[ind%50];
339 ret = (0== crcInd->crc[idx].cbCrcStatus[0])?ROK:RFAILED;
340 /*TBD: To use crc ind with random number and percentage */
341 //crcInd->crc[idx].cbCrcStatus[0] = (crcPassPer >= rand()%(100))?0:1;
344 crcInd->crc[idx].ul_cqi = 0;
345 crcInd->crc[idx].timingAdvance = 0;
346 crcInd->crc[idx].rssi = 0;
348 fillMsgHeader(&crcInd->header, FAPI_CRC_INDICATION, \
349 sizeof(fapi_crc_ind_t) - sizeof(fapi_msg_t));
351 /* Sending CRC indication to MAC */
352 DU_LOG("\nINFO --> PHY STUB: Sending CRC Indication to MAC");
353 procPhyMessages(crcInd->header.msg_id, sizeof(fapi_crc_ind_t), (void *)crcInd);
354 MAC_FREE(crcInd, sizeof(fapi_crc_ind_t));
357 } /* l1BuildAndSendCrcInd */
360 /*******************************************************************
362 * @brief Build and send Rx data indication
366 * Function : l1BuildAndSendRxDataInd
369 * Build and send Rx data indication
373 * @return ROK - success
376 * ****************************************************************/
377 uint16_t l1BuildAndSendRxDataInd(uint16_t slot, uint16_t sfn, fapi_ul_pusch_pdu_t puschPdu)
379 uint8_t idx = 0, ueId = 0;
380 fapi_rx_data_indication_t *rxDataInd =NULLP;
381 fapi_pdu_ind_info_t *pduInfo =NULLP;
382 uint8_t *pdu = NULLP;
383 uint16_t byteIdx = 0;
387 GET_UE_ID(puschPdu.rnti, ueId);
388 if(phyDb.ueDb.ueCb[ueId-1].isCFRA)
390 if(!phyDb.ueDb.ueCb[ueId-1].msgRrcReconfigComp)
392 /* In CF-RA in case of handover, RRC Reconfiguration Complete is sent
393 * by UE once RAR is received from DU */
394 phyDb.ueDb.ueCb[ueId-1].ueId = ueId;
395 phyDb.ueDb.ueCb[ueId-1].crnti = puschPdu.rnti;
396 phyDb.ueDb.ueCb[ueId-1].msgRrcReconfigComp = true;
397 type = MSG_TYPE_RRC_RECONFIG_COMPLETE;
404 if(!phyDb.ueDb.ueCb[ueId-1].msg3Sent)
406 phyDb.ueDb.ueCb[ueId-1].ueId = ueId;
407 phyDb.ueDb.ueCb[ueId-1].crnti = puschPdu.rnti;
408 phyDb.ueDb.ueCb[ueId-1].msg3Sent = true;
409 type = MSG_TYPE_MSG3;
412 else if(!phyDb.ueDb.ueCb[ueId-1].msg5ShortBsrSent)
414 phyDb.ueDb.ueCb[ueId-1].msg5ShortBsrSent = true;
415 type = MSG_TYPE_SHORT_BSR;
417 else if(!phyDb.ueDb.ueCb[ueId-1].msg5Sent)
419 phyDb.ueDb.ueCb[ueId-1].msg5Sent = true;
420 type = MSG_TYPE_MSG5;
422 else if(!phyDb.ueDb.ueCb[ueId-1].msgNasSecurityModeComp)
424 phyDb.ueDb.ueCb[ueId-1].msgNasSecurityModeComp = true;
425 type = MSG_TYPE_NAS_SECURITY_MODE_COMPLETE;
427 else if(!phyDb.ueDb.ueCb[ueId-1].msgRrcSecurityModeComp)
429 phyDb.ueDb.ueCb[ueId-1].msgRrcSecurityModeComp = true;
430 type = MSG_TYPE_RRC_SECURITY_MODE_COMPLETE;
432 else if(!phyDb.ueDb.ueCb[ueId-1].msgRegistrationComp)
434 phyDb.ueDb.ueCb[ueId-1].msgRegistrationComp = true;
435 type = MSG_TYPE_REGISTRATION_COMPLETE;
437 else if(!phyDb.ueDb.ueCb[ueId-1].msgRrcReconfigComp)
439 phyDb.ueDb.ueCb[ueId-1].msgRrcReconfigComp = true;
440 type = MSG_TYPE_RRC_RECONFIG_COMPLETE;
446 MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t));
449 DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
452 memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t));
454 msgLen = sizeof(fapi_rx_data_indication_t) - sizeof(fapi_msg_t);
455 rxDataInd->sfn = sfn;
456 rxDataInd->slot = slot;
457 rxDataInd->numPdus = 1;
459 pduInfo = &rxDataInd->pdus[idx];
460 pduInfo->handle = puschPdu.handle;
461 pduInfo->rnti = puschPdu.rnti;
462 pduInfo->harqId = puschPdu.puschData.harqProcessId;
463 pduInfo->pdu_length = puschPdu.puschData.tbSize ;
465 pduInfo->timingAdvance = 0;
468 /* Filling pdu with random values for testing */
469 pduInfo->pduData = NULL;
470 MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length);
471 if(!pduInfo->pduData)
473 DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
476 memset(pduInfo->pduData, 0, pduInfo->pdu_length);
478 pdu = (uint8_t *)pduInfo->pduData;
484 DU_LOG("\nDEBUG --> PHY_STUB: Forming MSG3 PDU ");
485 /* For Initial RRC setup Request,
486 MAC subheader format is R/R/LCId (1byte)
488 From 38.321 section 6.1.1
491 /* Hardcoding MAC PDU */
497 pdu[byteIdx++] = 103;
501 case MSG_TYPE_SHORT_BSR:
503 DU_LOG("\nDEBUG --> PHY_STUB: Forming SHORT BSR PDU ");
505 uint8_t bufferSizeIdx = 6;
508 MAC subheader format is R/R/LcId (1Byte)
510 From 38.321 section 6.1.1
512 pdu[byteIdx++] = 61; // LCID
513 pdu[byteIdx++] = (lcgId << 5) | bufferSizeIdx;
520 /* For RRC setup complete
522 * MAC subheader format is R/F/LCId/L (2/3 bytes)
524 * L is length of PDU i.e 6bytes here
525 * From 38.321 section 6.1.1
527 * RLC subheader for AM PDU is D/C/P/SI/SN (2 bytes for 12-bit SN)
528 * From 38.322, section 6.2.2.4
530 DU_LOG("\nDEBUG --> PHY_STUB: Forming MSG5 PDU");
531 uint8_t msg5PduLen = 33; /* Length of MSG5 */
532 msg5PduLen += 2; /* RLC subheader */
533 uint8_t msg5[] = {1, msg5PduLen, 128, phyDb.ueDb.ueCb[ueId-1].rlcSnForSrb1++, 0, phyDb.ueDb.ueCb[ueId-1].pdcpSn++, 16, 0, \
534 5, 223, 128, 16, 94, 64, 3, 64, 68, 252, 97, 0, 0, 0, 0, 4, 0, 0, 4, 68, 11, 128, 184, 56, 0, 0, 0, 0, 0};
536 msg5PduLen += 2; /* 2 bytes of MAC header */
537 memcpy(pdu, &msg5, msg5PduLen);
538 byteIdx += msg5PduLen; /* 4 bytes of header : MAC+RLC */
542 case MSG_TYPE_NAS_SECURITY_MODE_COMPLETE:
544 /* For NAS security mode complete where RRC Container is dummy
546 * MAC subheader format is R/F/LCId/L (2/3 bytes)
548 * L is length of PDU i.e 6bytes here
549 * From 38.321 section 6.1.1
551 * RLC subheader for AM PDU is D/C/P/SI/SN (2 bytes for 12-bit SN)
552 * From 38.322, section 6.2.2.4
554 DU_LOG("\nDEBUG --> PHY_STUB: Forming NAS SECURITY MODE COMPLETE PDU");
555 uint8_t pduLen = 93; /* Length of PDU */
556 pduLen += 2; /* RLC subheader */
557 uint8_t msg[] = {1, pduLen, 128, phyDb.ueDb.ueCb[ueId-1].rlcSnForSrb1++, 0, phyDb.ueDb.ueCb[ueId-1].pdcpSn++, 0x3a, 0x2a, 0x3f,
558 0x02, 0x75, 0xa0, 0xa0, 0xc0, 0x80, 0x3f, 0x00, 0x2f, 0x3b, 0x80, 0x04, 0x9a, 0xa2, 0x81, 0x09, 0x80, 0xc0,
559 0x28, 0x04, 0xf8, 0xb8, 0x80, 0x1d, 0xbf, 0x00, 0x20, 0x8c, 0x80, 0x05, 0xf9, 0x00, 0x78, 0x88, 0x7a, 0x88,
560 0xd9, 0x00, 0x00, 0x00, 0x03, 0x08, 0x00, 0x81, 0x97, 0x02, 0x78, 0x38, 0x78, 0x38, 0x17, 0x82, 0x82, 0x00,
561 0x80, 0x00, 0x00, 0xa9, 0x00, 0x78, 0x88, 0x00, 0x00, 0x00, 0x8b, 0x83, 0xf8, 0x38, 0x60, 0x20, 0x0c, 0xc0,
562 0x50, 0x0c, 0x00, 0x80, 0x3a, 0x00, 0x00, 0x48, 0x29, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00};
564 pduLen += 2; /* 2 bytes of MAC header */
565 memcpy(pdu, &msg, pduLen);
566 byteIdx += pduLen; /* 4 bytes of header : MAC+RLC */
569 case MSG_TYPE_RRC_SECURITY_MODE_COMPLETE:
571 /* For security mode complete where RRC Container is dummy
573 * MAC subheader format is R/F/LCId/L (2/3 bytes)
575 * L is length of PDU i.e 6bytes here
576 * From 38.321 section 6.1.1
578 * RLC subheader for AM PDU is D/C/P/SI/SN (2 bytes for 12-bit SN)
579 * From 38.322, section 6.2.2.4
581 DU_LOG("\nDEBUG --> PHY_STUB: Forming RRC SECURITY MODE COMPLETE PDU");
582 uint8_t pduLen = 12; /* Length of PDU */
583 pduLen += 2; /* RLC subheader */
584 uint8_t msg[] = {1, pduLen, 128, phyDb.ueDb.ueCb[ueId-1].rlcSnForSrb1++, 0, phyDb.ueDb.ueCb[ueId-1].pdcpSn++, 0x2a, 0x40, \
585 0, 0, 0, 0, 0, 0, 0, 0};
587 pduLen += 2; /* 2 bytes of MAC header */
588 memcpy(pdu, &msg, pduLen);
589 byteIdx += pduLen; /* 4 bytes of header : MAC+RLC */
593 case MSG_TYPE_REGISTRATION_COMPLETE:
595 /* For rrc reconfig complete where RRC Container is dummy
597 * MAC subheader format is R/F/LCId/L (2/3 bytes)
599 * L is length of PDU i.e 6bytes here
600 * From 38.321 section 6.1.1
602 * RLC subheader for AM PDU is D/C/P/SI/SN (2 bytes for 12-bit SN)
603 * From 38.322, section 6.2.2.4
605 DU_LOG("\nDEBUG --> PHY_STUB: Forming RRC REGISTRATION COMPLETE PDU");
606 uint8_t pduLen = 12; /* Length of PDU */
607 pduLen += 2; /* RLC subheader */
608 uint8_t msg[] = {1, pduLen, 128, phyDb.ueDb.ueCb[ueId-1].rlcSnForSrb1++, 0, phyDb.ueDb.ueCb[ueId-1].pdcpSn++, 0x3a, 0x81, \
609 0xbf, 0, 0x21, 0x80, 0, 0, 0, 0};
611 pduLen += 2; /* 2 bytes of MAC header */
612 memcpy(pdu, &msg, pduLen);
613 byteIdx += pduLen; /* 4 bytes of header : MAC+RLC */
617 case MSG_TYPE_RRC_RECONFIG_COMPLETE:
619 /* For rrc reconfig complete where RRC Container is dummy
621 * MAC subheader format is R/F/LCId/L (2/3 bytes)
623 * L is length of PDU i.e 6bytes here
624 * From 38.321 section 6.1.1
626 * RLC subheader for AM PDU is D/C/P/SI/SN (2 bytes for 12-bit SN)
627 * From 38.322, section 6.2.2.4
629 DU_LOG("\nDEBUG --> PHY_STUB: Forming RRC RECONFIGURATION COMPLETE PDU");
630 uint8_t pduLen = 13; /* PDU length */
631 pduLen += 2; /* RLC sub header */
632 uint8_t msg[] = {1, pduLen, 128, phyDb.ueDb.ueCb[ueId-1].rlcSnForSrb1++, 0, phyDb.ueDb.ueCb[ueId-1].pdcpSn++, 8, 64, 0, 0,\
633 0, 0, 0, 0, 0, 0, 0};
635 pduLen += 2; /* 2bytes of MAC header */
636 memcpy(pdu, &msg, pduLen);
637 byteIdx += pduLen; /* 4 bytes of header : MAC+RLC*/
644 } /* End of switch(type) */
646 /* Filling MAC SDU for Padding bytes*/
647 if(byteIdx < pduInfo->pdu_length)
650 MAC subheader format is R/R/LCId (1byte)
651 LCId is 63 for padding
652 From 38.321 section 6.1.1
656 for(; byteIdx < pduInfo->pdu_length; byteIdx++)
659 msgLen += pduInfo->pdu_length;
661 fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen);
663 /* Sending Rx data indication to MAC */
664 DU_LOG("\nINFO --> PHY STUB: Sending Rx data Indication to MAC");
665 procPhyMessages(rxDataInd->header.msg_id, sizeof(fapi_rx_data_indication_t), (void *)rxDataInd);
667 if(pduInfo->pdu_length)
668 MAC_FREE(pduInfo->pduData, pduInfo->pdu_length);
669 MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t));
674 /*******************************************************************
676 * @brief Builds and Sends RACH indication to MAC
680 * Function : l1BuildAndSendRachInd
683 * Builds and Sends RACH indication to MAC
685 * @params[in] SFN value
687 * @return ROK - success
690 * ****************************************************************/
691 uint16_t l1BuildAndSendRachInd(uint16_t slot, uint16_t sfn, uint8_t raPreambleIdx)
694 uint8_t rachPduIdx = 0;
695 uint8_t preamIdx = 0;
696 fapi_rach_pdu_t *rachPdu;
697 fapi_rach_indication_t *rachInd;
699 /* Building RACH indication */
700 MAC_ALLOC(rachInd, sizeof(fapi_rach_indication_t));
703 DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rach Indication Message");
706 memset(rachInd, 0, sizeof(fapi_rach_indication_t));
708 rachInd->slot = slot;
709 rachInd->numPdus = 1;
711 rachPdu = &rachInd->rachPdu[rachPduIdx];
712 rachPdu->phyCellId = NR_PCI;
713 rachPdu->symbolIndex = 0;
714 rachPdu->slotIndex = slot;
715 rachPdu->freqIndex = 0;
716 rachPdu->avgRssi = 0;
718 rachPdu->numPreamble = 1;
720 rachPdu->preambleInfo[preamIdx].preambleIndex = raPreambleIdx;
721 rachPdu->preambleInfo[preamIdx].timingAdvance = 0;
722 rachPdu->preambleInfo[preamIdx].preamblePwr = 0;
724 fillMsgHeader(&rachInd->header, FAPI_RACH_INDICATION, \
725 sizeof(fapi_rach_indication_t) - sizeof(fapi_msg_t));
727 /* Sending RACH indication to MAC */
728 DU_LOG("\nINFO --> PHY STUB: Sending RACH Indication to MAC");
729 procPhyMessages(rachInd->header.msg_id, sizeof(fapi_rach_indication_t), (void *)rachInd);
730 MAC_FREE(rachInd, sizeof(fapi_rach_indication_t));
735 /*******************************************************************
737 * @brief Builds and Send the Slot Indication message to MAC
741 * Function : l1BuildAndSendSlotIndication
744 * -Send the Slot indication Message to MAC
746 * @params[in] Message length
747 * config request message pointer
751 * ****************************************************************/
752 uint16_t l1BuildAndSendSlotIndication()
758 fapi_slot_ind_t *slotIndMsg;
760 MAC_ALLOC_SHRABL_BUF(slotIndMsg, sizeof(fapi_slot_ind_t));
763 DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for slot Indication Message");
768 memset(slotIndMsg, 0, sizeof(fapi_slot_ind_t));
769 slotIndMsg->sfn = sfnValue;
770 slotIndMsg->slot = slotValue;
772 #ifdef ODU_SLOT_IND_DEBUG_LOG
773 DU_LOG("\n\nDEBUG --> PHY_STUB: Sending Slot Indication [%d : %d] to MAC", sfnValue, slotValue);
776 /* increment for the next TTI */
778 if(sfnValue >= MAX_SFN_VALUE && slotValue > MAX_SLOT_VALUE)
783 else if(slotValue > MAX_SLOT_VALUE)
788 fillMsgHeader(&slotIndMsg->header, FAPI_SLOT_INDICATION, \
789 sizeof(fapi_slot_ind_t) - sizeof(fapi_msg_t));
791 memset(&pst, 0, sizeof(Pst));
792 FILL_PST_PHY_STUB_TO_LWR_MAC(pst, EVT_PHY_STUB_SLOT_IND);
793 ODU_GET_MSG_BUF(pst.region, pst.pool, &mBuf);
796 DU_LOG("\nERROR --> PHY_STUB: Failed to allocate memory for slot indication buffer");
797 MAC_FREE_SHRABL_BUF(pst.region, pst.pool, slotIndMsg, sizeof(fapi_slot_ind_t));
800 CMCHKPK(oduPackPointer, (PTR)slotIndMsg, mBuf);
801 ODU_POST_TASK(&pst, mBuf);
807 /*******************************************************************
809 * @brief Handles start request received from MAC
813 * Function : l1HdlStartReq
816 * -Handles start request received from MAC
818 * @params[in] Message length
819 * config request message pointer
823 * ****************************************************************/
825 S16 l1HdlStartReq(uint32_t msgLen, void *msg)
828 if(lwrMacCb.phyState == PHY_STATE_CONFIGURED)
830 l1HdlSlotIndicaion(FALSE);
831 l1StartConsoleHandler();
832 MAC_FREE(msg, msgLen);
836 DU_LOG("\nINFO --> PHY_STUB: Received Start Req in PHY State %d", lwrMacCb.phyState);
837 MAC_FREE(msg, msgLen);
844 /*******************************************************************
846 * @brief Handles Dl Tti request received from MAC
850 * Function : l1HdlDlTtiReq
853 * -Handles Dl Tti request received from MAC
855 * @params[in] Message length
856 * Dl Tti request message pointer
860 * ****************************************************************/
862 S16 l1HdlDlTtiReq(uint16_t msgLen, void *msg)
865 p_fapi_api_queue_elem_t dlTtiElem = (p_fapi_api_queue_elem_t)msg;
866 fapi_dl_tti_req_t *dlTtiReq = (fapi_dl_tti_req_t *)(dlTtiElem +1);
868 uint8_t pduCount = 0;
870 #ifdef ODU_SLOT_IND_DEBUG_LOG
871 if(dlTtiReq->nPdus == 0)
873 DU_LOG("\nDEBUG --> PHY_STUB: No PDU in DL TTI Request");
877 DU_LOG("\nDEBUG --> PHY STUB: DL TTI Request at sfn=%d slot=%d",dlTtiReq->sfn,dlTtiReq->slot);
881 for(pduCount=0; pduCount<dlTtiReq->nPdus; pduCount++)
883 if(dlTtiReq->pdus[pduCount].pduType == 3) //SSB_PDU_TYPE
885 DU_LOG("\nINFO --> PHY_STUB: SSB PDU");
887 else if(dlTtiReq->pdus[pduCount].pduType == 0)
889 DU_LOG("\nINFO --> PHY_STUB: PDCCH PDU");
891 else if(dlTtiReq->pdus[pduCount].pduType == 1)
893 DU_LOG("\nINFO --> PHY_STUB: PDSCH PDU");
897 /* Free FAPI message */
898 MAC_FREE(msg, msgLen);
903 /*******************************************************************
905 * @brief Handles tx_data request received from MAC
909 * Function : l1HdlTxDataReq
912 * -Handles tx_data request received from MAC
914 * @params[in] Message length
915 * tx_data request message pointer
919 * ****************************************************************/
921 S16 l1HdlTxDataReq(uint16_t msgLen, void *msg)
924 p_fapi_api_queue_elem_t txDataElem = (p_fapi_api_queue_elem_t)msg;
925 fapi_tx_data_req_t *txDataReq = (fapi_tx_data_req_t *)(txDataElem +1);
927 DU_LOG("\nINFO --> PHY STUB: TX DATA Request at sfn=%d slot=%d",txDataReq->sfn,txDataReq->slot);
931 DU_LOG("\nINFO --> PHY_STUB: TxDataPdu for DED MSG sent");
935 MAC_FREE(msg, msgLen);
941 /*******************************************************************
943 * @brief Fills Uci Ind Pdu Info carried on Pucch Format 0/Format 1
947 * Function : fillPucchF0F1PduInfo
950 * Fills Uci Ind Pdu Info carried on Pucch Format 0/Format 1
952 * @params[in] fapi_uci_o_pucch_f0f1_t *
954 * @return ROK - success
957 * ****************************************************************/
958 uint8_t fillPucchF0F1PduInfo(fapi_uci_o_pucch_f0f1_t *pduInfo, fapi_ul_pucch_pdu_t pucchPdu)
961 static uint8_t ind=0;
962 uint8_t result[]={0,//msg4
963 0,//Security Mode Command
964 0,//Registration Accept
965 0,//RRC Reconfiguration
984 pduInfo->handle = pucchPdu.handle;
985 pduInfo->pduBitmap = 1; //hardcoded for SR
986 if (pucchPdu.bitLenHarq)
988 pduInfo->pduBitmap |= HARQ_PDU_BITMASK;
990 pduInfo->pucchFormat = pucchPdu.formatType;
992 pduInfo->rnti = pucchPdu.rnti;
993 pduInfo->timingAdvance = 0;
995 if(pduInfo->pduBitmap & SR_PDU_BITMASK)
997 if (result[ind%50] == 0)
999 pduInfo->srInfo.srIndication = SR_DETECTED;
1000 pduInfo->srInfo.srConfidenceLevel = CONFDC_LEVEL_GOOD;
1003 if(pduInfo->pduBitmap & HARQ_PDU_BITMASK)
1005 pduInfo->harqInfo.numHarq++;
1006 pduInfo->harqInfo.harqConfidenceLevel = CONFDC_LEVEL_GOOD;
1007 for(idx = 0; idx < pduInfo->harqInfo.numHarq; idx++)
1009 pduInfo->harqInfo.harqValue[idx] = result[ind%50];
1011 /*TBD: To use harq ind with random number and percentage*/
1012 //pduInfo->harqInfo.harqValue[idx] = (dlHqPassPer >= rand()%(100))?HARQ_PASS:HARQ_FAIL;
1017 /*******************************************************************
1019 * @brief Fills UCI Pdu Information
1023 * Function : fillUciPduInfo
1026 * Fills UCI Pdu Information
1028 * @params[in] Pointer to uciPdu
1030 * @return ROK - success
1033 * ****************************************************************/
1034 uint8_t fillUciPduInfo(fapi_uci_pdu_info_t *uciPdu, fapi_ul_pucch_pdu_t pucchPdu)
1038 /*TODO: The pduType is hardcoded here to support
1039 UCI Ind for PUCCH forat0/format1. This is to be
1040 modified when we get SR form UE */
1041 uciPdu->pduType = UCI_IND_PUCCH_F0F1;
1042 switch(uciPdu->pduType)
1046 case UCI_IND_PUCCH_F0F1:
1048 fapi_uci_o_pucch_f0f1_t *pduInfo = NULLP;
1050 pduInfo = &uciPdu->uci.uciPucchF0F1;
1051 ret = fillPucchF0F1PduInfo(pduInfo, pucchPdu);
1052 uciPdu->pduSize = sizeof(fapi_uci_o_pucch_f0f1_t);
1055 case UCI_IND_PUCCH_F2F3F4:
1058 DU_LOG("\nERROR --> PHY_STUB: Invalid Pdu Type %d", uciPdu->pduType);
1064 /*******************************************************************
1066 * @brief Build and send Uci indication
1070 * Function : l1BuildAndSendUciInd
1073 * Build and send Uci indication
1077 * @return ROK - success
1080 * ****************************************************************/
1081 uint8_t l1BuildAndSendUciInd(uint16_t slot, uint16_t sfn, fapi_ul_pucch_pdu_t pucchPdu)
1084 uint8_t nUciPdus = 0;
1086 uint32_t msgLen = 0;
1087 fapi_uci_indication_t *uciInd = NULLP;
1089 MAC_ALLOC(uciInd, sizeof(fapi_uci_indication_t));
1092 DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for UCI Indication");
1095 memset(uciInd, 0, sizeof(fapi_uci_indication_t));
1097 uciInd->slot = slot;
1098 uciInd->numUcis = 1; //consdering the UCI Ind for SR
1099 nUciPdus = uciInd->numUcis;
1102 ret = fillUciPduInfo(&uciInd->uciPdu[uciIdx], pucchPdu);
1108 msgLen = sizeof(fapi_uci_indication_t)- sizeof(fapi_msg_t);
1109 fillMsgHeader(&uciInd->header, FAPI_UCI_INDICATION, msgLen);
1111 /* Sending UCI indication to MAC */
1112 DU_LOG("\nINFO --> PHY STUB: Sending UCI Indication to MAC");
1113 procPhyMessages(uciInd->header.msg_id, sizeof(fapi_uci_indication_t), (void *)uciInd);
1115 MAC_FREE(uciInd, sizeof(fapi_uci_indication_t));
1120 /*******************************************************************
1122 * @brief Handles Ul Tti request received from MAC
1126 * Function : l1HdlUlTtiReq
1129 * -Handles Ul Tti request received from MAC
1131 * @params[in] Message length
1132 * Ul Tti request message pointer
1136 * ****************************************************************/
1138 S16 l1HdlUlTtiReq(uint16_t msgLen, void *msg)
1141 p_fapi_api_queue_elem_t ulTtiElem = (p_fapi_api_queue_elem_t)msg;
1142 fapi_ul_tti_req_t *ulTtiReq = (fapi_ul_tti_req_t *)(ulTtiElem +1);
1143 uint8_t numPdus = ulTtiReq->nPdus;
1145 #ifdef ODU_SLOT_IND_DEBUG_LOG
1148 DU_LOG("\nINFO --> PHY STUB: No PDU received in UL TTI Req");
1152 DU_LOG("\nINFO --> PHY STUB: Received UL TTI Request");
1158 if(ulTtiReq->pdus[numPdus-1].pduType == 0)
1160 DU_LOG("\nINFO --> PHY STUB: PRACH PDU");
1162 /* Send RACH Ind to L2 for first UE */
1163 if(phyDb.ueDb.ueCb[UE_IDX_0].rachIndSent == false)
1165 phyDb.ueDb.ueCb[UE_IDX_0].isCFRA = false;
1166 phyDb.ueDb.ueCb[UE_IDX_0].rachIndSent = true;
1167 l1BuildAndSendRachInd(ulTtiReq->slot, ulTtiReq->sfn, CB_RA_PREAMBLE_IDX);
1168 phyDb.ueDb.numActvUe++;
1171 /* Send RACH Ind to L2 for second UE */
1172 if(phyDb.ueDb.ueCb[UE_IDX_1].rachIndSent == false && phyDb.ueDb.ueCb[UE_IDX_0].msgRrcReconfigComp == true)
1174 phyDb.ueDb.ueCb[UE_IDX_0].isCFRA = false;
1175 phyDb.ueDb.ueCb[UE_IDX_1].rachIndSent = true;
1176 l1BuildAndSendRachInd(ulTtiReq->slot, ulTtiReq->sfn, CB_RA_PREAMBLE_IDX);
1177 phyDb.ueDb.numActvUe++;
1180 /* Send RACH Ind to L2 for third UE */
1181 if(phyDb.ueDb.ueCb[UE_IDX_2].rachIndSent == false && phyDb.ueDb.ueCb[UE_IDX_1].msgRrcReconfigComp == true)
1183 phyDb.ueDb.ueCb[UE_IDX_0].isCFRA = false;
1184 phyDb.ueDb.ueCb[UE_IDX_2].rachIndSent = true;
1185 l1BuildAndSendRachInd(ulTtiReq->slot, ulTtiReq->sfn, CB_RA_PREAMBLE_IDX);
1186 phyDb.ueDb.numActvUe++;
1190 if(ulTtiReq->pdus[numPdus-1].pduType == 1)
1192 DU_LOG("\nINFO --> PHY STUB: PUSCH PDU");
1193 if (ROK == l1BuildAndSendCrcInd(ulTtiReq->slot, ulTtiReq->sfn,ulTtiReq->pdus[numPdus-1].pdu.pusch_pdu))
1195 l1BuildAndSendRxDataInd(ulTtiReq->slot, ulTtiReq->sfn, ulTtiReq->pdus[numPdus-1].pdu.pusch_pdu);
1198 if(ulTtiReq->pdus[numPdus-1].pduType == 2)
1200 DU_LOG("\nINFO --> PHY STUB: PUCCH PDU");
1202 fapi_ul_tti_req_t ulTtiSlotInd;
1203 memset(&ulTtiSlotInd, 0, sizeof(fapi_ul_tti_req_t));
1204 ulTtiSlotInd.slot = ulTtiReq->slot;
1205 ulTtiSlotInd.sfn = ulTtiReq->sfn;
1206 ADD_DELTA_TO_TIME(ulTtiSlotInd, ulTtiSlotInd, SLOT_DELAY, MAX_SLOTS);
1207 l1BuildAndSendUciInd(ulTtiSlotInd.slot, ulTtiSlotInd.sfn, ulTtiReq->pdus[numPdus-1].pdu.pucch_pdu);
1212 MAC_FREE(msg, msgLen);
1217 /*******************************************************************
1219 * @brief Builds and Send the stop Indication message to MAC
1223 * Function : l1BuildAndSendStopInd
1226 * -Send the Stop indication Message to MAC
1231 * ****************************************************************/
1232 uint16_t l1BuildAndSendStopInd()
1236 Buffer *mBuf = NULLP;
1237 fapi_stop_ind_t *stopIndMsg = NULLP;
1238 uint32_t msgLen = 0;
1240 MAC_ALLOC_SHRABL_BUF(stopIndMsg, sizeof(fapi_stop_ind_t));
1243 DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for stop Indication Message");
1248 fillMsgHeader(&stopIndMsg->header, FAPI_STOP_INDICATION, msgLen);
1249 DU_LOG("\n\nINFO --> PHY_STUB: Processing Stop indication to MAC");
1251 memset(&pst, 0, sizeof(Pst));
1252 FILL_PST_PHY_STUB_TO_LWR_MAC(pst, EVT_PHY_STUB_STOP_IND);
1253 ODU_GET_MSG_BUF(pst.region, pst.pool, &mBuf);
1256 DU_LOG("\nERROR --> PHY_STUB: Failed to allocate memory for slot indication buffer");
1257 MAC_FREE_SHRABL_BUF(pst.region, pst.pool, stopIndMsg, sizeof(fapi_stop_ind_t));
1260 CMCHKPK(oduPackPointer, (PTR)stopIndMsg, mBuf);
1261 ODU_POST_TASK(&pst, mBuf);
1267 /*******************************************************************
1269 * @brief Handles stop request received from MAC
1273 * Function : l1HdlStopReq
1276 * -Handles stop request received from MAC
1278 * @params[in] Message length
1279 * stop request message pointer
1283 * ****************************************************************/
1285 S16 l1HdlStopReq(uint32_t msgLen, void *msg)
1288 if(lwrMacCb.phyState == PHY_STATE_RUNNING)
1290 l1HdlSlotIndicaion(TRUE);
1292 /* Initialize all global variables */
1295 memset(&phyDb.ueDb, 0, sizeof(UeDb));
1297 DU_LOG("\nINFO --> PHY_STUB: Slot Indication is stopped successfully");
1298 MAC_FREE(msg, msgLen);
1302 DU_LOG("\nINFO --> PHY_STUB: Received Stop Req in PHY State %d", lwrMacCb.phyState);
1303 MAC_FREE(msg, msgLen);
1311 /*******************************************************************
1313 * @brief Build And Send Rx Data Ind for Msg5
1317 * Function : l1BuildAndSendMsg5
1319 * Functionality: Build And Send Rx Data Ind for Msg5
1323 * @return ROK - success
1326 * ****************************************************************/
1327 uint8_t l1BuildAndSendMsg5(uint16_t sfn, uint16_t slot)
1331 fapi_rx_data_indication_t *rxDataInd;
1332 fapi_pdu_ind_info_t *pduInfo;
1334 uint16_t byteIdx = 0;
1335 uint32_t msgLen = 0;
1337 MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t));
1340 DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication for msg5");
1343 memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t));
1345 /* TODO: Fill the required values */
1346 msgLen = sizeof(fapi_rx_data_indication_t) - sizeof(fapi_msg_t);
1347 rxDataInd->sfn = sfn;
1348 rxDataInd->slot = slot;
1349 rxDataInd->numPdus = 1;
1351 pduInfo = &rxDataInd->pdus[idx];
1352 pduInfo->handle = 100;
1353 pduInfo->rnti = 100;
1354 pduInfo->harqId = 1;
1355 pduInfo->pdu_length = 25;
1356 pduInfo->ul_cqi = 0;
1357 pduInfo->timingAdvance = 0;
1360 /* Filling pdu with random values for testing */
1361 pduInfo->pduData = NULL;
1362 MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length);
1363 if(!pduInfo->pduData)
1365 DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
1370 pdu = (uint8_t *)pduInfo->pduData;
1372 uint8_t msg5PduLen = 33;
1373 /* For RRC setup complete
1374 MAC subheader format is R/F/LCId/L (2/3 bytes)
1376 L is length of PDU i.e 6bytes here
1377 From 38.321 section 6.1.1
1379 uint8_t msg5[] = {1, msg5PduLen, 0, 0, 16, 0, 5, 223, 128, 16, 94, \
1380 64, 3, 64, 89, 61, 138, 64, 0, 0, 0, 4, 0, 0, 4, 68, 11, 128, \
1381 184, 56, 0, 0, 0, 0, 0};
1383 msg5PduLen += 2; /* 2bytes of header */
1384 memcpy(pdu, &msg5, msg5PduLen);
1385 byteIdx += msg5PduLen; /* 2 bytes of header */
1387 /* Filling MAC SDU for Padding bytes*/
1388 if(byteIdx < pduInfo->pdu_length)
1391 MAC subheader format is R/R/LCId (1byte)
1392 LCId is 63 for padding
1393 From 38.321 section 6.1.1
1395 pdu[byteIdx++] = 63;
1397 for(; byteIdx < pduInfo->pdu_length; byteIdx++)
1400 msgLen += pduInfo->pdu_length;
1402 fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen);
1404 /* Sending Rx data indication to MAC */
1405 DU_LOG("\nINFO --> PHY STUB: Sending Rx data Indication to MAC");
1406 procPhyMessages(rxDataInd->header.msg_id, sizeof(fapi_rx_data_indication_t), (void *)rxDataInd);
1408 if(pduInfo->pdu_length)
1409 MAC_FREE(pduInfo->pduData, pduInfo->pdu_length);
1410 MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t));
1416 /*******************************************************************
1418 * @brief Handles Ul Dci request received from MAC
1422 * Function : l1HdlUlDciReq
1425 * -Handles Ul Dci request received from MAC
1427 * @params[in] Message length
1428 * Ul Dci request message pointer
1432 * ****************************************************************/
1434 S16 l1HdlUlDciReq(uint16_t msgLen, void *msg)
1437 p_fapi_api_queue_elem_t ulDciElem = (p_fapi_api_queue_elem_t)msg;
1438 fapi_ul_dci_req_t *ulDciReq = (fapi_ul_dci_req_t *)(ulDciElem +1);
1439 uint8_t numPdus = ulDciReq->numPdus;
1443 if(ulDciReq->pdus[numPdus-1].pduType == 0)
1445 DU_LOG("\nINFO --> PHY STUB: Received UL DCI Request for PDCCH PDU");
1446 //l1BuildAndSendMsg5(ulDciReq->sfn, ulDciReq->slot);
1452 MAC_FREE(msg, msgLen);
1457 /*******************************************************************
1459 * @brief Send UL user data to DU
1463 * Function : l1SendUlUserData
1465 * Functionality: Send UL user data to DU
1468 * @return ROK - success
1471 * ****************************************************************/
1472 uint8_t l1SendUlUserData(uint8_t drbId, uint8_t ueIdx)
1475 fapi_rx_data_indication_t *rxDataInd;
1476 fapi_pdu_ind_info_t *pduInfo;
1477 uint8_t *pdu = NULLP;
1478 uint16_t byteIdx = 0;
1479 uint32_t msgLen = 0;
1483 MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t));
1486 DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
1489 memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t));
1491 msgLen = sizeof(fapi_rx_data_indication_t) - sizeof(fapi_msg_t);
1493 rxDataInd->slot = 0;
1494 rxDataInd->numPdus = 1;
1496 /* TODO : Fill pduInfo using PUSCH PDU. Currently hardcoding */
1497 pduInfo = &rxDataInd->pdus[idx];
1498 pduInfo->handle = ueIdx + ODU_START_CRNTI;
1499 pduInfo->rnti = ueIdx + ODU_START_CRNTI;
1500 pduInfo->harqId = 1;
1501 /* Since user data size = 50bytes and 2 bytes of MAC header and 3 byte of RLC header,
1502 * setting tbsize = 56 from Table 5.1.3.2-1 spec 38.214 */
1503 pduInfo->pdu_length = 56;
1504 pduInfo->ul_cqi = 0;
1505 pduInfo->timingAdvance = 0;
1508 /* Filling pdu with random values for testing */
1509 pduInfo->pduData = NULL;
1510 MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length);
1511 if(!pduInfo->pduData)
1513 DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
1518 pdu = (uint8_t *)pduInfo->pduData;
1522 MAC subheader format is R/F/LCId/L (2/3 bytes)
1524 L is length of PDU i.e 50 bytes
1525 From 38.321 section 6.1.1
1526 From 38.322 section 6.2.2.4, 6.2.2.3 for AM, UM Header
1529 /* Below ulMsg supports 12bit SN for UM mode */
1531 lcId = MIN_DRB_LCID + drbId;
1532 uint8_t ulMsg[] = {lcId, msgLen, 0, 0, 0, 0, 0, 50, 0, 0, 0, 0, 0, 1, 0, 0, 192, 168, 130, 81, 192, 168, 130, 82, 84, 104,
1533 105, 115, 32, 105, 115, 32, 69, 71, 84, 80, 32, 100, 97, 116, 97, 32, 102, 114, 111, 109, 32, 68, 85, 0, 0, 0, 0, 0};
1534 msgLen += 2; /* 2bytes of header */
1535 memcpy(pdu, &ulMsg, msgLen);
1536 byteIdx += msgLen; /* 2 bytes of header */
1538 /* Filling MAC SDU for Padding bytes*/
1539 if(byteIdx < pduInfo->pdu_length)
1542 MAC subheader format is R/R/LCId (1byte)
1543 LCId is 63 for padding
1544 From 38.321 section 6.1.1
1546 pdu[byteIdx++] = 63;
1548 for(; byteIdx < pduInfo->pdu_length; byteIdx++)
1551 msgLen += pduInfo->pdu_length;
1553 fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen);
1555 /* Send Message to peer */
1556 while(cnt < NUM_UL_PACKETS)
1558 DU_LOG("\nDEBUG --> PHY STUB : Sending UL User Data[%d][LCID:%d] at sfn %d slot %d", cnt+1, lcId, sfnValue, slotValue);
1559 /* Sending Rx data indication to MAC */
1560 rxDataInd->sfn = sfnValue;
1561 rxDataInd->slot = slotValue;
1562 procPhyMessages(rxDataInd->header.msg_id, sizeof(fapi_rx_data_indication_t), (void *)rxDataInd);
1566 if(pduInfo->pdu_length)
1567 MAC_FREE(pduInfo->pduData, pduInfo->pdu_length);
1568 MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t));
1572 /*******************************************************************
1574 * @brief Sends RLC Status PDU to DU
1578 * Function : l1SendStatusPdu
1580 * Functionality: Send RLC Status PDU to DU
1583 * @return ROK - success
1586 * ****************************************************************/
1587 uint8_t l1SendStatusPdu()
1589 fapi_rx_data_indication_t *rxDataInd;
1590 fapi_pdu_ind_info_t *pduInfo;
1591 uint8_t *pdu = NULLP;
1592 uint16_t byteIdx = 0;
1593 uint32_t msgLen = 0;
1596 MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t));
1599 printf("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
1602 memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t));
1604 msgLen = sizeof(fapi_rx_data_indication_t) - sizeof(fapi_msg_t);
1606 rxDataInd->slot = 0;
1607 rxDataInd->numPdus = 1;
1609 /* TODO : Fill pduInfo using PUSCH PDU. Currently hardcoding */
1610 pduInfo = &rxDataInd->pdus[idx];
1611 pduInfo->handle = 100;
1612 pduInfo->rnti = 100;
1613 pduInfo->harqId = 1;
1614 /* Since status pdu size = 3bytes and 2 bytes of MAC header,
1615 * setting tbsize = 24 from Table 5.1.3.2-1 spec 38.214 */
1616 pduInfo->pdu_length = 24;
1617 pduInfo->ul_cqi = 0;
1618 pduInfo->timingAdvance = 0;
1621 /* Filling pdu with random values for testing */
1622 pduInfo->pduData = NULL;
1623 MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length);
1624 if(!pduInfo->pduData)
1626 printf("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
1631 pdu = (uint8_t *)pduInfo->pduData;
1634 /* For RLC Status PDU
1635 * MAC subheader format is R/F/LCId/L (2/3 bytes)
1636 * LCId is 4 for DRB1
1637 * L is length of Status PDU i.e 3 bytes
1638 * From 38.321 section 6.1.1
1640 * RLC Status PDU format :
1641 * ---------------------------------
1642 * |D/C|CPT| ACK_SN |
1643 * ---------------------------------
1645 * ---------------------------------
1646 * |E1 | R | R | R | R | R | R | R |
1647 * ---------------------------------
1649 * Here, D/C bit = 0 for Control PDU
1650 * CPT bit = 0 since control pdu type is Status PDU
1651 * ACK_SN = 0 as of now, this can be changed based on the
1652 * scenario being tested
1653 * E1 = 0 because no NACK_SN, E1, E2 and E3 follows it
1654 * R = 0 i.e. reserved bits
1655 * From Spec 38.322 section 6.2.2.5
1657 uint8_t statusPdu[] = {4, msgLen, 0, 0, 0};
1658 msgLen += 2; /* 2bytes of header */
1659 memcpy(pdu, &statusPdu, msgLen);
1660 byteIdx += msgLen; /* 2 bytes of header */
1663 /* Filling MAC SDU for Padding bytes*/
1664 if(byteIdx < pduInfo->pdu_length)
1667 MAC subheader format is R/R/LCId (1byte)
1668 LCId is 63 for padding
1669 From 38.321 section 6.1.1
1671 pdu[byteIdx++] = 63;
1673 for(; byteIdx < pduInfo->pdu_length; byteIdx++)
1676 msgLen += pduInfo->pdu_length;
1678 fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen);
1680 /* Send Message to peer */
1681 DU_LOG("\nDEBUG --> PHY STUB : Sending RLC status pdu at sfn %d slot %d", sfnValue, slotValue);
1682 /* Sending Rx data indication to MAC */
1683 rxDataInd->sfn = sfnValue;
1684 rxDataInd->slot = slotValue;
1685 procPhyMessages(rxDataInd->header.msg_id, sizeof(fapi_rx_data_indication_t), (void *)rxDataInd);
1687 if(pduInfo->pdu_length)
1688 MAC_FREE(pduInfo->pduData, pduInfo->pdu_length);
1689 MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t));
1693 /*******************************************************************
1695 * @brief Receives message from MAC
1699 * Function : l1ProcessFapiRequest
1702 * - Receives message from MAC and calls handler
1704 * @params[in] Message type
1710 * ****************************************************************/
1712 void l1ProcessFapiRequest(uint8_t msgType, uint32_t msgLen, void *msg)
1717 case FAPI_PARAM_REQUEST:
1718 l1HdlParamReq(msgLen, msg);
1720 case FAPI_CONFIG_REQUEST:
1721 l1HdlConfigReq(msgLen, msg);
1723 case FAPI_START_REQUEST:
1724 l1HdlStartReq(msgLen, msg);
1726 case FAPI_DL_TTI_REQUEST:
1727 l1HdlDlTtiReq(msgLen, msg);
1729 case FAPI_TX_DATA_REQUEST:
1730 l1HdlTxDataReq(msgLen, msg);
1732 case FAPI_UL_TTI_REQUEST:
1733 l1HdlUlTtiReq(msgLen, msg);
1735 case FAPI_STOP_REQUEST:
1736 l1HdlStopReq(msgLen, msg);
1738 case FAPI_UL_DCI_REQUEST:
1739 l1HdlUlDciReq(msgLen, msg);
1742 DU_LOG("\nERROR --> PHY_STUB: Invalid message type[%x] received at PHY", msgType);
1749 /*******************************************************************
1751 * @brief Builds and Send the BSR message to MAC
1755 * Function : l1BuildAndSendBSR
1758 * -Send the BSR Message to MAC
1760 * @params[in] BSR type
1761 * array of LCGID and BSIdx
1764 *****************************************************************/
1765 uint16_t l1BuildAndSendBSR(uint8_t ueIdx, BsrType bsrType,\
1766 LcgBufferSize lcgBsIdx[MAX_NUM_LOGICAL_CHANNEL_GROUPS])
1768 fapi_rx_data_indication_t *rxDataInd;
1769 fapi_pdu_ind_info_t *pduInfo;
1770 uint8_t *pdu = NULLP;
1771 uint16_t byteIdx = 0;
1772 uint32_t msgLen = 0;
1773 uint8_t pduIdx = 0, lcgIdx = 0, lcgIdxPos = 0;
1775 MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t));
1778 DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
1781 memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t));
1783 msgLen = sizeof(fapi_rx_data_indication_t) - sizeof(fapi_msg_t);
1785 rxDataInd->slot = 0;
1786 rxDataInd->numPdus = 1;
1788 pduInfo = &rxDataInd->pdus[pduIdx];
1789 pduInfo->handle = (ODU_START_CRNTI + ueIdx);
1790 pduInfo->rnti = (ODU_START_CRNTI + ueIdx);
1791 pduInfo->harqId = 1;
1793 /* Since status pdu size = 3bytes and 2 bytes of MAC header,
1794 * setting tbsize = 24 from Table 5.1.3.2-1 spec 38.214 */
1795 pduInfo->pdu_length = 24;
1796 pduInfo->ul_cqi = 0;
1797 pduInfo->timingAdvance = 0;
1800 /* Filling pdu with random values for testing */
1801 pduInfo->pduData = NULL;
1802 MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length);
1803 if(!pduInfo->pduData)
1805 DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
1806 MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t));
1811 pdu = (uint8_t *)pduInfo->pduData;
1817 DU_LOG("\nDEBUG --> PHY_STUB: Forming SHORT BSR PDU ");
1820 * MAC subheader format is R/R/LcId (1Byte)
1822 * From 38.321 section 6.1.1
1824 pdu[byteIdx++] = 61; // LCID
1825 pdu[byteIdx++] = (lcgBsIdx[0].lcgId << 5) | lcgBsIdx[0].bsIdx;
1831 DU_LOG("\nDEBUG --> PHY_STUB: Forming LONG BSR PDU ");
1834 * MAC subheader format is R/R/LcId (1Byte)
1836 * From 38.321 section 6.1.1
1838 pdu[byteIdx++] = 62; // LCID
1840 /*Octet where lcgId bitmap will be present*/
1841 lcgIdxPos = byteIdx;
1843 for(lcgIdx = 0; lcgIdx < MAX_NUM_LOGICAL_CHANNEL_GROUPS; lcgIdx++)
1845 if(lcgBsIdx[lcgIdx].bsIdx > 0)
1847 pdu[lcgIdxPos] |= 1 << lcgBsIdx[lcgIdx].lcgId;
1848 pdu[byteIdx++] = lcgBsIdx[lcgIdx].bsIdx;
1857 DU_LOG("\nERROR --> PHY_STUB: Incorrect BSR type:%d!", bsrType);
1858 if(pduInfo->pdu_length)
1859 MAC_FREE(pduInfo->pduData, pduInfo->pdu_length);
1860 MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t));
1864 /* Filling MAC SDU for Padding bytes*/
1865 if(byteIdx < pduInfo->pdu_length)
1868 * MAC subheader format is R/R/LCId (1byte)
1869 * LCId is 63 for padding
1870 * From 38.321 section 6.1.1
1872 pdu[byteIdx++] = 63;
1874 for(; byteIdx < pduInfo->pdu_length; byteIdx++)
1877 msgLen += pduInfo->pdu_length;
1878 fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen);
1880 /* Sending Rx data indication to MAC */
1881 DU_LOG("\nINFO --> PHY STUB: Sending Rx data Indication to MAC");
1882 procPhyMessages(rxDataInd->header.msg_id, sizeof(fapi_rx_data_indication_t), (void *)rxDataInd);
1884 if(pduInfo->pdu_length)
1885 MAC_FREE(pduInfo->pduData, pduInfo->pdu_length);
1886 MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t));
1891 /**********************************************************************
1893 **********************************************************************/