65 #include <ti/control/mmwavelink/mmwavelink.h> 66 #include <ti/control/mmwavelink/include/rl_driver.h> 67 #include <ti/control/mmwavelink/include/rl_messages.h> 68 #include <ti/control/mmwavelink/include/rl_controller.h> 69 #include <ti/control/mmwavelink/include/rl_sensor.h> 70 #include <ti/control/mmwavelink/include/rl_trace.h> 109 rlReturnVal_t retVal;
115 retVal = RL_RET_CODE_INVALID_INPUT;
121 RL_RF_CHAN_CONF_SB, (rlUInt8_t*)data,
125 RL_LOGV_ARG0(
"rlSetChannelConfig ends...\n");
155 rlReturnVal_t retVal;
157 RL_LOGV_ARG0(
"rlSetAdcOutConfig starts...\n");
161 (RL_NULL_PTR == data))
164 retVal = RL_RET_CODE_INVALID_INPUT;
165 RL_LOGE_ARG0(
"rlSetAdcOutConfig, Invalid device map\n");
171 RL_RF_ADCOUT_CONF_SB, (rlUInt8_t*)data,
175 RL_LOGV_ARG0(
"rlSetAdcOutConfig ends...\n");
201 rlReturnVal_t retVal;
203 RL_LOGV_ARG0(
"rlSetBpmCommonConfig starts...\n");
207 (RL_NULL_PTR == data))
210 retVal = RL_RET_CODE_INVALID_INPUT;
211 RL_LOGE_ARG0(
"rlSetBpmCommonConfig, Invalid device map\n");
217 RL_RF_BPM_COMMON_CONF_SB, (rlUInt8_t*)data,
220 RL_LOGV_ARG0(
"rlSetBpmCommonConfig ends...\n");
243 rlReturnVal_t retVal;
245 RL_LOGV_ARG0(
"rlSetBpmChirpConfig starts...\n");
249 (RL_NULL_PTR == data))
252 retVal = RL_RET_CODE_INVALID_INPUT;
253 RL_LOGE_ARG0(
"rlSetBpmChirpConfig, Invalid device map\n");
259 RL_RF_BPM_CHIRP_CONF_SB, (rlUInt8_t*)data,
263 RL_LOGV_ARG0(
"rlSetBpmChirpConfig ends...\n");
288 rlReturnVal_t retVal;
289 RL_LOGV_ARG0(
"rlSetMultiBpmChirpConfig starts...\n");
296 retVal = RL_RET_CODE_INVALID_INPUT;
305 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
310 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
313 sbLen = (rlUInt16_t)(
sizeof(
rlBpmChirpCfg_t) + (RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE));
318 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
320 retVal = RL_RET_CODE_OK;
322 if (cnt <= maxSbCntInMsg)
330 sbCntInMsg = maxSbCntInMsg;
331 numChnkOfMsg = cnt / maxSbCntInMsg;
332 lastSbCntInMsg = cnt % maxSbCntInMsg;
338 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
340 while (retVal == RL_RET_CODE_OK)
343 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
345 inMsg.opcode.
nsbc = lastSbCntInMsg;
349 inMsg.opcode.
nsbc = sbCntInMsg;
352 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
358 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_ADVANCED_FEATURES_SET_MSG,
359 RL_RF_BPM_CHIRP_CONF_SB);
367 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(*data);
384 RL_LOGV_ARG0(
"rlSetMultiBpmChirpConfig ends...\n");
438 rlReturnVal_t retVal;
440 RL_LOGV_ARG0(
"rlSetProfileConfig starts...\n");
444 (RL_NULL_PTR == data) || (cnt == 0U))
447 retVal = RL_RET_CODE_INVALID_INPUT;
448 RL_LOGE_ARG0(
"rlSetProfileConfig, Invalid device map\n");
457 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
460 rlUInt16_t sbCntInAllChunk = 0U;
461 rlUInt16_t maxSbInMsg = (RL_CMD_PL_LEN_MAX /(
sizeof(
rlProfileCfg_t) + \
462 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE));
467 retVal = RL_RET_CODE_OK;
469 for (indx = 0U; (indx < cnt) && (retVal == RL_RET_CODE_OK); indx++)
479 &inPayloadSb[indx], (rlUInt8_t*)(data + indx),
486 if ((maxSbInMsg == (indx + 1U)) || (cnt == sbCntInAllChunk))
489 inMsg.opcode.
nsbc = (indx + 1U);
496 RL_LOGV_ARG0(
"rlSetProfileConfig ends...\n");
524 rlReturnVal_t retVal;
526 RL_LOGV_ARG0(
"rlGetProfileConfig ends...\n");
530 (RL_NULL_PTR == data))
533 retVal = RL_RET_CODE_INVALID_INPUT;
534 RL_LOGE_ARG0(
"rlGetProfileConfig, Invalid device map\n");
545 wordParam.halfWordOne = profileId;
546 wordParam.halfWordTwo = 0U;
563 RL_LOGV_ARG0(
"rlGetProfileConfig ends...\n");
599 rlReturnVal_t retVal;
601 RL_LOGV_ARG0(
"rlSetChirpConfig starts...\n");
605 (RL_NULL_PTR == data) || (cnt == 0U))
608 retVal = RL_RET_CODE_INVALID_INPUT;
616 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
620 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
623 sbLen = (rlUInt16_t)(
sizeof(
rlChirpCfg_t) + (RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE));
628 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
630 retVal = RL_RET_CODE_OK;
632 if (cnt <= maxSbCntInMsg)
640 sbCntInMsg = maxSbCntInMsg;
641 numChnkOfMsg = cnt / maxSbCntInMsg;
642 lastSbCntInMsg = cnt % maxSbCntInMsg;
648 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
650 while (retVal == RL_RET_CODE_OK)
653 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
655 inMsg.opcode.
nsbc = lastSbCntInMsg;
659 inMsg.opcode.
nsbc = sbCntInMsg;
662 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
668 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_SET_MSG,
669 RL_RF_CHIRP_CONF_SB);
673 inPayloadSb[indx].len = (rlUInt16_t)
sizeof(
rlChirpCfg_t);
677 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(data);
698 RL_LOGV_ARG0(
"rlSetChirpConfig ends...\n");
725 rlReturnVal_t retVal;
728 RL_LOGV_ARG0(
"rlGetChirpConfig starts...\n");
732 (RL_NULL_PTR == chirpCfgData))
735 retVal = RL_RET_CODE_INVALID_INPUT;
736 RL_LOGE_ARG0(
"rlGetChirpConfig, Invalid device map\n");
744 rlUInt16_t sbLen, maxSbCntOutMsg, sbCntOutMsg, numChnkOfMsg, lastSbCntOutMsg, loopCnt;
758 maxSbCntOutMsg = (RL_CMD_PL_LEN_MAX -(RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE)) /sbLen;
760 retVal = RL_RET_CODE_OK;
762 if ((chirpEndIdx - chirpStartIdx + 1U) <= maxSbCntOutMsg)
764 sbCntOutMsg = (chirpEndIdx - chirpStartIdx + 1U);
766 lastSbCntOutMsg = 0U;
770 sbCntOutMsg = maxSbCntOutMsg;
771 numChnkOfMsg = (chirpEndIdx - chirpStartIdx + 1U) / maxSbCntOutMsg;
772 lastSbCntOutMsg = (chirpEndIdx - chirpStartIdx + 1U) % maxSbCntOutMsg;
777 wordParam.halfWordTwo = chirpStartIdx;
780 loopCnt = numChnkOfMsg + 1U;
782 outMsg.opcode.
nsbc = 1U;
784 while (retVal == RL_RET_CODE_OK)
787 wordParam.halfWordOne = wordParam.halfWordTwo;
789 if ((loopCnt == 1U) && (lastSbCntOutMsg != 0U))
791 wordParam.halfWordTwo = wordParam.halfWordOne + (lastSbCntOutMsg - 1U);
795 wordParam.halfWordTwo = wordParam.halfWordOne + (sbCntOutMsg - 1U);
805 outPayloadSb.sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_GET_MSG,
806 RL_RF_CHIRP_CONF_SB);
808 outPayloadSb.pSblkData = (rlUInt8_t*)(chirpCfgData);
817 chirpCfgData += sbCntOutMsg;
821 wordParam.halfWordTwo++;
830 RL_LOGV_ARG0(
"rlGetChirpConfig ends...\n");
863 rlReturnVal_t retVal;
864 RL_LOGV_ARG0(
"rlSetMultiChirpCfg starts...\n");
871 retVal = RL_RET_CODE_INVALID_INPUT;
880 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
885 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
888 sbLen = (rlUInt16_t)(
sizeof(
rlChirpCfg_t) + (RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE));
894 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
896 retVal = RL_RET_CODE_OK;
898 if (cnt <= maxSbCntInMsg)
906 sbCntInMsg = maxSbCntInMsg;
907 numChnkOfMsg = cnt / maxSbCntInMsg;
908 lastSbCntInMsg = cnt % maxSbCntInMsg;
914 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
916 while (retVal == RL_RET_CODE_OK)
919 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
921 inMsg.opcode.
nsbc = lastSbCntInMsg;
925 inMsg.opcode.
nsbc = sbCntInMsg;
928 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
934 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_SET_MSG,
935 RL_RF_CHIRP_CONF_SB);
939 inPayloadSb[indx].len = (rlUInt16_t)
sizeof(
rlChirpCfg_t);
943 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(*data);
960 RL_LOGV_ARG0(
"rlSetMultiChirpCfg ends...\n");
1019 rlReturnVal_t retVal;
1021 RL_LOGV_ARG0(
"rlSetFrameConfig starts...\n");
1025 (RL_NULL_PTR == data))
1028 retVal = RL_RET_CODE_INVALID_INPUT;
1029 RL_LOGE_ARG0(
"rlSetFrameConfig, Invalid device map\n");
1035 RL_RF_FRAME_CONF_SB, (rlUInt8_t*)data,
1047 tempVar = (rlUInt32_t)(((data->chirpEndIdx - data->chirpStartIdx) + 1U) *
1049 #ifndef MMWL_BIG_ENDIAN 1052 frameApplyCfgArgs.
numChirps = RL_SWAP_32(tempVar);
1058 RL_LOGV_ARG0(
"rlSetFrameConfig ends...\n");
1080 rlReturnVal_t retVal;
1082 RL_LOGV_ARG0(
"rlGetFrameConfig starts...\n");
1086 (RL_NULL_PTR == data))
1089 retVal = RL_RET_CODE_INVALID_INPUT;
1090 RL_LOGE_ARG0(
"rlGetFrameConfig, Invalid device map\n");
1096 RL_RF_FRAME_CONF_SB, (rlUInt8_t*)data, 0U);
1114 &inPayloadSb, (rlUInt8_t*)RL_NULL_PTR, 0x0U);
1120 (rlUInt8_t*)&frameApplyCfgArgs, 0U);
1124 #ifndef MMWL_BIG_ENDIAN 1127 data->numAdcSamples = frameApplyCfgArgs.numAdcSamples;
1130 data->numAdcSamples = RL_SWAP_32(frameApplyCfgArgs.numAdcSamples);
1135 RL_LOGV_ARG0(
"rlGetFrameConfig ends...\n");
1192 rlReturnVal_t retVal;
1194 RL_LOGV_ARG0(
"rlSetAdvFrameConfig starts...\n");
1200 retVal = RL_RET_CODE_INVALID_INPUT;
1201 RL_LOGE_ARG0(
"rlSetAdvFrameConfig, Invalid device map\n");
1207 RL_RF_FRAME_CONF_ADVANCED_SB,
1218 RL_LOGV_ARG0(
"rlSetAdvFrameConfig ends...\n");
1240 rlReturnVal_t retVal;
1242 RL_LOGV_ARG0(
"rlGetAdvFrameConfig starts...\n");
1246 (RL_NULL_PTR == data))
1249 retVal = RL_RET_CODE_INVALID_INPUT;
1250 RL_LOGE_ARG0(
"rlGetAdvFrameConfig, Invalid device map\n");
1256 RL_RF_FRAME_CONF_ADVANCED_SB,
1257 (rlUInt8_t*)(&(data->
frameSeq)), 0U);
1274 RL_SYS_ADV_FRAME_CONFIG_GET_SB,
1275 &inPayloadSb, (rlUInt8_t*)RL_NULL_PTR, 0U);
1288 RL_LOGV_ARG0(
"rlGetAdvFrameConfig ends...\n");
1313 rlReturnVal_t retVal;
1315 RL_LOGV_ARG0(
"rlSetContModeConfig starts...\n");
1319 (RL_NULL_PTR == data))
1322 retVal = RL_RET_CODE_INVALID_INPUT;
1323 RL_LOGE_ARG0(
"rlSetContModeConfig, Invalid device map\n");
1329 RL_RF_CONT_STREAMING_MODE_CONF_SB,
1333 RL_LOGV_ARG0(
"rlSetContModeConfig ends...\n");
1353 rlReturnVal_t retVal;
1355 RL_LOGV_ARG0(
"rlEnableContMode starts...\n");
1359 (RL_NULL_PTR == data))
1362 retVal = RL_RET_CODE_INVALID_INPUT;
1363 RL_LOGE_ARG0(
"rlEnableContMode, Invalid device map\n");
1369 RL_RF_CONT_STREAMING_MODE_EN_SB,
1374 RL_LOGV_ARG0(
"rlEnableContMode starts...\n");
1398 rlReturnVal_t retVal;
1400 RL_LOGV_ARG0(
"rlSetLowPowerModeConfig starts...\n");
1406 retVal = RL_RET_CODE_INVALID_INPUT;
1407 RL_LOGE_ARG0(
"rlSetLowPowerModeConfig, Invalid device map\n");
1413 RL_RF_LOWPOWERMODE_CONF_SB,
1418 RL_LOGV_ARG0(
"rlSetLowPowerModeConfig ends...\n");
1443 rlReturnVal_t retVal;
1447 RL_LOGV_ARG0(
"rlSensorStart starts...\n");
1449 frameTriggerArgs.
startStop = RL_FRAME_TRIGGER_START;
1456 retVal = RL_RET_CODE_INVALID_INPUT;
1457 RL_LOGE_ARG0(
"rlSensorStart, Invalid device map\n");
1463 RL_RF_FRAMESTARTSTOP_CONF_SB,
1464 (rlUInt8_t*)(&frameTriggerArgs),
1467 RL_LOGV_ARG0(
"rlSensorStart ends...\n");
1497 rlReturnVal_t retVal;
1501 frameTriggerArgs.
startStop = RL_FRAME_TRIGGER_STOP;
1504 RL_LOGV_ARG0(
"rlSensorStop starts...\n");
1510 retVal = RL_RET_CODE_INVALID_INPUT;
1511 RL_LOGE_ARG0(
"rlSensorStop, Invalid device map\n");
1517 RL_RF_FRAMESTARTSTOP_CONF_SB,
1518 (rlUInt8_t*)(&frameTriggerArgs),
1521 RL_LOGV_ARG0(
"rlSensorStop ends...\n");
1557 rlReturnVal_t retVal;
1559 RL_LOGV_ARG0(
"rlFrameStartStop starts...\n");
1565 retVal = RL_RET_CODE_INVALID_INPUT;
1566 RL_LOGE_ARG0(
"rlFrameStartStop, Invalid device map\n");
1572 RL_RF_FRAMESTARTSTOP_CONF_SB,
1576 RL_LOGV_ARG0(
"rlFrameStartStop ends...\n");
1614 rlReturnVal_t retVal;
1616 RL_LOGV_ARG0(
"rlRfInit starts...\n");
1622 retVal = RL_RET_CODE_INVALID_INPUT;
1623 RL_LOGE_ARG0(
"rlRfInit, Invalid device map\n");
1630 RL_LOGV_ARG0(
"rlRfInit ends...\n");
1660 rlReturnVal_t retVal;
1662 RL_LOGV_ARG0(
"rlSetTestSourceConfig starts...\n");
1666 (RL_NULL_PTR == data))
1669 retVal = RL_RET_CODE_INVALID_INPUT;
1670 RL_LOGE_ARG0(
"rlSetTestSourceConfig, Invalid device map\n");
1676 RL_RF_TEST_SOURCE_CONFIG_SET_SB,
1680 RL_LOGV_ARG0(
"rlSetTestSourceConfig ends...\n");
1700 rlReturnVal_t retVal;
1702 RL_LOGV_ARG0(
"rlTestSourceEnable starts...\n");
1706 (RL_NULL_PTR == data))
1709 retVal = RL_RET_CODE_INVALID_INPUT;
1710 RL_LOGE_ARG0(
"rlTestSourceEnable, Invalid device map\n");
1716 RL_RF_TEST_SOURCE_ENABLE_SET_SB,
1720 RL_LOGV_ARG0(
"rlTestSourceEnable ends...\n");
1740 rlReturnVal_t retVal;
1742 RL_LOGV_ARG0(
"rlRfGetTemperatureReport starts...\n");
1746 (RL_NULL_PTR == data))
1749 retVal = RL_RET_CODE_INVALID_INPUT;
1750 RL_LOGE_ARG0(
"rlRfGetTemperatureReport, Invalid device map\n");
1756 RL_RF_CHAR_CONF_DYNAMIC_GET_SB,
1759 RL_LOGV_ARG0(
"rlRfGetTemperatureReport ends...\n");
1782 rlReturnVal_t retVal;
1784 RL_LOGV_ARG0(
"rlRfDfeRxdStatisticsReport starts...\n");
1788 (RL_NULL_PTR == data))
1791 retVal = RL_RET_CODE_INVALID_INPUT;
1792 RL_LOGE_ARG0(
"Invalid input\n");
1798 RL_RF_DFE_STATISTICS_REPORT_GET_SB,
1799 (rlUInt8_t*)data, 0U);
1801 RL_LOGV_ARG0(
"rlRfDfeRxdStatisticsReport completes...\n");
1831 rlReturnVal_t retVal;
1833 RL_LOGV_ARG0(
"rlRfDynamicPowerSave starts...\n");
1837 (RL_NULL_PTR == data))
1840 retVal = RL_RET_CODE_INVALID_INPUT;
1841 RL_LOGE_ARG0(
"Invalid input\n");
1847 RL_RF_DYNAMICPOWERSAVE_CONF_SB,
1851 RL_LOGV_ARG0(
"rlRfDynamicPowerSave completes...\n");
1881 rlReturnVal_t retVal;
1883 RL_LOGV_ARG0(
"rlRfSetDeviceCfg starts...\n");
1887 (RL_NULL_PTR == data))
1890 retVal = RL_RET_CODE_INVALID_INPUT;
1891 RL_LOGE_ARG0(
"Invalid input\n");
1897 RL_RF_DEVICE_CFG_SB,
1901 RL_LOGV_ARG0(
"rlRfSetDeviceCfg completes...\n");
1927 rlReturnVal_t retVal;
1929 RL_LOGV_ARG0(
"rlSetGpAdcConfig starts...\n");
1933 (RL_NULL_PTR == data))
1936 retVal = RL_RET_CODE_INVALID_INPUT;
1937 RL_LOGE_ARG0(
"Invalid input\n");
1943 RL_RF_GPADC_CONF_SET_SB,
1947 RL_LOGV_ARG0(
"rlSetGpAdcConfig completes...\n");
1972 rlReturnVal_t retVal;
1974 RL_LOGV_ARG0(
"rlRfSetLdoBypassConfig starts...\n");
1980 retVal = RL_RET_CODE_INVALID_INPUT;
1986 RL_RF_LDOBYPASS_SET_SB,
1991 RL_LOGV_ARG0(
"rlRfSetLdoBypassConfig completes...\n");
2024 rlReturnVal_t retVal;
2026 RL_LOGV_ARG0(
"rlRfSetPhaseShiftConfig starts...\n");
2030 (RL_NULL_PTR == data) || (cnt == 0U))
2033 retVal = RL_RET_CODE_INVALID_INPUT;
2041 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
2045 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
2053 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
2055 retVal = RL_RET_CODE_OK;
2057 if (cnt <= maxSbCntInMsg)
2061 lastSbCntInMsg = 0U;
2065 sbCntInMsg = maxSbCntInMsg;
2066 numChnkOfMsg = cnt / maxSbCntInMsg;
2067 lastSbCntInMsg = cnt % maxSbCntInMsg;
2073 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
2075 while (retVal == RL_RET_CODE_OK)
2078 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
2080 inMsg.opcode.
nsbc = lastSbCntInMsg;
2084 inMsg.opcode.
nsbc = sbCntInMsg;
2087 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
2093 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_SET_MSG,
2094 RL_RF_PERCHIRPPHASESHIFT_CONF_SB);
2102 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(data);
2123 RL_LOGV_ARG0(
"rlRfSetPhaseShiftConfig ends...\n");
2147 rlReturnVal_t retVal;
2149 RL_LOGV_ARG0(
"rlRfSetPALoopbackConfig starts...\n");
2155 retVal = RL_RET_CODE_INVALID_INPUT;
2161 RL_RF_PALOOPBACK_CFG_SET_SB,
2166 RL_LOGV_ARG0(
"rlRfSetPALoopbackConfig completes...\n");
2197 rlReturnVal_t retVal;
2199 RL_LOGV_ARG0(
"rlRfSetPSLoopbackConfig starts...\n");
2205 retVal = RL_RET_CODE_INVALID_INPUT;
2211 RL_RF_PSLOOPBACK_CFG_SET_SB,
2216 RL_LOGV_ARG0(
"rlRfSetPSLoopbackConfig completes...\n");
2240 rlReturnVal_t retVal;
2242 RL_LOGV_ARG0(
"rlRfSetIFLoopbackConfig starts...\n");
2248 retVal = RL_RET_CODE_INVALID_INPUT;
2254 RL_RF_IFLOOPBACK_CFG_SET_SB,
2259 RL_LOGV_ARG0(
"rlRfSetIFLoopbackConfig completes...\n");
2289 rlReturnVal_t retVal;
2291 RL_LOGV_ARG0(
"rlRfSetProgFiltCoeffRam starts...\n");
2297 retVal = RL_RET_CODE_INVALID_INPUT;
2303 RL_RF_PROG_FILT_COEFF_RAM_SET_SB,
2308 RL_LOGV_ARG0(
"rlRfSetProgFiltCoeffRam completes...\n");
2331 rlReturnVal_t retVal;
2333 RL_LOGV_ARG0(
"rlRfSetProgFiltConfig starts...\n");
2339 retVal = RL_RET_CODE_INVALID_INPUT;
2345 RL_RF_PROG_FILT_CONF_SET_SB,
2350 RL_LOGV_ARG0(
"rlRfSetProgFiltConfig completes...\n");
2374 rlReturnVal_t retVal;
2376 RL_LOGV_ARG0(
"rlRfSetMiscConfig starts...\n");
2382 retVal = RL_RET_CODE_INVALID_INPUT;
2388 RL_RF_RADAR_MISC_CTL_SB,
2393 RL_LOGV_ARG0(
"rlRfSetMiscConfig completes...\n");
2427 rlReturnVal_t retVal;
2429 RL_LOGV_ARG0(
"rlRfSetCalMonTimeUnitConfig starts...\n");
2435 retVal = RL_RET_CODE_INVALID_INPUT;
2441 RL_RF_CALIB_MON_TIME_UNIT_SB,
2446 RL_LOGV_ARG0(
"rlRfSetCalMonTimeUnitConfig completes...\n");
2478 rlReturnVal_t retVal;
2480 RL_LOGV_ARG0(
"rlRfSetCalMonFreqLimitConfig starts...\n");
2486 retVal = RL_RET_CODE_INVALID_INPUT;
2492 RL_RF_CAL_MON_FREQ_LIMIT_SB,
2497 RL_LOGV_ARG0(
"rlRfSetCalMonFreqLimitConfig completes...\n");
2525 rlReturnVal_t retVal;
2527 RL_LOGV_ARG0(
"rlRfInitCalibConfig starts...\n");
2533 retVal = RL_RET_CODE_INVALID_INPUT;
2539 RL_RF_INIT_CALIB_CONF_SB,
2544 RL_LOGV_ARG0(
"rlRfInitCalibConfig completes...\n");
2577 rlReturnVal_t retVal;
2579 RL_LOGV_ARG0(
"rlRfRunTimeCalibConfig starts...\n");
2585 retVal = RL_RET_CODE_INVALID_INPUT;
2591 RL_RF_RUN_TIME_CALIB_CONF_TRIG_SB,
2596 RL_LOGV_ARG0(
"rlRfRunTimeCalibConfig completes...\n");
2618 rlReturnVal_t retVal;
2624 retVal = RL_RET_CODE_INVALID_INPUT;
2630 RL_RF_RX_GAIN_TEMPLUT_CONF_SB, (rlUInt8_t*)data,
2655 rlReturnVal_t retVal;
2657 RL_LOGV_ARG0(
"rlRxGainTempLutRead starts...\n");
2661 (RL_NULL_PTR == inData))
2664 retVal = RL_RET_CODE_INVALID_INPUT;
2665 RL_LOGE_ARG0(
"rlRxGainTempLutRead, Invalid device map\n");
2679 &inPayloadSb, (rlUInt8_t *)inData,
2695 RL_LOGV_ARG0(
"rlRxGainTempLutRead ends...\n");
2716 rlReturnVal_t retVal;
2722 retVal = RL_RET_CODE_INVALID_INPUT;
2728 RL_RF_TX_GAIN_TEMPLUT_CONF_SB, (rlUInt8_t*)data,
2750 rlReturnVal_t rlTxGainTempLutGet(rlUInt8_t deviceMap,
2753 rlReturnVal_t retVal;
2755 RL_LOGV_ARG0(
"rlTxGainTempLutRead starts...\n");
2759 (RL_NULL_PTR == inData))
2762 retVal = RL_RET_CODE_INVALID_INPUT;
2763 RL_LOGE_ARG0(
"rlTxGainTempLutRead, Invalid device map\n");
2777 &inPayloadSb, (rlUInt8_t *)inData,
2793 RL_LOGV_ARG0(
"rlTxGainTempLutRead ends...\n");
2823 rlReturnVal_t retVal;
2827 (RL_NULL_PTR == data))
2830 retVal = RL_RET_CODE_INVALID_INPUT;
2836 RL_RF_TX_FREQ_PWR_LIMIT_SB,
2879 rlReturnVal_t retVal;
2885 retVal = RL_RET_CODE_INVALID_INPUT;
2891 RL_RF_LB_BURST_CFG_SET_SB, (rlUInt8_t*)data,
2920 rlReturnVal_t retVal;
2927 retVal = RL_RET_CODE_INVALID_INPUT;
2936 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
2941 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
2944 sbLen = (rlUInt16_t)(
sizeof(
rlDynChirpCfg_t) + (RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE));
2950 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
2952 retVal = RL_RET_CODE_OK;
2954 if (segCnt <= maxSbCntInMsg)
2956 sbCntInMsg = segCnt;
2958 lastSbCntInMsg = 0U;
2962 sbCntInMsg = maxSbCntInMsg;
2963 numChnkOfMsg = segCnt / maxSbCntInMsg;
2964 lastSbCntInMsg = segCnt % maxSbCntInMsg;
2970 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
2972 while (retVal == RL_RET_CODE_OK)
2975 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
2977 inMsg.opcode.
nsbc = lastSbCntInMsg;
2981 inMsg.opcode.
nsbc = sbCntInMsg;
2984 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
2990 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_SET_MSG,
2991 RL_RF_DYN_CHIRP_CFG_SET_SB);
2999 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(*data);
3043 rlReturnVal_t retVal;
3049 retVal = RL_RET_CODE_INVALID_INPUT;
3055 RL_RF_DYN_CHIRP_CFG_EN_SB, (rlUInt8_t*)data,
3093 rlReturnVal_t retVal;
3100 retVal = RL_RET_CODE_INVALID_INPUT;
3109 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
3113 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
3117 (RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE));
3122 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
3124 retVal = RL_RET_CODE_OK;
3126 if (segCnt <= maxSbCntInMsg)
3128 sbCntInMsg = segCnt;
3130 lastSbCntInMsg = 0U;
3134 sbCntInMsg = maxSbCntInMsg;
3135 numChnkOfMsg = segCnt / maxSbCntInMsg;
3136 lastSbCntInMsg = segCnt % maxSbCntInMsg;
3142 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
3144 while (retVal == RL_RET_CODE_OK)
3147 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
3149 inMsg.opcode.
nsbc = lastSbCntInMsg;
3153 inMsg.opcode.
nsbc = sbCntInMsg;
3156 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
3162 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_SET_MSG,
3163 RL_RF_DYN_PERCHIRP_PHSHFT_CFG_SET_SB);
3171 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(*data);
3220 rlReturnVal_t retVal;
3227 retVal = RL_RET_CODE_INVALID_INPUT;
3237 retVal = RL_RET_CODE_OK;
3239 for (idx = 0U; idx < RL_MAX_CALIB_DATA_CHUNK; idx++)
3251 (rlUInt8_t*)(&data->calibChunk[idx]),
3262 if (RL_RET_CODE_OK != retVal)
3302 rlReturnVal_t retVal;
3308 retVal = RL_RET_CODE_INVALID_INPUT;
3320 retVal = RL_RET_CODE_OK;
3322 for (idx = 0U; idx < RL_MAX_CALIB_DATA_CHUNK; idx++)
3344 if (RL_RET_CODE_OK != retVal)
3350 caldataGetCfg.chunkId++;
3385 rlReturnVal_t retVal;
3391 retVal = RL_RET_CODE_INVALID_INPUT;
3397 RL_RF_DIG_COMP_EST_CTRL_SB, (rlUInt8_t*)data,
3418 rlReturnVal_t retVal;
3421 if (data == RL_NULL_PTR)
3424 retVal = RL_RET_CODE_NULL_PTR;
3430 RL_RF_BOOTUP_BIST_STATUS_SB, (rlUInt8_t*)data, 0U);
3462 rlReturnVal_t retVal;
3468 retVal = RL_RET_CODE_INVALID_INPUT;
3474 RL_RF_INTERCHIRP_BLOCK_CTRL_SB, (rlUInt8_t*)data,
3514 rlReturnVal_t retVal;
3520 retVal = RL_RET_CODE_INVALID_INPUT;
3526 RL_RF_SUBFRAME_START_SB, (rlUInt8_t*)data,
3555 rlReturnVal_t retVal;
3562 retVal = RL_RET_CODE_INVALID_INPUT;
3572 retVal = RL_RET_CODE_OK;
3574 for (idx = 0U; idx < RL_TX_CNT; idx++)
3578 if (idx == (RL_TX_CNT - 1U))
3580 data->PhShiftcalibChunk[idx].
calibApply = 1U;
3584 data->PhShiftcalibChunk[idx].
calibApply = 0U;
3586 data->PhShiftcalibChunk[idx].
txIndex = idx;
3595 &inPayloadSb, (rlUInt8_t*)(&data->PhShiftcalibChunk[idx]),
3606 if (RL_RET_CODE_OK != retVal)
3641 rlReturnVal_t retVal;
3647 retVal = RL_RET_CODE_INVALID_INPUT;
3661 retVal = RL_RET_CODE_OK;
3663 for (idx = 0U; idx < RL_TX_CNT; idx++)
3665 if ((RL_NULL_PTR != &data->PhShiftcalibChunk[idx]))
3667 phShifterCaldataGetCfg.
txIndex = idx;
3672 &inPayloadSb, (rlUInt8_t*)&phShifterCaldataGetCfg,
3685 (rlUInt8_t*)(&data->PhShiftcalibChunk[idx]), 0U);
3690 if (RL_RET_CODE_OK != retVal)
3716 rlReturnVal_t retVal;
3719 if (data == RL_NULL_PTR)
3722 retVal = RL_RET_CODE_NULL_PTR;
3728 RL_RF_DIEID_STATUS_SB, (rlUInt8_t*)data, 0U);
3749 rlReturnVal_t retVal;
3751 RL_LOGV_ARG0(
"rlRfGetCpuFault starts...\n");
3755 (RL_NULL_PTR == data))
3758 retVal = RL_RET_CODE_INVALID_INPUT;
3759 RL_LOGE_ARG0(
"Invalid input");
3765 RL_RF_RFCPUFAULT_STATUS_SB, (rlUInt8_t*)data,
3768 RL_LOGV_ARG0(
"rlRfGetCpuFault ends...\n");
3788 rlReturnVal_t retVal;
3790 RL_LOGV_ARG0(
"rlRfGetEsmFault starts...\n");
3794 (RL_NULL_PTR == data))
3797 retVal = RL_RET_CODE_INVALID_INPUT;
3798 RL_LOGE_ARG0(
"Invalid input");
3804 RL_RF_RFESMFAULT_STATUS_SB, (rlUInt8_t*)data,
3807 RL_LOGV_ARG0(
"rlRfGetEsmFault ends...\n");
3895 rlReturnVal_t retVal;
3897 RL_LOGV_ARG0(
"rlSetAdvChirpConfig starts...\n");
3903 retVal = RL_RET_CODE_INVALID_INPUT;
3904 RL_LOGE_ARG0(
"rlSetAdvChirpConfig, Invalid device map\n");
3910 RL_RF_ADV_CHIRP_CFG_SET_SB,
3915 RL_LOGV_ARG0(
"rlSetAdvChirpConfig ends...\n");
3966 rlReturnVal_t retVal;
3968 RL_LOGV_ARG0(
"rlMonTypeTrigConfig starts...\n");
3974 retVal = RL_RET_CODE_INVALID_INPUT;
3975 RL_LOGE_ARG0(
"rlMonTypeTrigConfig, Invalid device map\n");
3981 RL_RF_MONITOR_TYPE_TRIG_CONF_SB,
3986 RL_LOGV_ARG0(
"rlMonTypeTrigConfig ends...\n");
4011 rlReturnVal_t retVal;
4015 (RL_NULL_PTR == data))
4018 retVal = RL_RET_CODE_INVALID_INPUT;
4024 RL_RF_APLL_SYNTH_BW_CTL_SB,
4065 rlReturnVal_t retVal;
4067 RL_LOGV_ARG0(
"rlSetAdvChirpLUTConfig starts...\n");
4073 retVal = RL_RET_CODE_INVALID_INPUT;
4074 RL_LOGE_ARG0(
"rlSetAdvChirpLUTConfig, Invalid device map\n");
4080 RL_RF_ADV_CHIRP_CFG_LUT_SET_SB,
4085 RL_LOGV_ARG0(
"rlSetAdvChirpLUTConfig ends...\n");
4115 rlInt8_t* AdvChirpLUTData)
4117 rlReturnVal_t retVal = RL_RET_CODE_OK;
4121 rlUInt16_t chunkCount = 0U, totalChunkCount, lastChunkSize;
4123 RL_LOGV_ARG0(
"rlSetMultiAdvChirpLUTConfig starts...\n");
4127 (RL_NULL_PTR == AdvChirpLUTCfgArgs) || (RL_NULL_PTR == AdvChirpLUTData))
4130 retVal += RL_RET_CODE_INVALID_INPUT;
4131 RL_LOGE_ARG0(
"rlSetMultiAdvChirpLUTConfig, Invalid input params\n");
4135 RL_LOGV_ARG2(
"rlSetMultiAdvChirpLUTConfig with \nlutAddOffset[%d]\nnumBytes[%d] \n\n",\
4140 if (AdvChirpLUTCfgArgs->
numBytes > RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE)
4143 if ((AdvChirpLUTCfgArgs->
numBytes % RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE) == 0U)
4145 lastChunkSize = RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE;
4147 (rlUInt16_t)(AdvChirpLUTCfgArgs->
numBytes / RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE);
4153 (rlUInt16_t)((AdvChirpLUTCfgArgs->
numBytes/RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE) + 1U);
4155 (rlUInt16_t)(AdvChirpLUTCfgArgs->
numBytes % RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE);
4162 totalChunkCount = 1U;
4164 lastChunkSize = AdvChirpLUTCfgArgs->
numBytes;
4167 while (chunkCount < totalChunkCount)
4169 RL_LOGV_ARG1(
"Sending Advanced Chirp LUT data Chunk [%d]... \n\n", chunkCount);
4173 (chunkCount * RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE));
4176 if (chunkCount == (totalChunkCount - 1U))
4178 AdvChirpLUTCfgChunk.
numBytes = lastChunkSize;
4183 AdvChirpLUTCfgChunk.
numBytes = RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE;
4186 if (AdvChirpLUTCfgChunk.
numBytes > 0U)
4191 (void)memcpy(&AdvChirpLUTCfgChunk.
calData[0U], \
4192 &AdvChirpLUTData[chunkCount * RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE], \
4195 RL_LOGV_ARG2(
"rlSetAdvChirpLUTConfig with \nlutAddOffset[%d]\nnumBytes[%d] \n\n",\
4200 if (retVal != RL_RET_CODE_OK)
4202 RL_LOGV_ARG2(
"Advanced Chirp LUT data Chunk [%d] failed with error code %d",\
4203 chunkCount, retVal);
4210 retVal += RL_RET_CODE_INVALID_INPUT;
4211 RL_LOGV_ARG2(
"Invalid input, Chirp LUT Chunk [%d] is programmed with %d bytes",\
4212 chunkCount, AdvChirpLUTCfgChunk.
numBytes);
4219 RL_LOGV_ARG0(
"rlSetMultiAdvChirpLUTConfig ends...\n");
4246 rlReturnVal_t retVal;
4248 RL_LOGV_ARG0(
"rlSetAdvChirpDynLUTAddrOffConfig starts...\n");
4254 retVal = RL_RET_CODE_INVALID_INPUT;
4255 RL_LOGE_ARG0(
"rlSetAdvChirpDynLUTAddrOffConfig, Invalid device map\n");
4261 RL_RF_ADV_CHIRP_DYN_LUT_ADD_OFF_CONF_SB,
4266 RL_LOGV_ARG0(
"rlSetAdvChirpDynLUTAddrOffConfig ends...\n");
Radar RF LDO bypass enable/disable configuration.
ADC format and payload justification Configuration.
rlReturnVal_t rlSetInterChirpBlkCtrl(rlUInt8_t deviceMap, rlInterChirpBlkCtrlCfg_t *data)
Sets Inter-chip turn on and turn off times or various RF blocks.
rlReturnVal_t rlGetRfBootupStatus(rlUInt8_t deviceMap, rlRfBootStatusCfg_t *data)
Get radarSS bootup status.
Test source Enable API parameters RL_RF_TEST_SOURCE_ENABLE_SB.
Radar RF Calibration monitoring time unit configuration.
rlReturnVal_t rlSetTestSourceConfig(rlUInt8_t deviceMap, rlTestSource_t *data)
Configures the Test Source.
Advanced chirp configuration structure.
Advance Frame Sequence config API parameters rlAdvFrameCfg, 148 bytes.
rlReturnVal_t rlSetProfileConfig(rlUInt8_t deviceMap, rlUInt16_t cnt, rlProfileCfg_t *data)
Sets Chirp profile Configuration.
rlReturnVal_t rlFrameStartStop(rlUInt8_t deviceMap, rlFrameTrigger_t *data)
Triggers/Stops Transmission of Frames.
rlReturnVal_t rlRfInterRxGainPhaseConfig(rlUInt8_t deviceMap, rlInterRxGainPhConf_t *data)
Sets different Rx gain/phase offset.
rlReturnVal_t rlTxGainTempLutSet(rlUInt8_t deviceMap, rlTxGainTempLutData_t *data)
Overwrites TX gain temperature based Lookup table (LUT)
API radarSS GPADC API MEAS SET SBC M_API_AR_RF_GPADC_API_SET_SB.
Dynamic chirp enable configuration.
rlReturnVal_t rlRfGetTemperatureReport(rlUInt8_t deviceMap, rlRfTempData_t *data)
Gets Time and Temperature information report.
rlReturnVal_t rlGetRfDieId(rlUInt8_t deviceMap, rlRfDieIdCfg_t *data)
Get device die ID status.
Structure to hold the BSS ESM Fault data strucutre for event RL_RF_AE_ESMFAULT_SB.
rlReturnVal_t rlSetAdvChirpDynLUTAddrOffConfig(rlUInt8_t deviceMap, rlAdvChirpDynLUTAddrOffCfg_t *data)
Configure LUT address offset dynamically for each chirp parameters defined in rlSetAdvChirpConfig API...
Structure to store all Phase shifter calibration data chunks which device provides in response of rlR...
Radar RF Phase shift loopback configuration.
rlReturnVal_t rlRfGetCpuFault(rlUInt8_t deviceMap, rlCpuFault_t *data)
Get RadarSS CPU fault status.
rlReturnVal_t rlRfSetMiscConfig(rlUInt8_t deviceMap, rlRfMiscConf_t *data)
Sets misc feature such as per chirp phase shifter.
rlReturnVal_t rlTestSourceEnable(rlUInt8_t deviceMap, rlTestSourceEnable_t *data)
Enables the Test Source.
rlUInt16_t numBytes
Number of valid bytes to write. Valid range: 4 to 212, must be multiple of 4. .
rlReturnVal_t rlRfRunTimeCalibConfig(rlUInt8_t deviceMap, rlRunTimeCalibConf_t *data)
Set RF one time & periodic calibration of various RF/analog aspects and trigger.
void rlDriverConstructOutMsg(rlUInt16_t numSblk, rlDriverMsg_t *outMsg, rlPayloadSb_t *payloadPtr)
: Construct command packet based on given message-ID and payload
RX gain temperature LUT inject.
Test source config API parameters E_API_AR_TEST_SOURCE_CONF_SB.
rlReturnVal_t rlSetLowPowerModeConfig(rlUInt8_t deviceMap, rlLowPowerModeCfg_t *data)
Sets Low Power Mode Configuration.
Tx freq and power limit configuration.
rlReturnVal_t rlGetProfileConfig(rlUInt8_t deviceMap, rlUInt16_t profileId, rlProfileCfg_t *data)
Gets Chirp profile Configuration.
rlReturnVal_t rlRfInit(rlUInt8_t deviceMap)
Initializes the RF/Analog Subsystem.
rlUInt8_t rlDriverGetPlatformId(void)
Returns RL Platform ID (i.e. where mmWaveLink is executing)
Get phase shift calibration data configuration structure.
Chirp config API parameters. This structure contains fine dithering to coarse profile defined in rlPr...
rlReturnVal_t rlRfGetEsmFault(rlUInt8_t deviceMap, rlBssEsmFault_t *data)
Get RadarSS ESM fault status.
Frame config API parameters.
rlReturnVal_t rlRfSetCalMonFreqLimitConfig(rlUInt8_t deviceMap, rlRfCalMonFreqLimitConf_t *data)
Set Calibration monitoring Frequency Limit.
rlReturnVal_t rlMonTypeTrigConfig(rlUInt8_t deviceMap, rlMonTypeTrigCfg_t *data)
Maintains monitoring timing synchronization in cascaded devices to avoid mutual interference of monit...
rlReturnVal_t rlSetAdcOutConfig(rlUInt8_t deviceMap, rlAdcOutCfg_t *data)
Sets ADC Output Configuration.
Radar RF Init Calibration configuration.
rlReturnVal_t rlRfDynamicPowerSave(rlUInt8_t deviceMap, rlDynPwrSave_t *data)
: Configure dynamic power saving feature.
rlReturnVal_t rlRfSetCalMonTimeUnitConfig(rlUInt8_t deviceMap, rlRfCalMonTimeUntConf_t *data)
Set Calibration monitoring time unit.
Phase shift calibration data which application will receive from radarSS and will feed in to the Devi...
Low Power mode configuration.
rlReturnVal_t rlRfTxFreqPwrLimitConfig(rlUInt8_t deviceMap, rlRfTxFreqPwrLimitMonConf_t *data)
Sets the limits for RF frequency transmission for each TX and also TX power limits.
rlReturnVal_t rlRfPhShiftCalibDataRestore(rlUInt8_t deviceMap, rlPhShiftCalibrationData_t *data)
Injects phase shifter calibration data to the device.
Dynamic power saving API parameters.
rlReturnVal_t rlGetFrameConfig(rlUInt8_t deviceMap, rlFrameCfg_t *data)
Gets Frame Configuration.
void rlDriverConstructInMsg(rlUInt16_t msgId, rlDriverMsg_t *inMsg, rlPayloadSb_t *payloadPtr)
: Construct command packet (inMsg) based on given message-ID and payload
rlInt8_t calData[RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE]
Byte array to load in to the Generic SW Chirp Parameter LUT. The size of this sub-block is fixed to...
rlUInt8_t calibApply
Set this to 1 after injecting calibration data for all Txs to enable the firmware calibration....
API RF device Config SBC M_API_AR_RF_DEV_CONF_SBC.
rlReturnVal_t rlRfSetPSLoopbackConfig(rlUInt8_t deviceMap, rlRfPSLoopbackCfg_t *data)
Enable/Disable Phase shift loopback for all enabled profiles.
Radar RF Phase Shift enable/disable configuration.
rlReturnVal_t rlRfSetPhaseShiftConfig(rlUInt8_t deviceMap, rlUInt16_t cnt, rlRfPhaseShiftCfg_t *data)
Enable/Disable phase shift configurations per chirp in each of the TXs.
rlReturnVal_t rlSensorStop(rlUInt8_t deviceMap)
Stops Transmission of Frames.
rlUInt16_t nsbc
Number of Sub Blocks in Payload.
Radar RF Calibration monitoring Frequency Limit configuration.
RF characterization Time and Temperature data structure.
Frame config API parameters.
TX gain temperature LUT read.
Array of coefficients for the RF programmable filter.
rlReturnVal_t rlSetAdvFrameConfig(rlUInt8_t deviceMap, rlAdvFrameCfg_t *data)
Sets Advance Frame Configuration.
rlReturnVal_t rlDriverExecuteGetApi(rlUInt8_t deviceMap, rlUInt16_t msgId, rlUInt16_t sbcID, rlUInt8_t *msgData, rlUInt16_t inLen)
: Construct get message and invoke command.
Get calibration data configuration structure.
Advanced Chirp Dynamic LUT Address Offset Configuration Structure Configure LUT address offset dynami...
Radar RF IF loopback configuration.
rlReturnVal_t rlRfPhShiftCalibDataStore(rlUInt8_t deviceMap, rlPhShiftCalibrationData_t *data)
Read calibration data from the device.
rlReturnVal_t rlSetFrameConfig(rlUInt8_t deviceMap, rlFrameCfg_t *data)
Sets Frame Configuration.
MMWL_EXPORT rlReturnVal_t rlDeviceAdvFrameConfigApply(rlUInt8_t deviceMap, rlAdvFrameDataCfg_t *data)
Sets Advance Frame data path Configuration.
Dynamic chirp configuration for 16 chirp configurations.
rlReturnVal_t rlRfCalibDataStore(rlUInt8_t deviceMap, rlCalibrationData_t *data)
Read calibration data from the device.
rlReturnVal_t rlEnableContMode(rlUInt8_t deviceMap, rlContModeEn_t *data)
Enable/Disable Continous mode.
rlReturnVal_t rlRxGainTempLutSet(rlUInt8_t deviceMap, rlRxGainTempLutData_t *data)
Overwrite RX gain temperature Lookup Table(LUT) in Radar SS.
rlReturnVal_t rlSetContModeConfig(rlUInt8_t deviceMap, rlContModeCfg_t *data)
Sets Continous mode Configuration.
rlUInt16_t lutAddressOffset
Start address offset at which to populate the bytes of patterns. Address offset has to be multiple ...
rlReturnVal_t rlRfCalibDataRestore(rlUInt8_t deviceMap, rlCalibrationData_t *data)
Injects calibration data to the device.
MMWL_EXPORT rlReturnVal_t rlDeviceFrameConfigApply(rlUInt8_t deviceMap, rlFrameApplyCfg_t *data)
Sets Frame data path Configuration.
Calibration data which application will receive from radarSS and will feed in to the Device in next p...
APLL Synthesizer Bandwidth Control.
rlReturnVal_t rlDriverCmdInvoke(rlUInt8_t deviceMap, rlDriverMsg_t inMsg, rlDriverMsg_t *outMsg)
Invokes a command to mmwave radar Device. Implements mmwave radar Host Communication Protocol(RHCP)
rlReturnVal_t rlSetMultiBpmChirpConfig(rlUInt8_t deviceMap, rlUInt16_t cnt, rlBpmChirpCfg_t **data)
Sets Binary Phase Modulation configuration for multiple Chirp.
rlReturnVal_t rlRfSetDeviceCfg(rlUInt8_t deviceMap, rlRfDevCfg_t *data)
: Set different RadarSS device configurations
Binary phase modulation common configuration.
The DFE Statistics Report Contents.
rlUInt8_t txIndex
Index of the transmitter channel for which the phase shift is desired Valid range: 0 to (Number of ...
Dynamic per chirp phase shifter configuration.
mmwave radar Driver Payload
TX gain temperature LUT inject.
rlUInt16_t startStop
Start/Stop Frame 0x0000 - Stop the transmission of frames after the current frame 0x0001 - Trigge...
rlReturnVal_t rlSetChannelConfig(rlUInt8_t deviceMap, rlChanCfg_t *data)
Sets the Rx and Tx Channel Configuration.
Rx/Tx Channel Configuration.
rlReturnVal_t rlSetBpmChirpConfig(rlUInt8_t deviceMap, rlBpmChirpCfg_t *data)
Sets Binary Phase Modulation Chirp Configuration.
Radar RF PA loopback configuration.
rlReturnVal_t rlSetSubFrameStart(rlUInt8_t deviceMap, rlSubFrameStartCfg_t *data)
Triggers the next sub-frame in software triggered sub-frame mode.
rlReturnVal_t rlSetGpAdcConfig(rlUInt8_t deviceMap, rlGpAdcCfg_t *data)
: Configure GP ADC data parameters
void rlDriverFillPayload(rlUInt16_t msgId, rlUInt16_t sbcID, rlPayloadSb_t *payloadPtr, rlUInt8_t *data, rlUInt16_t inLen)
: Fill payload based on given message-ID, sub-block ID and data.
Binary phase modulation common configuration.
Radar RF Miscconfiguration.
rlUInt16_t reserved
Reserved for Future use.
Inter Chirp block control configuration.
Structure to store all Calibration data chunks which device provides in response of rlRfCalibDataStor...
rlReturnVal_t rlSetDynPerChirpPhShifterCfg(rlUInt8_t deviceMap, rlUInt16_t segCnt, rlDynPerChirpPhShftCfg_t **data)
Injects per-chirp phase shifter configuration to be applied dynamically.
rlAdvFrameDataCfg_t frameData
Advance Frame data configuration. Applicable with AWR1243/2243 device only.
rlReturnVal_t rlSetBpmCommonConfig(rlUInt8_t deviceMap, rlBpmCommonCfg_t *data)
Sets Binary Phase Modulation Common Configuration.
rlUInt16_t reserved
Reserved for Future use.
rlReturnVal_t rlSetDynChirpCfg(rlUInt8_t deviceMap, rlUInt16_t segCnt, rlDynChirpCfg_t **data)
Injects chirp configuration to be programmed dynamically.
Radar RF Run time calibration configuration.
Advance Frame Sequence config API parameters rlAdvFrameCfg, 148 bytes.
Continous Mode Enable API parameters.
Radar RF programmable filter configuration.
Advanced Chirp LUT Configuration Structure Load a generic chirp parameter LUT (firmware RAM of size 1...
Monitor Type Trigger configuration structure.
rlReturnVal_t rlRfSetPALoopbackConfig(rlUInt8_t deviceMap, rlRfPALoopbackCfg_t *data)
Enable/Disable PA loopback for all enabled profiles.
Structure to hold the MSS/radarSS CPU Fault data strucutre for event RL_DEV_AE_MSS_CPUFAULT_SB and RL...
Profile config API parameters. A profile contains coarse parameters of FMCW chirp such as start frequ...
Chirp start, end Index parameters for rlGetChirpConfig.
rlReturnVal_t rlRfSetProgFiltCoeffRam(rlUInt8_t deviceMap, rlRfProgFiltCoeff_t *data)
Set Programmable Filter coefficient RAM.
rlUInt32_t numChirps
Number of Chirps per Frame.
rlReturnVal_t rlGetAdvFrameConfig(rlUInt8_t deviceMap, rlAdvFrameCfg_t *data)
Gets Advance Frame Configuration.
Continous Mode config API parameters.
Loopback burst set configuration.
RX gain temperature LUT read.
rlReturnVal_t rlSetMultiAdvChirpLUTConfig(rlUInt8_t deviceMap, rlAdvChirpLUTCfg_t *AdvChirpLUTCfgArgs, rlInt8_t *AdvChirpLUTData)
Multi Advanced chirp LUT configuration API.
BSS Bootup status data structure.
rlReturnVal_t rlSetAdvChirpLUTConfig(rlUInt8_t deviceMap, rlAdvChirpLUTCfg_t *data)
Set the Advanced chirp LUT configuration to the device.
rlReturnVal_t rlSensorStart(rlUInt8_t deviceMap)
Triggers Transmission of Frames.
rlReturnVal_t rlSetDynChirpEn(rlUInt8_t deviceMap, rlDynChirpEnCfg_t *data)
Triggers copy of chirp config from SW to HW RAM.
rlReturnVal_t rlRfSetProgFiltConfig(rlUInt8_t deviceMap, rlRfProgFiltConf_t *data)
Set Programmable Filter configuration.
rlReturnVal_t rlRfSetIFLoopbackConfig(rlUInt8_t deviceMap, rlRfIFLoopbackCfg_t *data)
Enable/Disable RF IF loopback for all enabled profiles. This is used for debug to check if both TX an...
rlReturnVal_t rlSetMultiChirpCfg(rlUInt8_t deviceMap, rlUInt16_t cnt, rlChirpCfg_t **data)
Injects chirp configuration to be programmed dynamically.
rlReturnVal_t rlSetAdvChirpConfig(rlUInt8_t deviceMap, rlAdvChirpCfg_t *data)
Set the Advanced chirp configuration to the device.
Frame Trigger API parameters RL_RF_FRAMESTARTSTOP_CONF_SB.
rlReturnVal_t rlRfInitCalibConfig(rlUInt8_t deviceMap, rlRfInitCalConf_t *data)
Set RF Init Calibration Mask bits and report type.
rlUInt16_t numAdcSamples
Number of half words in ADC buffer per chirp Example 1: In real mode, if number of ADC samples per ...
rlReturnVal_t rlSetLoopBckBurstCfg(rlUInt8_t deviceMap, rlLoopbackBurst_t *data)
This API is used to introduce loopback chirps within the functional frames.
Inter-Rx gain and phase offset configuration.
rlReturnVal_t rlRfDfeRxStatisticsReport(rlUInt8_t deviceMap, rlDfeStatReport_t *data)
Gets Digital Front end statistics such as Residual DC, RMS power in I and Q chains for different Rece...
rlReturnVal_t rlRfApllSynthBwCtlConfig(rlUInt8_t deviceMap, rlRfApllSynthBwControl_t *data)
Control bandwidth of the APLL and Synthesizer.
rlReturnVal_t rlGetChirpConfig(rlUInt8_t deviceMap, rlUInt16_t chirpStartIdx, rlUInt16_t chirpEndIdx, rlChirpCfg_t *data)
Gets Chirp Configuration.
rlUInt8_t txIndex
Index of the transmitter channel for which the phase shift is desired Valid range: 0 to (Number of ...
rlReturnVal_t rlDriverExecuteSetApi(rlUInt8_t deviceMap, rlUInt16_t msgId, rlUInt16_t sbcID, rlUInt8_t *msgData, rlUInt16_t inLen)
: Construct set message and invoke command.
rlReturnVal_t rlSetChirpConfig(rlUInt8_t deviceMap, rlUInt16_t cnt, rlChirpCfg_t *data)
Sets Chirp Configuration.
rlReturnVal_t rlDriverIsDeviceMapValid(rlUInt8_t deviceMap)
Checks if given deviecMap is valid wrt to global DeviceMap set to mmWaveLink.
rlAdvFrameSeqCfg_t frameSeq
Advance Frame sequence and Subframe configuration.