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 *******************************************************************************/
23 /* header include files -- defines (.h) */
24 #include "envopt.h" /* environment options */
25 #include "envdep.h" /* environment dependent */
26 #include "envind.h" /* environment independent */
27 #include "gen.h" /* general layer */
28 #include "ssi.h" /* system service interface */
29 #include "cm_hash.h" /* common hash list */
30 #include "cm_mblk.h" /* common memory link list library */
31 #include "cm_llist.h" /* common linked list library */
32 #include "cm_err.h" /* common error */
33 #include "cm_lte.h" /* common LTE */
34 #include "lrg.h" /* Layer manager interface includes*/
35 #include "crg.h" /* CRG interface includes*/
36 #include "rgu.h" /* RGU interface includes*/
37 #include "tfu.h" /* TFU interface includes */
38 #include "rg_sch_inf.h" /* SCH interface includes */
39 #include "rg_prg.h" /* PRG (MAC-MAC) interface includes*/
40 #include "rg_env.h" /* MAC environmental includes*/
41 #include "rg.h" /* MAC includes*/
42 #include "rg_err.h" /* MAC error includes*/
44 #include "lwr_mac_fsm.h"
46 /* header/extern include files (.x) */
47 #include "gen.x" /* general layer typedefs */
48 #include "ssi.x" /* system services typedefs */
49 #include "cm5.x" /* common timers */
50 #include "cm_hash.x" /* common hash list */
51 #include "cm_lib.x" /* common library */
52 #include "cm_llist.x" /* common linked list */
53 #include "cm_mblk.x" /* memory management */
54 #include "cm_tkns.x" /* common tokens */
55 #include "cm_lte.x" /* common tokens */
56 #include "rgu.x" /* RGU types */
57 #include "tfu.x" /* RGU types */
58 #include "lrg.x" /* layer management typedefs for MAC */
59 #include "crg.x" /* CRG interface includes */
60 #include "rg_sch_inf.x" /* SCH interface typedefs */
61 #include "rg_prg.x" /* PRG (MAC-MAC) Interface typedefs */
62 #include "du_app_mac_inf.h"
64 #include "rg.x" /* typedefs for MAC */
65 #include "lwr_mac_phy.h"
66 #include "common_def.h"
69 #define MIB_SFN_BITMASK 0xFC
70 #define PDCCH_PDU_TYPE 0
71 #define PDSCH_PDU_TYPE 1
72 #define SSB_PDU_TYPE 3
73 #define PRACH_PDU_TYPE 0
74 #define PUSCH_PDU_TYPE 1
76 #define SET_MSG_LEN(x, size) x += size
78 extern void fapiMacConfigRsp();
79 extern uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX];
81 /* Global variables */
83 uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo);
90 /* Initializing WLS free mem list */
92 for(idx = 0; idx < WLS_MEM_FREE_PRD; idx++)
94 cmLListInit(&wlsBlockToFreeList[idx]);
99 /*******************************************************************
101 * @brief Handles Invalid Request Event
105 * Function : lwr_mac_handleInvalidEvt
108 * - Displays the PHY state when the invalid event occurs
111 * @return ROK - success
114 * ****************************************************************/
115 S16 lwr_mac_handleInvalidEvt(void *msg)
117 printf("\nLWR_MAC: Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState);
122 /*******************************************************************
124 * @brief Fills FAPI message header
128 * Function : fillMsgHeader
131 * -Fills FAPI message header
133 * @params[in] Pointer to header
139 * ****************************************************************/
140 PUBLIC void fillMsgHeader(fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen)
142 hdr->message_type_id = msgType;
143 hdr->length = msgLen;
146 /*******************************************************************
148 * @brief Fills FAPI Config Request message header
152 * Function : fillTlvs
155 * -Fills FAPI Config Request message header
157 * @params[in] Pointer to TLV
164 * ****************************************************************/
165 PUBLIC void fillTlvs(fapi_uint16_tlv_t *tlv, uint16_t tag, uint16_t length,
166 uint16_t value, uint32_t *msgLen)
169 tlv->tl.length = length;
171 *msgLen = *msgLen + sizeof(tag) + sizeof(length) + length;
173 /*******************************************************************
175 * @brief fills the cyclic prefix by comparing the bitmask
179 * Function : fillCyclicPrefix
182 * -checks the value with the bitmask and
183 * fills the cellPtr's cyclic prefix.
185 * @params[in] Pointer to ClCellParam
186 * Value to be compared
189 ********************************************************************/
190 PUBLIC void fillCyclicPrefix(uint8_t value, ClCellParam **cellPtr)
192 if((value & FAPI_NORMAL_CYCLIC_PREFIX_MASK) == FAPI_NORMAL_CYCLIC_PREFIX_MASK)
194 (*cellPtr)->cyclicPrefix = NORMAL_CYCLIC_PREFIX_MASK;
196 else if((value & FAPI_EXTENDED_CYCLIC_PREFIX_MASK) == FAPI_EXTENDED_CYCLIC_PREFIX_MASK)
198 (*cellPtr)->cyclicPrefix = EXTENDED_CYCLIC_PREFIX_MASK;
202 (*cellPtr)->cyclicPrefix = INVALID_VALUE;
206 /*******************************************************************
208 * @brief fills the subcarrier spacing of Downlink by comparing the bitmask
212 * Function : fillSubcarrierSpaceDl
215 * -checks the value with the bitmask and
216 * fills the cellPtr's subcarrier spacing in DL
218 * @params[in] Pointer to ClCellParam
219 * Value to be compared
222 * ****************************************************************/
224 PUBLIC void fillSubcarrierSpaceDl(uint8_t value, ClCellParam **cellPtr)
226 if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
228 (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_15_KHZ;
230 else if((value & FAPI_30KHZ_MASK) == FAPI_30KHZ_MASK)
232 (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_30_KHZ;
234 else if((value & FAPI_60KHZ_MASK) == FAPI_60KHZ_MASK)
236 (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_60_KHZ;
238 else if((value & FAPI_120KHZ_MASK) == FAPI_120KHZ_MASK)
240 (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_120_KHZ;
244 (*cellPtr)->supportedSubcarrierSpacingDl = INVALID_VALUE;
248 /*******************************************************************
250 * @brief fills the downlink bandwidth by comparing the bitmask
254 * Function : fillBandwidthDl
257 * -checks the value with the bitmask and
258 * -fills the cellPtr's DL Bandwidth
260 * @params[in] Pointer to ClCellParam
261 * Value to be compared
264 * ****************************************************************/
266 PUBLIC void fillBandwidthDl(uint16_t value, ClCellParam **cellPtr)
268 if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
270 (*cellPtr)->supportedBandwidthDl = BW_5MHZ;
272 else if((value & FAPI_10MHZ_BW_MASK) == FAPI_10MHZ_BW_MASK)
274 (*cellPtr)->supportedBandwidthDl = BW_10MHZ;
276 else if((value & FAPI_15MHZ_BW_MASK) == FAPI_15MHZ_BW_MASK)
278 (*cellPtr)->supportedBandwidthDl = BW_15MHZ;
280 else if((value & FAPI_20MHZ_BW_MASK) == FAPI_20MHZ_BW_MASK)
282 (*cellPtr)->supportedBandwidthDl = BW_20MHZ;
284 else if((value & FAPI_40MHZ_BW_MASK) == FAPI_40MHZ_BW_MASK)
286 (*cellPtr)->supportedBandwidthDl = BW_40MHZ;
288 else if((value & FAPI_50MHZ_BW_MASK) == FAPI_50MHZ_BW_MASK)
290 (*cellPtr)->supportedBandwidthDl = BW_50MHZ;
292 else if((value & FAPI_60MHZ_BW_MASK) == FAPI_60MHZ_BW_MASK)
294 (*cellPtr)->supportedBandwidthDl = BW_60MHZ;
296 else if((value & FAPI_70MHZ_BW_MASK) == FAPI_70MHZ_BW_MASK)
298 (*cellPtr)->supportedBandwidthDl = BW_70MHZ;
300 else if((value & FAPI_80MHZ_BW_MASK) == FAPI_80MHZ_BW_MASK)
302 (*cellPtr)->supportedBandwidthDl = BW_80MHZ;
304 else if((value & FAPI_90MHZ_BW_MASK) == FAPI_90MHZ_BW_MASK)
306 (*cellPtr)->supportedBandwidthDl = BW_90MHZ;
308 else if((value & FAPI_100MHZ_BW_MASK) == FAPI_100MHZ_BW_MASK)
310 (*cellPtr)->supportedBandwidthDl = BW_100MHZ;
312 else if((value & FAPI_200MHZ_BW_MASK) == FAPI_200MHZ_BW_MASK)
314 (*cellPtr)->supportedBandwidthDl = BW_200MHZ;
316 else if((value & FAPI_400MHZ_BW_MASK) == FAPI_400MHZ_BW_MASK)
318 (*cellPtr)->supportedBandwidthDl = BW_400MHZ;
322 (*cellPtr)->supportedBandwidthDl = INVALID_VALUE;
326 /*******************************************************************
328 * @brief fills the subcarrier spacing of Uplink by comparing the bitmask
332 * Function : fillSubcarrierSpaceUl
335 * -checks the value with the bitmask and
336 * -fills cellPtr's subcarrier spacing in UL
338 * @params[in] Pointer to ClCellParam
339 * Value to be compared
342 * ****************************************************************/
344 PUBLIC void fillSubcarrierSpaceUl(uint8_t value, ClCellParam **cellPtr)
346 if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
348 (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_15_KHZ;
350 else if((value & FAPI_30KHZ_MASK) == FAPI_30KHZ_MASK)
352 (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_30_KHZ;
354 else if((value & FAPI_60KHZ_MASK) == FAPI_60KHZ_MASK)
356 (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_60_KHZ;
358 else if((value & FAPI_120KHZ_MASK) == FAPI_120KHZ_MASK)
360 (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_120_KHZ;
364 (*cellPtr)->supportedSubcarrierSpacingsUl = INVALID_VALUE;
368 /*******************************************************************
370 * @brief fills the uplink bandwidth by comparing the bitmask
374 * Function : fillBandwidthUl
377 * -checks the value with the bitmask and
378 * fills the cellPtr's UL Bandwidth
382 * @params[in] Pointer to ClCellParam
383 * Value to be compared
387 * ****************************************************************/
389 PUBLIC void fillBandwidthUl(uint16_t value, ClCellParam **cellPtr)
391 if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
393 (*cellPtr)->supportedBandwidthUl = BW_5MHZ;
395 else if((value & FAPI_10MHZ_BW_MASK) == FAPI_10MHZ_BW_MASK)
397 (*cellPtr)->supportedBandwidthUl = BW_10MHZ;
399 else if((value & FAPI_15MHZ_BW_MASK) == FAPI_15MHZ_BW_MASK)
401 (*cellPtr)->supportedBandwidthUl = BW_15MHZ;
403 else if((value & FAPI_20MHZ_BW_MASK) == FAPI_20MHZ_BW_MASK)
405 (*cellPtr)->supportedBandwidthUl = BW_20MHZ;
407 else if((value & FAPI_40MHZ_BW_MASK) == FAPI_40MHZ_BW_MASK)
409 (*cellPtr)->supportedBandwidthUl = BW_40MHZ;
411 else if((value & FAPI_50MHZ_BW_MASK) == FAPI_50MHZ_BW_MASK)
413 (*cellPtr)->supportedBandwidthUl = BW_50MHZ;
415 else if((value & FAPI_60MHZ_BW_MASK) == FAPI_60MHZ_BW_MASK)
417 (*cellPtr)->supportedBandwidthUl = BW_60MHZ;
419 else if((value & FAPI_70MHZ_BW_MASK) == FAPI_70MHZ_BW_MASK)
421 (*cellPtr)->supportedBandwidthUl = BW_70MHZ;
423 else if((value & FAPI_80MHZ_BW_MASK) == FAPI_80MHZ_BW_MASK)
425 (*cellPtr)->supportedBandwidthUl = BW_80MHZ;
427 else if((value & FAPI_90MHZ_BW_MASK) == FAPI_90MHZ_BW_MASK)
429 (*cellPtr)->supportedBandwidthUl = BW_90MHZ;
431 else if((value & FAPI_100MHZ_BW_MASK) == FAPI_100MHZ_BW_MASK)
433 (*cellPtr)->supportedBandwidthUl = BW_100MHZ;
435 else if((value & FAPI_200MHZ_BW_MASK) == FAPI_200MHZ_BW_MASK)
437 (*cellPtr)->supportedBandwidthUl = BW_200MHZ;
439 else if((value & FAPI_400MHZ_BW_MASK) == FAPI_400MHZ_BW_MASK)
441 (*cellPtr)->supportedBandwidthUl = BW_400MHZ;
445 (*cellPtr)->supportedBandwidthUl = INVALID_VALUE;
448 /*******************************************************************
450 * @brief fills the CCE maping by comparing the bitmask
454 * Function : fillCCEmaping
457 * -checks the value with the bitmask and
458 * fills the cellPtr's CCE Mapping Type
461 * @params[in] Pointer to ClCellParam
462 * Value to be compared
465 * ****************************************************************/
467 PUBLIC void fillCCEmaping(uint8_t value, ClCellParam **cellPtr)
469 if ((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_INTERLEAVED_MASK)
471 (*cellPtr)->cceMappingType = CCE_MAPPING_INTERLEAVED_MASK;
473 else if((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_NONINTERLVD_MASK)
475 (*cellPtr)->cceMappingType = CCE_MAPPING_NONINTERLVD_MASK;
479 (*cellPtr)->cceMappingType = INVALID_VALUE;
483 /*******************************************************************
485 * @brief fills the PUCCH format by comparing the bitmask
489 * Function : fillPucchFormat
492 * -checks the value with the bitmask and
493 * fills the cellPtr's pucch format
496 * @params[in] Pointer to ClCellParam
497 * Value to be compared
500 * ****************************************************************/
502 PUBLIC void fillPucchFormat(uint8_t value, ClCellParam **cellPtr)
504 if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
506 (*cellPtr)->pucchFormats = FORMAT_0;
508 else if((value & FAPI_FORMAT_1_MASK) == FAPI_FORMAT_1_MASK)
510 (*cellPtr)->pucchFormats = FORMAT_1;
512 else if((value & FAPI_FORMAT_2_MASK) == FAPI_FORMAT_2_MASK)
514 (*cellPtr)->pucchFormats = FORMAT_2;
516 else if((value & FAPI_FORMAT_3_MASK) == FAPI_FORMAT_3_MASK)
518 (*cellPtr)->pucchFormats = FORMAT_3;
520 else if((value & FAPI_FORMAT_4_MASK) == FAPI_FORMAT_4_MASK)
522 (*cellPtr)->pucchFormats = FORMAT_4;
526 (*cellPtr)->pucchFormats = INVALID_VALUE;
530 /*******************************************************************
532 * @brief fills the PDSCH Mapping Type by comparing the bitmask
536 * Function : fillPdschMappingType
539 * -checks the value with the bitmask and
540 * fills the cellPtr's PDSCH MappingType
542 * @params[in] Pointer to ClCellParam
543 * Value to be compared
546 * ****************************************************************/
548 PUBLIC void fillPdschMappingType(uint8_t value, ClCellParam **cellPtr)
550 if((value & FAPI_PDSCH_MAPPING_TYPE_A_MASK) == FAPI_PDSCH_MAPPING_TYPE_A_MASK)
552 (*cellPtr)->pdschMappingType = MAPPING_TYPE_A;
554 else if((value & FAPI_PDSCH_MAPPING_TYPE_B_MASK) == FAPI_PDSCH_MAPPING_TYPE_B_MASK)
556 (*cellPtr)->pdschMappingType = MAPPING_TYPE_B;
560 (*cellPtr)->pdschMappingType = INVALID_VALUE;
564 /*******************************************************************
566 * @brief fills the PDSCH Allocation Type by comparing the bitmask
570 * Function : fillPdschAllocationType
573 * -checks the value with the bitmask and
574 * fills the cellPtr's PDSCH AllocationType
576 * @params[in] Pointer to ClCellParam
577 * Value to be compared
580 * ****************************************************************/
582 PUBLIC void fillPdschAllocationType(uint8_t value, ClCellParam **cellPtr)
584 if((value & FAPI_PDSCH_ALLOC_TYPE_0_MASK) == FAPI_PDSCH_ALLOC_TYPE_0_MASK)
586 (*cellPtr)->pdschAllocationTypes = ALLOCATION_TYPE_0;
588 else if((value & FAPI_PDSCH_ALLOC_TYPE_1_MASK) == FAPI_PDSCH_ALLOC_TYPE_1_MASK)
590 (*cellPtr)->pdschAllocationTypes = ALLOCATION_TYPE_1;
594 (*cellPtr)->pdschAllocationTypes = INVALID_VALUE;
598 /*******************************************************************
600 * @brief fills the PDSCH PRB Mapping Type by comparing the bitmask
604 * Function : fillPrbMappingType
607 * -checks the value with the bitmask and
608 * fills the cellPtr's PRB Mapping Type
610 * @params[in] Pointer to ClCellParam
611 * Value to be compared
614 ******************************************************************/
615 PUBLIC void fillPrbMappingType(uint8_t value, ClCellParam **cellPtr)
617 if((value & FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
619 (*cellPtr)->pdschVrbToPrbMapping = VRB_TO_PRB_MAP_NON_INTLV;
621 else if((value & FAPI_PDSCH_VRB_TO_PRB_MAP_INTLVD_MASK) == FAPI_PDSCH_VRB_TO_PRB_MAP_INTLVD_MASK)
623 (*cellPtr)->pdschVrbToPrbMapping = VRB_TO_PRB_MAP_INTLVD;
627 (*cellPtr)->pdschVrbToPrbMapping = INVALID_VALUE;
631 /*******************************************************************
633 * @brief fills the PDSCH DmrsConfig Type by comparing the bitmask
637 * Function : fillPdschDmrsConfigType
640 * -checks the value with the bitmask and
641 * fills the cellPtr's DmrsConfig Type
643 * @params[in] Pointer to ClCellParam
644 * Value to be compared
647 ******************************************************************/
649 PUBLIC void fillPdschDmrsConfigType(uint8_t value, ClCellParam **cellPtr)
651 if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK)
653 (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_1;
655 else if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK)
657 (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_2;
661 (*cellPtr)->pdschDmrsConfigTypes = INVALID_VALUE;
665 /*******************************************************************
667 * @brief fills the PDSCH DmrsLength by comparing the bitmask
671 * Function : fillPdschDmrsLength
674 * -checks the value with the bitmask and
675 * fills the cellPtr's PdschDmrsLength
677 * @params[in] Pointer to ClCellParam
678 * Value to be compared
681 ******************************************************************/
682 PUBLIC void fillPdschDmrsLength(uint8_t value, ClCellParam **cellPtr)
684 if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_1)
686 (*cellPtr)->pdschDmrsMaxLength = DMRS_MAX_LENGTH_1;
688 else if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_2)
690 (*cellPtr)->pdschDmrsMaxLength = DMRS_MAX_LENGTH_2;
694 (*cellPtr)->pdschDmrsMaxLength = INVALID_VALUE;
698 /*******************************************************************
700 * @brief fills the PDSCH Dmrs Additional Pos by comparing the bitmask
704 * Function : fillPdschDmrsAddPos
707 * -checks the value with the bitmask and
708 * fills the cellPtr's Pdsch DmrsAddPos
710 * @params[in] Pointer to ClCellParam
711 * Value to be compared
714 ******************************************************************/
716 PUBLIC void fillPdschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
718 if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
720 (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_0;
722 else if((value & FAPI_DMRS_ADDITIONAL_POS_1_MASK) == FAPI_DMRS_ADDITIONAL_POS_1_MASK)
724 (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_1;
726 else if((value & FAPI_DMRS_ADDITIONAL_POS_2_MASK) == FAPI_DMRS_ADDITIONAL_POS_2_MASK)
728 (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_2;
730 else if((value & FAPI_DMRS_ADDITIONAL_POS_3_MASK) == FAPI_DMRS_ADDITIONAL_POS_3_MASK)
732 (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_3;
736 (*cellPtr)->pdschDmrsAdditionalPos = INVALID_VALUE;
740 /*******************************************************************
742 * @brief fills the Modulation Order in DL by comparing the bitmask
746 * Function : fillModulationOrderDl
749 * -checks the value with the bitmask and
750 * fills the cellPtr's ModulationOrder in DL.
752 * @params[in] Pointer to ClCellParam
753 * Value to be compared
756 ******************************************************************/
757 PUBLIC void fillModulationOrderDl(uint8_t value, ClCellParam **cellPtr)
761 (*cellPtr)->supportedMaxModulationOrderDl = MOD_QPSK;
765 (*cellPtr)->supportedMaxModulationOrderDl = MOD_16QAM;
769 (*cellPtr)->supportedMaxModulationOrderDl = MOD_64QAM;
773 (*cellPtr)->supportedMaxModulationOrderDl = MOD_256QAM;
777 (*cellPtr)->supportedMaxModulationOrderDl = INVALID_VALUE;
781 /*******************************************************************
783 * @brief fills the PUSCH DmrsConfig Type by comparing the bitmask
787 * Function : fillPuschDmrsConfigType
790 * -checks the value with the bitmask and
791 * fills the cellPtr's PUSCH DmrsConfigType
793 * @params[in] Pointer to ClCellParam
794 * Value to be compared
797 ******************************************************************/
799 PUBLIC void fillPuschDmrsConfig(uint8_t value, ClCellParam **cellPtr)
801 if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK)
803 (*cellPtr)->puschDmrsConfigTypes = DMRS_CONFIG_TYPE_1;
805 else if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_2_MASK)
807 (*cellPtr)->puschDmrsConfigTypes = DMRS_CONFIG_TYPE_2;
811 (*cellPtr)->puschDmrsConfigTypes = INVALID_VALUE;
815 /*******************************************************************
817 * @brief fills the PUSCH DmrsLength by comparing the bitmask
821 * Function : fillPuschDmrsLength
824 * -checks the value with the bitmask and
825 * fills the cellPtr's PUSCH DmrsLength
827 * @params[in] Pointer to ClCellParam
828 * Value to be compared
831 ******************************************************************/
833 PUBLIC void fillPuschDmrsLength(uint8_t value, ClCellParam **cellPtr)
835 if(value == FAPI_PUSCH_DMRS_MAX_LENGTH_1)
837 (*cellPtr)->puschDmrsMaxLength = DMRS_MAX_LENGTH_1;
839 else if(value == FAPI_PUSCH_DMRS_MAX_LENGTH_2)
841 (*cellPtr)->puschDmrsMaxLength = DMRS_MAX_LENGTH_2;
845 (*cellPtr)->puschDmrsMaxLength = INVALID_VALUE;
849 /*******************************************************************
851 * @brief fills the PUSCH Dmrs Additional position by comparing the bitmask
855 * Function : fillPuschDmrsAddPos
858 * -checks the value with the bitmask and
859 * fills the cellPtr's PUSCH DmrsAddPos
861 * @params[in] Pointer to ClCellParam
862 * Value to be compared
865 ******************************************************************/
867 PUBLIC void fillPuschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
869 if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
871 (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_0;
873 else if((value & FAPI_DMRS_ADDITIONAL_POS_1_MASK) == FAPI_DMRS_ADDITIONAL_POS_1_MASK)
875 (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_1;
877 else if((value & FAPI_DMRS_ADDITIONAL_POS_2_MASK) == FAPI_DMRS_ADDITIONAL_POS_2_MASK)
879 (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_2;
881 else if((value & FAPI_DMRS_ADDITIONAL_POS_3_MASK) == FAPI_DMRS_ADDITIONAL_POS_3_MASK)
883 (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_3;
887 (*cellPtr)->puschDmrsAdditionalPos = INVALID_VALUE;
891 /*******************************************************************
893 * @brief fills the PUSCH Mapping Type by comparing the bitmask
897 * Function : fillPuschMappingType
900 * -checks the value with the bitmask and
901 * fills the cellPtr's PUSCH MappingType
903 * @params[in] Pointer to ClCellParam
904 * Value to be compared
907 ******************************************************************/
909 PUBLIC void fillPuschMappingType(uint8_t value, ClCellParam **cellPtr)
911 if((value & FAPI_PUSCH_MAPPING_TYPE_A_MASK) == FAPI_PUSCH_MAPPING_TYPE_A_MASK)
913 (*cellPtr)->puschMappingType = MAPPING_TYPE_A;
915 else if((value & FAPI_PUSCH_MAPPING_TYPE_B_MASK) == FAPI_PUSCH_MAPPING_TYPE_B_MASK)
917 (*cellPtr)->puschMappingType = MAPPING_TYPE_B;
921 (*cellPtr)->puschMappingType = INVALID_VALUE;
925 /*******************************************************************
927 * @brief fills the PUSCH Allocation Type by comparing the bitmask
931 * Function : fillPuschAllocationType
934 * -checks the value with the bitmask and
935 * fills the cellPtr's PUSCH AllocationType
937 * @params[in] Pointer to ClCellParam
938 * Value to be compared
941 ******************************************************************/
943 PUBLIC void fillPuschAllocationType(uint8_t value, ClCellParam **cellPtr)
945 if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK)
947 (*cellPtr)->puschAllocationTypes = ALLOCATION_TYPE_0;
949 else if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK)
951 (*cellPtr)->puschAllocationTypes = ALLOCATION_TYPE_1;
955 (*cellPtr)->puschAllocationTypes = INVALID_VALUE;
959 /*******************************************************************
961 * @brief fills the PUSCH PRB Mapping Type by comparing the bitmask
965 * Function : fillPuschPrbMappingType
968 * -checks the value with the bitmask and
969 * fills the cellPtr's PUSCH PRB MApping Type
971 * @params[in] Pointer to ClCellParam
972 * Value to be compared
975 ******************************************************************/
977 PUBLIC void fillPuschPrbMappingType(uint8_t value, ClCellParam **cellPtr)
979 if((value & FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
981 (*cellPtr)->puschVrbToPrbMapping = VRB_TO_PRB_MAP_NON_INTLV;
983 else if((value & FAPI_PUSCH_VRB_TO_PRB_MAP_INTLVD_MASK) == FAPI_PUSCH_VRB_TO_PRB_MAP_INTLVD_MASK)
985 (*cellPtr)->puschVrbToPrbMapping = VRB_TO_PRB_MAP_INTLVD;
989 (*cellPtr)->puschVrbToPrbMapping = INVALID_VALUE;
993 /*******************************************************************
995 * @brief fills the Modulation Order in Ul by comparing the bitmask
999 * Function : fillModulationOrderUl
1002 * -checks the value with the bitmask and
1003 * fills the cellPtr's Modualtsion Order in UL.
1005 * @params[in] Pointer to ClCellParam
1006 * Value to be compared
1009 ******************************************************************/
1011 PUBLIC void fillModulationOrderUl(uint8_t value, ClCellParam **cellPtr)
1015 (*cellPtr)->supportedModulationOrderUl = MOD_QPSK;
1019 (*cellPtr)->supportedModulationOrderUl = MOD_16QAM;
1023 (*cellPtr)->supportedModulationOrderUl = MOD_64QAM;
1027 (*cellPtr)->supportedModulationOrderUl = MOD_256QAM;
1031 (*cellPtr)->supportedModulationOrderUl = INVALID_VALUE;
1035 /*******************************************************************
1037 * @brief fills the PUSCH Aggregation Factor by comparing the bitmask
1041 * Function : fillPuschAggregationFactor
1044 * -checks the value with the bitmask and
1045 * fills the cellPtr's PUSCH Aggregation Factor
1047 * @params[in] Pointer to ClCellParam
1048 * Value to be compared
1051 ******************************************************************/
1053 PUBLIC void fillPuschAggregationFactor(uint8_t value, ClCellParam **cellPtr)
1055 if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
1057 (*cellPtr)->puschAggregationFactor = AGG_FACTOR_1;
1059 else if((value & FAPI_FORMAT_1_MASK) == FAPI_FORMAT_1_MASK)
1061 (*cellPtr)->puschAggregationFactor = AGG_FACTOR_2;
1063 else if((value & FAPI_FORMAT_2_MASK) == FAPI_FORMAT_2_MASK)
1065 (*cellPtr)->puschAggregationFactor = AGG_FACTOR_4;
1067 else if((value & FAPI_FORMAT_3_MASK) == FAPI_FORMAT_3_MASK)
1069 (*cellPtr)->puschAggregationFactor = AGG_FACTOR_8;
1073 (*cellPtr)->puschAggregationFactor = INVALID_VALUE;
1077 /*******************************************************************
1079 * @brief fills the PRACH Long Format by comparing the bitmask
1083 * Function : fillPrachLongFormat
1086 * -checks the value with the bitmask and
1087 * fills the cellPtr's PRACH Long Format
1089 * @params[in] Pointer to ClCellParam
1090 * Value to be compared
1093 ******************************************************************/
1095 PUBLIC void fillPrachLongFormat(uint8_t value, ClCellParam **cellPtr)
1097 if((value & FAPI_PRACH_LF_FORMAT_0_MASK) == FAPI_PRACH_LF_FORMAT_0_MASK)
1099 (*cellPtr)->prachLongFormats = FORMAT_0;
1101 else if((value & FAPI_PRACH_LF_FORMAT_1_MASK) == FAPI_PRACH_LF_FORMAT_1_MASK)
1103 (*cellPtr)->prachLongFormats = FORMAT_1;
1105 else if((value & FAPI_PRACH_LF_FORMAT_2_MASK) == FAPI_PRACH_LF_FORMAT_2_MASK)
1107 (*cellPtr)->prachLongFormats = FORMAT_2;
1109 else if((value & FAPI_PRACH_LF_FORMAT_3_MASK) == FAPI_PRACH_LF_FORMAT_3_MASK)
1111 (*cellPtr)->prachLongFormats = FORMAT_3;
1115 (*cellPtr)->prachLongFormats = INVALID_VALUE;
1119 /*******************************************************************
1121 * @brief fills the PRACH Short Format by comparing the bitmask
1125 * Function : fillPrachShortFormat
1128 * -checks the value with the bitmask and
1129 * fills the cellPtr's PRACH ShortFormat
1131 * @params[in] Pointer to ClCellParam
1132 * Value to be compared
1135 ******************************************************************/
1137 PUBLIC void fillPrachShortFormat(uint8_t value, ClCellParam **cellPtr)
1139 if((value & FAPI_PRACH_SF_FORMAT_A1_MASK) == FAPI_PRACH_SF_FORMAT_A1_MASK)
1141 (*cellPtr)->prachShortFormats = SF_FORMAT_A1;
1143 else if((value & FAPI_PRACH_SF_FORMAT_A2_MASK) == FAPI_PRACH_SF_FORMAT_A2_MASK)
1145 (*cellPtr)->prachShortFormats = SF_FORMAT_A2;
1147 else if((value & FAPI_PRACH_SF_FORMAT_A3_MASK) == FAPI_PRACH_SF_FORMAT_A3_MASK)
1149 (*cellPtr)->prachShortFormats = SF_FORMAT_A3;
1151 else if((value & FAPI_PRACH_SF_FORMAT_B1_MASK) == FAPI_PRACH_SF_FORMAT_B1_MASK)
1153 (*cellPtr)->prachShortFormats = SF_FORMAT_B1;
1155 else if((value & FAPI_PRACH_SF_FORMAT_B2_MASK) == FAPI_PRACH_SF_FORMAT_B2_MASK)
1157 (*cellPtr)->prachShortFormats = SF_FORMAT_B2;
1159 else if((value & FAPI_PRACH_SF_FORMAT_B3_MASK) == FAPI_PRACH_SF_FORMAT_B3_MASK)
1161 (*cellPtr)->prachShortFormats = SF_FORMAT_B3;
1163 else if((value & FAPI_PRACH_SF_FORMAT_B4_MASK) == FAPI_PRACH_SF_FORMAT_B4_MASK)
1165 (*cellPtr)->prachShortFormats = SF_FORMAT_B4;
1167 else if((value & FAPI_PRACH_SF_FORMAT_C0_MASK) == FAPI_PRACH_SF_FORMAT_C0_MASK)
1169 (*cellPtr)->prachShortFormats = SF_FORMAT_C0;
1171 else if((value & FAPI_PRACH_SF_FORMAT_C2_MASK) == FAPI_PRACH_SF_FORMAT_C2_MASK)
1173 (*cellPtr)->prachShortFormats = SF_FORMAT_C2;
1177 (*cellPtr)->prachShortFormats = INVALID_VALUE;
1181 /*******************************************************************
1183 * @brief fills the Fd Occasions Type by comparing the bitmask
1187 * Function : fillFdOccasions
1190 * -checks the value with the bitmask and
1191 * fills the cellPtr's Fd Occasions
1193 * @params[in] Pointer to ClCellParam
1194 * Value to be compared
1197 ******************************************************************/
1199 PUBLIC void fillFdOccasions(uint8_t value, ClCellParam **cellPtr)
1203 (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_1;
1207 (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_2;
1211 (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_4;
1215 (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_8;
1219 (*cellPtr)->maxPrachFdOccasionsInASlot = INVALID_VALUE;
1223 /*******************************************************************
1225 * @brief fills the RSSI Measurement by comparing the bitmask
1229 * Function : fillRssiMeas
1232 * -checks the value with the bitmask and
1233 * fills the cellPtr's RSSI Measurement report
1235 * @params[in] Pointer to ClCellParam
1236 * Value to be compared
1239 ******************************************************************/
1241 PUBLIC void fillRssiMeas(uint8_t value, ClCellParam **cellPtr)
1243 if((value & FAPI_RSSI_REPORT_IN_DBM_MASK) == FAPI_RSSI_REPORT_IN_DBM_MASK)
1245 (*cellPtr)->rssiMeasurementSupport = RSSI_REPORT_DBM;
1247 else if((value & FAPI_RSSI_REPORT_IN_DBFS_MASK) == FAPI_RSSI_REPORT_IN_DBFS_MASK)
1249 (*cellPtr)->rssiMeasurementSupport = RSSI_REPORT_DBFS;
1253 (*cellPtr)->rssiMeasurementSupport = INVALID_VALUE;
1257 /*******************************************************************
1259 * @brief Returns the TLVs value
1263 * Function : getParamValue
1266 * -return TLVs value
1269 * @return ROK - temp
1272 * ****************************************************************/
1274 uint32_t getParamValue(fapi_uint16_tlv_t *tlv, uint16_t type)
1276 //uint16_t valueLen;
1278 //valueLen = tlv->tl.length;
1279 posPtr = &tlv->tl.tag;
1280 posPtr += sizeof(tlv->tl.tag);
1281 posPtr += sizeof(tlv->tl.length);
1282 /*TO DO: malloc to SSI memory */
1283 if(type == FAPI_UINT_8)
1285 //temp = (uint8_t *)malloc(valueLen * sizeof(U8));
1286 //memcpy(temp, posPtr, valueLen);
1287 return(*(uint8_t *)posPtr);
1289 else if(type == FAPI_UINT_16)
1291 return(*(uint16_t *)posPtr);
1293 else if(type == FAPI_UINT_32)
1295 return(*(uint32_t *)posPtr);
1299 DU_LOG("\nLWR_MAC: Value Extraction failed" );
1304 /*******************************************************************
1306 * @brief Sends FAPI Param req to PHY
1310 * Function : lwr_mac_handleParamReqEvt
1313 * -Sends FAPI Param req to PHY
1316 * @return ROK - success
1319 * ****************************************************************/
1321 S16 lwr_mac_handleParamReqEvt(void *msg)
1324 /* startGuardTimer(); */
1325 uint32_t msgLen = 0; //Length of message Body
1326 fapi_param_req_t *paramReq = NULL;
1328 LWR_MAC_ALLOC(paramReq, sizeof(fapi_param_req_t));
1329 if(paramReq != NULL)
1331 fillMsgHeader(¶mReq->header, FAPI_PARAM_REQUEST, msgLen);
1333 DU_LOG("\nLWR_MAC: Sending Param Request to Phy");
1334 LwrMacSendToPhy(paramReq->header.message_type_id, \
1335 sizeof(fapi_param_req_t), (void *)paramReq);
1339 DU_LOG("\nLWR_MAC: Failed to allocate memory for Param Request");
1346 /*******************************************************************
1348 * @brief Sends FAPI Param Response to MAC via PHY
1352 * Function : lwr_mac_handleParamRspEvt
1355 * -Sends FAPI Param rsp to MAC via PHY
1358 * @return ROK - success
1361 * ****************************************************************/
1363 S16 lwr_mac_handleParamRspEvt(void *msg)
1366 /* stopGuardTimer(); */
1368 uint32_t encodedVal;
1369 fapi_param_resp_t *paramRsp;
1370 ClCellParam *cellParam = NULLP;
1372 paramRsp = (fapi_param_resp_t *)msg;
1373 DU_LOG("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
1375 if(paramRsp != NULLP)
1377 MAC_ALLOC(cellParam, sizeof(ClCellParam));
1378 if(cellParam != NULLP)
1380 DU_LOG("\n LWR_MAC: Filling TLVS into MAC API");
1381 if(paramRsp->error_code == MSG_OK)
1383 for(index = 0; index < paramRsp->number_of_tlvs; index++)
1385 switch(paramRsp->tlvs[index].tl.tag)
1387 case FAPI_RELEASE_CAPABILITY_TAG:
1388 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
1389 if(encodedVal != RFAILED && (encodedVal & RELEASE_15) == RELEASE_15)
1391 cellParam->releaseCapability = RELEASE_15;
1395 case FAPI_PHY_STATE_TAG:
1396 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1397 if(encodedVal != RFAILED && encodedVal != clGlobalCp.phyState)
1399 printf("\n PhyState mismatch [%d][%d]", clGlobalCp.phyState, clGlobalCp.event);
1404 case FAPI_SKIP_BLANK_DL_CONFIG_TAG:
1405 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1406 if(encodedVal != RFAILED && encodedVal != 0)
1408 cellParam->skipBlankDlConfig = SUPPORTED;
1412 cellParam->skipBlankDlConfig = NOT_SUPPORTED;
1416 case FAPI_SKIP_BLANK_UL_CONFIG_TAG:
1417 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1418 if(encodedVal != RFAILED && encodedVal != 0)
1420 cellParam->skipBlankUlConfig = SUPPORTED;
1424 cellParam->skipBlankUlConfig = NOT_SUPPORTED;
1428 case FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG:
1429 cellParam->numTlvsToReport = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
1432 case FAPI_CYCLIC_PREFIX_TAG:
1433 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1434 if(encodedVal != RFAILED)
1436 fillCyclicPrefix(encodedVal, &cellParam);
1440 case FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG:
1441 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1442 if(encodedVal != RFAILED)
1444 fillSubcarrierSpaceDl(encodedVal, &cellParam);
1448 case FAPI_SUPPORTED_BANDWIDTH_DL_TAG:
1449 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
1450 if(encodedVal != RFAILED)
1452 fillBandwidthDl(encodedVal, &cellParam);
1456 case FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG:
1457 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1458 if(encodedVal != RFAILED)
1460 fillSubcarrierSpaceUl(encodedVal, &cellParam);
1464 case FAPI_SUPPORTED_BANDWIDTH_UL_TAG:
1465 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
1466 if(encodedVal != RFAILED)
1468 fillBandwidthUl(encodedVal, &cellParam);
1472 case FAPI_CCE_MAPPING_TYPE_TAG:
1473 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1474 if(encodedVal != RFAILED)
1476 fillCCEmaping(encodedVal, &cellParam);
1480 case FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG:
1481 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1482 if(encodedVal != RFAILED && encodedVal != 0)
1484 cellParam->coresetOutsideFirst3OfdmSymsOfSlot = SUPPORTED;
1488 cellParam->coresetOutsideFirst3OfdmSymsOfSlot = NOT_SUPPORTED;
1492 case FAPI_PRECODER_GRANULARITY_CORESET_TAG:
1493 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1494 if(encodedVal != RFAILED && encodedVal != 0)
1496 cellParam->precoderGranularityCoreset = SUPPORTED;
1500 cellParam->precoderGranularityCoreset = NOT_SUPPORTED;
1504 case FAPI_PDCCH_MU_MIMO_TAG:
1505 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1506 if(encodedVal != RFAILED && encodedVal != 0)
1508 cellParam->pdcchMuMimo = SUPPORTED;
1512 cellParam->pdcchMuMimo = NOT_SUPPORTED;
1516 case FAPI_PDCCH_PRECODER_CYCLING_TAG:
1517 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1518 if(encodedVal != RFAILED && encodedVal != 0)
1520 cellParam->pdcchPrecoderCycling = SUPPORTED;
1524 cellParam->pdcchPrecoderCycling = NOT_SUPPORTED;
1528 case FAPI_MAX_PDCCHS_PER_SLOT_TAG:
1529 cellParam->maxPdcchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1532 case FAPI_PUCCH_FORMATS_TAG:
1533 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1534 if(encodedVal != RFAILED)
1536 fillPucchFormat(encodedVal, &cellParam);
1540 case FAPI_MAX_PUCCHS_PER_SLOT_TAG:
1541 cellParam->maxPucchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1544 case FAPI_PDSCH_MAPPING_TYPE_TAG:
1545 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1546 if(encodedVal != RFAILED)
1548 fillPdschMappingType(encodedVal, &cellParam);
1552 case FAPI_PDSCH_ALLOCATION_TYPES_TAG:
1553 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1554 if(encodedVal != RFAILED)
1556 fillPdschAllocationType(encodedVal, &cellParam);
1560 case FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG:
1561 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1562 if(encodedVal != RFAILED)
1564 fillPrbMappingType(encodedVal, &cellParam);
1568 case FAPI_PDSCH_CBG_TAG:
1569 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1570 if(encodedVal != RFAILED && encodedVal != 0)
1572 cellParam->pdschCbg = SUPPORTED;
1576 cellParam->pdschCbg = NOT_SUPPORTED;
1580 case FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG:
1581 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1582 if(encodedVal != RFAILED)
1584 fillPdschDmrsConfigType(encodedVal, &cellParam);
1588 case FAPI_PDSCH_DMRS_MAX_LENGTH_TAG:
1589 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1590 if(encodedVal != RFAILED)
1592 fillPdschDmrsLength(encodedVal, &cellParam);
1596 case FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG:
1597 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1598 if(encodedVal != RFAILED)
1600 fillPdschDmrsAddPos(encodedVal, &cellParam);
1604 case FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG:
1605 cellParam->maxPdschsTBsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1608 case FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG:
1609 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1610 if(encodedVal != RFAILED && encodedVal < FAPI_MAX_NUMBERMIMO_LAYERS_PDSCH)
1612 cellParam->maxNumberMimoLayersPdsch = encodedVal;
1616 case FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG:
1617 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1618 if(encodedVal != RFAILED)
1620 fillModulationOrderDl(encodedVal, &cellParam);
1624 case FAPI_MAX_MU_MIMO_USERS_DL_TAG:
1625 cellParam->maxMuMimoUsersDl = \
1626 getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1629 case FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG:
1630 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1631 if(encodedVal != RFAILED && encodedVal != 0)
1633 cellParam->pdschDataInDmrsSymbols = SUPPORTED;
1637 cellParam->pdschDataInDmrsSymbols = NOT_SUPPORTED;
1641 case FAPI_PREMPTIONSUPPORT_TAG:
1642 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1643 if(encodedVal != RFAILED && encodedVal != 0)
1645 cellParam->premptionSupport = SUPPORTED;
1649 cellParam->premptionSupport = NOT_SUPPORTED;
1653 case FAPI_PDSCH_NON_SLOT_SUPPORT_TAG:
1654 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1655 if(encodedVal != RFAILED && encodedVal != 0)
1657 cellParam->pdschNonSlotSupport = SUPPORTED;
1661 cellParam->pdschNonSlotSupport = NOT_SUPPORTED;
1665 case FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG:
1666 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1667 if(encodedVal != RFAILED && encodedVal != 0)
1669 cellParam->uciMuxUlschInPusch = SUPPORTED;
1673 cellParam->uciMuxUlschInPusch = NOT_SUPPORTED;
1677 case FAPI_UCI_ONLY_PUSCH_TAG:
1678 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1679 if(encodedVal != RFAILED && encodedVal != 0)
1681 cellParam->uciOnlyPusch = SUPPORTED;
1685 cellParam->uciOnlyPusch = NOT_SUPPORTED;
1689 case FAPI_PUSCH_FREQUENCY_HOPPING_TAG:
1690 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1691 if(encodedVal != RFAILED && encodedVal != 0)
1693 cellParam->puschFrequencyHopping = SUPPORTED;
1697 cellParam->puschFrequencyHopping = NOT_SUPPORTED;
1701 case FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG:
1702 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1703 if(encodedVal != RFAILED)
1705 fillPuschDmrsConfig(encodedVal, &cellParam);
1709 case FAPI_PUSCH_DMRS_MAX_LEN_TAG:
1710 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1711 if(encodedVal != RFAILED)
1713 fillPuschDmrsLength(encodedVal, &cellParam);
1717 case FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG:
1718 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1719 if(encodedVal != RFAILED)
1721 fillPuschDmrsAddPos(encodedVal, &cellParam);
1725 case FAPI_PUSCH_CBG_TAG:
1726 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1727 if(encodedVal != RFAILED && encodedVal != 0)
1729 cellParam->puschCbg = SUPPORTED;
1733 cellParam->puschCbg = NOT_SUPPORTED;
1737 case FAPI_PUSCH_MAPPING_TYPE_TAG:
1738 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1739 if(encodedVal != RFAILED)
1741 fillPuschMappingType(encodedVal, &cellParam);
1745 case FAPI_PUSCH_ALLOCATION_TYPES_TAG:
1746 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1747 if(encodedVal != RFAILED)
1749 fillPuschAllocationType(encodedVal, &cellParam);
1753 case FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG:
1754 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1755 if(encodedVal != RFAILED)
1757 fillPuschPrbMappingType(encodedVal, &cellParam);
1761 case FAPI_PUSCH_MAX_PTRS_PORTS_TAG:
1762 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1763 if(encodedVal != RFAILED && encodedVal < FAPI_PUSCH_MAX_PTRS_PORTS_UB)
1765 cellParam->puschMaxPtrsPorts = encodedVal;
1769 case FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG:
1770 cellParam->maxPduschsTBsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1773 case FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG:
1774 cellParam->maxNumberMimoLayersNonCbPusch = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1777 case FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG:
1778 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1779 if(encodedVal != RFAILED)
1781 fillModulationOrderUl(encodedVal, &cellParam);
1785 case FAPI_MAX_MU_MIMO_USERS_UL_TAG:
1786 cellParam->maxMuMimoUsersUl = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1789 case FAPI_DFTS_OFDM_SUPPORT_TAG:
1790 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1791 if(encodedVal != RFAILED && encodedVal != 0)
1793 cellParam->dftsOfdmSupport = SUPPORTED;
1797 cellParam->dftsOfdmSupport = NOT_SUPPORTED;
1801 case FAPI_PUSCH_AGGREGATION_FACTOR_TAG:
1802 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1803 if(encodedVal != RFAILED)
1805 fillPuschAggregationFactor(encodedVal, &cellParam);
1809 case FAPI_PRACH_LONG_FORMATS_TAG:
1810 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1811 if(encodedVal != RFAILED)
1813 fillPrachLongFormat(encodedVal, &cellParam);
1817 case FAPI_PRACH_SHORT_FORMATS_TAG:
1818 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1819 if(encodedVal != RFAILED)
1821 fillPrachShortFormat(encodedVal, &cellParam);
1825 case FAPI_PRACH_RESTRICTED_SETS_TAG:
1826 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1827 if(encodedVal != RFAILED && encodedVal != 0)
1829 cellParam->prachRestrictedSets = SUPPORTED;
1833 cellParam->prachRestrictedSets = NOT_SUPPORTED;
1837 case FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG:
1838 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1839 if(encodedVal != RFAILED)
1841 fillFdOccasions(encodedVal, &cellParam);
1845 case FAPI_RSSI_MEASUREMENT_SUPPORT_TAG:
1846 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1847 if(encodedVal != RFAILED)
1849 fillRssiMeas(encodedVal, &cellParam);
1853 //printf("\n Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index);
1857 MAC_FREE(cellParam, sizeof(ClCellParam));
1858 sendToLowerMac(FAPI_CONFIG_REQUEST, 0, (void *)NULL);
1863 DU_LOG("\n LWR_MAC: Invalid error code %d", paramRsp->error_code);
1869 DU_LOG("\nLWR_MAC: Failed to allocate memory for cell param");
1875 DU_LOG("\nLWR_MAC: Param Response received from PHY is NULL");
1883 /*******************************************************************
1885 * @brief Sends FAPI Config req to PHY
1889 * Function : lwr_mac_handleConfigReqEvt
1892 * -Sends FAPI Config Req to PHY
1895 * @return ROK - success
1898 * ****************************************************************/
1900 S16 lwr_mac_handleConfigReqEvt(void *msg)
1906 uint32_t msgLen = 0;
1907 uint32_t configReqSize;
1908 RgCellCb *cellParams;
1909 MacCellCfg macCfgParams;
1910 fapi_config_req_t *configReq;
1912 DU_LOG("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, \
1913 clGlobalCp.phyState);
1915 cellParams = rgCb[inst].cell;
1916 macCfgParams = cellParams->macCellCfg;
1918 configReqSize = sizeof(fapi_config_req_t);
1919 LWR_MAC_ALLOC(configReq, configReqSize);
1920 if(configReq != NULL)
1922 msgLen = sizeof(macCfgParams.numTlv);
1923 configReq->number_of_tlvs = macCfgParams.numTlv;
1925 if(macCfgParams.dlCarrCfg.pres)
1927 fillTlvs(&configReq->tlvs[index++], FAPI_DL_BANDWIDTH_TAG, \
1928 sizeof(uint16_t), macCfgParams.dlCarrCfg.bw, &msgLen);
1929 fillTlvs(&configReq->tlvs[index++], FAPI_DL_FREQUENCY_TAG, \
1930 sizeof(uint32_t), macCfgParams.dlCarrCfg.freq, &msgLen);
1931 fillTlvs(&configReq->tlvs[index++], FAPI_DL_K0_TAG, \
1932 sizeof(uint16_t), macCfgParams.dlCarrCfg.k0[0], &msgLen);
1933 fillTlvs(&configReq->tlvs[index++], FAPI_DL_GRIDSIZE_TAG, \
1934 sizeof(uint16_t), macCfgParams.dlCarrCfg.gridSize[0], &msgLen);
1935 fillTlvs(&configReq->tlvs[index++], FAPI_NUM_TX_ANT_TAG, \
1936 sizeof(uint16_t), macCfgParams.dlCarrCfg.numAnt, &msgLen);
1938 if(macCfgParams.ulCarrCfg.pres)
1940 fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_BANDWIDTH_TAG, \
1941 sizeof(uint16_t), macCfgParams.ulCarrCfg.bw, &msgLen);
1942 fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_FREQUENCY_TAG, \
1943 sizeof(uint32_t), macCfgParams.ulCarrCfg.freq, &msgLen);
1944 fillTlvs(&configReq->tlvs[index++], FAPI_UL_K0_TAG, \
1945 sizeof(uint16_t), macCfgParams.ulCarrCfg.k0[0], &msgLen);
1946 fillTlvs(&configReq->tlvs[index++], FAPI_UL_GRID_SIZE_TAG, \
1947 sizeof(uint16_t), macCfgParams.ulCarrCfg.gridSize[0], &msgLen);
1948 fillTlvs(&configReq->tlvs[index++], FAPI_NUM_RX_ANT_TAG, \
1949 sizeof(uint16_t), macCfgParams.ulCarrCfg.numAnt, &msgLen);
1951 fillTlvs(&configReq->tlvs[index++], FAPI_FREQUENCY_SHIFT_7P5_KHZ_TAG, \
1952 sizeof(uint8_t), macCfgParams.freqShft, &msgLen);
1954 /* fill cell config */
1955 fillTlvs(&configReq->tlvs[index++], FAPI_PHY_CELL_ID_TAG, \
1956 sizeof(uint8_t), macCfgParams.phyCellId, &msgLen);
1957 fillTlvs(&configReq->tlvs[index++], FAPI_FRAME_DUPLEX_TYPE_TAG, \
1958 sizeof(uint8_t), macCfgParams.dupType, &msgLen);
1960 /* fill SSB configuration */
1961 fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_POWER_TAG, \
1962 sizeof(uint32_t), macCfgParams.ssbCfg.ssbPbchPwr, &msgLen);
1963 fillTlvs(&configReq->tlvs[index++], FAPI_BCH_PAYLOAD_TAG, \
1964 sizeof(uint8_t), macCfgParams.ssbCfg.bchPayloadFlag, &msgLen);
1965 fillTlvs(&configReq->tlvs[index++], FAPI_SCS_COMMON_TAG, \
1966 sizeof(uint8_t), macCfgParams.ssbCfg.scsCmn, &msgLen);
1968 /* fill PRACH configuration */
1969 fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SEQUENCE_LENGTH_TAG, \
1970 sizeof(uint8_t), macCfgParams.prachCfg.prachSeqLen, &msgLen);
1971 fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SUBC_SPACING_TAG, \
1972 sizeof(uint8_t), macCfgParams.prachCfg.prachSubcSpacing, &msgLen);
1973 fillTlvs(&configReq->tlvs[index++], FAPI_RESTRICTED_SET_CONFIG_TAG, \
1974 sizeof(uint8_t), macCfgParams.prachCfg.prachRstSetCfg, &msgLen);
1975 fillTlvs(&configReq->tlvs[index++], FAPI_NUM_PRACH_FD_OCCASIONS_TAG,
1976 sizeof(uint8_t), macCfgParams.prachCfg.msg1Fdm, &msgLen);
1977 fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ROOT_SEQUENCE_INDEX_TAG, \
1978 sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].rootSeqIdx, &msgLen);
1979 fillTlvs(&configReq->tlvs[index++], FAPI_NUM_ROOT_SEQUENCES_TAG, \
1980 sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numRootSeq, &msgLen);
1981 fillTlvs(&configReq->tlvs[index++], FAPI_K1_TAG, \
1982 sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].k1, &msgLen);
1983 fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ZERO_CORR_CONF_TAG , \
1984 sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].zeroCorrZoneCfg, &msgLen);
1985 fillTlvs(&configReq->tlvs[index++], FAPI_NUM_UNUSED_ROOT_SEQUENCES_TAG, \
1986 sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numUnusedRootSeq, &msgLen);
1987 if(macCfgParams.prachCfg.fdm[0].numUnusedRootSeq)
1989 for(idx = 0; idx < macCfgParams.prachCfg.fdm[0].numUnusedRootSeq; idx++)
1990 fillTlvs(&configReq->tlvs[index++], FAPI_UNUSED_ROOT_SEQUENCES_TAG, \
1991 sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].unsuedRootSeq[idx], \
1996 macCfgParams.prachCfg.fdm[0].unsuedRootSeq = NULL;
1999 fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PER_RACH_TAG, \
2000 sizeof(uint8_t), macCfgParams.prachCfg.ssbPerRach, &msgLen);
2001 fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, \
2002 sizeof(uint8_t), macCfgParams.prachCfg.prachMultCarrBand, &msgLen);
2004 /* fill SSB table */
2005 fillTlvs(&configReq->tlvs[index++], FAPI_SSB_OFFSET_POINT_A_TAG, \
2006 sizeof(uint16_t), macCfgParams.ssbCfg.ssbOffsetPointA, &msgLen);
2007 fillTlvs(&configReq->tlvs[index++], FAPI_BETA_PSS_TAG, \
2008 sizeof(uint8_t), macCfgParams.ssbCfg.betaPss, &msgLen);
2009 fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PERIOD_TAG, \
2010 sizeof(uint8_t), macCfgParams.ssbCfg.ssbPeriod, &msgLen);
2011 fillTlvs(&configReq->tlvs[index++], FAPI_SSB_SUBCARRIER_OFFSET_TAG, \
2012 sizeof(uint8_t), macCfgParams.ssbCfg.ssbScOffset, &msgLen);
2013 fillTlvs(&configReq->tlvs[index++], FAPI_MIB_TAG , \
2014 sizeof(uint32_t), macCfgParams.ssbCfg.mibPdu[0], &msgLen);
2015 fillTlvs(&configReq->tlvs[index++], FAPI_SSB_MASK_TAG, \
2016 sizeof(uint32_t), macCfgParams.ssbCfg.ssbMask[0], &msgLen);
2017 fillTlvs(&configReq->tlvs[index++], FAPI_BEAM_ID_TAG, \
2018 sizeof(uint8_t), macCfgParams.ssbCfg.beamId[0], &msgLen);
2019 fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, \
2020 sizeof(uint8_t), macCfgParams.ssbCfg.multCarrBand, &msgLen);
2021 fillTlvs(&configReq->tlvs[index++], FAPI_MULTIPLE_CELLS_SS_PBCH_IN_A_CARRIER_TAG, \
2022 sizeof(uint8_t), macCfgParams.ssbCfg.multCellCarr, &msgLen);
2024 /* fill TDD table */
2025 fillTlvs(&configReq->tlvs[index++], FAPI_TDD_PERIOD_TAG, \
2026 sizeof(uint8_t), macCfgParams.tddCfg.tddPeriod, &msgLen);
2027 fillTlvs(&configReq->tlvs[index++], FAPI_SLOT_CONFIG_TAG, \
2028 sizeof(uint8_t), macCfgParams.tddCfg.slotCfg[0][0], &msgLen);
2030 /* fill measurement config */
2031 fillTlvs(&configReq->tlvs[index++], FAPI_RSSI_MESUREMENT_TAG, \
2032 sizeof(uint8_t), macCfgParams.rssiUnit, &msgLen);
2034 fillMsgHeader(&configReq->header, FAPI_CONFIG_REQUEST, msgLen);
2036 DU_LOG("\nLWR_MAC: Sending Config Request to Phy");
2037 LwrMacSendToPhy(configReq->header.message_type_id, configReqSize, (void *)configReq);
2041 DU_LOG("\nLWR_MAC: Failed to allocate memory for config Request");
2047 } /* lwr_mac_handleConfigReqEvt */
2049 /*******************************************************************
2051 * @brief Processes config response from phy
2055 * Function : lwr_mac_handleConfigRspEvt
2058 * Processes config response from phy
2060 * @params[in] FAPI message pointer
2061 * @return ROK - success
2064 * ****************************************************************/
2066 S16 lwr_mac_handleConfigRspEvt(void *msg)
2069 fapi_config_resp_t *configRsp;
2070 configRsp = (fapi_config_resp_t *)msg;
2072 DU_LOG("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, \
2073 clGlobalCp.phyState);
2075 if(configRsp != NULL)
2077 if(configRsp->error_code == MSG_OK)
2079 DU_LOG("\nLWR_MAC: PHY has moved to Configured state \n");
2080 clGlobalCp.phyState = PHY_STATE_CONFIGURED;
2082 * Store config response into an intermediate struture and send to MAC
2083 * Support LC and LWLC for sending config rsp to MAC
2089 DU_LOG("\n LWR_MAC: Invalid error code %d", configRsp->error_code);
2095 DU_LOG("\nLWR_MAC: Config Response received from PHY is NULL");
2101 } /* lwr_mac_handleConfigRspEvt */
2103 /*******************************************************************
2105 * @brief Build and send start request to phy
2109 * Function : lwr_mac_handleStartReqEvt
2112 * Build and send start request to phy
2114 * @params[in] FAPI message pointer
2115 * @return ROK - success
2118 * ****************************************************************/
2119 S16 lwr_mac_handleStartReqEvt(void *msg)
2122 uint32_t msgLen = 0;
2123 fapi_start_req_t *startReq;
2125 LWR_MAC_ALLOC(startReq, sizeof(fapi_start_req_t));
2126 if(startReq != NULL)
2128 fillMsgHeader(&startReq->header, FAPI_START_REQUEST, msgLen);
2130 DU_LOG("\nLWR_MAC: Sending Start Request to PHY");
2131 LwrMacSendToPhy(startReq->header.message_type_id, sizeof(fapi_start_req_t),\
2136 DU_LOG("\nLWR_MAC: Failed to allocate memory for Start Request");
2141 } /* lwr_mac_handleStartReqEvt */
2143 /*******************************************************************
2145 * @brief Sends FAPI Stop Req to PHY
2149 * Function : lwr_mac_handleStopReqEvt
2152 * -Sends FAPI Stop Req to PHY
2155 * @return ROK - success
2158 ********************************************************************/
2160 S16 lwr_mac_handleStopReqEvt(void *msg)
2163 uint32_t msgLen = 0;
2164 fapi_stop_req_t *stopReq = NULLP;
2165 LWR_MAC_ALLOC(stopReq, sizeof(fapi_stop_req_t));
2166 if(stopReq != NULLP)
2168 fillMsgHeader(&stopReq->header, FAPI_STOP_REQUEST, msgLen);
2169 DU_LOG("\nLOWER MAC: Sending Stop Request to PHY");
2170 LwrMacSendToPhy(stopReq->header.message_type_id, sizeof(fapi_stop_req_t), (void *)stopReq);
2174 DU_LOG("\nLOWER MAC: Failed to allocate memory for Stop Request");
2181 /*******************************************************************
2183 * @brief Modifes the received mibPdu to uint32 bit
2184 * and stores it in MacCellCfg
2188 * Function : setMibPdu
2193 * @params[in] Pointer to mibPdu
2194 * pointer to modified value
2195 ******************************************************************/
2197 PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val, uint16_t sfn)
2199 *mibPdu |= (((uint8_t)(sfn >> 2)) & MIB_SFN_BITMASK);
2200 *val = (mibPdu[0] << 24 | mibPdu[1] << 16 | mibPdu[2] << 8);
2201 DU_LOG("\nLWR_MAC: MIB PDU %x", *val);
2205 /*******************************************************************
2207 * @brief fills SSB PDU required for DL TTI info in MAC
2211 * Function : fillSsbPdu
2214 * -Fills the SSB PDU info
2217 * @params[in] Pointer to FAPI DL TTI Req
2218 * Pointer to RgCellCb
2219 * Pointer to msgLen of DL TTI Info
2222 ******************************************************************/
2224 S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg,
2225 MacDlSlot *currDlSlot, uint32_t *msgLen, uint8_t ssbIdxCount, uint16_t sfn)
2227 uint32_t mibPayload = 0;
2228 if(dlTtiReqPdu != NULL)
2230 dlTtiReqPdu->pduType = SSB_PDU_TYPE; /* SSB PDU */
2231 dlTtiReqPdu->u.ssb_pdu.physCellId = macCellCfg->phyCellId;
2232 dlTtiReqPdu->u.ssb_pdu.betaPss = macCellCfg->ssbCfg.betaPss;
2233 dlTtiReqPdu->u.ssb_pdu.ssbBlockIndex = currDlSlot->dlInfo.brdcstAlloc.ssbInfo[ssbIdxCount].ssbIdx;
2234 dlTtiReqPdu->u.ssb_pdu.ssbSubCarrierOffset = macCellCfg->ssbCfg.ssbScOffset;
2235 /* ssbOfPdufstA to be filled in ssbCfg */
2236 dlTtiReqPdu->u.ssb_pdu.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA;
2237 dlTtiReqPdu->u.ssb_pdu.bchPayloadFlag = macCellCfg->ssbCfg.bchPayloadFlag;
2238 /* Bit manipulation for SFN */
2239 setMibPdu(macCellCfg->ssbCfg.mibPdu, &mibPayload, sfn);
2240 dlTtiReqPdu->u.ssb_pdu.bchPayload.v.bchPayload = mibPayload;
2241 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.numPrgs = 0;
2242 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.prgSize = 0;
2243 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.digBfInterfaces = 0;
2244 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.pmi_bfi[0].pmIdx = 0;
2245 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming. \
2246 pmi_bfi[0].beamIdx[0].beamidx = macCellCfg->ssbCfg.beamId[0];
2247 dlTtiReqPdu->pduSize = sizeof(fapi_dl_ssb_pdu_t); /* Size of SSB PDU */
2248 SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \
2249 sizeof(dlTtiReqPdu->pduSize) + sizeof(fapi_dl_ssb_pdu_t)));
2258 /*******************************************************************
2260 * @brief fills Dl DCI PDU required for DL TTI info in MAC
2264 * Function : fillSib1DlDciPdu
2267 * -Fills the Dl DCI PDU
2269 * @params[in] Pointer to fapi_dl_dci_t
2270 * Pointer to PdcchCfg
2273 ******************************************************************/
2275 void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo)
2277 if(dlDciPtr != NULLP)
2283 uint16_t coreset0Size;
2286 uint32_t freqDomResAssign;
2287 uint32_t timeDomResAssign;
2289 uint32_t modNCodScheme;
2290 uint8_t redundancyVer;
2291 uint32_t sysInfoInd;
2294 /* Size(in bits) of each field in DCI format 0_1
2295 * as mentioned in spec 38.214 */
2296 uint8_t freqDomResAssignSize;
2297 uint8_t timeDomResAssignSize = 4;
2298 uint8_t VRB2PRBMapSize = 1;
2299 uint8_t modNCodSchemeSize = 5;
2300 uint8_t redundancyVerSize = 2;
2301 uint8_t sysInfoIndSize = 1;
2302 uint8_t reservedSize = 15;
2304 dlDciPtr->rnti = sib1PdcchInfo->dci.rnti;
2305 dlDciPtr->scramblingId = sib1PdcchInfo->dci.scramblingId;
2306 dlDciPtr->scramblingRnti = sib1PdcchInfo->dci.scramblingRnti;
2307 dlDciPtr->cceIndex = sib1PdcchInfo->dci.cceIndex;
2308 dlDciPtr->aggregationLevel = sib1PdcchInfo->dci.aggregLevel;
2309 dlDciPtr->pc_and_bform.numPrgs = sib1PdcchInfo->dci.beamPdcchInfo.numPrgs;
2310 dlDciPtr->pc_and_bform.prgSize = sib1PdcchInfo->dci.beamPdcchInfo.prgSize;
2311 dlDciPtr->pc_and_bform.digBfInterfaces = sib1PdcchInfo->dci.beamPdcchInfo.digBfInterfaces;
2312 dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = sib1PdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx;
2313 dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = sib1PdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0];
2314 dlDciPtr->beta_pdcch_1_0 = sib1PdcchInfo->dci.txPdcchPower.powerValue;
2315 dlDciPtr->powerControlOfssetSS = sib1PdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
2317 /* Calculating freq domain resource allocation field value and size
2318 * coreset0Size = Size of coreset 0
2319 * RBStart = Starting Virtual Rsource block
2320 * RBLen = length of contiguously allocted RBs
2321 * Spec 38.214 Sec 5.1.2.2.2
2323 coreset0Size= sib1PdcchInfo->coreset0Cfg.coreSet0Size;
2324 rbStart = 0; /* For SIB1 */
2325 //rbStart = sib1PdcchInfo->dci.pdschCfg->freqAlloc.rbStart;
2326 rbLen = sib1PdcchInfo->dci.pdschCfg->freqAlloc.rbSize;
2328 if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
2330 if((rbLen - 1) <= floor(coreset0Size / 2))
2331 freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart;
2333 freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \
2334 + (coreset0Size - 1 - rbStart);
2336 freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2));
2339 /* Fetching DCI field values */
2340 timeDomResAssign = sib1PdcchInfo->dci.pdschCfg->timeAlloc.
2342 VRB2PRBMap = sib1PdcchInfo->dci.pdschCfg->freqAlloc.\
2344 modNCodScheme = sib1PdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
2345 redundancyVer = sib1PdcchInfo->dci.pdschCfg->codeword[0].rvIndex;
2346 sysInfoInd = 0; /* 0 for SIB1; 1 for SI messages */
2349 /* Reversing bits in each DCI field */
2350 freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize);
2351 timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
2352 VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize);
2353 modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize);
2354 redundancyVer = reverseBits(redundancyVer, redundancyVerSize);
2355 sysInfoInd = reverseBits(sysInfoInd, sysInfoIndSize);
2357 /* Calulating total number of bytes in buffer */
2358 dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\
2359 + VRB2PRBMapSize + modNCodSchemeSize + redundancyVerSize\
2360 + sysInfoIndSize + reservedSize;
2362 numBytes = dlDciPtr->payloadSizeBits / 8;
2363 if(dlDciPtr->payloadSizeBits % 8)
2366 if(numBytes > DCI_PAYLOAD_BYTE_LEN)
2368 DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
2372 /* Initialize buffer */
2373 for(bytePos = 0; bytePos < numBytes; bytePos++)
2374 dlDciPtr->payload[bytePos] = 0;
2376 bytePos = numBytes - 1;
2379 /* Packing DCI format fields */
2380 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2381 freqDomResAssign, freqDomResAssignSize);
2382 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2383 timeDomResAssign, timeDomResAssignSize);
2384 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2385 VRB2PRBMap, VRB2PRBMapSize);
2386 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2387 modNCodScheme, modNCodSchemeSize);
2388 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2389 redundancyVer, redundancyVerSize);
2390 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2391 sysInfoInd, sysInfoIndSize);
2392 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2393 reserved, reservedSize);
2396 } /* fillSib1DlDciPdu */
2398 /*******************************************************************
2400 * @brief fills Dl DCI PDU required for DL TTI info in MAC
2404 * Function : fillRarDlDciPdu
2407 * -Fills the Dl DCI PDU
2409 * @params[in] Pointer to fapi_dl_dci_t
2410 * Pointer to PdcchCfg
2413 ******************************************************************/
2415 void fillRarDlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *rarPdcchInfo)
2417 if(dlDciPtr != NULLP)
2423 uint16_t coreset0Size;
2426 uint32_t freqDomResAssign;
2427 uint8_t timeDomResAssign;
2429 uint8_t modNCodScheme;
2433 /* Size(in bits) of each field in DCI format 1_0 */
2434 uint8_t freqDomResAssignSize;
2435 uint8_t timeDomResAssignSize = 4;
2436 uint8_t VRB2PRBMapSize = 1;
2437 uint8_t modNCodSchemeSize = 5;
2438 uint8_t tbScalingSize = 2;
2439 uint8_t reservedSize = 16;
2441 dlDciPtr->rnti = rarPdcchInfo->dci.rnti;
2442 dlDciPtr->scramblingId = rarPdcchInfo->dci.scramblingId;
2443 dlDciPtr->scramblingRnti = rarPdcchInfo->dci.scramblingRnti;
2444 dlDciPtr->cceIndex = rarPdcchInfo->dci.cceIndex;
2445 dlDciPtr->aggregationLevel = rarPdcchInfo->dci.aggregLevel;
2446 dlDciPtr->pc_and_bform.numPrgs = rarPdcchInfo->dci.beamPdcchInfo.numPrgs;
2447 dlDciPtr->pc_and_bform.prgSize = rarPdcchInfo->dci.beamPdcchInfo.prgSize;
2448 dlDciPtr->pc_and_bform.digBfInterfaces = rarPdcchInfo->dci.beamPdcchInfo.digBfInterfaces;
2449 dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx;
2450 dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0];
2451 dlDciPtr->beta_pdcch_1_0 = rarPdcchInfo->dci.txPdcchPower.powerValue;
2452 dlDciPtr->powerControlOfssetSS = rarPdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
2454 /* Calculating freq domain resource allocation field value and size
2455 * coreset0Size = Size of coreset 0
2456 * RBStart = Starting Virtual Rsource block
2457 * RBLen = length of contiguously allocted RBs
2458 * Spec 38.214 Sec 5.1.2.2.2
2461 /* TODO: Fill values of coreset0Size, rbStart and rbLen */
2462 coreset0Size= rarPdcchInfo->coreset0Cfg.coreSet0Size;
2463 rbStart = 0; /* For SIB1 */
2464 //rbStart = rarPdcchInfo->dci.pdschCfg->freqAlloc.rbStart;
2465 rbLen = rarPdcchInfo->dci.pdschCfg->freqAlloc.rbSize;
2467 if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
2469 if((rbLen - 1) <= floor(coreset0Size / 2))
2470 freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart;
2472 freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \
2473 + (coreset0Size - 1 - rbStart);
2475 freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2));
2478 /* Fetching DCI field values */
2479 timeDomResAssign = rarPdcchInfo->dci.pdschCfg->timeAlloc.rowIndex -1;
2480 VRB2PRBMap = rarPdcchInfo->dci.pdschCfg->freqAlloc.vrbPrbMapping;
2481 modNCodScheme = rarPdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
2482 tbScaling = 0; /* configured to 0 scaling */
2485 /* Reversing bits in each DCI field */
2486 freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize);
2487 timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
2488 VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize);
2489 modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize);
2490 tbScaling = reverseBits(tbScaling, tbScalingSize);
2492 /* Calulating total number of bytes in buffer */
2493 dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\
2494 + VRB2PRBMapSize + modNCodSchemeSize + tbScalingSize + reservedSize;
2496 numBytes = dlDciPtr->payloadSizeBits / 8;
2497 if(dlDciPtr->payloadSizeBits % 8)
2500 if(numBytes > DCI_PAYLOAD_BYTE_LEN)
2502 DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
2506 /* Initialize buffer */
2507 for(bytePos = 0; bytePos < numBytes; bytePos++)
2508 dlDciPtr->payload[bytePos] = 0;
2510 bytePos = numBytes - 1;
2513 /* Packing DCI format fields */
2514 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2515 freqDomResAssign, freqDomResAssignSize);
2516 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2517 timeDomResAssign, timeDomResAssignSize);
2518 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2519 VRB2PRBMap, VRB2PRBMapSize);
2520 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2521 modNCodScheme, modNCodSchemeSize);
2522 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2523 tbScaling, tbScalingSize);
2524 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2525 reserved, reservedSize);
2527 } /* fillRarDlDciPdu */
2529 /*******************************************************************
2531 * @brief fills msg4 Dl DCI PDU required for DL TTI info in MAC
2535 * Function : fillMsg4DlDciPdu
2538 * -Fills the Msg4 Dl DCI PDU
2540 * @params[in] Pointer to fapi_dl_dci_t
2541 * Pointer to PdcchCfg
2544 ******************************************************************/
2545 void fillMsg4DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *msg4PdcchInfo,\
2548 if(dlDciPtr != NULLP)
2554 uint16_t coreset0Size = 0;
2555 uint16_t rbStart = 0;
2557 uint8_t dciFormatId;
2558 uint32_t freqDomResAssign;
2559 uint8_t timeDomResAssign;
2561 uint8_t modNCodScheme;
2563 uint8_t redundancyVer = 0;
2564 uint8_t harqProcessNum = 0;
2565 uint8_t dlAssignmentIdx = 0;
2566 uint8_t pucchTpc = 0;
2567 uint8_t pucchResoInd = 0;
2568 uint8_t harqFeedbackInd = 0;
2570 /* Size(in bits) of each field in DCI format 1_0 */
2571 uint8_t dciFormatIdSize = 1;
2572 uint8_t freqDomResAssignSize;
2573 uint8_t timeDomResAssignSize = 4;
2574 uint8_t VRB2PRBMapSize = 1;
2575 uint8_t modNCodSchemeSize = 5;
2576 uint8_t ndiSize = 1;
2577 uint8_t redundancyVerSize = 2;
2578 uint8_t harqProcessNumSize = 4;
2579 uint8_t dlAssignmentIdxSize = 2;
2580 uint8_t pucchTpcSize = 2;
2581 uint8_t pucchResoIndSize = 3;
2582 uint8_t harqFeedbackIndSize = 3;
2584 dlDciPtr->rnti = msg4PdcchInfo->dci.rnti;
2585 dlDciPtr->scramblingId = msg4PdcchInfo->dci.scramblingId;
2586 dlDciPtr->scramblingRnti = msg4PdcchInfo->dci.scramblingRnti;
2587 dlDciPtr->cceIndex = msg4PdcchInfo->dci.cceIndex;
2588 dlDciPtr->aggregationLevel = msg4PdcchInfo->dci.aggregLevel;
2589 dlDciPtr->pc_and_bform.numPrgs = msg4PdcchInfo->dci.beamPdcchInfo.numPrgs;
2590 dlDciPtr->pc_and_bform.prgSize = msg4PdcchInfo->dci.beamPdcchInfo.prgSize;
2591 dlDciPtr->pc_and_bform.digBfInterfaces = msg4PdcchInfo->dci.beamPdcchInfo.digBfInterfaces;
2592 dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = msg4PdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx;
2593 dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = msg4PdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0];
2594 dlDciPtr->beta_pdcch_1_0 = msg4PdcchInfo->dci.txPdcchPower.powerValue;
2595 dlDciPtr->powerControlOfssetSS = msg4PdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
2597 /* Calculating freq domain resource allocation field value and size
2598 * coreset0Size = Size of coreset 0
2599 * RBStart = Starting Virtual Rsource block
2600 * RBLen = length of contiguously allocted RBs
2601 * Spec 38.214 Sec 5.1.2.2.2
2604 /* TODO: Fill values of coreset0Size, rbStart and rbLen */
2605 coreset0Size = msg4PdcchInfo->coreset0Cfg.coreSet0Size;
2606 //rbStart = msg4PdcchInfo->dci.pdschCfg->freqAlloc.rbStart;
2607 rbLen = msg4PdcchInfo->dci.pdschCfg->freqAlloc.rbSize;
2609 if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
2611 if((rbLen - 1) <= floor(coreset0Size / 2))
2612 freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart;
2614 freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \
2615 + (coreset0Size - 1 - rbStart);
2617 freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2));
2620 /* Fetching DCI field values */
2621 dciFormatId = msg4Info->dciFormatId; /* DCI indentifier for DL */
2622 timeDomResAssign = msg4PdcchInfo->dci.pdschCfg->timeAlloc.rowIndex -1;
2623 VRB2PRBMap = msg4PdcchInfo->dci.pdschCfg->freqAlloc.vrbPrbMapping;
2624 modNCodScheme = msg4PdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
2625 ndi = msg4Info->ndi;
2626 redundancyVer = msg4PdcchInfo->dci.pdschCfg->codeword[0].rvIndex;
2627 harqProcessNum = msg4Info->harqProcNum;
2628 dlAssignmentIdx = msg4Info->dlAssignIdx;
2629 pucchTpc = msg4Info->pucchTpc;
2630 pucchResoInd = msg4Info->pucchResInd;
2631 harqFeedbackInd = msg4Info->harqFeedbackInd;
2633 /* Reversing bits in each DCI field */
2634 dciFormatId = reverseBits(dciFormatId, dciFormatIdSize);
2635 freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize);
2636 timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
2637 VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize);
2638 modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize);
2639 ndi = reverseBits(ndi, ndiSize);
2640 redundancyVer = reverseBits(redundancyVer, redundancyVerSize);
2641 harqProcessNum = reverseBits(harqProcessNum, harqProcessNumSize);
2642 dlAssignmentIdx = reverseBits(dlAssignmentIdx , dlAssignmentIdxSize);
2643 pucchTpc = reverseBits(pucchTpc, pucchTpcSize);
2644 pucchResoInd = reverseBits(pucchResoInd, pucchResoIndSize);
2645 harqFeedbackInd = reverseBits(harqFeedbackInd, harqFeedbackIndSize);
2648 /* Calulating total number of bytes in buffer */
2649 dlDciPtr->payloadSizeBits = (dciFormatIdSize + freqDomResAssignSize\
2650 + timeDomResAssignSize + VRB2PRBMapSize + modNCodSchemeSize\
2651 + ndiSize + redundancyVerSize + harqProcessNumSize + dlAssignmentIdxSize\
2652 + pucchTpcSize + pucchResoIndSize + harqFeedbackIndSize);
2654 numBytes = dlDciPtr->payloadSizeBits / 8;
2655 if(dlDciPtr->payloadSizeBits % 8)
2658 if(numBytes > DCI_PAYLOAD_BYTE_LEN)
2660 DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
2664 /* Initialize buffer */
2665 for(bytePos = 0; bytePos < numBytes; bytePos++)
2666 dlDciPtr->payload[bytePos] = 0;
2668 bytePos = numBytes - 1;
2671 /* Packing DCI format fields */
2672 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2673 dciFormatId, dciFormatIdSize);
2674 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2675 freqDomResAssign, freqDomResAssignSize);
2676 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2677 timeDomResAssign, timeDomResAssignSize);
2678 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2679 VRB2PRBMap, VRB2PRBMapSize);
2680 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2681 modNCodScheme, modNCodSchemeSize);
2682 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2684 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2685 redundancyVer, redundancyVerSize);
2686 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2687 redundancyVer, redundancyVerSize);
2688 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2689 harqProcessNum, harqProcessNumSize);
2690 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2691 dlAssignmentIdx, dlAssignmentIdxSize);
2692 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2693 pucchTpc, pucchTpcSize);
2694 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2695 pucchResoInd, pucchResoIndSize);
2696 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2697 harqFeedbackInd, harqFeedbackIndSize);
2699 } /* fillMsg4DlDciPdu */
2701 /*******************************************************************
2703 * @brief fills PDCCH PDU required for DL TTI info in MAC
2707 * Function : fillPdcchPdu
2710 * -Fills the Pdcch PDU info
2713 * @params[in] Pointer to FAPI DL TTI Req
2714 * Pointer to PdcchCfg
2715 * Pointer to msgLen of DL TTI Info
2718 ******************************************************************/
2719 S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlSchedInfo *dlInfo, uint32_t *msgLen, RntiType rntiType)
2721 if(dlTtiReqPdu != NULLP)
2723 PdcchCfg *pdcchInfo = NULLP;
2724 BwpCfg *bwp = NULLP;
2726 dlTtiReqPdu->u.pdcch_pdu.dlDci = (fapi_dl_dci_t *)(dlTtiReqPdu + \
2727 (sizeof(fapi_dl_tti_req_pdu_t) - sizeof(dlTtiReqPdu->u)) + \
2728 (sizeof(fapi_dl_pdcch_pdu_t) - sizeof(fapi_dl_dci_t*)));
2730 if(rntiType == SI_RNTI_TYPE)
2732 pdcchInfo = &dlInfo->brdcstAlloc.sib1Alloc.sib1PdcchCfg;
2733 bwp = &dlInfo->brdcstAlloc.sib1Alloc.bwp;
2734 fillSib1DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo);
2736 else if(rntiType == RA_RNTI_TYPE)
2738 pdcchInfo = &dlInfo->rarAlloc->rarPdcchCfg;
2739 bwp = &dlInfo->rarAlloc->bwp;
2740 fillRarDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo);
2742 else if(rntiType == TC_RNTI_TYPE)
2744 pdcchInfo = &dlInfo->msg4Alloc->msg4PdcchCfg;
2745 bwp = &dlInfo->msg4Alloc->bwp;
2746 fillMsg4DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo,\
2747 &dlInfo->msg4Alloc->msg4Info);
2751 DU_LOG("\nLWR_MAC: Failed filling PDCCH Pdu");
2754 dlTtiReqPdu->pduType = PDCCH_PDU_TYPE;
2755 dlTtiReqPdu->u.pdcch_pdu.bwpSize = bwp->BWPSize;
2756 dlTtiReqPdu->u.pdcch_pdu.bwpPart = bwp->BWPStart;
2757 dlTtiReqPdu->u.pdcch_pdu.subCarrierSpacing = bwp->subcarrierSpacing;
2758 dlTtiReqPdu->u.pdcch_pdu.cyclicPrefix = bwp->cyclicPrefix;
2759 dlTtiReqPdu->u.pdcch_pdu.startSymbolIndex = pdcchInfo->coreset0Cfg.startSymbolIndex;
2760 dlTtiReqPdu->u.pdcch_pdu.durationSymbols = pdcchInfo->coreset0Cfg.durationSymbols;
2761 memcpy(dlTtiReqPdu->u.pdcch_pdu.freqDomainResource, pdcchInfo->coreset0Cfg.freqDomainResource, 6);
2762 dlTtiReqPdu->u.pdcch_pdu.cceRegMappingType = pdcchInfo->coreset0Cfg.cceRegMappingType;
2763 dlTtiReqPdu->u.pdcch_pdu.regBundleSize = pdcchInfo->coreset0Cfg.regBundleSize;
2764 dlTtiReqPdu->u.pdcch_pdu.interleaverSize = pdcchInfo->coreset0Cfg.interleaverSize;
2765 dlTtiReqPdu->u.pdcch_pdu.coreSetSize = pdcchInfo->coreset0Cfg.coreSetType;
2766 dlTtiReqPdu->u.pdcch_pdu.shiftIndex = pdcchInfo->coreset0Cfg.shiftIndex;
2767 dlTtiReqPdu->u.pdcch_pdu.precoderGranularity = pdcchInfo->coreset0Cfg.precoderGranularity;
2768 dlTtiReqPdu->u.pdcch_pdu.numDlDci = pdcchInfo->numDlDci;
2770 /* Calculating PDU length. Considering only one dl dci pdu for now */
2771 dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t) + sizeof(fapi_dl_dci_t);
2772 SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \
2773 sizeof(dlTtiReqPdu->pduSize) + dlTtiReqPdu->pduSize));
2780 /*******************************************************************
2782 * @brief fills PDSCH PDU required for DL TTI info in MAC
2786 * Function : fillPdschPdu
2789 * -Fills the Pdsch PDU info
2792 * @params[in] Pointer to FAPI DL TTI Req
2793 * Pointer to PdschCfg
2794 * Pointer to msgLen of DL TTI Info
2797 ******************************************************************/
2799 void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdschCfg *pdschInfo,
2800 BwpCfg bwp,uint32_t *msgLen, uint16_t pduIndex)
2804 if(dlTtiReqPdu != NULLP)
2806 dlTtiReqPdu->pduType = PDSCH_PDU_TYPE;
2807 dlTtiReqPdu->u.pdsch_pdu.pduBitMap = pdschInfo->pduBitmap;
2808 dlTtiReqPdu->u.pdsch_pdu.rnti = pdschInfo->rnti;
2809 dlTtiReqPdu->u.pdsch_pdu.pduIndex = pduIndex;
2810 dlTtiReqPdu->u.pdsch_pdu.bwpSize = bwp.BWPSize;
2811 dlTtiReqPdu->u.pdsch_pdu.bwpStart = bwp.BWPStart;
2812 dlTtiReqPdu->u.pdsch_pdu.subCarrierSpacing = bwp.subcarrierSpacing;
2813 dlTtiReqPdu->u.pdsch_pdu.cyclicPrefix = bwp.cyclicPrefix;
2814 dlTtiReqPdu->u.pdsch_pdu.nrOfCodeWords = pdschInfo->numCodewords;
2815 for(idx = 0; idx < MAX_CODEWORDS ; idx++)
2817 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].targetCodeRate = pdschInfo->codeword[idx].targetCodeRate;
2818 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].qamModOrder = pdschInfo->codeword[idx].qamModOrder;
2819 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsIndex = pdschInfo->codeword[idx].mcsIndex;
2820 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsTable = pdschInfo->codeword[idx].mcsTable;
2821 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].rvIndex = pdschInfo->codeword[idx].rvIndex;
2822 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].tbSize = pdschInfo->codeword[idx].tbSize;
2824 dlTtiReqPdu->u.pdsch_pdu.dataScramblingId = pdschInfo->dataScramblingId;
2825 dlTtiReqPdu->u.pdsch_pdu.nrOfLayers = pdschInfo->numLayers;
2826 dlTtiReqPdu->u.pdsch_pdu.transmissionScheme = pdschInfo->transmissionScheme;
2827 dlTtiReqPdu->u.pdsch_pdu.refPoint = pdschInfo->refPoint;
2828 dlTtiReqPdu->u.pdsch_pdu.dlDmrsSymbPos = pdschInfo->dmrs.dlDmrsSymbPos;
2829 dlTtiReqPdu->u.pdsch_pdu.dmrsConfigType = pdschInfo->dmrs.dmrsConfigType;
2830 dlTtiReqPdu->u.pdsch_pdu.dlDmrsScramblingId = pdschInfo->dmrs.dlDmrsScramblingId;
2831 dlTtiReqPdu->u.pdsch_pdu.scid = pdschInfo->dmrs.scid;
2832 dlTtiReqPdu->u.pdsch_pdu.numDmrsCdmGrpsNoData = pdschInfo->dmrs.numDmrsCdmGrpsNoData;
2833 dlTtiReqPdu->u.pdsch_pdu.dmrsPorts = pdschInfo->dmrs.dmrsPorts;
2834 dlTtiReqPdu->u.pdsch_pdu.resourceAlloc = pdschInfo->freqAlloc.resourceAlloc;
2835 /* since we are using type-1, hence rbBitmap excluded */
2836 dlTtiReqPdu->u.pdsch_pdu.rbStart = pdschInfo->freqAlloc.rbStart;
2837 dlTtiReqPdu->u.pdsch_pdu.rbSize = pdschInfo->freqAlloc.rbSize;
2838 dlTtiReqPdu->u.pdsch_pdu.vrbToPrbMapping = pdschInfo->freqAlloc.vrbPrbMapping;
2839 dlTtiReqPdu->u.pdsch_pdu.startSymbIndex = pdschInfo->timeAlloc.startSymbolIndex;
2840 dlTtiReqPdu->u.pdsch_pdu.nrOfSymbols = pdschInfo->timeAlloc.numSymbols;
2841 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.numPrgs = pdschInfo->beamPdschInfo.numPrgs;
2842 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.prgSize = pdschInfo->beamPdschInfo.prgSize;
2843 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = pdschInfo->beamPdschInfo.digBfInterfaces;
2844 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
2845 pmIdx = pdschInfo->beamPdschInfo.prg[0].pmIdx;
2846 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
2847 beamIdx[0].beamidx = pdschInfo->beamPdschInfo.prg[0].beamIdx[0];
2848 dlTtiReqPdu->u.pdsch_pdu.powerControlOffset = pdschInfo->txPdschPower.powerControlOffset;
2849 dlTtiReqPdu->u.pdsch_pdu.powerControlOffsetSS = pdschInfo->txPdschPower.powerControlOffsetSS;
2850 dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdsch_pdu_t);
2852 SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \
2853 sizeof(dlTtiReqPdu->pduSize) + sizeof(fapi_dl_pdsch_pdu_t)));
2859 /***********************************************************************
2861 * @brief calculates the total size to be allocated for DL TTI Req
2865 * Function : calcDlTtiReqPduCount
2868 * -calculates the total pdu count to be allocated for DL TTI Req
2870 * @params[in] DlBrdcstAlloc *cellBroadcastInfo
2873 * ********************************************************************/
2874 uint8_t calcDlTtiReqPduCount(DlSchedInfo *dlInfo)
2879 if(dlInfo->isBroadcastPres)
2881 if(dlInfo->brdcstAlloc.ssbTrans)
2883 for(idx = 0; idx < dlInfo->brdcstAlloc.ssbIdxSupported; idx++)
2885 /* SSB PDU is filled */
2889 if(dlInfo->brdcstAlloc.sib1Trans)
2891 /* PDCCH and PDSCH PDU is filled */
2895 if(dlInfo->rarAlloc != NULLP)
2897 /* PDCCH and PDSCH PDU is filled */
2900 if(dlInfo->msg4Alloc != NULLP)
2902 /* PDCCH and PDSCH PDU is filled */
2909 /***********************************************************************
2911 * @brief calculates the total size to be allocated for DL TTI Req
2915 * Function : calcTxDataReqPduCount
2918 * -calculates the total pdu count to be allocated for DL TTI Req
2920 * @params[in] DlBrdcstAlloc *cellBroadcastInfo
2923 * ********************************************************************/
2924 uint8_t calcTxDataReqPduCount(DlSchedInfo *dlInfo)
2928 if(dlInfo->isBroadcastPres && dlInfo->brdcstAlloc.sib1Trans)
2932 if(dlInfo->rarAlloc != NULLP)
2936 if(dlInfo->msg4Alloc != NULLP)
2943 /***********************************************************************
2945 * @brief fills the SIB1 TX-DATA request message
2949 * Function : fillSib1TxDataReq
2952 * - fills the SIB1 TX-DATA request message
2954 * @params[in] fapi_tx_pdu_desc_t *pduDesc
2955 * @params[in] macCellCfg consist of SIB1 pdu
2956 * @params[in] uint32_t *msgLen
2957 * @params[in] uint16_t pduIndex
2960 * ********************************************************************/
2961 uint8_t fillSib1TxDataReq(fapi_tx_pdu_desc_t *pduDesc,MacCellCfg *macCellCfg,
2962 uint32_t *msgLen, uint16_t pduIndex)
2964 uint32_t pduLen = 0;
2965 uint32_t *sib1TxdataValue = NULLP;
2967 pduDesc[pduIndex].pduIndex = pduIndex;
2968 pduDesc[pduIndex].numTlvs = 1;
2971 /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */
2972 pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */
2973 pduDesc[pduIndex].tlvs[0].tl.length = macCellCfg->sib1Cfg.sib1PduLen;
2974 LWR_MAC_ALLOC(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen);
2975 if(sib1TxdataValue == NULLP)
2979 memcpy(sib1TxdataValue,macCellCfg->sib1Cfg.sib1Pdu,
2980 macCellCfg->sib1Cfg.sib1PduLen);
2981 pduDesc[pduIndex].tlvs[0].value = sib1TxdataValue;
2983 /* The total length of the PDU description and PDU data */
2984 pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */
2985 pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */
2986 pduDesc[pduIndex].pduLength = pduLen;
2990 MAC_FREE(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen);
2996 /***********************************************************************
2998 * @brief fills the RAR TX-DATA request message
3002 * Function : fillRarTxDataReq
3005 * - fills the RAR TX-DATA request message
3007 * @params[in] fapi_tx_pdu_desc_t *pduDesc
3008 * @params[in] RarInfo *rarInfo
3009 * @params[in] uint32_t *msgLen
3010 * @params[in] uint16_t pduIndex
3013 * ********************************************************************/
3014 uint8_t fillRarTxDataReq(fapi_tx_pdu_desc_t *pduDesc, RarInfo *rarInfo,
3015 uint32_t *msgLen, uint16_t pduIndex)
3017 uint32_t pduLen = 0;
3018 uint32_t *rarTxdataValue = NULLP;
3020 pduDesc[pduIndex].pduIndex = pduIndex;
3021 pduDesc[pduIndex].numTlvs = 1;
3024 /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */
3025 pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */
3026 pduDesc[pduIndex].tlvs[0].tl.length = rarInfo->rarPduLen;
3027 LWR_MAC_ALLOC(rarTxdataValue,rarInfo->rarPduLen);
3028 if(rarTxdataValue == NULLP)
3032 memcpy(rarTxdataValue,rarInfo->rarPdu,rarInfo->rarPduLen);
3033 pduDesc[pduIndex].tlvs[0].value = (uint32_t)rarTxdataValue;
3035 /* The total length of the PDU description and PDU data */
3036 pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */
3037 pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */
3038 pduDesc[pduIndex].pduLength = pduLen;
3041 /* TODO: The pointer value which was stored, needs to be free-ed at PHY *
3042 * But since we did not implement WLS, this has to be done here
3045 MAC_FREE(rarTxdataValue,rarInfo->rarPduLen);
3051 /***********************************************************************
3053 * @brief fills the Msg4 TX-DATA request message
3057 * Function : fillMsg4TxDataReq
3060 * - fills the Msg4 TX-DATA request message
3062 * @params[in] fapi_tx_pdu_desc_t *pduDesc
3063 * @params[in] Msg4Info *msg4Info
3064 * @params[in] uint32_t *msgLen
3065 * @params[in] uint16_t pduIndex
3068 * ********************************************************************/
3069 uint8_t fillMsg4TxDataReq(fapi_tx_pdu_desc_t *pduDesc, Msg4Info *msg4Info,
3070 uint32_t *msgLen, uint16_t pduIndex)
3072 uint32_t pduLen = 0;
3073 uint32_t *msg4TxDataValue = NULLP;
3075 pduDesc[pduIndex].pduIndex = pduIndex;
3076 pduDesc[pduIndex].numTlvs = 1;
3079 /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */
3080 pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */
3081 pduDesc[pduIndex].tlvs[0].tl.length = msg4Info->msg4PduLen;
3082 LWR_MAC_ALLOC(msg4TxDataValue, msg4Info->msg4PduLen);
3083 if(msg4TxDataValue == NULLP)
3087 memcpy(msg4TxDataValue, msg4Info->msg4Pdu, msg4Info->msg4PduLen);
3088 pduDesc[pduIndex].tlvs[0].value = (uint32_t)msg4TxDataValue;
3090 /* The total length of the PDU description and PDU data */
3091 pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */
3092 pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */
3093 pduDesc[pduIndex].pduLength = pduLen;
3096 /* TODO: The pointer value which was stored, needs to be free-ed at PHY *
3097 * But since we did not implement WLS, this has to be done here
3100 MAC_FREE(msg4TxDataValue, msg4Info->msg4PduLen);
3107 /*******************************************************************
3109 * @brief Sends DL TTI Request to PHY
3113 * Function : handleDlTtiReq
3116 * -Sends FAPI DL TTI req to PHY
3118 * @params[in] timing info
3119 * @return ROK - success
3122 * ****************************************************************/
3123 uint16_t handleDlTtiReq(SlotIndInfo currTimingInfo)
3128 uint8_t numPduEncoded = 0;
3129 uint16_t pduIndex = 0;
3130 uint32_t msgLen = 0;
3131 uint32_t dlTtiReqMsgSize = 0;
3133 fapi_dl_tti_req_t *dlTtiReq = NULLP;
3134 SlotIndInfo dlTtiReqTimingInfo;
3136 RgCellCb *cellCbParams = NULLP;
3137 MacDlSlot *currDlSlot = NULLP;
3138 MacCellCfg macCellCfg;
3139 memset(&macCellCfg, 0, sizeof(MacCellCfg));
3143 if(clGlobalCp.phyState == PHY_STATE_RUNNING)
3145 /* consider phy delay */
3146 ADD_DELTA_TO_TIME(currTimingInfo,dlTtiReqTimingInfo,PHY_DELTA);
3148 cellCbParams = rgCb[inst].cell;
3149 macCellCfg = cellCbParams->macCellCfg;
3151 currDlSlot = &macCb.macCell->dlSlot[dlTtiReqTimingInfo.slot];
3152 nPdu = calcDlTtiReqPduCount(&currDlSlot->dlInfo);
3153 dlTtiReqMsgSize = sizeof(fapi_dl_tti_req_t) + (nPdu * \
3154 sizeof(fapi_dl_tti_req_pdu_t));
3157 if(currDlSlot->dlInfo.isBroadcastPres)
3159 if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
3161 dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
3164 if(currDlSlot->dlInfo.rarAlloc != NULLP)
3166 dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
3168 if(currDlSlot->dlInfo.msg4Alloc != NULLP)
3170 dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
3173 LWR_MAC_ALLOC(dlTtiReq, dlTtiReqMsgSize);
3174 if(dlTtiReq != NULLP)
3176 memset(dlTtiReq, 0, dlTtiReqMsgSize);
3177 dlTtiReq->sfn = dlTtiReqTimingInfo.sfn;
3178 dlTtiReq->slot = dlTtiReqTimingInfo.slot;
3179 dlTtiReq->nPdus = calcDlTtiReqPduCount(&currDlSlot->dlInfo); /* get total Pdus */
3180 nPdu = dlTtiReq->nPdus;
3181 dlTtiReq->nGroup = 0;
3183 if(dlTtiReq->nPdus > 0)
3185 dlTtiReq->pdus = (fapi_dl_tti_req_pdu_t*)(dlTtiReq + \
3186 (sizeof(fapi_dl_tti_req_t) - sizeof(fapi_dl_tti_req_pdu_t*)));
3189 DU_LOG("\nLWR_MAC: Memory allocation failed");
3193 if(currDlSlot->dlInfo.isBroadcastPres)
3195 if(currDlSlot->dlInfo.brdcstAlloc.ssbTrans)
3197 if(dlTtiReq->pdus != NULLP)
3199 for(idx = 0; idx < currDlSlot->dlInfo.brdcstAlloc.ssbIdxSupported; idx++)
3201 fillSsbPdu(&dlTtiReq->pdus[numPduEncoded], &macCellCfg,\
3202 currDlSlot, &msgLen, idx, dlTtiReq->sfn);
3206 printf("\033[1;31m");
3207 DU_LOG("\nLWR_MAC: MIB sent..");
3210 if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
3212 /* Filling SIB1 param */
3213 if(numPduEncoded != nPdu)
3215 rntiType = SI_RNTI_TYPE;
3216 fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo,\
3219 fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
3220 &currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdschCfg,
3221 currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.bwp,
3226 printf("\033[1;34m");
3227 DU_LOG("\nLWR_MAC: SIB1 sent...");
3231 if(currDlSlot->dlInfo.rarAlloc != NULLP)
3233 /* Filling RAR param */
3234 rntiType = RA_RNTI_TYPE;
3235 fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
3236 &currDlSlot->dlInfo, &msgLen, rntiType);
3238 fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
3239 &currDlSlot->dlInfo.rarAlloc->rarPdschCfg,
3240 currDlSlot->dlInfo.rarAlloc->bwp,
3245 printf("\033[1;32m");
3246 DU_LOG("\nLWR_MAC: RAR sent...");
3249 if(currDlSlot->dlInfo.msg4Alloc != NULLP)
3251 /* Filling Msg4 param */
3252 rntiType = TC_RNTI_TYPE;
3253 fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
3254 &currDlSlot->dlInfo, &msgLen, rntiType);
3256 fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
3257 &currDlSlot->dlInfo.msg4Alloc->msg4PdschCfg,
3258 currDlSlot->dlInfo.msg4Alloc->bwp,
3263 printf("\033[1;32m");
3264 DU_LOG("\nLWR_MAC: MSG4 sent...");
3267 msgLen += sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
3268 fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
3269 LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, \
3272 /* send Tx-DATA req message */
3273 sendTxDataReq(currTimingInfo, &currDlSlot->dlInfo);
3277 msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
3278 fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
3279 LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, (void *)dlTtiReq);
3285 DU_LOG("\nLWR_MAC: Failed to allocate memory for DL TTI Request");
3291 lwr_mac_handleInvalidEvt(&currTimingInfo);
3298 /*******************************************************************
3300 * @brief Sends TX data Request to PHY
3304 * Function : sendTxDataReq
3307 * -Sends FAPI TX data req to PHY
3309 * @params[in] timing info
3310 * @return ROK - success
3313 * ****************************************************************/
3314 uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo)
3318 uint32_t msgLen = 0;
3319 uint16_t pduIndex = 0;
3320 uint32_t txDataReqMsgSize = 0;
3321 fapi_tx_data_req_t *txDataReq = NULLP;
3324 /* send TX_Data request message */
3325 nPdu = calcTxDataReqPduCount(dlInfo);
3328 txDataReqMsgSize = sizeof(fapi_tx_data_req_t) + \
3329 (nPdu * sizeof(fapi_tx_pdu_desc_t));
3330 if(dlInfo->brdcstAlloc.sib1Trans)
3332 txDataReqMsgSize += rgCb[inst].cell->macCellCfg.sib1Cfg.sib1PduLen;
3334 if(dlInfo->rarAlloc != NULLP)
3336 txDataReqMsgSize += dlInfo->rarAlloc->rarInfo.rarPduLen;
3338 if(dlInfo->msg4Alloc != NULLP)
3340 txDataReqMsgSize += dlInfo->msg4Alloc->msg4Info.msg4PduLen;
3343 LWR_MAC_ALLOC(txDataReq, txDataReqMsgSize);
3344 if(txDataReq == NULLP)
3346 DU_LOG("\nLWR_MAC: Failed to allocate memory for TX data Request");
3350 memset(txDataReq, 0, txDataReqMsgSize);
3351 txDataReq->sfn = currTimingInfo.sfn;
3352 txDataReq->slot = currTimingInfo.slot;
3353 txDataReq->pduDesc = (fapi_tx_pdu_desc_t *)(txDataReq + \
3354 (sizeof(fapi_tx_data_req_t) - sizeof(fapi_tx_pdu_desc_t *)));
3356 if(dlInfo->brdcstAlloc.sib1Trans)
3358 fillSib1TxDataReq(txDataReq->pduDesc,
3359 &rgCb[inst].cell->macCellCfg, &msgLen, pduIndex);
3361 txDataReq->numPdus++;
3363 if(dlInfo->rarAlloc != NULLP)
3365 fillRarTxDataReq(txDataReq->pduDesc, &dlInfo->rarAlloc->rarInfo, &msgLen, pduIndex);
3367 txDataReq->numPdus++;
3369 MAC_FREE(dlInfo->rarAlloc,sizeof(RarAlloc));
3370 dlInfo->rarAlloc = NULLP;
3372 if(dlInfo->msg4Alloc != NULLP)
3374 fillMsg4TxDataReq(txDataReq->pduDesc, &dlInfo->msg4Alloc->\
3375 msg4Info, &msgLen, pduIndex);
3377 txDataReq->numPdus++;
3379 MAC_FREE(dlInfo->msg4Alloc,sizeof(Msg4Alloc));
3380 dlInfo->msg4Alloc = NULLP;
3382 msgLen += sizeof(fapi_tx_data_req_t) - sizeof(fapi_msg_t);
3383 fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, msgLen);
3384 LwrMacSendToPhy(txDataReq->header.message_type_id, txDataReqMsgSize, \
3391 /***********************************************************************
3393 * @brief calculates the total size to be allocated for UL TTI Req
3397 * Function : getnPdus
3400 * -calculates the total pdu count to be allocated for UL TTI Req
3402 * @params[in] Pointer to fapi Ul TTI Req
3403 * Pointer to CurrUlSlot
3405 * ********************************************************************/
3407 uint8_t getnPdus(fapi_ul_tti_req_t *ulTtiReq, MacUlSlot *currUlSlot)
3409 uint8_t pduCount = 0;
3411 if(currUlSlot != NULLP)
3413 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH)
3417 ulTtiReq->rachPresent = PDU_PRESENT;
3419 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH)
3425 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH_UCI)
3429 ulTtiReq->nUlsch = PDU_PRESENT;
3431 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_UCI)
3435 ulTtiReq->nUlcch = PDU_PRESENT;
3437 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_SRS)
3446 /***********************************************************************
3448 * @brief Set the value of zero correlation config in PRACH PDU
3452 * Function : setNumCs
3455 * -Set the value of zero correlation config in PRACH PDU
3457 * @params[in] Pointer to zero correlation config
3458 * Pointer to MacCellCfg
3459 * ********************************************************************/
3461 void setNumCs(uint8_t *numCs, MacCellCfg *macCellCfg)
3465 if(macCellCfg != NULLP)
3467 idx = macCellCfg->prachCfg.fdm[0].zeroCorrZoneCfg;
3468 *numCs = UnrestrictedSetNcsTable[idx];
3473 /***********************************************************************
3475 * @brief Fills the PRACH PDU in UL TTI Request
3479 * Function : fillPrachPdu
3482 * -Fills the PRACH PDU in UL TTI Request
3484 * @params[in] Pointer to Prach Pdu
3485 * Pointer to CurrUlSlot
3486 * Pointer to macCellCfg
3488 * ********************************************************************/
3491 void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, MacUlSlot *currUlSlot, uint32_t *msgLen)
3493 if(ulTtiReqPdu != NULLP)
3495 ulTtiReqPdu->pduType = PRACH_PDU_TYPE;
3496 ulTtiReqPdu->u.prach_pdu.physCellId = macCellCfg->phyCellId;
3497 ulTtiReqPdu->u.prach_pdu.numPrachOcas = currUlSlot->ulInfo.prachSchInfo.numPrachOcas;
3498 ulTtiReqPdu->u.prach_pdu.prachFormat = \
3499 currUlSlot->ulInfo.prachSchInfo.prachFormat;
3500 ulTtiReqPdu->u.prach_pdu.numRa = currUlSlot->ulInfo.prachSchInfo.numRa;
3501 ulTtiReqPdu->u.prach_pdu.prachStartSymbol = \
3502 currUlSlot->ulInfo.prachSchInfo.prachStartSymb;
3503 setNumCs(&ulTtiReqPdu->u.prach_pdu.numCs, macCellCfg);
3504 ulTtiReqPdu->u.prach_pdu.beamforming.numPrgs = 0;
3505 ulTtiReqPdu->u.prach_pdu.beamforming.prgSize = 0;
3506 ulTtiReqPdu->u.prach_pdu.beamforming.digBfInterfaces = 0;
3507 ulTtiReqPdu->u.prach_pdu.beamforming.pmi_bfi[0].pmIdx = 0;
3508 ulTtiReqPdu->u.prach_pdu.beamforming.pmi_bfi[0].beamIdx[0].beamidx = 0;
3509 ulTtiReqPdu->pduSize = sizeof(fapi_ul_prach_pdu_t);
3511 SET_MSG_LEN(*msgLen, (sizeof(ulTtiReqPdu->pduType) + \
3512 sizeof(ulTtiReqPdu->pduSize) + sizeof(fapi_ul_prach_pdu_t)));
3516 void fillPuschPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, MacUlSlot *currUlSlot, uint32_t *msgLen)
3518 if(ulTtiReqPdu != NULLP)
3520 ulTtiReqPdu->pduType = PUSCH_PDU_TYPE;
3521 ulTtiReqPdu->u.pusch_pdu.pduBitMap = 1;
3522 ulTtiReqPdu->u.pusch_pdu.rnti = currUlSlot->ulInfo.crnti;
3523 /* TODO : Fill handle in raCb when scheduling pusch and access here */
3524 ulTtiReqPdu->u.pusch_pdu.handle = 100;
3525 ulTtiReqPdu->u.pusch_pdu.bwpSize = macCellCfg->initialUlBwp.bwp.numPrb;
3526 ulTtiReqPdu->u.pusch_pdu.bwpStart = macCellCfg->initialUlBwp.bwp.firstPrb;
3527 ulTtiReqPdu->u.pusch_pdu.subCarrierSpacing = \
3528 macCellCfg->initialUlBwp.bwp.scs;
3529 ulTtiReqPdu->u.pusch_pdu.cyclicPrefix = \
3530 macCellCfg->initialUlBwp.bwp.cyclicPrefix;
3531 ulTtiReqPdu->u.pusch_pdu.targetCodeRate = 308;
3532 ulTtiReqPdu->u.pusch_pdu.qamModOrder = 2;
3533 ulTtiReqPdu->u.pusch_pdu.mcsIndex = \
3534 currUlSlot->ulInfo.schPuschInfo.tbInfo.mcs;
3535 ulTtiReqPdu->u.pusch_pdu.mcsTable = 0;
3536 ulTtiReqPdu->u.pusch_pdu.transformPrecoding = 1;
3537 ulTtiReqPdu->u.pusch_pdu.dataScramblingId = currUlSlot->ulInfo.cellId;
3538 ulTtiReqPdu->u.pusch_pdu.nrOfLayers = 1;
3539 ulTtiReqPdu->u.pusch_pdu.ulDmrsSymbPos = 4;
3540 ulTtiReqPdu->u.pusch_pdu.dmrsConfigType = 0;
3541 ulTtiReqPdu->u.pusch_pdu.ulDmrsScramblingId = currUlSlot->ulInfo.cellId;
3542 ulTtiReqPdu->u.pusch_pdu.scid = 0;
3543 ulTtiReqPdu->u.pusch_pdu.numDmrsCdmGrpsNoData = 1;
3544 ulTtiReqPdu->u.pusch_pdu.dmrsPorts = 0;
3545 ulTtiReqPdu->u.pusch_pdu.resourceAlloc = \
3546 currUlSlot->ulInfo.schPuschInfo.resAllocType;
3547 ulTtiReqPdu->u.pusch_pdu.rbStart = \
3548 currUlSlot->ulInfo.schPuschInfo.fdAlloc.startPrb;
3549 ulTtiReqPdu->u.pusch_pdu.rbSize = \
3550 currUlSlot->ulInfo.schPuschInfo.fdAlloc.numPrb;
3551 ulTtiReqPdu->u.pusch_pdu.vrbToPrbMapping = 0;
3552 ulTtiReqPdu->u.pusch_pdu.frequencyHopping = 0;
3553 ulTtiReqPdu->u.pusch_pdu.txDirectCurrentLocation = 0;
3554 ulTtiReqPdu->u.pusch_pdu.uplinkFrequencyShift7p5khz = 0;
3555 ulTtiReqPdu->u.pusch_pdu.startSymbIndex = \
3556 currUlSlot->ulInfo.schPuschInfo.tdAlloc.startSymb;
3557 ulTtiReqPdu->u.pusch_pdu.nrOfSymbols = \
3558 currUlSlot->ulInfo.schPuschInfo.tdAlloc.numSymb;
3559 ulTtiReqPdu->u.pusch_pdu.puschData.rvIndex = \
3560 currUlSlot->ulInfo.schPuschInfo.tbInfo.rv;
3561 ulTtiReqPdu->u.pusch_pdu.puschData.harqProcessId = \
3562 currUlSlot->ulInfo.schPuschInfo.harqProcId;
3563 ulTtiReqPdu->u.pusch_pdu.puschData.newDataIndicator = \
3564 currUlSlot->ulInfo.schPuschInfo.tbInfo.ndi;
3565 ulTtiReqPdu->u.pusch_pdu.puschData.tbSize = \
3566 currUlSlot->ulInfo.schPuschInfo.tbInfo.tbSize;
3567 /* numCb is 0 for new transmission */
3568 ulTtiReqPdu->u.pusch_pdu.puschData.numCb = 0;
3570 ulTtiReqPdu->pduSize = sizeof(fapi_ul_pusch_pdu_t);
3572 SET_MSG_LEN(*msgLen, (sizeof(ulTtiReqPdu->pduType) + \
3573 sizeof(ulTtiReqPdu->pduSize) + sizeof(fapi_ul_pusch_pdu_t)));
3578 /*******************************************************************
3580 * @brief Sends UL TTI Request to PHY
3584 * Function : handleUlTtiReq
3587 * -Sends FAPI Param req to PHY
3589 * @params[in] Pointer to CmLteTimingInfo
3590 * @return ROK - success
3593 ******************************************************************/
3594 uint16_t handleUlTtiReq(SlotIndInfo currTimingInfo)
3597 uint8_t pduIdx = -1;
3599 uint32_t msgLen = 0;
3600 uint32_t msgSize = 0;
3602 fapi_ul_tti_req_t *ulTtiReq = NULLP;
3603 SlotIndInfo ulTtiReqTimingInfo;
3605 RgCellCb *cellCbParams = NULLP;
3606 MacUlSlot *currUlSlot = NULLP;
3607 MacCellCfg macCellCfg;
3610 if(clGlobalCp.phyState == PHY_STATE_RUNNING)
3612 cellCbParams = rgCb[inst].cell;
3613 macCellCfg = cellCbParams->macCellCfg;
3616 ADD_DELTA_TO_TIME(currTimingInfo,ulTtiReqTimingInfo,PHY_DELTA);
3618 currUlSlot = &macCb.macCell->ulSlot[ulTtiReqTimingInfo.slot % MAX_SLOT_SUPPORTED];
3619 numPdu = getnPdus(NULL, currUlSlot);
3620 msgSize = sizeof(fapi_ul_tti_req_t) + (numPdu*sizeof(fapi_ul_tti_req_pdu_t));
3621 LWR_MAC_ALLOC(ulTtiReq, msgSize);
3623 if(ulTtiReq != NULLP)
3625 memset(ulTtiReq, 0, msgSize);
3626 ulTtiReq->sfn = currTimingInfo.sfn;
3627 ulTtiReq->slot = currTimingInfo.slot;
3628 ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot);
3629 ulTtiReq->nGroup = 0;
3630 if(ulTtiReq->nPdus > 0)
3632 ulTtiReq->pdus = (fapi_ul_tti_req_pdu_t *)(ulTtiReq + \
3633 (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_ul_tti_req_pdu_t*)));
3634 /* Fill Prach Pdu */
3635 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH)
3638 fillPrachPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
3641 /* Fill PUSCH PDU */
3642 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH)
3645 fillPuschPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
3648 if((currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH) || \
3649 (currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH))
3651 msgLen += (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t));
3652 fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
3654 DU_LOG("\nLWR_MAC: Sending UL TTI Request");
3655 LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq);
3660 msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t);
3661 fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
3663 DU_LOG("\nLWR_MAC: Sending UL TTI Request");
3664 LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq);
3666 memset(&currUlSlot, 0, sizeof(MacUlSlot));
3671 DU_LOG("\nLWR_MAC: Failed to allocate memory for UL TTI Request");
3672 memset(&currUlSlot, 0, sizeof(MacUlSlot));
3678 lwr_mac_handleInvalidEvt(&currTimingInfo);
3684 lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] =
3687 /* PHY_STATE_IDLE */
3688 lwr_mac_handleParamReqEvt,
3689 lwr_mac_handleParamRspEvt,
3690 lwr_mac_handleConfigReqEvt,
3691 lwr_mac_handleConfigRspEvt,
3692 lwr_mac_handleInvalidEvt,
3693 lwr_mac_handleInvalidEvt,
3696 /* PHY_STATE_CONFIGURED */
3697 lwr_mac_handleParamReqEvt,
3698 lwr_mac_handleParamRspEvt,
3699 lwr_mac_handleConfigReqEvt,
3700 lwr_mac_handleConfigRspEvt,
3701 lwr_mac_handleStartReqEvt,
3702 lwr_mac_handleInvalidEvt,
3705 /* PHY_STATE_RUNNING */
3706 lwr_mac_handleInvalidEvt,
3707 lwr_mac_handleInvalidEvt,
3708 lwr_mac_handleConfigReqEvt,
3709 lwr_mac_handleConfigRspEvt,
3710 lwr_mac_handleInvalidEvt,
3711 lwr_mac_handleStopReqEvt,
3715 /*******************************************************************
3717 * @brief Sends message to LWR_MAC Fsm Event Handler
3721 * Function : sendToLowerMac
3724 * -Sends message to LowerMac
3726 * @params[in] Message Type
3732 ******************************************************************/
3733 void sendToLowerMac(uint16_t msgType, uint32_t msgLen, void *msg)
3735 clGlobalCp.event = msgType;
3736 fapiEvtHdlr[clGlobalCp.phyState][clGlobalCp.event](msg);
3738 /**********************************************************************
3740 **********************************************************************/