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 */
64 #include "lwr_mac_phy.h"
67 #define MIB_SFN_BITMASK 0xFC
68 #define PDCCH_PDU_TYPE 0
69 #define PDSCH_PDU_TYPE 1
70 #define SSB_PDU_TYPE 3
71 #define SETLENGTH(x, size) x += size
73 extern void fapiMacConfigRsp();
74 /* Global variables */
75 SlotIndInfo slotIndInfo;
83 /* Initializing WLS free mem list */
85 for(idx = 0; idx < WLS_MEM_FREE_PRD; idx++)
87 cmLListInit(&wlsBlockToFreeList[idx]);
92 /*******************************************************************
94 * @brief Handles Invalid Request Event
98 * Function : lwr_mac_handleInvalidEvt
101 * - Displays the PHY state when the invalid event occurs
104 * @return ROK - success
107 * ****************************************************************/
108 S16 lwr_mac_handleInvalidEvt(void *msg)
110 printf("\nLOWER MAC: Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState);
115 /*******************************************************************
117 * @brief Fills FAPI message header
121 * Function : fillMsgHeader
124 * -Fills FAPI message header
126 * @params[in] Pointer to header
132 * ****************************************************************/
133 PUBLIC void fillMsgHeader(fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen)
135 hdr->message_type_id = msgType;
136 hdr->length = msgLen;
139 /*******************************************************************
141 * @brief Fills FAPI Config Request message header
145 * Function : fillTlvs
148 * -Fills FAPI Config Request message header
150 * @params[in] Pointer to TLV
157 * ****************************************************************/
158 PUBLIC void fillTlvs(fapi_uint16_tlv_t *tlv, uint16_t tag, uint16_t length,
159 uint16_t value, uint32_t *msgLen)
162 tlv->tl.length = length;
164 *msgLen = *msgLen + sizeof(tag) + sizeof(length) + length;
166 /*******************************************************************
168 * @brief fills the cyclic prefix by comparing the bitmask
172 * Function : fillCyclicPrefix
175 * -checks the value with the bitmask and
176 * fills the cellPtr's cyclic prefix.
178 * @params[in] Pointer to ClCellParam
179 * Value to be compared
182 ********************************************************************/
183 PUBLIC void fillCyclicPrefix(uint8_t value, ClCellParam **cellPtr)
185 if((value & FAPI_NORMAL_CYCLIC_PREFIX_MASK) == FAPI_NORMAL_CYCLIC_PREFIX_MASK)
187 (*cellPtr)->cyclicPrefix = NORMAL_CYCLIC_PREFIX_MASK;
189 else if((value & FAPI_EXTENDED_CYCLIC_PREFIX_MASK) == FAPI_EXTENDED_CYCLIC_PREFIX_MASK)
191 (*cellPtr)->cyclicPrefix = EXTENDED_CYCLIC_PREFIX_MASK;
195 (*cellPtr)->cyclicPrefix = INVALID_VALUE;
199 /*******************************************************************
201 * @brief fills the subcarrier spacing of Downlink by comparing the bitmask
205 * Function : fillSubcarrierSpaceDl
208 * -checks the value with the bitmask and
209 * fills the cellPtr's subcarrier spacing in DL
211 * @params[in] Pointer to ClCellParam
212 * Value to be compared
215 * ****************************************************************/
217 PUBLIC void fillSubcarrierSpaceDl(uint8_t value, ClCellParam **cellPtr)
219 if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
221 (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_15_KHZ;
223 else if((value & FAPI_30KHZ_MASK) == FAPI_30KHZ_MASK)
225 (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_30_KHZ;
227 else if((value & FAPI_60KHZ_MASK) == FAPI_60KHZ_MASK)
229 (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_60_KHZ;
231 else if((value & FAPI_120KHZ_MASK) == FAPI_120KHZ_MASK)
233 (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_120_KHZ;
237 (*cellPtr)->supportedSubcarrierSpacingDl = INVALID_VALUE;
241 /*******************************************************************
243 * @brief fills the downlink bandwidth by comparing the bitmask
247 * Function : fillBandwidthDl
250 * -checks the value with the bitmask and
251 * -fills the cellPtr's DL Bandwidth
253 * @params[in] Pointer to ClCellParam
254 * Value to be compared
257 * ****************************************************************/
259 PUBLIC void fillBandwidthDl(uint16_t value, ClCellParam **cellPtr)
261 if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
263 (*cellPtr)->supportedBandwidthDl = BW_5MHZ;
265 else if((value & FAPI_10MHZ_BW_MASK) == FAPI_10MHZ_BW_MASK)
267 (*cellPtr)->supportedBandwidthDl = BW_10MHZ;
269 else if((value & FAPI_15MHZ_BW_MASK) == FAPI_15MHZ_BW_MASK)
271 (*cellPtr)->supportedBandwidthDl = BW_15MHZ;
273 else if((value & FAPI_20MHZ_BW_MASK) == FAPI_20MHZ_BW_MASK)
275 (*cellPtr)->supportedBandwidthDl = BW_20MHZ;
277 else if((value & FAPI_40MHZ_BW_MASK) == FAPI_40MHZ_BW_MASK)
279 (*cellPtr)->supportedBandwidthDl = BW_40MHZ;
281 else if((value & FAPI_50MHZ_BW_MASK) == FAPI_50MHZ_BW_MASK)
283 (*cellPtr)->supportedBandwidthDl = BW_50MHZ;
285 else if((value & FAPI_60MHZ_BW_MASK) == FAPI_60MHZ_BW_MASK)
287 (*cellPtr)->supportedBandwidthDl = BW_60MHZ;
289 else if((value & FAPI_70MHZ_BW_MASK) == FAPI_70MHZ_BW_MASK)
291 (*cellPtr)->supportedBandwidthDl = BW_70MHZ;
293 else if((value & FAPI_80MHZ_BW_MASK) == FAPI_80MHZ_BW_MASK)
295 (*cellPtr)->supportedBandwidthDl = BW_80MHZ;
297 else if((value & FAPI_90MHZ_BW_MASK) == FAPI_90MHZ_BW_MASK)
299 (*cellPtr)->supportedBandwidthDl = BW_90MHZ;
301 else if((value & FAPI_100MHZ_BW_MASK) == FAPI_100MHZ_BW_MASK)
303 (*cellPtr)->supportedBandwidthDl = BW_100MHZ;
305 else if((value & FAPI_200MHZ_BW_MASK) == FAPI_200MHZ_BW_MASK)
307 (*cellPtr)->supportedBandwidthDl = BW_200MHZ;
309 else if((value & FAPI_400MHZ_BW_MASK) == FAPI_400MHZ_BW_MASK)
311 (*cellPtr)->supportedBandwidthDl = BW_400MHZ;
315 (*cellPtr)->supportedBandwidthDl = INVALID_VALUE;
319 /*******************************************************************
321 * @brief fills the subcarrier spacing of Uplink by comparing the bitmask
325 * Function : fillSubcarrierSpaceUl
328 * -checks the value with the bitmask and
329 * -fills cellPtr's subcarrier spacing in UL
331 * @params[in] Pointer to ClCellParam
332 * Value to be compared
335 * ****************************************************************/
337 PUBLIC void fillSubcarrierSpaceUl(uint8_t value, ClCellParam **cellPtr)
339 if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
341 (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_15_KHZ;
343 else if((value & FAPI_30KHZ_MASK) == FAPI_30KHZ_MASK)
345 (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_30_KHZ;
347 else if((value & FAPI_60KHZ_MASK) == FAPI_60KHZ_MASK)
349 (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_60_KHZ;
351 else if((value & FAPI_120KHZ_MASK) == FAPI_120KHZ_MASK)
353 (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_120_KHZ;
357 (*cellPtr)->supportedSubcarrierSpacingsUl = INVALID_VALUE;
361 /*******************************************************************
363 * @brief fills the uplink bandwidth by comparing the bitmask
367 * Function : fillBandwidthUl
370 * -checks the value with the bitmask and
371 * fills the cellPtr's UL Bandwidth
375 * @params[in] Pointer to ClCellParam
376 * Value to be compared
380 * ****************************************************************/
382 PUBLIC void fillBandwidthUl(uint16_t value, ClCellParam **cellPtr)
384 if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
386 (*cellPtr)->supportedBandwidthUl = BW_5MHZ;
388 else if((value & FAPI_10MHZ_BW_MASK) == FAPI_10MHZ_BW_MASK)
390 (*cellPtr)->supportedBandwidthUl = BW_10MHZ;
392 else if((value & FAPI_15MHZ_BW_MASK) == FAPI_15MHZ_BW_MASK)
394 (*cellPtr)->supportedBandwidthUl = BW_15MHZ;
396 else if((value & FAPI_20MHZ_BW_MASK) == FAPI_20MHZ_BW_MASK)
398 (*cellPtr)->supportedBandwidthUl = BW_20MHZ;
400 else if((value & FAPI_40MHZ_BW_MASK) == FAPI_40MHZ_BW_MASK)
402 (*cellPtr)->supportedBandwidthUl = BW_40MHZ;
404 else if((value & FAPI_50MHZ_BW_MASK) == FAPI_50MHZ_BW_MASK)
406 (*cellPtr)->supportedBandwidthUl = BW_50MHZ;
408 else if((value & FAPI_60MHZ_BW_MASK) == FAPI_60MHZ_BW_MASK)
410 (*cellPtr)->supportedBandwidthUl = BW_60MHZ;
412 else if((value & FAPI_70MHZ_BW_MASK) == FAPI_70MHZ_BW_MASK)
414 (*cellPtr)->supportedBandwidthUl = BW_70MHZ;
416 else if((value & FAPI_80MHZ_BW_MASK) == FAPI_80MHZ_BW_MASK)
418 (*cellPtr)->supportedBandwidthUl = BW_80MHZ;
420 else if((value & FAPI_90MHZ_BW_MASK) == FAPI_90MHZ_BW_MASK)
422 (*cellPtr)->supportedBandwidthUl = BW_90MHZ;
424 else if((value & FAPI_100MHZ_BW_MASK) == FAPI_100MHZ_BW_MASK)
426 (*cellPtr)->supportedBandwidthUl = BW_100MHZ;
428 else if((value & FAPI_200MHZ_BW_MASK) == FAPI_200MHZ_BW_MASK)
430 (*cellPtr)->supportedBandwidthUl = BW_200MHZ;
432 else if((value & FAPI_400MHZ_BW_MASK) == FAPI_400MHZ_BW_MASK)
434 (*cellPtr)->supportedBandwidthUl = BW_400MHZ;
438 (*cellPtr)->supportedBandwidthUl = INVALID_VALUE;
441 /*******************************************************************
443 * @brief fills the CCE maping by comparing the bitmask
447 * Function : fillCCEmaping
450 * -checks the value with the bitmask and
451 * fills the cellPtr's CCE Mapping Type
454 * @params[in] Pointer to ClCellParam
455 * Value to be compared
458 * ****************************************************************/
460 PUBLIC void fillCCEmaping(uint8_t value, ClCellParam **cellPtr)
462 if ((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_INTERLEAVED_MASK)
464 (*cellPtr)->cceMappingType = CCE_MAPPING_INTERLEAVED_MASK;
466 else if((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_NONINTERLVD_MASK)
468 (*cellPtr)->cceMappingType = CCE_MAPPING_NONINTERLVD_MASK;
472 (*cellPtr)->cceMappingType = INVALID_VALUE;
476 /*******************************************************************
478 * @brief fills the PUCCH format by comparing the bitmask
482 * Function : fillPucchFormat
485 * -checks the value with the bitmask and
486 * fills the cellPtr's pucch format
489 * @params[in] Pointer to ClCellParam
490 * Value to be compared
493 * ****************************************************************/
495 PUBLIC void fillPucchFormat(uint8_t value, ClCellParam **cellPtr)
497 if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
499 (*cellPtr)->pucchFormats = FORMAT_0;
501 else if((value & FAPI_FORMAT_1_MASK) == FAPI_FORMAT_1_MASK)
503 (*cellPtr)->pucchFormats = FORMAT_1;
505 else if((value & FAPI_FORMAT_2_MASK) == FAPI_FORMAT_2_MASK)
507 (*cellPtr)->pucchFormats = FORMAT_2;
509 else if((value & FAPI_FORMAT_3_MASK) == FAPI_FORMAT_3_MASK)
511 (*cellPtr)->pucchFormats = FORMAT_3;
513 else if((value & FAPI_FORMAT_4_MASK) == FAPI_FORMAT_4_MASK)
515 (*cellPtr)->pucchFormats = FORMAT_4;
519 (*cellPtr)->pucchFormats = INVALID_VALUE;
523 /*******************************************************************
525 * @brief fills the PDSCH Mapping Type by comparing the bitmask
529 * Function : fillPdschMappingType
532 * -checks the value with the bitmask and
533 * fills the cellPtr's PDSCH MappingType
535 * @params[in] Pointer to ClCellParam
536 * Value to be compared
539 * ****************************************************************/
541 PUBLIC void fillPdschMappingType(uint8_t value, ClCellParam **cellPtr)
543 if((value & FAPI_PDSCH_MAPPING_TYPE_A_MASK) == FAPI_PDSCH_MAPPING_TYPE_A_MASK)
545 (*cellPtr)->pdschMappingType = MAPPING_TYPE_A;
547 else if((value & FAPI_PDSCH_MAPPING_TYPE_B_MASK) == FAPI_PDSCH_MAPPING_TYPE_B_MASK)
549 (*cellPtr)->pdschMappingType = MAPPING_TYPE_B;
553 (*cellPtr)->pdschMappingType = INVALID_VALUE;
557 /*******************************************************************
559 * @brief fills the PDSCH Allocation Type by comparing the bitmask
563 * Function : fillPdschAllocationType
566 * -checks the value with the bitmask and
567 * fills the cellPtr's PDSCH AllocationType
569 * @params[in] Pointer to ClCellParam
570 * Value to be compared
573 * ****************************************************************/
575 PUBLIC void fillPdschAllocationType(uint8_t value, ClCellParam **cellPtr)
577 if((value & FAPI_PDSCH_ALLOC_TYPE_0_MASK) == FAPI_PDSCH_ALLOC_TYPE_0_MASK)
579 (*cellPtr)->pdschAllocationTypes = ALLOCATION_TYPE_0;
581 else if((value & FAPI_PDSCH_ALLOC_TYPE_1_MASK) == FAPI_PDSCH_ALLOC_TYPE_1_MASK)
583 (*cellPtr)->pdschAllocationTypes = ALLOCATION_TYPE_1;
587 (*cellPtr)->pdschAllocationTypes = INVALID_VALUE;
591 /*******************************************************************
593 * @brief fills the PDSCH PRB Mapping Type by comparing the bitmask
597 * Function : fillPrbMappingType
600 * -checks the value with the bitmask and
601 * fills the cellPtr's PRB Mapping Type
603 * @params[in] Pointer to ClCellParam
604 * Value to be compared
607 ******************************************************************/
608 PUBLIC void fillPrbMappingType(uint8_t value, ClCellParam **cellPtr)
610 if((value & FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
612 (*cellPtr)->pdschVrbToPrbMapping = VRB_TO_PRB_MAP_NON_INTLV;
614 else if((value & FAPI_PDSCH_VRB_TO_PRB_MAP_INTLVD_MASK) == FAPI_PDSCH_VRB_TO_PRB_MAP_INTLVD_MASK)
616 (*cellPtr)->pdschVrbToPrbMapping = VRB_TO_PRB_MAP_INTLVD;
620 (*cellPtr)->pdschVrbToPrbMapping = INVALID_VALUE;
624 /*******************************************************************
626 * @brief fills the PDSCH DmrsConfig Type by comparing the bitmask
630 * Function : fillPdschDmrsConfigType
633 * -checks the value with the bitmask and
634 * fills the cellPtr's DmrsConfig Type
636 * @params[in] Pointer to ClCellParam
637 * Value to be compared
640 ******************************************************************/
642 PUBLIC void fillPdschDmrsConfigType(uint8_t value, ClCellParam **cellPtr)
644 if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK)
646 (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_1;
648 else if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK)
650 (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_2;
654 (*cellPtr)->pdschDmrsConfigTypes = INVALID_VALUE;
658 /*******************************************************************
660 * @brief fills the PDSCH DmrsLength by comparing the bitmask
664 * Function : fillPdschDmrsLength
667 * -checks the value with the bitmask and
668 * fills the cellPtr's PdschDmrsLength
670 * @params[in] Pointer to ClCellParam
671 * Value to be compared
674 ******************************************************************/
675 PUBLIC void fillPdschDmrsLength(uint8_t value, ClCellParam **cellPtr)
677 if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_1)
679 (*cellPtr)->pdschDmrsMaxLength = DMRS_MAX_LENGTH_1;
681 else if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_2)
683 (*cellPtr)->pdschDmrsMaxLength = DMRS_MAX_LENGTH_2;
687 (*cellPtr)->pdschDmrsMaxLength = INVALID_VALUE;
691 /*******************************************************************
693 * @brief fills the PDSCH Dmrs Additional Pos by comparing the bitmask
697 * Function : fillPdschDmrsAddPos
700 * -checks the value with the bitmask and
701 * fills the cellPtr's Pdsch DmrsAddPos
703 * @params[in] Pointer to ClCellParam
704 * Value to be compared
707 ******************************************************************/
709 PUBLIC void fillPdschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
711 if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
713 (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_0;
715 else if((value & FAPI_DMRS_ADDITIONAL_POS_1_MASK) == FAPI_DMRS_ADDITIONAL_POS_1_MASK)
717 (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_1;
719 else if((value & FAPI_DMRS_ADDITIONAL_POS_2_MASK) == FAPI_DMRS_ADDITIONAL_POS_2_MASK)
721 (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_2;
723 else if((value & FAPI_DMRS_ADDITIONAL_POS_3_MASK) == FAPI_DMRS_ADDITIONAL_POS_3_MASK)
725 (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_3;
729 (*cellPtr)->pdschDmrsAdditionalPos = INVALID_VALUE;
733 /*******************************************************************
735 * @brief fills the Modulation Order in DL by comparing the bitmask
739 * Function : fillModulationOrderDl
742 * -checks the value with the bitmask and
743 * fills the cellPtr's ModulationOrder in DL.
745 * @params[in] Pointer to ClCellParam
746 * Value to be compared
749 ******************************************************************/
750 PUBLIC void fillModulationOrderDl(uint8_t value, ClCellParam **cellPtr)
754 (*cellPtr)->supportedMaxModulationOrderDl = MOD_QPSK;
758 (*cellPtr)->supportedMaxModulationOrderDl = MOD_16QAM;
762 (*cellPtr)->supportedMaxModulationOrderDl = MOD_64QAM;
766 (*cellPtr)->supportedMaxModulationOrderDl = MOD_256QAM;
770 (*cellPtr)->supportedMaxModulationOrderDl = INVALID_VALUE;
774 /*******************************************************************
776 * @brief fills the PUSCH DmrsConfig Type by comparing the bitmask
780 * Function : fillPuschDmrsConfigType
783 * -checks the value with the bitmask and
784 * fills the cellPtr's PUSCH DmrsConfigType
786 * @params[in] Pointer to ClCellParam
787 * Value to be compared
790 ******************************************************************/
792 PUBLIC void fillPuschDmrsConfig(uint8_t value, ClCellParam **cellPtr)
794 if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK)
796 (*cellPtr)->puschDmrsConfigTypes = DMRS_CONFIG_TYPE_1;
798 else if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_2_MASK)
800 (*cellPtr)->puschDmrsConfigTypes = DMRS_CONFIG_TYPE_2;
804 (*cellPtr)->puschDmrsConfigTypes = INVALID_VALUE;
808 /*******************************************************************
810 * @brief fills the PUSCH DmrsLength by comparing the bitmask
814 * Function : fillPuschDmrsLength
817 * -checks the value with the bitmask and
818 * fills the cellPtr's PUSCH DmrsLength
820 * @params[in] Pointer to ClCellParam
821 * Value to be compared
824 ******************************************************************/
826 PUBLIC void fillPuschDmrsLength(uint8_t value, ClCellParam **cellPtr)
828 if(value == FAPI_PUSCH_DMRS_MAX_LENGTH_1)
830 (*cellPtr)->puschDmrsMaxLength = DMRS_MAX_LENGTH_1;
832 else if(value == FAPI_PUSCH_DMRS_MAX_LENGTH_2)
834 (*cellPtr)->puschDmrsMaxLength = DMRS_MAX_LENGTH_2;
838 (*cellPtr)->puschDmrsMaxLength = INVALID_VALUE;
842 /*******************************************************************
844 * @brief fills the PUSCH Dmrs Additional position by comparing the bitmask
848 * Function : fillPuschDmrsAddPos
851 * -checks the value with the bitmask and
852 * fills the cellPtr's PUSCH DmrsAddPos
854 * @params[in] Pointer to ClCellParam
855 * Value to be compared
858 ******************************************************************/
860 PUBLIC void fillPuschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
862 if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
864 (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_0;
866 else if((value & FAPI_DMRS_ADDITIONAL_POS_1_MASK) == FAPI_DMRS_ADDITIONAL_POS_1_MASK)
868 (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_1;
870 else if((value & FAPI_DMRS_ADDITIONAL_POS_2_MASK) == FAPI_DMRS_ADDITIONAL_POS_2_MASK)
872 (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_2;
874 else if((value & FAPI_DMRS_ADDITIONAL_POS_3_MASK) == FAPI_DMRS_ADDITIONAL_POS_3_MASK)
876 (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_3;
880 (*cellPtr)->puschDmrsAdditionalPos = INVALID_VALUE;
884 /*******************************************************************
886 * @brief fills the PUSCH Mapping Type by comparing the bitmask
890 * Function : fillPuschMappingType
893 * -checks the value with the bitmask and
894 * fills the cellPtr's PUSCH MappingType
896 * @params[in] Pointer to ClCellParam
897 * Value to be compared
900 ******************************************************************/
902 PUBLIC void fillPuschMappingType(uint8_t value, ClCellParam **cellPtr)
904 if((value & FAPI_PUSCH_MAPPING_TYPE_A_MASK) == FAPI_PUSCH_MAPPING_TYPE_A_MASK)
906 (*cellPtr)->puschMappingType = MAPPING_TYPE_A;
908 else if((value & FAPI_PUSCH_MAPPING_TYPE_B_MASK) == FAPI_PUSCH_MAPPING_TYPE_B_MASK)
910 (*cellPtr)->puschMappingType = MAPPING_TYPE_B;
914 (*cellPtr)->puschMappingType = INVALID_VALUE;
918 /*******************************************************************
920 * @brief fills the PUSCH Allocation Type by comparing the bitmask
924 * Function : fillPuschAllocationType
927 * -checks the value with the bitmask and
928 * fills the cellPtr's PUSCH AllocationType
930 * @params[in] Pointer to ClCellParam
931 * Value to be compared
934 ******************************************************************/
936 PUBLIC void fillPuschAllocationType(uint8_t value, ClCellParam **cellPtr)
938 if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK)
940 (*cellPtr)->puschAllocationTypes = ALLOCATION_TYPE_0;
942 else if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK)
944 (*cellPtr)->puschAllocationTypes = ALLOCATION_TYPE_1;
948 (*cellPtr)->puschAllocationTypes = INVALID_VALUE;
952 /*******************************************************************
954 * @brief fills the PUSCH PRB Mapping Type by comparing the bitmask
958 * Function : fillPuschPrbMappingType
961 * -checks the value with the bitmask and
962 * fills the cellPtr's PUSCH PRB MApping Type
964 * @params[in] Pointer to ClCellParam
965 * Value to be compared
968 ******************************************************************/
970 PUBLIC void fillPuschPrbMappingType(uint8_t value, ClCellParam **cellPtr)
972 if((value & FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
974 (*cellPtr)->puschVrbToPrbMapping = VRB_TO_PRB_MAP_NON_INTLV;
976 else if((value & FAPI_PUSCH_VRB_TO_PRB_MAP_INTLVD_MASK) == FAPI_PUSCH_VRB_TO_PRB_MAP_INTLVD_MASK)
978 (*cellPtr)->puschVrbToPrbMapping = VRB_TO_PRB_MAP_INTLVD;
982 (*cellPtr)->puschVrbToPrbMapping = INVALID_VALUE;
986 /*******************************************************************
988 * @brief fills the Modulation Order in Ul by comparing the bitmask
992 * Function : fillModulationOrderUl
995 * -checks the value with the bitmask and
996 * fills the cellPtr's Modualtsion Order in UL.
998 * @params[in] Pointer to ClCellParam
999 * Value to be compared
1002 ******************************************************************/
1004 PUBLIC void fillModulationOrderUl(uint8_t value, ClCellParam **cellPtr)
1008 (*cellPtr)->supportedModulationOrderUl = MOD_QPSK;
1012 (*cellPtr)->supportedModulationOrderUl = MOD_16QAM;
1016 (*cellPtr)->supportedModulationOrderUl = MOD_64QAM;
1020 (*cellPtr)->supportedModulationOrderUl = MOD_256QAM;
1024 (*cellPtr)->supportedModulationOrderUl = INVALID_VALUE;
1028 /*******************************************************************
1030 * @brief fills the PUSCH Aggregation Factor by comparing the bitmask
1034 * Function : fillPuschAggregationFactor
1037 * -checks the value with the bitmask and
1038 * fills the cellPtr's PUSCH Aggregation Factor
1040 * @params[in] Pointer to ClCellParam
1041 * Value to be compared
1044 ******************************************************************/
1046 PUBLIC void fillPuschAggregationFactor(uint8_t value, ClCellParam **cellPtr)
1048 if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
1050 (*cellPtr)->puschAggregationFactor = AGG_FACTOR_1;
1052 else if((value & FAPI_FORMAT_1_MASK) == FAPI_FORMAT_1_MASK)
1054 (*cellPtr)->puschAggregationFactor = AGG_FACTOR_2;
1056 else if((value & FAPI_FORMAT_2_MASK) == FAPI_FORMAT_2_MASK)
1058 (*cellPtr)->puschAggregationFactor = AGG_FACTOR_4;
1060 else if((value & FAPI_FORMAT_3_MASK) == FAPI_FORMAT_3_MASK)
1062 (*cellPtr)->puschAggregationFactor = AGG_FACTOR_8;
1066 (*cellPtr)->puschAggregationFactor = INVALID_VALUE;
1070 /*******************************************************************
1072 * @brief fills the PRACH Long Format by comparing the bitmask
1076 * Function : fillPrachLongFormat
1079 * -checks the value with the bitmask and
1080 * fills the cellPtr's PRACH Long Format
1082 * @params[in] Pointer to ClCellParam
1083 * Value to be compared
1086 ******************************************************************/
1088 PUBLIC void fillPrachLongFormat(uint8_t value, ClCellParam **cellPtr)
1090 if((value & FAPI_PRACH_LF_FORMAT_0_MASK) == FAPI_PRACH_LF_FORMAT_0_MASK)
1092 (*cellPtr)->prachLongFormats = FORMAT_0;
1094 else if((value & FAPI_PRACH_LF_FORMAT_1_MASK) == FAPI_PRACH_LF_FORMAT_1_MASK)
1096 (*cellPtr)->prachLongFormats = FORMAT_1;
1098 else if((value & FAPI_PRACH_LF_FORMAT_2_MASK) == FAPI_PRACH_LF_FORMAT_2_MASK)
1100 (*cellPtr)->prachLongFormats = FORMAT_2;
1102 else if((value & FAPI_PRACH_LF_FORMAT_3_MASK) == FAPI_PRACH_LF_FORMAT_3_MASK)
1104 (*cellPtr)->prachLongFormats = FORMAT_3;
1108 (*cellPtr)->prachLongFormats = INVALID_VALUE;
1112 /*******************************************************************
1114 * @brief fills the PRACH Short Format by comparing the bitmask
1118 * Function : fillPrachShortFormat
1121 * -checks the value with the bitmask and
1122 * fills the cellPtr's PRACH ShortFormat
1124 * @params[in] Pointer to ClCellParam
1125 * Value to be compared
1128 ******************************************************************/
1130 PUBLIC void fillPrachShortFormat(uint8_t value, ClCellParam **cellPtr)
1132 if((value & FAPI_PRACH_SF_FORMAT_A1_MASK) == FAPI_PRACH_SF_FORMAT_A1_MASK)
1134 (*cellPtr)->prachShortFormats = SF_FORMAT_A1;
1136 else if((value & FAPI_PRACH_SF_FORMAT_A2_MASK) == FAPI_PRACH_SF_FORMAT_A2_MASK)
1138 (*cellPtr)->prachShortFormats = SF_FORMAT_A2;
1140 else if((value & FAPI_PRACH_SF_FORMAT_A3_MASK) == FAPI_PRACH_SF_FORMAT_A3_MASK)
1142 (*cellPtr)->prachShortFormats = SF_FORMAT_A3;
1144 else if((value & FAPI_PRACH_SF_FORMAT_B1_MASK) == FAPI_PRACH_SF_FORMAT_B1_MASK)
1146 (*cellPtr)->prachShortFormats = SF_FORMAT_B1;
1148 else if((value & FAPI_PRACH_SF_FORMAT_B2_MASK) == FAPI_PRACH_SF_FORMAT_B2_MASK)
1150 (*cellPtr)->prachShortFormats = SF_FORMAT_B2;
1152 else if((value & FAPI_PRACH_SF_FORMAT_B3_MASK) == FAPI_PRACH_SF_FORMAT_B3_MASK)
1154 (*cellPtr)->prachShortFormats = SF_FORMAT_B3;
1156 else if((value & FAPI_PRACH_SF_FORMAT_B4_MASK) == FAPI_PRACH_SF_FORMAT_B4_MASK)
1158 (*cellPtr)->prachShortFormats = SF_FORMAT_B4;
1160 else if((value & FAPI_PRACH_SF_FORMAT_C0_MASK) == FAPI_PRACH_SF_FORMAT_C0_MASK)
1162 (*cellPtr)->prachShortFormats = SF_FORMAT_C0;
1164 else if((value & FAPI_PRACH_SF_FORMAT_C2_MASK) == FAPI_PRACH_SF_FORMAT_C2_MASK)
1166 (*cellPtr)->prachShortFormats = SF_FORMAT_C2;
1170 (*cellPtr)->prachShortFormats = INVALID_VALUE;
1174 /*******************************************************************
1176 * @brief fills the Fd Occasions Type by comparing the bitmask
1180 * Function : fillFdOccasions
1183 * -checks the value with the bitmask and
1184 * fills the cellPtr's Fd Occasions
1186 * @params[in] Pointer to ClCellParam
1187 * Value to be compared
1190 ******************************************************************/
1192 PUBLIC void fillFdOccasions(uint8_t value, ClCellParam **cellPtr)
1196 (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_1;
1200 (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_2;
1204 (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_4;
1208 (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_8;
1212 (*cellPtr)->maxPrachFdOccasionsInASlot = INVALID_VALUE;
1216 /*******************************************************************
1218 * @brief fills the RSSI Measurement by comparing the bitmask
1222 * Function : fillRssiMeas
1225 * -checks the value with the bitmask and
1226 * fills the cellPtr's RSSI Measurement report
1228 * @params[in] Pointer to ClCellParam
1229 * Value to be compared
1232 ******************************************************************/
1234 PUBLIC void fillRssiMeas(uint8_t value, ClCellParam **cellPtr)
1236 if((value & FAPI_RSSI_REPORT_IN_DBM_MASK) == FAPI_RSSI_REPORT_IN_DBM_MASK)
1238 (*cellPtr)->rssiMeasurementSupport = RSSI_REPORT_DBM;
1240 else if((value & FAPI_RSSI_REPORT_IN_DBFS_MASK) == FAPI_RSSI_REPORT_IN_DBFS_MASK)
1242 (*cellPtr)->rssiMeasurementSupport = RSSI_REPORT_DBFS;
1246 (*cellPtr)->rssiMeasurementSupport = INVALID_VALUE;
1250 /*******************************************************************
1252 * @brief Returns the TLVs value
1256 * Function : getParamValue
1259 * -return TLVs value
1262 * @return ROK - temp
1265 * ****************************************************************/
1267 uint32_t getParamValue(fapi_uint16_tlv_t *tlv, uint16_t type)
1269 //uint16_t valueLen;
1271 //valueLen = tlv->tl.length;
1272 posPtr = &tlv->tl.tag;
1273 posPtr += sizeof(tlv->tl.tag);
1274 posPtr += sizeof(tlv->tl.length);
1275 /*TO DO: malloc to SSI memory */
1276 if(type == FAPI_UINT_8)
1278 //temp = (uint8_t *)malloc(valueLen * sizeof(U8));
1279 //memcpy(temp, posPtr, valueLen);
1280 return(*(uint8_t *)posPtr);
1282 else if(type == FAPI_UINT_16)
1284 return(*(uint16_t *)posPtr);
1286 else if(type == FAPI_UINT_32)
1288 return(*(uint32_t *)posPtr);
1292 DU_LOG("\nLOWER MAC: Value Extraction failed" );
1297 /*******************************************************************
1299 * @brief Sends FAPI Param req to PHY
1303 * Function : lwr_mac_handleParamReqEvt
1306 * -Sends FAPI Param req to PHY
1309 * @return ROK - success
1312 * ****************************************************************/
1314 S16 lwr_mac_handleParamReqEvt(void *msg)
1317 /* startGuardTimer(); */
1318 uint32_t msgLen; //Length of message Body
1320 fapi_param_req_t *paramReq;
1322 WLS_MEM_ALLOC(paramReq, sizeof(fapi_param_req_t));
1324 MAC_ALLOC(paramReq, sizeof(fapi_param_req_t));
1327 if(paramReq != NULLP)
1329 fillMsgHeader(¶mReq->header, FAPI_PARAM_REQUEST, msgLen);
1330 DU_LOG("\nLOWER MAC: sending param Req to Phy");
1331 LwrMacSendToPhy(paramReq->header.message_type_id, sizeof(fapi_param_req_t), (void *)paramReq);
1332 MAC_FREE(paramReq, sizeof(fapi_param_req_t));
1337 DU_LOG("\nLOWER MAC: Failed to allocate memory for Param Request");
1345 /*******************************************************************
1347 * @brief Sends FAPI Param Response to MAC via PHY
1351 * Function : lwr_mac_handleParamRspEvt
1354 * -Sends FAPI Param rsp to MAC via PHY
1357 * @return ROK - success
1360 * ****************************************************************/
1362 S16 lwr_mac_handleParamRspEvt(void *msg)
1365 /* stopGuardTimer(); */
1367 uint32_t encodedVal;
1368 fapi_param_resp_t *paramRsp;
1369 ClCellParam *cellParam = NULLP;
1371 paramRsp = (fapi_param_resp_t *)msg;
1372 DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
1374 if(paramRsp != NULLP)
1376 MAC_ALLOC(cellParam, sizeof(ClCellParam));
1377 if(cellParam != NULLP)
1379 DU_LOG("\n LOWER MAC: Filling TLVS into MAC API");
1380 if(paramRsp->error_code == MSG_OK)
1382 for(index = 0; index < paramRsp->number_of_tlvs; index++)
1384 switch(paramRsp->tlvs[index].tl.tag)
1386 case FAPI_RELEASE_CAPABILITY_TAG:
1387 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
1388 if(encodedVal != RFAILED && (encodedVal & RELEASE_15) == RELEASE_15)
1390 cellParam->releaseCapability = RELEASE_15;
1394 case FAPI_PHY_STATE_TAG:
1395 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1396 if(encodedVal != RFAILED && encodedVal != clGlobalCp.phyState)
1398 printf("\n PhyState mismatch [%d][%d]", clGlobalCp.phyState, clGlobalCp.event);
1403 case FAPI_SKIP_BLANK_DL_CONFIG_TAG:
1404 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1405 if(encodedVal != RFAILED && encodedVal != 0)
1407 cellParam->skipBlankDlConfig = SUPPORTED;
1411 cellParam->skipBlankDlConfig = NOT_SUPPORTED;
1415 case FAPI_SKIP_BLANK_UL_CONFIG_TAG:
1416 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1417 if(encodedVal != RFAILED && encodedVal != 0)
1419 cellParam->skipBlankUlConfig = SUPPORTED;
1423 cellParam->skipBlankUlConfig = NOT_SUPPORTED;
1427 case FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG:
1428 cellParam->numTlvsToReport = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
1431 case FAPI_CYCLIC_PREFIX_TAG:
1432 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1433 if(encodedVal != RFAILED)
1435 fillCyclicPrefix(encodedVal, &cellParam);
1439 case FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG:
1440 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1441 if(encodedVal != RFAILED)
1443 fillSubcarrierSpaceDl(encodedVal, &cellParam);
1447 case FAPI_SUPPORTED_BANDWIDTH_DL_TAG:
1448 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
1449 if(encodedVal != RFAILED)
1451 fillBandwidthDl(encodedVal, &cellParam);
1455 case FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG:
1456 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1457 if(encodedVal != RFAILED)
1459 fillSubcarrierSpaceUl(encodedVal, &cellParam);
1463 case FAPI_SUPPORTED_BANDWIDTH_UL_TAG:
1464 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
1465 if(encodedVal != RFAILED)
1467 fillBandwidthUl(encodedVal, &cellParam);
1471 case FAPI_CCE_MAPPING_TYPE_TAG:
1472 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1473 if(encodedVal != RFAILED)
1475 fillCCEmaping(encodedVal, &cellParam);
1479 case FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG:
1480 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1481 if(encodedVal != RFAILED && encodedVal != 0)
1483 cellParam->coresetOutsideFirst3OfdmSymsOfSlot = SUPPORTED;
1487 cellParam->coresetOutsideFirst3OfdmSymsOfSlot = NOT_SUPPORTED;
1491 case FAPI_PRECODER_GRANULARITY_CORESET_TAG:
1492 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1493 if(encodedVal != RFAILED && encodedVal != 0)
1495 cellParam->precoderGranularityCoreset = SUPPORTED;
1499 cellParam->precoderGranularityCoreset = NOT_SUPPORTED;
1503 case FAPI_PDCCH_MU_MIMO_TAG:
1504 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1505 if(encodedVal != RFAILED && encodedVal != 0)
1507 cellParam->pdcchMuMimo = SUPPORTED;
1511 cellParam->pdcchMuMimo = NOT_SUPPORTED;
1515 case FAPI_PDCCH_PRECODER_CYCLING_TAG:
1516 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1517 if(encodedVal != RFAILED && encodedVal != 0)
1519 cellParam->pdcchPrecoderCycling = SUPPORTED;
1523 cellParam->pdcchPrecoderCycling = NOT_SUPPORTED;
1527 case FAPI_MAX_PDCCHS_PER_SLOT_TAG:
1528 cellParam->maxPdcchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1531 case FAPI_PUCCH_FORMATS_TAG:
1532 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1533 if(encodedVal != RFAILED)
1535 fillPucchFormat(encodedVal, &cellParam);
1539 case FAPI_MAX_PUCCHS_PER_SLOT_TAG:
1540 cellParam->maxPucchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1543 case FAPI_PDSCH_MAPPING_TYPE_TAG:
1544 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1545 if(encodedVal != RFAILED)
1547 fillPdschMappingType(encodedVal, &cellParam);
1551 case FAPI_PDSCH_ALLOCATION_TYPES_TAG:
1552 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1553 if(encodedVal != RFAILED)
1555 fillPdschAllocationType(encodedVal, &cellParam);
1559 case FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG:
1560 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1561 if(encodedVal != RFAILED)
1563 fillPrbMappingType(encodedVal, &cellParam);
1567 case FAPI_PDSCH_CBG_TAG:
1568 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1569 if(encodedVal != RFAILED && encodedVal != 0)
1571 cellParam->pdschCbg = SUPPORTED;
1575 cellParam->pdschCbg = NOT_SUPPORTED;
1579 case FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG:
1580 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1581 if(encodedVal != RFAILED)
1583 fillPdschDmrsConfigType(encodedVal, &cellParam);
1587 case FAPI_PDSCH_DMRS_MAX_LENGTH_TAG:
1588 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1589 if(encodedVal != RFAILED)
1591 fillPdschDmrsLength(encodedVal, &cellParam);
1595 case FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG:
1596 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1597 if(encodedVal != RFAILED)
1599 fillPdschDmrsAddPos(encodedVal, &cellParam);
1603 case FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG:
1604 cellParam->maxPdschsTBsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1607 case FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG:
1608 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1609 if(encodedVal != RFAILED && encodedVal < FAPI_MAX_NUMBERMIMO_LAYERS_PDSCH)
1611 cellParam->maxNumberMimoLayersPdsch = encodedVal;
1615 case FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG:
1616 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1617 if(encodedVal != RFAILED)
1619 fillModulationOrderDl(encodedVal, &cellParam);
1623 case FAPI_MAX_MU_MIMO_USERS_DL_TAG:
1624 cellParam->maxMuMimoUsersDl = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1627 case FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG:
1628 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1629 if(encodedVal != RFAILED && encodedVal != 0)
1631 cellParam->pdschDataInDmrsSymbols = SUPPORTED;
1635 cellParam->pdschDataInDmrsSymbols = NOT_SUPPORTED;
1639 case FAPI_PREMPTIONSUPPORT_TAG:
1640 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1641 if(encodedVal != RFAILED && encodedVal != 0)
1643 cellParam->premptionSupport = SUPPORTED;
1647 cellParam->premptionSupport = NOT_SUPPORTED;
1651 case FAPI_PDSCH_NON_SLOT_SUPPORT_TAG:
1652 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1653 if(encodedVal != RFAILED && encodedVal != 0)
1655 cellParam->pdschNonSlotSupport = SUPPORTED;
1659 cellParam->pdschNonSlotSupport = NOT_SUPPORTED;
1663 case FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG:
1664 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1665 if(encodedVal != RFAILED && encodedVal != 0)
1667 cellParam->uciMuxUlschInPusch = SUPPORTED;
1671 cellParam->uciMuxUlschInPusch = NOT_SUPPORTED;
1675 case FAPI_UCI_ONLY_PUSCH_TAG:
1676 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1677 if(encodedVal != RFAILED && encodedVal != 0)
1679 cellParam->uciOnlyPusch = SUPPORTED;
1683 cellParam->uciOnlyPusch = NOT_SUPPORTED;
1687 case FAPI_PUSCH_FREQUENCY_HOPPING_TAG:
1688 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1689 if(encodedVal != RFAILED && encodedVal != 0)
1691 cellParam->puschFrequencyHopping = SUPPORTED;
1695 cellParam->puschFrequencyHopping = NOT_SUPPORTED;
1699 case FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG:
1700 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1701 if(encodedVal != RFAILED)
1703 fillPuschDmrsConfig(encodedVal, &cellParam);
1707 case FAPI_PUSCH_DMRS_MAX_LEN_TAG:
1708 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1709 if(encodedVal != RFAILED)
1711 fillPuschDmrsLength(encodedVal, &cellParam);
1715 case FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG:
1716 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1717 if(encodedVal != RFAILED)
1719 fillPuschDmrsAddPos(encodedVal, &cellParam);
1723 case FAPI_PUSCH_CBG_TAG:
1724 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1725 if(encodedVal != RFAILED && encodedVal != 0)
1727 cellParam->puschCbg = SUPPORTED;
1731 cellParam->puschCbg = NOT_SUPPORTED;
1735 case FAPI_PUSCH_MAPPING_TYPE_TAG:
1736 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1737 if(encodedVal != RFAILED)
1739 fillPuschMappingType(encodedVal, &cellParam);
1743 case FAPI_PUSCH_ALLOCATION_TYPES_TAG:
1744 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1745 if(encodedVal != RFAILED)
1747 fillPuschAllocationType(encodedVal, &cellParam);
1751 case FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG:
1752 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1753 if(encodedVal != RFAILED)
1755 fillPuschPrbMappingType(encodedVal, &cellParam);
1759 case FAPI_PUSCH_MAX_PTRS_PORTS_TAG:
1760 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1761 if(encodedVal != RFAILED && encodedVal < FAPI_PUSCH_MAX_PTRS_PORTS_UB)
1763 cellParam->puschMaxPtrsPorts = encodedVal;
1767 case FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG:
1768 cellParam->maxPduschsTBsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1771 case FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG:
1772 cellParam->maxNumberMimoLayersNonCbPusch = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1775 case FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG:
1776 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1777 if(encodedVal != RFAILED)
1779 fillModulationOrderUl(encodedVal, &cellParam);
1783 case FAPI_MAX_MU_MIMO_USERS_UL_TAG:
1784 cellParam->maxMuMimoUsersUl = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1787 case FAPI_DFTS_OFDM_SUPPORT_TAG:
1788 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1789 if(encodedVal != RFAILED && encodedVal != 0)
1791 cellParam->dftsOfdmSupport = SUPPORTED;
1795 cellParam->dftsOfdmSupport = NOT_SUPPORTED;
1799 case FAPI_PUSCH_AGGREGATION_FACTOR_TAG:
1800 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1801 if(encodedVal != RFAILED)
1803 fillPuschAggregationFactor(encodedVal, &cellParam);
1807 case FAPI_PRACH_LONG_FORMATS_TAG:
1808 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1809 if(encodedVal != RFAILED)
1811 fillPrachLongFormat(encodedVal, &cellParam);
1815 case FAPI_PRACH_SHORT_FORMATS_TAG:
1816 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1817 if(encodedVal != RFAILED)
1819 fillPrachShortFormat(encodedVal, &cellParam);
1823 case FAPI_PRACH_RESTRICTED_SETS_TAG:
1824 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1825 if(encodedVal != RFAILED && encodedVal != 0)
1827 cellParam->prachRestrictedSets = SUPPORTED;
1831 cellParam->prachRestrictedSets = NOT_SUPPORTED;
1835 case FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG:
1836 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1837 if(encodedVal != RFAILED)
1839 fillFdOccasions(encodedVal, &cellParam);
1843 case FAPI_RSSI_MEASUREMENT_SUPPORT_TAG:
1844 encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
1845 if(encodedVal != RFAILED)
1847 fillRssiMeas(encodedVal, &cellParam);
1851 //printf("\n Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index);
1855 MAC_FREE(cellParam, sizeof(ClCellParam));
1856 MAC_FREE(paramRsp, sizeof(fapi_param_resp_t));
1858 sendToLowerMac(FAPI_CONFIG_REQUEST, 0, (void *)NULL);
1863 DU_LOG("\n LOWER MAC: Invalid error code %d", paramRsp->error_code);
1869 DU_LOG("\nLOWER MAC: Failed to allocate memory for cell param");
1875 DU_LOG("\nLOWER 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)
1904 uint32_t msgLen = 0;
1905 uint32_t configReqSize;
1906 RgCellCb *cellParams;
1907 MacCellCfg macCfgParams;
1910 DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
1912 fapi_config_req_t *configReq;
1913 cellParams = rgCb[inst].cell;
1914 macCfgParams = cellParams->macCellCfg;
1915 configReqSize = sizeof(fapi_config_req_t) + (macCfgParams.numTlv * sizeof(fapi_uint16_tlv_t));
1917 WLS_MEM_ALLOC(configReq, configReqSize);
1919 MAC_ALLOC(configReq, configReqSize);
1922 if(configReq != NULL)
1924 configReq->number_of_tlvs = macCfgParams.numTlv;
1926 if(macCfgParams.dlCarrCfg.pres)
1928 fillTlvs(&configReq->tlvs[index++], FAPI_DL_BANDWIDTH_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.bw, &msgLen);
1929 fillTlvs(&configReq->tlvs[index++], FAPI_DL_FREQUENCY_TAG, sizeof(uint32_t), macCfgParams.dlCarrCfg.freq, &msgLen);
1930 fillTlvs(&configReq->tlvs[index++], FAPI_DL_K0_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.k0[0], &msgLen);
1931 fillTlvs(&configReq->tlvs[index++], FAPI_DL_GRIDSIZE_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.gridSize[0], &msgLen);
1932 fillTlvs(&configReq->tlvs[index++], FAPI_NUM_TX_ANT_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.numAnt, &msgLen);
1934 if(macCfgParams.ulCarrCfg.pres)
1936 fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_BANDWIDTH_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.bw, &msgLen);
1937 fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_FREQUENCY_TAG, sizeof(uint32_t), macCfgParams.ulCarrCfg.freq, &msgLen);
1938 fillTlvs(&configReq->tlvs[index++], FAPI_UL_K0_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.k0[0], &msgLen);
1939 fillTlvs(&configReq->tlvs[index++], FAPI_UL_GRID_SIZE_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.gridSize[0], &msgLen);
1940 fillTlvs(&configReq->tlvs[index++], FAPI_NUM_RX_ANT_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.numAnt, &msgLen);
1942 fillTlvs(&configReq->tlvs[index++], FAPI_FREQUENCY_SHIFT_7P5_KHZ_TAG, sizeof(uint8_t), macCfgParams.freqShft, &msgLen);
1944 /* fill cell config */
1945 fillTlvs(&configReq->tlvs[index++], FAPI_PHY_CELL_ID_TAG, sizeof(uint8_t), macCfgParams.phyCellId, &msgLen);
1946 fillTlvs(&configReq->tlvs[index++], FAPI_FRAME_DUPLEX_TYPE_TAG, sizeof(uint8_t), macCfgParams.dupType, &msgLen);
1948 /* fill SSB configuration */
1949 fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_POWER_TAG, sizeof(uint32_t), macCfgParams.ssbCfg.ssbPbchPwr, &msgLen);
1950 fillTlvs(&configReq->tlvs[index++], FAPI_BCH_PAYLOAD_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.bchPayloadFlag, &msgLen);
1951 fillTlvs(&configReq->tlvs[index++], FAPI_SCS_COMMON_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.scsCmn, &msgLen);
1953 /* fill PRACH configuration */
1954 fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SEQUENCE_LENGTH_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachSeqLen, &msgLen);
1955 fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SUBC_SPACING_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachSubcSpacing, &msgLen);
1956 fillTlvs(&configReq->tlvs[index++], FAPI_RESTRICTED_SET_CONFIG_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachRstSetCfg, &msgLen);
1957 fillTlvs(&configReq->tlvs[index++], FAPI_NUM_PRACH_FD_OCCASIONS_TAG,
1958 sizeof(uint8_t), macCfgParams.prachCfg.msg1Fdm, &msgLen);
1959 fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ROOT_SEQUENCE_INDEX_TAG, sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].rootSeqIdx, &msgLen);
1960 fillTlvs(&configReq->tlvs[index++], FAPI_NUM_ROOT_SEQUENCES_TAG, sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numRootSeq, &msgLen);
1961 fillTlvs(&configReq->tlvs[index++], FAPI_K1_TAG, sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].k1, &msgLen);
1962 fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ZERO_CORR_CONF_TAG , sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].zeroCorrZoneCfg, &msgLen);
1963 fillTlvs(&configReq->tlvs[index++], FAPI_NUM_UNUSED_ROOT_SEQUENCES_TAG, sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numUnusedRootSeq, &msgLen);
1964 //MAC_ALLOC(macCfgParams.prachCfg.fdm[0].unsuedRootSeq, \
1965 sizeof(uint8_t)*macCfgParams.prachCfg.fdm[0].numUnusedRootSeq);
1966 macCfgParams.prachCfg.fdm[0].unsuedRootSeq = (uint8_t *)malloc(sizeof(uint8_t)*macCfgParams.prachCfg.fdm[0].numUnusedRootSeq);
1967 fillTlvs(&configReq->tlvs[index++], FAPI_UNUSED_ROOT_SEQUENCES_TAG,
1968 sizeof(uint8_t), *(macCfgParams.prachCfg.fdm[0].unsuedRootSeq), &msgLen);
1969 fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PER_RACH_TAG, sizeof(uint8_t), macCfgParams.prachCfg.ssbPerRach, &msgLen);
1970 fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachMultCarrBand, &msgLen);
1972 /* fill SSB table */
1973 fillTlvs(&configReq->tlvs[index++], FAPI_SSB_OFFSET_POINT_A_TAG, sizeof(uint16_t), macCfgParams.ssbCfg.ssbOffsetPointA, &msgLen);
1974 fillTlvs(&configReq->tlvs[index++], FAPI_BETA_PSS_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.betaPss, &msgLen);
1975 fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PERIOD_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.ssbPeriod, &msgLen);
1976 fillTlvs(&configReq->tlvs[index++], FAPI_SSB_SUBCARRIER_OFFSET_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.ssbScOffset, &msgLen);
1977 fillTlvs(&configReq->tlvs[index++], FAPI_MIB_TAG , sizeof(uint32_t), macCfgParams.ssbCfg.mibPdu[0], &msgLen);
1978 fillTlvs(&configReq->tlvs[index++], FAPI_SSB_MASK_TAG, sizeof(uint32_t), macCfgParams.ssbCfg.ssbMask[0], &msgLen);
1979 fillTlvs(&configReq->tlvs[index++], FAPI_BEAM_ID_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.beamId[0], &msgLen);
1980 fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.multCarrBand, &msgLen);
1981 fillTlvs(&configReq->tlvs[index++], FAPI_MULTIPLE_CELLS_SS_PBCH_IN_A_CARRIER_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.multCellCarr, &msgLen);
1983 /* fill TDD table */
1984 fillTlvs(&configReq->tlvs[index++], FAPI_TDD_PERIOD_TAG, sizeof(uint8_t), macCfgParams.tddCfg.tddPeriod, &msgLen);
1985 fillTlvs(&configReq->tlvs[index++], FAPI_SLOT_CONFIG_TAG, sizeof(uint8_t), macCfgParams.tddCfg.slotCfg[0][0], &msgLen);
1987 /* fill measurement config */
1988 fillTlvs(&configReq->tlvs[index++], FAPI_RSSI_MESUREMENT_TAG, sizeof(uint8_t), macCfgParams.rssiUnit, &msgLen);
1990 fillMsgHeader(&configReq->header, FAPI_CONFIG_REQUEST, msgLen);
1991 DU_LOG("\nLOWER_MAC: Sending Config Request to Phy");
1992 /* TODO : Recheck the size / msglen to be sent to WLS_Put*/
1993 LwrMacSendToPhy(configReq->header.message_type_id, msgLen, (void *)configReq);
1994 MAC_FREE(configReq, configReqSize);
1999 DU_LOG("\nLOWER_MAC: Failed to allocate memory for config Request");
2007 S16 lwr_mac_handleConfigRspEvt(void *msg)
2010 fapi_config_resp_t *configRsp;
2011 configRsp = (fapi_config_resp_t *)msg;
2012 DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
2014 if(configRsp != NULL)
2016 if(configRsp->error_code == MSG_OK)
2018 DU_LOG("\nLOWER MAC: PHY has moved to Conigured state \n");
2019 clGlobalCp.phyState = PHY_STATE_CONFIGURED;
2021 * Store config response into an intermediate struture and send to MAC
2022 * Support LC and LWLC for sending config rsp to MAC
2025 MAC_FREE(configRsp, sizeof(fapi_config_resp_t));
2031 DU_LOG("\n LOWER MAC: Invalid error code %d", configRsp->error_code);
2037 DU_LOG("\nLOWER_MAC: Config Response received from PHY is NULL");
2045 S16 lwr_mac_handleStartReqEvt(void *msg)
2048 uint32_t msgLen = 0;
2049 fapi_start_req_t *startReq;
2051 WLS_MEM_ALLOC(startReq, sizeof(fapi_start_req_t));
2053 MAC_ALLOC(startReq, sizeof(fapi_start_req_t));
2056 if(startReq != NULL)
2058 fillMsgHeader(&startReq->header, FAPI_START_REQUEST, msgLen);
2059 DU_LOG("\nLOWER MAC: Sending Start Request to PHY");
2060 LwrMacSendToPhy(startReq->header.message_type_id, sizeof(fapi_start_req_t), (void *)startReq);
2061 MAC_FREE(startReq, sizeof(fapi_start_req_t));
2066 DU_LOG("\nLOWER MAC: Failed to allocate memory for Start Request");
2074 S16 lwr_mac_handleStopReqEvt(void *msg)
2077 /* stop TX and RX operation return PHy to configured State
2078 send stop.indication to l2/l3 */
2083 /*******************************************************************
2085 * @brief Modifes the received mibPdu to uint32 bit
2086 * and stores it in MacCellCfg
2090 * Function : setMibPdu
2095 * @params[in] Pointer to mibPdu
2096 * pointer to modified value
2097 ******************************************************************/
2099 PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val)
2101 *mibPdu |= (((uint8_t)(slotIndInfo.sfn >> 2)) & MIB_SFN_BITMASK);
2102 *val = (mibPdu[0] << 24 | mibPdu[1] << 16 | mibPdu[2] << 8);
2103 DU_LOG("\nLOWER MAC: value filled %x", *val);
2107 /*******************************************************************
2109 * @brief fills SSB PDU required for DL TTI info in MAC
2113 * Function : fillSsbPdu
2116 * -Fills the SSB PDU info
2119 * @params[in] Pointer to FAPI DL TTI Req
2120 * Pointer to RgCellCb
2121 * Pointer to msgLen of DL TTI Info
2124 ******************************************************************/
2126 S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg,
2127 MacDlSlot *currDlSlot,
2128 uint32_t *msgLen, uint8_t ssbIdxCount)
2130 uint32_t mibPayload = 0;
2131 if(dlTtiReqPdu != NULL)
2133 dlTtiReqPdu->pduType = SSB_PDU_TYPE; /* SSB PDU */
2134 dlTtiReqPdu->u.ssb_pdu.physCellId = macCellCfg->phyCellId;
2135 dlTtiReqPdu->u.ssb_pdu.betaPss = macCellCfg->ssbCfg.betaPss;
2136 dlTtiReqPdu->u.ssb_pdu.ssbBlockIndex = currDlSlot->cellBroadcastInfo.ssbInfo[ssbIdxCount].ssbIdx;
2137 dlTtiReqPdu->u.ssb_pdu.ssbSubCarrierOffset = macCellCfg->ssbCfg.ssbScOffset;
2138 /* ssbOfPdufstA to be filled in ssbCfg */
2139 dlTtiReqPdu->u.ssb_pdu.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA;
2140 dlTtiReqPdu->u.ssb_pdu.bchPayloadFlag = macCellCfg->ssbCfg.bchPayloadFlag;
2141 /* Bit manipulation for SFN */
2142 setMibPdu(macCellCfg->ssbCfg.mibPdu, &mibPayload);
2143 dlTtiReqPdu->u.ssb_pdu.bchPayload.v.bchPayload = mibPayload;
2144 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.numPrgs = 0;
2145 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.prgSize = 0;
2146 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.digBfInterfaces = 0;
2147 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.pmi_bfi[0].pmIdx = 0;
2148 dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming. \
2149 pmi_bfi[0].beamIdx[0].beamidx = macCellCfg->ssbCfg.beamId[0];
2150 dlTtiReqPdu->pduSize = sizeof(fapi_dl_ssb_pdu_t); /* Size of SSB PDU */
2151 SETLENGTH(*msgLen, sizeof(fapi_dl_ssb_pdu_t));
2160 /*******************************************************************
2162 * @brief fills Dl DCI PDU required for DL TTI info in MAC
2166 * Function : fillDlDciPdu
2169 * -Fills the Dl DCI PDU
2171 * @params[in] Pointer to fapi_dl_dci_t
2172 * Pointer to Sib1PdcchCfg
2175 ******************************************************************/
2177 void fillDlDciPdu(fapi_dl_dci_t *dlDciPtr, Sib1PdcchCfg *sib1PdcchInfo)
2179 if(dlDciPtr != NULLP)
2185 uint16_t coreset0Size;
2188 uint32_t freqDomResAssign;
2189 uint32_t timeDomResAssign;
2191 uint32_t modNCodScheme;
2192 uint8_t redundancyVer;
2193 uint32_t sysInfoInd;
2196 /* Size(in bits) of each field in DCI format 0_1
2197 * as mentioned in spec 38.214 */
2198 uint8_t freqDomResAssignSize;
2199 uint8_t timeDomResAssignSize = 4;
2200 uint8_t VRB2PRBMapSize = 1;
2201 uint8_t modNCodSchemeSize = 5;
2202 uint8_t redundancyVerSize = 2;
2203 uint8_t sysInfoIndSize = 1;
2204 uint8_t reservedSize = 15;
2206 dlDciPtr->rnti = sib1PdcchInfo->sib1DlDci.rnti;
2207 dlDciPtr->scramblingId = sib1PdcchInfo->sib1DlDci.scramblingId;
2208 dlDciPtr->scramblingRnti = sib1PdcchInfo->sib1DlDci.scramblingRnti;
2209 dlDciPtr->cceIndex = sib1PdcchInfo->sib1DlDci.cceIndex;
2210 dlDciPtr->aggregationLevel = sib1PdcchInfo->sib1DlDci.aggregLevel;
2211 dlDciPtr->pc_and_bform.numPrgs = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.numPrgs;
2212 dlDciPtr->pc_and_bform.prgSize = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.prgSize;
2213 dlDciPtr->pc_and_bform.digBfInterfaces = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.digBfInterfaces;
2214 dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.prg[0].pmIdx;
2215 dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.prg[0].beamIdx[0];
2216 dlDciPtr->beta_pdcch_1_0 = sib1PdcchInfo->sib1DlDci.txPdcchPower.powerValue;
2217 dlDciPtr->powerControlOfssetSS = sib1PdcchInfo->sib1DlDci.txPdcchPower.powerControlOffsetSS;
2219 /* Calculating freq domain resource allocation field value and size
2220 * coreset0Size = Size of coreset 0
2221 * RBStart = Starting Virtual Rsource block
2222 * RBLen = length of contiguously allocted RBs
2223 * Spec 38.214 Sec 5.1.2.2.2
2225 coreset0Size= sib1PdcchInfo->sib1Coreset0Cfg.coreSet0Size;
2226 rbStart = 0; /* For SIB1 */
2227 //rbStart = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1FreqAlloc.rbStart;
2228 rbLen = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1FreqAlloc.rbSize;
2230 if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
2232 if((rbLen - 1) <= floor(coreset0Size / 2))
2233 freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart;
2235 freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \
2236 + (coreset0Size - 1 - rbStart);
2238 freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2));
2241 /* Fetching DCI field values */
2242 timeDomResAssign = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1TimeAlloc.
2244 VRB2PRBMap = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1FreqAlloc.\
2246 modNCodScheme = sib1PdcchInfo->sib1DlDci.pdschCfg->codeword[0].mcsIndex;
2247 redundancyVer = sib1PdcchInfo->sib1DlDci.pdschCfg->codeword[0].rvIndex;
2248 sysInfoInd = 0; /* 0 for SIB1; 1 for SI messages */
2251 /* Reversing bits in each DCI field */
2252 freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize);
2253 timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
2254 VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize);
2255 modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize);
2256 redundancyVer = reverseBits(redundancyVer, redundancyVerSize);
2257 sysInfoInd = reverseBits(sysInfoInd, sysInfoIndSize);
2258 reserved = reverseBits(reserved, reservedSize);
2260 /* Calulating total number of bytes in buffer */
2261 dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\
2262 + VRB2PRBMapSize + modNCodSchemeSize + redundancyVerSize\
2263 + sysInfoIndSize + reservedSize;
2265 numBytes = dlDciPtr->payloadSizeBits / 8;
2266 if(dlDciPtr->payloadSizeBits % 8)
2269 if(numBytes > DCI_PAYLOAD_BYTE_LEN)
2271 DU_LOG("\nLOWER MAC : Total bytes for DCI is more than expected");
2275 /* Initialize buffer */
2276 for(bytePos = 0; bytePos < numBytes; bytePos++)
2277 dlDciPtr->payload[bytePos] = 0;
2279 bytePos = numBytes - 1;
2282 /* Packing DCI format fields */
2283 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2284 freqDomResAssign, freqDomResAssignSize);
2285 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2286 timeDomResAssign, timeDomResAssignSize);
2287 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2288 VRB2PRBMap, VRB2PRBMapSize);
2289 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2290 modNCodScheme, modNCodSchemeSize);
2291 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2292 redundancyVer, redundancyVerSize);
2293 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2294 sysInfoInd, sysInfoIndSize);
2295 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2296 reserved, reservedSize);
2299 } /* fillDlDciPdu */
2301 /*******************************************************************
2303 * @brief fills PDCCH PDU required for DL TTI info in MAC
2307 * Function : fillPdcchPdu
2310 * -Fills the Pdcch PDU info
2313 * @params[in] Pointer to FAPI DL TTI Req
2314 * Pointer to Sib1PdcchCfg
2315 * Pointer to msgLen of DL TTI Info
2318 ******************************************************************/
2320 S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, Sib1PdcchCfg *sib1PdcchInfo,
2323 if(dlTtiReqPdu != NULLP)
2325 dlTtiReqPdu->pduType = PDCCH_PDU_TYPE;
2326 dlTtiReqPdu->u.pdcch_pdu.bwpSize = sib1PdcchInfo->sib1PdcchBwpCfg.BWPSize;
2327 dlTtiReqPdu->u.pdcch_pdu.bwpPart = sib1PdcchInfo->sib1PdcchBwpCfg.BWPStart;
2328 dlTtiReqPdu->u.pdcch_pdu.subCarrierSpacing = sib1PdcchInfo->sib1PdcchBwpCfg.subcarrierSpacing;
2329 dlTtiReqPdu->u.pdcch_pdu.cyclicPrefix = sib1PdcchInfo->sib1PdcchBwpCfg.cyclicPrefix;
2330 dlTtiReqPdu->u.pdcch_pdu.startSymbolIndex = sib1PdcchInfo->sib1Coreset0Cfg.startSymbolIndex;
2331 dlTtiReqPdu->u.pdcch_pdu.durationSymbols = sib1PdcchInfo->sib1Coreset0Cfg.durationSymbols;
2332 memcpy(dlTtiReqPdu->u.pdcch_pdu.freqDomainResource, sib1PdcchInfo->sib1Coreset0Cfg.freqDomainResource, 6);
2333 dlTtiReqPdu->u.pdcch_pdu.cceRegMappingType = sib1PdcchInfo->sib1Coreset0Cfg.cceRegMappingType;
2334 dlTtiReqPdu->u.pdcch_pdu.regBundleSize = sib1PdcchInfo->sib1Coreset0Cfg.regBundleSize;
2335 dlTtiReqPdu->u.pdcch_pdu.interleaverSize = sib1PdcchInfo->sib1Coreset0Cfg.interleaverSize;
2336 dlTtiReqPdu->u.pdcch_pdu.coreSetSize = sib1PdcchInfo->sib1Coreset0Cfg.coreSetType;
2337 dlTtiReqPdu->u.pdcch_pdu.shiftIndex = sib1PdcchInfo->sib1Coreset0Cfg.shiftIndex;
2338 dlTtiReqPdu->u.pdcch_pdu.precoderGranularity = sib1PdcchInfo->sib1Coreset0Cfg.precoderGranularity;
2339 dlTtiReqPdu->u.pdcch_pdu.numDlDci = sib1PdcchInfo->numDlDci;
2341 WLS_MEM_ALLOC(dlTtiReqPdu->u.pdcch_pdu.dlDci, sizeof(fapi_dl_dci_t));
2343 MAC_ALLOC(dlTtiReqPdu->u.pdcch_pdu.dlDci, sizeof(fapi_dl_dci_t));
2345 fillDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, sib1PdcchInfo);
2346 dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t);
2347 SETLENGTH(*msgLen, sizeof(fapi_dl_pdcch_pdu_t));
2354 /*******************************************************************
2356 * @brief fills PDSCH PDU required for DL TTI info in MAC
2360 * Function : fillPdschPdu
2363 * -Fills the Pdsch PDU info
2366 * @params[in] Pointer to FAPI DL TTI Req
2367 * Pointer to Sib1PdschCfg
2368 * Pointer to msgLen of DL TTI Info
2371 ******************************************************************/
2373 void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, Sib1PdschCfg *sib1PdschInfo,
2378 if(dlTtiReqPdu != NULLP)
2380 dlTtiReqPdu->pduType = PDSCH_PDU_TYPE;
2381 dlTtiReqPdu->u.pdsch_pdu.pduBitMap = sib1PdschInfo->pduBitmap;
2382 dlTtiReqPdu->u.pdsch_pdu.rnti = sib1PdschInfo->rnti;
2383 dlTtiReqPdu->u.pdsch_pdu.pduIndex = sib1PdschInfo->pduIndex;
2384 dlTtiReqPdu->u.pdsch_pdu.bwpSize = sib1PdschInfo->sib1PdschBwpCfg.BWPSize;
2385 dlTtiReqPdu->u.pdsch_pdu.bwpStart = sib1PdschInfo->sib1PdschBwpCfg.BWPStart;
2386 dlTtiReqPdu->u.pdsch_pdu.subCarrierSpacing = sib1PdschInfo->sib1PdschBwpCfg.subcarrierSpacing;
2387 dlTtiReqPdu->u.pdsch_pdu.cyclicPrefix = sib1PdschInfo->sib1PdschBwpCfg.cyclicPrefix;
2388 dlTtiReqPdu->u.pdsch_pdu.nrOfCodeWords = sib1PdschInfo->numCodewords;
2389 for(idx = 0; idx < MAX_CODEWORDS ; idx++)
2391 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].targetCodeRate = sib1PdschInfo->codeword[idx].targetCodeRate;
2392 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].qamModOrder = sib1PdschInfo->codeword[idx].qamModOrder;
2393 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsIndex = sib1PdschInfo->codeword[idx].mcsIndex;
2394 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsTable = sib1PdschInfo->codeword[idx].mcsTable;
2395 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].rvIndex = sib1PdschInfo->codeword[idx].rvIndex;
2396 dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].tbSize = sib1PdschInfo->codeword[idx].tbSize;
2398 dlTtiReqPdu->u.pdsch_pdu.dataScramblingId = sib1PdschInfo->dataScramblingId;
2399 dlTtiReqPdu->u.pdsch_pdu.nrOfLayers = sib1PdschInfo->numLayers;
2400 dlTtiReqPdu->u.pdsch_pdu.transmissionScheme = sib1PdschInfo->transmissionScheme;
2401 dlTtiReqPdu->u.pdsch_pdu.refPoint = sib1PdschInfo->refPoint;
2402 dlTtiReqPdu->u.pdsch_pdu.dlDmrsSymbPos = sib1PdschInfo->dmrs.dlDmrsSymbPos;
2403 dlTtiReqPdu->u.pdsch_pdu.dmrsConfigType = sib1PdschInfo->dmrs.dmrsConfigType;
2404 dlTtiReqPdu->u.pdsch_pdu.dlDmrsScramblingId = sib1PdschInfo->dmrs.dlDmrsScramblingId;
2405 dlTtiReqPdu->u.pdsch_pdu.scid = sib1PdschInfo->dmrs.scid;
2406 dlTtiReqPdu->u.pdsch_pdu.numDmrsCdmGrpsNoData = sib1PdschInfo->dmrs.numDmrsCdmGrpsNoData;
2407 dlTtiReqPdu->u.pdsch_pdu.dmrsPorts = sib1PdschInfo->dmrs.dmrsPorts;
2408 dlTtiReqPdu->u.pdsch_pdu.resourceAlloc = sib1PdschInfo->sib1FreqAlloc.resourceAlloc;
2409 /* since we are using type-1, hence rbBitmap excluded */
2410 dlTtiReqPdu->u.pdsch_pdu.rbStart = sib1PdschInfo->sib1FreqAlloc.rbStart;
2411 dlTtiReqPdu->u.pdsch_pdu.rbSize = sib1PdschInfo->sib1FreqAlloc.rbSize;
2412 dlTtiReqPdu->u.pdsch_pdu.vrbToPrbMapping = sib1PdschInfo->sib1FreqAlloc.vrbPrbMapping;
2413 dlTtiReqPdu->u.pdsch_pdu.startSymbIndex = sib1PdschInfo->sib1TimeAlloc.startSymbolIndex;
2414 dlTtiReqPdu->u.pdsch_pdu.nrOfSymbols = sib1PdschInfo->sib1TimeAlloc.numSymbols;
2415 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.numPrgs = sib1PdschInfo->beamPdschInfo.numPrgs;
2416 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.prgSize = sib1PdschInfo->beamPdschInfo.prgSize;
2417 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = sib1PdschInfo->beamPdschInfo.digBfInterfaces;
2418 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
2419 pmIdx = sib1PdschInfo->beamPdschInfo.prg[0].pmIdx;
2420 dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
2421 beamIdx[0].beamidx = sib1PdschInfo->beamPdschInfo.prg[0].beamIdx[0];
2422 dlTtiReqPdu->u.pdsch_pdu.powerControlOffset = sib1PdschInfo->txPdschPower.powerControlOffset;
2423 dlTtiReqPdu->u.pdsch_pdu.powerControlOffsetSS = sib1PdschInfo->txPdschPower.powerControlOffsetSS;
2424 dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdsch_pdu_t);
2425 SETLENGTH(*msgLen, sizeof(fapi_dl_pdsch_pdu_t));
2431 /***********************************************************************
2433 * @brief calculates the total size to be allocated for DL TTI Req
2437 * Function : calculatePduCount
2440 * -calculates the total pdu count to be allocated for DL TTI Req
2442 * @params[in] DlBrdcstAlloc *cellBroadcastInfo
2445 * ********************************************************************/
2446 uint8_t calculatePduCount(DlBrdcstAlloc *cellBroadcastInfo)
2450 if(cellBroadcastInfo->ssbTrans)
2452 for(idx = 0; idx < cellBroadcastInfo->ssbIdxSupported; idx++)
2457 if(cellBroadcastInfo->sib1Trans)
2466 /*******************************************************************
2468 * @brief Sends DL TTI Request to PHY
2472 * Function : handleDlTtiReq
2475 * -Sends FAPI Param req to PHY
2477 * @params[in] RgDlSf *dlTtiReqSlot
2478 * @return ROK - success
2481 * ****************************************************************/
2482 S16 handleDlTtiReq(CmLteTimingInfo *dlTtiReqtimingInfo)
2487 uint32_t msgLen = 0;
2488 fapi_dl_tti_req_t *dlTtiReq = NULLP;
2489 fapi_dl_tti_req_pdu_t *dlTtiReqPdu = NULLP;
2490 RgCellCb *cellCbParams = NULLP;
2491 MacDlSlot *currDlSlot = NULLP;
2492 MacCellCfg macCellCfg;
2493 cmMemset((U8 *)&macCellCfg, 0, sizeof(MacCellCfg));
2496 if(clGlobalCp.phyState == PHY_STATE_RUNNING)
2498 cellCbParams = rgCb[inst].cell;
2499 macCellCfg = cellCbParams->macCellCfg;
2501 if(dlTtiReqtimingInfo != NULLP)
2504 WLS_MEM_ALLOC(dlTtiReq, sizeof(fapi_dl_tti_req_t));
2506 MAC_ALLOC(dlTtiReq, sizeof(fapi_dl_tti_req_t));
2508 if(dlTtiReq != NULLP)
2510 dlTtiReq->sfn = dlTtiReqtimingInfo->sfn;
2511 dlTtiReq->slot = dlTtiReqtimingInfo->slot;
2512 currDlSlot = &macCb.macCell->dlSlot[dlTtiReq->slot % MAX_SLOT_SUPPORTED];
2513 dlTtiReq->nPdus = calculatePduCount(&currDlSlot->cellBroadcastInfo); /* get total Pdus */
2514 nPdu = dlTtiReq->nPdus;
2515 dlTtiReq->nGroup = 0;
2516 if(dlTtiReq->nPdus > 0)
2519 WLS_MEM_ALLOC(dlTtiReqPdu, (nPdu * sizeof(fapi_dl_tti_req_pdu_t)));
2521 MAC_ALLOC(dlTtiReqPdu, (nPdu * sizeof(fapi_dl_tti_req_pdu_t)));
2523 if(currDlSlot->cellBroadcastInfo.ssbTrans)
2525 if(dlTtiReqPdu != NULLP)
2527 for(idx = 0; idx < currDlSlot->cellBroadcastInfo.ssbIdxSupported; idx++)
2531 fillSsbPdu(dlTtiReqPdu, &macCellCfg, currDlSlot, &msgLen, idx);
2532 dlTtiReq->pdus = dlTtiReqPdu;
2536 if(currDlSlot->cellBroadcastInfo.sib1Trans)
2538 /* Filling SIB1 param */
2539 if(dlTtiReqPdu != NULLP)
2542 fillPdcchPdu(dlTtiReqPdu, &currDlSlot->cellBroadcastInfo.sib1Alloc.sib1PdcchCfg, &msgLen);
2543 dlTtiReq->pdus = dlTtiReqPdu;
2545 fillPdschPdu(dlTtiReqPdu, &currDlSlot->cellBroadcastInfo.sib1Alloc.sib1PdschCfg, &msgLen);
2546 dlTtiReq->pdus = dlTtiReqPdu;
2549 msgLen += sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
2550 fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
2551 /* TODO : Recheck the size / msglen to be sent to WLS_Put*/
2552 LwrMacSendToPhy(dlTtiReq->header.message_type_id, msgLen, (void *)dlTtiReq);
2553 if(currDlSlot->cellBroadcastInfo.sib1Trans)
2555 MAC_FREE(dlTtiReqPdu->u.pdcch_pdu.dlDci, sizeof(fapi_dl_dci_t));
2557 MAC_FREE(dlTtiReqPdu, (nPdu * sizeof(fapi_dl_tti_req_pdu_t)));
2561 msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
2562 fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
2563 /* TODO : Recheck the size / msglen to be sent to WLS_Put*/
2564 LwrMacSendToPhy(dlTtiReq->header.message_type_id, msgLen, (void *)dlTtiReq);
2566 MAC_FREE(dlTtiReq, sizeof(fapi_dl_tti_req_t));
2571 DU_LOG("\nLOWER MAC: Failed to allocate memory for DL TTI Request");
2577 DU_LOG("\nLOWER MAC: Current TTI Info is NULL");
2583 lwr_mac_handleInvalidEvt(dlTtiReqtimingInfo);
2589 lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] =
2592 /* PHY_STATE_IDLE */
2593 lwr_mac_handleParamReqEvt,
2594 lwr_mac_handleParamRspEvt,
2595 lwr_mac_handleConfigReqEvt,
2596 lwr_mac_handleConfigRspEvt,
2597 lwr_mac_handleInvalidEvt,
2600 /* PHY_STATE_CONFIGURED */
2601 lwr_mac_handleParamReqEvt,
2602 lwr_mac_handleParamRspEvt,
2603 lwr_mac_handleConfigReqEvt,
2604 lwr_mac_handleConfigRspEvt,
2605 lwr_mac_handleStartReqEvt,
2608 /* PHY_STATE_RUNNING */
2609 lwr_mac_handleInvalidEvt,
2610 lwr_mac_handleInvalidEvt,
2611 lwr_mac_handleConfigReqEvt,
2612 lwr_mac_handleConfigRspEvt,
2613 lwr_mac_handleInvalidEvt,
2617 /*******************************************************************
2619 * @brief Sends message to Lower Mac Fsm Event Handler
2623 * Function : sendToLowerMac
2626 * -Sends message to LowerMac
2628 * @params[in] Message Type
2634 ******************************************************************/
2635 void sendToLowerMac(uint16_t msgType, uint32_t msgLen, void *msg)
2637 clGlobalCp.event = msgType;
2638 fapiEvtHdlr[clGlobalCp.phyState][clGlobalCp.event](msg);
2640 /**********************************************************************
2642 **********************************************************************/