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> 108 rlReturnVal_t retVal;
114 retVal = RL_RET_CODE_INVALID_INPUT;
120 RL_RF_CHAN_CONF_SB, (rlUInt8_t*)data,
124 RL_LOGV_ARG0(
"rlSetChannelConfig ends...\n");
153 rlReturnVal_t retVal;
155 RL_LOGV_ARG0(
"rlSetAdcOutConfig starts...\n");
159 (RL_NULL_PTR == data))
162 retVal = RL_RET_CODE_INVALID_INPUT;
163 RL_LOGE_ARG0(
"rlSetAdcOutConfig, Invalid device map\n");
169 RL_RF_ADCOUT_CONF_SB, (rlUInt8_t*)data,
173 RL_LOGV_ARG0(
"rlSetAdcOutConfig ends...\n");
198 rlReturnVal_t retVal;
200 RL_LOGV_ARG0(
"rlSetBpmCommonConfig starts...\n");
204 (RL_NULL_PTR == data))
207 retVal = RL_RET_CODE_INVALID_INPUT;
208 RL_LOGE_ARG0(
"rlSetBpmCommonConfig, Invalid device map\n");
214 RL_RF_BPM_COMMON_CONF_SB, (rlUInt8_t*)data,
217 RL_LOGV_ARG0(
"rlSetBpmCommonConfig ends...\n");
239 rlReturnVal_t retVal;
241 RL_LOGV_ARG0(
"rlSetBpmChirpConfig starts...\n");
245 (RL_NULL_PTR == data))
248 retVal = RL_RET_CODE_INVALID_INPUT;
249 RL_LOGE_ARG0(
"rlSetBpmChirpConfig, Invalid device map\n");
255 RL_RF_BPM_CHIRP_CONF_SB, (rlUInt8_t*)data,
259 RL_LOGV_ARG0(
"rlSetBpmChirpConfig ends...\n");
283 rlReturnVal_t retVal;
284 RL_LOGV_ARG0(
"rlSetMultiBpmChirpConfig starts...\n");
291 retVal = RL_RET_CODE_INVALID_INPUT;
300 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
305 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
308 sbLen = (rlUInt16_t)(
sizeof(
rlBpmChirpCfg_t) + (RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE));
313 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
315 retVal = RL_RET_CODE_OK;
317 if (cnt <= maxSbCntInMsg)
325 sbCntInMsg = maxSbCntInMsg;
326 numChnkOfMsg = cnt / maxSbCntInMsg;
327 lastSbCntInMsg = cnt % maxSbCntInMsg;
333 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
335 while (retVal == RL_RET_CODE_OK)
338 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
340 inMsg.opcode.
nsbc = lastSbCntInMsg;
344 inMsg.opcode.
nsbc = sbCntInMsg;
347 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
353 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_ADVANCED_FEATURES_SET_MSG,
354 RL_RF_BPM_CHIRP_CONF_SB);
362 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(*data);
379 RL_LOGV_ARG0(
"rlSetMultiBpmChirpConfig ends...\n");
432 rlReturnVal_t retVal;
434 RL_LOGV_ARG0(
"rlSetProfileConfig starts...\n");
438 (RL_NULL_PTR == data) || (cnt == 0U))
441 retVal = RL_RET_CODE_INVALID_INPUT;
442 RL_LOGE_ARG0(
"rlSetProfileConfig, Invalid device map\n");
451 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
454 rlUInt16_t sbCntInAllChunk = 0U;
455 rlUInt16_t maxSbInMsg = (RL_CMD_PL_LEN_MAX /(
sizeof(
rlProfileCfg_t) + \
456 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE));
461 retVal = RL_RET_CODE_OK;
463 for (indx = 0U; (indx < cnt) && (retVal == RL_RET_CODE_OK); indx++)
473 &inPayloadSb[indx], (rlUInt8_t*)(data + indx),
480 if ((maxSbInMsg == (indx + 1U)) || (cnt == sbCntInAllChunk))
483 inMsg.opcode.
nsbc = (indx + 1U);
490 RL_LOGV_ARG0(
"rlSetProfileConfig ends...\n");
517 rlReturnVal_t retVal;
519 RL_LOGV_ARG0(
"rlGetProfileConfig ends...\n");
523 (RL_NULL_PTR == data))
526 retVal = RL_RET_CODE_INVALID_INPUT;
527 RL_LOGE_ARG0(
"rlGetProfileConfig, Invalid device map\n");
538 wordParam.halfWordOne = profileId;
539 wordParam.halfWordTwo = 0U;
556 RL_LOGV_ARG0(
"rlGetProfileConfig ends...\n");
591 rlReturnVal_t retVal;
593 RL_LOGV_ARG0(
"rlSetChirpConfig starts...\n");
597 (RL_NULL_PTR == data) || (cnt == 0U))
600 retVal = RL_RET_CODE_INVALID_INPUT;
608 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
612 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
615 sbLen = (rlUInt16_t)(
sizeof(
rlChirpCfg_t) + (RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE));
620 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
622 retVal = RL_RET_CODE_OK;
624 if (cnt <= maxSbCntInMsg)
632 sbCntInMsg = maxSbCntInMsg;
633 numChnkOfMsg = cnt / maxSbCntInMsg;
634 lastSbCntInMsg = cnt % maxSbCntInMsg;
640 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
642 while (retVal == RL_RET_CODE_OK)
645 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
647 inMsg.opcode.
nsbc = lastSbCntInMsg;
651 inMsg.opcode.
nsbc = sbCntInMsg;
654 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
660 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_SET_MSG,
661 RL_RF_CHIRP_CONF_SB);
665 inPayloadSb[indx].len = (rlUInt16_t)
sizeof(
rlChirpCfg_t);
669 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(data);
690 RL_LOGV_ARG0(
"rlSetChirpConfig ends...\n");
716 rlReturnVal_t retVal;
719 RL_LOGV_ARG0(
"rlGetChirpConfig starts...\n");
723 (RL_NULL_PTR == chirpCfgData))
726 retVal = RL_RET_CODE_INVALID_INPUT;
727 RL_LOGE_ARG0(
"rlGetChirpConfig, Invalid device map\n");
735 rlUInt16_t sbLen, maxSbCntOutMsg, sbCntOutMsg, numChnkOfMsg, lastSbCntOutMsg, loopCnt;
749 maxSbCntOutMsg = (RL_CMD_PL_LEN_MAX -(RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE)) /sbLen;
751 retVal = RL_RET_CODE_OK;
753 if ((chirpEndIdx - chirpStartIdx + 1U) <= maxSbCntOutMsg)
755 sbCntOutMsg = (chirpEndIdx - chirpStartIdx + 1U);
757 lastSbCntOutMsg = 0U;
761 sbCntOutMsg = maxSbCntOutMsg;
762 numChnkOfMsg = (chirpEndIdx - chirpStartIdx + 1U) / maxSbCntOutMsg;
763 lastSbCntOutMsg = (chirpEndIdx - chirpStartIdx + 1U) % maxSbCntOutMsg;
768 wordParam.halfWordTwo = chirpStartIdx;
771 loopCnt = numChnkOfMsg + 1U;
773 outMsg.opcode.
nsbc = 1U;
775 while (retVal == RL_RET_CODE_OK)
778 wordParam.halfWordOne = wordParam.halfWordTwo;
780 if ((loopCnt == 1U) && (lastSbCntOutMsg != 0U))
782 wordParam.halfWordTwo = wordParam.halfWordOne + (lastSbCntOutMsg - 1U);
786 wordParam.halfWordTwo = wordParam.halfWordOne + (sbCntOutMsg - 1U);
796 outPayloadSb.sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_GET_MSG,
797 RL_RF_CHIRP_CONF_SB);
799 outPayloadSb.pSblkData = (rlUInt8_t*)(chirpCfgData);
808 chirpCfgData += sbCntOutMsg;
812 wordParam.halfWordTwo++;
821 RL_LOGV_ARG0(
"rlGetChirpConfig ends...\n");
854 rlReturnVal_t retVal;
855 RL_LOGV_ARG0(
"rlSetMultiChirpCfg starts...\n");
862 retVal = RL_RET_CODE_INVALID_INPUT;
871 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
876 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
879 sbLen = (rlUInt16_t)(
sizeof(
rlChirpCfg_t) + (RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE));
885 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
887 retVal = RL_RET_CODE_OK;
889 if (cnt <= maxSbCntInMsg)
897 sbCntInMsg = maxSbCntInMsg;
898 numChnkOfMsg = cnt / maxSbCntInMsg;
899 lastSbCntInMsg = cnt % maxSbCntInMsg;
905 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
907 while (retVal == RL_RET_CODE_OK)
910 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
912 inMsg.opcode.
nsbc = lastSbCntInMsg;
916 inMsg.opcode.
nsbc = sbCntInMsg;
919 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
925 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_SET_MSG,
926 RL_RF_CHIRP_CONF_SB);
930 inPayloadSb[indx].len = (rlUInt16_t)
sizeof(
rlChirpCfg_t);
934 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(*data);
951 RL_LOGV_ARG0(
"rlSetMultiChirpCfg ends...\n");
1009 rlReturnVal_t retVal;
1011 RL_LOGV_ARG0(
"rlSetFrameConfig starts...\n");
1015 (RL_NULL_PTR == data))
1018 retVal = RL_RET_CODE_INVALID_INPUT;
1019 RL_LOGE_ARG0(
"rlSetFrameConfig, Invalid device map\n");
1025 RL_RF_FRAME_CONF_SB, (rlUInt8_t*)data,
1037 tempVar = (rlUInt32_t)(((data->chirpEndIdx - data->chirpStartIdx) + 1U) *
1039 #ifndef MMWL_BIG_ENDIAN 1042 frameApplyCfgArgs.
numChirps = RL_SWAP_32(tempVar);
1048 RL_LOGV_ARG0(
"rlSetFrameConfig ends...\n");
1069 rlReturnVal_t retVal;
1071 RL_LOGV_ARG0(
"rlGetFrameConfig starts...\n");
1075 (RL_NULL_PTR == data))
1078 retVal = RL_RET_CODE_INVALID_INPUT;
1079 RL_LOGE_ARG0(
"rlGetFrameConfig, Invalid device map\n");
1085 RL_RF_FRAME_CONF_SB, (rlUInt8_t*)data, 0U);
1103 &inPayloadSb, (rlUInt8_t*)RL_NULL_PTR, 0x0U);
1109 (rlUInt8_t*)&frameApplyCfgArgs, 0U);
1113 #ifndef MMWL_BIG_ENDIAN 1116 data->numAdcSamples = frameApplyCfgArgs.numAdcSamples;
1119 data->numAdcSamples = RL_SWAP_32(frameApplyCfgArgs.numAdcSamples);
1124 RL_LOGV_ARG0(
"rlGetFrameConfig ends...\n");
1180 rlReturnVal_t retVal;
1182 RL_LOGV_ARG0(
"rlSetAdvFrameConfig starts...\n");
1188 retVal = RL_RET_CODE_INVALID_INPUT;
1189 RL_LOGE_ARG0(
"rlSetAdvFrameConfig, Invalid device map\n");
1195 RL_RF_FRAME_CONF_ADVANCED_SB,
1206 RL_LOGV_ARG0(
"rlSetAdvFrameConfig ends...\n");
1227 rlReturnVal_t retVal;
1229 RL_LOGV_ARG0(
"rlGetAdvFrameConfig starts...\n");
1233 (RL_NULL_PTR == data))
1236 retVal = RL_RET_CODE_INVALID_INPUT;
1237 RL_LOGE_ARG0(
"rlGetAdvFrameConfig, Invalid device map\n");
1243 RL_RF_FRAME_CONF_ADVANCED_SB,
1244 (rlUInt8_t*)(&(data->
frameSeq)), 0U);
1261 RL_SYS_ADV_FRAME_CONFIG_GET_SB,
1262 &inPayloadSb, (rlUInt8_t*)RL_NULL_PTR, 0U);
1275 RL_LOGV_ARG0(
"rlGetAdvFrameConfig ends...\n");
1299 rlReturnVal_t retVal;
1301 RL_LOGV_ARG0(
"rlSetContModeConfig starts...\n");
1305 (RL_NULL_PTR == data))
1308 retVal = RL_RET_CODE_INVALID_INPUT;
1309 RL_LOGE_ARG0(
"rlSetContModeConfig, Invalid device map\n");
1315 RL_RF_CONT_STREAMING_MODE_CONF_SB,
1319 RL_LOGV_ARG0(
"rlSetContModeConfig ends...\n");
1338 rlReturnVal_t retVal;
1340 RL_LOGV_ARG0(
"rlEnableContMode starts...\n");
1344 (RL_NULL_PTR == data))
1347 retVal = RL_RET_CODE_INVALID_INPUT;
1348 RL_LOGE_ARG0(
"rlEnableContMode, Invalid device map\n");
1354 RL_RF_CONT_STREAMING_MODE_EN_SB,
1359 RL_LOGV_ARG0(
"rlEnableContMode starts...\n");
1382 rlReturnVal_t retVal;
1384 RL_LOGV_ARG0(
"rlSetLowPowerModeConfig starts...\n");
1390 retVal = RL_RET_CODE_INVALID_INPUT;
1391 RL_LOGE_ARG0(
"rlSetLowPowerModeConfig, Invalid device map\n");
1397 RL_RF_LOWPOWERMODE_CONF_SB,
1402 RL_LOGV_ARG0(
"rlSetLowPowerModeConfig ends...\n");
1426 rlReturnVal_t retVal;
1430 RL_LOGV_ARG0(
"rlSensorStart starts...\n");
1432 frameTriggerArgs.
startStop = RL_FRAME_TRIGGER_START;
1439 retVal = RL_RET_CODE_INVALID_INPUT;
1440 RL_LOGE_ARG0(
"rlSensorStart, Invalid device map\n");
1446 RL_RF_FRAMESTARTSTOP_CONF_SB,
1447 (rlUInt8_t*)(&frameTriggerArgs),
1450 RL_LOGV_ARG0(
"rlSensorStart ends...\n");
1479 rlReturnVal_t retVal;
1483 frameTriggerArgs.
startStop = RL_FRAME_TRIGGER_STOP;
1486 RL_LOGV_ARG0(
"rlSensorStop starts...\n");
1492 retVal = RL_RET_CODE_INVALID_INPUT;
1493 RL_LOGE_ARG0(
"rlSensorStop, Invalid device map\n");
1499 RL_RF_FRAMESTARTSTOP_CONF_SB,
1500 (rlUInt8_t*)(&frameTriggerArgs),
1503 RL_LOGV_ARG0(
"rlSensorStop ends...\n");
1538 rlReturnVal_t retVal;
1540 RL_LOGV_ARG0(
"rlFrameStartStop starts...\n");
1546 retVal = RL_RET_CODE_INVALID_INPUT;
1547 RL_LOGE_ARG0(
"rlFrameStartStop, Invalid device map\n");
1553 RL_RF_FRAMESTARTSTOP_CONF_SB,
1557 RL_LOGV_ARG0(
"rlFrameStartStop ends...\n");
1594 rlReturnVal_t retVal;
1596 RL_LOGV_ARG0(
"rlRfInit starts...\n");
1602 retVal = RL_RET_CODE_INVALID_INPUT;
1603 RL_LOGE_ARG0(
"rlRfInit, Invalid device map\n");
1610 RL_LOGV_ARG0(
"rlRfInit ends...\n");
1639 rlReturnVal_t retVal;
1641 RL_LOGV_ARG0(
"rlSetTestSourceConfig starts...\n");
1645 (RL_NULL_PTR == data))
1648 retVal = RL_RET_CODE_INVALID_INPUT;
1649 RL_LOGE_ARG0(
"rlSetTestSourceConfig, Invalid device map\n");
1655 RL_RF_TEST_SOURCE_CONFIG_SET_SB,
1659 RL_LOGV_ARG0(
"rlSetTestSourceConfig ends...\n");
1678 rlReturnVal_t retVal;
1680 RL_LOGV_ARG0(
"rlTestSourceEnable starts...\n");
1684 (RL_NULL_PTR == data))
1687 retVal = RL_RET_CODE_INVALID_INPUT;
1688 RL_LOGE_ARG0(
"rlTestSourceEnable, Invalid device map\n");
1694 RL_RF_TEST_SOURCE_ENABLE_SET_SB,
1698 RL_LOGV_ARG0(
"rlTestSourceEnable ends...\n");
1717 rlReturnVal_t retVal;
1719 RL_LOGV_ARG0(
"rlRfGetTemperatureReport starts...\n");
1723 (RL_NULL_PTR == data))
1726 retVal = RL_RET_CODE_INVALID_INPUT;
1727 RL_LOGE_ARG0(
"rlRfGetTemperatureReport, Invalid device map\n");
1733 RL_RF_CHAR_CONF_DYNAMIC_GET_SB,
1736 RL_LOGV_ARG0(
"rlRfGetTemperatureReport ends...\n");
1758 rlReturnVal_t retVal;
1760 RL_LOGV_ARG0(
"rlRfDfeRxdStatisticsReport starts...\n");
1764 (RL_NULL_PTR == data))
1767 retVal = RL_RET_CODE_INVALID_INPUT;
1768 RL_LOGE_ARG0(
"Invalid input\n");
1774 RL_RF_DFE_STATISTICS_REPORT_GET_SB,
1775 (rlUInt8_t*)data, 0U);
1777 RL_LOGV_ARG0(
"rlRfDfeRxdStatisticsReport completes...\n");
1806 rlReturnVal_t retVal;
1808 RL_LOGV_ARG0(
"rlRfDynamicPowerSave starts...\n");
1812 (RL_NULL_PTR == data))
1815 retVal = RL_RET_CODE_INVALID_INPUT;
1816 RL_LOGE_ARG0(
"Invalid input\n");
1822 RL_RF_DYNAMICPOWERSAVE_CONF_SB,
1826 RL_LOGV_ARG0(
"rlRfDynamicPowerSave completes...\n");
1855 rlReturnVal_t retVal;
1857 RL_LOGV_ARG0(
"rlRfSetDeviceCfg starts...\n");
1861 (RL_NULL_PTR == data))
1864 retVal = RL_RET_CODE_INVALID_INPUT;
1865 RL_LOGE_ARG0(
"Invalid input\n");
1871 RL_RF_DEVICE_CFG_SB,
1875 RL_LOGV_ARG0(
"rlRfSetDeviceCfg completes...\n");
1900 rlReturnVal_t retVal;
1902 RL_LOGV_ARG0(
"rlSetGpAdcConfig starts...\n");
1906 (RL_NULL_PTR == data))
1909 retVal = RL_RET_CODE_INVALID_INPUT;
1910 RL_LOGE_ARG0(
"Invalid input\n");
1916 RL_RF_GPADC_CONF_SET_SB,
1920 RL_LOGV_ARG0(
"rlSetGpAdcConfig completes...\n");
1944 rlReturnVal_t retVal;
1946 RL_LOGV_ARG0(
"rlRfSetLdoBypassConfig starts...\n");
1952 retVal = RL_RET_CODE_INVALID_INPUT;
1958 RL_RF_LDOBYPASS_SET_SB,
1963 RL_LOGV_ARG0(
"rlRfSetLdoBypassConfig completes...\n");
1995 rlReturnVal_t retVal;
1997 RL_LOGV_ARG0(
"rlRfSetPhaseShiftConfig starts...\n");
2001 (RL_NULL_PTR == data) || (cnt == 0U))
2004 retVal = RL_RET_CODE_INVALID_INPUT;
2012 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
2016 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
2024 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
2026 retVal = RL_RET_CODE_OK;
2028 if (cnt <= maxSbCntInMsg)
2032 lastSbCntInMsg = 0U;
2036 sbCntInMsg = maxSbCntInMsg;
2037 numChnkOfMsg = cnt / maxSbCntInMsg;
2038 lastSbCntInMsg = cnt % maxSbCntInMsg;
2044 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
2046 while (retVal == RL_RET_CODE_OK)
2049 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
2051 inMsg.opcode.
nsbc = lastSbCntInMsg;
2055 inMsg.opcode.
nsbc = sbCntInMsg;
2058 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
2064 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_SET_MSG,
2065 RL_RF_PERCHIRPPHASESHIFT_CONF_SB);
2073 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(data);
2094 RL_LOGV_ARG0(
"rlRfSetPhaseShiftConfig ends...\n");
2117 rlReturnVal_t retVal;
2119 RL_LOGV_ARG0(
"rlRfSetPALoopbackConfig starts...\n");
2125 retVal = RL_RET_CODE_INVALID_INPUT;
2131 RL_RF_PALOOPBACK_CFG_SET_SB,
2136 RL_LOGV_ARG0(
"rlRfSetPALoopbackConfig completes...\n");
2158 rlReturnVal_t retVal;
2160 RL_LOGV_ARG0(
"rlRfSetPSLoopbackConfig starts...\n");
2166 retVal = RL_RET_CODE_INVALID_INPUT;
2172 RL_RF_PSLOOPBACK_CFG_SET_SB,
2177 RL_LOGV_ARG0(
"rlRfSetPSLoopbackConfig completes...\n");
2200 rlReturnVal_t retVal;
2202 RL_LOGV_ARG0(
"rlRfSetIFLoopbackConfig starts...\n");
2208 retVal = RL_RET_CODE_INVALID_INPUT;
2214 RL_RF_IFLOOPBACK_CFG_SET_SB,
2219 RL_LOGV_ARG0(
"rlRfSetIFLoopbackConfig completes...\n");
2248 rlReturnVal_t retVal;
2250 RL_LOGV_ARG0(
"rlRfSetProgFiltCoeffRam starts...\n");
2256 retVal = RL_RET_CODE_INVALID_INPUT;
2262 RL_RF_PROG_FILT_COEFF_RAM_SET_SB,
2267 RL_LOGV_ARG0(
"rlRfSetProgFiltCoeffRam completes...\n");
2290 rlReturnVal_t retVal;
2292 RL_LOGV_ARG0(
"rlRfSetProgFiltConfig starts...\n");
2298 retVal = RL_RET_CODE_INVALID_INPUT;
2304 RL_RF_PROG_FILT_CONF_SET_SB,
2309 RL_LOGV_ARG0(
"rlRfSetProgFiltConfig completes...\n");
2332 rlReturnVal_t retVal;
2334 RL_LOGV_ARG0(
"rlRfSetMiscConfig starts...\n");
2340 retVal = RL_RET_CODE_INVALID_INPUT;
2346 RL_RF_RADAR_MISC_CTL_SB,
2351 RL_LOGV_ARG0(
"rlRfSetMiscConfig completes...\n");
2380 rlReturnVal_t retVal;
2382 RL_LOGV_ARG0(
"rlRfSetCalMonTimeUnitConfig starts...\n");
2388 retVal = RL_RET_CODE_INVALID_INPUT;
2394 RL_RF_CALIB_MON_TIME_UNIT_SB,
2399 RL_LOGV_ARG0(
"rlRfSetCalMonTimeUnitConfig completes...\n");
2430 rlReturnVal_t retVal;
2432 RL_LOGV_ARG0(
"rlRfSetCalMonFreqLimitConfig starts...\n");
2438 retVal = RL_RET_CODE_INVALID_INPUT;
2444 RL_RF_CAL_MON_FREQ_LIMIT_SB,
2449 RL_LOGV_ARG0(
"rlRfSetCalMonFreqLimitConfig completes...\n");
2476 rlReturnVal_t retVal;
2478 RL_LOGV_ARG0(
"rlRfInitCalibConfig starts...\n");
2484 retVal = RL_RET_CODE_INVALID_INPUT;
2490 RL_RF_INIT_CALIB_CONF_SB,
2495 RL_LOGV_ARG0(
"rlRfInitCalibConfig completes...\n");
2520 rlReturnVal_t retVal;
2522 RL_LOGV_ARG0(
"rlRfRunTimeCalibConfig starts...\n");
2528 retVal = RL_RET_CODE_INVALID_INPUT;
2534 RL_RF_RUN_TIME_CALIB_CONF_TRIG_SB,
2539 RL_LOGV_ARG0(
"rlRfRunTimeCalibConfig completes...\n");
2560 rlReturnVal_t retVal;
2566 retVal = RL_RET_CODE_INVALID_INPUT;
2572 RL_RF_RX_GAIN_TEMPLUT_CONF_SB, (rlUInt8_t*)data,
2596 rlReturnVal_t retVal;
2598 RL_LOGV_ARG0(
"rlRxGainTempLutRead starts...\n");
2602 (RL_NULL_PTR == inData))
2605 retVal = RL_RET_CODE_INVALID_INPUT;
2606 RL_LOGE_ARG0(
"rlRxGainTempLutRead, Invalid device map\n");
2620 &inPayloadSb, (rlUInt8_t *)inData,
2636 RL_LOGV_ARG0(
"rlRxGainTempLutRead ends...\n");
2656 rlReturnVal_t retVal;
2662 retVal = RL_RET_CODE_INVALID_INPUT;
2668 RL_RF_TX_GAIN_TEMPLUT_CONF_SB, (rlUInt8_t*)data,
2689 rlReturnVal_t rlTxGainTempLutGet(rlUInt8_t deviceMap,
2692 rlReturnVal_t retVal;
2694 RL_LOGV_ARG0(
"rlTxGainTempLutRead starts...\n");
2698 (RL_NULL_PTR == inData))
2701 retVal = RL_RET_CODE_INVALID_INPUT;
2702 RL_LOGE_ARG0(
"rlTxGainTempLutRead, Invalid device map\n");
2716 &inPayloadSb, (rlUInt8_t *)inData,
2732 RL_LOGV_ARG0(
"rlTxGainTempLutRead ends...\n");
2761 rlReturnVal_t retVal;
2765 (RL_NULL_PTR == data))
2768 retVal = RL_RET_CODE_INVALID_INPUT;
2774 RL_RF_TX_FREQ_PWR_LIMIT_SB,
2808 rlReturnVal_t retVal;
2814 retVal = RL_RET_CODE_INVALID_INPUT;
2820 RL_RF_LB_BURST_CFG_SET_SB, (rlUInt8_t*)data,
2848 rlReturnVal_t retVal;
2855 retVal = RL_RET_CODE_INVALID_INPUT;
2864 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
2869 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
2872 sbLen = (rlUInt16_t)(
sizeof(
rlDynChirpCfg_t) + (RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE));
2878 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
2880 retVal = RL_RET_CODE_OK;
2882 if (segCnt <= maxSbCntInMsg)
2884 sbCntInMsg = segCnt;
2886 lastSbCntInMsg = 0U;
2890 sbCntInMsg = maxSbCntInMsg;
2891 numChnkOfMsg = segCnt / maxSbCntInMsg;
2892 lastSbCntInMsg = segCnt % maxSbCntInMsg;
2898 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
2900 while (retVal == RL_RET_CODE_OK)
2903 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
2905 inMsg.opcode.
nsbc = lastSbCntInMsg;
2909 inMsg.opcode.
nsbc = sbCntInMsg;
2912 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
2918 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_SET_MSG,
2919 RL_RF_DYN_CHIRP_CFG_SET_SB);
2927 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(*data);
2970 rlReturnVal_t retVal;
2976 retVal = RL_RET_CODE_INVALID_INPUT;
2982 RL_RF_DYN_CHIRP_CFG_EN_SB, (rlUInt8_t*)data,
3019 rlReturnVal_t retVal;
3026 retVal = RL_RET_CODE_INVALID_INPUT;
3035 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
3039 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
3043 (RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE));
3048 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
3050 retVal = RL_RET_CODE_OK;
3052 if (segCnt <= maxSbCntInMsg)
3054 sbCntInMsg = segCnt;
3056 lastSbCntInMsg = 0U;
3060 sbCntInMsg = maxSbCntInMsg;
3061 numChnkOfMsg = segCnt / maxSbCntInMsg;
3062 lastSbCntInMsg = segCnt % maxSbCntInMsg;
3068 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
3070 while (retVal == RL_RET_CODE_OK)
3073 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
3075 inMsg.opcode.
nsbc = lastSbCntInMsg;
3079 inMsg.opcode.
nsbc = sbCntInMsg;
3082 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
3088 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_SET_MSG,
3089 RL_RF_DYN_PERCHIRP_PHSHFT_CFG_SET_SB);
3097 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(*data);
3145 rlReturnVal_t retVal;
3152 retVal = RL_RET_CODE_INVALID_INPUT;
3162 retVal = RL_RET_CODE_OK;
3164 for (idx = 0U; idx < RL_MAX_CALIB_DATA_CHUNK; idx++)
3176 (rlUInt8_t*)(&data->calibChunk[idx]),
3187 if (RL_RET_CODE_OK != retVal)
3226 rlReturnVal_t retVal;
3232 retVal = RL_RET_CODE_INVALID_INPUT;
3244 retVal = RL_RET_CODE_OK;
3246 for (idx = 0U; idx < RL_MAX_CALIB_DATA_CHUNK; idx++)
3268 if (RL_RET_CODE_OK != retVal)
3274 caldataGetCfg.chunkId++;
3308 rlReturnVal_t retVal;
3314 retVal = RL_RET_CODE_INVALID_INPUT;
3320 RL_RF_DIG_COMP_EST_CTRL_SB, (rlUInt8_t*)data,
3340 rlReturnVal_t retVal;
3343 if (data == RL_NULL_PTR)
3346 retVal = RL_RET_CODE_NULL_PTR;
3352 RL_RF_BOOTUP_BIST_STATUS_SB, (rlUInt8_t*)data, 0U);
3383 rlReturnVal_t retVal;
3389 retVal = RL_RET_CODE_INVALID_INPUT;
3395 RL_RF_INTERCHIRP_BLOCK_CTRL_SB, (rlUInt8_t*)data,
3434 rlReturnVal_t retVal;
3440 retVal = RL_RET_CODE_INVALID_INPUT;
3446 RL_RF_SUBFRAME_START_SB, (rlUInt8_t*)data,
3471 rlReturnVal_t retVal;
3478 retVal = RL_RET_CODE_INVALID_INPUT;
3488 retVal = RL_RET_CODE_OK;
3490 for (idx = 0U; idx < RL_TX_CNT; idx++)
3494 if (idx == (RL_TX_CNT - 1U))
3496 data->PhShiftcalibChunk[idx].
calibApply = 1U;
3506 &inPayloadSb, (rlUInt8_t*)(&data->PhShiftcalibChunk[idx]),
3517 if (RL_RET_CODE_OK != retVal)
3546 rlReturnVal_t retVal;
3552 retVal = RL_RET_CODE_INVALID_INPUT;
3566 retVal = RL_RET_CODE_OK;
3568 for (idx = 0U; idx < RL_TX_CNT; idx++)
3570 if ((RL_NULL_PTR != &data->PhShiftcalibChunk[idx]))
3572 phShifterCaldataGetCfg.
txIndex = data->PhShiftcalibChunk[idx].
txIndex;
3577 &inPayloadSb, (rlUInt8_t*)&phShifterCaldataGetCfg,
3590 (rlUInt8_t*)(&data->PhShiftcalibChunk[idx]), 0U);
3595 if (RL_RET_CODE_OK != retVal)
3620 rlReturnVal_t retVal;
3623 if (data == RL_NULL_PTR)
3626 retVal = RL_RET_CODE_NULL_PTR;
3632 RL_RF_DIEID_STATUS_SB, (rlUInt8_t*)data, 0U);
3652 rlReturnVal_t retVal;
3654 RL_LOGV_ARG0(
"rlRfGetCpuFault starts...\n");
3658 (RL_NULL_PTR == data))
3661 retVal = RL_RET_CODE_INVALID_INPUT;
3662 RL_LOGE_ARG0(
"Invalid input");
3668 RL_RF_RFCPUFAULT_STATUS_SB, (rlUInt8_t*)data,
3671 RL_LOGV_ARG0(
"rlRfGetCpuFault ends...\n");
3690 rlReturnVal_t retVal;
3692 RL_LOGV_ARG0(
"rlRfGetEsmFault starts...\n");
3696 (RL_NULL_PTR == data))
3699 retVal = RL_RET_CODE_INVALID_INPUT;
3700 RL_LOGE_ARG0(
"Invalid input");
3706 RL_RF_RFESMFAULT_STATUS_SB, (rlUInt8_t*)data,
3709 RL_LOGV_ARG0(
"rlRfGetEsmFault ends...\n");
3796 rlReturnVal_t retVal;
3798 RL_LOGV_ARG0(
"rlSetAdvChirpConfig starts...\n");
3804 retVal = RL_RET_CODE_INVALID_INPUT;
3805 RL_LOGE_ARG0(
"rlSetAdvChirpConfig, Invalid device map\n");
3811 RL_RF_ADV_CHIRP_CFG_SET_SB,
3816 RL_LOGV_ARG0(
"rlSetAdvChirpConfig ends...\n");
3866 rlReturnVal_t retVal;
3868 RL_LOGV_ARG0(
"rlMonTypeTrigConfig starts...\n");
3874 retVal = RL_RET_CODE_INVALID_INPUT;
3875 RL_LOGE_ARG0(
"rlMonTypeTrigConfig, Invalid device map\n");
3881 RL_RF_MONITOR_TYPE_TRIG_CONF_SB,
3886 RL_LOGV_ARG0(
"rlMonTypeTrigConfig ends...\n");
3910 rlReturnVal_t retVal;
3914 (RL_NULL_PTR == data))
3917 retVal = RL_RET_CODE_INVALID_INPUT;
3923 RL_RF_APLL_SYNTH_BW_CTL_SB,
3963 rlReturnVal_t retVal;
3965 RL_LOGV_ARG0(
"rlSetAdvChirpLUTConfig starts...\n");
3971 retVal = RL_RET_CODE_INVALID_INPUT;
3972 RL_LOGE_ARG0(
"rlSetAdvChirpLUTConfig, Invalid device map\n");
3978 RL_RF_ADV_CHIRP_CFG_LUT_SET_SB,
3983 RL_LOGV_ARG0(
"rlSetAdvChirpLUTConfig ends...\n");
4012 rlInt8_t* AdvChirpLUTData)
4014 rlReturnVal_t retVal = RL_RET_CODE_OK;
4018 rlUInt16_t chunkCount = 0U, totalChunkCount, lastChunkSize;
4020 RL_LOGV_ARG0(
"rlSetMultiAdvChirpLUTConfig starts...\n");
4024 (RL_NULL_PTR == AdvChirpLUTCfgArgs) || (RL_NULL_PTR == AdvChirpLUTData))
4027 retVal += RL_RET_CODE_INVALID_INPUT;
4028 RL_LOGE_ARG0(
"rlSetMultiAdvChirpLUTConfig, Invalid input params\n");
4032 RL_LOGV_ARG2(
"rlSetMultiAdvChirpLUTConfig with \nlutAddOffset[%d]\nnumBytes[%d] \n\n",\
4037 if (AdvChirpLUTCfgArgs->
numBytes > RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE)
4040 if ((AdvChirpLUTCfgArgs->
numBytes % RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE) == 0U)
4042 lastChunkSize = RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE;
4044 (rlUInt16_t)(AdvChirpLUTCfgArgs->
numBytes / RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE);
4050 (rlUInt16_t)((AdvChirpLUTCfgArgs->
numBytes/RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE) + 1U);
4052 (rlUInt16_t)(AdvChirpLUTCfgArgs->
numBytes % RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE);
4059 totalChunkCount = 1U;
4061 lastChunkSize = AdvChirpLUTCfgArgs->
numBytes;
4064 while (chunkCount < totalChunkCount)
4066 RL_LOGV_ARG1(
"Sending Advanced Chirp LUT data Chunk [%d]... \n\n", chunkCount);
4070 (chunkCount * RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE));
4073 if (chunkCount == (totalChunkCount - 1U))
4075 AdvChirpLUTCfgChunk.
numBytes = lastChunkSize;
4080 AdvChirpLUTCfgChunk.
numBytes = RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE;
4083 if (AdvChirpLUTCfgChunk.
numBytes > 0U)
4088 (void)memcpy(&AdvChirpLUTCfgChunk.
calData[0U], \
4092 RL_LOGV_ARG2(
"rlSetAdvChirpLUTConfig with \nlutAddOffset[%d]\nnumBytes[%d] \n\n",\
4097 if (retVal != RL_RET_CODE_OK)
4099 RL_LOGV_ARG2(
"Advanced Chirp LUT data Chunk [%d] failed with error code %d",\
4100 chunkCount, retVal);
4107 retVal += RL_RET_CODE_INVALID_INPUT;
4108 RL_LOGV_ARG2(
"Invalid input, Chirp LUT Chunk [%d] is programmed with %d bytes",\
4109 chunkCount, AdvChirpLUTCfgChunk.
numBytes);
4116 RL_LOGV_ARG0(
"rlSetMultiAdvChirpLUTConfig ends...\n");
4142 rlReturnVal_t retVal;
4144 RL_LOGV_ARG0(
"rlSetAdvChirpDynLUTAddrOffConfig starts...\n");
4150 retVal = RL_RET_CODE_INVALID_INPUT;
4151 RL_LOGE_ARG0(
"rlSetAdvChirpDynLUTAddrOffConfig, Invalid device map\n");
4157 RL_RF_ADV_CHIRP_DYN_LUT_ADD_OFF_CONF_SB,
4162 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.