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 /* fill DMRS Type A Pos */
2035 fillTlvs(&configReq->tlvs[index++], FAPI_DMRS_TYPE_A_POS_TAG, \
2036 sizeof(uint8_t), macCfgParams.dmrsTypeAPos, &msgLen);
2038 fillMsgHeader(&configReq->header, FAPI_CONFIG_REQUEST, msgLen);
2040 DU_LOG("\nLWR_MAC: Sending Config Request to Phy");
2041 LwrMacSendToPhy(configReq->header.message_type_id, configReqSize, (void *)configReq);
2045 DU_LOG("\nLWR_MAC: Failed to allocate memory for config Request");
2051 } /* lwr_mac_handleConfigReqEvt */
2053 /*******************************************************************
2055 * @brief Processes config response from phy
2059 * Function : lwr_mac_handleConfigRspEvt
2062 * Processes config response from phy
2064 * @params[in] FAPI message pointer
2065 * @return ROK - success
2068 * ****************************************************************/
2070 S16 lwr_mac_handleConfigRspEvt(void *msg)
2073 fapi_config_resp_t *configRsp;
2074 configRsp = (fapi_config_resp_t *)msg;
2076 DU_LOG("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, \
2077 clGlobalCp.phyState);
2079 if(configRsp != NULL)
2081 if(configRsp->error_code == MSG_OK)
2083 DU_LOG("\nLWR_MAC: PHY has moved to Configured state \n");
2084 clGlobalCp.phyState = PHY_STATE_CONFIGURED;
2086 * Store config response into an intermediate struture and send to MAC
2087 * Support LC and LWLC for sending config rsp to MAC
2093 DU_LOG("\n LWR_MAC: Invalid error code %d", configRsp->error_code);
2099 DU_LOG("\nLWR_MAC: Config Response received from PHY is NULL");
2105 } /* lwr_mac_handleConfigRspEvt */
2107 /*******************************************************************
2109 * @brief Build and send start request to phy
2113 * Function : lwr_mac_handleStartReqEvt
2116 * Build and send start request to phy
2118 * @params[in] FAPI message pointer
2119 * @return ROK - success
2122 * ****************************************************************/
2123 S16 lwr_mac_handleStartReqEvt(void *msg)
2126 uint32_t msgLen = 0;
2127 fapi_start_req_t *startReq;
2129 LWR_MAC_ALLOC(startReq, sizeof(fapi_start_req_t));
2130 if(startReq != NULL)
2132 fillMsgHeader(&startReq->header, FAPI_START_REQUEST, msgLen);
2134 DU_LOG("\nLWR_MAC: Sending Start Request to PHY");
2135 LwrMacSendToPhy(startReq->header.message_type_id, sizeof(fapi_start_req_t),\
2140 DU_LOG("\nLWR_MAC: Failed to allocate memory for Start Request");
2145 } /* lwr_mac_handleStartReqEvt */
2147 /*******************************************************************
2149 * @brief Sends FAPI Stop Req to PHY
2153 * Function : lwr_mac_handleStopReqEvt
2156 * -Sends FAPI Stop Req to PHY
2159 * @return ROK - success
2162 ********************************************************************/
2164 S16 lwr_mac_handleStopReqEvt(void *msg)
2167 uint32_t msgLen = 0;
2168 fapi_stop_req_t *stopReq = NULLP;
2169 LWR_MAC_ALLOC(stopReq, sizeof(fapi_stop_req_t));
2170 if(stopReq != NULLP)
2172 fillMsgHeader(&stopReq->header, FAPI_STOP_REQUEST, msgLen);
2173 DU_LOG("\nLOWER MAC: Sending Stop Request to PHY");
2174 LwrMacSendToPhy(stopReq->header.message_type_id, sizeof(fapi_stop_req_t), (void *)stopReq);
2178 DU_LOG("\nLOWER MAC: Failed to allocate memory for Stop Request");
2185 /*******************************************************************
2187 * @brief Modifes the received mibPdu to uint32 bit
2188 * and stores it in MacCellCfg
2192 * Function : setMibPdu
2197 * @params[in] Pointer to mibPdu
2198 * pointer to modified value
2199 ******************************************************************/
2201 PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val, uint16_t sfn)
2203 *mibPdu |= (((uint8_t)(sfn >> 2)) & MIB_SFN_BITMASK);
2204 *val = (mibPdu[0] << 24 | mibPdu[1] << 16 | mibPdu[2] << 8);
2205 DU_LOG("\nLWR_MAC: MIB PDU %x", *val);
2209 /*******************************************************************
2211 * @brief fills SSB PDU required for DL TTI info in MAC
2215 * Function : fillSsbPdu
2218 * -Fills the SSB PDU info
2221 * @params[in] Pointer to FAPI DL TTI Req
2222 * Pointer to RgCellCb
2223 * Pointer to msgLen of DL TTI Info
2226 ******************************************************************/
2228 S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg,
2229 MacDlSlot *currDlSlot, uint32_t *msgLen, uint8_t ssbIdxCount, uint16_t sfn)
2231 uint32_t mibPayload = 0;
2232 if(dlTtiReqPdu != NULL)
2234 dlTtiReqPdu->pduType = SSB_PDU_TYPE; /* SSB PDU */
2235 dlTtiReqPdu->u.ssb_pdu.physCellId = macCellCfg->phyCellId;
2236 dlTtiReqPdu->u.ssb_pdu.betaPss = macCellCfg->ssbCfg.betaPss;
2237 dlTtiReqPdu->u.ssb_pdu.ssbBlockIndex = currDlSlot->dlInfo.brdcstAlloc.ssbInfo[ssbIdxCount].ssbIdx;
2238 dlTtiReqPdu->u.ssb_pdu.ssbSubCarrierOffset = macCellCfg->ssbCfg.ssbScOffset;
2239 /* ssbOfPdufstA to be filled in ssbCfg */
2240 dlTtiReqPdu->u.ssb_pdu.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA;
2241 dlTtiReqPdu->u.ssb_pdu.bchPayloadFlag = macCellCfg->ssbCfg.bchPayloadFlag;
2242 /* Bit manipulation for SFN */
2243 setMibPdu(macCellCfg->ssbCfg.mibPdu, &mibPayload, sfn);
2244 dlTtiReqPdu->u.ssb_pdu.bchPayload.v.bchPayload = mibPayload;
2245 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.numPrgs = 0;
2246 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.prgSize = 0;
2247 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.digBfInterfaces = 0;
2248 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.pmi_bfi[0].pmIdx = 0;
2249 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming. \
2250 pmi_bfi[0].beamIdx[0].beamidx = macCellCfg->ssbCfg.beamId[0];
2251 dlTtiReqPdu->pduSize = sizeof(fapi_dl_ssb_pdu_t); /* Size of SSB PDU */
2252 SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \
2253 sizeof(dlTtiReqPdu->pduSize) + sizeof(fapi_dl_ssb_pdu_t)));
2262 /*******************************************************************
2264 * @brief fills Dl DCI PDU required for DL TTI info in MAC
2268 * Function : fillSib1DlDciPdu
2271 * -Fills the Dl DCI PDU
2273 * @params[in] Pointer to fapi_dl_dci_t
2274 * Pointer to PdcchCfg
2277 ******************************************************************/
2279 void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo)
2281 if(dlDciPtr != NULLP)
2287 uint16_t coreset0Size;
2290 uint32_t freqDomResAssign;
2291 uint32_t timeDomResAssign;
2293 uint32_t modNCodScheme;
2294 uint8_t redundancyVer;
2295 uint32_t sysInfoInd;
2298 /* Size(in bits) of each field in DCI format 0_1
2299 * as mentioned in spec 38.214 */
2300 uint8_t freqDomResAssignSize;
2301 uint8_t timeDomResAssignSize = 4;
2302 uint8_t VRB2PRBMapSize = 1;
2303 uint8_t modNCodSchemeSize = 5;
2304 uint8_t redundancyVerSize = 2;
2305 uint8_t sysInfoIndSize = 1;
2306 uint8_t reservedSize = 15;
2308 dlDciPtr->rnti = sib1PdcchInfo->dci.rnti;
2309 dlDciPtr->scramblingId = sib1PdcchInfo->dci.scramblingId;
2310 dlDciPtr->scramblingRnti = sib1PdcchInfo->dci.scramblingRnti;
2311 dlDciPtr->cceIndex = sib1PdcchInfo->dci.cceIndex;
2312 dlDciPtr->aggregationLevel = sib1PdcchInfo->dci.aggregLevel;
2313 dlDciPtr->pc_and_bform.numPrgs = sib1PdcchInfo->dci.beamPdcchInfo.numPrgs;
2314 dlDciPtr->pc_and_bform.prgSize = sib1PdcchInfo->dci.beamPdcchInfo.prgSize;
2315 dlDciPtr->pc_and_bform.digBfInterfaces = sib1PdcchInfo->dci.beamPdcchInfo.digBfInterfaces;
2316 dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = sib1PdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx;
2317 dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = sib1PdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0];
2318 dlDciPtr->beta_pdcch_1_0 = sib1PdcchInfo->dci.txPdcchPower.powerValue;
2319 dlDciPtr->powerControlOfssetSS = sib1PdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
2321 /* Calculating freq domain resource allocation field value and size
2322 * coreset0Size = Size of coreset 0
2323 * RBStart = Starting Virtual Rsource block
2324 * RBLen = length of contiguously allocted RBs
2325 * Spec 38.214 Sec 5.1.2.2.2
2327 coreset0Size= sib1PdcchInfo->coreset0Cfg.coreSet0Size;
2328 rbStart = 0; /* For SIB1 */
2329 //rbStart = sib1PdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.startPrb;
2330 rbLen = sib1PdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.numPrb;
2332 if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
2334 if((rbLen - 1) <= floor(coreset0Size / 2))
2335 freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart;
2337 freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \
2338 + (coreset0Size - 1 - rbStart);
2340 freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2));
2343 /* Fetching DCI field values */
2344 timeDomResAssign = sib1PdcchInfo->dci.pdschCfg->pdschTimeAlloc.
2346 VRB2PRBMap = sib1PdcchInfo->dci.pdschCfg->pdschFreqAlloc.\
2348 modNCodScheme = sib1PdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
2349 redundancyVer = sib1PdcchInfo->dci.pdschCfg->codeword[0].rvIndex;
2350 sysInfoInd = 0; /* 0 for SIB1; 1 for SI messages */
2353 /* Reversing bits in each DCI field */
2354 freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize);
2355 timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
2356 VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize);
2357 modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize);
2358 redundancyVer = reverseBits(redundancyVer, redundancyVerSize);
2359 sysInfoInd = reverseBits(sysInfoInd, sysInfoIndSize);
2361 /* Calulating total number of bytes in buffer */
2362 dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\
2363 + VRB2PRBMapSize + modNCodSchemeSize + redundancyVerSize\
2364 + sysInfoIndSize + reservedSize;
2366 numBytes = dlDciPtr->payloadSizeBits / 8;
2367 if(dlDciPtr->payloadSizeBits % 8)
2370 if(numBytes > DCI_PAYLOAD_BYTE_LEN)
2372 DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
2376 /* Initialize buffer */
2377 for(bytePos = 0; bytePos < numBytes; bytePos++)
2378 dlDciPtr->payload[bytePos] = 0;
2380 bytePos = numBytes - 1;
2383 /* Packing DCI format fields */
2384 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2385 freqDomResAssign, freqDomResAssignSize);
2386 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2387 timeDomResAssign, timeDomResAssignSize);
2388 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2389 VRB2PRBMap, VRB2PRBMapSize);
2390 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2391 modNCodScheme, modNCodSchemeSize);
2392 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2393 redundancyVer, redundancyVerSize);
2394 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2395 sysInfoInd, sysInfoIndSize);
2396 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2397 reserved, reservedSize);
2400 } /* fillSib1DlDciPdu */
2402 /*******************************************************************
2404 * @brief fills Dl DCI PDU required for DL TTI info in MAC
2408 * Function : fillRarDlDciPdu
2411 * -Fills the Dl DCI PDU
2413 * @params[in] Pointer to fapi_dl_dci_t
2414 * Pointer to PdcchCfg
2417 ******************************************************************/
2419 void fillRarDlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *rarPdcchInfo)
2421 if(dlDciPtr != NULLP)
2427 uint16_t coreset0Size;
2430 uint32_t freqDomResAssign;
2431 uint8_t timeDomResAssign;
2433 uint8_t modNCodScheme;
2437 /* Size(in bits) of each field in DCI format 1_0 */
2438 uint8_t freqDomResAssignSize;
2439 uint8_t timeDomResAssignSize = 4;
2440 uint8_t VRB2PRBMapSize = 1;
2441 uint8_t modNCodSchemeSize = 5;
2442 uint8_t tbScalingSize = 2;
2443 uint8_t reservedSize = 16;
2445 dlDciPtr->rnti = rarPdcchInfo->dci.rnti;
2446 dlDciPtr->scramblingId = rarPdcchInfo->dci.scramblingId;
2447 dlDciPtr->scramblingRnti = rarPdcchInfo->dci.scramblingRnti;
2448 dlDciPtr->cceIndex = rarPdcchInfo->dci.cceIndex;
2449 dlDciPtr->aggregationLevel = rarPdcchInfo->dci.aggregLevel;
2450 dlDciPtr->pc_and_bform.numPrgs = rarPdcchInfo->dci.beamPdcchInfo.numPrgs;
2451 dlDciPtr->pc_and_bform.prgSize = rarPdcchInfo->dci.beamPdcchInfo.prgSize;
2452 dlDciPtr->pc_and_bform.digBfInterfaces = rarPdcchInfo->dci.beamPdcchInfo.digBfInterfaces;
2453 dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx;
2454 dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0];
2455 dlDciPtr->beta_pdcch_1_0 = rarPdcchInfo->dci.txPdcchPower.powerValue;
2456 dlDciPtr->powerControlOfssetSS = rarPdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
2458 /* Calculating freq domain resource allocation field value and size
2459 * coreset0Size = Size of coreset 0
2460 * RBStart = Starting Virtual Rsource block
2461 * RBLen = length of contiguously allocted RBs
2462 * Spec 38.214 Sec 5.1.2.2.2
2465 /* TODO: Fill values of coreset0Size, rbStart and rbLen */
2466 coreset0Size= rarPdcchInfo->coreset0Cfg.coreSet0Size;
2467 rbStart = 0; /* For SIB1 */
2468 //rbStart = rarPdcchInfo->dci.pdschCfg->freqAlloc.rbStart;
2469 rbLen = rarPdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.numPrb;
2471 if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
2473 if((rbLen - 1) <= floor(coreset0Size / 2))
2474 freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart;
2476 freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \
2477 + (coreset0Size - 1 - rbStart);
2479 freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2));
2482 /* Fetching DCI field values */
2483 timeDomResAssign = rarPdcchInfo->dci.pdschCfg->pdschTimeAlloc.rowIndex -1;
2484 VRB2PRBMap = rarPdcchInfo->dci.pdschCfg->pdschFreqAlloc.vrbPrbMapping;
2485 modNCodScheme = rarPdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
2486 tbScaling = 0; /* configured to 0 scaling */
2489 /* Reversing bits in each DCI field */
2490 freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize);
2491 timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
2492 VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize);
2493 modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize);
2494 tbScaling = reverseBits(tbScaling, tbScalingSize);
2496 /* Calulating total number of bytes in buffer */
2497 dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\
2498 + VRB2PRBMapSize + modNCodSchemeSize + tbScalingSize + reservedSize;
2500 numBytes = dlDciPtr->payloadSizeBits / 8;
2501 if(dlDciPtr->payloadSizeBits % 8)
2504 if(numBytes > DCI_PAYLOAD_BYTE_LEN)
2506 DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
2510 /* Initialize buffer */
2511 for(bytePos = 0; bytePos < numBytes; bytePos++)
2512 dlDciPtr->payload[bytePos] = 0;
2514 bytePos = numBytes - 1;
2517 /* Packing DCI format fields */
2518 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2519 freqDomResAssign, freqDomResAssignSize);
2520 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2521 timeDomResAssign, timeDomResAssignSize);
2522 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2523 VRB2PRBMap, VRB2PRBMapSize);
2524 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2525 modNCodScheme, modNCodSchemeSize);
2526 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2527 tbScaling, tbScalingSize);
2528 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2529 reserved, reservedSize);
2531 } /* fillRarDlDciPdu */
2533 /*******************************************************************
2535 * @brief fills msg4 Dl DCI PDU required for DL TTI info in MAC
2539 * Function : fillMsg4DlDciPdu
2542 * -Fills the Msg4 Dl DCI PDU
2544 * @params[in] Pointer to fapi_dl_dci_t
2545 * Pointer to PdcchCfg
2548 ******************************************************************/
2549 void fillMsg4DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *msg4PdcchInfo,\
2552 if(dlDciPtr != NULLP)
2558 uint16_t coreset0Size = 0;
2559 uint16_t rbStart = 0;
2561 uint8_t dciFormatId;
2562 uint32_t freqDomResAssign;
2563 uint8_t timeDomResAssign;
2565 uint8_t modNCodScheme;
2567 uint8_t redundancyVer = 0;
2568 uint8_t harqProcessNum = 0;
2569 uint8_t dlAssignmentIdx = 0;
2570 uint8_t pucchTpc = 0;
2571 uint8_t pucchResoInd = 0;
2572 uint8_t harqFeedbackInd = 0;
2574 /* Size(in bits) of each field in DCI format 1_0 */
2575 uint8_t dciFormatIdSize = 1;
2576 uint8_t freqDomResAssignSize;
2577 uint8_t timeDomResAssignSize = 4;
2578 uint8_t VRB2PRBMapSize = 1;
2579 uint8_t modNCodSchemeSize = 5;
2580 uint8_t ndiSize = 1;
2581 uint8_t redundancyVerSize = 2;
2582 uint8_t harqProcessNumSize = 4;
2583 uint8_t dlAssignmentIdxSize = 2;
2584 uint8_t pucchTpcSize = 2;
2585 uint8_t pucchResoIndSize = 3;
2586 uint8_t harqFeedbackIndSize = 3;
2588 dlDciPtr->rnti = msg4PdcchInfo->dci.rnti;
2589 dlDciPtr->scramblingId = msg4PdcchInfo->dci.scramblingId;
2590 dlDciPtr->scramblingRnti = msg4PdcchInfo->dci.scramblingRnti;
2591 dlDciPtr->cceIndex = msg4PdcchInfo->dci.cceIndex;
2592 dlDciPtr->aggregationLevel = msg4PdcchInfo->dci.aggregLevel;
2593 dlDciPtr->pc_and_bform.numPrgs = msg4PdcchInfo->dci.beamPdcchInfo.numPrgs;
2594 dlDciPtr->pc_and_bform.prgSize = msg4PdcchInfo->dci.beamPdcchInfo.prgSize;
2595 dlDciPtr->pc_and_bform.digBfInterfaces = msg4PdcchInfo->dci.beamPdcchInfo.digBfInterfaces;
2596 dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = msg4PdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx;
2597 dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = msg4PdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0];
2598 dlDciPtr->beta_pdcch_1_0 = msg4PdcchInfo->dci.txPdcchPower.powerValue;
2599 dlDciPtr->powerControlOfssetSS = msg4PdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
2601 /* Calculating freq domain resource allocation field value and size
2602 * coreset0Size = Size of coreset 0
2603 * RBStart = Starting Virtual Rsource block
2604 * RBLen = length of contiguously allocted RBs
2605 * Spec 38.214 Sec 5.1.2.2.2
2608 /* TODO: Fill values of coreset0Size, rbStart and rbLen */
2609 coreset0Size = msg4PdcchInfo->coreset0Cfg.coreSet0Size;
2610 //rbStart = msg4PdcchInfo->dci.pdschCfg->freqAlloc.rbStart;
2611 rbLen = msg4PdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.numPrb;
2613 if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
2615 if((rbLen - 1) <= floor(coreset0Size / 2))
2616 freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart;
2618 freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \
2619 + (coreset0Size - 1 - rbStart);
2621 freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2));
2624 /* Fetching DCI field values */
2625 dciFormatId = msg4Info->dciFormatId; /* DCI indentifier for DL */
2626 timeDomResAssign = msg4PdcchInfo->dci.pdschCfg->pdschTimeAlloc.rowIndex -1;
2627 VRB2PRBMap = msg4PdcchInfo->dci.pdschCfg->pdschFreqAlloc.vrbPrbMapping;
2628 modNCodScheme = msg4PdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
2629 ndi = msg4Info->ndi;
2630 redundancyVer = msg4PdcchInfo->dci.pdschCfg->codeword[0].rvIndex;
2631 harqProcessNum = msg4Info->harqProcNum;
2632 dlAssignmentIdx = msg4Info->dlAssignIdx;
2633 pucchTpc = msg4Info->pucchTpc;
2634 pucchResoInd = msg4Info->pucchResInd;
2635 harqFeedbackInd = msg4Info->harqFeedbackInd;
2637 /* Reversing bits in each DCI field */
2638 dciFormatId = reverseBits(dciFormatId, dciFormatIdSize);
2639 freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize);
2640 timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
2641 VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize);
2642 modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize);
2643 ndi = reverseBits(ndi, ndiSize);
2644 redundancyVer = reverseBits(redundancyVer, redundancyVerSize);
2645 harqProcessNum = reverseBits(harqProcessNum, harqProcessNumSize);
2646 dlAssignmentIdx = reverseBits(dlAssignmentIdx , dlAssignmentIdxSize);
2647 pucchTpc = reverseBits(pucchTpc, pucchTpcSize);
2648 pucchResoInd = reverseBits(pucchResoInd, pucchResoIndSize);
2649 harqFeedbackInd = reverseBits(harqFeedbackInd, harqFeedbackIndSize);
2652 /* Calulating total number of bytes in buffer */
2653 dlDciPtr->payloadSizeBits = (dciFormatIdSize + freqDomResAssignSize\
2654 + timeDomResAssignSize + VRB2PRBMapSize + modNCodSchemeSize\
2655 + ndiSize + redundancyVerSize + harqProcessNumSize + dlAssignmentIdxSize\
2656 + pucchTpcSize + pucchResoIndSize + harqFeedbackIndSize);
2658 numBytes = dlDciPtr->payloadSizeBits / 8;
2659 if(dlDciPtr->payloadSizeBits % 8)
2662 if(numBytes > DCI_PAYLOAD_BYTE_LEN)
2664 DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
2668 /* Initialize buffer */
2669 for(bytePos = 0; bytePos < numBytes; bytePos++)
2670 dlDciPtr->payload[bytePos] = 0;
2672 bytePos = numBytes - 1;
2675 /* Packing DCI format fields */
2676 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2677 dciFormatId, dciFormatIdSize);
2678 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2679 freqDomResAssign, freqDomResAssignSize);
2680 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2681 timeDomResAssign, timeDomResAssignSize);
2682 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2683 VRB2PRBMap, VRB2PRBMapSize);
2684 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2685 modNCodScheme, modNCodSchemeSize);
2686 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2688 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2689 redundancyVer, redundancyVerSize);
2690 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2691 redundancyVer, redundancyVerSize);
2692 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2693 harqProcessNum, harqProcessNumSize);
2694 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2695 dlAssignmentIdx, dlAssignmentIdxSize);
2696 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2697 pucchTpc, pucchTpcSize);
2698 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2699 pucchResoInd, pucchResoIndSize);
2700 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2701 harqFeedbackInd, harqFeedbackIndSize);
2703 } /* fillMsg4DlDciPdu */
2705 /*******************************************************************
2707 * @brief fills PDCCH PDU required for DL TTI info in MAC
2711 * Function : fillPdcchPdu
2714 * -Fills the Pdcch PDU info
2717 * @params[in] Pointer to FAPI DL TTI Req
2718 * Pointer to PdcchCfg
2719 * Pointer to msgLen of DL TTI Info
2722 ******************************************************************/
2723 S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlSchedInfo *dlInfo, uint32_t *msgLen, RntiType rntiType)
2725 if(dlTtiReqPdu != NULLP)
2727 PdcchCfg *pdcchInfo = NULLP;
2728 BwpCfg *bwp = NULLP;
2730 dlTtiReqPdu->u.pdcch_pdu.dlDci = (fapi_dl_dci_t *)(dlTtiReqPdu + \
2731 (sizeof(fapi_dl_tti_req_pdu_t) - sizeof(dlTtiReqPdu->u)) + \
2732 (sizeof(fapi_dl_pdcch_pdu_t) - sizeof(fapi_dl_dci_t*)));
2734 if(rntiType == SI_RNTI_TYPE)
2736 pdcchInfo = &dlInfo->brdcstAlloc.sib1Alloc.sib1PdcchCfg;
2737 bwp = &dlInfo->brdcstAlloc.sib1Alloc.bwp;
2738 fillSib1DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo);
2740 else if(rntiType == RA_RNTI_TYPE)
2742 pdcchInfo = &dlInfo->rarAlloc->rarPdcchCfg;
2743 bwp = &dlInfo->rarAlloc->bwp;
2744 fillRarDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo);
2746 else if(rntiType == TC_RNTI_TYPE)
2748 pdcchInfo = &dlInfo->msg4Alloc->msg4PdcchCfg;
2749 bwp = &dlInfo->msg4Alloc->bwp;
2750 fillMsg4DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo,\
2751 &dlInfo->msg4Alloc->msg4Info);
2755 DU_LOG("\nLWR_MAC: Failed filling PDCCH Pdu");
2758 dlTtiReqPdu->pduType = PDCCH_PDU_TYPE;
2759 dlTtiReqPdu->u.pdcch_pdu.bwpSize = bwp->freqAlloc.numPrb;
2760 dlTtiReqPdu->u.pdcch_pdu.bwpPart = bwp->freqAlloc.startPrb;
2761 dlTtiReqPdu->u.pdcch_pdu.subCarrierSpacing = bwp->subcarrierSpacing;
2762 dlTtiReqPdu->u.pdcch_pdu.cyclicPrefix = bwp->cyclicPrefix;
2763 dlTtiReqPdu->u.pdcch_pdu.startSymbolIndex = pdcchInfo->coreset0Cfg.startSymbolIndex;
2764 dlTtiReqPdu->u.pdcch_pdu.durationSymbols = pdcchInfo->coreset0Cfg.durationSymbols;
2765 memcpy(dlTtiReqPdu->u.pdcch_pdu.freqDomainResource, pdcchInfo->coreset0Cfg.freqDomainResource, 6);
2766 dlTtiReqPdu->u.pdcch_pdu.cceRegMappingType = pdcchInfo->coreset0Cfg.cceRegMappingType;
2767 dlTtiReqPdu->u.pdcch_pdu.regBundleSize = pdcchInfo->coreset0Cfg.regBundleSize;
2768 dlTtiReqPdu->u.pdcch_pdu.interleaverSize = pdcchInfo->coreset0Cfg.interleaverSize;
2769 dlTtiReqPdu->u.pdcch_pdu.coreSetSize = pdcchInfo->coreset0Cfg.coreSetType;
2770 dlTtiReqPdu->u.pdcch_pdu.shiftIndex = pdcchInfo->coreset0Cfg.shiftIndex;
2771 dlTtiReqPdu->u.pdcch_pdu.precoderGranularity = pdcchInfo->coreset0Cfg.precoderGranularity;
2772 dlTtiReqPdu->u.pdcch_pdu.numDlDci = pdcchInfo->numDlDci;
2774 /* Calculating PDU length. Considering only one dl dci pdu for now */
2775 dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t) + sizeof(fapi_dl_dci_t);
2776 SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \
2777 sizeof(dlTtiReqPdu->pduSize) + dlTtiReqPdu->pduSize));
2784 /*******************************************************************
2786 * @brief fills PDSCH PDU required for DL TTI info in MAC
2790 * Function : fillPdschPdu
2793 * -Fills the Pdsch PDU info
2796 * @params[in] Pointer to FAPI DL TTI Req
2797 * Pointer to PdschCfg
2798 * Pointer to msgLen of DL TTI Info
2801 ******************************************************************/
2803 void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdschCfg *pdschInfo,
2804 BwpCfg bwp,uint32_t *msgLen, uint16_t pduIndex)
2808 if(dlTtiReqPdu != NULLP)
2810 dlTtiReqPdu->pduType = PDSCH_PDU_TYPE;
2811 dlTtiReqPdu->u.pdsch_pdu.pduBitMap = pdschInfo->pduBitmap;
2812 dlTtiReqPdu->u.pdsch_pdu.rnti = pdschInfo->rnti;
2813 dlTtiReqPdu->u.pdsch_pdu.pduIndex = pduIndex;
2814 dlTtiReqPdu->u.pdsch_pdu.bwpSize = bwp.freqAlloc.numPrb;
2815 dlTtiReqPdu->u.pdsch_pdu.bwpStart = bwp.freqAlloc.startPrb;
2816 dlTtiReqPdu->u.pdsch_pdu.subCarrierSpacing = bwp.subcarrierSpacing;
2817 dlTtiReqPdu->u.pdsch_pdu.cyclicPrefix = bwp.cyclicPrefix;
2818 dlTtiReqPdu->u.pdsch_pdu.nrOfCodeWords = pdschInfo->numCodewords;
2819 for(idx = 0; idx < MAX_CODEWORDS ; idx++)
2821 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].targetCodeRate = pdschInfo->codeword[idx].targetCodeRate;
2822 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].qamModOrder = pdschInfo->codeword[idx].qamModOrder;
2823 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsIndex = pdschInfo->codeword[idx].mcsIndex;
2824 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsTable = pdschInfo->codeword[idx].mcsTable;
2825 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].rvIndex = pdschInfo->codeword[idx].rvIndex;
2826 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].tbSize = pdschInfo->codeword[idx].tbSize;
2828 dlTtiReqPdu->u.pdsch_pdu.dataScramblingId = pdschInfo->dataScramblingId;
2829 dlTtiReqPdu->u.pdsch_pdu.nrOfLayers = pdschInfo->numLayers;
2830 dlTtiReqPdu->u.pdsch_pdu.transmissionScheme = pdschInfo->transmissionScheme;
2831 dlTtiReqPdu->u.pdsch_pdu.refPoint = pdschInfo->refPoint;
2832 dlTtiReqPdu->u.pdsch_pdu.dlDmrsSymbPos = pdschInfo->dmrs.dlDmrsSymbPos;
2833 dlTtiReqPdu->u.pdsch_pdu.dmrsConfigType = pdschInfo->dmrs.dmrsConfigType;
2834 dlTtiReqPdu->u.pdsch_pdu.dlDmrsScramblingId = pdschInfo->dmrs.dlDmrsScramblingId;
2835 dlTtiReqPdu->u.pdsch_pdu.scid = pdschInfo->dmrs.scid;
2836 dlTtiReqPdu->u.pdsch_pdu.numDmrsCdmGrpsNoData = pdschInfo->dmrs.numDmrsCdmGrpsNoData;
2837 dlTtiReqPdu->u.pdsch_pdu.dmrsPorts = pdschInfo->dmrs.dmrsPorts;
2838 dlTtiReqPdu->u.pdsch_pdu.resourceAlloc = pdschInfo->pdschFreqAlloc.resourceAllocType;
2839 /* since we are using type-1, hence rbBitmap excluded */
2840 dlTtiReqPdu->u.pdsch_pdu.rbStart = pdschInfo->pdschFreqAlloc.freqAlloc.startPrb;
2841 dlTtiReqPdu->u.pdsch_pdu.rbSize = pdschInfo->pdschFreqAlloc.freqAlloc.numPrb;
2842 dlTtiReqPdu->u.pdsch_pdu.vrbToPrbMapping = pdschInfo->pdschFreqAlloc.vrbPrbMapping;
2843 dlTtiReqPdu->u.pdsch_pdu.startSymbIndex = pdschInfo->pdschTimeAlloc.timeAlloc.startSymb;
2844 dlTtiReqPdu->u.pdsch_pdu.nrOfSymbols = pdschInfo->pdschTimeAlloc.timeAlloc.numSymb;
2845 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.numPrgs = pdschInfo->beamPdschInfo.numPrgs;
2846 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.prgSize = pdschInfo->beamPdschInfo.prgSize;
2847 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = pdschInfo->beamPdschInfo.digBfInterfaces;
2848 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
2849 pmIdx = pdschInfo->beamPdschInfo.prg[0].pmIdx;
2850 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
2851 beamIdx[0].beamidx = pdschInfo->beamPdschInfo.prg[0].beamIdx[0];
2852 dlTtiReqPdu->u.pdsch_pdu.powerControlOffset = pdschInfo->txPdschPower.powerControlOffset;
2853 dlTtiReqPdu->u.pdsch_pdu.powerControlOffsetSS = pdschInfo->txPdschPower.powerControlOffsetSS;
2854 dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdsch_pdu_t);
2856 SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \
2857 sizeof(dlTtiReqPdu->pduSize) + sizeof(fapi_dl_pdsch_pdu_t)));
2863 /***********************************************************************
2865 * @brief calculates the total size to be allocated for DL TTI Req
2869 * Function : calcDlTtiReqPduCount
2872 * -calculates the total pdu count to be allocated for DL TTI Req
2874 * @params[in] DlBrdcstAlloc *cellBroadcastInfo
2877 * ********************************************************************/
2878 uint8_t calcDlTtiReqPduCount(DlSchedInfo *dlInfo)
2883 if(dlInfo->isBroadcastPres)
2885 if(dlInfo->brdcstAlloc.ssbTrans)
2887 for(idx = 0; idx < dlInfo->brdcstAlloc.ssbIdxSupported; idx++)
2889 /* SSB PDU is filled */
2893 if(dlInfo->brdcstAlloc.sib1Trans)
2895 /* PDCCH and PDSCH PDU is filled */
2899 if(dlInfo->rarAlloc != NULLP)
2901 /* PDCCH and PDSCH PDU is filled */
2904 if(dlInfo->msg4Alloc != NULLP)
2906 /* PDCCH and PDSCH PDU is filled */
2913 /***********************************************************************
2915 * @brief calculates the total size to be allocated for DL TTI Req
2919 * Function : calcTxDataReqPduCount
2922 * -calculates the total pdu count to be allocated for DL TTI Req
2924 * @params[in] DlBrdcstAlloc *cellBroadcastInfo
2927 * ********************************************************************/
2928 uint8_t calcTxDataReqPduCount(DlSchedInfo *dlInfo)
2932 if(dlInfo->isBroadcastPres && dlInfo->brdcstAlloc.sib1Trans)
2936 if(dlInfo->rarAlloc != NULLP)
2940 if(dlInfo->msg4Alloc != NULLP)
2947 /***********************************************************************
2949 * @brief fills the SIB1 TX-DATA request message
2953 * Function : fillSib1TxDataReq
2956 * - fills the SIB1 TX-DATA request message
2958 * @params[in] fapi_tx_pdu_desc_t *pduDesc
2959 * @params[in] macCellCfg consist of SIB1 pdu
2960 * @params[in] uint32_t *msgLen
2961 * @params[in] uint16_t pduIndex
2964 * ********************************************************************/
2965 uint8_t fillSib1TxDataReq(fapi_tx_pdu_desc_t *pduDesc,MacCellCfg *macCellCfg,
2966 uint32_t *msgLen, uint16_t pduIndex)
2968 uint32_t pduLen = 0;
2969 uint32_t *sib1TxdataValue = NULLP;
2971 pduDesc[pduIndex].pduIndex = pduIndex;
2972 pduDesc[pduIndex].numTlvs = 1;
2975 /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */
2976 pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */
2977 pduDesc[pduIndex].tlvs[0].tl.length = macCellCfg->sib1Cfg.sib1PduLen;
2978 LWR_MAC_ALLOC(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen);
2979 if(sib1TxdataValue == NULLP)
2983 memcpy(sib1TxdataValue,macCellCfg->sib1Cfg.sib1Pdu,
2984 macCellCfg->sib1Cfg.sib1PduLen);
2985 pduDesc[pduIndex].tlvs[0].value = sib1TxdataValue;
2987 /* The total length of the PDU description and PDU data */
2988 pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */
2989 pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */
2990 pduDesc[pduIndex].pduLength = pduLen;
2994 MAC_FREE(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen);
3000 /***********************************************************************
3002 * @brief fills the RAR TX-DATA request message
3006 * Function : fillRarTxDataReq
3009 * - fills the RAR TX-DATA request message
3011 * @params[in] fapi_tx_pdu_desc_t *pduDesc
3012 * @params[in] RarInfo *rarInfo
3013 * @params[in] uint32_t *msgLen
3014 * @params[in] uint16_t pduIndex
3017 * ********************************************************************/
3018 uint8_t fillRarTxDataReq(fapi_tx_pdu_desc_t *pduDesc, RarInfo *rarInfo,
3019 uint32_t *msgLen, uint16_t pduIndex)
3021 uint32_t pduLen = 0;
3022 uint32_t *rarTxdataValue = NULLP;
3024 pduDesc[pduIndex].pduIndex = pduIndex;
3025 pduDesc[pduIndex].numTlvs = 1;
3028 /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */
3029 pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */
3030 pduDesc[pduIndex].tlvs[0].tl.length = rarInfo->rarPduLen;
3031 LWR_MAC_ALLOC(rarTxdataValue,rarInfo->rarPduLen);
3032 if(rarTxdataValue == NULLP)
3036 memcpy(rarTxdataValue,rarInfo->rarPdu,rarInfo->rarPduLen);
3037 pduDesc[pduIndex].tlvs[0].value = (uint32_t)rarTxdataValue;
3039 /* The total length of the PDU description and PDU data */
3040 pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */
3041 pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */
3042 pduDesc[pduIndex].pduLength = pduLen;
3045 /* TODO: The pointer value which was stored, needs to be free-ed at PHY *
3046 * But since we did not implement WLS, this has to be done here
3049 MAC_FREE(rarTxdataValue,rarInfo->rarPduLen);
3055 /***********************************************************************
3057 * @brief fills the Msg4 TX-DATA request message
3061 * Function : fillMsg4TxDataReq
3064 * - fills the Msg4 TX-DATA request message
3066 * @params[in] fapi_tx_pdu_desc_t *pduDesc
3067 * @params[in] Msg4Info *msg4Info
3068 * @params[in] uint32_t *msgLen
3069 * @params[in] uint16_t pduIndex
3072 * ********************************************************************/
3073 uint8_t fillMsg4TxDataReq(fapi_tx_pdu_desc_t *pduDesc, Msg4Info *msg4Info,
3074 uint32_t *msgLen, uint16_t pduIndex)
3076 uint32_t pduLen = 0;
3077 uint32_t *msg4TxDataValue = NULLP;
3079 pduDesc[pduIndex].pduIndex = pduIndex;
3080 pduDesc[pduIndex].numTlvs = 1;
3083 /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */
3084 pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */
3085 pduDesc[pduIndex].tlvs[0].tl.length = msg4Info->msg4PduLen;
3086 LWR_MAC_ALLOC(msg4TxDataValue, msg4Info->msg4PduLen);
3087 if(msg4TxDataValue == NULLP)
3091 memcpy(msg4TxDataValue, msg4Info->msg4Pdu, msg4Info->msg4PduLen);
3092 pduDesc[pduIndex].tlvs[0].value = (uint32_t)msg4TxDataValue;
3094 /* The total length of the PDU description and PDU data */
3095 pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */
3096 pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */
3097 pduDesc[pduIndex].pduLength = pduLen;
3100 /* TODO: The pointer value which was stored, needs to be free-ed at PHY *
3101 * But since we did not implement WLS, this has to be done here
3104 MAC_FREE(msg4TxDataValue, msg4Info->msg4PduLen);
3111 /*******************************************************************
3113 * @brief Sends DL TTI Request to PHY
3117 * Function : handleDlTtiReq
3120 * -Sends FAPI DL TTI req to PHY
3122 * @params[in] timing info
3123 * @return ROK - success
3126 * ****************************************************************/
3127 uint16_t handleDlTtiReq(SlotIndInfo currTimingInfo)
3132 uint8_t numPduEncoded = 0;
3133 uint16_t pduIndex = 0;
3134 uint32_t msgLen = 0;
3135 uint32_t dlTtiReqMsgSize = 0;
3137 fapi_dl_tti_req_t *dlTtiReq = NULLP;
3138 SlotIndInfo dlTtiReqTimingInfo;
3140 RgCellCb *cellCbParams = NULLP;
3141 MacDlSlot *currDlSlot = NULLP;
3142 MacCellCfg macCellCfg;
3143 memset(&macCellCfg, 0, sizeof(MacCellCfg));
3147 if(clGlobalCp.phyState == PHY_STATE_RUNNING)
3149 /* consider phy delay */
3150 ADD_DELTA_TO_TIME(currTimingInfo,dlTtiReqTimingInfo,PHY_DELTA);
3152 cellCbParams = rgCb[inst].cell;
3153 macCellCfg = cellCbParams->macCellCfg;
3155 currDlSlot = &macCb.macCell->dlSlot[dlTtiReqTimingInfo.slot];
3156 nPdu = calcDlTtiReqPduCount(&currDlSlot->dlInfo);
3157 dlTtiReqMsgSize = sizeof(fapi_dl_tti_req_t) + (nPdu * \
3158 sizeof(fapi_dl_tti_req_pdu_t));
3161 if(currDlSlot->dlInfo.isBroadcastPres)
3163 if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
3165 dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
3168 if(currDlSlot->dlInfo.rarAlloc != NULLP)
3170 dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
3172 if(currDlSlot->dlInfo.msg4Alloc != NULLP)
3174 dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
3177 LWR_MAC_ALLOC(dlTtiReq, dlTtiReqMsgSize);
3178 if(dlTtiReq != NULLP)
3180 memset(dlTtiReq, 0, dlTtiReqMsgSize);
3181 dlTtiReq->sfn = dlTtiReqTimingInfo.sfn;
3182 dlTtiReq->slot = dlTtiReqTimingInfo.slot;
3183 dlTtiReq->nPdus = calcDlTtiReqPduCount(&currDlSlot->dlInfo); /* get total Pdus */
3184 nPdu = dlTtiReq->nPdus;
3185 dlTtiReq->nGroup = 0;
3187 if(dlTtiReq->nPdus > 0)
3189 dlTtiReq->pdus = (fapi_dl_tti_req_pdu_t*)(dlTtiReq + \
3190 (sizeof(fapi_dl_tti_req_t) - sizeof(fapi_dl_tti_req_pdu_t*)));
3193 DU_LOG("\nLWR_MAC: Memory allocation failed");
3197 if(currDlSlot->dlInfo.isBroadcastPres)
3199 if(currDlSlot->dlInfo.brdcstAlloc.ssbTrans)
3201 if(dlTtiReq->pdus != NULLP)
3203 for(idx = 0; idx < currDlSlot->dlInfo.brdcstAlloc.ssbIdxSupported; idx++)
3205 fillSsbPdu(&dlTtiReq->pdus[numPduEncoded], &macCellCfg,\
3206 currDlSlot, &msgLen, idx, dlTtiReq->sfn);
3210 printf("\033[1;31m");
3211 DU_LOG("\nLWR_MAC: MIB sent..");
3214 if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
3216 /* Filling SIB1 param */
3217 if(numPduEncoded != nPdu)
3219 rntiType = SI_RNTI_TYPE;
3220 fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo,\
3223 fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
3224 &currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdschCfg,
3225 currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.bwp,
3230 printf("\033[1;34m");
3231 DU_LOG("\nLWR_MAC: SIB1 sent...");
3235 if(currDlSlot->dlInfo.rarAlloc != NULLP)
3237 /* Filling RAR param */
3238 rntiType = RA_RNTI_TYPE;
3239 fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
3240 &currDlSlot->dlInfo, &msgLen, rntiType);
3242 fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
3243 &currDlSlot->dlInfo.rarAlloc->rarPdschCfg,
3244 currDlSlot->dlInfo.rarAlloc->bwp,
3249 printf("\033[1;32m");
3250 DU_LOG("\nLWR_MAC: RAR sent...");
3253 if(currDlSlot->dlInfo.msg4Alloc != NULLP)
3255 /* Filling Msg4 param */
3256 rntiType = TC_RNTI_TYPE;
3257 fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
3258 &currDlSlot->dlInfo, &msgLen, rntiType);
3260 fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
3261 &currDlSlot->dlInfo.msg4Alloc->msg4PdschCfg,
3262 currDlSlot->dlInfo.msg4Alloc->bwp,
3267 printf("\033[1;32m");
3268 DU_LOG("\nLWR_MAC: MSG4 sent...");
3271 msgLen += sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
3272 fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
3273 LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, \
3276 /* send Tx-DATA req message */
3277 sendTxDataReq(currTimingInfo, &currDlSlot->dlInfo);
3281 msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
3282 fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
3283 LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, (void *)dlTtiReq);
3285 memset(currDlSlot, 0, sizeof(MacDlSlot));
3290 DU_LOG("\nLWR_MAC: Failed to allocate memory for DL TTI Request");
3291 memset(currDlSlot, 0, sizeof(MacDlSlot));
3297 lwr_mac_handleInvalidEvt(&currTimingInfo);
3304 /*******************************************************************
3306 * @brief Sends TX data Request to PHY
3310 * Function : sendTxDataReq
3313 * -Sends FAPI TX data req to PHY
3315 * @params[in] timing info
3316 * @return ROK - success
3319 * ****************************************************************/
3320 uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo)
3324 uint32_t msgLen = 0;
3325 uint16_t pduIndex = 0;
3326 uint32_t txDataReqMsgSize = 0;
3327 fapi_tx_data_req_t *txDataReq = NULLP;
3330 /* send TX_Data request message */
3331 nPdu = calcTxDataReqPduCount(dlInfo);
3334 txDataReqMsgSize = sizeof(fapi_tx_data_req_t) + \
3335 (nPdu * sizeof(fapi_tx_pdu_desc_t));
3336 if(dlInfo->brdcstAlloc.sib1Trans)
3338 txDataReqMsgSize += rgCb[inst].cell->macCellCfg.sib1Cfg.sib1PduLen;
3340 if(dlInfo->rarAlloc != NULLP)
3342 txDataReqMsgSize += dlInfo->rarAlloc->rarInfo.rarPduLen;
3344 if(dlInfo->msg4Alloc != NULLP)
3346 txDataReqMsgSize += dlInfo->msg4Alloc->msg4Info.msg4PduLen;
3349 LWR_MAC_ALLOC(txDataReq, txDataReqMsgSize);
3350 if(txDataReq == NULLP)
3352 DU_LOG("\nLWR_MAC: Failed to allocate memory for TX data Request");
3356 memset(txDataReq, 0, txDataReqMsgSize);
3357 txDataReq->sfn = currTimingInfo.sfn;
3358 txDataReq->slot = currTimingInfo.slot;
3359 txDataReq->pduDesc = (fapi_tx_pdu_desc_t *)(txDataReq + \
3360 (sizeof(fapi_tx_data_req_t) - sizeof(fapi_tx_pdu_desc_t *)));
3362 if(dlInfo->brdcstAlloc.sib1Trans)
3364 fillSib1TxDataReq(txDataReq->pduDesc,
3365 &rgCb[inst].cell->macCellCfg, &msgLen, pduIndex);
3367 txDataReq->numPdus++;
3369 if(dlInfo->rarAlloc != NULLP)
3371 fillRarTxDataReq(txDataReq->pduDesc, &dlInfo->rarAlloc->rarInfo, &msgLen, pduIndex);
3373 txDataReq->numPdus++;
3375 MAC_FREE(dlInfo->rarAlloc,sizeof(RarAlloc));
3376 dlInfo->rarAlloc = NULLP;
3378 if(dlInfo->msg4Alloc != NULLP)
3380 fillMsg4TxDataReq(txDataReq->pduDesc, &dlInfo->msg4Alloc->\
3381 msg4Info, &msgLen, pduIndex);
3383 txDataReq->numPdus++;
3385 MAC_FREE(dlInfo->msg4Alloc,sizeof(Msg4Alloc));
3386 dlInfo->msg4Alloc = NULLP;
3388 msgLen += sizeof(fapi_tx_data_req_t) - sizeof(fapi_msg_t);
3389 fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, msgLen);
3390 LwrMacSendToPhy(txDataReq->header.message_type_id, txDataReqMsgSize, \
3397 /***********************************************************************
3399 * @brief calculates the total size to be allocated for UL TTI Req
3403 * Function : getnPdus
3406 * -calculates the total pdu count to be allocated for UL TTI Req
3408 * @params[in] Pointer to fapi Ul TTI Req
3409 * Pointer to CurrUlSlot
3411 * ********************************************************************/
3413 uint8_t getnPdus(fapi_ul_tti_req_t *ulTtiReq, MacUlSlot *currUlSlot)
3415 uint8_t pduCount = 0;
3417 if(ulTtiReq && currUlSlot)
3419 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH)
3422 ulTtiReq->rachPresent = PDU_PRESENT;
3424 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH)
3429 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH_UCI)
3433 ulTtiReq->nUlsch = PDU_PRESENT;
3435 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_UCI)
3438 ulTtiReq->nUlcch = PDU_PRESENT;
3440 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_SRS)
3449 /***********************************************************************
3451 * @brief Set the value of zero correlation config in PRACH PDU
3455 * Function : setNumCs
3458 * -Set the value of zero correlation config in PRACH PDU
3460 * @params[in] Pointer to zero correlation config
3461 * Pointer to MacCellCfg
3462 * ********************************************************************/
3464 void setNumCs(uint8_t *numCs, MacCellCfg *macCellCfg)
3468 if(macCellCfg != NULLP)
3470 idx = macCellCfg->prachCfg.fdm[0].zeroCorrZoneCfg;
3471 *numCs = UnrestrictedSetNcsTable[idx];
3476 /***********************************************************************
3478 * @brief Fills the PRACH PDU in UL TTI Request
3482 * Function : fillPrachPdu
3485 * -Fills the PRACH PDU in UL TTI Request
3487 * @params[in] Pointer to Prach Pdu
3488 * Pointer to CurrUlSlot
3489 * Pointer to macCellCfg
3491 * ********************************************************************/
3494 void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, MacUlSlot *currUlSlot, uint32_t *msgLen)
3496 if(ulTtiReqPdu != NULLP)
3498 ulTtiReqPdu->pduType = PRACH_PDU_TYPE;
3499 ulTtiReqPdu->u.prach_pdu.physCellId = macCellCfg->phyCellId;
3500 ulTtiReqPdu->u.prach_pdu.numPrachOcas = currUlSlot->ulInfo.prachSchInfo.numPrachOcas;
3501 ulTtiReqPdu->u.prach_pdu.prachFormat = \
3502 currUlSlot->ulInfo.prachSchInfo.prachFormat;
3503 ulTtiReqPdu->u.prach_pdu.numRa = currUlSlot->ulInfo.prachSchInfo.numRa;
3504 ulTtiReqPdu->u.prach_pdu.prachStartSymbol = \
3505 currUlSlot->ulInfo.prachSchInfo.prachStartSymb;
3506 setNumCs(&ulTtiReqPdu->u.prach_pdu.numCs, macCellCfg);
3507 ulTtiReqPdu->u.prach_pdu.beamforming.numPrgs = 0;
3508 ulTtiReqPdu->u.prach_pdu.beamforming.prgSize = 0;
3509 ulTtiReqPdu->u.prach_pdu.beamforming.digBfInterfaces = 0;
3510 ulTtiReqPdu->u.prach_pdu.beamforming.pmi_bfi[0].pmIdx = 0;
3511 ulTtiReqPdu->u.prach_pdu.beamforming.pmi_bfi[0].beamIdx[0].beamidx = 0;
3512 ulTtiReqPdu->pduSize = sizeof(fapi_ul_prach_pdu_t);
3514 SET_MSG_LEN(*msgLen, (sizeof(ulTtiReqPdu->pduType) + \
3515 sizeof(ulTtiReqPdu->pduSize) + sizeof(fapi_ul_prach_pdu_t)));
3519 void fillPuschPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, MacUlSlot *currUlSlot, uint32_t *msgLen)
3521 if(ulTtiReqPdu != NULLP)
3523 ulTtiReqPdu->pduType = PUSCH_PDU_TYPE;
3524 ulTtiReqPdu->u.pusch_pdu.pduBitMap = 1;
3525 ulTtiReqPdu->u.pusch_pdu.rnti = currUlSlot->ulInfo.crnti;
3526 /* TODO : Fill handle in raCb when scheduling pusch and access here */
3527 ulTtiReqPdu->u.pusch_pdu.handle = 100;
3528 ulTtiReqPdu->u.pusch_pdu.bwpSize = macCellCfg->initialUlBwp.bwp.numPrb;
3529 ulTtiReqPdu->u.pusch_pdu.bwpStart = macCellCfg->initialUlBwp.bwp.firstPrb;
3530 ulTtiReqPdu->u.pusch_pdu.subCarrierSpacing = \
3531 macCellCfg->initialUlBwp.bwp.scs;
3532 ulTtiReqPdu->u.pusch_pdu.cyclicPrefix = \
3533 macCellCfg->initialUlBwp.bwp.cyclicPrefix;
3534 ulTtiReqPdu->u.pusch_pdu.targetCodeRate = 308;
3535 ulTtiReqPdu->u.pusch_pdu.qamModOrder = 2;
3536 ulTtiReqPdu->u.pusch_pdu.mcsIndex = \
3537 currUlSlot->ulInfo.schPuschInfo.tbInfo.mcs;
3538 ulTtiReqPdu->u.pusch_pdu.mcsTable = 0;
3539 ulTtiReqPdu->u.pusch_pdu.transformPrecoding = 1;
3540 ulTtiReqPdu->u.pusch_pdu.dataScramblingId = currUlSlot->ulInfo.cellId;
3541 ulTtiReqPdu->u.pusch_pdu.nrOfLayers = 1;
3542 ulTtiReqPdu->u.pusch_pdu.ulDmrsSymbPos = 4;
3543 ulTtiReqPdu->u.pusch_pdu.dmrsConfigType = 0;
3544 ulTtiReqPdu->u.pusch_pdu.ulDmrsScramblingId = currUlSlot->ulInfo.cellId;
3545 ulTtiReqPdu->u.pusch_pdu.scid = 0;
3546 ulTtiReqPdu->u.pusch_pdu.numDmrsCdmGrpsNoData = 1;
3547 ulTtiReqPdu->u.pusch_pdu.dmrsPorts = 0;
3548 ulTtiReqPdu->u.pusch_pdu.resourceAlloc = \
3549 currUlSlot->ulInfo.schPuschInfo.resAllocType;
3550 ulTtiReqPdu->u.pusch_pdu.rbStart = \
3551 currUlSlot->ulInfo.schPuschInfo.fdAlloc.startPrb;
3552 ulTtiReqPdu->u.pusch_pdu.rbSize = \
3553 currUlSlot->ulInfo.schPuschInfo.fdAlloc.numPrb;
3554 ulTtiReqPdu->u.pusch_pdu.vrbToPrbMapping = 0;
3555 ulTtiReqPdu->u.pusch_pdu.frequencyHopping = 0;
3556 ulTtiReqPdu->u.pusch_pdu.txDirectCurrentLocation = 0;
3557 ulTtiReqPdu->u.pusch_pdu.uplinkFrequencyShift7p5khz = 0;
3558 ulTtiReqPdu->u.pusch_pdu.startSymbIndex = \
3559 currUlSlot->ulInfo.schPuschInfo.tdAlloc.startSymb;
3560 ulTtiReqPdu->u.pusch_pdu.nrOfSymbols = \
3561 currUlSlot->ulInfo.schPuschInfo.tdAlloc.numSymb;
3562 ulTtiReqPdu->u.pusch_pdu.puschData.rvIndex = \
3563 currUlSlot->ulInfo.schPuschInfo.tbInfo.rv;
3564 ulTtiReqPdu->u.pusch_pdu.puschData.harqProcessId = \
3565 currUlSlot->ulInfo.schPuschInfo.harqProcId;
3566 ulTtiReqPdu->u.pusch_pdu.puschData.newDataIndicator = \
3567 currUlSlot->ulInfo.schPuschInfo.tbInfo.ndi;
3568 ulTtiReqPdu->u.pusch_pdu.puschData.tbSize = \
3569 currUlSlot->ulInfo.schPuschInfo.tbInfo.tbSize;
3570 /* numCb is 0 for new transmission */
3571 ulTtiReqPdu->u.pusch_pdu.puschData.numCb = 0;
3573 ulTtiReqPdu->pduSize = sizeof(fapi_ul_pusch_pdu_t);
3575 SET_MSG_LEN(*msgLen, (sizeof(ulTtiReqPdu->pduType) + \
3576 sizeof(ulTtiReqPdu->pduSize) + sizeof(fapi_ul_pusch_pdu_t)));
3581 /*******************************************************************
3583 * @brief Sends UL TTI Request to PHY
3587 * Function : handleUlTtiReq
3590 * -Sends FAPI Param req to PHY
3592 * @params[in] Pointer to CmLteTimingInfo
3593 * @return ROK - success
3596 ******************************************************************/
3597 uint16_t handleUlTtiReq(SlotIndInfo currTimingInfo)
3600 uint8_t pduIdx = -1;
3602 uint32_t msgLen = 0;
3603 uint32_t msgSize = 0;
3605 fapi_ul_tti_req_t *ulTtiReq = NULLP;
3606 SlotIndInfo ulTtiReqTimingInfo;
3608 RgCellCb *cellCbParams = NULLP;
3609 MacUlSlot *currUlSlot = NULLP;
3610 MacCellCfg macCellCfg;
3613 if(clGlobalCp.phyState == PHY_STATE_RUNNING)
3615 cellCbParams = rgCb[inst].cell;
3616 macCellCfg = cellCbParams->macCellCfg;
3619 ADD_DELTA_TO_TIME(currTimingInfo,ulTtiReqTimingInfo,PHY_DELTA);
3621 currUlSlot = &macCb.macCell->ulSlot[ulTtiReqTimingInfo.slot % MAX_SLOT_SUPPORTED];
3622 numPdu = getnPdus(NULL, currUlSlot);
3623 msgSize = sizeof(fapi_ul_tti_req_t) + (numPdu*sizeof(fapi_ul_tti_req_pdu_t));
3624 LWR_MAC_ALLOC(ulTtiReq, msgSize);
3626 if(ulTtiReq != NULLP)
3628 memset(ulTtiReq, 0, msgSize);
3629 ulTtiReq->sfn = currTimingInfo.sfn;
3630 ulTtiReq->slot = currTimingInfo.slot;
3631 ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot);
3632 ulTtiReq->nGroup = 0;
3633 if(ulTtiReq->nPdus > 0)
3635 ulTtiReq->pdus = (fapi_ul_tti_req_pdu_t *)(ulTtiReq + \
3636 (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_ul_tti_req_pdu_t*)));
3637 /* Fill Prach Pdu */
3638 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH)
3641 fillPrachPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
3644 /* Fill PUSCH PDU */
3645 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH)
3648 fillPuschPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
3651 if((currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH) || \
3652 (currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH))
3654 msgLen += (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t));
3655 fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
3657 DU_LOG("\nLWR_MAC: Sending UL TTI Request");
3658 LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq);
3663 msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t);
3664 fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
3666 DU_LOG("\nLWR_MAC: Sending UL TTI Request");
3667 LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq);
3669 memset(&currUlSlot, 0, sizeof(MacUlSlot));
3674 DU_LOG("\nLWR_MAC: Failed to allocate memory for UL TTI Request");
3675 memset(&currUlSlot, 0, sizeof(MacUlSlot));
3681 lwr_mac_handleInvalidEvt(&currTimingInfo);
3687 lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] =
3690 /* PHY_STATE_IDLE */
3691 lwr_mac_handleParamReqEvt,
3692 lwr_mac_handleParamRspEvt,
3693 lwr_mac_handleConfigReqEvt,
3694 lwr_mac_handleConfigRspEvt,
3695 lwr_mac_handleInvalidEvt,
3696 lwr_mac_handleInvalidEvt,
3699 /* PHY_STATE_CONFIGURED */
3700 lwr_mac_handleParamReqEvt,
3701 lwr_mac_handleParamRspEvt,
3702 lwr_mac_handleConfigReqEvt,
3703 lwr_mac_handleConfigRspEvt,
3704 lwr_mac_handleStartReqEvt,
3705 lwr_mac_handleInvalidEvt,
3708 /* PHY_STATE_RUNNING */
3709 lwr_mac_handleInvalidEvt,
3710 lwr_mac_handleInvalidEvt,
3711 lwr_mac_handleConfigReqEvt,
3712 lwr_mac_handleConfigRspEvt,
3713 lwr_mac_handleInvalidEvt,
3714 lwr_mac_handleStopReqEvt,
3718 /*******************************************************************
3720 * @brief Sends message to LWR_MAC Fsm Event Handler
3724 * Function : sendToLowerMac
3727 * -Sends message to LowerMac
3729 * @params[in] Message Type
3735 ******************************************************************/
3736 void sendToLowerMac(uint16_t msgType, uint32_t msgLen, void *msg)
3738 clGlobalCp.event = msgType;
3739 fapiEvtHdlr[clGlobalCp.phyState][clGlobalCp.event](msg);
3741 /**********************************************************************
3743 **********************************************************************/