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");
444 rlReturnVal_t retVal;
446 RL_LOGV_ARG0(
"rlSetProfileConfig starts...\n");
450 (RL_NULL_PTR == data) || (cnt == 0U))
453 retVal = RL_RET_CODE_INVALID_INPUT;
454 RL_LOGE_ARG0(
"rlSetProfileConfig, Invalid device map\n");
463 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
466 rlUInt16_t sbCntInAllChunk = 0U;
467 rlUInt16_t maxSbInMsg = (RL_CMD_PL_LEN_MAX /(
sizeof(
rlProfileCfg_t) + \
468 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE));
473 retVal = RL_RET_CODE_OK;
475 for (indx = 0U; (indx < cnt) && (retVal == RL_RET_CODE_OK); indx++)
485 &inPayloadSb[indx], (rlUInt8_t*)(data + indx),
492 if ((maxSbInMsg == (indx + 1U)) || (cnt == sbCntInAllChunk))
495 inMsg.opcode.
nsbc = (indx + 1U);
502 RL_LOGV_ARG0(
"rlSetProfileConfig ends...\n");
530 rlReturnVal_t retVal;
532 RL_LOGV_ARG0(
"rlGetProfileConfig ends...\n");
536 (RL_NULL_PTR == data))
539 retVal = RL_RET_CODE_INVALID_INPUT;
540 RL_LOGE_ARG0(
"rlGetProfileConfig, Invalid device map\n");
551 wordParam.halfWordOne = profileId;
552 wordParam.halfWordTwo = 0U;
569 RL_LOGV_ARG0(
"rlGetProfileConfig ends...\n");
605 rlReturnVal_t retVal;
607 RL_LOGV_ARG0(
"rlSetChirpConfig starts...\n");
611 (RL_NULL_PTR == data) || (cnt == 0U))
614 retVal = RL_RET_CODE_INVALID_INPUT;
622 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
626 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
629 sbLen = (rlUInt16_t)(
sizeof(
rlChirpCfg_t) + (RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE));
634 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
636 retVal = RL_RET_CODE_OK;
638 if (cnt <= maxSbCntInMsg)
646 sbCntInMsg = maxSbCntInMsg;
647 numChnkOfMsg = cnt / maxSbCntInMsg;
648 lastSbCntInMsg = cnt % maxSbCntInMsg;
654 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
656 while (retVal == RL_RET_CODE_OK)
659 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
661 inMsg.opcode.
nsbc = lastSbCntInMsg;
665 inMsg.opcode.
nsbc = sbCntInMsg;
668 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
674 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_SET_MSG,
675 RL_RF_CHIRP_CONF_SB);
679 inPayloadSb[indx].len = (rlUInt16_t)
sizeof(
rlChirpCfg_t);
683 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(data);
704 RL_LOGV_ARG0(
"rlSetChirpConfig ends...\n");
731 rlReturnVal_t retVal;
734 RL_LOGV_ARG0(
"rlGetChirpConfig starts...\n");
738 (RL_NULL_PTR == chirpCfgData))
741 retVal = RL_RET_CODE_INVALID_INPUT;
742 RL_LOGE_ARG0(
"rlGetChirpConfig, Invalid device map\n");
750 rlUInt16_t sbLen, maxSbCntOutMsg, sbCntOutMsg, numChnkOfMsg, lastSbCntOutMsg, loopCnt;
764 maxSbCntOutMsg = (RL_CMD_PL_LEN_MAX -(RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE)) /sbLen;
766 retVal = RL_RET_CODE_OK;
768 if ((chirpEndIdx - chirpStartIdx + 1U) <= maxSbCntOutMsg)
770 sbCntOutMsg = (chirpEndIdx - chirpStartIdx + 1U);
772 lastSbCntOutMsg = 0U;
776 sbCntOutMsg = maxSbCntOutMsg;
777 numChnkOfMsg = (chirpEndIdx - chirpStartIdx + 1U) / maxSbCntOutMsg;
778 lastSbCntOutMsg = (chirpEndIdx - chirpStartIdx + 1U) % maxSbCntOutMsg;
783 wordParam.halfWordTwo = chirpStartIdx;
786 loopCnt = numChnkOfMsg + 1U;
788 outMsg.opcode.
nsbc = 1U;
790 while (retVal == RL_RET_CODE_OK)
793 wordParam.halfWordOne = wordParam.halfWordTwo;
795 if ((loopCnt == 1U) && (lastSbCntOutMsg != 0U))
797 wordParam.halfWordTwo = wordParam.halfWordOne + (lastSbCntOutMsg - 1U);
801 wordParam.halfWordTwo = wordParam.halfWordOne + (sbCntOutMsg - 1U);
811 outPayloadSb.sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_GET_MSG,
812 RL_RF_CHIRP_CONF_SB);
814 outPayloadSb.pSblkData = (rlUInt8_t*)(chirpCfgData);
823 chirpCfgData += sbCntOutMsg;
827 wordParam.halfWordTwo++;
836 RL_LOGV_ARG0(
"rlGetChirpConfig ends...\n");
869 rlReturnVal_t retVal;
870 RL_LOGV_ARG0(
"rlSetMultiChirpCfg starts...\n");
877 retVal = RL_RET_CODE_INVALID_INPUT;
886 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
891 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
894 sbLen = (rlUInt16_t)(
sizeof(
rlChirpCfg_t) + (RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE));
900 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
902 retVal = RL_RET_CODE_OK;
904 if (cnt <= maxSbCntInMsg)
912 sbCntInMsg = maxSbCntInMsg;
913 numChnkOfMsg = cnt / maxSbCntInMsg;
914 lastSbCntInMsg = cnt % maxSbCntInMsg;
920 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
922 while (retVal == RL_RET_CODE_OK)
925 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
927 inMsg.opcode.
nsbc = lastSbCntInMsg;
931 inMsg.opcode.
nsbc = sbCntInMsg;
934 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
940 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_SET_MSG,
941 RL_RF_CHIRP_CONF_SB);
945 inPayloadSb[indx].len = (rlUInt16_t)
sizeof(
rlChirpCfg_t);
949 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(*data);
966 RL_LOGV_ARG0(
"rlSetMultiChirpCfg ends...\n");
1025 rlReturnVal_t retVal;
1027 RL_LOGV_ARG0(
"rlSetFrameConfig starts...\n");
1031 (RL_NULL_PTR == data))
1034 retVal = RL_RET_CODE_INVALID_INPUT;
1035 RL_LOGE_ARG0(
"rlSetFrameConfig, Invalid device map\n");
1041 RL_RF_FRAME_CONF_SB, (rlUInt8_t*)data,
1053 tempVar = (rlUInt32_t)(((data->chirpEndIdx - data->chirpStartIdx) + 1U) *
1055 #ifndef MMWL_BIG_ENDIAN 1058 frameApplyCfgArgs.
numChirps = RL_SWAP_32(tempVar);
1064 RL_LOGV_ARG0(
"rlSetFrameConfig ends...\n");
1086 rlReturnVal_t retVal;
1088 RL_LOGV_ARG0(
"rlGetFrameConfig starts...\n");
1092 (RL_NULL_PTR == data))
1095 retVal = RL_RET_CODE_INVALID_INPUT;
1096 RL_LOGE_ARG0(
"rlGetFrameConfig, Invalid device map\n");
1102 RL_RF_FRAME_CONF_SB, (rlUInt8_t*)data, 0U);
1120 &inPayloadSb, (rlUInt8_t*)RL_NULL_PTR, 0x0U);
1126 (rlUInt8_t*)&frameApplyCfgArgs, 0U);
1130 #ifndef MMWL_BIG_ENDIAN 1133 data->numAdcSamples = frameApplyCfgArgs.numAdcSamples;
1136 data->numAdcSamples = RL_SWAP_32(frameApplyCfgArgs.numAdcSamples);
1141 RL_LOGV_ARG0(
"rlGetFrameConfig ends...\n");
1198 rlReturnVal_t retVal;
1200 RL_LOGV_ARG0(
"rlSetAdvFrameConfig starts...\n");
1206 retVal = RL_RET_CODE_INVALID_INPUT;
1207 RL_LOGE_ARG0(
"rlSetAdvFrameConfig, Invalid device map\n");
1213 RL_RF_FRAME_CONF_ADVANCED_SB,
1224 RL_LOGV_ARG0(
"rlSetAdvFrameConfig ends...\n");
1246 rlReturnVal_t retVal;
1248 RL_LOGV_ARG0(
"rlGetAdvFrameConfig starts...\n");
1252 (RL_NULL_PTR == data))
1255 retVal = RL_RET_CODE_INVALID_INPUT;
1256 RL_LOGE_ARG0(
"rlGetAdvFrameConfig, Invalid device map\n");
1262 RL_RF_FRAME_CONF_ADVANCED_SB,
1263 (rlUInt8_t*)(&(data->
frameSeq)), 0U);
1280 RL_SYS_ADV_FRAME_CONFIG_GET_SB,
1281 &inPayloadSb, (rlUInt8_t*)RL_NULL_PTR, 0U);
1294 RL_LOGV_ARG0(
"rlGetAdvFrameConfig ends...\n");
1319 rlReturnVal_t retVal;
1321 RL_LOGV_ARG0(
"rlSetContModeConfig starts...\n");
1325 (RL_NULL_PTR == data))
1328 retVal = RL_RET_CODE_INVALID_INPUT;
1329 RL_LOGE_ARG0(
"rlSetContModeConfig, Invalid device map\n");
1335 RL_RF_CONT_STREAMING_MODE_CONF_SB,
1339 RL_LOGV_ARG0(
"rlSetContModeConfig ends...\n");
1359 rlReturnVal_t retVal;
1361 RL_LOGV_ARG0(
"rlEnableContMode starts...\n");
1365 (RL_NULL_PTR == data))
1368 retVal = RL_RET_CODE_INVALID_INPUT;
1369 RL_LOGE_ARG0(
"rlEnableContMode, Invalid device map\n");
1375 RL_RF_CONT_STREAMING_MODE_EN_SB,
1380 RL_LOGV_ARG0(
"rlEnableContMode starts...\n");
1406 rlReturnVal_t retVal;
1408 RL_LOGV_ARG0(
"rlSetLowPowerModeConfig starts...\n");
1414 retVal = RL_RET_CODE_INVALID_INPUT;
1415 RL_LOGE_ARG0(
"rlSetLowPowerModeConfig, Invalid device map\n");
1421 RL_RF_LOWPOWERMODE_CONF_SB,
1426 RL_LOGV_ARG0(
"rlSetLowPowerModeConfig ends...\n");
1451 rlReturnVal_t retVal;
1455 RL_LOGV_ARG0(
"rlSensorStart starts...\n");
1457 frameTriggerArgs.
startStop = RL_FRAME_TRIGGER_START;
1464 retVal = RL_RET_CODE_INVALID_INPUT;
1465 RL_LOGE_ARG0(
"rlSensorStart, Invalid device map\n");
1471 RL_RF_FRAMESTARTSTOP_CONF_SB,
1472 (rlUInt8_t*)(&frameTriggerArgs),
1475 RL_LOGV_ARG0(
"rlSensorStart ends...\n");
1505 rlReturnVal_t retVal;
1509 frameTriggerArgs.
startStop = RL_FRAME_TRIGGER_STOP;
1512 RL_LOGV_ARG0(
"rlSensorStop starts...\n");
1518 retVal = RL_RET_CODE_INVALID_INPUT;
1519 RL_LOGE_ARG0(
"rlSensorStop, Invalid device map\n");
1525 RL_RF_FRAMESTARTSTOP_CONF_SB,
1526 (rlUInt8_t*)(&frameTriggerArgs),
1529 RL_LOGV_ARG0(
"rlSensorStop ends...\n");
1565 rlReturnVal_t retVal;
1567 RL_LOGV_ARG0(
"rlFrameStartStop starts...\n");
1573 retVal = RL_RET_CODE_INVALID_INPUT;
1574 RL_LOGE_ARG0(
"rlFrameStartStop, Invalid device map\n");
1580 RL_RF_FRAMESTARTSTOP_CONF_SB,
1584 RL_LOGV_ARG0(
"rlFrameStartStop ends...\n");
1628 rlReturnVal_t retVal;
1630 RL_LOGV_ARG0(
"rlRfInit starts...\n");
1636 retVal = RL_RET_CODE_INVALID_INPUT;
1637 RL_LOGE_ARG0(
"rlRfInit, Invalid device map\n");
1644 RL_LOGV_ARG0(
"rlRfInit ends...\n");
1675 rlReturnVal_t retVal;
1677 RL_LOGV_ARG0(
"rlSetTestSourceConfig starts...\n");
1681 (RL_NULL_PTR == data))
1684 retVal = RL_RET_CODE_INVALID_INPUT;
1685 RL_LOGE_ARG0(
"rlSetTestSourceConfig, Invalid device map\n");
1691 RL_RF_TEST_SOURCE_CONFIG_SET_SB,
1695 RL_LOGV_ARG0(
"rlSetTestSourceConfig ends...\n");
1715 rlReturnVal_t retVal;
1717 RL_LOGV_ARG0(
"rlTestSourceEnable starts...\n");
1721 (RL_NULL_PTR == data))
1724 retVal = RL_RET_CODE_INVALID_INPUT;
1725 RL_LOGE_ARG0(
"rlTestSourceEnable, Invalid device map\n");
1731 RL_RF_TEST_SOURCE_ENABLE_SET_SB,
1735 RL_LOGV_ARG0(
"rlTestSourceEnable ends...\n");
1755 rlReturnVal_t retVal;
1757 RL_LOGV_ARG0(
"rlRfGetTemperatureReport starts...\n");
1761 (RL_NULL_PTR == data))
1764 retVal = RL_RET_CODE_INVALID_INPUT;
1765 RL_LOGE_ARG0(
"rlRfGetTemperatureReport, Invalid device map\n");
1771 RL_RF_CHAR_CONF_DYNAMIC_GET_SB,
1774 RL_LOGV_ARG0(
"rlRfGetTemperatureReport ends...\n");
1797 rlReturnVal_t retVal;
1799 RL_LOGV_ARG0(
"rlRfDfeRxdStatisticsReport starts...\n");
1803 (RL_NULL_PTR == data))
1806 retVal = RL_RET_CODE_INVALID_INPUT;
1807 RL_LOGE_ARG0(
"Invalid input\n");
1813 RL_RF_DFE_STATISTICS_REPORT_GET_SB,
1814 (rlUInt8_t*)data, 0U);
1816 RL_LOGV_ARG0(
"rlRfDfeRxdStatisticsReport completes...\n");
1846 rlReturnVal_t retVal;
1848 RL_LOGV_ARG0(
"rlRfDynamicPowerSave starts...\n");
1852 (RL_NULL_PTR == data))
1855 retVal = RL_RET_CODE_INVALID_INPUT;
1856 RL_LOGE_ARG0(
"Invalid input\n");
1862 RL_RF_DYNAMICPOWERSAVE_CONF_SB,
1866 RL_LOGV_ARG0(
"rlRfDynamicPowerSave completes...\n");
1896 rlReturnVal_t retVal;
1898 RL_LOGV_ARG0(
"rlRfSetDeviceCfg starts...\n");
1902 (RL_NULL_PTR == data))
1905 retVal = RL_RET_CODE_INVALID_INPUT;
1906 RL_LOGE_ARG0(
"Invalid input\n");
1912 RL_RF_DEVICE_CFG_SB,
1916 RL_LOGV_ARG0(
"rlRfSetDeviceCfg completes...\n");
1942 rlReturnVal_t retVal;
1944 RL_LOGV_ARG0(
"rlSetGpAdcConfig starts...\n");
1948 (RL_NULL_PTR == data))
1951 retVal = RL_RET_CODE_INVALID_INPUT;
1952 RL_LOGE_ARG0(
"Invalid input\n");
1958 RL_RF_GPADC_CONF_SET_SB,
1962 RL_LOGV_ARG0(
"rlSetGpAdcConfig completes...\n");
1987 rlReturnVal_t retVal;
1989 RL_LOGV_ARG0(
"rlRfSetLdoBypassConfig starts...\n");
1995 retVal = RL_RET_CODE_INVALID_INPUT;
2001 RL_RF_LDOBYPASS_SET_SB,
2006 RL_LOGV_ARG0(
"rlRfSetLdoBypassConfig completes...\n");
2039 rlReturnVal_t retVal;
2041 RL_LOGV_ARG0(
"rlRfSetPhaseShiftConfig starts...\n");
2045 (RL_NULL_PTR == data) || (cnt == 0U))
2048 retVal = RL_RET_CODE_INVALID_INPUT;
2056 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
2060 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
2068 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
2070 retVal = RL_RET_CODE_OK;
2072 if (cnt <= maxSbCntInMsg)
2076 lastSbCntInMsg = 0U;
2080 sbCntInMsg = maxSbCntInMsg;
2081 numChnkOfMsg = cnt / maxSbCntInMsg;
2082 lastSbCntInMsg = cnt % maxSbCntInMsg;
2088 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
2090 while (retVal == RL_RET_CODE_OK)
2093 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
2095 inMsg.opcode.
nsbc = lastSbCntInMsg;
2099 inMsg.opcode.
nsbc = sbCntInMsg;
2102 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
2108 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_SET_MSG,
2109 RL_RF_PERCHIRPPHASESHIFT_CONF_SB);
2117 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(data);
2138 RL_LOGV_ARG0(
"rlRfSetPhaseShiftConfig ends...\n");
2162 rlReturnVal_t retVal;
2164 RL_LOGV_ARG0(
"rlRfSetPALoopbackConfig starts...\n");
2170 retVal = RL_RET_CODE_INVALID_INPUT;
2176 RL_RF_PALOOPBACK_CFG_SET_SB,
2181 RL_LOGV_ARG0(
"rlRfSetPALoopbackConfig completes...\n");
2212 rlReturnVal_t retVal;
2214 RL_LOGV_ARG0(
"rlRfSetPSLoopbackConfig starts...\n");
2220 retVal = RL_RET_CODE_INVALID_INPUT;
2226 RL_RF_PSLOOPBACK_CFG_SET_SB,
2231 RL_LOGV_ARG0(
"rlRfSetPSLoopbackConfig completes...\n");
2255 rlReturnVal_t retVal;
2257 RL_LOGV_ARG0(
"rlRfSetIFLoopbackConfig starts...\n");
2263 retVal = RL_RET_CODE_INVALID_INPUT;
2269 RL_RF_IFLOOPBACK_CFG_SET_SB,
2274 RL_LOGV_ARG0(
"rlRfSetIFLoopbackConfig completes...\n");
2304 rlReturnVal_t retVal;
2306 RL_LOGV_ARG0(
"rlRfSetProgFiltCoeffRam starts...\n");
2312 retVal = RL_RET_CODE_INVALID_INPUT;
2318 RL_RF_PROG_FILT_COEFF_RAM_SET_SB,
2323 RL_LOGV_ARG0(
"rlRfSetProgFiltCoeffRam completes...\n");
2346 rlReturnVal_t retVal;
2348 RL_LOGV_ARG0(
"rlRfSetProgFiltConfig starts...\n");
2354 retVal = RL_RET_CODE_INVALID_INPUT;
2360 RL_RF_PROG_FILT_CONF_SET_SB,
2365 RL_LOGV_ARG0(
"rlRfSetProgFiltConfig completes...\n");
2389 rlReturnVal_t retVal;
2391 RL_LOGV_ARG0(
"rlRfSetMiscConfig starts...\n");
2397 retVal = RL_RET_CODE_INVALID_INPUT;
2403 RL_RF_RADAR_MISC_CTL_SB,
2408 RL_LOGV_ARG0(
"rlRfSetMiscConfig completes...\n");
2442 rlReturnVal_t retVal;
2444 RL_LOGV_ARG0(
"rlRfSetCalMonTimeUnitConfig starts...\n");
2450 retVal = RL_RET_CODE_INVALID_INPUT;
2456 RL_RF_CALIB_MON_TIME_UNIT_SB,
2461 RL_LOGV_ARG0(
"rlRfSetCalMonTimeUnitConfig completes...\n");
2495 rlReturnVal_t retVal;
2497 RL_LOGV_ARG0(
"rlRfSetCalMonFreqLimitConfig starts...\n");
2503 retVal = RL_RET_CODE_INVALID_INPUT;
2509 RL_RF_CAL_MON_FREQ_LIMIT_SB,
2514 RL_LOGV_ARG0(
"rlRfSetCalMonFreqLimitConfig completes...\n");
2542 rlReturnVal_t retVal;
2544 RL_LOGV_ARG0(
"rlRfInitCalibConfig starts...\n");
2550 retVal = RL_RET_CODE_INVALID_INPUT;
2556 RL_RF_INIT_CALIB_CONF_SB,
2561 RL_LOGV_ARG0(
"rlRfInitCalibConfig completes...\n");
2594 rlReturnVal_t retVal;
2596 RL_LOGV_ARG0(
"rlRfRunTimeCalibConfig starts...\n");
2602 retVal = RL_RET_CODE_INVALID_INPUT;
2608 RL_RF_RUN_TIME_CALIB_CONF_TRIG_SB,
2613 RL_LOGV_ARG0(
"rlRfRunTimeCalibConfig completes...\n");
2635 rlReturnVal_t retVal;
2641 retVal = RL_RET_CODE_INVALID_INPUT;
2647 RL_RF_RX_GAIN_TEMPLUT_CONF_SB, (rlUInt8_t*)data,
2672 rlReturnVal_t retVal;
2674 RL_LOGV_ARG0(
"rlRxGainTempLutRead starts...\n");
2678 (RL_NULL_PTR == inData))
2681 retVal = RL_RET_CODE_INVALID_INPUT;
2682 RL_LOGE_ARG0(
"rlRxGainTempLutRead, Invalid device map\n");
2696 &inPayloadSb, (rlUInt8_t *)inData,
2712 RL_LOGV_ARG0(
"rlRxGainTempLutRead ends...\n");
2733 rlReturnVal_t retVal;
2739 retVal = RL_RET_CODE_INVALID_INPUT;
2745 RL_RF_TX_GAIN_TEMPLUT_CONF_SB, (rlUInt8_t*)data,
2767 rlReturnVal_t rlTxGainTempLutGet(rlUInt8_t deviceMap,
2770 rlReturnVal_t retVal;
2772 RL_LOGV_ARG0(
"rlTxGainTempLutRead starts...\n");
2776 (RL_NULL_PTR == inData))
2779 retVal = RL_RET_CODE_INVALID_INPUT;
2780 RL_LOGE_ARG0(
"rlTxGainTempLutRead, Invalid device map\n");
2794 &inPayloadSb, (rlUInt8_t *)inData,
2810 RL_LOGV_ARG0(
"rlTxGainTempLutRead ends...\n");
2847 rlReturnVal_t retVal;
2851 (RL_NULL_PTR == data))
2854 retVal = RL_RET_CODE_INVALID_INPUT;
2860 RL_RF_TX_FREQ_PWR_LIMIT_SB,
2903 rlReturnVal_t retVal;
2909 retVal = RL_RET_CODE_INVALID_INPUT;
2915 RL_RF_LB_BURST_CFG_SET_SB, (rlUInt8_t*)data,
2944 rlReturnVal_t retVal;
2951 retVal = RL_RET_CODE_INVALID_INPUT;
2960 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
2965 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
2968 sbLen = (rlUInt16_t)(
sizeof(
rlDynChirpCfg_t) + (RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE));
2974 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
2976 retVal = RL_RET_CODE_OK;
2978 if (segCnt <= maxSbCntInMsg)
2980 sbCntInMsg = segCnt;
2982 lastSbCntInMsg = 0U;
2986 sbCntInMsg = maxSbCntInMsg;
2987 numChnkOfMsg = segCnt / maxSbCntInMsg;
2988 lastSbCntInMsg = segCnt % maxSbCntInMsg;
2994 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
2996 while (retVal == RL_RET_CODE_OK)
2999 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
3001 inMsg.opcode.
nsbc = lastSbCntInMsg;
3005 inMsg.opcode.
nsbc = sbCntInMsg;
3008 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
3014 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_SET_MSG,
3015 RL_RF_DYN_CHIRP_CFG_SET_SB);
3023 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(*data);
3067 rlReturnVal_t retVal;
3073 retVal = RL_RET_CODE_INVALID_INPUT;
3079 RL_RF_DYN_CHIRP_CFG_EN_SB, (rlUInt8_t*)data,
3117 rlReturnVal_t retVal;
3124 retVal = RL_RET_CODE_INVALID_INPUT;
3133 rlUInt16_t sbLen, maxSbCntInMsg, sbCntInMsg, numChnkOfMsg, lastSbCntInMsg, loopCnt, indx;
3137 RL_SBC_ID_SIZE + RL_SBC_LEN_SIZE)];
3141 (RL_SBC_LEN_SIZE + RL_SBC_ID_SIZE));
3146 maxSbCntInMsg = (RL_CMD_PL_LEN_MAX /sbLen);
3148 retVal = RL_RET_CODE_OK;
3150 if (segCnt <= maxSbCntInMsg)
3152 sbCntInMsg = segCnt;
3154 lastSbCntInMsg = 0U;
3158 sbCntInMsg = maxSbCntInMsg;
3159 numChnkOfMsg = segCnt / maxSbCntInMsg;
3160 lastSbCntInMsg = segCnt % maxSbCntInMsg;
3166 loopCnt = (lastSbCntInMsg == 0U) ? numChnkOfMsg : (numChnkOfMsg + 1U);
3168 while (retVal == RL_RET_CODE_OK)
3171 if ((loopCnt == 1U) && (lastSbCntInMsg != 0U))
3173 inMsg.opcode.
nsbc = lastSbCntInMsg;
3177 inMsg.opcode.
nsbc = sbCntInMsg;
3180 for (indx = 0U; indx < inMsg.opcode.
nsbc; indx++)
3186 inPayloadSb[indx].sbid = RL_GET_UNIQUE_SBID(RL_RF_DYNAMIC_CONF_SET_MSG,
3187 RL_RF_DYN_PERCHIRP_PHSHFT_CFG_SET_SB);
3195 inPayloadSb[indx].pSblkData = (rlUInt8_t*)(*data);
3244 rlReturnVal_t retVal;
3251 retVal = RL_RET_CODE_INVALID_INPUT;
3261 retVal = RL_RET_CODE_OK;
3263 for (idx = 0U; idx < RL_MAX_CALIB_DATA_CHUNK; idx++)
3275 (rlUInt8_t*)(&data->calibChunk[idx]),
3286 if (RL_RET_CODE_OK != retVal)
3326 rlReturnVal_t retVal;
3332 retVal = RL_RET_CODE_INVALID_INPUT;
3344 retVal = RL_RET_CODE_OK;
3346 for (idx = 0U; idx < RL_MAX_CALIB_DATA_CHUNK; idx++)
3368 if (RL_RET_CODE_OK != retVal)
3374 caldataGetCfg.chunkId++;
3409 rlReturnVal_t retVal;
3415 retVal = RL_RET_CODE_INVALID_INPUT;
3421 RL_RF_DIG_COMP_EST_CTRL_SB, (rlUInt8_t*)data,
3442 rlReturnVal_t retVal;
3445 if (data == RL_NULL_PTR)
3448 retVal = RL_RET_CODE_NULL_PTR;
3454 RL_RF_BOOTUP_BIST_STATUS_SB, (rlUInt8_t*)data, 0U);
3483 rlReturnVal_t retVal;
3489 retVal = RL_RET_CODE_INVALID_INPUT;
3495 RL_RF_INTERCHIRP_BLOCK_CTRL_SB, (rlUInt8_t*)data,
3535 rlReturnVal_t retVal;
3541 retVal = RL_RET_CODE_INVALID_INPUT;
3547 RL_RF_SUBFRAME_START_SB, (rlUInt8_t*)data,
3576 rlReturnVal_t retVal;
3583 retVal = RL_RET_CODE_INVALID_INPUT;
3593 retVal = RL_RET_CODE_OK;
3595 for (idx = 0U; idx < RL_TX_CNT; idx++)
3599 if (idx == (RL_TX_CNT - 1U))
3601 data->PhShiftcalibChunk[idx].
calibApply = 1U;
3605 data->PhShiftcalibChunk[idx].
calibApply = 0U;
3607 data->PhShiftcalibChunk[idx].
txIndex = idx;
3616 &inPayloadSb, (rlUInt8_t*)(&data->PhShiftcalibChunk[idx]),
3627 if (RL_RET_CODE_OK != retVal)
3662 rlReturnVal_t retVal;
3668 retVal = RL_RET_CODE_INVALID_INPUT;
3682 retVal = RL_RET_CODE_OK;
3684 for (idx = 0U; idx < RL_TX_CNT; idx++)
3686 if ((RL_NULL_PTR != &data->PhShiftcalibChunk[idx]))
3688 phShifterCaldataGetCfg.
txIndex = idx;
3693 &inPayloadSb, (rlUInt8_t*)&phShifterCaldataGetCfg,
3706 (rlUInt8_t*)(&data->PhShiftcalibChunk[idx]), 0U);
3711 if (RL_RET_CODE_OK != retVal)
3737 rlReturnVal_t retVal;
3740 if (data == RL_NULL_PTR)
3743 retVal = RL_RET_CODE_NULL_PTR;
3749 RL_RF_DIEID_STATUS_SB, (rlUInt8_t*)data, 0U);
3770 rlReturnVal_t retVal;
3772 RL_LOGV_ARG0(
"rlRfGetCpuFault starts...\n");
3776 (RL_NULL_PTR == data))
3779 retVal = RL_RET_CODE_INVALID_INPUT;
3780 RL_LOGE_ARG0(
"Invalid input");
3786 RL_RF_RFCPUFAULT_STATUS_SB, (rlUInt8_t*)data,
3789 RL_LOGV_ARG0(
"rlRfGetCpuFault ends...\n");
3809 rlReturnVal_t retVal;
3811 RL_LOGV_ARG0(
"rlRfGetEsmFault starts...\n");
3815 (RL_NULL_PTR == data))
3818 retVal = RL_RET_CODE_INVALID_INPUT;
3819 RL_LOGE_ARG0(
"Invalid input");
3825 RL_RF_RFESMFAULT_STATUS_SB, (rlUInt8_t*)data,
3828 RL_LOGV_ARG0(
"rlRfGetEsmFault ends...\n");
3916 rlReturnVal_t retVal;
3918 RL_LOGV_ARG0(
"rlSetAdvChirpConfig starts...\n");
3924 retVal = RL_RET_CODE_INVALID_INPUT;
3925 RL_LOGE_ARG0(
"rlSetAdvChirpConfig, Invalid device map\n");
3931 RL_RF_ADV_CHIRP_CFG_SET_SB,
3936 RL_LOGV_ARG0(
"rlSetAdvChirpConfig ends...\n");
3987 rlReturnVal_t retVal;
3989 RL_LOGV_ARG0(
"rlMonTypeTrigConfig starts...\n");
3995 retVal = RL_RET_CODE_INVALID_INPUT;
3996 RL_LOGE_ARG0(
"rlMonTypeTrigConfig, Invalid device map\n");
4002 RL_RF_MONITOR_TYPE_TRIG_CONF_SB,
4007 RL_LOGV_ARG0(
"rlMonTypeTrigConfig ends...\n");
4032 rlReturnVal_t retVal;
4036 (RL_NULL_PTR == data))
4039 retVal = RL_RET_CODE_INVALID_INPUT;
4045 RL_RF_APLL_SYNTH_BW_CTL_SB,
4086 rlReturnVal_t retVal;
4088 RL_LOGV_ARG0(
"rlSetAdvChirpLUTConfig starts...\n");
4094 retVal = RL_RET_CODE_INVALID_INPUT;
4095 RL_LOGE_ARG0(
"rlSetAdvChirpLUTConfig, Invalid device map\n");
4101 RL_RF_ADV_CHIRP_CFG_LUT_SET_SB,
4106 RL_LOGV_ARG0(
"rlSetAdvChirpLUTConfig ends...\n");
4136 rlInt8_t* AdvChirpLUTData)
4138 rlReturnVal_t retVal = RL_RET_CODE_OK;
4142 rlUInt16_t chunkCount = 0U, totalChunkCount, lastChunkSize;
4144 RL_LOGV_ARG0(
"rlSetMultiAdvChirpLUTConfig starts...\n");
4148 (RL_NULL_PTR == AdvChirpLUTCfgArgs) || (RL_NULL_PTR == AdvChirpLUTData))
4151 retVal += RL_RET_CODE_INVALID_INPUT;
4152 RL_LOGE_ARG0(
"rlSetMultiAdvChirpLUTConfig, Invalid input params\n");
4156 RL_LOGV_ARG2(
"rlSetMultiAdvChirpLUTConfig with \nlutAddOffset[%d]\nnumBytes[%d] \n\n",\
4161 if (AdvChirpLUTCfgArgs->
numBytes > RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE)
4164 if ((AdvChirpLUTCfgArgs->
numBytes % RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE) == 0U)
4166 lastChunkSize = RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE;
4168 (rlUInt16_t)(AdvChirpLUTCfgArgs->
numBytes / RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE);
4174 (rlUInt16_t)((AdvChirpLUTCfgArgs->
numBytes/RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE) + 1U);
4176 (rlUInt16_t)(AdvChirpLUTCfgArgs->
numBytes % RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE);
4183 totalChunkCount = 1U;
4185 lastChunkSize = AdvChirpLUTCfgArgs->
numBytes;
4188 while (chunkCount < totalChunkCount)
4190 RL_LOGV_ARG1(
"Sending Advanced Chirp LUT data Chunk [%d]... \n\n", chunkCount);
4194 (chunkCount * RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE));
4197 if (chunkCount == (totalChunkCount - 1U))
4199 AdvChirpLUTCfgChunk.
numBytes = lastChunkSize;
4204 AdvChirpLUTCfgChunk.
numBytes = RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE;
4207 if (AdvChirpLUTCfgChunk.
numBytes > 0U)
4212 (void)memcpy(&AdvChirpLUTCfgChunk.
calData[0U], \
4213 &AdvChirpLUTData[chunkCount * RL_MAX_ADV_CHIRP_LUT_CHUNK_SIZE], \
4216 RL_LOGV_ARG2(
"rlSetAdvChirpLUTConfig with \nlutAddOffset[%d]\nnumBytes[%d] \n\n",\
4221 if (retVal != RL_RET_CODE_OK)
4223 RL_LOGV_ARG2(
"Advanced Chirp LUT data Chunk [%d] failed with error code %d",\
4224 chunkCount, retVal);
4231 retVal += RL_RET_CODE_INVALID_INPUT;
4232 RL_LOGV_ARG2(
"Invalid input, Chirp LUT Chunk [%d] is programmed with %d bytes",\
4233 chunkCount, AdvChirpLUTCfgChunk.
numBytes);
4240 RL_LOGV_ARG0(
"rlSetMultiAdvChirpLUTConfig ends...\n");
4267 rlReturnVal_t retVal;
4269 RL_LOGV_ARG0(
"rlSetAdvChirpDynLUTAddrOffConfig starts...\n");
4275 retVal = RL_RET_CODE_INVALID_INPUT;
4276 RL_LOGE_ARG0(
"rlSetAdvChirpDynLUTAddrOffConfig, Invalid device map\n");
4282 RL_RF_ADV_CHIRP_DYN_LUT_ADD_OFF_CONF_SB,
4287 RL_LOGV_ARG0(
"rlSetAdvChirpDynLUTAddrOffConfig ends...\n");
4314 rlReturnVal_t retVal;
4316 RL_LOGV_ARG0(
"rlSetPowerSaveModeConfig starts...\n");
4320 (RL_NULL_PTR == data))
4323 retVal = RL_RET_CODE_INVALID_INPUT;
4324 RL_LOGE_ARG0(
"rlSetPowerSaveModeConfig, Invalid device map\n");
4330 RL_RF_POWER_SAVE_MODE_CONF_SB, (rlUInt8_t*)data,
4334 RL_LOGV_ARG0(
"rlSetPowerSaveModeConfig 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.
rlReturnVal_t rlSetPowerSaveModeConfig(rlUInt8_t deviceMap, rlPowerSaveModeCfg_t *data)
Sets the power save mode Configuration.
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.
Power saving mode 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/AWR2243/xWR6243 devices.
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.