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 *******************************************************************************/
22 /* header include files -- defines (.h) */
23 #include "envopt.h" /* environment options */
24 #include "envdep.h" /* environment dependent */
25 #include "envind.h" /* environment independent */
26 #include "gen.h" /* general layer */
27 #include "ssi.h" /* system service interface */
28 #include "cm_hash.h" /* common hash list */
29 #include "cm_mblk.h" /* common memory link list library */
30 #include "cm_llist.h" /* common linked list library */
31 #include "cm_err.h" /* common error */
32 #include "cm_lte.h" /* common LTE */
33 #include "lrg.h" /* Layer manager interface includes*/
34 #include "crg.h" /* CRG interface includes*/
35 #include "rgu.h" /* RGU interface includes*/
36 #include "tfu.h" /* TFU interface includes */
37 #include "rg_sch_inf.h" /* SCH interface includes */
38 #include "rg_prg.h" /* PRG (MAC-MAC) interface includes*/
39 #include "rg_env.h" /* MAC environmental includes*/
40 #include "rg.h" /* MAC includes*/
41 #include "rg_err.h" /* MAC error includes*/
43 #include "lwr_mac_fsm.h"
45 /* header/extern include files (.x) */
46 #include "gen.x" /* general layer typedefs */
47 #include "ssi.x" /* system services typedefs */
48 #include "cm5.x" /* common timers */
49 #include "cm_hash.x" /* common hash list */
50 #include "cm_lib.x" /* common library */
51 #include "cm_llist.x" /* common linked list */
52 #include "cm_mblk.x" /* memory management */
53 #include "cm_tkns.x" /* common tokens */
54 #include "cm_lte.x" /* common tokens */
55 #include "rgu.x" /* RGU types */
56 #include "tfu.x" /* RGU types */
57 #include "lrg.x" /* layer management typedefs for MAC */
58 #include "crg.x" /* CRG interface includes */
59 #include "rg_sch_inf.x" /* SCH interface typedefs */
60 #include "rg_prg.x" /* PRG (MAC-MAC) Interface typedefs */
61 #include "du_app_mac_inf.h"
63 #include "rg.x" /* typedefs for MAC */
65 #define MIB_SFN_BITMASK 0xFC
66 #define PDCCH_PDU_TYPE 0
67 #define PDSCH_PDU_TYPE 1
68 #define SSB_PDU_TYPE 3
69 #define SETLENGTH(x, size) x += size
72 EXTERN void sendToPhy ARGS((uint8_t msgType, uint32_t msgLen, void *msg));
73 SlotIndInfo slotIndInfo; //global variable
75 /*******************************************************************
77 * @brief Handles Invalid Request Event
81 * Function : lwr_mac_handleInvalidEvt
84 * - Displays the PHY state when the invalid event occurs
87 * @return ROK - success
90 * ****************************************************************/
91 S16 lwr_mac_handleInvalidEvt(void *msg)
93 printf("\nLOWER MAC: Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState);
98 /*******************************************************************
100 * @brief Fills FAPI message header
104 * Function : fillMsgHeader
107 * -Fills FAPI message header
109 * @params[in] Pointer to header
115 * ****************************************************************/
116 PUBLIC void fillMsgHeader(fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen)
118 hdr->message_type_id = msgType;
119 hdr->length = msgLen;
122 /*******************************************************************
124 * @brief Fills FAPI Config Request message header
128 * Function : fillTlvs
131 * -Fills FAPI Config Request message header
133 * @params[in] Pointer to TLV
140 * ****************************************************************/
141 PUBLIC void fillTlvs(fapi_uint16_tlv_t *tlv, uint16_t tag, uint16_t length,
142 uint16_t value, uint32_t *msgLen)
145 tlv->tl.length = length;
147 *msgLen = *msgLen + sizeof(tag) + sizeof(length) + length;
149 /*******************************************************************
151 * @brief fills the cyclic prefix by comparing the bitmask
155 * Function : fillCyclicPrefix
158 * -checks the value with the bitmask and
159 * fills the cellPtr's cyclic prefix.
161 * @params[in] Pointer to ClCellParam
162 * Value to be compared
165 ********************************************************************/
166 PUBLIC void fillCyclicPrefix(uint8_t value, ClCellParam **cellPtr)
168 if((value & FAPI_NORMAL_CYCLIC_PREFIX_MASK) == FAPI_NORMAL_CYCLIC_PREFIX_MASK)
170 (*cellPtr)->cyclicPrefix = NORMAL_CYCLIC_PREFIX_MASK;
172 else if((value & FAPI_EXTENDED_CYCLIC_PREFIX_MASK) == FAPI_EXTENDED_CYCLIC_PREFIX_MASK)
174 (*cellPtr)->cyclicPrefix = EXTENDED_CYCLIC_PREFIX_MASK;
178 (*cellPtr)->cyclicPrefix = INVALID_VALUE;
182 /*******************************************************************
184 * @brief fills the subcarrier spacing of Downlink by comparing the bitmask
188 * Function : fillSubcarrierSpaceDl
191 * -checks the value with the bitmask and
192 * fills the cellPtr's subcarrier spacing in DL
194 * @params[in] Pointer to ClCellParam
195 * Value to be compared
198 * ****************************************************************/
200 PUBLIC void fillSubcarrierSpaceDl(uint8_t value, ClCellParam **cellPtr)
202 if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
204 (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_15_KHZ;
206 else if((value & FAPI_30KHZ_MASK) == FAPI_30KHZ_MASK)
208 (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_30_KHZ;
210 else if((value & FAPI_60KHZ_MASK) == FAPI_60KHZ_MASK)
212 (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_60_KHZ;
214 else if((value & FAPI_120KHZ_MASK) == FAPI_120KHZ_MASK)
216 (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_120_KHZ;
220 (*cellPtr)->supportedSubcarrierSpacingDl = INVALID_VALUE;
224 /*******************************************************************
226 * @brief fills the downlink bandwidth by comparing the bitmask
230 * Function : fillBandwidthDl
233 * -checks the value with the bitmask and
234 * -fills the cellPtr's DL Bandwidth
236 * @params[in] Pointer to ClCellParam
237 * Value to be compared
240 * ****************************************************************/
242 PUBLIC void fillBandwidthDl(uint16_t value, ClCellParam **cellPtr)
244 if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
246 (*cellPtr)->supportedBandwidthDl = BW_5MHZ;
248 else if((value & FAPI_10MHZ_BW_MASK) == FAPI_10MHZ_BW_MASK)
250 (*cellPtr)->supportedBandwidthDl = BW_10MHZ;
252 else if((value & FAPI_15MHZ_BW_MASK) == FAPI_15MHZ_BW_MASK)
254 (*cellPtr)->supportedBandwidthDl = BW_15MHZ;
256 else if((value & FAPI_20MHZ_BW_MASK) == FAPI_20MHZ_BW_MASK)
258 (*cellPtr)->supportedBandwidthDl = BW_20MHZ;
260 else if((value & FAPI_40MHZ_BW_MASK) == FAPI_40MHZ_BW_MASK)
262 (*cellPtr)->supportedBandwidthDl = BW_40MHZ;
264 else if((value & FAPI_50MHZ_BW_MASK) == FAPI_50MHZ_BW_MASK)
266 (*cellPtr)->supportedBandwidthDl = BW_50MHZ;
268 else if((value & FAPI_60MHZ_BW_MASK) == FAPI_60MHZ_BW_MASK)
270 (*cellPtr)->supportedBandwidthDl = BW_60MHZ;
272 else if((value & FAPI_70MHZ_BW_MASK) == FAPI_70MHZ_BW_MASK)
274 (*cellPtr)->supportedBandwidthDl = BW_70MHZ;
276 else if((value & FAPI_80MHZ_BW_MASK) == FAPI_80MHZ_BW_MASK)
278 (*cellPtr)->supportedBandwidthDl = BW_80MHZ;
280 else if((value & FAPI_90MHZ_BW_MASK) == FAPI_90MHZ_BW_MASK)
282 (*cellPtr)->supportedBandwidthDl = BW_90MHZ;
284 else if((value & FAPI_100MHZ_BW_MASK) == FAPI_100MHZ_BW_MASK)
286 (*cellPtr)->supportedBandwidthDl = BW_100MHZ;
288 else if((value & FAPI_200MHZ_BW_MASK) == FAPI_200MHZ_BW_MASK)
290 (*cellPtr)->supportedBandwidthDl = BW_200MHZ;
292 else if((value & FAPI_400MHZ_BW_MASK) == FAPI_400MHZ_BW_MASK)
294 (*cellPtr)->supportedBandwidthDl = BW_400MHZ;
298 (*cellPtr)->supportedBandwidthDl = INVALID_VALUE;
302 /*******************************************************************
304 * @brief fills the subcarrier spacing of Uplink by comparing the bitmask
308 * Function : fillSubcarrierSpaceUl
311 * -checks the value with the bitmask and
312 * -fills cellPtr's subcarrier spacing in UL
314 * @params[in] Pointer to ClCellParam
315 * Value to be compared
318 * ****************************************************************/
320 PUBLIC void fillSubcarrierSpaceUl(uint8_t value, ClCellParam **cellPtr)
322 if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
324 (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_15_KHZ;
326 else if((value & FAPI_30KHZ_MASK) == FAPI_30KHZ_MASK)
328 (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_30_KHZ;
330 else if((value & FAPI_60KHZ_MASK) == FAPI_60KHZ_MASK)
332 (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_60_KHZ;
334 else if((value & FAPI_120KHZ_MASK) == FAPI_120KHZ_MASK)
336 (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_120_KHZ;
340 (*cellPtr)->supportedSubcarrierSpacingsUl = INVALID_VALUE;
344 /*******************************************************************
346 * @brief fills the uplink bandwidth by comparing the bitmask
350 * Function : fillBandwidthUl
353 * -checks the value with the bitmask and
354 * fills the cellPtr's UL Bandwidth
358 * @params[in] Pointer to ClCellParam
359 * Value to be compared
363 * ****************************************************************/
365 PUBLIC void fillBandwidthUl(uint16_t value, ClCellParam **cellPtr)
367 if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
369 (*cellPtr)->supportedBandwidthUl = BW_5MHZ;
371 else if((value & FAPI_10MHZ_BW_MASK) == FAPI_10MHZ_BW_MASK)
373 (*cellPtr)->supportedBandwidthUl = BW_10MHZ;
375 else if((value & FAPI_15MHZ_BW_MASK) == FAPI_15MHZ_BW_MASK)
377 (*cellPtr)->supportedBandwidthUl = BW_15MHZ;
379 else if((value & FAPI_20MHZ_BW_MASK) == FAPI_20MHZ_BW_MASK)
381 (*cellPtr)->supportedBandwidthUl = BW_20MHZ;
383 else if((value & FAPI_40MHZ_BW_MASK) == FAPI_40MHZ_BW_MASK)
385 (*cellPtr)->supportedBandwidthUl = BW_40MHZ;
387 else if((value & FAPI_50MHZ_BW_MASK) == FAPI_50MHZ_BW_MASK)
389 (*cellPtr)->supportedBandwidthUl = BW_50MHZ;
391 else if((value & FAPI_60MHZ_BW_MASK) == FAPI_60MHZ_BW_MASK)
393 (*cellPtr)->supportedBandwidthUl = BW_60MHZ;
395 else if((value & FAPI_70MHZ_BW_MASK) == FAPI_70MHZ_BW_MASK)
397 (*cellPtr)->supportedBandwidthUl = BW_70MHZ;
399 else if((value & FAPI_80MHZ_BW_MASK) == FAPI_80MHZ_BW_MASK)
401 (*cellPtr)->supportedBandwidthUl = BW_80MHZ;
403 else if((value & FAPI_90MHZ_BW_MASK) == FAPI_90MHZ_BW_MASK)
405 (*cellPtr)->supportedBandwidthUl = BW_90MHZ;
407 else if((value & FAPI_100MHZ_BW_MASK) == FAPI_100MHZ_BW_MASK)
409 (*cellPtr)->supportedBandwidthUl = BW_100MHZ;
411 else if((value & FAPI_200MHZ_BW_MASK) == FAPI_200MHZ_BW_MASK)
413 (*cellPtr)->supportedBandwidthUl = BW_200MHZ;
415 else if((value & FAPI_400MHZ_BW_MASK) == FAPI_400MHZ_BW_MASK)
417 (*cellPtr)->supportedBandwidthUl = BW_400MHZ;
421 (*cellPtr)->supportedBandwidthUl = INVALID_VALUE;
424 /*******************************************************************
426 * @brief fills the CCE maping by comparing the bitmask
430 * Function : fillCCEmaping
433 * -checks the value with the bitmask and
434 * fills the cellPtr's CCE Mapping Type
437 * @params[in] Pointer to ClCellParam
438 * Value to be compared
441 * ****************************************************************/
443 PUBLIC void fillCCEmaping(uint8_t value, ClCellParam **cellPtr)
445 if ((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_INTERLEAVED_MASK)
447 (*cellPtr)->cceMappingType = CCE_MAPPING_INTERLEAVED_MASK;
449 else if((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_NONINTERLVD_MASK)
451 (*cellPtr)->cceMappingType = CCE_MAPPING_NONINTERLVD_MASK;
455 (*cellPtr)->cceMappingType = INVALID_VALUE;
459 /*******************************************************************
461 * @brief fills the PUCCH format by comparing the bitmask
465 * Function : fillPucchFormat
468 * -checks the value with the bitmask and
469 * fills the cellPtr's pucch format
472 * @params[in] Pointer to ClCellParam
473 * Value to be compared
476 * ****************************************************************/
478 PUBLIC void fillPucchFormat(uint8_t value, ClCellParam **cellPtr)
480 if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
482 (*cellPtr)->pucchFormats = FORMAT_0;
484 else if((value & FAPI_FORMAT_1_MASK) == FAPI_FORMAT_1_MASK)
486 (*cellPtr)->pucchFormats = FORMAT_1;
488 else if((value & FAPI_FORMAT_2_MASK) == FAPI_FORMAT_2_MASK)
490 (*cellPtr)->pucchFormats = FORMAT_2;
492 else if((value & FAPI_FORMAT_3_MASK) == FAPI_FORMAT_3_MASK)
494 (*cellPtr)->pucchFormats = FORMAT_3;
496 else if((value & FAPI_FORMAT_4_MASK) == FAPI_FORMAT_4_MASK)
498 (*cellPtr)->pucchFormats = FORMAT_4;
502 (*cellPtr)->pucchFormats = INVALID_VALUE;
506 /*******************************************************************
508 * @brief fills the PDSCH Mapping Type by comparing the bitmask
512 * Function : fillPdschMappingType
515 * -checks the value with the bitmask and
516 * fills the cellPtr's PDSCH MappingType
518 * @params[in] Pointer to ClCellParam
519 * Value to be compared
522 * ****************************************************************/
524 PUBLIC void fillPdschMappingType(uint8_t value, ClCellParam **cellPtr)
526 if((value & FAPI_PDSCH_MAPPING_TYPE_A_MASK) == FAPI_PDSCH_MAPPING_TYPE_A_MASK)
528 (*cellPtr)->pdschMappingType = MAPPING_TYPE_A;
530 else if((value & FAPI_PDSCH_MAPPING_TYPE_B_MASK) == FAPI_PDSCH_MAPPING_TYPE_B_MASK)
532 (*cellPtr)->pdschMappingType = MAPPING_TYPE_B;
536 (*cellPtr)->pdschMappingType = INVALID_VALUE;
540 /*******************************************************************
542 * @brief fills the PDSCH Allocation Type by comparing the bitmask
546 * Function : fillPdschAllocationType
549 * -checks the value with the bitmask and
550 * fills the cellPtr's PDSCH AllocationType
552 * @params[in] Pointer to ClCellParam
553 * Value to be compared
556 * ****************************************************************/
558 PUBLIC void fillPdschAllocationType(uint8_t value, ClCellParam **cellPtr)
560 if((value & FAPI_PDSCH_ALLOC_TYPE_0_MASK) == FAPI_PDSCH_ALLOC_TYPE_0_MASK)
562 (*cellPtr)->pdschAllocationTypes = ALLOCATION_TYPE_0;
564 else if((value & FAPI_PDSCH_ALLOC_TYPE_1_MASK) == FAPI_PDSCH_ALLOC_TYPE_1_MASK)
566 (*cellPtr)->pdschAllocationTypes = ALLOCATION_TYPE_1;
570 (*cellPtr)->pdschAllocationTypes = INVALID_VALUE;
574 /*******************************************************************
576 * @brief fills the PDSCH PRB Mapping Type by comparing the bitmask
580 * Function : fillPrbMappingType
583 * -checks the value with the bitmask and
584 * fills the cellPtr's PRB Mapping Type
586 * @params[in] Pointer to ClCellParam
587 * Value to be compared
590 ******************************************************************/
591 PUBLIC void fillPrbMappingType(uint8_t value, ClCellParam **cellPtr)
593 if((value & FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
595 (*cellPtr)->pdschVrbToPrbMapping = VRB_TO_PRB_MAP_NON_INTLV;
597 else if((value & FAPI_PDSCH_VRB_TO_PRB_MAP_INTLVD_MASK) == FAPI_PDSCH_VRB_TO_PRB_MAP_INTLVD_MASK)
599 (*cellPtr)->pdschVrbToPrbMapping = VRB_TO_PRB_MAP_INTLVD;
603 (*cellPtr)->pdschVrbToPrbMapping = INVALID_VALUE;
607 /*******************************************************************
609 * @brief fills the PDSCH DmrsConfig Type by comparing the bitmask
613 * Function : fillPdschDmrsConfigType
616 * -checks the value with the bitmask and
617 * fills the cellPtr's DmrsConfig Type
619 * @params[in] Pointer to ClCellParam
620 * Value to be compared
623 ******************************************************************/
625 PUBLIC void fillPdschDmrsConfigType(uint8_t value, ClCellParam **cellPtr)
627 if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK)
629 (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_1;
631 else if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK)
633 (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_2;
637 (*cellPtr)->pdschDmrsConfigTypes = INVALID_VALUE;
641 /*******************************************************************
643 * @brief fills the PDSCH DmrsLength by comparing the bitmask
647 * Function : fillPdschDmrsLength
650 * -checks the value with the bitmask and
651 * fills the cellPtr's PdschDmrsLength
653 * @params[in] Pointer to ClCellParam
654 * Value to be compared
657 ******************************************************************/
658 PUBLIC void fillPdschDmrsLength(uint8_t value, ClCellParam **cellPtr)
660 if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_1)
662 (*cellPtr)->pdschDmrsMaxLength = DMRS_MAX_LENGTH_1;
664 else if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_2)
666 (*cellPtr)->pdschDmrsMaxLength = DMRS_MAX_LENGTH_2;
670 (*cellPtr)->pdschDmrsMaxLength = INVALID_VALUE;
674 /*******************************************************************
676 * @brief fills the PDSCH Dmrs Additional Pos by comparing the bitmask
680 * Function : fillPdschDmrsAddPos
683 * -checks the value with the bitmask and
684 * fills the cellPtr's Pdsch DmrsAddPos
686 * @params[in] Pointer to ClCellParam
687 * Value to be compared
690 ******************************************************************/
692 PUBLIC void fillPdschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
694 if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
696 (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_0;
698 else if((value & FAPI_DMRS_ADDITIONAL_POS_1_MASK) == FAPI_DMRS_ADDITIONAL_POS_1_MASK)
700 (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_1;
702 else if((value & FAPI_DMRS_ADDITIONAL_POS_2_MASK) == FAPI_DMRS_ADDITIONAL_POS_2_MASK)
704 (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_2;
706 else if((value & FAPI_DMRS_ADDITIONAL_POS_3_MASK) == FAPI_DMRS_ADDITIONAL_POS_3_MASK)
708 (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_3;
712 (*cellPtr)->pdschDmrsAdditionalPos = INVALID_VALUE;
716 /*******************************************************************
718 * @brief fills the Modulation Order in DL by comparing the bitmask
722 * Function : fillModulationOrderDl
725 * -checks the value with the bitmask and
726 * fills the cellPtr's ModulationOrder in DL.
728 * @params[in] Pointer to ClCellParam
729 * Value to be compared
732 ******************************************************************/
733 PUBLIC void fillModulationOrderDl(uint8_t value, ClCellParam **cellPtr)
737 (*cellPtr)->supportedMaxModulationOrderDl = MOD_QPSK;
741 (*cellPtr)->supportedMaxModulationOrderDl = MOD_16QAM;
745 (*cellPtr)->supportedMaxModulationOrderDl = MOD_64QAM;
749 (*cellPtr)->supportedMaxModulationOrderDl = MOD_256QAM;
753 (*cellPtr)->supportedMaxModulationOrderDl = INVALID_VALUE;
757 /*******************************************************************
759 * @brief fills the PUSCH DmrsConfig Type by comparing the bitmask
763 * Function : fillPuschDmrsConfigType
766 * -checks the value with the bitmask and
767 * fills the cellPtr's PUSCH DmrsConfigType
769 * @params[in] Pointer to ClCellParam
770 * Value to be compared
773 ******************************************************************/
775 PUBLIC void fillPuschDmrsConfig(uint8_t value, ClCellParam **cellPtr)
777 if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK)
779 (*cellPtr)->puschDmrsConfigTypes = DMRS_CONFIG_TYPE_1;
781 else if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_2_MASK)
783 (*cellPtr)->puschDmrsConfigTypes = DMRS_CONFIG_TYPE_2;
787 (*cellPtr)->puschDmrsConfigTypes = INVALID_VALUE;
791 /*******************************************************************
793 * @brief fills the PUSCH DmrsLength by comparing the bitmask
797 * Function : fillPuschDmrsLength
800 * -checks the value with the bitmask and
801 * fills the cellPtr's PUSCH DmrsLength
803 * @params[in] Pointer to ClCellParam
804 * Value to be compared
807 ******************************************************************/
809 PUBLIC void fillPuschDmrsLength(uint8_t value, ClCellParam **cellPtr)
811 if(value == FAPI_PUSCH_DMRS_MAX_LENGTH_1)
813 (*cellPtr)->puschDmrsMaxLength = DMRS_MAX_LENGTH_1;
815 else if(value == FAPI_PUSCH_DMRS_MAX_LENGTH_2)
817 (*cellPtr)->puschDmrsMaxLength = DMRS_MAX_LENGTH_2;
821 (*cellPtr)->puschDmrsMaxLength = INVALID_VALUE;
825 /*******************************************************************
827 * @brief fills the PUSCH Dmrs Additional position by comparing the bitmask
831 * Function : fillPuschDmrsAddPos
834 * -checks the value with the bitmask and
835 * fills the cellPtr's PUSCH DmrsAddPos
837 * @params[in] Pointer to ClCellParam
838 * Value to be compared
841 ******************************************************************/
843 PUBLIC void fillPuschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
845 if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
847 (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_0;
849 else if((value & FAPI_DMRS_ADDITIONAL_POS_1_MASK) == FAPI_DMRS_ADDITIONAL_POS_1_MASK)
851 (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_1;
853 else if((value & FAPI_DMRS_ADDITIONAL_POS_2_MASK) == FAPI_DMRS_ADDITIONAL_POS_2_MASK)
855 (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_2;
857 else if((value & FAPI_DMRS_ADDITIONAL_POS_3_MASK) == FAPI_DMRS_ADDITIONAL_POS_3_MASK)
859 (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_3;
863 (*cellPtr)->puschDmrsAdditionalPos = INVALID_VALUE;
867 /*******************************************************************
869 * @brief fills the PUSCH Mapping Type by comparing the bitmask
873 * Function : fillPuschMappingType
876 * -checks the value with the bitmask and
877 * fills the cellPtr's PUSCH MappingType
879 * @params[in] Pointer to ClCellParam
880 * Value to be compared
883 ******************************************************************/
885 PUBLIC void fillPuschMappingType(uint8_t value, ClCellParam **cellPtr)
887 if((value & FAPI_PUSCH_MAPPING_TYPE_A_MASK) == FAPI_PUSCH_MAPPING_TYPE_A_MASK)
889 (*cellPtr)->puschMappingType = MAPPING_TYPE_A;
891 else if((value & FAPI_PUSCH_MAPPING_TYPE_B_MASK) == FAPI_PUSCH_MAPPING_TYPE_B_MASK)
893 (*cellPtr)->puschMappingType = MAPPING_TYPE_B;
897 (*cellPtr)->puschMappingType = INVALID_VALUE;
901 /*******************************************************************
903 * @brief fills the PUSCH Allocation Type by comparing the bitmask
907 * Function : fillPuschAllocationType
910 * -checks the value with the bitmask and
911 * fills the cellPtr's PUSCH AllocationType
913 * @params[in] Pointer to ClCellParam
914 * Value to be compared
917 ******************************************************************/
919 PUBLIC void fillPuschAllocationType(uint8_t value, ClCellParam **cellPtr)
921 if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK)
923 (*cellPtr)->puschAllocationTypes = ALLOCATION_TYPE_0;
925 else if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK)
927 (*cellPtr)->puschAllocationTypes = ALLOCATION_TYPE_1;
931 (*cellPtr)->puschAllocationTypes = INVALID_VALUE;
935 /*******************************************************************
937 * @brief fills the PUSCH PRB Mapping Type by comparing the bitmask
941 * Function : fillPuschPrbMappingType
944 * -checks the value with the bitmask and
945 * fills the cellPtr's PUSCH PRB MApping Type
947 * @params[in] Pointer to ClCellParam
948 * Value to be compared
951 ******************************************************************/
953 PUBLIC void fillPuschPrbMappingType(uint8_t value, ClCellParam **cellPtr)
955 if((value & FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
957 (*cellPtr)->puschVrbToPrbMapping = VRB_TO_PRB_MAP_NON_INTLV;
959 else if((value & FAPI_PUSCH_VRB_TO_PRB_MAP_INTLVD_MASK) == FAPI_PUSCH_VRB_TO_PRB_MAP_INTLVD_MASK)
961 (*cellPtr)->puschVrbToPrbMapping = VRB_TO_PRB_MAP_INTLVD;
965 (*cellPtr)->puschVrbToPrbMapping = INVALID_VALUE;
969 /*******************************************************************
971 * @brief fills the Modulation Order in Ul by comparing the bitmask
975 * Function : fillModulationOrderUl
978 * -checks the value with the bitmask and
979 * fills the cellPtr's Modualtsion Order in UL.
981 * @params[in] Pointer to ClCellParam
982 * Value to be compared
985 ******************************************************************/
987 PUBLIC void fillModulationOrderUl(uint8_t value, ClCellParam **cellPtr)
991 (*cellPtr)->supportedModulationOrderUl = MOD_QPSK;
995 (*cellPtr)->supportedModulationOrderUl = MOD_16QAM;
999 (*cellPtr)->supportedModulationOrderUl = MOD_64QAM;
1003 (*cellPtr)->supportedModulationOrderUl = MOD_256QAM;
1007 (*cellPtr)->supportedModulationOrderUl = INVALID_VALUE;
1011 /*******************************************************************
1013 * @brief fills the PUSCH Aggregation Factor by comparing the bitmask
1017 * Function : fillPuschAggregationFactor
1020 * -checks the value with the bitmask and
1021 * fills the cellPtr's PUSCH Aggregation Factor
1023 * @params[in] Pointer to ClCellParam
1024 * Value to be compared
1027 ******************************************************************/
1029 PUBLIC void fillPuschAggregationFactor(uint8_t value, ClCellParam **cellPtr)
1031 if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
1033 (*cellPtr)->puschAggregationFactor = AGG_FACTOR_1;
1035 else if((value & FAPI_FORMAT_1_MASK) == FAPI_FORMAT_1_MASK)
1037 (*cellPtr)->puschAggregationFactor = AGG_FACTOR_2;
1039 else if((value & FAPI_FORMAT_2_MASK) == FAPI_FORMAT_2_MASK)
1041 (*cellPtr)->puschAggregationFactor = AGG_FACTOR_4;
1043 else if((value & FAPI_FORMAT_3_MASK) == FAPI_FORMAT_3_MASK)
1045 (*cellPtr)->puschAggregationFactor = AGG_FACTOR_8;
1049 (*cellPtr)->puschAggregationFactor = INVALID_VALUE;
1053 /*******************************************************************
1055 * @brief fills the PRACH Long Format by comparing the bitmask
1059 * Function : fillPrachLongFormat
1062 * -checks the value with the bitmask and
1063 * fills the cellPtr's PRACH Long Format
1065 * @params[in] Pointer to ClCellParam
1066 * Value to be compared
1069 ******************************************************************/
1071 PUBLIC void fillPrachLongFormat(uint8_t value, ClCellParam **cellPtr)
1073 if((value & FAPI_PRACH_LF_FORMAT_0_MASK) == FAPI_PRACH_LF_FORMAT_0_MASK)
1075 (*cellPtr)->prachLongFormats = FORMAT_0;
1077 else if((value & FAPI_PRACH_LF_FORMAT_1_MASK) == FAPI_PRACH_LF_FORMAT_1_MASK)
1079 (*cellPtr)->prachLongFormats = FORMAT_1;
1081 else if((value & FAPI_PRACH_LF_FORMAT_2_MASK) == FAPI_PRACH_LF_FORMAT_2_MASK)
1083 (*cellPtr)->prachLongFormats = FORMAT_2;
1085 else if((value & FAPI_PRACH_LF_FORMAT_3_MASK) == FAPI_PRACH_LF_FORMAT_3_MASK)
1087 (*cellPtr)->prachLongFormats = FORMAT_3;
1091 (*cellPtr)->prachLongFormats = INVALID_VALUE;
1095 /*******************************************************************
1097 * @brief fills the PRACH Short Format by comparing the bitmask
1101 * Function : fillPrachShortFormat
1104 * -checks the value with the bitmask and
1105 * fills the cellPtr's PRACH ShortFormat
1107 * @params[in] Pointer to ClCellParam
1108 * Value to be compared
1111 ******************************************************************/
1113 PUBLIC void fillPrachShortFormat(uint8_t value, ClCellParam **cellPtr)
1115 if((value & FAPI_PRACH_SF_FORMAT_A1_MASK) == FAPI_PRACH_SF_FORMAT_A1_MASK)
1117 (*cellPtr)->prachShortFormats = SF_FORMAT_A1;
1119 else if((value & FAPI_PRACH_SF_FORMAT_A2_MASK) == FAPI_PRACH_SF_FORMAT_A2_MASK)
1121 (*cellPtr)->prachShortFormats = SF_FORMAT_A2;
1123 else if((value & FAPI_PRACH_SF_FORMAT_A3_MASK) == FAPI_PRACH_SF_FORMAT_A3_MASK)
1125 (*cellPtr)->prachShortFormats = SF_FORMAT_A3;
1127 else if((value & FAPI_PRACH_SF_FORMAT_B1_MASK) == FAPI_PRACH_SF_FORMAT_B1_MASK)
1129 (*cellPtr)->prachShortFormats = SF_FORMAT_B1;
1131 else if((value & FAPI_PRACH_SF_FORMAT_B2_MASK) == FAPI_PRACH_SF_FORMAT_B2_MASK)
1133 (*cellPtr)->prachShortFormats = SF_FORMAT_B2;
1135 else if((value & FAPI_PRACH_SF_FORMAT_B3_MASK) == FAPI_PRACH_SF_FORMAT_B3_MASK)
1137 (*cellPtr)->prachShortFormats = SF_FORMAT_B3;
1139 else if((value & FAPI_PRACH_SF_FORMAT_B4_MASK) == FAPI_PRACH_SF_FORMAT_B4_MASK)
1141 (*cellPtr)->prachShortFormats = SF_FORMAT_B4;
1143 else if((value & FAPI_PRACH_SF_FORMAT_C0_MASK) == FAPI_PRACH_SF_FORMAT_C0_MASK)
1145 (*cellPtr)->prachShortFormats = SF_FORMAT_C0;
1147 else if((value & FAPI_PRACH_SF_FORMAT_C2_MASK) == FAPI_PRACH_SF_FORMAT_C2_MASK)
1149 (*cellPtr)->prachShortFormats = SF_FORMAT_C2;
1153 (*cellPtr)->prachShortFormats = INVALID_VALUE;
1157 /*******************************************************************
1159 * @brief fills the Fd Occasions Type by comparing the bitmask
1163 * Function : fillFdOccasions
1166 * -checks the value with the bitmask and
1167 * fills the cellPtr's Fd Occasions
1169 * @params[in] Pointer to ClCellParam
1170 * Value to be compared
1173 ******************************************************************/
1175 PUBLIC void fillFdOccasions(uint8_t value, ClCellParam **cellPtr)
1179 (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_1;
1183 (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_2;
1187 (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_4;
1191 (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_8;
1195 (*cellPtr)->maxPrachFdOccasionsInASlot = INVALID_VALUE;
1199 /*******************************************************************
1201 * @brief fills the RSSI Measurement by comparing the bitmask
1205 * Function : fillRssiMeas
1208 * -checks the value with the bitmask and
1209 * fills the cellPtr's RSSI Measurement report
1211 * @params[in] Pointer to ClCellParam
1212 * Value to be compared
1215 ******************************************************************/
1217 PUBLIC void fillRssiMeas(uint8_t value, ClCellParam **cellPtr)
1219 if((value & FAPI_RSSI_REPORT_IN_DBM_MASK) == FAPI_RSSI_REPORT_IN_DBM_MASK)
1221 (*cellPtr)->rssiMeasurementSupport = RSSI_REPORT_DBM;
1223 else if((value & FAPI_RSSI_REPORT_IN_DBFS_MASK) == FAPI_RSSI_REPORT_IN_DBFS_MASK)
1225 (*cellPtr)->rssiMeasurementSupport = RSSI_REPORT_DBFS;
1229 (*cellPtr)->rssiMeasurementSupport = INVALID_VALUE;
1233 /*******************************************************************
1235 * @brief Returns the TLVs value
1239 * Function : getParamValue
1242 * -return TLVs value
1245 * @return ROK - temp
1248 * ****************************************************************/
1250 uint32_t getParamValue(fapi_uint16_tlv_t *tlv, uint16_t type)
1252 //uint16_t valueLen;
1254 //valueLen = tlv->tl.length;
1255 posPtr = &tlv->tl.tag;
1256 posPtr += sizeof(tlv->tl.tag);
1257 posPtr += sizeof(tlv->tl.length);
1258 /*TO DO: malloc to SSI memory */
1259 if(type == FAPI_UINT_8)
1261 //temp = (uint8_t *)malloc(valueLen * sizeof(U8));
1262 //memcpy(temp, posPtr, valueLen);
1263 return(*(uint8_t *)posPtr);
1265 else if(type == FAPI_UINT_16)
1267 return(*(uint16_t *)posPtr);
1269 else if(type == FAPI_UINT_32)
1271 return(*(uint32_t *)posPtr);
1275 DU_LOG("\nLOWER MAC: Value Extraction failed" );
1280 /*******************************************************************
1282 * @brief Sends FAPI Param req to PHY
1286 * Function : lwr_mac_handleParamReqEvt
1289 * -Sends FAPI Param req to PHY
1292 * @return ROK - success
1295 * ****************************************************************/
1297 S16 lwr_mac_handleParamReqEvt(void *msg)
1300 /* startGuardTimer(); */
1301 uint32_t msgLen; //Length of message Body
1303 fapi_param_req_t *paramReq;
1304 MAC_ALLOC(paramReq, sizeof(fapi_param_req_t));
1305 if(paramReq != NULLP)
1307 fillMsgHeader(¶mReq->header, FAPI_PARAM_REQUEST, msgLen);
1308 DU_LOG("\nLOWER MAC: sending param Req to Phy");
1309 sendToPhy(paramReq->header.message_type_id, sizeof(fapi_param_req_t), (void *)paramReq);
1310 MAC_FREE(paramReq, sizeof(fapi_param_req_t));
1315 DU_LOG("\nLOWER MAC: Failed to allocate memory for Param Request");
1323 /*******************************************************************
1325 * @brief Sends FAPI Param Response to MAC via PHY
1329 * Function : lwr_mac_handleParamRspEvt
1332 * -Sends FAPI Param rsp to MAC via PHY
1335 * @return ROK - success
1338 * ****************************************************************/
1340 S16 lwr_mac_handleParamRspEvt(void *msg)
1343 /* stopGuardTimer(); */
1345 uint32_t encodedVal;
1346 fapi_param_resp_t *paramRsp;
1347 ClCellParam *cellParam = NULLP;
1349 paramRsp = (fapi_param_resp_t *)msg;
1350 DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
1352 if(paramRsp != NULLP)
1354 MAC_ALLOC(cellParam, sizeof(ClCellParam));
1355 if(cellParam != NULLP)
1357 DU_LOG("\n LOWER MAC: Filling TLVS into MAC API");
1358 if(paramRsp->error_code == MSG_OK)
1360 for(index = 0; index < paramRsp->number_of_tlvs; index++)
1362 switch(paramRsp->tlvs[index].tl.tag)
1364 case FAPI_RELEASE_CAPABILITY_TAG:
1365 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
1366 if(encodedVal != RFAILED && (encodedVal & RELEASE_15) == RELEASE_15)
1368 cellParam->releaseCapability = RELEASE_15;
1372 case FAPI_PHY_STATE_TAG:
1373 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1374 if(encodedVal != RFAILED && encodedVal != clGlobalCp.phyState)
1376 printf("\n PhyState mismatch [%d][%d]", clGlobalCp.phyState, clGlobalCp.event);
1381 case FAPI_SKIP_BLANK_DL_CONFIG_TAG:
1382 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1383 if(encodedVal != RFAILED && encodedVal != 0)
1385 cellParam->skipBlankDlConfig = SUPPORTED;
1389 cellParam->skipBlankDlConfig = NOT_SUPPORTED;
1393 case FAPI_SKIP_BLANK_UL_CONFIG_TAG:
1394 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1395 if(encodedVal != RFAILED && encodedVal != 0)
1397 cellParam->skipBlankUlConfig = SUPPORTED;
1401 cellParam->skipBlankUlConfig = NOT_SUPPORTED;
1405 case FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG:
1406 cellParam->numTlvsToReport = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
1409 case FAPI_CYCLIC_PREFIX_TAG:
1410 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1411 if(encodedVal != RFAILED)
1413 fillCyclicPrefix(encodedVal, &cellParam);
1417 case FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG:
1418 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1419 if(encodedVal != RFAILED)
1421 fillSubcarrierSpaceDl(encodedVal, &cellParam);
1425 case FAPI_SUPPORTED_BANDWIDTH_DL_TAG:
1426 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
1427 if(encodedVal != RFAILED)
1429 fillBandwidthDl(encodedVal, &cellParam);
1433 case FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG:
1434 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1435 if(encodedVal != RFAILED)
1437 fillSubcarrierSpaceUl(encodedVal, &cellParam);
1441 case FAPI_SUPPORTED_BANDWIDTH_UL_TAG:
1442 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
1443 if(encodedVal != RFAILED)
1445 fillBandwidthUl(encodedVal, &cellParam);
1449 case FAPI_CCE_MAPPING_TYPE_TAG:
1450 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1451 if(encodedVal != RFAILED)
1453 fillCCEmaping(encodedVal, &cellParam);
1457 case FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG:
1458 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1459 if(encodedVal != RFAILED && encodedVal != 0)
1461 cellParam->coresetOutsideFirst3OfdmSymsOfSlot = SUPPORTED;
1465 cellParam->coresetOutsideFirst3OfdmSymsOfSlot = NOT_SUPPORTED;
1469 case FAPI_PRECODER_GRANULARITY_CORESET_TAG:
1470 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1471 if(encodedVal != RFAILED && encodedVal != 0)
1473 cellParam->precoderGranularityCoreset = SUPPORTED;
1477 cellParam->precoderGranularityCoreset = NOT_SUPPORTED;
1481 case FAPI_PDCCH_MU_MIMO_TAG:
1482 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1483 if(encodedVal != RFAILED && encodedVal != 0)
1485 cellParam->pdcchMuMimo = SUPPORTED;
1489 cellParam->pdcchMuMimo = NOT_SUPPORTED;
1493 case FAPI_PDCCH_PRECODER_CYCLING_TAG:
1494 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1495 if(encodedVal != RFAILED && encodedVal != 0)
1497 cellParam->pdcchPrecoderCycling = SUPPORTED;
1501 cellParam->pdcchPrecoderCycling = NOT_SUPPORTED;
1505 case FAPI_MAX_PDCCHS_PER_SLOT_TAG:
1506 cellParam->maxPdcchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1509 case FAPI_PUCCH_FORMATS_TAG:
1510 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1511 if(encodedVal != RFAILED)
1513 fillPucchFormat(encodedVal, &cellParam);
1517 case FAPI_MAX_PUCCHS_PER_SLOT_TAG:
1518 cellParam->maxPucchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1521 case FAPI_PDSCH_MAPPING_TYPE_TAG:
1522 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1523 if(encodedVal != RFAILED)
1525 fillPdschMappingType(encodedVal, &cellParam);
1529 case FAPI_PDSCH_ALLOCATION_TYPES_TAG:
1530 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1531 if(encodedVal != RFAILED)
1533 fillPdschAllocationType(encodedVal, &cellParam);
1537 case FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG:
1538 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1539 if(encodedVal != RFAILED)
1541 fillPrbMappingType(encodedVal, &cellParam);
1545 case FAPI_PDSCH_CBG_TAG:
1546 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1547 if(encodedVal != RFAILED && encodedVal != 0)
1549 cellParam->pdschCbg = SUPPORTED;
1553 cellParam->pdschCbg = NOT_SUPPORTED;
1557 case FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG:
1558 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1559 if(encodedVal != RFAILED)
1561 fillPdschDmrsConfigType(encodedVal, &cellParam);
1565 case FAPI_PDSCH_DMRS_MAX_LENGTH_TAG:
1566 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1567 if(encodedVal != RFAILED)
1569 fillPdschDmrsLength(encodedVal, &cellParam);
1573 case FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG:
1574 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1575 if(encodedVal != RFAILED)
1577 fillPdschDmrsAddPos(encodedVal, &cellParam);
1581 case FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG:
1582 cellParam->maxPdschsTBsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1585 case FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG:
1586 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1587 if(encodedVal != RFAILED && encodedVal < FAPI_MAX_NUMBERMIMO_LAYERS_PDSCH)
1589 cellParam->maxNumberMimoLayersPdsch = encodedVal;
1593 case FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG:
1594 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1595 if(encodedVal != RFAILED)
1597 fillModulationOrderDl(encodedVal, &cellParam);
1601 case FAPI_MAX_MU_MIMO_USERS_DL_TAG:
1602 cellParam->maxMuMimoUsersDl = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1605 case FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG:
1606 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1607 if(encodedVal != RFAILED && encodedVal != 0)
1609 cellParam->pdschDataInDmrsSymbols = SUPPORTED;
1613 cellParam->pdschDataInDmrsSymbols = NOT_SUPPORTED;
1617 case FAPI_PREMPTIONSUPPORT_TAG:
1618 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1619 if(encodedVal != RFAILED && encodedVal != 0)
1621 cellParam->premptionSupport = SUPPORTED;
1625 cellParam->premptionSupport = NOT_SUPPORTED;
1629 case FAPI_PDSCH_NON_SLOT_SUPPORT_TAG:
1630 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1631 if(encodedVal != RFAILED && encodedVal != 0)
1633 cellParam->pdschNonSlotSupport = SUPPORTED;
1637 cellParam->pdschNonSlotSupport = NOT_SUPPORTED;
1641 case FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG:
1642 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1643 if(encodedVal != RFAILED && encodedVal != 0)
1645 cellParam->uciMuxUlschInPusch = SUPPORTED;
1649 cellParam->uciMuxUlschInPusch = NOT_SUPPORTED;
1653 case FAPI_UCI_ONLY_PUSCH_TAG:
1654 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1655 if(encodedVal != RFAILED && encodedVal != 0)
1657 cellParam->uciOnlyPusch = SUPPORTED;
1661 cellParam->uciOnlyPusch = NOT_SUPPORTED;
1665 case FAPI_PUSCH_FREQUENCY_HOPPING_TAG:
1666 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1667 if(encodedVal != RFAILED && encodedVal != 0)
1669 cellParam->puschFrequencyHopping = SUPPORTED;
1673 cellParam->puschFrequencyHopping = NOT_SUPPORTED;
1677 case FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG:
1678 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1679 if(encodedVal != RFAILED)
1681 fillPuschDmrsConfig(encodedVal, &cellParam);
1685 case FAPI_PUSCH_DMRS_MAX_LEN_TAG:
1686 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1687 if(encodedVal != RFAILED)
1689 fillPuschDmrsLength(encodedVal, &cellParam);
1693 case FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG:
1694 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1695 if(encodedVal != RFAILED)
1697 fillPuschDmrsAddPos(encodedVal, &cellParam);
1701 case FAPI_PUSCH_CBG_TAG:
1702 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1703 if(encodedVal != RFAILED && encodedVal != 0)
1705 cellParam->puschCbg = SUPPORTED;
1709 cellParam->puschCbg = NOT_SUPPORTED;
1713 case FAPI_PUSCH_MAPPING_TYPE_TAG:
1714 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1715 if(encodedVal != RFAILED)
1717 fillPuschMappingType(encodedVal, &cellParam);
1721 case FAPI_PUSCH_ALLOCATION_TYPES_TAG:
1722 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1723 if(encodedVal != RFAILED)
1725 fillPuschAllocationType(encodedVal, &cellParam);
1729 case FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG:
1730 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1731 if(encodedVal != RFAILED)
1733 fillPuschPrbMappingType(encodedVal, &cellParam);
1737 case FAPI_PUSCH_MAX_PTRS_PORTS_TAG:
1738 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1739 if(encodedVal != RFAILED && encodedVal < FAPI_PUSCH_MAX_PTRS_PORTS_UB)
1741 cellParam->puschMaxPtrsPorts = encodedVal;
1745 case FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG:
1746 cellParam->maxPduschsTBsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1749 case FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG:
1750 cellParam->maxNumberMimoLayersNonCbPusch = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1753 case FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG:
1754 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1755 if(encodedVal != RFAILED)
1757 fillModulationOrderUl(encodedVal, &cellParam);
1761 case FAPI_MAX_MU_MIMO_USERS_UL_TAG:
1762 cellParam->maxMuMimoUsersUl = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1765 case FAPI_DFTS_OFDM_SUPPORT_TAG:
1766 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1767 if(encodedVal != RFAILED && encodedVal != 0)
1769 cellParam->dftsOfdmSupport = SUPPORTED;
1773 cellParam->dftsOfdmSupport = NOT_SUPPORTED;
1777 case FAPI_PUSCH_AGGREGATION_FACTOR_TAG:
1778 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1779 if(encodedVal != RFAILED)
1781 fillPuschAggregationFactor(encodedVal, &cellParam);
1785 case FAPI_PRACH_LONG_FORMATS_TAG:
1786 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1787 if(encodedVal != RFAILED)
1789 fillPrachLongFormat(encodedVal, &cellParam);
1793 case FAPI_PRACH_SHORT_FORMATS_TAG:
1794 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1795 if(encodedVal != RFAILED)
1797 fillPrachShortFormat(encodedVal, &cellParam);
1801 case FAPI_PRACH_RESTRICTED_SETS_TAG:
1802 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1803 if(encodedVal != RFAILED && encodedVal != 0)
1805 cellParam->prachRestrictedSets = SUPPORTED;
1809 cellParam->prachRestrictedSets = NOT_SUPPORTED;
1813 case FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG:
1814 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1815 if(encodedVal != RFAILED)
1817 fillFdOccasions(encodedVal, &cellParam);
1821 case FAPI_RSSI_MEASUREMENT_SUPPORT_TAG:
1822 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1823 if(encodedVal != RFAILED)
1825 fillRssiMeas(encodedVal, &cellParam);
1829 //printf("\n Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index);
1833 MAC_FREE(cellParam, sizeof(ClCellParam));
1834 MAC_FREE(paramRsp, sizeof(fapi_param_resp_t));
1836 sendToLowerMac(FAPI_CONFIG_REQUEST, 0, (void *)NULL);
1841 DU_LOG("\n LOWER MAC: Invalid error code %d", paramRsp->error_code);
1847 DU_LOG("\nLOWER MAC: Failed to allocate memory for cell param");
1853 DU_LOG("\nLOWER MAC: Param Response received from PHY is NULL");
1861 /*******************************************************************
1863 * @brief Sends FAPI Config req to PHY
1867 * Function : lwr_mac_handleConfigReqEvt
1870 * -Sends FAPI Config Req to PHY
1873 * @return ROK - success
1876 * ****************************************************************/
1878 S16 lwr_mac_handleConfigReqEvt(void *msg)
1882 uint32_t msgLen = 0;
1883 uint32_t configReqSize;
1884 RgCellCb *cellParams;
1885 MacCellCfg macCfgParams;
1888 DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
1890 fapi_config_req_t *configReq;
1891 cellParams = rgCb[inst].cell;
1892 macCfgParams = cellParams->macCellCfg;
1893 configReqSize = sizeof(fapi_config_req_t) + (macCfgParams.numTlv * sizeof(fapi_uint16_tlv_t));
1894 MAC_ALLOC(configReq, configReqSize);
1896 if(configReq != NULL)
1898 configReq->number_of_tlvs = macCfgParams.numTlv;
1900 if(macCfgParams.dlCarrCfg.pres)
1902 fillTlvs(&configReq->tlvs[index++], FAPI_DL_BANDWIDTH_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.bw, &msgLen);
1903 fillTlvs(&configReq->tlvs[index++], FAPI_DL_FREQUENCY_TAG, sizeof(uint32_t), macCfgParams.dlCarrCfg.freq, &msgLen);
1904 fillTlvs(&configReq->tlvs[index++], FAPI_DL_K0_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.k0[0], &msgLen);
1905 fillTlvs(&configReq->tlvs[index++], FAPI_DL_GRIDSIZE_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.gridSize[0], &msgLen);
1906 fillTlvs(&configReq->tlvs[index++], FAPI_NUM_TX_ANT_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.numAnt, &msgLen);
1908 if(macCfgParams.ulCarrCfg.pres)
1910 fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_BANDWIDTH_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.bw, &msgLen);
1911 fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_FREQUENCY_TAG, sizeof(uint32_t), macCfgParams.ulCarrCfg.freq, &msgLen);
1912 fillTlvs(&configReq->tlvs[index++], FAPI_UL_K0_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.k0[0], &msgLen);
1913 fillTlvs(&configReq->tlvs[index++], FAPI_UL_GRID_SIZE_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.gridSize[0], &msgLen);
1914 fillTlvs(&configReq->tlvs[index++], FAPI_NUM_RX_ANT_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.numAnt, &msgLen);
1916 fillTlvs(&configReq->tlvs[index++], FAPI_FREQUENCY_SHIFT_7P5_KHZ_TAG, sizeof(uint8_t), macCfgParams.freqShft, &msgLen);
1918 /* fill cell config */
1919 fillTlvs(&configReq->tlvs[index++], FAPI_PHY_CELL_ID_TAG, sizeof(uint8_t), macCfgParams.phyCellId, &msgLen);
1920 fillTlvs(&configReq->tlvs[index++], FAPI_FRAME_DUPLEX_TYPE_TAG, sizeof(uint8_t), macCfgParams.dupType, &msgLen);
1922 /* fill SSB configuration */
1923 fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_POWER_TAG, sizeof(uint32_t), macCfgParams.ssbCfg.ssbPbchPwr, &msgLen);
1924 fillTlvs(&configReq->tlvs[index++], FAPI_BCH_PAYLOAD_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.bchPayloadFlag, &msgLen);
1925 fillTlvs(&configReq->tlvs[index++], FAPI_SCS_COMMON_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.scsCmn, &msgLen);
1927 /* fill PRACH configuration */
1928 fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SEQUENCE_LENGTH_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachSeqLen, &msgLen);
1929 fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SUBC_SPACING_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachSubcSpacing, &msgLen);
1930 fillTlvs(&configReq->tlvs[index++], FAPI_RESTRICTED_SET_CONFIG_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachRstSetCfg, &msgLen);
1931 fillTlvs(&configReq->tlvs[index++], FAPI_NUM_PRACH_FD_OCCASIONS_TAG,
1932 sizeof(uint8_t), macCfgParams.prachCfg.msg1Fdm, &msgLen);
1933 fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ROOT_SEQUENCE_INDEX_TAG, sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].rootSeqIdx, &msgLen);
1934 fillTlvs(&configReq->tlvs[index++], FAPI_NUM_ROOT_SEQUENCES_TAG, sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numRootSeq, &msgLen);
1935 fillTlvs(&configReq->tlvs[index++], FAPI_K1_TAG, sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].k1, &msgLen);
1936 fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ZERO_CORR_CONF_TAG , sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].zeroCorrZoneCfg, &msgLen);
1937 fillTlvs(&configReq->tlvs[index++], FAPI_NUM_UNUSED_ROOT_SEQUENCES_TAG, sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numUnusedRootSeq, &msgLen);
1938 //MAC_ALLOC(macCfgParams.prachCfg.fdm[0].unsuedRootSeq, \
1939 sizeof(uint8_t)*macCfgParams.prachCfg.fdm[0].numUnusedRootSeq);
1940 macCfgParams.prachCfg.fdm[0].unsuedRootSeq = (uint8_t *)malloc(sizeof(uint8_t)*macCfgParams.prachCfg.fdm[0].numUnusedRootSeq);
1941 fillTlvs(&configReq->tlvs[index++], FAPI_UNUSED_ROOT_SEQUENCES_TAG,
1942 sizeof(uint8_t), *(macCfgParams.prachCfg.fdm[0].unsuedRootSeq), &msgLen);
1943 fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PER_RACH_TAG, sizeof(uint8_t), macCfgParams.prachCfg.ssbPerRach, &msgLen);
1944 fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachMultCarrBand, &msgLen);
1946 /* fill SSB table */
1947 fillTlvs(&configReq->tlvs[index++], FAPI_SSB_OFFSET_POINT_A_TAG, sizeof(uint16_t), macCfgParams.ssbCfg.ssbOffsetPointA, &msgLen);
1948 fillTlvs(&configReq->tlvs[index++], FAPI_BETA_PSS_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.betaPss, &msgLen);
1949 fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PERIOD_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.ssbPeriod, &msgLen);
1950 fillTlvs(&configReq->tlvs[index++], FAPI_SSB_SUBCARRIER_OFFSET_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.ssbScOffset, &msgLen);
1951 fillTlvs(&configReq->tlvs[index++], FAPI_MIB_TAG , sizeof(uint32_t), macCfgParams.ssbCfg.mibPdu[0], &msgLen);
1952 fillTlvs(&configReq->tlvs[index++], FAPI_SSB_MASK_TAG, sizeof(uint32_t), macCfgParams.ssbCfg.ssbMask[0], &msgLen);
1953 fillTlvs(&configReq->tlvs[index++], FAPI_BEAM_ID_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.beamId[0], &msgLen);
1954 fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.multCarrBand, &msgLen);
1955 fillTlvs(&configReq->tlvs[index++], FAPI_MULTIPLE_CELLS_SS_PBCH_IN_A_CARRIER_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.multCellCarr, &msgLen);
1957 /* fill TDD table */
1958 fillTlvs(&configReq->tlvs[index++], FAPI_TDD_PERIOD_TAG, sizeof(uint8_t), macCfgParams.tddCfg.tddPeriod, &msgLen);
1959 fillTlvs(&configReq->tlvs[index++], FAPI_SLOT_CONFIG_TAG, sizeof(uint8_t), macCfgParams.tddCfg.slotCfg[0][0], &msgLen);
1961 /* fill measurement config */
1962 fillTlvs(&configReq->tlvs[index++], FAPI_RSSI_MESUREMENT_TAG, sizeof(uint8_t), macCfgParams.rssiUnit, &msgLen);
1964 fillMsgHeader(&configReq->header, FAPI_CONFIG_REQUEST, msgLen);
1965 DU_LOG("\nLOWER_MAC: Sending Config Request to Phy");
1966 sendToPhy(configReq->header.message_type_id, msgLen, (void *)configReq);
1967 MAC_FREE(configReq, configReqSize);
1972 DU_LOG("\nLOWER_MAC: Failed to allocate memory for config Request");
1980 S16 lwr_mac_handleConfigRspEvt(void *msg)
1983 fapi_config_resp_t *configRsp;
1984 configRsp = (fapi_config_resp_t *)msg;
1985 DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
1987 if(configRsp != NULL)
1989 if(configRsp->error_code == MSG_OK)
1991 DU_LOG("\nLOWER MAC: PHY has moved to Conigured state \n");
1992 clGlobalCp.phyState = PHY_STATE_CONFIGURED;
1994 * Store config response into an intermediate struture and send to MAC
1995 * Support LC and LWLC for sending config rsp to MAC
1998 MAC_FREE(configRsp, sizeof(fapi_config_resp_t));
2004 DU_LOG("\n LOWER MAC: Invalid error code %d", configRsp->error_code);
2010 DU_LOG("\nLOWER_MAC: Config Response received from PHY is NULL");
2018 S16 lwr_mac_handleStartReqEvt(void *msg)
2021 uint32_t msgLen = 0;
2022 fapi_start_req_t *startReq;
2023 MAC_ALLOC(startReq, sizeof(fapi_start_req_t));
2025 if(startReq != NULL)
2027 fillMsgHeader(&startReq->header, FAPI_START_REQUEST, msgLen);
2028 DU_LOG("\nLOWER MAC: Sending Start Request to PHY");
2029 sendToPhy(startReq->header.message_type_id, sizeof(fapi_start_req_t), (void *)startReq);
2030 MAC_FREE(startReq, sizeof(fapi_start_req_t));
2035 DU_LOG("\nLOWER MAC: Failed to allocate memory for Start Request");
2043 S16 lwr_mac_handleStopReqEvt(void *msg)
2046 /* stop TX and RX operation return PHy to configured State
2047 send stop.indication to l2/l3 */
2053 /*******************************************************************
2055 * @brief Modifes the received mibPdu to uint32 bit
2056 * and stores it in MacCellCfg
2060 * Function : setMibPdu
2065 * @params[in] Pointer to mibPdu
2066 * pointer to modified value
2067 ******************************************************************/
2069 PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val)
2071 *mibPdu |= (((uint8_t)(slotIndInfo.sfn >> 2)) & MIB_SFN_BITMASK);
2072 *val = (mibPdu[0] << 24 | mibPdu[1] << 16 | mibPdu[2] << 8);
2073 DU_LOG("\nLOWER MAC: value filled %x", *val);
2077 /*******************************************************************
2079 * @brief fills SSB PDU required for DL TTI info in MAC
2083 * Function : fillSsbPdu
2086 * -Fills the SSB PDU info
2089 * @params[in] Pointer to FAPI DL TTI Req
2090 * Pointer to RgCellCb
2091 * Pointer to msgLen of DL TTI Info
2094 ******************************************************************/
2096 S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg,
2097 MacDlSlot *currDlSlot,
2098 uint32_t *msgLen, uint8_t ssbIdxCount)
2100 uint32_t mibPayload = 0;
2101 if(dlTtiReqPdu != NULL)
2103 dlTtiReqPdu->pduType = SSB_PDU_TYPE; /* SSB PDU */
2104 dlTtiReqPdu->u.ssb_pdu.physCellId = macCellCfg->phyCellId;
2105 dlTtiReqPdu->u.ssb_pdu.betaPss = macCellCfg->ssbCfg.betaPss;
2106 dlTtiReqPdu->u.ssb_pdu.ssbBlockIndex = currDlSlot->cellBroadcastInfo.ssbInfo[ssbIdxCount].ssbIdx;
2107 dlTtiReqPdu->u.ssb_pdu.ssbSubCarrierOffset = macCellCfg->ssbCfg.ssbScOffset;
2108 /* ssbOfPdufstA to be filled in ssbCfg */
2109 dlTtiReqPdu->u.ssb_pdu.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA;
2110 dlTtiReqPdu->u.ssb_pdu.bchPayloadFlag = macCellCfg->ssbCfg.bchPayloadFlag;
2111 /* Bit manipulation for SFN */
2112 setMibPdu(macCellCfg->ssbCfg.mibPdu, &mibPayload);
2113 dlTtiReqPdu->u.ssb_pdu.bchPayload.v.bchPayload = mibPayload;
2114 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.numPrgs = 0;
2115 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.prgSize = 0;
2116 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.digBfInterfaces = 0;
2117 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.pmi_bfi[0].pmIdx = 0;
2118 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming. \
2119 pmi_bfi[0].beamIdx[0].beamidx = macCellCfg->ssbCfg.beamId[0];
2120 dlTtiReqPdu->pduSize = sizeof(fapi_dl_ssb_pdu_t); /* Size of SSB PDU */
2121 SETLENGTH(*msgLen, sizeof(fapi_dl_ssb_pdu_t));
2130 /*******************************************************************
2132 * @brief fills Dl DCI PDU required for DL TTI info in MAC
2136 * Function : fillDlDciPdu
2139 * -Fills the Dl DCI PDU
2141 * @params[in] Pointer to fapi_dl_dci_t
2142 * Pointer to Sib1PdcchCfg
2145 ******************************************************************/
2147 void fillDlDciPdu(fapi_dl_dci_t *dlDciPtr, Sib1PdcchCfg *sib1PdcchInfo)
2149 if(dlDciPtr != NULLP)
2155 uint16_t coreset0Size;
2158 uint32_t freqDomResAssign;
2159 uint32_t timeDomResAssign;
2161 uint32_t modNCodScheme;
2162 uint8_t redundancyVer;
2163 uint32_t sysInfoInd;
2166 /* Size(in bits) of each field in DCI format 0_1
2167 * as mentioned in spec 38.214 */
2168 uint8_t freqDomResAssignSize;
2169 uint8_t timeDomResAssignSize = 4;
2170 uint8_t VRB2PRBMapSize = 1;
2171 uint8_t modNCodSchemeSize = 5;
2172 uint8_t redundancyVerSize = 2;
2173 uint8_t sysInfoIndSize = 1;
2174 uint8_t reservedSize = 15;
2176 dlDciPtr->rnti = sib1PdcchInfo->sib1DlDci.rnti;
2177 dlDciPtr->scramblingId = sib1PdcchInfo->sib1DlDci.scramblingId;
2178 dlDciPtr->scramblingRnti = sib1PdcchInfo->sib1DlDci.scramblingRnti;
2179 dlDciPtr->cceIndex = sib1PdcchInfo->sib1DlDci.cceIndex;
2180 dlDciPtr->aggregationLevel = sib1PdcchInfo->sib1DlDci.aggregLevel;
2181 dlDciPtr->pc_and_bform.numPrgs = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.numPrgs;
2182 dlDciPtr->pc_and_bform.prgSize = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.prgSize;
2183 dlDciPtr->pc_and_bform.digBfInterfaces = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.digBfInterfaces;
2184 dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.prg[0].pmIdx;
2185 dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.prg[0].beamIdx[0];
2186 dlDciPtr->beta_pdcch_1_0 = sib1PdcchInfo->sib1DlDci.txPdcchPower.powerValue;
2187 dlDciPtr->powerControlOfssetSS = sib1PdcchInfo->sib1DlDci.txPdcchPower.powerControlOffsetSS;
2189 /* Calculating freq domain resource allocation field value and size
2190 * coreset0Size = Size of coreset 0
2191 * RBStart = Starting Virtual Rsource block
2192 * RBLen = length of contiguously allocted RBs
2193 * Spec 38.214 Sec 5.1.2.2.2
2195 coreset0Size= sib1PdcchInfo->sib1Coreset0Cfg.coreSet0Size;
2196 rbStart = 0; /* For SIB1 */
2197 //rbStart = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1FreqAlloc.rbStart;
2198 rbLen = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1FreqAlloc.rbSize;
2200 if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
2202 if((rbLen - 1) <= floor(coreset0Size / 2))
2203 freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart;
2205 freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \
2206 + (coreset0Size - 1 - rbStart);
2208 freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2));
2211 /* Fetching DCI field values */
2212 timeDomResAssign = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1TimeAlloc.
2214 VRB2PRBMap = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1FreqAlloc.\
2216 modNCodScheme = sib1PdcchInfo->sib1DlDci.pdschCfg->codeword[0].mcsIndex;
2217 redundancyVer = sib1PdcchInfo->sib1DlDci.pdschCfg->codeword[0].rvIndex;
2218 sysInfoInd = 0; /* 0 for SIB1; 1 for SI messages */
2221 /* Reversing bits in each DCI field */
2222 freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize);
2223 timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
2224 VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize);
2225 modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize);
2226 redundancyVer = reverseBits(redundancyVer, redundancyVerSize);
2227 sysInfoInd = reverseBits(sysInfoInd, sysInfoIndSize);
2228 reserved = reverseBits(reserved, reservedSize);
2230 /* Calulating total number of bytes in buffer */
2231 dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\
2232 + VRB2PRBMapSize + modNCodSchemeSize + redundancyVerSize\
2233 + sysInfoIndSize + reservedSize;
2235 numBytes = dlDciPtr->payloadSizeBits / 8;
2236 if(dlDciPtr->payloadSizeBits % 8)
2239 if(numBytes > DCI_PAYLOAD_BYTE_LEN)
2241 DU_LOG("\nLOWER MAC : Total bytes for DCI is more than expected");
2245 /* Initialize buffer */
2246 for(bytePos = 0; bytePos < numBytes; bytePos++)
2247 dlDciPtr->payload[bytePos] = 0;
2249 bytePos = numBytes - 1;
2252 /* Packing DCI format fields */
2253 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2254 freqDomResAssign, freqDomResAssignSize);
2255 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2256 timeDomResAssign, timeDomResAssignSize);
2257 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2258 VRB2PRBMap, VRB2PRBMapSize);
2259 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2260 modNCodScheme, modNCodSchemeSize);
2261 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2262 redundancyVer, redundancyVerSize);
2263 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2264 sysInfoInd, sysInfoIndSize);
2265 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2266 reserved, reservedSize);
2269 } /* fillDlDciPdu */
2271 /*******************************************************************
2273 * @brief fills PDCCH PDU required for DL TTI info in MAC
2277 * Function : fillPdcchPdu
2280 * -Fills the Pdcch PDU info
2283 * @params[in] Pointer to FAPI DL TTI Req
2284 * Pointer to Sib1PdcchCfg
2285 * Pointer to msgLen of DL TTI Info
2288 ******************************************************************/
2290 S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, Sib1PdcchCfg *sib1PdcchInfo,
2293 if(dlTtiReqPdu != NULLP)
2295 dlTtiReqPdu->pduType = PDCCH_PDU_TYPE;
2296 dlTtiReqPdu->u.pdcch_pdu.bwpSize = sib1PdcchInfo->sib1PdcchBwpCfg.BWPSize;
2297 dlTtiReqPdu->u.pdcch_pdu.bwpPart = sib1PdcchInfo->sib1PdcchBwpCfg.BWPStart;
2298 dlTtiReqPdu->u.pdcch_pdu.subCarrierSpacing = sib1PdcchInfo->sib1PdcchBwpCfg.subcarrierSpacing;
2299 dlTtiReqPdu->u.pdcch_pdu.cyclicPrefix = sib1PdcchInfo->sib1PdcchBwpCfg.cyclicPrefix;
2300 dlTtiReqPdu->u.pdcch_pdu.startSymbolIndex = sib1PdcchInfo->sib1Coreset0Cfg.startSymbolIndex;
2301 dlTtiReqPdu->u.pdcch_pdu.durationSymbols = sib1PdcchInfo->sib1Coreset0Cfg.durationSymbols;
2302 memcpy(dlTtiReqPdu->u.pdcch_pdu.freqDomainResource, sib1PdcchInfo->sib1Coreset0Cfg.freqDomainResource, 6);
2303 dlTtiReqPdu->u.pdcch_pdu.cceRegMappingType = sib1PdcchInfo->sib1Coreset0Cfg.cceRegMappingType;
2304 dlTtiReqPdu->u.pdcch_pdu.regBundleSize = sib1PdcchInfo->sib1Coreset0Cfg.regBundleSize;
2305 dlTtiReqPdu->u.pdcch_pdu.interleaverSize = sib1PdcchInfo->sib1Coreset0Cfg.interleaverSize;
2306 dlTtiReqPdu->u.pdcch_pdu.coreSetSize = sib1PdcchInfo->sib1Coreset0Cfg.coreSetType;
2307 dlTtiReqPdu->u.pdcch_pdu.shiftIndex = sib1PdcchInfo->sib1Coreset0Cfg.shiftIndex;
2308 dlTtiReqPdu->u.pdcch_pdu.precoderGranularity = sib1PdcchInfo->sib1Coreset0Cfg.precoderGranularity;
2309 dlTtiReqPdu->u.pdcch_pdu.numDlDci = sib1PdcchInfo->numDlDci;
2310 MAC_ALLOC(dlTtiReqPdu->u.pdcch_pdu.dlDci, sizeof(fapi_dl_dci_t));
2311 fillDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, sib1PdcchInfo);
2312 dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t);
2313 SETLENGTH(*msgLen, sizeof(fapi_dl_pdcch_pdu_t));
2320 /*******************************************************************
2322 * @brief fills PDSCH PDU required for DL TTI info in MAC
2326 * Function : fillPdschPdu
2329 * -Fills the Pdsch PDU info
2332 * @params[in] Pointer to FAPI DL TTI Req
2333 * Pointer to Sib1PdschCfg
2334 * Pointer to msgLen of DL TTI Info
2337 ******************************************************************/
2339 void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, Sib1PdschCfg *sib1PdschInfo,
2344 if(dlTtiReqPdu != NULLP)
2346 dlTtiReqPdu->pduType = PDSCH_PDU_TYPE;
2347 dlTtiReqPdu->u.pdsch_pdu.pduBitMap = sib1PdschInfo->pduBitmap;
2348 dlTtiReqPdu->u.pdsch_pdu.rnti = sib1PdschInfo->rnti;
2349 dlTtiReqPdu->u.pdsch_pdu.pduIndex = sib1PdschInfo->pduIndex;
2350 dlTtiReqPdu->u.pdsch_pdu.bwpSize = sib1PdschInfo->sib1PdschBwpCfg.BWPSize;
2351 dlTtiReqPdu->u.pdsch_pdu.bwpStart = sib1PdschInfo->sib1PdschBwpCfg.BWPStart;
2352 dlTtiReqPdu->u.pdsch_pdu.subCarrierSpacing = sib1PdschInfo->sib1PdschBwpCfg.subcarrierSpacing;
2353 dlTtiReqPdu->u.pdsch_pdu.cyclicPrefix = sib1PdschInfo->sib1PdschBwpCfg.cyclicPrefix;
2354 dlTtiReqPdu->u.pdsch_pdu.nrOfCodeWords = sib1PdschInfo->numCodewords;
2355 for(idx = 0; idx < MAX_CODEWORDS ; idx++)
2357 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].targetCodeRate = sib1PdschInfo->codeword[idx].targetCodeRate;
2358 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].qamModOrder = sib1PdschInfo->codeword[idx].qamModOrder;
2359 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsIndex = sib1PdschInfo->codeword[idx].mcsIndex;
2360 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsTable = sib1PdschInfo->codeword[idx].mcsTable;
2361 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].rvIndex = sib1PdschInfo->codeword[idx].rvIndex;
2362 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].tbSize = sib1PdschInfo->codeword[idx].tbSize;
2364 dlTtiReqPdu->u.pdsch_pdu.dataScramblingId = sib1PdschInfo->dataScramblingId;
2365 dlTtiReqPdu->u.pdsch_pdu.nrOfLayers = sib1PdschInfo->numLayers;
2366 dlTtiReqPdu->u.pdsch_pdu.transmissionScheme = sib1PdschInfo->transmissionScheme;
2367 dlTtiReqPdu->u.pdsch_pdu.refPoint = sib1PdschInfo->refPoint;
2368 dlTtiReqPdu->u.pdsch_pdu.dlDmrsSymbPos = sib1PdschInfo->dmrs.dlDmrsSymbPos;
2369 dlTtiReqPdu->u.pdsch_pdu.dmrsConfigType = sib1PdschInfo->dmrs.dmrsConfigType;
2370 dlTtiReqPdu->u.pdsch_pdu.dlDmrsScramblingId = sib1PdschInfo->dmrs.dlDmrsScramblingId;
2371 dlTtiReqPdu->u.pdsch_pdu.scid = sib1PdschInfo->dmrs.scid;
2372 dlTtiReqPdu->u.pdsch_pdu.numDmrsCdmGrpsNoData = sib1PdschInfo->dmrs.numDmrsCdmGrpsNoData;
2373 dlTtiReqPdu->u.pdsch_pdu.dmrsPorts = sib1PdschInfo->dmrs.dmrsPorts;
2374 dlTtiReqPdu->u.pdsch_pdu.resourceAlloc = sib1PdschInfo->sib1FreqAlloc.resourceAlloc;
2375 /* since we are using type-1, hence rbBitmap excluded */
2376 dlTtiReqPdu->u.pdsch_pdu.rbStart = sib1PdschInfo->sib1FreqAlloc.rbStart;
2377 dlTtiReqPdu->u.pdsch_pdu.rbSize = sib1PdschInfo->sib1FreqAlloc.rbSize;
2378 dlTtiReqPdu->u.pdsch_pdu.vrbToPrbMapping = sib1PdschInfo->sib1FreqAlloc.vrbPrbMapping;
2379 dlTtiReqPdu->u.pdsch_pdu.startSymbIndex = sib1PdschInfo->sib1TimeAlloc.startSymbolIndex;
2380 dlTtiReqPdu->u.pdsch_pdu.nrOfSymbols = sib1PdschInfo->sib1TimeAlloc.numSymbols;
2381 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.numPrgs = sib1PdschInfo->beamPdschInfo.numPrgs;
2382 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.prgSize = sib1PdschInfo->beamPdschInfo.prgSize;
2383 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = sib1PdschInfo->beamPdschInfo.digBfInterfaces;
2384 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
2385 pmIdx = sib1PdschInfo->beamPdschInfo.prg[0].pmIdx;
2386 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
2387 beamIdx[0].beamidx = sib1PdschInfo->beamPdschInfo.prg[0].beamIdx[0];
2388 dlTtiReqPdu->u.pdsch_pdu.powerControlOffset = sib1PdschInfo->txPdschPower.powerControlOffset;
2389 dlTtiReqPdu->u.pdsch_pdu.powerControlOffsetSS = sib1PdschInfo->txPdschPower.powerControlOffsetSS;
2390 dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdsch_pdu_t);
2391 SETLENGTH(*msgLen, sizeof(fapi_dl_pdsch_pdu_t));
2397 /***********************************************************************
2399 * @brief calculates the total size to be allocated for DL TTI Req
2403 * Function : calculatePduCount
2406 * -calculates the total pdu count to be allocated for DL TTI Req
2408 * @params[in] DlBrdcstAlloc *cellBroadcastInfo
2411 * ********************************************************************/
2412 uint8_t calculatePduCount(DlBrdcstAlloc *cellBroadcastInfo)
2416 if(cellBroadcastInfo->ssbTrans)
2418 for(idx = 0; idx < cellBroadcastInfo->ssbIdxSupported; idx++)
2423 if(cellBroadcastInfo->sib1Trans)
2432 /*******************************************************************
2434 * @brief Sends DL TTI Request to PHY
2438 * Function : handleDlTtiReq
2441 * -Sends FAPI Param req to PHY
2443 * @params[in] RgDlSf *dlTtiReqSlot
2444 * @return ROK - success
2447 * ****************************************************************/
2448 S16 handleDlTtiReq(CmLteTimingInfo *dlTtiReqtimingInfo)
2452 uint32_t msgLen = 0;
2453 fapi_dl_tti_req_t *dlTtiReq = NULLP;
2454 fapi_dl_tti_req_pdu_t *dlTtiReqPdu = NULLP;
2455 RgCellCb *cellCbParams = NULLP;
2456 MacDlSlot *currDlSlot = NULLP;
2457 MacCellCfg macCellCfg;
2458 cmMemset((U8 *)&macCellCfg, 0, sizeof(MacCellCfg));
2461 if(clGlobalCp.phyState == PHY_STATE_RUNNING)
2463 cellCbParams = rgCb[inst].cell;
2464 macCellCfg = cellCbParams->macCellCfg;
2466 if(dlTtiReqtimingInfo != NULLP)
2468 MAC_ALLOC(dlTtiReq, sizeof(fapi_dl_tti_req_t));
2469 if(dlTtiReq != NULLP)
2471 dlTtiReq->sfn = dlTtiReqtimingInfo->sfn;
2472 dlTtiReq->slot = dlTtiReqtimingInfo->slot;
2473 currDlSlot = &macCb.macCell->dlSlot[dlTtiReq->slot % MAX_SLOT_SUPPORTED];
2474 dlTtiReq->nPdus = calculatePduCount(&currDlSlot->cellBroadcastInfo); /* get total Pdus */
2475 dlTtiReq->nGroup = 0;
2476 if(dlTtiReq->nPdus > 0)
2478 MAC_ALLOC(dlTtiReqPdu, (dlTtiReq->nPdus * sizeof(fapi_dl_tti_req_pdu_t)));
2479 if(currDlSlot->cellBroadcastInfo.ssbTrans)
2481 if(dlTtiReqPdu != NULLP)
2483 for(idx = 0; idx < currDlSlot->cellBroadcastInfo.ssbIdxSupported; idx++)
2487 fillSsbPdu(dlTtiReqPdu, &macCellCfg, currDlSlot, &msgLen, idx);
2488 dlTtiReq->pdus = dlTtiReqPdu;
2492 if(currDlSlot->cellBroadcastInfo.sib1Trans)
2494 /* Filling SIB1 param */
2495 if(dlTtiReqPdu != NULLP)
2498 fillPdcchPdu(dlTtiReqPdu, &currDlSlot->cellBroadcastInfo.sib1Alloc.sib1PdcchCfg, &msgLen);
2499 dlTtiReq->pdus = dlTtiReqPdu;
2501 fillPdschPdu(dlTtiReqPdu, &currDlSlot->cellBroadcastInfo.sib1Alloc.sib1PdschCfg, &msgLen);
2502 dlTtiReq->pdus = dlTtiReqPdu;
2505 msgLen += sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
2506 fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
2507 sendToPhy(dlTtiReq->header.message_type_id, msgLen, (void *)dlTtiReq);
2508 if(currDlSlot->cellBroadcastInfo.sib1Trans)
2510 MAC_FREE(dlTtiReq->pdus->u.pdcch_pdu.dlDci, sizeof(fapi_dl_dci_t));
2512 MAC_FREE(dlTtiReqPdu, (dlTtiReq->nPdus * sizeof(fapi_dl_tti_req_pdu_t)));
2516 msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
2517 fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
2518 sendToPhy(dlTtiReq->header.message_type_id, msgLen, (void *)dlTtiReq);
2520 MAC_FREE(dlTtiReq, sizeof(fapi_dl_tti_req_t));
2525 DU_LOG("\nLOWER MAC: Failed to allocate memory for DL TTI Request");
2531 DU_LOG("\nLOWER MAC: Current TTI Info is NULL");
2537 lwr_mac_handleInvalidEvt(dlTtiReqtimingInfo);
2544 lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] =
2547 /* PHY_STATE_IDLE */
2548 lwr_mac_handleParamReqEvt,
2549 lwr_mac_handleParamRspEvt,
2550 lwr_mac_handleConfigReqEvt,
2551 lwr_mac_handleConfigRspEvt,
2552 lwr_mac_handleInvalidEvt,
2555 /* PHY_STATE_CONFIGURED */
2556 lwr_mac_handleParamReqEvt,
2557 lwr_mac_handleParamRspEvt,
2558 lwr_mac_handleConfigReqEvt,
2559 lwr_mac_handleConfigRspEvt,
2560 lwr_mac_handleStartReqEvt,
2563 /* PHY_STATE_RUNNING */
2564 lwr_mac_handleInvalidEvt,
2565 lwr_mac_handleInvalidEvt,
2566 lwr_mac_handleConfigReqEvt,
2567 lwr_mac_handleConfigRspEvt,
2568 lwr_mac_handleInvalidEvt,
2572 /*******************************************************************
2574 * @brief Sends message to Lower Mac Fsm Event Handler
2578 * Function : sendToLowerMac
2581 * -Sends message to LowerMac
2583 * @params[in] Message Type
2589 ******************************************************************/
2590 void sendToLowerMac(uint16_t msgType, uint32_t msgLen, void *msg)
2592 clGlobalCp.event = msgType;
2593 fapiEvtHdlr[clGlobalCp.phyState][clGlobalCp.event](msg);
2595 /**********************************************************************
2597 **********************************************************************/